package configs

import (
	"apigame/util/util-lx/lxalilog"
	"encoding/json"
	"errors"
	"fmt"
	"strings"
)

// Decode 解析配置原始数据
func (c *CardActivityConfig) Decode(gameId string, configRaw *CardActivityConfigRaw) {
	c.GameId = gameId
	c.Raw = configRaw

	c.Id = configRaw.Id
	c.OpenLevel = configRaw.OpenLevel
	c.PreviewTime = configRaw.PreviewTime
	c.StartTime = configRaw.StartTime
	c.EndTime = configRaw.EndTime
	c.Round = configRaw.Round

	c.Awards = make(map[string]string)
	c.AlbumConfig = make(map[int]AlbumConfig)
	c.CardConfig = make(map[int]CardConfig)
	c.CardholderConfig = make(map[string]OpenCardholderConfig)
	c.NormalCardStarConfig = make(map[string]NormalCardStarConfig)
	c.CardSequenceConfig = make(map[string]CardSequenceConfig)
	c.StarShopConfig = make(map[int]StarShopConfig)
	// 解析奖励
	{
		err := json.Unmarshal([]byte(configRaw.Awards), &c.Awards)
		if err != nil {
			lxalilog.Errors(err, configRaw.Awards, gameId, configRaw.Id)
			return
		}
	}
	// 卡组配置
	{
		configs := make([]AlbumConfig, 0)
		err := json.Unmarshal([]byte(configRaw.AlbumConfig), &configs)
		if err != nil {
			lxalilog.Errors(err, configRaw.AlbumConfig, gameId, configRaw.Id)
			return
		}
		for _, i2 := range configs {
			c.AlbumConfig[i2.SetId] = i2
		}
	}
	// 卡牌配置
	{
		configs := make([]CardConfig, 0)
		err := json.Unmarshal([]byte(configRaw.CardConfig), &configs)
		if err != nil {
			lxalilog.Errors(err, configRaw.CardConfig, gameId, configRaw.Id)
			return
		}
		for _, i2 := range configs {
			c.CardConfig[i2.Id] = i2
		}
	}
	// 卡包开卡规则
	{
		configs := make([]OpenCardholderConfig, 0)
		err := json.Unmarshal([]byte(configRaw.CardHolderConfig), &configs)
		if err != nil {
			lxalilog.Errors(err, configRaw.CardHolderConfig, gameId, configRaw.Id)
			return
		}
		for _, i2 := range configs {
			c.CardholderConfig[i2.Id] = i2
		}
	}
	// 卡片星级配置
	{
		configs := make([]NormalCardStarConfig, 0)
		err := json.Unmarshal([]byte(configRaw.NormalCardStarSequence), &configs)
		if err != nil {
			lxalilog.Errors(err, configRaw.NormalCardStarSequence, gameId, configRaw.Id)
			return
		}
		for _, i2 := range configs {
			i2.NormalCardSequenceIds = strings.Split(i2.NormalCardSequenceId, ",")
			combineId := CombineIdSequenceIdCohort(i2.Id, i2.SequenceId, i2.Cohort)
			c.NormalCardStarConfig[combineId] = i2
		}
	}
	// 卡片星级对应卡牌配置
	{
		configs := make([]CardSequenceConfig, 0)
		err := json.Unmarshal([]byte(configRaw.CardSequenceConfig), &configs)
		if err != nil {
			lxalilog.Errors(err, configRaw.CardSequenceConfig, gameId, configRaw.Id)
			return
		}
		for _, i2 := range configs {
			i2.CardIdLists = strings.Split(i2.CardIdList, ",")
			combineId := CombineIdSequenceIdCohort(i2.Id, i2.SequenceId, i2.Cohort)
			c.CardSequenceConfig[combineId] = i2
		}
	}
	// 星星商店配置
	{
		configs := make([]StarShopConfig, 0)
		err := json.Unmarshal([]byte(configRaw.StarShopConfig), &configs)
		if err != nil {
			lxalilog.Errors(err, configRaw.StarShopConfig, gameId, configRaw.Id)
			return
		}
		for _, i2 := range configs {
			c.StarShopConfig[i2.Id] = i2
		}
	}

	c.GenerateConfigClient()
}

// GenerateConfigClient 生成给客户端的配置
func (c *CardActivityConfig) GenerateConfigClient() {
	configClient := &CardActivityConfigClient{
		Id:          c.Id,
		RoundAwards: c.Awards,
		Albums:      make([]AlbumConfig, 0),
		Cards:       make([]CardConfig, 0),
		Holders:     make([]OpenCardholderConfig, 0),
		StarShop:    make([]StarShopConfig, 0),
	}
	for _, i2 := range c.AlbumConfig {
		configClient.Albums = append(configClient.Albums, i2)
	}
	for _, i2 := range c.CardConfig {
		configClient.Cards = append(configClient.Cards, i2)
	}
	for _, i2 := range c.CardholderConfig {
		configClient.Holders = append(configClient.Holders, i2)
	}
	for _, i2 := range c.StarShopConfig {
		configClient.StarShop = append(configClient.StarShop, i2)
	}
	c.Client = configClient
}

// CombineIdSequenceIdCohort 组合ID k=ID_用户序列_用户分组
func CombineIdSequenceIdCohort(id, sequenceId, cohort string) string {
	return fmt.Sprintf("%s_%s_%s", id, sequenceId, cohort)
}

// FindNormalCardStarConfig 查找配置 非保底卡星级ID
func (c *CardActivityConfig) FindNormalCardStarConfig(id, sequenceId, cohort string) (conf NormalCardStarConfig, has bool) {
	combineId := CombineIdSequenceIdCohort(id, sequenceId, cohort)
	conf, has = c.NormalCardStarConfig[combineId]
	if !has {
		lxalilog.Errors(errors.New("ht_cardholder NormalCardStarConfig error"), id, sequenceId, cohort)
	}
	return
}

// FindCardSequenceConfig 查找配置 星级ID对应的卡片
func (c *CardActivityConfig) FindCardSequenceConfig(id, sequenceId, cohort string) (conf CardSequenceConfig, has bool) {
	combineId := CombineIdSequenceIdCohort(id, sequenceId, cohort)
	conf, has = c.CardSequenceConfig[combineId]
	if !has {
		lxalilog.Errors(errors.New("ht_cardholder CardSequenceConfig error"), id, sequenceId, cohort)
		fmt.Println(id)
		fmt.Println(sequenceId)
		fmt.Println(cohort)
	}
	return
}