package containers

import (
	"joybuywork/internal/app"
	"joybuywork/internal/consts"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_fission"
	"joybuywork/proto/go_proto/workerr"
	"fmt"
	"strings"
)

type FissionTemplateInfo struct {
	logic.Logic
	Req *pb.TemplateInfoReq
	Res *pb.TemplateInfoRes
}

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

func (s *FissionTemplateInfo) Exec() (err error) {
	temp, group, err := s.temp()
	if err != nil {
		return
	}

	temp, err = s.switchTemp(temp)
	if err != nil {
		return
	}

	err = s.lang(temp, group)
	if err != nil {
		return
	}

	s.fixReward()

	return
}

func (s *FissionTemplateInfo) temp() (temp *model.FissionTemp, group *model.FissionTempGroup, err error) {
	temp, err = finder.FissionTemp(s.Ctx, s.Req.GetId(), s.Req.GetHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if temp == nil || temp.IsDel == mtype.Yes {
		err = workerr.NotFound("template not found")
		return
	}

	group, err = cache.NewFissionTempGroup(s.Ctx).FindById(temp.GroupID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	s.Res.TempGroupMark = group.Mark

	return
}

func (s *FissionTemplateInfo) switchTemp(temp *model.FissionTemp) (*model.FissionTemp, error) {
	langType := mtype.MarkToLangType[s.Req.GetLang()]

	if langType == 0 || langType == temp.LangType {
		return temp, nil
	}

	m := s.GetDao().FissionTemp
	info, err := m.WithContext(s.Ctx).Where(m.GroupID.Eq(temp.GroupID), m.LangType.Eq(langType)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return nil, err
	}

	if info == nil {
		return temp, nil
	}

	return info, nil
}

func (s *FissionTemplateInfo) lang(temp *model.FissionTemp, group *model.FissionTempGroup) (err error) {
	textMap, err := s._groupTextMap(group, mtype.FissionLangTypeToMark[temp.LangType])
	if err != nil {
		return
	}

	customText, err := s._text(temp.ID)
	if err != nil {
		return
	}

	for k, v := range customText {
		textMap[k] = v
	}

	s.Res.Lang = make([]*pb.TemplateInfoRes_KV, 0, len(textMap))
	for _, v := range textMap {
		s.Res.Lang = append(s.Res.Lang, &pb.TemplateInfoRes_KV{
			Key:   v.Key,
			Value: v.Value,
			Desc:  v.Desc,
		})
	}

	imgMap, err := s._commonImg(temp.LangType)
	if err != nil {
		return
	}

	customImg, err := s._img(temp.ID)
	for k, v := range customImg {
		imgMap[k] = v
	}

	s.Res.Image = make([]*pb.TemplateInfoRes_KV, 0, len(imgMap))
	for _, v := range imgMap {
		s.Res.Image = append(s.Res.Image, &pb.TemplateInfoRes_KV{
			Key:   v.Key,
			Value: v.Value,
			Desc:  v.Desc,
		})
	}

	s.Res.Id = temp.ID
	s.Res.HashId = temp.HashID
	s.Res.LangType = int32(temp.LangType)
	s.Res.TextType = int32(temp.TextType)

	return
}

func (s *FissionTemplateInfo) _groupTextMap(group *model.FissionTempGroup, mark string) (textMap map[string]*mtype.LangKv, err error) {
	textMap = make(map[string]*mtype.LangKv)

	m := s.GetDao().FissionTempGroupLang

	var lms []string
	list, err := m.WithContext(s.Ctx).Where(m.GroupID.Eq(group.ID)).Find()
	for _, v := range list {
		lms = append(lms, v.LangMark)
	}

	var partLkv []*mtype.LangKv
	if group.LangParts != "" {
		parts := strings.Split(group.LangParts, ",")
		moduleM := s.GetDao().FissionLangModule
		var partList []*model.FissionLangModule
		partList, err = moduleM.WithContext(s.Ctx).Where(moduleM.Mark.In(parts...)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		for _, v := range partList {
			for _, kv := range v.GetParts() {
				partLkv = append(partLkv, kv)
				lms = append(lms, kv.Value)
			}
		}
	}

	langM := s.GetDao().Lang
	langList, err := langM.WithContext(s.Ctx).Where(langM.LangMark.In(lms...), langM.Mark.Eq(mark)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var mtMap = make(map[string]string)
	for _, lang := range langList {
		mtMap[lang.LangMark] = lang.LangText
	}

	for _, v := range list {
		textMap[v.Mark] = &mtype.LangKv{
			Key:   v.Mark,
			Value: mtMap[v.LangMark],
			Desc:  v.Desc,
		}
	}

	for _, v := range partLkv {
		textMap[v.Key] = &mtype.LangKv{
			Key:   v.Key,
			Value: mtMap[v.Value],
			Desc:  v.Desc,
		}
	}

	return
}

func (s *FissionTemplateInfo) _text(tempId int64) (textMap map[string]*mtype.LangKv, err error) {
	textMap = make(map[string]*mtype.LangKv)

	langM := s.GetDao().FissionTempLang
	lang, err := langM.WithContext(s.Ctx).Where(langM.TempID.Eq(tempId)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, v := range lang {
		textMap[v.Mark] = &mtype.LangKv{
			Key:   v.Mark,
			Value: v.Val,
			Desc:  v.Desc,
		}
	}
	return
}

func (s *FissionTemplateInfo) _commonImg(langType int8) (imgMap map[string]*mtype.LangKv, err error) {

	if langType == mtype.FissionLangTypeZh {

		return map[string]*mtype.LangKv{
			consts.TempInfoImgAndroidBtnKey: {
				Key:   consts.TempInfoImgAndroidBtnKey,
				Value: fmt.Sprintf(consts.TempInfoImgAndroidBtnValue, ""),
				Desc:  consts.TempInfoImgAndroidBtnDesc,
			},
			consts.TempInfoImgIosBtnKey: {
				Key:   consts.TempInfoImgIosBtnKey,
				Value: fmt.Sprintf(consts.TempInfoImgIosBtnValue, ""),
				Desc:  consts.TempInfoImgIosBtnDesc,
			},
			consts.TempInfoImgAndroidBtnWhiteKey: {
				Key:   consts.TempInfoImgAndroidBtnWhiteKey,
				Value: fmt.Sprintf(consts.TempInfoImgAndroidBtnWhiteValue, ""),
				Desc:  consts.TempInfoImgAndroidBtnWhiteDesc,
			},
			consts.TempInfoImgIosBtnWhiteKey: {
				Key:   consts.TempInfoImgIosBtnWhiteKey,
				Value: fmt.Sprintf(consts.TempInfoImgIosBtnWhiteValue, ""),
				Desc:  consts.TempInfoImgIosBtnWhiteDesc,
			},
			consts.TempInfoImgWechatBrowserKey: {
				Key:   consts.TempInfoImgWechatBrowserKey,
				Value: fmt.Sprintf(consts.TempInfoImgWechatBrowserValue, ""),
				Desc:  consts.TempInfoImgWechatBrowserDesc,
			},
			consts.TempInfoImgWechatLineKey: {
				Key:   consts.TempInfoImgWechatLineKey,
				Value: fmt.Sprintf(consts.TempInfoImgWechatLineValue, ""),
				Desc:  consts.TempInfoImgWechatLineDesc,
			},
			consts.TempInfoImgDefaultKey: {
				Key:   consts.TempInfoImgDefaultKey,
				Value: consts.TempInfoImgDefaultValue,
				Desc:  consts.TempInfoImgDefaultDesc,
			},
		}, nil

	}

	return map[string]*mtype.LangKv{
		consts.TempInfoImgAndroidBtnKey: {
			Key:   consts.TempInfoImgAndroidBtnKey,
			Value: fmt.Sprintf(consts.TempInfoImgAndroidBtnValue, "_en"),
			Desc:  consts.TempInfoImgAndroidBtnDesc,
		},
		consts.TempInfoImgIosBtnKey: {
			Key:   consts.TempInfoImgIosBtnKey,
			Value: fmt.Sprintf(consts.TempInfoImgIosBtnValue, "_en"),
			Desc:  consts.TempInfoImgIosBtnDesc,
		},
		consts.TempInfoImgAndroidBtnWhiteKey: {
			Key:   consts.TempInfoImgAndroidBtnWhiteKey,
			Value: fmt.Sprintf(consts.TempInfoImgAndroidBtnWhiteValue, "_en"),
			Desc:  consts.TempInfoImgAndroidBtnWhiteDesc,
		},
		consts.TempInfoImgIosBtnWhiteKey: {
			Key:   consts.TempInfoImgIosBtnWhiteKey,
			Value: fmt.Sprintf(consts.TempInfoImgIosBtnWhiteValue, "_en"),
			Desc:  consts.TempInfoImgIosBtnWhiteDesc,
		},
		consts.TempInfoImgWechatBrowserKey: {
			Key:   consts.TempInfoImgWechatBrowserKey,
			Value: fmt.Sprintf(consts.TempInfoImgWechatBrowserValue, "_en"),
			Desc:  consts.TempInfoImgWechatBrowserDesc,
		},
		consts.TempInfoImgWechatLineKey: {
			Key:   consts.TempInfoImgWechatLineKey,
			Value: fmt.Sprintf(consts.TempInfoImgWechatLineValue, "_en"),
			Desc:  consts.TempInfoImgWechatLineDesc,
		},
		consts.TempInfoImgDefaultKey: {
			Key:   consts.TempInfoImgDefaultKey,
			Value: consts.TempInfoImgDefaultValue,
			Desc:  consts.TempInfoImgDefaultDesc,
		},
	}, nil
}

func (s *FissionTemplateInfo) _img(tempId int64) (imgMap map[string]*mtype.LangKv, err error) {
	imgMap = make(map[string]*mtype.LangKv)

	imageM := s.GetDao().FissionTempImage
	img, err := imageM.WithContext(s.Ctx).Where(imageM.TempID.Eq(tempId)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	for _, v := range img {
		imgMap[v.Mark] = &mtype.LangKv{
			Key:   v.Mark,
			Value: v.Val,
			Desc:  v.Desc,
		}
	}

	return
}

func (s *FissionTemplateInfo) fixReward() {
	s.Res.FixRewards = make([]*pb.TemplateInfoRes_FixReward, 0, len(app.FissionFixRewards))
	for _, reward := range app.FissionFixRewards {
		one := &pb.TemplateInfoRes_FixReward{
			Id:    reward.Id,
			Langs: make([]*pb.TemplateInfoRes_Lang, 0, len(reward.Langs)),
		}
		for _, lang := range reward.Langs {
			one.Langs = append(one.Langs, &pb.TemplateInfoRes_Lang{
				Title:    lang.Title,
				ImgUrl:   lang.ImgUrl,
				LangMark: lang.Mark,
			})
		}
		s.Res.FixRewards = append(s.Res.FixRewards, one)
	}
	return
}