package logic

import (
	"ecs/proto/pb"
	"ecs/servers/game/data"
	"github.com/oylshe1314/framework/util"
	"sort"
)

type PlayerLineup struct {
	Uid    uint64               `json:"uid" key:"1"`
	Name   string               `bson:"name"`
	Active bool                 `bson:"active"`
	Heroes [8]*PlayerLineupHero `bson:"heroes"`
	Helper [8]uint64            `bson:"helper"`
}

func (this *PlayerLineup) BuildMsgLineup() *pb.Lineup {
	var msg = &pb.Lineup{Uid: this.Uid, Name: this.Name, Active: this.Active}
	if this.Active {
		msg.HeroList = make([]*pb.LineupHero, 8)
		for i, hero := range this.Heroes {
			if hero != nil {
				msg.HeroList[i] = hero.BuildMsgLineupHero(uint32(i))
			}
		}
		for _, helper := range this.Helper {
			msg.HelpList = append(msg.HelpList, helper)
		}
	}
	return msg
}

func (this *Player) SendUpgradeMaster(masterType pb.UpgradeMasterType, preLevel, curLevel uint32, heroUid uint64) {
	if heroUid == 0 {
		return
	}

	var masterTables = this.manager.tables.UpgradeMaster.Find1(int(masterType))
	if len(masterTables) == 0 {
		return
	}

	var preMasterTable, curMasterTable *data.UpgradeMaster
	for _, v := range masterTables {
		if uint32(v.NeedLevel) <= preLevel {
			preMasterTable = v
			continue
		}

		if uint32(v.NeedLevel) > curLevel {
			return
		}

		curMasterTable = v
		break
	}

	if curMasterTable == nil {
		return
	}

	var lineup = util.MapFindValue(this.Lineup, func(v *PlayerLineup) bool {
		return v.Active
	})
	if lineup == nil {
		return
	}

	var lineupHero = util.SliceFindValue(lineup.Heroes[:], func(i int) bool {
		return lineup.Heroes[i] != nil && lineup.Heroes[i].HeroUid == heroUid
	})
	if lineupHero == nil {
		return
	}

	var ack *pb.UpgradeMasterAck
	switch masterType {
	case pb.UpgradeMasterType_MasterEquipUpgrade, pb.UpgradeMasterType_MasterEquipRefine:
		for _, equipUid := range lineupHero.Equip {
			var equip = this.Equip[equipUid]
			if equip == nil {
				return
			}

			if masterType == pb.UpgradeMasterType_MasterEquipUpgrade {
				if equip.Level < uint32(curMasterTable.NeedLevel) {
					return
				}
			} else {
				if equip.RefineLevel < uint32(curMasterTable.NeedLevel) {
					return
				}
			}
		}
		ack = &pb.UpgradeMasterAck{
			CurLevel: uint32(curMasterTable.Level),
		}
	case pb.UpgradeMasterType_MasterTreasureUpgrade, pb.UpgradeMasterType_MasterTreasureRefine:
		for _, treasureUid := range lineupHero.Treasure {
			var treasure = this.Treasure[treasureUid]
			if treasure == nil {
				return
			}

			if masterType == pb.UpgradeMasterType_MasterTreasureUpgrade {
				if treasure.Level < uint32(curMasterTable.NeedLevel) {
					return
				}
			} else {
				if treasure.RefineLevel < uint32(curMasterTable.NeedLevel) {
					return
				}
			}
		}
		ack = &pb.UpgradeMasterAck{
			CurLevel: uint32(curMasterTable.Level),
		}
	default:
		return
	}

	if preMasterTable != nil {
		ack.PreLevel = uint32(preMasterTable.Level)
	}

	_ = this.Send(uint16(pb.ModId_ModuleRole), uint16(pb.MsgId_ModRoleUpgradeMaster), ack)
}

func (this *Player) BuildMsgLineupListAck() *pb.LineupListAck {
	var list []*pb.Lineup
	for _, lineup := range this.Lineup {
		list = append(list, lineup.BuildMsgLineup())
	}
	sort.Slice(list, func(i, j int) bool {
		return list[i].Uid < list[j].Uid
	})
	return &pb.LineupListAck{LineupList: list}
}