package handler

import (
	"ecs/proto"
	"ecs/proto/pb"
	"ecs/servers/game/logic"
	"github.com/oylshe1314/framework/net"
)

func (this *PlayerHandler) HeroUpgrade(player *logic.Player, msg *net.Message) {
	var req = new(pb.HeroUpgradeReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.ErrMessageError)
		return
	}

	if req.HeroUid == 0 {
		_ = player.TipNotice(proto.ErrParameterError)
		return
	}

	if req.Levels != 1 && req.Levels != 5 {
		_ = player.TipNotice(proto.ErrParameterError)
		return
	}

	var hero = player.Hero[req.HeroUid]
	if hero == nil {
		_ = player.TipNotice(proto.ErrHeroNotFound)
		return
	}

	var heroTable = this.tables.Hero.Get(int(hero.Id))
	if heroTable == nil {
		_ = player.TipNotice(proto.ErrDataTablesError)
		return
	}

	if hero.Level >= uint32(heroTable.Level) {
		_ = player.TipNotice(proto.ErrLevelAlreadyMax)
		return
	}

	var itemTables = this.tables.Item.Find2(int(pb.ItemType_ItemProp), int(pb.PropType_HeroExp))
	if len(itemTables) == 0 {
		_ = player.TipNotice(proto.ErrDataTablesError)
		return
	}

	var exp = hero.Exp
	var level = hero.Level
	var consumeItems = map[uint32]uint32{}
	for range req.Levels {
		var heroLevelTable = this.tables.HeroLevel.Find3(int(hero.Id), int(level))
		if heroLevelTable == nil {
			_ = player.TipNotice(proto.ErrDataTablesError)
			return
		}

		var hasItem = false
		for _, itemTable := range itemTables {
			var item = player.Item[uint32(itemTable.Id)]
			if item == nil || item.Num == 0 {
				continue
			}

			var consumedNum = consumeItems[item.Id]
			if item.Num <= consumedNum {
				continue
			}

			var needExp = uint64(heroLevelTable.NeedExp) - exp
			var needNums = uint32(needExp / uint64(itemTable.Value))
			if needExp%uint64(itemTable.Value) > 0 {
				needNums += 1
			}

			if item.Num-consumedNum < needNums {
				consumedNum = item.Num
				exp += uint64(itemTable.Value) * uint64(item.Num-consumedNum)
			} else {
				hasItem = true
				consumedNum += needNums
				exp += uint64(itemTable.Value) * uint64(needNums)
			}

			if exp >= uint64(heroLevelTable.NeedExp) {
				level += 1
				exp -= uint64(heroLevelTable.NeedExp)
			}
		}
		if !hasItem {
			break
		}
	}

	if exp == hero.Exp && level == hero.Level {
		return
	}

	hero.Exp = exp
	hero.Level = level

	player.SaveModel(hero)
	player.UpdateHeroAttrs(hero)

	for itemId, itemNum := range consumeItems {
		player.ReduceItem(itemId, itemNum, logic.LogTypeItemConsumeByHeroUpgrade)
	}

	_ = player.Send(uint16(pb.ModId_ModuleHero), uint16(pb.MsgId_ModHeroChange), &pb.HeroChangeListAck{
		ChangeList: []*pb.HeroChange{{ChangeType: pb.ChangeType_Changed, Hero: hero.BuildMsgHero()}},
	})

	//	switch proto.EquipType(component.Type) {
	//	case proto.EquipTypeHead:
	//		player.CheckTask(proto.TaskSection1UpgradeHeadComponents, 0, 1)
	//		player.CheckTask(proto.TaskSection1HeadComponentMaxLevel, 0, nextComponentTable.Level)
	//	case proto.EquipTypeBody:
	//		player.CheckTask(proto.TaskSection1UpgradeBodyComponents, 0, 1)
	//		player.CheckTask(proto.TaskSection1BodyComponentMaxLevel, 0, nextComponentTable.Level)
	//	case proto.EquipTypeTail:
	//		player.CheckTask(proto.TaskSection1UpgradeTailComponents, 0, 1)
	//		player.CheckTask(proto.TaskSection1TailComponentMaxLevel, 0, nextComponentTable.Level)
	//	}
	//
	//	player.UpdateRigAttrs()
	//
	//	player.CheckRigTrammelsStatus(uint32(nextComponentTable.ItemId), uint32(nextComponentTable.Level), 0)
	//
	//	player.CheckTask(proto.TaskSection1UpgradeComponents, 0, 1)
	//	player.CheckTask(proto.TaskSection1ComponentsAllLevels, 0, int(player.GetAllRigComponentLevels()))
	return
}

