package wtask

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

const (
	gameWorldTask       = "game_worldtask.json"
	gameWorldtaskBattle = "game_worldbattle.json"
	gameWorldAll        = "game_worldall.json"
	gameburiedCond      = "game_buriedcondi.json"
	gamerdtasknpc       = "game_rdtasknpc.json"
	gamesearchitemall   = "game_searchitemall.json"
	gamesearchitembox   = "game_searchitembox.json"
	game_worlddeal      = "game_worlddeal.json"
	game_worldrd        = "game_worldrd.json"
)

type configureComp struct {
	modules.MCompConfigure
	module        *WTask
	lock          sync.RWMutex
	condlTask     map[int32][]*cfg.GameWorldTaskData  //key 条件ID
	desTask       map[int32][]*cfg.GameWorldTaskData  //key 分类
	groupTask     map[int32][]*cfg.GameWorldTaskData  //key 任务组
	opencmdTask   map[string][]*cfg.GameWorldTaskData //key 功能开启
	daylock       sync.RWMutex
	daygroupTasks map[int32][]*cfg.GameAnnulartask_LibraryData //key 条件ID
	evevtlock     sync.RWMutex
	groupEvents   map[int32][]*cfg.GameWorldRdData //事件组
}

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.(*WTask)
	err = this.LoadMultiConfigure(map[string]interface{}{
		gameWorldTask:       cfg.NewGameWorldTask,
		gameWorldtaskBattle: cfg.NewGameWorldBattle,
		gameWorldAll:        cfg.NewGameWorldAll,
		gameburiedCond:      cfg.NewGameBuriedCondi,
		gamerdtasknpc:       cfg.NewGameRdtaskNpc,
		gamesearchitemall:   cfg.NewGameSearchitemAll,
		gamesearchitembox:   cfg.NewGameSearchitemBox,
		game_worlddeal:      cfg.NewGameWorldDeal,
	})
	this.condlTask = make(map[int32][]*cfg.GameWorldTaskData)
	configure.RegisterConfigure(gameWorldTask, cfg.NewGameBuriedCondi, this.updateconfigure)
	configure.RegisterConfigure(game_worldrd, cfg.NewGameWorldRd, this.updateeventconfigure)
	return
}

// 读取任务配置表
func (this *configureComp) getWorldtaskCfg() (data *cfg.GameWorldTask, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(gameWorldTask); err != nil {
		return
	} else {
		if data, ok = v.(*cfg.GameWorldTask); !ok {
			err = fmt.Errorf("%T is *cfg.GameWorldTask", v)
			return
		}
	}
	return
}

// 更新任务配置表
func (this *configureComp) updateconfigure() {
	gwt, err := this.getWorldtaskCfg()
	if err != nil {
		this.module.Error("世界任务配置表异常!")
		return
	}
	worldtaskConf := make(map[int32][]*cfg.GameWorldTaskData)
	destaskConf := make(map[int32][]*cfg.GameWorldTaskData)
	grouptaskConf := make(map[int32][]*cfg.GameWorldTaskData)
	opencmdConf := make(map[string][]*cfg.GameWorldTaskData)
	for _, v := range gwt.GetDataList() {

		if _, ok := destaskConf[v.Des]; !ok {
			destaskConf[v.Des] = make([]*cfg.GameWorldTaskData, 0)
		}
		destaskConf[v.Des] = append(destaskConf[v.Des], v)

		if _, ok := grouptaskConf[v.Group]; !ok {
			grouptaskConf[v.Group] = make([]*cfg.GameWorldTaskData, 0)
		}
		grouptaskConf[v.Group] = append(grouptaskConf[v.Group], v)

		if v.Opencond != "" {
			if _, ok := opencmdConf[v.Opencond]; !ok {
				opencmdConf[v.Opencond] = make([]*cfg.GameWorldTaskData, 0)
			}
			opencmdConf[v.Opencond] = append(opencmdConf[v.Opencond], v)
		}

		for _, condl := range v.Completetask {
			if _, ok := worldtaskConf[condl]; !ok {
				worldtaskConf[condl] = make([]*cfg.GameWorldTaskData, 0)
			}
			worldtaskConf[condl] = append(worldtaskConf[condl], v)
		}
	}

	this.lock.Lock()
	this.condlTask = worldtaskConf
	this.desTask = destaskConf
	this.groupTask = grouptaskConf
	this.opencmdTask = opencmdConf
	this.lock.Unlock()
}

// 更新任务配置表
func (this *configureComp) updateeventconfigure() {
	var (
		v           interface{}
		groupEvents map[int32][]*cfg.GameWorldRdData //事件组
		err         error
	)
	if v, err = this.GetConfigure(game_worldrd); err != nil {
		return
	} else {
		groupEvents = make(map[int32][]*cfg.GameWorldRdData)
		for _, conf := range v.(*cfg.GameWorldRd).GetDataList() {
			if _, ok := groupEvents[conf.Group]; !ok {
				groupEvents[conf.Group] = make([]*cfg.GameWorldRdData, 0)
			}
			groupEvents[conf.Group] = append(groupEvents[conf.Group], conf)
		}

		this.evevtlock.Lock()
		this.groupEvents = groupEvents
		this.evevtlock.Unlock()
	}
}

