package campaign

import (
	"joybuywork/internal/consts"
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dbcheck"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/utils/blink"
	"joybuywork/internal/utils/logic"
	pb "joybuywork/proto/go_proto/w_campaign"
	"joybuywork/proto/go_proto/workerr"

	"gorm.io/gen/field"
)

type SaveLang struct {
	logic.Logic
	Req *pb.SaveLangReq
	Res *pb.SaveLangRes
}

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

func (s *SaveLang) Exec() (err error) {
	cpn, conf, err := s.campaign()
	if err != nil {
		return
	}

	return s.save(cpn, conf)
}

// 活动数据
func (s *SaveLang) campaign() (cpn *model.FissionCampaign, conf *model.FissionCampaignConfig, err error) {
	cpn, err = finder.Campaign(s.Ctx, s.Req.GetCampaignHashId())
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

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

	conf, err = cache.NewCampaignConfig(s.Ctx).FindByCampaignId(cpn.ID)
	if err != nil {
		err = s.BE().CacheError(err)
		return
	}

	return
}

func (s *SaveLang) save(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig) (err error) {
	m := s.GetDao().FissionCampaignLang
	lang, err := m.WithContext(s.Ctx).Where(m.CampaignID.Eq(cpn.ID), m.LangMark.Eq(s.Req.GetLangMark()), m.IsDel.Eq(mtype.No)).Take()
	if err = dbcheck.DbError(err); err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if s.Req.ToView {
		channelM := s.GetDao().FissionCampaignChannel
		var channel *model.FissionCampaignChannel
		channel, err = channelM.WithContext(s.Ctx).Where(channelM.CampaignID.Eq(cpn.ID), channelM.IsDefault.Eq(mtype.Yes), channelM.IsDel.Eq(mtype.No)).Take()
		if err = dbcheck.DbError(err); err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		var project *model.Project
		project, err = cache.NewProject(s.Ctx).FindById(cpn.ProjectID)
		if err != nil {
			err = s.BE().CacheError(err)
			return
		}

		if channel != nil {
			linkObj := blink.NewCampaignLink(project.Domain, cpn.HashID, channel.Mark,
				blink.SetView(),
				blink.SetLang(s.Req.GetLangMark()),
				blink.SetUserId(consts.FissionViewer),
			)
			s.Res.ViewLink = linkObj.CampaignShareLink()
		}
	}

	if lang == nil {
		return s._create(cpn, conf)
	}

	return s._update(lang, conf)
}