func (this *PlayerHandler) HeroBreak(player *logic.Player, msg *net.Message) {
	var req = new(pb.HeroBreakReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.ErrMessageError)
		return
	}

	if req.HeroUid == 0 || req.OptItemId == 0 {
		_ = player.TipNotice(proto.ErrParameterError)
		return
	}

	var hero = player.Hero[req.HeroUid]
	if hero == nil {
		_ = player.TipNotice(proto.ErrHeroNotFound)
		return
	}

	var heroTable = this.tables.Hero.Get(int(hero.Id))
	if heroTable == nil {
		_ = player.TipNotice(proto.ErrDataTablesError)
		return
	}

	if hero.BreakLevel >= uint32(heroTable.BreaksLevels) {
		_ = player.TipNotice(proto.ErrHeroBreakLevelAlreadyMax)
		return
	}

	var nextBreakLevelTable = this.tables.HeroBreak.Find3(int(hero.Id), int(hero.BreakLevel+1))
	if nextBreakLevelTable == nil {
		_ = player.TipNotice(proto.ErrDataTablesError)
		return
	}

	for i := range nextBreakLevelTable.ConsumeItems {
		err = player.CheckItem(uint32(nextBreakLevelTable.ConsumeItems[i]), uint32(nextBreakLevelTable.ConsumeNums[i]))
		if err != nil {
			_ = player.TipNotice(err)
			return
		}
	}

	var optItemId, optItemNum uint32
	for i := range nextBreakLevelTable.OptionalConsumeItems {
		if uint32(nextBreakLevelTable.OptionalConsumeItems[i]) == req.OptItemId {
			optItemId, optItemNum = uint32(nextBreakLevelTable.OptionalConsumeItems[i]), uint32(nextBreakLevelTable.OptionalConsumeNums[i])
			err = player.CheckItem(optItemId, optItemNum)
			if err != nil {
				_ = player.TipNotice(err)
				return
			}
		}
	}

	if optItemId == 0 {
		_ = player.TipNotice(proto.ErrParameterError)
		return
	}

	hero.BreakLevel = uint32(nextBreakLevelTable.BreakLevel)
	player.SaveModel(hero)
	player.UpdateHeroAttrs(hero)

	for i := range nextBreakLevelTable.ConsumeItems {
		player.ReduceItem(uint32(nextBreakLevelTable.ConsumeItems[i]), uint32(nextBreakLevelTable.ConsumeNums[i]), logic.LogTypeItemConsumeByHeroBreak)
	}

	player.ReduceItem(optItemId, optItemNum, logic.LogTypeItemConsumeByHeroBreak)
}

func (this *PlayerHandler) HeroAwaken(player *logic.Player, msg *net.Message) {

}

func (this *PlayerHandler) HeroSoul(player *logic.Player, msg *net.Message) {

}

func (this *PlayerHandler) HeroFate(player *logic.Player, msg *net.Message) {

}

func (this *PlayerHandler) HeroQuality(player *logic.Player, msg *net.Message) {

}

