package logic

import (
	"ecs/proto"
	"ecs/proto/pb"
	"ecs/servers/game/data"
)

type PlayerItem struct {
	Id      uint32 `bson:"id" key:"1"`
	Num     uint32 `bson:"num"`
	Expired int64  `bson:"expired"`
}

func (this *PlayerItem) BuildMsgItem(deleted ...bool) *pb.Item {
	if len(deleted) > 0 && deleted[0] {
		return &pb.Item{ItemId: this.Id}
	}
	return &pb.Item{ItemId: this.Id, ItemNum: this.Num, Expired: this.Expired}
}

func (this *Player) saveItem(itemTable *data.Item, itemNum uint32, logType LogType) *pb.ItemChange {
	var changeType = pb.ChangeType_Changed
	var item = this.Item[uint32(itemTable.Id)]

	if item == nil {
		item = &PlayerItem{Id: uint32(itemTable.Id), Num: itemNum}
		this.Item[item.Id] = item

		changeType = pb.ChangeType_Add
	} else {
		item.Num += itemNum
	}

	this.SaveModel(item)

	//this.CheckTask(proto.TaskSection1CollectSpecificItem, itemTable.Id, int(itemNum))

	//if logType > 0 {
	//	this.manager.eventManager.PlayerItemObtain(this, logType, uint32(itemTable.Id), itemNum)
	//}

	return &pb.ItemChange{ChangeType: changeType, Item: item.BuildMsgItem()}
}

func (this *Player) addItem(itemTable *data.Item, itemNum uint32, logType LogType) (itemChange *pb.ItemChange, ok bool) {
	if itemTable.UseDirect {
		return nil, this.useItem(itemTable, itemNum, logType)
	}

	switch pb.ItemType(itemTable.Type) {
	case pb.ItemType_ItemProp:
		itemChange = this.saveItem(itemTable, itemNum, logType)
	case pb.ItemType_ItemMoney:
		ok = this.AddMoney(pb.MoneyType(itemTable.SubType), itemNum, logType)
	case pb.ItemType_ItemHero:
		if pb.HeroType(itemTable.SubType) == pb.HeroType_HeroPiece {
			itemChange = this.saveItem(itemTable, itemNum, logType)
		} else {
			ok = this.AddHero(uint32(itemTable.Value))
		}
	case pb.ItemType_ItemEquip:
		if pb.EquipType(itemTable.SubType) == pb.EquipType_EquipPiece {
			itemChange = this.saveItem(itemTable, itemNum, logType)
		} else {
			ok = this.AddEquips(uint32(itemTable.Value), itemNum, logType)
		}
	case pb.ItemType_ItemTreasure:
		if pb.TreasureType(itemTable.SubType) == pb.TreasureType_TreasurePiece {
			itemChange = this.saveItem(itemTable, itemNum, logType)
		} else {
			ok = this.AddTreasures(uint32(itemTable.Value), itemNum, logType)
		}
	case pb.ItemType_ItemArtifact:
	case pb.ItemType_ItemSack:
	case pb.ItemType_ItemOrnament:
	case pb.ItemType_ItemFateChart:
	case pb.ItemType_ItemJade:
	case pb.ItemType_ItemArtifactJade:
	case pb.ItemType_ItemAwakenProp:
	case pb.ItemType_ItemGeneral:
	case pb.ItemType_ItemGeneralWeapon:
	case pb.ItemType_ItemTetris:
	case pb.ItemType_ItemHolyBeast:
	case pb.ItemType_ItemMascot:
	case pb.ItemType_ItemHarness:
	case pb.ItemType_ItemMountAmulet:
	case pb.ItemType_ItemHolyWeapon:
	}
	return
}

func (this *Player) useItem(itemTable *data.Item, itemNum uint32, logType LogType) bool {
	switch pb.ItemType(itemTable.Type) {
	case pb.ItemType_ItemMoney:
		this.AddMoney(pb.MoneyType(itemTable.SubType), uint32(itemTable.Value)*itemNum, logType)
	case pb.ItemType_ItemProp:
	default:
		return false
	}
	return true
}

func (this *Player) AddItem(itemId, itemNum uint32, logType LogType) bool {
	var itemTable = this.manager.tables.Item.Find1(int(itemId))
	if itemTable == nil {
		this.manager.logger.Error("Data table error, item table was not found, itemId: ", itemId)
		return false
	}

	itemChange, ok := this.addItem(itemTable, itemNum, logType)
	if itemChange != nil {
		_ = this.Send(pb.ModId_ModuleItem, pb.MsgId_ModItemChange, &pb.ItemChangeListAck{ChangeList: []*pb.ItemChange{itemChange}})
	}
	return ok
}

func (this *Player) AddItems(itemMap map[uint32]uint32, logType LogType) {
	var changeList []*pb.ItemChange
	for itemId, itemNum := range itemMap {
		var itemTable = this.manager.tables.Item.Find1(int(itemId))
		if itemTable == nil {
			this.manager.logger.Error("Data table error, item table was not found, itemId: ", itemId)
			continue
		}

		itemChange, _ := this.addItem(itemTable, itemNum, logType)
		if itemChange != nil {
			changeList = append(changeList, itemChange)
		}
	}

	if len(changeList) > 0 {
		_ = this.Send(pb.ModId_ModuleItem, pb.MsgId_ModItemChange, &pb.ItemChangeListAck{ChangeList: changeList})
	}
}

