package advance_config_ser

import (
	"91porn-server/app/appg"
	"91porn-server/common"
	"91porn-server/common/constant/redisconst"
	"91porn-server/common/log"
	"91porn-server/models/commod"
	"91porn-server/models/v/advanceconfigmod"
	"91porn-server/models/v/prdcthsomod"
	"91porn-server/models/v/productmod"
	"fmt"
	"github.com/vmihailenco/msgpack/v5"
	"go.mongodb.org/mongo-driver/bson"
	"go.mongodb.org/mongo-driver/mongo/options"
	"sync"
	"time"
)

func GainAdvanceConfig(uid uint64) (data advanceconfigmod.AppAdvanceRes, err error) {
	var resp advanceconfigmod.AppAdvanceRes

	str, err := appg.Redis.Get(redisconst.GameAdvanceKey(uid))
	if err != nil {
		log.Warn(fmt.Sprintf("uid:%v;缓存获取游戏预售列表信息异常:%v", uid, err))
	}
	if str != nil {
		if err = msgpack.Unmarshal([]byte(*str), &resp); err == nil {
			return resp, nil
		}
		log.Warn(fmt.Sprintf("uid:%v;解析游戏预售缓存数据异常:%v", uid, err))
	}

	wg := sync.WaitGroup{}
	wg.Add(2)
	common.Go(func() {
		defer wg.Done()
		filter := bson.M{"isDelete": false, "status": 1}
		op := options.Find().SetSort(bson.M{"sortCode": -1})
		list, err := advanceconfigmod.QueryAllDocument(filter, op)
		if err != nil {
			log.Error(fmt.Sprintf("uid:%v, advanceconfigmod QueryAllDocument err:%v", uid, err))
			return
		}

		for _, a := range list {
			ad := advanceconfigmod.AppAdvanceConfig{
				Type:      a.Type,
				Cover:     a.Cover,
				Url:       a.Url,
				Name:      a.Name,
				SourceURL: a.SourceURL,
			}
			resp.List = append(resp.List, &ad)
		}
	})
	common.Go(func() {
		defer wg.Done()

		products, err := productmod.FindByProductType(commod.GameAdvanceCard)
		if err != nil {
			log.Error(fmt.Sprintf("uid:%v, productmod FindByProductType err:%v", uid, err))
			return
		}

		var gameCards []*advanceconfigmod.ProductCard
		if products != nil && len(products) > 0 {
			resp.ActivityDetail.ActivityTime = products[0].ActivityTime
			resp.ActivityDetail.StartTime = products[0].StartTime
			resp.ActivityDetail.EndTime = products[0].EndTime
			for _, p := range products {
				var privilege []advanceconfigmod.PrivilegeInfo
				if len(p.NewPrivilege) > 0 {
					for _, np := range p.NewPrivilege {
						privilege = append(privilege, advanceconfigmod.PrivilegeInfo{
							Name:  np.Name,
							Image: np.Image,
							Desc:  np.Desc,
						})
					}
				}

				gc := &advanceconfigmod.ProductCard{
					ID:                 p.ID,
					Type:               p.Type,
					Name:               p.Name,
					Position:           p.Position,
					BGImg:              p.BGImg,
					SendGame:           p.SendGame,
					OriginalPrice:      p.OriginalPrice,
					DiscountedPrice:    *p.DiscountedPriceIos,
					DiscountedPriceIos: *p.DiscountedPriceIos,
					DiscountedPriceAnd: *p.DiscountedPriceAnd,
					Desc:               p.Desc,
					NewPrivilege:       privilege,
				}
				gameCards = append(gameCards, gc)
			}
		}

		// 获取用户购买记录
		histories, err := prdcthsomod.FindUserProductHistoryByType(uid)
		if err != nil {
			log.Error(fmt.Sprintf("uid:%v, prdcthsomod FindUserProductHistoryByType err:%v", uid, err))
			return
		}

		if len(histories) > 0 {
			resp.ActivityDetail.Status = 1
			if len(gameCards) > 0 {
				for _, g := range gameCards {
					for _, h := range histories {
						if g.ID.Hex() == h.ProductID.Hex() {
							g.IsPay = true
							g.GameCode = append(g.GameCode, h.GameCode)
						}
					}
				}
			}
		}

		resp.CardList = gameCards

	})
	wg.Wait()

	common.Go(func() {
		bytes, _ := msgpack.Marshal(resp)
		if err = appg.Redis.Set(redisconst.GameAdvanceKey(uid), bytes, 2*time.Minute); err != nil {
			log.Warn(fmt.Sprintf("uid:%v;保存游戏预售缓存数据异常:%v", uid, err))
		}
	})
	return resp, nil
}