package mall

import (
	"joybuywork/internal/repository/model"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/service/provider/malls"
	"joybuywork/internal/service/provider/stocks"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_mall"
)

type ItemList struct {
	logic.Logic

	Req *pb.ItemListReq
	Res *pb.ItemListRes
}

func (s *ItemList) Run() (err error) {
	return logic.Run(s)
}

func (s *ItemList) Exec() (err error) {
	return s.list()
}

func (s *ItemList) list() (err error) {
	mall, err := malls.NewMall(s.Ctx, s.Req.GetMallId())
	if err != nil {
		return
	}

	var list []*model.RedeemMallItem
	switch s.Req.GetStatus() {
	case 1:
		list, err = mall.UpItems()
		if err != nil {
			return
		}
	case 2:
		list, err = mall.DownItems()
		if err != nil {
			return
		}
	}

	var rewardMap = make(map[int64]struct{})
	var rewardIds []int64
	var ids []int64
	for _, v := range list {
		if v.UseStock == -1 {
			ids = append(ids, v.ID)
		}

		if _, ok := rewardMap[v.RewardID]; !ok {
			rewardMap[v.RewardID] = struct{}{}
			rewardIds = append(rewardIds, v.RewardID)
		}
	}

	useStockMap, err := s._useStock(ids)
	if err != nil {
		return
	}

	preward, err := provider.NewRewards(s.Ctx, mall.GetMall().ProjectID, rewardIds...)
	if err != nil {
		return
	}

	s.Res.List = make([]*pb.ItemListRes_One, 0, len(list))

	for _, v := range list {
		info, _ := preward.InfoAutoLang(v.RewardID)
		s.Res.List = append(s.Res.List, &pb.ItemListRes_One{
			Id:         v.ID,
			RewardId:   v.RewardID,
			Title:      info.RewardTitle,
			ImgUrl:     info.ImgUrl,
			Stock:      v.Stock,
			Remain:     utils.Ternary[int64](v.UseStock == -1, v.Stock-useStockMap[v.ID], v.Stock-v.UseStock),
			UpType:     int32(v.UpType),
			UpCustom:   v.UpCustom,
			UpAt:       v.UpAt,
			UpFrom:     v.UpFrom,
			UpShow:     v.GetUpShow(),
			DownType:   int32(v.DownType),
			DownCustom: v.DownCustom,
			DownAt:     v.DownAt,
			DownFrom:   v.DownFrom,
			DownShow:   v.GetDownShow(),
			Status:     v.GetStatus(),
			CoinNum:    v.CoinNum,
			UseStock:   utils.Ternary[int64](v.UseStock == -1, useStockMap[v.ID], v.UseStock),
		})
	}

	return
}

func (s *ItemList) _useStock(ids []int64) (data map[int64]int64, err error) {
	data = make(map[int64]int64)
	if len(ids) == 0 {
		return
	}

	stock, err := stocks.NewMallItem(s.Ctx, ids...)
	if err != nil {
		return
	}

	data, err = stock.AllUseStock()
	if err != nil {
		return
	}

	return
}