package hero

import (
	"fmt"
	"go_dreamfactory/modules"
	cfg "go_dreamfactory/sys/configure/structs"

	"go_dreamfactory/lego/core"
)

const (
	new_hero        = "game_hero.json"           //英雄
	hero_stargrow   = "game_herostargrow.json"   //英雄品质系数
	hero_levelgrow  = "game_herolevelgrow.json"  //英雄成长系数
	hero_starup     = "game_herostarup.json"     // 升星
	hero_levelup    = "game_herolevelup.json"    //英雄等级基础属性
	hero_exp        = "game_heroexp.json"        // 升级
	hero_skillup    = "game_heroskilllevel.json" // 英雄技能升级
	game_skillatk   = "game_skillatk.json"       // 英雄技能
	hero_resonance  = "game_heroresonance.json"  // 英雄共鸣
	hero_comatn     = "game_comatn.json"         // 英雄共鸣重置
	hero_awaken     = "game_heroawaken.json"     // 英雄觉醒
	hero_drawcard   = "game_drawcard.json"       // 抽卡
	hero_drawupdraw = "game_drawupdraw.json"     // 抽卡概率调整
	hero_drawcost   = "game_drawcost.json"       // 抽卡消耗
)

///配置管理组件
type configureComp struct {
	modules.MCompConfigure
}

//组件初始化接口
func (this *configureComp) Init(service core.IService, module core.IModule, comp core.IModuleComp, options core.IModuleOptions) (err error) {

	err = this.MCompConfigure.Init(service, module, comp, options)
	err = this.LoadMultiConfigure(map[string]interface{}{
		new_hero:        cfg.NewGame_hero,
		hero_stargrow:   cfg.NewGame_heroStargrow,
		hero_levelgrow:  cfg.NewGame_heroLevelgrow,
		hero_starup:     cfg.NewGame_heroStarup,
		hero_levelup:    cfg.NewGame_heroLevelup,
		hero_exp:        cfg.NewGame_heroExp,
		hero_skillup:    cfg.NewGame_heroSkillLevel,
		game_skillatk:   cfg.NewGame_skillAtk,
		hero_resonance:  cfg.NewGame_heroResonance,
		hero_comatn:     cfg.NewGame_comAtn,
		hero_awaken:     cfg.NewGame_heroAwaken,
		hero_drawcard:   cfg.NewGame_drawCard,
		hero_drawupdraw: cfg.NewGame_drawUpdraw,
		hero_drawcost:   cfg.NewGame_drawCost,
	})

	return
}

//获取英雄配置数据
func (this *configureComp) getHeroConfigure() (configure *cfg.Game_hero, err error) {
	var (
		v  interface{}
		ok bool
	)

	if v, err = this.GetConfigure(new_hero); err != nil {
		return
	} else {
		if configure, ok = v.(*cfg.Game_hero); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_hero", v)
		}
	}
	return
}

// 获取英雄强化增加属性配置数据
func (this *configureComp) GetHeroStargrowConfig() (configure *cfg.Game_heroStargrow, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_stargrow); err == nil {
		if configure, ok = v.(*cfg.Game_heroStargrow); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_hero", v)
			return
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.Game_hero", v)
	}

	return
}

// 获取英雄升级属性变化相关配置数据
func (this *configureComp) GetHeroLevelgrowConfig() (configure *cfg.Game_heroLevelgrow, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_levelgrow); err == nil {
		if configure, ok = v.(*cfg.Game_heroLevelgrow); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_heroLevelgrow", v)
			return
		}

	}
	return
}

// 获取英雄升星相关配置数据
func (this *configureComp) GetHeroStarupConfig() (configure *cfg.Game_heroStarup, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_starup); err == nil {
		if configure, ok = v.(*cfg.Game_heroStarup); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_heroStarup", v)
			return
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.Game_heroStarup", v)
	}
	return
}

// 获取英雄升级相关配置数据
func (this *configureComp) GetHeroLevelUpConfig() (configure *cfg.Game_heroLevelup, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_levelup); err == nil {
		if configure, ok = v.(*cfg.Game_heroLevelup); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_heroLevelup", v)
			return
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.Game_heroLevelup", v)
	}
	return
}

func (this *configureComp) GetHeroExpConfig() (configure *cfg.Game_heroExp, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_exp); err == nil {
		if configure, ok = v.(*cfg.Game_heroExp); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_heroExp", v)
			return
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.Game_heroExp", v)
	}
	return
}
func (this *configureComp) GetHeroExp(hid string) *cfg.Game_heroExpData {

	if v, err := this.GetConfigure(hero_exp); err == nil {
		if configure, ok := v.(*cfg.Game_heroExp); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_heroExp", v)
			return nil
		} else {
			return configure.Get(hid)
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.Game_heroExp", v)
	}
	return nil
}

//英雄等级基础属性
func (this *configureComp) GetHeroLevelup() (configure *cfg.Game_heroLevelup, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_levelup); err != nil {
		return
	} else {
		if configure, ok = v.(*cfg.Game_heroLevelup); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_heroLevelup", v)
			return
		}
	}
	return
}

//英雄品质系数
func (this *configureComp) GetHeroStargrow() (configure *cfg.Game_heroStargrow, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_stargrow); err != nil {
		return
	} else {
		if configure, ok = v.(*cfg.Game_heroStargrow); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_heroStargrow", v)
			return
		}
	}
	return
}