func (this *PlayerHandler) HeroEquip(player *logic.Player, msg *net.Message) {
	var req = new(pb.HeroEquipReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.ErrMessageError)
		return
	}

	var hero = player.Hero[req.HeroUid]
	if hero == nil {
		_ = player.TipNotice(proto.ErrHeroNotFound)
		return
	}

	var equip = player.Equip[req.EquipUid]
	if equip == nil {
		_ = player.TipNotice(proto.ErrEquipNotFound)
		return
	}

	var equipTable = this.tables.Equip.Find(int(equip.Id))
	if equipTable == nil {
		_ = player.TipNotice(proto.ErrDataTablesError)
		return
	}

	var equipIndex = 0
	switch pb.EquipType(equipTable.Type) {
	case pb.EquipType_Weapon:
		equipIndex = 0
	case pb.EquipType_Hat:
		equipIndex = 1
	case pb.EquipType_Cloth:
		equipIndex = 2
	case pb.EquipType_Shoe:
		equipIndex = 3
	default:
		_ = player.TipNotice(proto.ErrDataTablesError)
		return
	}

	var heroChangeList []*pb.HeroChange
	var equipChangeList []*pb.EquipChange

	if hero.Equips[equipIndex] != 0 {
		var setup = player.Equip[hero.Equips[equipIndex]]
		if setup != nil && setup.HeroUid != 0 {
			setup.Id = 0
			player.SaveModel(setup)
			equipChangeList = append(equipChangeList, &pb.EquipChange{
				ChangeType: pb.ChangeType_Changed,
				Equip:      setup.BuildMsgEquip(),
			})
		}
	}

	hero.Equips[equipIndex] = equip.Uid
	player.SaveModel(hero)
	heroChangeList = append(heroChangeList, &pb.HeroChange{
		ChangeType: pb.ChangeType_Changed,
		Hero:       hero.BuildMsgHero(),
	})

	if equip.HeroUid != 0 {
		var setup = player.Hero[equip.HeroUid]
		if setup != nil && setup.Equips[equipIndex] != 0 {
			setup.Equips[equipIndex] = 0
			player.SaveModel(setup)
			heroChangeList = append(heroChangeList, &pb.HeroChange{
				ChangeType: pb.ChangeType_Changed,
				Hero:       setup.BuildMsgHero(),
			})
		}
	}

	equip.HeroUid = hero.Uid
	player.SaveModel(equip)
	equipChangeList = append(equipChangeList, &pb.EquipChange{
		ChangeType: pb.ChangeType_Changed,
		Equip:      equip.BuildMsgEquip(),
	})

	_ = player.Send(uint16(pb.ModId_ModuleHero), uint16(pb.MsgId_ModHeroChange), &pb.HeroChangeListAck{ChangeList: heroChangeList})
	_ = player.Send(uint16(pb.ModId_ModuleItem), uint16(pb.MsgId_ModItemEquipChange), &pb.EquipChangeListAck{ChangeList: equipChangeList})
	return
}

func (this *PlayerHandler) HeroTreasure(player *logic.Player, msg *net.Message) {

}

func (this *PlayerHandler) HeroArtifacts(player *logic.Player, msg *net.Message) {

}

func (this *PlayerHandler) HeroTips(player *logic.Player, msg *net.Message) {

}

func (this *PlayerHandler) HeroBookActivate(player *logic.Player, msg *net.Message) {
	var req = new(pb.HeroBookActivateReq)
	var err = msg.Read(req)
	if err != nil {
		this.logger.Error("Read message failed, ", err)
		_ = player.TipNotice(proto.ErrMessageError)
		return
	}

	if req.HeroId == 0 {
		_ = player.TipNotice(proto.ErrParameterError)
		return
	}

	var heroBook = player.HeroBook[req.HeroId]
	if heroBook == nil {
		_ = player.TipNotice(proto.ErrHeroNotFound)
		return
	}

	if req.Index >= uint32(len(heroBook.Items)) {
		_ = player.TipNotice(proto.ErrParameterError)
		return
	}

	var heroBookTables = this.tables.HeroBook.Find2(int(heroBook.HeroId))
	if len(heroBookTables) != len(heroBook.Items) {
		_ = player.TipNotice(proto.ErrDataTablesError)
		return
	}

	if heroBook.Items[req.Index].Value {
		_ = player.TipNotice(proto.ErrHeroBookActivated)
		return
	}

	for _, needId := range heroBookTables[req.Index].NeedHeroes {
		if _, ok := player.HeroBook[uint32(needId)]; !ok {
			_ = player.TipNotice(proto.ErrHeroBookCanNotActivate)
			return
		}
	}

	heroBook.Items[req.Index].Value = true

	player.SaveModel(heroBook)
	for _, hero := range player.Hero {
		if hero.Id == heroBook.HeroId {
			player.UpdateHeroAttrs(hero)
		}
	}

	_ = player.Send(uint16(pb.ModId_ModuleHero), uint16(pb.MsgId_ModHeroBookChange), &pb.HeroBookChangeAck{
		ChangeType: pb.ChangeType_Changed,
		HeroBook:   heroBook.BuildMsgHeroBook(),
	})
}