package cache

import (
	"encoding/json"
	"fmt"
	"strings"

	. "app.yhyue.com/moapp/jybase/common"
	. "app.yhyue.com/moapp/jybase/encrypt"
	"app.yhyue.com/moapp/jybase/redis"
)

const (
	threeDay            = 172800
	oneDay              = 86400
	AllSubPushCacheSize = 200
)

type SubPushList struct {
	Id              string        `json:"_id"`
	Title           string        `json:"title"`
	Area            string        `json:"area"`
	BuyerClass      string        `json:"buyerClass"`
	Subtype         string        `json:"subtype"`
	Industry        string        `json:"industry"`
	PublishTime     int64         `json:"publishTime"`
	Ca_index        int64         `json:"ca_index"`
	Ca_date         int64         `json:"ca_date"`
	Ca_isvisit      int           `json:"ca_isvisit"`
	Ca_isvip        int           `json:"ca_isvip"`
	Ca_type         int           `json:"ca_type"`
	Ca_fileExists   bool          `json:"ca_fileExists"`
	MatchKeys       []string      `json:"matchKeys"`
	Budget          interface{}   `json:"budget"`
	BidAmount       interface{}   `json:"bidAmount"`
	Collection      int           `json:"collection"`
	Buyer           string        `json:"buyer"`
	ProjectName     string        `json:"projectName"`
	Winner          string        `json:"winner"`
	BidOpenTime     int64         `json:"bidOpenTime"`
	Source          int64         `json:"source"`
	WinnerInfo      []*WinnerInfo `json:"winnerInfo"`
	Site            string        `json:"site"`
	BuyerTel        string        `json:"buyerTel"`
	BuyerPerson     string        `json:"buyerPerson"`
	Agency          string        `json:"agency"`
	AgencyPerson    string        `json:"agencyPerson"`
	AgencyTel       string        `json:"agencyTel"`
	SignendTime     int64         `json:"signendTime"`
	BidendTime      int64         `json:"bidendTime"`
	Filetext_search bool          `json:"filetext_search"`
}

//
type WinnerInfo struct {
	Winner       string `json:"winner"`
	WinnerTel    string `json:"winnerTel"`
	WinnerPerson string `json:"winnerPerson"`
	WinnerId     string `json:"winnerId"`
}

type SubPush struct {
	Date  string
	Datas []*SubPushList
	Count int64
}

type PushCa struct {
	Date            int64
	InfoId          string
	Visit           int
	Keys            []string
	Type            int
	Isvip           int
	FileExists      bool
	Source          int64
	Info            *map[string]interface{}
	Filetext_search bool
}

type Cache struct {
	Prefix string
	UserId string
	Ymd    string
}

func NewEntnicheCache(userId, ymd string) *Cache {
	return &Cache{
		Prefix: "entnichepush",
		UserId: userId,
		Ymd:    ymd,
	}
}

func NewSubscribeCache(userId, ymd string) *Cache {
	return &Cache{
		Prefix: "subpush",
		UserId: userId,
		Ymd:    ymd,
	}
}

func NewMemberCache(userId, ymd string) *Cache {
	return &Cache{
		Prefix: "memberpush",
		UserId: userId,
		Ymd:    ymd,
	}
}

