package containers

import (
	"joybuywork/internal/repository/dbcheck"
	"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 FissionCreateTempGroup struct {
	logic.Logic
	Req *pb.CreateTempGroupReq
	Res *pb.CreateTempGroupRes
}

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

func (s *FissionCreateTempGroup) Exec() (err error) {
	err = s.check()
	if err != nil {
		return
	}

	group, err := s.create()
	if err != nil {
		return
	}

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

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

	return
}

func (s *FissionCreateTempGroup) check() (err error) {
	m := s.GetDao().FissionTempGroup
	exist, err := m.WithContext(s.Ctx).Where(m.Mark.Eq(s.Req.GetMark())).Take()
	if err = dbcheck.DbError(err); err != nil {
		return s.BE().MysqlError(err)
	}

	if exist != nil {
		return workerr.BadRequest("mark exist")
	}

	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 *FissionCreateTempGroup) create() (group *model.FissionTempGroup, err error) {
	group = withdefault.FissionTempGroup(&model.FissionTempGroup{
		FissionID:       s.Req.GetFissionId(),
		CoverURL:        s.Req.GetCoverUrl(),
		Mark:            s.Req.GetMark(),
		Sort:            s.Req.GetSort(),
		LangParts:       s.Req.GetLangParts(),
		ConvertCoverURL: s.Req.GetConvertCoverUrl(),
	})

	m := s.GetDao().FissionTempGroup

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

	s.AddAfterRun(func() (err error) {
		s.Res.Id = group.ID
		return
	})
	return
}

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

	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
	var add []*model.FissionTempGroupLang
	for _, v := range s.Req.GetLang() {
		add = append(add, withdefault.FissionTempGroupLang(&model.FissionTempGroupLang{
			GroupID:  group.ID,
			Mark:     v.Key,
			LangMark: vm[v.Value],
			Desc:     v.Desc,
		}))
	}

	if len(add) == 0 {
		return
	}

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

	return
}

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

	m := s.GetDao().FissionTemp

	var add []*model.FissionTemp
	for _, v := range s.Req.GetLangType() {
		add = append(add, withdefault.FissionTemp(&model.FissionTemp{
			FissionID: group.FissionID,
			GroupID:   group.ID,
			LangType:  int8(v),
			TextType:  mtype.FissionLangTypeTextType[int8(v)],
		}))
	}

	if len(add) == 0 {
		return
	}

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

	return
}