package treasuremap

import (
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/lego/core"
	"go_dreamfactory/modules"
	"go_dreamfactory/sys/configure"
	cfg "go_dreamfactory/sys/configure/structs"
	"sync"
)

const (
	game_gcolorgetfraction = "game_gcolorgetfraction.json"
	game_gcolorreward      = "game_gcolorreward.json"
	game_gcolorttmedecay   = "game_gcolorttmedecay.json"
)

type configureComp struct {
	modules.MCompConfigure
	module      *TreasureMap
	lock        sync.RWMutex
	repeatMap   map[int32][]*cfg.GameGColorGetfractionData
	norepeatMap map[int32][]*cfg.GameGColorGetfractionData
}

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)
	this.module = module.(*TreasureMap)
	this.repeatMap = make(map[int32][]*cfg.GameGColorGetfractionData)
	err = this.LoadMultiConfigure(map[string]interface{}{
		game_gcolorreward:    cfg.NewGameGColorReward,
		game_gcolorttmedecay: cfg.NewGameGColortTmedecay,
	})
	configure.RegisterConfigure(game_gcolorgetfraction, cfg.NewGameGColorGetfraction, this.updateconfigure)
	return
}

// 更新任务配置表
func (this *configureComp) updateconfigure() {
	var (
		v    interface{}
		conf *cfg.GameGColorGetfraction
		ok   bool
		err  error
	)
	if v, err = this.GetConfigure(game_gcolorgetfraction); err != nil {
		return
	}
	if conf, ok = v.(*cfg.GameGColorGetfraction); !ok {
		this.module.Error("日常任务配置异常!")
		return
	}
	repeatMap := map[int32][]*cfg.GameGColorGetfractionData{}
	norepeatMap := map[int32][]*cfg.GameGColorGetfractionData{}
	for _, v := range conf.GetDataList() {
		if v.Repeat == 1 {
			if _, ok = repeatMap[v.Difficulty]; !ok {
				repeatMap[v.Difficulty] = make([]*cfg.GameGColorGetfractionData, 0)
			}
			repeatMap[v.Difficulty] = append(repeatMap[v.Difficulty], v)
		} else {
			if _, ok = norepeatMap[v.Difficulty]; !ok {
				norepeatMap[v.Difficulty] = make([]*cfg.GameGColorGetfractionData, 0)
			}
			norepeatMap[v.Difficulty] = append(norepeatMap[v.Difficulty], v)
		}
	}
	this.lock.Lock()
	this.repeatMap = repeatMap
	this.norepeatMap = norepeatMap
	this.lock.Unlock()
}

func (this *configureComp) getGameGColorGetfractionData(dif int32, repeat bool, index int) (conf *cfg.GameGColorGetfractionData, err error) {
	var (
		confs map[int32][]*cfg.GameGColorGetfractionData
		ok    bool
	)
	if repeat {
		confs = this.repeatMap
	} else {
		confs = this.norepeatMap
	}

	if _, ok = confs[dif]; ok {
		if len(confs[dif]) > index {
			conf = confs[dif][index]
			return
		}
	}
	err = comm.NewNotFoundConfErr(string(this.module.GetType()), game_gcolorgetfraction, fmt.Sprintf("dif:%d repeat:%v index:%d", dif, repeat, index))
	return
}

// 获取伤害对应的评分组
func (this *configureComp) getGameGColortTmedecayData(time int32) (conf *cfg.GameGColortTmedecayData, err error) {
	var (
		v interface{}
	)

	if v, err = this.GetConfigure(game_gcolorttmedecay); err != nil {
		return
	} else {
		for _, v := range v.(*cfg.GameGColortTmedecay).GetDataList() {
			if (time >= v.Min || v.Min == -1) && (time <= v.Max || v.Max == -1) {
				conf = v
				return
			}
		}
		err = comm.NewNotFoundConfErr(string(this.module.GetType()), game_gcolorttmedecay, time)
		this.module.Errorf("err:%v", err)
	}
	return
}

// 获取奖励列表
func (this *configureComp) getGameGColorRewardData(id int32) (conf *cfg.GameGColorRewardData, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(game_gcolorreward); err != nil {
		return
	}
	if conf, ok = v.(*cfg.GameGColorReward).GetDataMap()[id]; !ok {
		err = comm.NewNotFoundConfErr(string(this.module.GetType()), game_gcolorreward, id)
		this.module.Errorln(err)
		return
	}
	return
}