package campaignuser

import (
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_campaign_user"

	"gits.branchcn.com/backend/joybuywork/proto/go_proto/workerr"
	"gorm.io/gen"
)

type ChatList struct {
	logic.Logic
	Req *pb.ChatListReq
	Res *pb.ChatListRes

	newChat bool
}

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

func (s *ChatList) Exec() (err error) {
	cpn, user, err := s.user()
	if err != nil {
		return
	}

	chat, err := s.chat(cpn, user)
	if err != nil {
		return
	}
	return s.list(chat)
}

func (s *ChatList) user() (cpn *model.FissionCampaign, user *model.FissionUser, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetCampaignId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	user, err = finder.FissionUser(s.Ctx, cpn.ID, s.Req.GetUserId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	return
}

func (s *ChatList) chat(cpn *model.FissionCampaign, user *model.FissionUser) (chat *model.FissionChat, err error) {
	chat, err = cache.NewFissionChat(s.Ctx).FindByUniq(user.CampaignID, user.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if chat.Character != "" {
		return
	}

	temp, err := cache.NewFissionTemp(s.Ctx).FindById(cpn.TemplateID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	if temp == nil {
		return
	}

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

	var character string
	switch group.Mark {
	case "cat":
		character = "你是一只聪明的小猫"
	case "panda_sister":
		character = "你是一只可爱的小熊猫妹妹"
	case "panda_brother":
		character = "你是一只暖心的小熊猫哥哥"
	default:
		character = "你是一只聪明的小狗"
	}

	m := s.GetDao().FissionChat
	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(chat.ID)).UpdateSimple(m.Character.Value(character))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewFissionChat(s.Ctx).Clear(chat)
	})

	chat.Character = character
	s.newChat = true

	return
}

func (s *ChatList) list(chat *model.FissionChat) (err error) {
	m := s.GetDao().FissionChatMsg

	var cond = []gen.Condition{
		m.ChatID.Eq(chat.ID),
	}

	if s.Req.GetLastId() > 0 {
		cond = append(cond, m.ID.Lt(s.Req.GetLastId()))
	}

	list, err := m.WithContext(s.Ctx).Where(cond...).Limit(int(s.Req.GetPerPage())).Order(m.ID.Desc()).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if s.newChat && len(list) == 0 {
		msg := withdefault.FissionChatMsg(&model.FissionChatMsg{
			CampaignID: chat.CampaignID,
			UserID:     chat.UserID,
			ChatID:     chat.ID,
			Source:     mtype.FissionChatMsgSourceSystem,
			MsgType:    mtype.FissionChatMsgTypeFix,
			Val:        "",
		}, mtype.ChatMsgVal{Text: "chat:sys_guide"})
		if err = m.WithContext(s.Ctx).Create(msg); err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		list = append(list, msg)
	}

	var data = make([]*pb.ChatListRes_One, 0, len(list))
	for _, v := range list {

		var one = &pb.ChatListRes_One{
			Content:   "",
			Source:    v.Source,
			MsgType:   int32(v.MsgType),
			CreatedAt: v.CreatedAt,
			MsgId:     v.ID,
		}

		val := v.GetVal()
		switch v.MsgType {
		case mtype.FissionChatMsgTypeText, mtype.FissionChatMsgTypeFix:
			one.Content = val.Text
		}

		data = append(data, one)
	}

	s.Res.List = data

	return
}