func (s *SaveLang) _create(cpn *model.FissionCampaign, conf *model.FissionCampaignConfig) (err error) {
	langTypes := cpn.GetLangTypes()
	nt := mtype.MarkToLangType[s.Req.GetLangMark()]
	for _, v := range langTypes {
		if v == nt {
			err = s.BE().VerifyError("lang exist")
			return
		}
	}

	conds, _ := jsonm.ToSliceString(s.Req.GetConds())
	quit, _ := jsonm.ToObjString(s.Req.GetQuit())
	questions, _ := jsonm.ToSliceString(s.Req.GetQuestions())
	cash, _ := jsonm.ToObjString(s.Req.GetCash())
	gold, _ := jsonm.ToObjString(s.Req.GetGold())
	coin, _ := jsonm.ToObjString(s.Req.GetCoin())
	qaGroup, _ := jsonm.ToObjString(s.Req.GetQaGroup())
	talkText, _ := jsonm.ToSliceString(s.Req.GetTalkText())
	vs, _ := jsonm.ToSliceString(s.Req.GetSchedules())

	lang := withdefault.FissionCampaignLang(&model.FissionCampaignLang{
		CampaignID:        cpn.ID,
		LangMark:          s.Req.GetLangMark(),
		PageTitle:         s.Req.GetPageTitle(),
		ImageMain:         s.Req.GetImageMain(),
		DownloadPageImage: s.Req.GetDownloadPageImage(),
		WechatPageImage:   s.Req.GetWechatPageImage(),
		ContentImg:        s.Req.GetContentImg(),
		WebBgImg:          s.Req.GetWebBgImg(),
		WarmUpImg:         s.Req.GetWarmUpImg(),
		DlBgImg:           s.Req.GetDlBgImg(),
		DlBannerImg:       s.Req.GetDlBannerImg(),
		DlBannerAppLogo:   s.Req.GetDlBannerAppLogo(),
		DlBannerAppName:   s.Req.GetDlBannerAppName(),
		DlBannerAppBtn:    s.Req.GetDlBannerAppBtn(),
		ShareText:         s.Req.GetShareText(),
		ShareImg:          s.Req.GetShareImg(),
		Rule:              s.Req.GetRule(),
		Conds:             conds,
		Quit:              quit,
		Questions:         questions,
		QaGroup:           qaGroup,
		LongImg:           "[]",
		Cash:              cash,
		Gold:              gold,
		TOffset:           s.Req.GetTOffset(),
		TalkText:          talkText,
		Coin:              coin,
		TopicColor:        s.Req.GetTopicColor(),
		PcBg:              s.Req.GetPcBg(),
		RuleImg:           s.Req.GetRuleImg(),
		Vs:                vs,
		Uno:               "{}",
	})

	if uno := s.Req.GetUno(); uno != nil {
		lang.SetUno(&mtype.LangUno{
			Red:    s._unoCard(uno.GetRed()),
			Blue:   s._unoCard(uno.GetBlue()),
			Green:  s._unoCard(uno.GetGreen()),
			Yellow: s._unoCard(uno.GetYellow()),
		})
	}

	err = s.GetDao().FissionCampaignLang.WithContext(s.Ctx).Create(lang)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	if conf.HasLongImg == mtype.Yes {
		var zones []*model.FissionCampaignLongImgZone
		var imgs = make([]*model.FissionCampaignLongImg, 0, len(s.Req.GetLongImgs()))
		for _, v := range s.Req.GetLongImgs() {
			one := withdefault.FissionCampaignLongImg(&model.FissionCampaignLongImg{
				CampaignID:   cpn.ID,
				LangID:       lang.ID,
				ClickType:    int8(v.ClickType),
				ImgURL:       v.ImgUrl,
				WebURL:       v.WebUrl,
				AppParam:     v.AppParam,
				PcParam:      v.PcParam,
				TargetType:   int8(v.GetTargetType()),
				TargetID:     v.GetTargetId(),
				LangSourceID: v.GetLangSourceId(),
			})

			for _, zone := range v.GetHotZone() {
				zones = append(zones, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
					CampaignID: cpn.ID,
					ImgID:      one.ID,
					WebURL:     zone.WebUrl,
					AppParam:   zone.AppParam,
					ClickX:     zone.ClickX,
					ClickY:     zone.ClickY,
					ClickH:     zone.ClickH,
					ClickW:     zone.ClickW,
					TargetType: int8(zone.GetTargetType()),
					TargetID:   zone.GetTargetId(),
					PcParam:    zone.GetPcParam(),
				}))
			}

			imgs = append(imgs, one)
		}

		err = s.GetDao().FissionCampaignLongImg.WithContext(s.Ctx).Create(imgs...)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		if len(zones) > 0 {
			err = s.GetDao().FissionCampaignLongImgZone.WithContext(s.Ctx).Create(zones...)
			if err != nil {
				err = s.BE().MysqlError(err)
				return
			}
		}

	}

	langTypes = append(langTypes, nt)

	m := s.GetDao().FissionCampaign
	lt, _ := jsonm.MarshalToString(langTypes)
	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(cpn.ID)).UpdateSimple(m.LangTypes.Value(lt))
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewCampaign(s.Ctx).Clear(cpn)
	})

	return
}

func (s *SaveLang) _unoCard(in []*pb.SaveLangReq_UnoCard) []*mtype.UnoCard {
	out := make([]*mtype.UnoCard, 0, len(in))
	for i, v := range in {
		out = append(out, &mtype.UnoCard{
			CardNo:   int32(i) + 1,
			Title:    v.GetTitle(),
			ImgURL:   v.GetImgUrl(),
			WebURL:   v.GetWebUrl(),
			AppParam: v.GetAppParam(),
			PcParam:  v.GetPcParam(),
		})
	}

	return out
}

