package containers

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

type FissionUpdateTempGroup struct {
	logic.Logic
	Req *pb.UpdateTempGroupReq
	Res *pb.UpdateTempGroupRes
}

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

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

	err = s.update(group)
	if err != nil {
		return
	}

	err = s.updateGroupLang(group)
	if err != nil {
		return
	}

	err = s.updateTemp(group)
	if err != nil {
		return
	}

	return
}

func (s *FissionUpdateTempGroup) check() (group *model.FissionTempGroup, err error) {
	group, err = cache.NewFissionTempGroup(s.Ctx).FindById(s.Req.GetId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	if s.Req.GetLangParts() != "" {
		moduleM := s.GetDao().FissionLangModule
		marks := strings.Split(s.Req.GetLangParts(), ",")

		var list []*model.FissionLangModule

		list, err = moduleM.WithContext(s.Ctx).Where(moduleM.Mark.In(marks...)).Find()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		var markKey = make(map[string]string)
		for _, v := range list {
			for _, kv := range v.GetParts() {
				markKey[kv.Key] = v.Mark
			}
		}

		for _, v := range s.Req.GetLang() {
			if module, ok := markKey[v.Key]; ok {
				err = s.BE().VerifyError(fmt.Sprintf("%s模块下已存在%s，请重新设置", module, v.Key))
				return
			}
		}
	}

	return
}

func (s *FissionUpdateTempGroup) update(group *model.FissionTempGroup) (err error) {
	m := s.GetDao().FissionTempGroup

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(group.ID)).UpdateSimple(
		m.CoverURL.Value(s.Req.GetCoverUrl()),
		m.Sort.Value(s.Req.GetSort()),
		m.LangParts.Value(s.Req.GetLangParts()),
		m.ConvertCoverURL.Value(s.Req.GetConvertCoverUrl()),
	)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		_ = cache.NewFissionTempGroup(s.Ctx).Clear(group)
		s.Res.Id = group.ID
		return
	})
	return
}

func (s *FissionUpdateTempGroup) updateGroupLang(group *model.FissionTempGroup) (err error) {
	var lts []string
	for _, v := range s.Req.GetLang() {
		lts = append(lts, v.GetValue())
	}

	ltmM := s.GetDao().LangTextMark
	list, err := ltmM.WithContext(s.Ctx).Where(ltmM.Text.In(lts...)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var vm = make(map[string]string)
	for _, v := range list {
		vm[v.Text] = v.Mark
	}

	for _, text := range lts {
		if _, ok := vm[text]; !ok {
			err = s.BE().VerifyError(fmt.Sprintf("[%s]未翻译", text))
			return
		}
	}

	m := s.GetDao().FissionTempGroupLang
	tglList, err := m.WithContext(s.Ctx).Where(m.GroupID.Eq(group.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var old = make(map[string]*model.FissionTempGroupLang)
	for _, v := range tglList {
		old[v.LangMark] = v
	}

	var add []*model.FissionTempGroupLang
	for _, v := range s.Req.GetLang() {

		tgl, ok := old[v.GetKey()]
		if !ok {
			add = append(add, withdefault.FissionTempGroupLang(&model.FissionTempGroupLang{
				GroupID:  group.ID,
				Mark:     v.GetKey(),
				LangMark: vm[v.GetValue()],
				Desc:     v.GetDesc(),
			}))
			continue
		}

		_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(tgl.ID)).UpdateSimple(m.LangMark.Value(vm[v.GetValue()]), m.Desc.Value(v.GetValue()))
		if err != nil {
			return
		}

	}

	if len(add) == 0 {
		return
	}

	if err = m.WithContext(s.Ctx).Create(add...); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	return
}

func (s *FissionUpdateTempGroup) updateTemp(group *model.FissionTempGroup) (err error) {
	if len(s.Req.LangType) == 0 {
		return
	}

	m := s.GetDao().FissionTemp

	list, err := m.WithContext(s.Ctx).Where(m.GroupID.Eq(group.ID)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var old = make(map[int32]*model.FissionTemp)
	for _, v := range list {
		old[int32(v.LangType)] = v
	}

	var newLangType = make(map[int32]struct{})
	var add []*model.FissionTemp
	for _, v := range s.Req.GetLangType() {
		newLangType[v] = struct{}{}

		if _, ok := old[v]; !ok {
			add = append(add, withdefault.FissionTemp(&model.FissionTemp{
				FissionID: group.FissionID,
				GroupID:   group.ID,
				LangType:  int8(v),
				TextType:  mtype.FissionLangTypeTextType[int8(v)],
			}))
			continue
		}
	}

	var delIds []int64
	for _, v := range list {
		if _, ok := newLangType[int32(v.LangType)]; !ok {
			delIds = append(delIds, v.ID)
		}
	}

	if len(add) > 0 {
		if err = m.WithContext(s.Ctx).Create(add...); err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(delIds) > 0 {
		_, err = m.WithContext(s.Ctx).Where(m.ID.In(delIds...)).Delete()
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}