package cardholder

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

var (
	Configs map[string]*CardActivityConfig // 配置列表 k=GameId v=配置
)

func NewConfigs() {
	Configs = make(map[string]*CardActivityConfig)
}

func GetConfig(gameId string) (config *CardActivityConfig, has bool) {
	config, has = Configs[gameId]
	return
}

// ConfigDecode 解析配置原始数据
func ConfigDecode(gameId string, configRaw *CardActivityConfigRaw) {
	Config := &CardActivityConfig{
		Raw:                  configRaw,
		GameId:               gameId,
		Id:                   configRaw.Id,
		Awards:               make(map[string]string),
		AlbumConfig:          make(map[string]AlbumConfig),
		CardConfig:           make(map[int]CardConfig),
		CardholderConfig:     make(map[string]OpenCardholderConfig),
		NormalCardStarConfig: make(map[string]NormalCardStarConfig),
		CardSequenceConfig:   make(map[string]CardSequenceConfig),
	}
	// 解析奖励
	{
		err := json.Unmarshal([]byte(configRaw.Awards), &Config.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 {
			Config.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 {
			Config.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 {
			Config.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)
			Config.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)
			Config.CardSequenceConfig[combineId] = i2
		}
	}
	Configs[gameId] = Config
}

// 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)
	}
	return
}