package service

import (
	"fmt"

	"crazy-fox-backend-api/model"
	"crazy-fox-backend-api/repo"
	"crazy-fox-backend-api/repo/okeys"
	"crazy-fox-backend-api/utils"

	"github.com/dablelv/go-huge-util/conv"
	"github.com/pkg/errors"
	"github.com/xuri/excelize/v2"
	"golang.org/x/sync/errgroup"
)

// signInService 签到模块服务
type signInService struct{}

const (
	SignInTypeWeekly   = "weekly"
	SignInTypeProgress = "progress"
)

func (This *signInService) BasicConf() (basicConf model.SignInBasicConf, err error) {

	basicConf.Options = Config.GetSkinOptions("signIn")

	basicConf.Theme, err = Config.GetSystemConf(model.ItemTitle{Item: "Game", Title: "signInDir"})
	if err != nil {
		return basicConf, errors.WithStack(err)
	}

	return
}

func (This *signInService) BasicConfEdit(req *model.SignInBasicConf) error {

	sysConf := model.TSystemConfig{
		ItemTitle: model.ItemTitle{Item: "Game", Title: "signInDir"},
		Content:   req.Theme,
		Memo:      "签到主题配置",
	}

	if err := Config.UpdateSystemConf(sysConf); err != nil {
		return errors.WithStack(err)
	}

	return nil
}

func (This *signInService) PrizeConf(typ string) ([]model.TSignInWeeklyConfig, error) {

	if !utils.InSlice(typ, []string{SignInTypeWeekly, SignInTypeProgress}) {
		return nil, errors.New("type error :" + typ)
	}

	conf := repo.SignIn.GetConfByType(typ)

	return conf, nil
}

func (This *signInService) PrizeConfEdit(req []model.TSignInWeeklyConfig) error {

	if len(req) == 0 {
		return errors.New("配置列表为空")
	}

	typ := req[0].Type
	if !utils.InSlice(typ, []string{SignInTypeWeekly, SignInTypeProgress}) {
		return errors.New("type error :" + typ)
	}

	var countDays int
	var dayArr []int64
	if typ == SignInTypeWeekly {
		countDays = 7
		dayArr = []int64{1, 2, 3, 4, 5, 6, 7}
	} else {
		countDays = 4
		dayArr = []int64{8, 15, 22, 30}
	}

	for _, config := range req {
		if len(config.PrizeJson) != countDays {
			return errors.New(fmt.Sprintf("配置的总天数为%d, 期望总天数为%d", len(config.PrizeJson), countDays))
		}

		for _, prize := range config.PrizeJson {
			if !utils.InSlice(prize.Day, dayArr) {
				return errors.New(fmt.Sprintf("配置的天数为%d, 期望天数列表为%v", prize.Day, dayArr))
			}
		}
	}

	if _, err := repo.ReplaceStruct[model.TSignInWeeklyConfig](req, repo.WithKeys("id"), repo.WithWhere("Where type = ?", typ)); err != nil {
		return errors.WithStack(err)
	}

	// 删除缓存
	repo.DelCache(okeys.SignInConfig(typ))

	return nil
}

func (This *signInService) handlePrizeConfImport(excelInfo [][][]string, params map[string]any) error {

	if len(excelInfo) < 2 {
		return errors.New("工作表数量不匹配")
	}

	typ := conv.ToAny[string](params["type"])
	if typ == "" {
		return errors.New("字段type 为空")
	}

	var (
		err      error
		eg       errgroup.Group
		showConf []model.TSignInWeeklyConfig
		prizeMap map[int64][]model.SignInPrize
	)

	eg.Go(func() error {
		showConf, err = This.ParsePrizeSheet1(excelInfo[0], typ)
		if err != nil {
			return errors.Wrap(err, "基础配置 工作表解析失败")
		}
		return nil
	})

	eg.Go(func() error {
		prizeMap, err = This.ParsePrizeSheet2(excelInfo[1])
		if err != nil {
			return errors.Wrap(err, "奖励配置 工作表解析失败")
		}
		return nil
	})

	if err = eg.Wait(); err != nil {
		return errors.WithStack(err)
	}

	if err = This.packagePrizeConf(showConf, prizeMap); err != nil {
		return errors.WithStack(err)
	}

	if err = This.PrizeConfEdit(showConf); err != nil {
		return errors.WithStack(err)
	}

	return err
}

