package robot

import (
	"errors"
	"fmt"
	"go_dreamfactory/comm"
	"go_dreamfactory/pb"
	"go_dreamfactory/sys/configure"
	cfg "go_dreamfactory/sys/configure/structs"
	"sort"

	"google.golang.org/protobuf/proto"
)

//用户模块 机器人
type ModuleRobot_Hero struct {
	heros  map[string]*pb.DBHero
	talent []*pb.DBHeroTalent // 天赋数据
}

func (this *ModuleRobot_Hero) Init() (err error) {
	this.heros = make(map[string]*pb.DBHero)
	return
}

//接收到消息
func (this *ModuleRobot_Hero) Receive(robot IRobot, stype string, message proto.Message) (err error) {
	switch stype {
	case "list":
		resp := message.(*pb.HeroListResp)
		for _, v := range resp.List {
			this.heros[v.Id] = v
		}
		break
	case "change":
		resp := message.(*pb.HeroChangePush)
		for _, v := range resp.List {
			this.heros[v.Id] = v
		}
		break
	case "talentlist": // 获取天赋数据
		resp := message.(*pb.HeroTalentListResp)
		this.talent = resp.Telnet
		break
	}
	return
}

func (this *ModuleRobot_Hero) OncePipeline(robot IRobot) (err error) {
	var (
		errdata *pb.ErrorData
	)
	if _, errdata = robot.SendMessage("hero", "list", &pb.HeroListReq{}); errdata != nil {
		err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
		return
	}
	if _, errdata = robot.SendMessage("hero", "talentlist", &pb.HeroTalentListReq{}); errdata != nil {
		err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
		return
	}
	return
}

//机器人执行流
func (this *ModuleRobot_Hero) DoPipeline(robot IRobot) (err error) {
	if _, errdata := robot.SendMessage("hero", "drawcard", &pb.HeroDrawCardReq{DrawType: 2, DrawCount: 10, Consume: 1}); errdata != nil {
		err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
		return
	}
	return
}

//做任务
func (this *ModuleRobot_Hero) DoTask(robot IRobot, taskconf *cfg.GameWorldTaskData, condconf *cfg.GameBuriedCondiData) (err error) {
	var (
		errdata *pb.ErrorData
	)
	switch comm.TaskType(condconf.Type) {
	case comm.Rtype14:
		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "drawcard", &pb.HeroDrawCardReq{DrawType: 2, DrawCount: 1, Consume: 0}); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}

	case comm.Rtype199, comm.Rtype39, comm.Rtype40:
		req := &pb.HeroTalentLearnReq{
			TalentID: 0,
			ObjId:    "",
			Heroid:   "",
		}
		// check 该英雄天赋满级
		bMax := false
		// 获取英雄数据
		for _, v := range this.heros {
			if c, err := this.GMGetTalentByHeroId(v.HeroID); err == nil {
				if this.talent == nil {
					req.TalentID = c[0].Skillid
					req.Heroid = v.HeroID
				} else {
					for _, v1 := range this.talent {
						if len(v1.Talent) == len(c) {
							bMax = true
							break
						}
						if v1.HeroId == v.HeroID {
							req.ObjId = v1.Id
							req.Heroid = v.HeroID
							// 依次往后学
							if len(v1.Talent) < len(c) {
								req.TalentID = c[len(v1.Talent)].Skillid
							}
							break
						}
					}
				}
			}
			if !bMax { // 当前英雄全满共鸣后 继续找下一个英雄
				continue
			}
			break
		}

		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "talentlearn", req); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
	case comm.Rtype6: // 升星
		req := &pb.HeroStrengthenUpStarReq{}
		for _, v := range this.heros {
			req.HeroObjID = v.Id
			break
		}

		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "strengthenupstar", req); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
	case comm.Rtype24: // 升级
		var (
			itemmodule *ModuleRobot_Item
			items      map[string]*pb.DB_UserItemData
			use        map[string]int32
			heroMaxLv  int32 // 当前英雄最大等级
		)
		use = make(map[string]int32)
		req := &pb.HeroStrengthenUplvReq{
			HeroObjID: "",
			Item:      map[string]int32{},
		}
		// 取任务等级
		usermodule := robot.GetModule(comm.ModuleUser).(*ModuleRobot_User)

		if c := this.GetPlayerlvConf(usermodule.user.Lv); c != nil {
			heroMaxLv = c.HeroLv
		}
		// 找最大等级的英雄
		for _, v := range this.heros {
			if v.Lv > 1 && v.Lv < heroMaxLv {
				req.HeroObjID = v.Id
			}
			break
		}
		if req.HeroObjID == "" { // 随机找一个1级的英雄进行升级
			for _, v := range this.heros {
				if v.Lv == 1 {
					req.HeroObjID = v.Id
					break
				}
			}
		}

		itemmodule = robot.GetModule(comm.ModuleItems).(*ModuleRobot_Item)
		items = itemmodule.items
		if _, ok := items["10000008"]; ok {
			use["10000008"] = 1
		}
		if _, ok := items["10000009"]; ok && len(use) == 0 {
			use["10000009"] = 1
		}
		if _, ok := items["10000010"]; ok && len(use) == 0 {
			use["10000010"] = 1
		}
		if len(use) > 0 {
			req.Item = use
		}
		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "strengthenuplv", req); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
	case comm.Rtype25: // 升星
		req := &pb.HeroStrengthenUpStarReq{}
		for _, v := range this.heros {
			if v.HeroID == string(condconf.Filter[0]) { // 找到指定英雄ID
				req.HeroObjID = v.Id
			}
			break
		}

		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "strengthenupstar", req); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
	case comm.Rtype34: // 觉醒

		req := &pb.HeroAwakenReq{}
		for _, v := range this.heros {
			if int(v.JuexingLv) > 1 && int(v.JuexingLv) < len(this.GetHeroAwalenConf(v.HeroID)) { // 优先找觉醒大于1 并且没有满觉醒的英雄
				req.HeroObjID = v.Id
				break
			}
			if len(this.GetHeroAwalenConf(v.HeroID)) == int(v.JuexingLv) { // 满觉醒了就找下一个
				continue
			}

			req.HeroObjID = v.Id
			break
		}
		if req.HeroObjID == "" {
			err = errors.New(fmt.Sprintf("code:%d message:not found hero", errdata.Code))
			return
		}
		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "awaken", req); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
	case comm.Rtype33:
		req := &pb.HeroAwakenReq{}
		for _, v := range this.heros {
			data, _ := this.GMGetTalentByHeroId(v.HeroID)
			if int(v.JuexingLv) > 1 && 0 < len(data) {
				req.HeroObjID = v.Id
				break
			}
			if this.GetHeroTalentMaxLv(v.HeroID) > 10 {
				continue
			}

			req.HeroObjID = v.Id
			break
		}
		if req.HeroObjID == "" {
			err = errors.New(fmt.Sprintf("code:%d message:not found hero", errdata.Code))
			return
		}
		if _, errdata = robot.SendTaskMessage(taskconf.Key, condconf.Id, "hero", "awaken", req); errdata != nil {
			err = errors.New(fmt.Sprintf("code:%d message:%s", errdata.Code, errdata.Message))
			return
		}
	}
	return
}