func (s *SaveLang) _update(lang *model.FissionCampaignLang, conf *model.FissionCampaignConfig) (err error) {
	conds, _ := jsonm.ToSliceString(s.Req.GetConds())
	quit, _ := jsonm.ToObjString(s.Req.GetQuit())
	questions, _ := jsonm.ToSliceString(s.Req.GetQuestions())
	cash, _ := jsonm.ToObjString(s.Req.GetCash())
	gold, _ := jsonm.ToObjString(s.Req.GetGold())
	coin, _ := jsonm.ToObjString(s.Req.GetCoin())
	qaGroup, _ := jsonm.ToObjString(s.Req.GetQaGroup())
	talkText, _ := jsonm.ToSliceString(s.Req.GetTalkText())
	vs, _ := jsonm.ToSliceString(s.Req.GetSchedules())

	m := s.GetDao().FissionCampaignLang
	var upData = []field.AssignExpr{
		m.PageTitle.Value(s.Req.GetPageTitle()),
		m.ImageMain.Value(s.Req.GetImageMain()),
		m.DownloadPageImage.Value(s.Req.GetDownloadPageImage()),
		m.WechatPageImage.Value(s.Req.GetWechatPageImage()),
		m.WebBgImg.Value(s.Req.GetWebBgImg()),
		m.WarmUpImg.Value(s.Req.GetWarmUpImg()),
		m.ContentImg.Value(s.Req.GetContentImg()),
		m.DlBgImg.Value(s.Req.GetDlBgImg()),
		m.DlBannerImg.Value(s.Req.GetDlBannerImg()),
		m.DlBannerAppLogo.Value(s.Req.GetDlBannerAppLogo()),
		m.DlBannerAppName.Value(s.Req.GetDlBannerAppName()),
		m.DlBannerAppBtn.Value(s.Req.GetDlBannerAppBtn()),
		m.ShareText.Value(s.Req.GetShareText()),
		m.ShareImg.Value(s.Req.GetShareImg()),
		m.Rule.Value(s.Req.GetRule()),
		m.Cash.Value(cash),
		m.Gold.Value(gold),
		m.Coin.Value(coin),
		m.TOffset.Value(s.Req.GetTOffset()),
		m.TopicColor.Value(s.Req.GetTopicColor()),
		m.PcBg.Value(s.Req.GetPcBg()),
		m.RuleImg.Value(s.Req.GetRuleImg()),
		m.Vs.Value(vs),
	}

	if uno := s.Req.GetUno(); uno != nil {
		unoVal, _ := jsonm.ToObjString(&mtype.LangUno{
			Red:    s._unoCard(uno.GetRed()),
			Blue:   s._unoCard(uno.GetBlue()),
			Green:  s._unoCard(uno.GetGreen()),
			Yellow: s._unoCard(uno.GetYellow()),
		})
		upData = append(upData, m.Uno.Value(unoVal))
	}

	upData = append(upData, m.Conds.Value(conds), m.Questions.Value(questions), m.Quit.Value(quit), m.QaGroup.Value(qaGroup), m.TalkText.Value(talkText))

	_, err = m.WithContext(s.Ctx).Where(m.ID.Eq(lang.ID)).UpdateSimple(upData...)
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	s.AddAfterRun(func() (err error) {
		return cache.NewCampaignLang(s.Ctx).Clear(lang)
	})

	if conf.HasLongImg == mtype.No {
		return
	}

	imgM := s.GetDao().FissionCampaignLongImg
	imgs, err := imgM.WithContext(s.Ctx).Where(imgM.CampaignID.Eq(lang.CampaignID), imgM.LangID.Eq(lang.ID), imgM.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		err = s.BE().MysqlError(err)
		return
	}

	var oldMap = make(map[int64]*model.FissionCampaignLongImg)
	for _, v := range imgs {
		oldMap[v.ID] = v
	}

	zoneM := s.GetDao().FissionCampaignLongImgZone
	var zone []*model.FissionCampaignLongImgZone
	var add = make([]*model.FissionCampaignLongImg, 0)
	var zoneDelIds []int64
	for _, v := range s.Req.GetLongImgs() {
		old, ok := oldMap[v.GetId()]
		if !ok {
			one := withdefault.FissionCampaignLongImg(&model.FissionCampaignLongImg{
				CampaignID: conf.CampaignID,
				LangID:     lang.ID,
				ClickType:  int8(v.GetClickType()),
				ImgURL:     v.GetImgUrl(),
				WebURL:     v.GetWebUrl(),
				AppParam:   v.GetAppParam(),
				TargetType: int8(v.GetTargetType()),
				TargetID:   v.GetTargetId(),
				PcParam:    v.GetPcParam(),
			})

			if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeZone {
				for _, hotZone := range v.GetHotZone() {
					zone = append(zone, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
						CampaignID: conf.CampaignID,
						ImgID:      one.ID,
						WebURL:     hotZone.GetWebUrl(),
						AppParam:   hotZone.GetAppParam(),
						ClickX:     hotZone.GetClickX(),
						ClickY:     hotZone.GetClickY(),
						ClickH:     hotZone.GetClickH(),
						ClickW:     hotZone.GetClickW(),
						TargetType: int8(hotZone.GetTargetType()),
						TargetID:   hotZone.GetTargetId(),
						PcParam:    hotZone.GetPcParam(),
					}))
				}
			}

			add = append(add, one)

			continue
		}

		_, err = imgM.WithContext(s.Ctx).Where(imgM.ID.Eq(old.ID)).UpdateSimple(
			imgM.ClickType.Value(int8(v.GetClickType())),
			imgM.ImgURL.Value(v.GetImgUrl()),
			imgM.WebURL.Value(v.GetWebUrl()),
			imgM.AppParam.Value(v.GetAppParam()),
			imgM.TargetType.Value(int8(v.GetTargetType())),
			imgM.TargetID.Value(v.GetTargetId()),
			imgM.PcParam.Value(v.GetPcParam()),
		)
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}

		delete(oldMap, old.ID)

		switch old.ClickType {
		case mtype.FissionCampaignLongImgClickTypeAll:
			if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeZone {
				for _, hotZone := range v.GetHotZone() {
					zone = append(zone, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
						CampaignID: conf.CampaignID,
						ImgID:      old.ID,
						WebURL:     hotZone.GetWebUrl(),
						AppParam:   hotZone.GetAppParam(),
						ClickX:     hotZone.GetClickX(),
						ClickY:     hotZone.GetClickY(),
						ClickH:     hotZone.GetClickH(),
						ClickW:     hotZone.GetClickW(),
						TargetType: int8(hotZone.GetTargetType()),
						TargetID:   hotZone.GetTargetId(),
						PcParam:    hotZone.GetPcParam(),
					}))
				}
			}
		case mtype.FissionCampaignLongImgClickTypeZone:
			if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeAll {
				_, err = zoneM.WithContext(s.Ctx).Where(zoneM.ImgID.Eq(old.ID)).UpdateSimple(m.IsDel.Value(mtype.Yes))
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}
			} else if v.GetClickType() == mtype.FissionCampaignLongImgClickTypeZone {
				var zones []*model.FissionCampaignLongImgZone
				zones, err = zoneM.WithContext(s.Ctx).Where(zoneM.ImgID.Eq(old.ID), zoneM.IsDel.Eq(mtype.No)).Find()
				if err != nil {
					err = s.BE().MysqlError(err)
					return
				}

				var oldZoneMap = make(map[int64]*model.FissionCampaignLongImgZone, len(zones))
				for _, click := range zones {
					oldZoneMap[click.ID] = click
				}

				for _, hotZone := range v.GetHotZone() {
					oldZone, ok1 := oldZoneMap[hotZone.GetId()]
					if !ok1 {
						zone = append(zone, withdefault.FissionCampaignLongImgZone(&model.FissionCampaignLongImgZone{
							CampaignID: conf.CampaignID,
							ImgID:      old.ID,
							WebURL:     hotZone.GetWebUrl(),
							AppParam:   hotZone.GetAppParam(),
							ClickX:     hotZone.GetClickX(),
							ClickY:     hotZone.GetClickY(),
							ClickH:     hotZone.GetClickH(),
							ClickW:     hotZone.GetClickW(),
							TargetType: int8(hotZone.GetTargetType()),
							TargetID:   hotZone.GetTargetId(),
							PcParam:    hotZone.GetPcParam(),
						}))

						continue
					}

					_, err = zoneM.WithContext(s.Ctx).Where(zoneM.ID.Eq(oldZone.ID)).UpdateSimple(
						zoneM.WebURL.Value(hotZone.GetWebUrl()),
						zoneM.AppParam.Value(hotZone.GetAppParam()),
						zoneM.ClickX.Value(hotZone.GetClickX()),
						zoneM.ClickY.Value(hotZone.GetClickY()),
						zoneM.ClickH.Value(hotZone.GetClickH()),
						zoneM.ClickW.Value(hotZone.GetClickW()),
						zoneM.TargetType.Value(int8(hotZone.GetTargetType())),
						zoneM.TargetID.Value(hotZone.GetTargetId()),
						zoneM.PcParam.Value(hotZone.GetPcParam()),
					)
					if err != nil {
						err = s.BE().MysqlError(err)
						return
					}

					delete(oldZoneMap, oldZone.ID)
				}

				for id := range oldZoneMap {
					zoneDelIds = append(zoneDelIds, id)
				}
			}
		}
	}

	var imgDelIds []int64
	for id := range oldMap {
		imgDelIds = append(imgDelIds, id)
	}

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

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

	if len(imgDelIds) > 0 {
		_, err = imgM.WithContext(s.Ctx).Where(imgM.ID.In(imgDelIds...)).UpdateSimple(imgM.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	if len(zoneDelIds) > 0 {
		_, err = zoneM.WithContext(s.Ctx).Where(zoneM.ID.In(zoneDelIds...)).UpdateSimple(zoneM.IsDel.Value(mtype.Yes))
		if err != nil {
			err = s.BE().MysqlError(err)
			return
		}
	}

	return
}