//
func NewSubPushList(pushCas []*PushCa) []*SubPushList {
	subPushList := []*SubPushList{}
	for _, p := range pushCas {
		info := p.Info
		area := ObjToString((*info)["area"])
		if area == "A" {
			area = "全国"
		}
		industry := ObjToString((*info)["s_subscopeclass"])
		scs := strings.Split(industry, ",")
		if len(scs) > 0 {
			industry = scs[0]
			if industry != "" {
				iss := strings.Split(industry, "_")
				if len(iss) > 0 {
					industry = iss[0]
				}
			}
		}
		infotype := ObjToString((*info)["subtype"])
		if infotype == "" {
			infotype = ObjToString((*info)["toptype"])
		}
		_id := p.InfoId
		if _id == "" {
			_id = ObjToString((*info)["_id"])
		}
		winner := ObjToString((*info)["s_winner"])
		winnerInfo := []*WinnerInfo{}
		if winner != "" && len(strings.Split(winner, ",")) > 0 {
			for wk, wv := range strings.Split(winner, ",") {
				var winnerId = ""
				eil, _ := (*info)["entidlist"].([]interface{})
				if entIdList := ObjArrToStringArr(eil); len(entIdList) > wk { //中标企业id集合
					winnerId = entIdList[wk]
				}
				winnerInfo = append(winnerInfo, &WinnerInfo{
					Winner:       wv,                                                                                               //中标企业 需要单独处理
					WinnerTel:    ObjToString((*info)["winnertel"]),                                                                //中标企业联系电话
					WinnerPerson: ObjToString((*info)["winnerperson"]),                                                             //中标企业联系人
					WinnerId:     If(winnerId != "" && len([]rune(winnerId)) > 12, EncodeArticleId2ByCheck(winnerId), "").(string), //中标企业加密id  存在winnerId 异常的情况
				})
			}
		}
		subPushList = append(subPushList, &SubPushList{
			Id:              EncodeArticleId2ByCheck(_id),
			Title:           ObjToString((*info)["title"]),
			Area:            area,
			BuyerClass:      ObjToString((*info)["buyerclass"]),
			Subtype:         infotype,
			Industry:        industry,
			PublishTime:     Int64All((*info)["publishtime"]),
			Ca_date:         p.Date,
			Ca_isvisit:      p.Visit,
			Ca_isvip:        p.Isvip,
			Ca_type:         p.Type,
			Ca_fileExists:   p.FileExists,
			MatchKeys:       p.Keys,
			Budget:          (*info)["budget"],
			BidAmount:       (*info)["bidamount"],
			Buyer:           ObjToString((*info)["buyer"]),
			ProjectName:     ObjToString((*info)["projectname"]),
			Winner:          winner,
			BidOpenTime:     Int64All((*info)["bidopentime"]),
			Source:          p.Source,
			Site:            ObjToString((*info)["site"]),
			BuyerTel:        ObjToString((*info)["buyerTel"]),
			BuyerPerson:     ObjToString((*info)["buyerPerson"]),
			Agency:          ObjToString((*info)["agency"]),
			AgencyPerson:    ObjToString((*info)["agencyPerson"]),
			AgencyTel:       ObjToString((*info)["agencyTel"]),
			SignendTime:     Int64All((*info)["signendTime"]),
			BidendTime:      Int64All((*info)["bidendTime"]),
			WinnerInfo:      winnerInfo,
			Filetext_search: p.Filetext_search,
		})
	}
	return subPushList
}

//从pushcache_2_b中取
func (c *Cache) GetTodayCache(userId string) (*SubPush, error) {
	pc_a, err := redis.GetNewBytes("pushcache_2_b", c.todayKey(userId))
	if err != nil {
		return nil, err
	}
	if pc_a == nil {
		return nil, nil
	}
	var p *SubPush
	if err := json.Unmarshal(*pc_a, &p); err != nil {
		return nil, err
	}
	return p, nil
}

//往pushcache_2_b中放
func (c *Cache) PutTodayCache(userId string, pc_a *SubPush) {
	redis.Put("pushcache_2_b", c.todayKey(userId), pc_a, oneDay)
}

//获取redis key
func (c *Cache) todayKey(userId string) string {
	return fmt.Sprintf("%s_%s", c.Prefix, userId)
}
func (c *Cache) allKey(userId string) string {
	return fmt.Sprintf("all_%s_%s", c.Prefix, userId)
}

//查看全部列表缓存
func (c *Cache) PutAllCache(userId string, datas *SubPush) {
	redis.Put("pushcache_2_a", c.allKey(userId), datas, oneDay)
}

func (c *Cache) GetAllCache(userId string) (*SubPush, error) {
	return c.GetCache("pushcache_2_a", c.allKey(userId))
}

func (c *Cache) GetCache(code, key string) (*SubPush, error) {
	pc_a, err := redis.GetNewBytes(code, key)
	if err != nil {
		return nil, err
	}
	if pc_a == nil {
		return nil, nil
	}
	var p *SubPush
	if err := json.Unmarshal(*pc_a, &p); err != nil {
		return nil, err
	}
	return p, nil
}

func (c *Cache) DoCache(subPushList []*SubPushList) {
	subPush_datas := []*SubPushList{}
	for i := len(subPushList) - 1; i >= 0; i-- {
		subPush_datas = append(subPush_datas, subPushList[i])
	}
	//更新redis
	subPush, err := c.GetTodayCache(c.UserId)
	if err == nil && subPush != nil && len(subPush.Datas) > 0 {
		if subPush.Date != c.Ymd {
			subPush = &SubPush{
				Date:  c.Ymd,
				Datas: subPush_datas,
				Count: int64(len(subPush_datas)),
			}
		} else {
			subPush.Datas = append(subPush_datas, subPush.Datas...)
			subPush.Count = subPush.Count + int64(len(subPush_datas))
		}
		c.PutTodayCache(c.UserId, subPush)
	}
	//全部列表缓存
	allCache, err := c.GetAllCache(c.UserId)
	if err == nil && allCache != nil && len(allCache.Datas) > 0 {
		allCache.Datas = append(subPush_datas, allCache.Datas...)
		if len(allCache.Datas) > AllSubPushCacheSize {
			allCache.Datas = allCache.Datas[:AllSubPushCacheSize]
		}
		allCache.Count = allCache.Count + int64(len(subPush_datas))
		c.PutAllCache(c.UserId, allCache)
	}
}