//获取英雄配置
func (this *configureComp) GetHero(heroCfgId string) *cfg.Game_heroData {
	cfg, err := this.getHeroConfigure()
	if err != nil {
		return nil
	}
	if v, ok := cfg.GetDataMap()[heroCfgId]; ok {
		return v
	}
	return nil
}

//获取英雄星级配置
func (this *configureComp) GetHeroStar(star int32) *cfg.Game_heroStargrowData {
	cfg, err := this.GetHeroStargrow()
	if err != nil {
		return nil
	}

	if v, ok := cfg.GetDataMap()[star]; ok {
		return v
	}
	return nil
}

//获取英雄等级配置
func (this *configureComp) GetHeroLv(lv int32) *cfg.Game_heroLevelupData {
	cfg, err := this.GetHeroLevelup()
	if err != nil {
		return nil
	}
	if v, ok := cfg.GetDataMap()[lv]; ok {
		return v
	}
	return nil
}

// 英雄成长系数
func (this *configureComp) GetHeroLevelgrow() (configure *cfg.Game_heroLevelgrow, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_levelgrow); err != nil {
		return
	} else {
		if configure, ok = v.(*cfg.Game_heroLevelgrow); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_heroLevelgrow", v)
			return
		}
	}
	return
}

//英雄成长配置
func (this *configureComp) GetHeroLvgrow(heroId string) *cfg.Game_heroLevelgrowData {
	cfg, err := this.GetHeroLevelgrow()
	if err != nil {
		return nil
	}
	if v, ok := cfg.GetDataMap()[heroId]; ok {
		return v
	}
	return nil
}

// 获取英雄技能升级相关信息
func (this *configureComp) GetHeroSkillUpConfig(skillid int32) (data *cfg.Game_heroSkillLevelData) {

	if v, err := this.GetConfigure(hero_skillup); err == nil {
		if conf, ok := v.(*cfg.Game_heroSkillLevel); ok {
			data = conf.Get(skillid)
			return
		}
	}

	return
}

// 获取英雄技能最大等级
func (this *configureComp) GetHeroSkillMaxLvConfig(skillId uint32) int32 {

	if v, err := this.GetConfigure(game_skillatk); err == nil {
		if configure, ok := v.(*cfg.Game_skillAtk); ok {
			return configure.Get(int32(skillId)).MaxLV
		}
	}

	return 0
}

// 通过英雄配置ID获取共鸣配置信息
func (this *configureComp) GetHeroResonanceConfig(cardConfigID string) (data *cfg.Game_heroResonanceData, err error) {
	var (
		v interface{}
	)
	if v, err = this.GetConfigure(hero_resonance); err == nil {
		if configure, ok := v.(*cfg.Game_heroResonance); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_heroResonance", v)
			return
		} else {
			data = configure.Get(cardConfigID)
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.Game_heroResonance", v)
	}

	return
}

func (this *configureComp) GetHeroResonanceRestConfig() (data *cfg.Game_comAtnData, err error) {
	var (
		v interface{}
	)
	if v, err = this.GetConfigure(hero_comatn); err == nil {
		if configure, ok := v.(*cfg.Game_comAtn); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_comAtn", v)
			return
		} else {
			data = configure.Get("hero_reset")
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.game_comatn", v)
	}

	return
}
func (this *configureComp) GetHeroAwakenConfig() (configure *cfg.Game_heroAwaken, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_awaken); err == nil {
		if configure, ok = v.(*cfg.Game_heroAwaken); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_heroAwaken", v)
			return
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.Game_heroAwaken", v)
	}

	return
}

// 抽卡配置表
func (this *configureComp) GetHeroDrawConfig(typeid int32) (card []*cfg.Game_drawCardData, err error) {
	var (
		v interface{}
	)
	if v, err = this.GetConfigure(hero_drawcard); err == nil {
		if _configure, ok := v.(*cfg.Game_drawCard); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_drawCard", v)
			return
		} else {
			for _, v := range _configure.GetDataList() {
				if v.TypeId == typeid {
					card = append(card, v)
				}
			}
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.Game_drawCard", v)
	}

	return
}

// 抽卡概率提高
func (this *configureComp) GetDrawUpDrawConfig() (configure *cfg.Game_drawUpdraw, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_drawupdraw); err == nil {
		if configure, ok = v.(*cfg.Game_drawUpdraw); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_drawUpdraw", v)
			return
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.Game_drawUpdraw", v)
	}

	return
}

// 抽卡消耗
func (this *configureComp) GetDrawCostConfig() (configure *cfg.Game_drawCost, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(hero_drawcost); err == nil {
		if configure, ok = v.(*cfg.Game_drawCost); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_drawCost", v)
			return
		}
	} else {
		err = fmt.Errorf("%T no is *cfg.Game_drawCost", v)
	}

	return
}

func (this *configureComp) GetDrawCostConfigByID(id int32) (data *cfg.Game_drawCostData, err error) {
	var (
		v interface{}
	)
	if v, err = this.GetConfigure(hero_drawcost); err == nil {
		if configure, ok := v.(*cfg.Game_drawCost); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_drawCost", v)
			return
		} else {
			data = configure.Get(id)
		}

	} else {
		err = fmt.Errorf("%T no is *cfg.Game_drawCost", v)
	}

	return
}