package containers

import (
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_reward"
	"strings"

	"gorm.io/gen"
)

type Num struct {
	RewardId int64
	Num      int64
}

type RewardList struct {
	logic.Logic

	Req *pb.ListReq
	Res *pb.ListRes
}

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

func (s *RewardList) Exec() (err error) {
	project, err := finder.Project(s.Ctx, s.Req.GetProjectHashId())
	if err != nil {
		return
	}

	if project == nil {
		return
	}

	m := s.GetDao().Reward

	var cond = []gen.Condition{
		m.ProjectID.Eq(project.ID),
		m.IsDel.Eq(mtype.No),
	}

	query := m.WithContext(s.Ctx)

	if s.Req.GetRewardTitle() != "" {
		cond = append(cond, m.RewardTitle.Like(utils.DbAllLike(s.Req.GetRewardTitle())))
	}

	if s.Req.GetLangMark() != "" || s.Req.GetTitle() != "" {
		rewardM := s.GetDao().RewardLang
		query = query.Join(rewardM, rewardM.RewardID.EqCol(m.ID)).Group(m.ID)

		if s.Req.GetLangMark() != "" {
			lms := strings.Split(s.Req.GetLangMark(), ",")
			cond = append(cond, rewardM.Mark.In(lms...))
		}

		if s.Req.GetTitle() != "" {
			cond = append(cond, rewardM.Title.Like(utils.DbAllLike(s.Req.GetTitle())))
		}
	}

	switch s.Req.GetOrderType() {
	case 1:
		query = query.Order(m.CreatedAt)
	default:
		query = query.Order(m.ID.Desc())
	}

	offset, limit := utils.PpDbLo(s.Req.GetPage(), s.Req.GetPerPage())
	list, total, err := query.Where(cond...).FindByPage(offset, limit)
	if err != nil {
		return s.BE().MysqlError(err)
	}

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

	if total == 0 {
		return
	}

	var ids []int64
	for _, v := range list {
		ids = append(ids, v.ID)
	}

	relateNum, err := s._relatedNum(ids)
	if err != nil {
		return
	}

	titleAndImg, langMap, err := s._rewardLangs(ids)
	if err != nil {
		return
	}

	for _, v := range list {
		one := &pb.ListRes_One{
			Id:           v.ID,
			RewardTitle:  v.RewardTitle,
			Title:        "",
			ImgUrl:       "",
			ReceiveType:  int32(v.ReceiveType),
			RelatedNum:   relateNum[v.ID],
			KvData:       nil,
			Langs:        make([]*pb.ListRes_Lang, 0, len(langMap[v.ID])),
			DyRewardType: int32(v.DyRewardType),
			CreatedAt:    v.CreatedAt,
			Contact:      v.Contact,
			UrlId:        v.URLID,
		}

		if info, ok := titleAndImg[v.ID]; ok {
			one.Title = info.Title
			one.ImgUrl = info.ImgURL
		}

		_ = jsonm.StrUnmarshal(v.KvData, &one.KvData)

		for _, lang := range langMap[v.ID] {
			one.Langs = append(one.Langs, &pb.ListRes_Lang{
				Mark:      lang.Mark,
				Title:     lang.Title,
				ImgUrl:    lang.ImgURL,
				IsDefault: int32(lang.IsDefault),
				LangType:  int32(mtype.MarkToLangType[lang.Mark]),
				ImgId:     lang.ImageID,
			})
		}

		s.Res.List = append(s.Res.List, one)
	}

	return
}

func (s *RewardList) _relatedNum(ids []int64) (data map[int64]int64, err error) {
	data = make(map[int64]int64)

	m := s.GetDao().RewardRelated

	var num []*Num
	err = m.WithContext(s.Ctx).
		Select(m.RewardID, m.ID.Count().As("num")).
		Where(m.RewardID.In(ids...), m.CancelTime.Eq(0)).
		Group(m.RewardID).
		Scan(&num)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}
	for _, v := range num {
		data[v.RewardId] = v.Num
	}

	return
}

func (s *RewardList) _rewardLangs(ids []int64) (data map[int64]*model.RewardLang, rlMap map[int64][]*model.RewardLang, err error) {

	m := s.GetDao().RewardLang
	list, err := m.WithContext(s.Ctx).Where(m.RewardID.In(ids...), m.IsDel.Eq(mtype.No)).Order(m.ID).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	rlMap = make(map[int64][]*model.RewardLang)
	for _, v := range list {
		rlMap[v.RewardID] = append(rlMap[v.RewardID], v)
	}

	data = make(map[int64]*model.RewardLang)

	var idMap = make(map[int64]struct{})
	for _, id := range ids {
		idMap[id] = struct{}{}
	}

	// 找筛选的第一种语言
	if s.Req.GetLangMark() != "" {
		lm := strings.Split(s.Req.GetLangMark(), ",")[0]
		for _, v := range list {
			if v.Mark == lm {
				data[v.RewardID] = v
				if _, ok := idMap[v.RewardID]; ok {
					delete(idMap, v.RewardID)
				}
			}
		}
	}

	// 找页面的语言
	var plmIds []int64
	for id := range idMap {
		plmIds = append(plmIds, id)
	}

	if len(plmIds) == 0 {
		return
	}

	for _, v := range list {
		if v.Mark == s.Req.GetPageLang() {
			data[v.RewardID] = v
			if _, ok := idMap[v.RewardID]; ok {
				delete(idMap, v.RewardID)
			}
		}

	}

	// 找默认语言
	var dfIds []int64
	for id := range idMap {
		dfIds = append(dfIds, id)
	}

	if len(dfIds) == 0 {
		return
	}

	for _, v := range list {
		if _, ok := data[v.RewardID]; !ok && v.IsDefault == mtype.Yes {
			data[v.RewardID] = v
		}
	}

	return
}