package script

import (
	"context"
	"joybuywork/internal/app"
	"joybuywork/internal/config"
	"joybuywork/internal/consts"
	"joybuywork/internal/consts/ckey"
	"joybuywork/internal/plugins/jsonm"
	"joybuywork/internal/plugins/printer"
	"joybuywork/internal/repository/cache"
	"joybuywork/internal/repository/dao"
	"joybuywork/internal/repository/finder"
	"joybuywork/internal/repository/model"
	"joybuywork/internal/repository/mtype"
	"joybuywork/internal/repository/withdefault"
	"joybuywork/internal/service/provider"
	"joybuywork/internal/service/queue/producer"
	"joybuywork/internal/service/queue/types"
	"joybuywork/internal/utils"
	"encoding/json"
	"fmt"
	"os"
	"strings"
	"time"

	"github.com/aliyun/aliyun-oss-go-sdk/oss"
	ddevicepb "gits.branchcn.com/backend/deeplink/proto/go_proto/ddevice"
)

type clearCache struct {
	ctx   context.Context
	Table string `json:"table"`
}

// 清楚对应的数据表缓存
func (c clearCache) clearCache() {
	var table = strings.Split(c.Table, ",")

	for _, v := range table {

		var mkey string
		switch v {
		case model.TableNameFissionCampaign:
			cc := cache.NewCampaign(c.ctx)

			mkey = cc.Cache.Prefix()

		case model.TableNameFissionCampaignConfig:
			cc := cache.NewCampaignConfig(c.ctx)

			mkey = cc.Cache.Prefix()
		case model.TableNameFissionCampaignStyle:
			cc := cache.NewCampaignStyle(c.ctx)

			mkey = cc.Cache.Prefix()
		case model.TableNameFissionCampaignCash:
			cc := cache.NewCampaignCash(c.ctx)

			mkey = cc.Cache.Prefix()
		case model.TableNameUser:
			cc := cache.NewUser(c.ctx)

			mkey = cc.Cache.Prefix()
		case model.TableNameProject:
			cc := cache.NewProject(c.ctx)

			mkey = cc.Cache.Prefix()
		case model.TableNameFissionUser:
			cc := cache.NewFissionUser(c.ctx, 0)

			mkey = cc.Cache.Prefix()
		case model.TableNameReward:
			cc := cache.NewReward(c.ctx)

			mkey = cc.Cache.Prefix()
		case model.TableNameFissionWebUser:
			cc := cache.NewReward(c.ctx)

			mkey = cc.Cache.Prefix()
		case model.TableNameFissionTemp:
			cc := cache.NewFissionTemp(c.ctx)

			mkey = cc.Cache.Prefix()
		case model.TableNameLibraryQaGroup:
			cc := cache.NewLibraryQaGroup(c.ctx)

			mkey = cc.Cache.Prefix()
		case model.TableNameFissionTempGroup:
			cc := cache.NewFissionTempGroup(c.ctx)

			list, _ := dao.FissionTempGroup.WithContext(c.ctx).Find()
			_ = cc.Clear(list...)

			return
		}

		if mkey == "" {
			continue
		}

		app.FeishuNormalSend("[%s]开始处理缓存数据", v)

		var idx int
		var cursor uint64
		var err error
		var keys []string
		for {

			keys, cursor, err = app.Redis.Cache.Scan(c.ctx, cursor, fmt.Sprintf("%s:*", mkey), 10000).Result()
			if err != nil {
				return
			}

			app.Redis.Cache.Del(c.ctx, keys...)

			idx += len(keys)

			if cursor == 0 {
				break
			}
		}
		app.FeishuNormalSend("[%s]删除了%d个缓存", v, idx)
	}

}

type lang struct {
	ctx    context.Context
	taskId string
}

