package mall

import (
	"joybuywork/internal/app"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/utils"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_mall"
	"joybuywork/proto/go_proto/workerr"
	"time"

	t_center_statpb "gits.branchcn.com/backend/taskcenter/proto/go_proto/t_center_stat"
	"gorm.io/gen"
	"gorm.io/gen/field"
)

type List struct {
	logic.Logic

	Req *pb.ListReq
	Res *pb.ListRes
}

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

func (s *List) Exec() (err error) {
	project, err := s.project()
	if err != nil {
		return
	}

	return s.list(project)
}

func (s *List) project() (project *model.Project, err error) {
	project, err = finder.Project(s.Ctx, s.Req.GetProjectHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if project == nil {
		err = workerr.NotFound("project not found")
		return
	}

	return
}

func (s *List) list(project *model.Project) (err error) {
	m := s.GetDao().RedeemMall

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

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

	if s.Req.GetStatus() != 0 {
		cond = append(cond, m.Status.Eq(int8(s.Req.GetStatus())))
	}

	var orderBy []field.Expr
	if len(s.Req.GetOrderBy()) == 0 {
		// 排序字段(1-创建最晚优先，2-创建最早优先，3-使用中优先，4-暂未使用优先)
		for _, v := range s.Req.GetOrderBy() {

			switch v {
			case 1:
				orderBy = append(orderBy, m.CreatedAt.Desc())
			case 2:
				orderBy = append(orderBy, m.CreatedAt)
			case 3:
				orderBy = append(orderBy, m.Status)
			case 4:
				orderBy = append(orderBy, m.Status.Desc())
			}
		}
	}

	offset, limit := utils.PpDbLo(s.Req.GetPage(), s.Req.GetPerPage())
	list, total, err := m.WithContext(s.Ctx).Where(cond...).Order(orderBy...).Order(m.ID.Desc()).FindByPage(offset, limit)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if total == 0 {
		return
	}

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

	relateMap, err := s._relate(ids)
	if err != nil {
		return
	}

	rewardMap, err := s._reward(project.ID, ids)
	if err != nil {
		return
	}

	s.Res.Total = total
	s.Res.List = make([]*pb.ListRes_One, 0, len(list))
	for _, v := range list {
		one := &pb.ListRes_One{
			Id:        v.ID,
			Title:     v.Title,
			Status:    int32(v.Status),
			CreatedAt: v.CreatedAt,
			Rewards:   rewardMap[v.ID],
			Relates:   relateMap[v.ID],
		}

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

	return
}

func (s *List) _reward(projectId int64, ids []int64) (data map[int64][]*pb.ListRes_Reward, err error) {
	data = make(map[int64][]*pb.ListRes_Reward, len(ids))
	if len(ids) == 0 {
		return
	}

	m := s.GetDao().RedeemMallItem
	list, err := m.WithContext(s.Ctx).Where(
		m.MallID.In(ids...),
		m.DownAt.Eq(mtype.No),
		m.IsDel.Eq(mtype.No),
		m.UpAt.Lte(time.Now().Unix()),
	).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var rewardMap = make(map[int64]string)
	var rewardIds []int64
	for _, v := range list {
		if _, ok := rewardMap[v.RewardID]; !ok {
			rewardIds = append(rewardIds, v.RewardID)
			rewardMap[v.RewardID] = ""
		}
	}

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

	for _, v := range list {
		if !v.IsShow() {
			continue
		}

		info, _ := preward.InfoAutoLang(v.RewardID)
		data[v.MallID] = append(data[v.MallID], &pb.ListRes_Reward{
			Id:     v.ID,
			Title:  info.RewardTitle,
			ImgUrl: info.ImgUrl,
		})
	}

	return
}

func (s *List) _relate(ids []int64) (data map[int64][]*pb.ListRes_Relate, err error) {
	data = make(map[int64][]*pb.ListRes_Relate, len(ids))
	if len(ids) == 0 {
		return
	}

	m := s.GetDao().RedeemMallRelate
	list, err := m.WithContext(s.Ctx).Where(m.MallID.In(ids...), m.CancelTime.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var cpnIds, centerIds []int64
	for _, v := range list {
		switch v.Source {
		case mtype.RedeemMallRelateSourceCenter:
			centerIds = append(centerIds, v.RelateID)
		case mtype.RedeemMallRelateSourceCampaign:
			cpnIds = append(cpnIds, v.RelateID)
		}
	}

	cpnTitle, err := s._cpnTitle(cpnIds)
	if err != nil {
		return
	}

	centerTitle, err := s._centerTitle(centerIds)
	if err != nil {
		return
	}

	for _, v := range list {
		one := &pb.ListRes_Relate{
			Id:     v.ID,
			Source: int32(v.Source),
		}

		switch v.Source {
		case mtype.RedeemMallRelateSourceCenter:
			one.Title = centerTitle[v.RelateID]
		case mtype.RedeemMallRelateSourceCampaign:
			one.Title = cpnTitle[v.RelateID]
		}

		data[v.MallID] = append(data[v.MallID], one)
	}

	return
}

func (s *List) _centerTitle(ids []int64) (data map[int64]string, err error) {
	data = make(map[int64]string, len(ids))

	if len(ids) == 0 {
		return
	}

	res, err := app.NewTaskcenterCenterStat().DemTitle(s.Ctx, &t_center_statpb.DemTitleReq{
		CenterIds: ids,
	})

	if err != nil {
		return
	}

	for _, v := range res.GetCenters() {
		data[v.GetId()] = v.GetTitle()
	}

	return
}

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

	m := s.GetDao().FissionCampaign
	list, err := m.WithContext(s.Ctx).Where(m.ID.In(ids...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, v := range list {
		data[v.ID] = v.Title
	}

	return
}