func (This *signInService) ParsePrizeSheet1(sheet [][]string, typ string) (confArr []model.TSignInWeeklyConfig, err error) {

	confArr = make([]model.TSignInWeeklyConfig, 0, len(sheet))
	for rowIdx := 1; rowIdx < len(sheet); rowIdx++ {

		var (
			ssGroup    string
			ssGroupArr model.SsGroup
			one        model.TSignInWeeklyConfig
		)

		// 解析行配置
		if err = utils.DestructAssign(sheet[rowIdx], &one.Id, &one.MinLevel, &one.MaxLevel, &ssGroup); err != nil {
			return confArr, errors.WithStack(err)
		}

		if ssGroupArr, err = Props.ParseSsGroup(ssGroup); err != nil {
			return confArr, errors.Wrap(err, fmt.Sprintf("第%d行", rowIdx+1))
		}

		one.SsGroup = ssGroupArr.Shushu
		one.Type = typ

		confArr = append(confArr, one)
	}

	return
}
func (This *signInService) ParsePrizeSheet2(sheet [][]string) (confMap map[int64][]model.SignInPrize, err error) {

	confMap = make(map[int64][]model.SignInPrize, len(sheet))
	for rowIdx := 1; rowIdx < len(sheet); rowIdx++ {

		var (
			id        int64
			one       model.SignInPrize
			rewardArr = make([]model.ExcelPrize, 5)
		)

		// 解析行配置
		if err = utils.DestructAssign(sheet[rowIdx], &id, &one.Day, &rewardArr); err != nil {
			return confMap, errors.WithStack(err)
		}

		// 转换奖励格式
		if one.Prize, err = Props.MultiParsePropPrize(rewardArr); err != nil {
			return confMap, errors.WithStack(err)
		}

		confMap[id] = append(confMap[id], one)
	}

	return
}

func (This *signInService) packagePrizeConf(confArr []model.TSignInWeeklyConfig, prizeMap map[int64][]model.SignInPrize) error {

	var Ok bool
	for i := 0; i < len(confArr); i++ {
		one := &confArr[i]
		if one.PrizeJson, Ok = prizeMap[one.Id]; !Ok {
			return errors.New(fmt.Sprintf("唯一ID: %d 未配置奖励", i))
		}
		one.Id = 0
		one.OtherJson = []any{}
	}

	return nil
}

func (This *signInService) handlePrizeConfExport(xlsx *excelize.File, fileName *string, params map[string]any) error {

	typ := conv.ToAny[string](params["type"])
	if typ == "" {
		return errors.New("字段type 为空")
	}

	list, err := This.PrizeConf(typ)
	if err != nil {
		return errors.WithStack(err)
	}

	// 工作表1
	sheetName := "基础配置"
	if err = xlsx.SetSheetName("Sheet1", sheetName); err != nil {
		return errors.WithStack(err)
	}

	if err = This.fillSheet1(xlsx, sheetName, list); err != nil {
		return errors.WithStack(err)
	}

	// 工作表2
	sheetName = "奖励配置"
	if _, err = xlsx.NewSheet(sheetName); err != nil {
		return errors.WithStack(err)
	}

	if err = This.fillSheet2(xlsx, sheetName, list); err != nil {
		return errors.WithStack(err)
	}

	*fileName = utils.Ternary(typ == SignInTypeWeekly, "七天签到", "签到进度") + "奖励配置"

	return err
}

func (This *signInService) fillSheet1(xlsx *excelize.File, sheetName string, list []model.TSignInWeeklyConfig) error {
	titles := []string{"唯一ID", "等级下限", "等级上限", "数数分组"}
	if err := xlsx.SetSheetRow(sheetName, "A1", &titles); err != nil {
		return errors.WithStack(err)
	}

	for i, oneInfo := range list {
		ssGroupStr, err := Props.RestoreSsGroup(model.SsGroup{Shushu: oneInfo.SsGroup})
		if err != nil {
			return errors.WithStack(err)
		}

		rowSlice := []any{i + 1, oneInfo.MinLevel, oneInfo.MaxLevel, ssGroupStr}

		if err = xlsx.SetSheetRow(sheetName, fmt.Sprintf("A%d", i+2), &rowSlice); err != nil {
			return errors.WithStack(err)
		}
	}

	return nil
}

func (This *signInService) fillSheet2(xlsx *excelize.File, sheetName string, list []model.TSignInWeeklyConfig) error {
	titles := []string{"唯一ID", "天数"}
	for i := 1; i <= 5; i++ {
		titles = append(titles, fmt.Sprintf("奖励%d", i), "是否固定值(非金币奖励均为固定值)", "数值(宝箱等部分奖励数量固定为1)")
	}
	if err := xlsx.SetSheetRow(sheetName, "A1", &titles); err != nil {
		return errors.WithStack(err)
	}

	rowNum := 2
	for i, oneInfo := range list {
		for _, prize := range oneInfo.PrizeJson {
			prizes, err := Props.MultiParseExcelPrize(prize.Prize)
			if err != nil {
				return errors.WithStack(err)
			}

			rowSlice := utils.Destruct(i+1, prize.Day, prizes)
			if err = xlsx.SetSheetRow(sheetName, fmt.Sprintf("A%d", rowNum), &rowSlice); err != nil {
				return errors.WithStack(err)
			}
			rowNum++
		}
	}

	return nil
}