// 把json文件里面的语言数据写到表里面
func (s lang) lang() {
	dir, _ := os.Getwd()

	var path string

	if consts.RunTest {
		path = fmt.Sprintf("../../../asset/campaign/lang")
	} else {
		path = fmt.Sprintf("%s/asset/campaign/lang", dir)
	}

	var err error
	tx := dao.Q.Begin()
	defer func() {
		if err != nil {
			app.Logger.Error(s.ctx, fmt.Sprintf("语言包处理有异常:%v", err))
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	entrys, err := os.ReadDir(path)
	if err != nil {
		return
	}

	m := tx.Lang
	for _, entry := range entrys {
		if !strings.HasSuffix(entry.Name(), ".json") {
			continue
		}
		mark, _ := strings.CutSuffix(entry.Name(), ".json")

		_, ok := mtype.MarkToLangType[mark]
		if !ok {
			continue
		}

		var ddd = make(map[string]string)
		var b []byte
		b, err = os.ReadFile(path + "/" + entry.Name())
		if err != nil {
			return
		}

		_ = json.Unmarshal(b, &ddd)
		var list []*model.Lang
		list, err = m.WithContext(s.ctx).Where(m.Mark.Eq(mark)).Find()
		if err != nil {
			return
		}

		var oldMap = make(map[string]*model.Lang)
		for _, v := range list {
			oldMap[v.LangMark] = v
		}

		var add []*model.Lang
		for mk, text := range ddd {

			for {
				if strings.HasSuffix(text, "_") {
					text = strings.TrimSuffix(text, "_")
					continue
				}
				break
			}

			l, ok1 := oldMap[mk]
			if !ok1 {
				add = append(add, withdefault.Lang(&model.Lang{
					Mark:     mark,
					LangMark: mk,
					LangText: text,
				}))

				continue
			}
			if l.LangText != text {
				_, err = m.WithContext(s.ctx).Where(m.ID.Eq(l.ID)).UpdateSimple(m.LangText.Value(text))
				if err != nil {
					return
				}
			}
		}

		if len(add) > 0 {
			err = m.WithContext(s.ctx).Create(add...)
			if err != nil {
				return
			}
		}

	}

}

type langModule struct {
	ctx    context.Context
	taskId string
}

func (s langModule) langModule() {
	dir, _ := os.Getwd()

	var path string

	if consts.RunTest {
		path = fmt.Sprintf("../../../asset/campaign")
	} else {
		path = fmt.Sprintf("%s/asset/campaign", dir)
	}

	var err error
	tx := dao.Q.Begin()
	defer func() {
		if err != nil {
			app.Logger.Error(s.ctx, fmt.Sprintf("语言包处理有异常:%v", err))
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	m := tx.FissionLangModule

	type parts struct {
		Parts any    `json:"parts"`
		Desc  string `json:"desc"`
	}

	var ddd = make(map[string]*parts)
	b, err := os.ReadFile(path + "/fission_lang.json")
	if err != nil {
		return
	}

	_ = json.Unmarshal(b, &ddd)

	list, err := m.WithContext(s.ctx).Find()
	if err != nil {
		return
	}

	var old = make(map[string]*model.FissionLangModule)
	for _, v := range list {
		old[v.Mark] = v
	}

	var add []*model.FissionLangModule
	for mark, v := range ddd {
		ps, _ := jsonm.MarshalToString(v.Parts)
		module, ok := old[mark]
		if !ok {
			add = append(add, withdefault.FissionLangModule(&model.FissionLangModule{
				Mark:  mark,
				Desc:  v.Desc,
				Parts: ps,
			}))
			continue
		}

		_, err = m.WithContext(s.ctx).Where(m.ID.Eq(module.ID)).UpdateSimple(m.Desc.Value(v.Desc), m.Parts.Value(ps))
		if err != nil {
			return
		}
	}

	if len(add) > 0 {
		err = m.WithContext(s.ctx).Create(add...)
		if err != nil {
			return
		}
	}

}

type langTextMark struct {
	ctx    context.Context
	taskId string
}

// 语言文案标识，用中文来做文案标识
func (s langTextMark) langTextMark() {
	dir, _ := os.Getwd()

	var path string
	if consts.RunTest {
		path = fmt.Sprintf("../../../asset/campaign/lang")
	} else {
		path = fmt.Sprintf("%s/asset/campaign/lang", dir)
	}

	var err error
	tx := dao.Q.Begin()
	defer func() {
		if err != nil {
			app.Logger.Error(s.ctx, fmt.Sprintf("语言包处理有异常:%v", err))
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	b, err := os.ReadFile(path + "/zh.json")
	if err != nil {
		return
	}

	m := tx.LangTextMark

	var ddd = make(map[string]string)
	_ = json.Unmarshal(b, &ddd)

	var list []*model.LangTextMark
	list, err = m.WithContext(s.ctx).Find()
	if err != nil {
		return
	}

	var lm = make(map[string]*model.LangTextMark)
	for _, v := range list {
		lm[v.Mark] = v
	}

	var add []*model.LangTextMark
	for mark, text := range ddd {
		ltm, ok := lm[mark]
		if !ok {
			add = append(add, withdefault.LangTextMark(&model.LangTextMark{
				Mark: mark,
				Text: text,
			}))
			continue
		}

		if ltm.Text != text {
			_, err = m.WithContext(s.ctx).Where(m.ID.Eq(ltm.ID)).UpdateSimple(m.Text.Value(text))
			if err != nil {
				return
			}
		}
	}

	if len(add) > 0 {
		err = m.WithContext(s.ctx).Create(add...)
		if err != nil {
			return
		}
	}

}

type checkLang struct {
	ctx    context.Context
	taskId string
}

func (s checkLang) checkLang() {
	path := fmt.Sprintf("../../../asset/campaign/lang")
	b, err := os.ReadFile(path + "/zh.json")
	if err != nil {
		return
	}

	var ddd = make(map[string]string)
	_ = json.Unmarshal(b, &ddd)

	entrys, err := os.ReadDir(path)
	if err != nil {
		return
	}

	for _, entry := range entrys {
		if !strings.HasSuffix(entry.Name(), ".json") {
			continue
		}
		mark, _ := strings.CutSuffix(entry.Name(), ".json")

		_, ok := mtype.MarkToLangType[mark]
		if !ok {
			continue
		}

		var c []byte
		c, err = os.ReadFile(path + "/" + entry.Name())
		if err != nil {
			return
		}

		var fff = make(map[string]string)
		_ = json.Unmarshal(c, &fff)

		for k := range fff {
			if _, ok1 := ddd[k]; !ok1 {
				fmt.Printf("[%s]文件的[%s]不存在于zh\n", entry.Name(), k)
			}
		}

		for k := range ddd {
			if _, ok1 := fff[k]; !ok1 {
				fmt.Printf("[%s]不存在于[%s]\n", k, entry.Name())
			}
		}
	}

}

type fillLang struct {
	ctx    context.Context
	taskId string
}

func (s fillLang) fillLang() {

	var lts = []int8{
		mtype.FissionLangTypeZh,
		mtype.FissionLangTypeEn,
		mtype.FissionLangTypeRu,
		mtype.FissionLangTypeFr,
		mtype.FissionLangTypePt,
		mtype.FissionLangTypeJa,
		mtype.FissionLangTypeDe,
		mtype.FissionLangTypeEs,
		mtype.FissionLangTypeId,
		mtype.FissionLangTypeIt,
		mtype.FissionLangTypeTr,
		mtype.FissionLangTypeAr,
		mtype.FissionLangTypeKo,
		mtype.FissionLangTypeTh,
	}

	m := dao.FissionTempGroup
	list, err := m.WithContext(s.ctx).Find()

	tx := dao.Q.Begin()
	defer func() {
		if err != nil {
			app.Logger.Error(s.ctx, fmt.Sprintf("语言包处理有异常:%v", err))
			_ = tx.Rollback()
			return
		}
		_ = tx.Commit()
	}()

	tempM := tx.FissionTemp
	imgM := tx.FissionTempImage
	for _, v := range list {
		var tempList []*model.FissionTemp
		tempList, err = tempM.WithContext(s.ctx).Where(tempM.GroupID.Eq(v.ID), tempM.LangType.In(lts...)).Find()
		if err != nil {
			return
		}

		var old = make(map[int8]*model.FissionTemp)
		var ch bool
		for _, temp := range tempList {
			if temp.LangType == mtype.FissionLangTypeZh {
				ch = true
			}
			old[temp.LangType] = temp
		}

		if len(tempList) == 0 || !ch {
			continue
		}

		var add []*model.FissionTemp
		for _, lt := range lts {
			if _, ok := old[lt]; ok {
				continue
			}

			one := withdefault.FissionTemp(&model.FissionTemp{
				FissionID: v.FissionID,
				GroupID:   v.ID,
				LangType:  lt,
				TextType:  mtype.FissionLangTypeTextType[lt],
			})

			add = append(add, one)
		}

		if len(add) == 0 {
			continue
		}

		err = tempM.WithContext(s.ctx).Create(add...)
		if err != nil {
			return
		}
		var images []*model.FissionTempImage
		enTemp, ok := old[mtype.FissionLangTypeEn]
		if ok {
			var useImg []*model.FissionTempImage
			useImg, err = dao.FissionTempImage.WithContext(s.ctx).Where(dao.FissionTempImage.TempID.Eq(enTemp.ID)).Find()
			if err != nil {
				return
			}
			for _, temp := range add {
				for _, image := range useImg {
					images = append(images, withdefault.FissionTempImage(&model.FissionTempImage{
						TempID: temp.ID,
						Mark:   image.Mark,
						Val:    image.Val,
						Desc:   image.Desc,
					}))
				}
			}
		} else {
			for _, temp := range add {
				images = append(images, withdefault.FissionTempImage(&model.FissionTempImage{
					TempID: temp.ID,
					Mark:   "main",
					Val:    fmt.Sprintf("ftg/%s/main_en.png", v.Mark),
					Desc:   "活动主图",
				}), withdefault.FissionTempImage(&model.FissionTempImage{
					TempID: temp.ID,
					Mark:   "wechat",
					Val:    fmt.Sprintf("ftg/%s/main_en.png", v.Mark),
					Desc:   "微信引导图",
				}), withdefault.FissionTempImage(&model.FissionTempImage{
					TempID: temp.ID,
					Mark:   "wechat_bg",
					Val:    fmt.Sprintf("ftg/%s/main_en.png", v.Mark),
					Desc:   "微信引导图背景",
				}), withdefault.FissionTempImage(&model.FissionTempImage{
					TempID: temp.ID,
					Mark:   "download",
					Val:    fmt.Sprintf("ftg/%s/main_en.png", v.Mark),
					Desc:   "下载引导图",
				}))

			}
		}

		if len(images) > 0 {
			err = imgM.WithContext(s.ctx).Create(images...)
			if err != nil {
				return
			}
		}
	}
}

type openAd struct {
	ctx           context.Context
	taskId        string
	ProjectId     int64  `json:"project_id"`
	ProjectHashId string `json:"project_hash_id"`
	GaShowId      string `json:"ga_show_id"`
	GaEmbedId     string `json:"ga_embed_id"`
	GaDoubleId    string `json:"ga_double_id"`
	Prod          bool   `json:"prod"`
}

func (s openAd) openAd() {
	project, err := finder.Project(s.ctx, s.ProjectId, s.ProjectHashId)
	if err != nil {
		return
	}

	if project == nil {
		app.FeishuNormalSend(fmt.Sprintf("[%d_%s] 找不到对应的项目", s.ProjectId, s.ProjectHashId))
		return
	}

	ads, err := cache.NewProjectAd(s.ctx).FindByProjectId(project.ID)
	if err != nil {
		return
	}

	showId := utils.Ternary[string](s.Prod, s.GaShowId, "6366208850")
	embedId := utils.Ternary[string](s.Prod, s.GaEmbedId, "8800800505")
	doubleId := utils.Ternary[string](s.Prod, s.GaDoubleId, "6174637163")
	status := utils.Ternary[int8](s.Prod, mtype.ProjectAdStatusProd, mtype.ProjectAdStatusTest)

	if ads == nil {
		ads = withdefault.ProjectAd(&model.ProjectAd{
			ProjectID:  project.ID,
			OpenAd:     mtype.Yes,
			CampaignAd: mtype.Yes,
			GaShowID:   showId,
			GaEmbedID:  embedId,
			GaDoubleID: doubleId,
			AdStatus:   status,
		})

		err = dao.ProjectAd.WithContext(s.ctx).Create(ads)
		if err != nil {
			return
		}

	} else {
		m := dao.ProjectAd
		_, err = m.WithContext(s.ctx).Where(m.ID.Eq(ads.ID)).UpdateSimple(
			m.GaShowID.Value(showId),
			m.GaEmbedID.Value(embedId),
			m.GaDoubleID.Value(doubleId),
			m.AdStatus.Value(status),
		)

		if err != nil {
			return
		}
		_ = cache.NewProjectAd(s.ctx).Clear(ads)
	}

	app.FeishuNormalSend(fmt.Sprintf(
		"[%d_%s]配置广告成功， 谷歌展示广告id：%s， 谷歌内嵌广告id：%s，谷歌多重广告id：%s，状态：%d",
		s.ProjectId,
		s.ProjectHashId,
		showId,
		embedId,
		doubleId,
		status,
	))

}

type openCloseCopyShare struct {
	ctx           context.Context
	taskId        string
	ProjectId     int64  `json:"project_id"`
	ProjectHashId string `json:"project_hash_id"`
	Open          int8   `json:"open"`
}

func (s openCloseCopyShare) openCloseCopyShare() {
	project, err := finder.Project(s.ctx, s.ProjectId, s.ProjectHashId)
	if err != nil {
		return
	}

	if project == nil {
		app.FeishuNormalSend(fmt.Sprintf("[%d_%s] 找不到对应的项目", s.ProjectId, s.ProjectHashId))
		return
	}

	m := dao.Project
	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(project.ID)).UpdateSimple(m.CloseCopyShare.Value(s.Open))
	if err != nil {
		return
	}

	_ = cache.NewProject(s.ctx).Clear(project)
	app.Redis.Cache.Del(s.ctx,
		fmt.Sprintf("certified:project:project_show_id:%d", project.ID),
		fmt.Sprintf("certified:project:project_show_hash:%s", project.HashID),
	)
	app.FeishuNormalSend(fmt.Sprintf("[%d_%s]项目关闭社媒状态修改为[%s]", s.ProjectId, s.ProjectHashId, utils.Ternary(s.Open == mtype.Yes, "开启", "关闭")))

}

type openPushLadder struct {
	ctx           context.Context
	taskId        string
	ProjectId     int64  `json:"project_id"`
	ProjectHashId string `json:"project_hash_id"`
	Open          int8   `json:"open"`
}

func (s openPushLadder) openPushLadder() {
	project, err := finder.Project(s.ctx, s.ProjectId, s.ProjectHashId)
	if err != nil {
		return
	}

	if project == nil {
		app.FeishuNormalSend(fmt.Sprintf("[%d_%s] 找不到对应的项目", s.ProjectId, s.ProjectHashId))
		return
	}

	m := dao.Project
	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(project.ID)).UpdateSimple(m.PushLadder.Value(s.Open))
	if err != nil {
		return
	}

	_ = cache.NewProject(s.ctx).Clear(project)
	app.Redis.Cache.Del(s.ctx,
		fmt.Sprintf("certified:project:project_show_id:%d", project.ID),
		fmt.Sprintf("certified:project:project_show_hash:%s", project.HashID),
	)
	app.FeishuNormalSend(fmt.Sprintf("[%d_%s]项目代理推送状态修改为[%s]", s.ProjectId, s.ProjectHashId, utils.Ternary(s.Open == mtype.Yes, "开启", "关闭")))

}

type openCert struct {
	ctx           context.Context
	taskId        string
	ProjectId     int64  `json:"project_id"`
	ProjectHashId string `json:"project_hash_id"`
	Open          int8   `json:"open"`
}

func (s openCert) openCert() {
	project, err := finder.Project(s.ctx, s.ProjectId, s.ProjectHashId)
	if err != nil {
		return
	}

	if project == nil {
		app.FeishuNormalSend(fmt.Sprintf("[%d_%s] 找不到对应的项目", s.ProjectId, s.ProjectHashId))
		return
	}

	m := dao.Project
	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(project.ID)).UpdateSimple(m.FissionCertType.Value(s.Open))
	if err != nil {
		return
	}

	_ = cache.NewProject(s.ctx).Clear(project)
	app.Redis.Cache.Del(s.ctx,
		fmt.Sprintf("certified:project:project_show_id:%d", project.ID),
		fmt.Sprintf("certified:project:project_show_hash:%s", project.HashID),
	)
	app.FeishuNormalSend(fmt.Sprintf("[%d_%s]项目认证状态修改为[%s]", s.ProjectId, s.ProjectHashId, utils.Ternary(s.Open == mtype.Yes, "开启", "关闭")))

}

// 奖品库存缓存清理
type clearStock struct {
	ctx        context.Context
	taskId     string
	CampaignId int64 `json:"campaign_id"`
}

func (s clearStock) clearStock() {
	var err error
	defer func() {
		if err != nil {
			app.Logger.Error(s.ctx, fmt.Sprintf("fixData逻辑问题%v", err))
			return
		}
	}()
	cpn, err := finder.Campaign(s.ctx, s.CampaignId)
	if err != nil || cpn == nil {
		return
	}

	m := dao.FissionCampaignReward

	list, err := m.WithContext(s.ctx).Where(m.CampaignID.Eq(cpn.ID), m.IsDel.Eq(mtype.No)).Find()
	if err != nil {
		return
	}

	var ids []int64

	for _, v := range list {
		ids = append(ids, v.ID)
	}

	type num struct {
		RewardId int64
		Num      int64
	}

	recordM := dao.FissionRewardRecord.SubTable(cpn.ID)
	var nums []*num
	err = recordM.WithContext(s.ctx).Select(recordM.RewardID, recordM.ID.Count().As("num")).Where(recordM.RewardID.In(ids...)).Group(recordM.RewardID).Scan(&nums)
	if err != nil {
		return
	}

	var idMap = make(map[int64]int64)
	for _, v := range nums {
		idMap[v.RewardId] = v.Num
	}

	var preIdMap = make(map[int64]int64)
	switch cpn.FissionID {
	case consts.IdKeep:
		var preNums []*num
		preM := dao.FissionKeep
		err = preM.WithContext(s.ctx).Select(preM.RewardID, preM.ID.Count().As("num")).Where(preM.RewardID.In(ids...)).Group(preM.RewardID).Scan(&nums)
		if err != nil {
			return
		}

		for _, v := range preNums {
			preIdMap[v.RewardId] = v.Num
		}

	}

	for _, v := range list {
		n, _ := app.Redis.Cache.Get(s.ctx, ckey.FissionCampaignRewardPool(v.ID)).Int64()
		n1, _ := app.Redis.Cache.Get(s.ctx, ckey.FissionCampaignRewardUseStock(v.ID)).Int64()

		app.FeishuNormalSend("配置库存：%d, 实际发放库存： %d，redis记录库存池剩余库存：%d，已使用库存： %d", v.Stock, idMap[v.ID], n, n1)

		app.Redis.Cache.Del(s.ctx, ckey.FissionCampaignRewardPool(v.ID), ckey.FissionCampaignRewardUseStock(v.ID))

		pn, _ := app.Redis.Cache.Get(s.ctx, ckey.FissionCampaignPreRewardPool(v.ID)).Int64()
		pn1, _ := app.Redis.Cache.Get(s.ctx, ckey.FissionCampaignRewardPreUseStock(v.ID)).Int64()

		app.FeishuNormalSend("配置预备库存：%d, 实际发放预备库存： %d，redis记录预备库存池剩余预备库存：%d，已使用预备库存： %d", v.Stock, preIdMap[v.ID], pn, pn1)

		app.Redis.Cache.Del(s.ctx, ckey.FissionCampaignPreRewardPool(v.ID), ckey.FissionCampaignRewardPreUseStock(v.ID))
	}

}

type resetAdsInit struct {
	ctx    context.Context
	taskId string
	Url    string `json:"url"`
}

// 重制广告配置
func (s resetAdsInit) resetAdsInit() {

	resp, err := app.EtcdCli.Put(s.ctx, app.EtcdConfig+"/ads", s.Url)
	if err != nil {
		app.FeishuNormalSend("重制广告配置错误：%v", err)
		return
	}

	app.FeishuNormalSend("重制广告配置成功, Header: %+v, PrevKv: %+v", resp.Header, resp.PrevKv)
	return
}

type taskCenterLang struct {
	ctx     context.Context
	taskId  string
	Refresh int32 `json:"refresh"`
	Ver     int64 `json:"ver"`
}

// 重制广告配置
func (s taskCenterLang) taskCenterLang() {
	var err error
	defer func() {
		if err != nil {
			app.Logger.Error(s.ctx, fmt.Sprintf("语言包处理有异常:%v", err))
			return
		}
	}()

	dir, _ := os.Getwd()

	var path string
	if consts.RunTest {
		path = fmt.Sprintf("../../../asset/taskcenter")
	} else {
		path = fmt.Sprintf("%s/asset/taskcenter", dir)
	}

	client, err := oss.New("https://oss-cn-shenzhen.aliyuncs.com", "LTAI5tNvMLF181bTb3qCZxk4", "9HXWh6yTXhbBQ7WaMkS1c3o0UNtl7A")
	if err != nil {
		return
	}

	// 填写存储空间名称，例如examplebucket。
	bucket, err := client.Bucket("client-project-resource")
	if err != nil {
		return
	}

	var yunPath = "taskcenter/lang"
	var fileNames []string
	files, _ := os.ReadDir(path)
	for _, v := range files {
		name := fmt.Sprintf("%s/%s", yunPath, v.Name())
		err = bucket.PutObjectFromFile(name, fmt.Sprintf("%s/%s", path, v.Name()))
		if err != nil {
			return
		}

		fileNames = append(fileNames, name)
	}

	if s.Refresh == 0 {
		app.FeishuNormalSend("任务中心语言包处理成功，仅更新远端语言包")
		return
	}

	b, _ := jsonm.MarshalToString(map[string]interface{}{
		"ver":  utils.STernary[int64](s.Ver, 0, time.Now().Unix()),
		"path": fmt.Sprintf("%s/%s", config.Config.Upload.Host, yunPath),
	})

	resp, err := app.EtcdCli.Put(s.ctx, "/taskcenter/lang", b)
	if err != nil {
		return
	}

	app.FeishuNormalSend("任务中心语言包处理成功, Header: %+v, PrevKv: %+v, data: %s, 文件内容：%+v", resp.Header, resp.PrevKv, b, fileNames)
	return
}

type clearCpn struct {
	ctx            context.Context
	CampaignHashId string `json:"campaign_hash_id"`
}

// 清楚活动的用户设备数据
func (s clearCpn) clearCpn() {
	d := dao.Q.Begin()
	var err error
	defer func() {
		if err != nil {
			app.Logger.Error(s.ctx, fmt.Sprintf("clearCpn逻辑问题%v", err))
			d.Rollback()
			return
		}
		d.Commit()
	}()

	cpn, err := finder.Campaign(s.ctx, s.CampaignHashId)
	if err != nil || cpn == nil {
		return
	}

	project, err := finder.Project(s.ctx, cpn.ProjectID)
	if err != nil {
		return
	}

	if project == nil || project.IsDel == mtype.Yes || project.IsTest == mtype.No {
		return
	}

	m := d.FissionUser.SubTable(cpn.ID)

	list, err := m.WithContext(s.ctx).Where(m.CampaignID.Eq(cpn.ID)).Limit(50).Find()
	if err != nil {
		return
	}

	if len(list) == 0 {
		return
	}

	cc := cache.NewFissionUser(s.ctx, cpn.ID)
	var keys []string
	var ids []int64
	for _, v := range list {
		ids = append(ids, v.ID)

		if v.DeviceID != "" {
			keys = append(keys, cc.IdxKey("campaign_id", v.CampaignID, "device_id", v.DeviceID))
		}

		if v.SubUserID != "" {
			keys = append(keys, cc.IdxKey("campaign_id", v.CampaignID, "sub_user_id", v.SubUserID))
		}

		if v.DeviceID != "" {
			_, _ = app.NewDeepLinkDevice().DeleteDevice(s.ctx, &ddevicepb.DeleteDeviceReq{
				Code:      v.DeviceID,
				ProjectId: project.ID,
			})
		}
	}

	res, err := m.WithContext(s.ctx).Where(m.ID.In(ids...)).Delete()
	if err != nil {
		return
	}

	statM := d.FissionUserStat
	resStat, err := statM.WithContext(s.ctx).Where(statM.UserID.In(ids...)).Delete()
	if err != nil {
		return
	}

	_ = cc.Clear(list...)

	if len(keys) > 0 {
		app.Redis.Cache.Del(s.ctx, keys...)
	}

	app.FeishuNormalSend("用户数据删除：%d，统计数据删除：%d", res.RowsAffected, resStat.RowsAffected)
}

type openTest struct {
	ctx           context.Context
	taskId        string
	ProjectId     int64  `json:"project_id"`
	ProjectHashId string `json:"project_hash_id"`
	Open          int8   `json:"open"`
}

// 把项目变成测试项目
func (s openTest) openTest() {
	project, err := finder.Project(s.ctx, s.ProjectId, s.ProjectHashId)
	if err != nil {
		return
	}

	if project == nil {
		app.FeishuNormalSend(fmt.Sprintf("[%d_%s] 找不到对应的项目", s.ProjectId, s.ProjectHashId))
		return
	}

	m := dao.Project
	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(project.ID)).UpdateSimple(m.IsTest.Value(s.Open))
	if err != nil {
		return
	}

	_ = cache.NewProject(s.ctx).Clear(project)
	app.Redis.Cache.Del(s.ctx,
		fmt.Sprintf("certified:project:project_show_id:%d", project.ID),
		fmt.Sprintf("certified:project:project_show_hash:%s", project.HashID),
	)
	app.FeishuNormalSend(fmt.Sprintf("[%d_%s]项目测试状态修改为[%s]", s.ProjectId, s.ProjectHashId, utils.Ternary(s.Open == mtype.Yes, "开启", "关闭")))

}

type getCache struct {
	ctx    context.Context
	taskId string
	Key    string `json:"key"`
	Cmd    string `json:"cmd"`
}

// 把项目变成测试项目
func (s getCache) getCache() {

	var v string
	switch s.Cmd {
	case "hget":
		r, _ := app.Redis.Cache.HGetAll(s.ctx, s.Key).Result()
		v, _ = jsonm.MarshalToString(r)
	case "del":
		r, _ := app.Redis.Cache.Del(s.ctx, s.Key).Result()
		v = fmt.Sprintf("del:%d rows", r)
	default:
		v, _ = app.Redis.Cache.Get(s.ctx, s.Key).Result()
	}

	app.FeishuNormalSend("key:%s value:%s", s.Key, utils.STernary[string](v, "", "没有查到数据哦"))

}

type printAllLog struct {
	ctx    context.Context
	taskId string
	Open   int32 `json:"open"`
}

// 把项目变成测试项目
func (s printAllLog) printAllLog() {

	switch s.Open {
	case 1:
		consts.PrintAllLog = true
	default:
		consts.PrintAllLog = false
	}

	app.FeishuNormalSend(fmt.Sprintf("全量日志状态修改为[%s]", utils.Ternary[string](s.Open == mtype.Yes, "开启", "关闭")))
}

type collectSlowLog struct {
	ctx    context.Context
	taskId string
	Open   int32 `json:"open"`
}

// 把项目变成测试项目
func (s collectSlowLog) collectSlowLog() {
	defer app.TryCatch(s.ctx, "收集慢日志状态修改")

	switch s.Open {
	case 1:
		if consts.CollectSlowLog {
			return
		}

		consts.CollectSlowLog = true
		printer.Slow.Run()
	default:
		if !consts.CollectSlowLog {
			return
		}
		consts.CollectSlowLog = false
		printer.Slow.Stop()
	}

	app.FeishuNormalSend(fmt.Sprintf("收集慢日志状态修改为[%s]", utils.Ternary[string](s.Open == mtype.Yes, "开启", "关闭")))
}

type setLangParts struct {
	ctx    context.Context
	taskId string
	Mark   string `json:"mark"`
	Parts  string `json:"parts"`
}

func (s setLangParts) setLangParts() {
	m := dao.FissionTempGroup
	g, err := m.WithContext(s.ctx).Where(m.Mark.Eq(s.Mark)).Take()
	if err != nil || g == nil || g.LangParts == s.Parts {
		return
	}

	_, err = m.WithContext(s.ctx).Where(m.ID.Eq(g.ID)).UpdateSimple(m.LangParts.Value(s.Parts))
	if err != nil {
		return
	}

	_ = cache.NewFissionTempGroup(s.ctx).Clear(g)

	app.FeishuNormalSend(fmt.Sprintf("模版组[%s]语言包修改过成功[%s]->[%s]", g.Mark, g.LangParts, s.Parts))
}

type openLvApi struct {
	ctx       context.Context
	taskId    string
	CompanyId int64 `json:"company_id"`
	Open      int32 `json:"open"`
}

func (s openLvApi) openLvApi() {

	made, err := cache.NewCompanyMade(s.ctx).FindByUniqId(s.CompanyId, mtype.CompanyMadeMarkLvApi)
	if err != nil {
		return
	}

	if made == nil && s.Open == 1 {
		err = provider.NewCompanyMade(s.ctx, s.CompanyId).SetMake(mtype.CompanyMadeMarkLvApi, "")

		app.FeishuNormalSend(fmt.Sprintf("企业[%d]开启[%s]组件", s.CompanyId, mtype.CompanyMadeMarkLvApi))

		return
	}

	if made != nil && s.Open == 0 {
		err = provider.NewCompanyMade(s.ctx, s.CompanyId).Del(mtype.CompanyMadeMarkLvApi)

		app.FeishuNormalSend(fmt.Sprintf("企业[%d]关闭[%s]组件", s.CompanyId, mtype.CompanyMadeMarkLvApi))

		return
	}

}

type openFissionTemp struct {
	ctx       context.Context
	taskId    string
	CompanyId int64    `json:"company_id"`
	Temp      []string `json:"temp"`
}

func (s openFissionTemp) openFissionTemp() {

	made, err := cache.NewCompanyMade(s.ctx).FindByUniqId(s.CompanyId, mtype.CompanyMadeMarkFissionTemp)
	if err != nil {
		return
	}

	if len(s.Temp) > 0 {
		err = provider.NewCompanyMade(s.ctx, s.CompanyId).SetMake(mtype.CompanyMadeMarkFissionTemp, s.Temp)

		app.FeishuNormalSend(fmt.Sprintf("企业[%d]开启[%s]组件, 模板：%+v", s.CompanyId, mtype.CompanyMadeMarkFissionTemp, s.Temp))

		return
	}

	if made != nil && len(s.Temp) == 0 {
		err = provider.NewCompanyMade(s.ctx, s.CompanyId).Del(mtype.CompanyMadeMarkFissionTemp)

		app.FeishuNormalSend(fmt.Sprintf("企业[%d]关闭[%s]组件", s.CompanyId, mtype.CompanyMadeMarkFissionTemp))

		return
	}

}

type pushWaitReward struct {
	ctx        context.Context
	taskId     string
	CampaignId int64 `json:"campaign_id"`
}

func (s pushWaitReward) pushWaitReward() {

	m := dao.FissionRewardRecord.SubTable(s.CampaignId)
	list, err := m.WithContext(s.ctx).Where(m.CampaignID.Eq(s.CampaignId), m.Status.Eq(mtype.FissionRewardRecordStatusWait)).Find()
	if err != nil {
		return
	}

	for _, record := range list {
		producer.NewCampaignNotice(s.ctx).CampaignRewardNotify(types.CampaignRewardNotify{
			CampaignId:   record.CampaignID,
			UserId:       record.UserID,
			UserRewardId: record.ID,
		})
	}
}

type statCampaign struct {
	ctx    context.Context
	taskId string

	BehaviorType int32             `json:"behavior_type"`
	IpAddress    string            `json:"ip_address"`
	UserID       string            `json:"user_id"`
	DeviceID     string            `json:"device_id"`
	Event        string            `json:"event"`
	EventData    []types.EventData `json:"event_data"`
	ProjectID    int64             `json:"project_id"`
	Hid          int64             `json:"hid"`
	TsHID        string            `json:"ts_hid"`   //任务中心hash_id
	Language     string            `json:"language"` // 语言
}

func (s statCampaign) statCampaign() {
	p := producer.NewStatCampaign(s.ctx)

	p.StatCampaign(types.StatCampaignValue{
		BehaviorType: s.BehaviorType,
		BehaviorTime: time.Now().Unix(),
		IpAddress:    s.IpAddress,
		Os:           "ios",
		OsVersion:    "16.3",
		DeviceModel:  "iphone",
		DeviceID:     s.DeviceID,
		UserID:       s.UserID,
		Event:        s.Event,
		EventData:    s.EventData,
		ProjectID:    s.ProjectID,
		Language:     s.Language,
	})

}