func (this *configureComp) getcondlTask() map[int32][]*cfg.GameWorldTaskData {
	this.lock.RLock()
	defer this.lock.RUnlock()
	return this.condlTask
}

func (this *configureComp) getdesTask(des int32) []*cfg.GameWorldTaskData {
	this.lock.RLock()
	defer this.lock.RUnlock()
	if _, ok := this.desTask[des]; ok {
		return this.desTask[des]
	} else {
		return make([]*cfg.GameWorldTaskData, 0)
	}
}

func (this *configureComp) getgroupTask() map[int32][]*cfg.GameWorldTaskData {
	this.lock.RLock()
	defer this.lock.RUnlock()
	return this.groupTask
}

func (this *configureComp) getopencmdTask() map[string][]*cfg.GameWorldTaskData {
	this.lock.RLock()
	defer this.lock.RUnlock()
	return this.opencmdTask
}

func (this *configureComp) gettaskconfconfigure(tid int32) (conf *cfg.GameWorldTaskData, err error) {

	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(gameWorldTask); err != nil {
		return
	} else {
		if conf, ok = v.(*cfg.GameWorldTask).GetDataMap()[tid]; !ok {
			err = comm.NewNotFoundConfErr(modulename, gameWorldTask, tid)
			this.module.Errorf("err:%v", err)
			return
		}
	}
	return
}

// 获取战斗配置
func (this *configureComp) getWorldtaskBattleById(confId int32) (conf *cfg.GameWorldBattleData, err error) {

	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(gameWorldtaskBattle); err != nil {
		return
	} else {
		if conf, ok = v.(*cfg.GameWorldBattle).GetDataMap()[confId]; !ok {
			err = comm.NewNotFoundConfErr(modulename, gameWorldtaskBattle, confId)
			this.module.Errorf("err:%v", err)
			return
		}
	}
	return
}

func (this *configureComp) getGameWorldAll(id int32) (conf *cfg.GameWorldAllData, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(gameWorldAll); err != nil {
		return
	} else {
		if conf, ok = v.(*cfg.GameWorldAll).GetDataMap()[id]; !ok {
			err = comm.NewNotFoundConfErr(modulename, gameWorldTask, id)
			this.module.Errorf("err:%v", err)
			return
		}
	}
	return
}

func (this *configureComp) getGameSearchitemAll(id int32) (results map[int32]int32, err error) {
	var (
		v    interface{}
		conf *cfg.GameSearchitemAllData

		weight []int
		ok     bool
	)
	if v, err = this.GetConfigure(gamesearchitemall); err != nil {
		return
	} else {
		if conf, ok = v.(*cfg.GameSearchitemAll).GetDataMap()[id]; !ok {
			err = comm.NewNotFoundConfErr(modulename, gameWorldTask, id)
			this.module.Errorf("err:%v", err)
			return
		}
		results = make(map[int32]int32)
		weight = comm.RandShuffle(len(conf.Pointweight))
		for i := 0; i < int(conf.Pointnum); i++ {
			results[conf.Point[weight[i]]] = 0
		}
	}
	return
}

func (this *configureComp) getGameSearchitemBox(id int32) (conf *cfg.GameSearchitemBoxData, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(gamesearchitembox); err != nil {
		return
	} else {
		if conf, ok = v.(*cfg.GameSearchitemBox).GetDataMap()[id]; !ok {
			err = comm.NewNotFoundConfErr(modulename, gameWorldTask, id)
			this.module.Errorf("err:%v", err)
			return
		}

	}
	return
}

func (this *configureComp) getGameWorldDeal(ids []int32) (confs []*cfg.GameWorldDealData, err error) {
	var (
		v    interface{}
		conf *cfg.GameWorldDealData
		ok   bool
	)
	if v, err = this.GetConfigure(game_worlddeal); err != nil {
		return
	} else {
		confs = make([]*cfg.GameWorldDealData, 0)
		for _, id := range ids {
			if conf, ok = v.(*cfg.GameWorldDeal).GetDataMap()[id]; !ok {
				err = comm.NewNotFoundConfErr(modulename, gameWorldTask, v)
				this.module.Errorf("err:%v", err)
				return
			}
			confs = append(confs, conf)
		}

	}
	return
}

// 随机事件
func (this *configureComp) getGameWorldRdDataByGroup(group int32) (conf *cfg.GameWorldRdData, err error) {
	this.evevtlock.RLock()
	events, ok := this.groupEvents[group]
	this.evevtlock.RUnlock()
	if !ok {
		err = comm.NewNotFoundConfErr(modulename, game_worldrd, group)
		this.module.Errorf("err:%v", err)
		return
	}
	weight := comm.RandShuffle(len(events))
	conf = events[weight[0]]
	return
}

func (this *configureComp) getGameWorldRdData(id int32) (conf *cfg.GameWorldRdData, err error) {
	var (
		v  interface{}
		ok bool
	)
	if v, err = this.GetConfigure(game_worldrd); err != nil {
		return
	} else {
		if conf, ok = v.(*cfg.GameWorldRd).GetDataMap()[id]; !ok {
			err = comm.NewNotFoundConfErr(modulename, gameWorldTask, id)
			this.module.Errorf("err:%v", err)
			return
		}

	}
	return
}