func (this *Player) checkItem(itemId, itemNum uint32) bool {
	var item = this.Item[itemId]
	return item != nil && item.Num >= itemNum
}

func (this *Player) CheckItem(itemId, itemNum uint32) (bool, proto.TipError) {
	if itemId == 0 || itemNum == 0 {
		this.manager.logger.Errorf("Parameter error, itemId: %d, itemNum: %d", itemId, itemNum)
		return false, proto.TipParameterError
	}

	var itemTable = this.manager.tables.Item.Find1(int(itemId))
	if itemTable == nil {
		this.manager.logger.Error("Data table error, item table was not found, itemId: ", itemId)
		return false, proto.TipDataTablesError
	}

	switch pb.ItemType(itemTable.Type) {
	case pb.ItemType_ItemMoney:
		return this.CheckMoney(pb.MoneyType(itemTable.SubType), itemNum)
	case pb.ItemType_ItemProp:
		if this.checkItem(itemId, itemNum) {
			return true, nil
		}
		return false, proto.TipItemNotEnough
	case pb.ItemType_ItemHero:
	case pb.ItemType_ItemEquip:
	case pb.ItemType_ItemTreasure:
		if this.CheckTreasure(uint32(itemTable.Value), itemNum) {
			return true, nil
		}
		return false, proto.TipItemNotEnough
	case pb.ItemType_ItemArtifact:
	case pb.ItemType_ItemSack:
	case pb.ItemType_ItemOrnament:
	case pb.ItemType_ItemFateChart:
	case pb.ItemType_ItemJade:
	case pb.ItemType_ItemArtifactJade:
	case pb.ItemType_ItemAwakenProp:
	case pb.ItemType_ItemGeneral:
	case pb.ItemType_ItemGeneralWeapon:
	case pb.ItemType_ItemTetris:
	case pb.ItemType_ItemHolyBeast:
	case pb.ItemType_ItemMascot:
	case pb.ItemType_ItemHarness:
	case pb.ItemType_ItemMountAmulet:
	case pb.ItemType_ItemHolyWeapon:
	default:
		return false, proto.TipUnknownItemType
	}
	return false, proto.TipUnknownItemType
}

func (this *Player) reduceItem(itemId, itemNum uint32, logType LogType) {
	var item = this.Item[itemId]
	if item == nil || item.Num < itemNum {
		this.manager.logger.Error("Reduce item out of range, did not check before deducting?")
		return
	}

	item.Num -= itemNum

	var deleted = false
	var changeType pb.ChangeType
	if item.Num == 0 {
		delete(this.Item, item.Id)
		this.WipeModel(item)
		deleted = true
		changeType = pb.ChangeType_Delete
	} else {
		this.SaveModel(item)
		changeType = pb.ChangeType_Changed
	}

	_ = this.Send(pb.ModId_ModuleItem, pb.MsgId_ModItemChange, &pb.ItemChangeListAck{ChangeList: []*pb.ItemChange{{Item: item.BuildMsgItem(deleted), ChangeType: changeType}}})

	//if logType > LogTypeNone {
	//	this.manager.eventManager.PlayerItemConsume(this, logType, itemId, itemNum)
	//}
}

func (this *Player) ReduceItem(itemId, itemNum uint32, logType LogType) {
	if itemId == 0 || itemNum == 0 {
		return
	}

	var itemTable = this.manager.tables.Item.Find1(int(itemId))
	if itemTable == nil {
		return
	}

	switch pb.ItemType(itemTable.Type) {
	case pb.ItemType_ItemMoney:
		this.ReduceMoney(pb.MoneyType(itemTable.SubType), itemNum, logType)
	case pb.ItemType_ItemProp:
		this.reduceItem(itemId, itemNum, logType)
	case pb.ItemType_ItemHero:
	case pb.ItemType_ItemEquip:
	case pb.ItemType_ItemTreasure:
		this.ReduceTreasure(uint32(itemTable.Value), itemNum, logType)
	case pb.ItemType_ItemArtifact:
	case pb.ItemType_ItemSack:
	case pb.ItemType_ItemOrnament:
	case pb.ItemType_ItemFateChart:
	case pb.ItemType_ItemJade:
	case pb.ItemType_ItemArtifactJade:
	case pb.ItemType_ItemAwakenProp:
	case pb.ItemType_ItemGeneral:
	case pb.ItemType_ItemGeneralWeapon:
	case pb.ItemType_ItemTetris:
	case pb.ItemType_ItemHolyBeast:
	case pb.ItemType_ItemMascot:
	case pb.ItemType_ItemHarness:
	case pb.ItemType_ItemMountAmulet:
	case pb.ItemType_ItemHolyWeapon:
	}
}

func (this *Player) ReduceItems(itemMap map[uint32]uint32, logType LogType) {
	for itemId, itemNum := range itemMap {
		this.ReduceItem(itemId, itemNum, logType)
	}
}

func (this *Player) BuildMsgItemListAck() *pb.ItemListAck {
	var list []*pb.Item
	for _, item := range this.Item {
		if item.Id > 0 {
			list = append(list, item.BuildMsgItem())
		}
	}
	return &pb.ItemListAck{ItemList: list}
}