//获取战斗英雄
func (this *ModuleRobot_Hero) getbattlehero() (bheros []string) {
	var (
		heros []*pb.DBHero = make([]*pb.DBHero, 0, len(this.heros))
	)
	bheros = make([]string, 5)
	for _, v := range this.heros {
		heros = append(heros, v)
	}
	// 使用sort.Slice进行排序
	sort.Slice(heros, func(i, j int) bool {
		return heros[i].Lv > heros[j].Lv
	})

	for i, v := range heros {
		if i < 5 {
			bheros[i] = v.Id
		} else {
			return
		}
	}
	return
}

//获取武官训练英雄英雄
func (this *ModuleRobot_Hero) getpracticehero() (bheros string) {
	for _, v := range this.heros {
		if v.Status != pb.HeroType_HeroTypeKongFu {
			return v.Id
		}
	}
	return
}

func (this *ModuleRobot_Hero) GMGetTalentByHeroId(hid string) (data []*cfg.GameHeroTalentData, err error) {
	var (
		v interface{}
	)
	if v, err = configure.GetConfigure(hero_talent); err == nil {
		if configure, ok := v.(*cfg.GameHeroTalent); ok {
			for _, v1 := range configure.GetDataList() {
				if v1.Hid == hid {
					data = append(data, v1)
				}
			}
		}
	}
	if len(data) == 0 {
		err = comm.NewNotFoundConfErr("robot", hero_talent, hid)
	}
	return
}

// 玩家等级经验配置表
func (this *ModuleRobot_Hero) GetPlayerlvConf(lv int32) (data *cfg.GamePlayerlvData) {
	if v, err := configure.GetConfigure(game_playerlv); err != nil {
		return
	} else {
		if configure, ok := v.(*cfg.GamePlayerlv); !ok {
			err = fmt.Errorf("%T no is *cfg.Game_playerlv", v)
			return
		} else {
			if configure != nil {
				data = configure.GetDataMap()[lv]
			}
		}
	}
	return
}
func (this *ModuleRobot_Hero) GetHeroAwalenConf(hid string) (data []*cfg.GameHeroAwakenData) {
	data = make([]*cfg.GameHeroAwakenData, 0)
	if v, err := configure.GetConfigure(hero_awaken); err == nil {
		if _configure, ok := v.(*cfg.GameHeroAwaken); ok {
			for _, v := range _configure.GetDataList() {
				if v.Hid == hid {
					data = append(data, v)
				}
			}
		}
	}
	return
}
func (this *ModuleRobot_Hero) GetHeroTalentMaxLv(heroid string) (maxlv int32) {
	if v, err := configure.GetConfigure(hero_talentbox); err == nil {
		if configure, ok := v.(*cfg.GameTalentBox); ok {
			return int32(len(configure.GetDataList()))
		}
	}

	return 0
}