package currency

import (
	"f1-game/internal/code"
	"f1-game/internal/data"
	"f1-game/internal/enum"
	facade "f1-game/internal/facade"
	nameRoute "f1-game/internal/name/route"
	"f1-game/internal/pb"
	"f1-game/internal/sessions"
	"f1-game/internal/types"
	"f1-game/nodes/game/internal/db"
	ao "f1-game/nodes/game/player/asset/origin"
)

var (
	srv = newService()
)

func newService() *service {
	instance := &service{}
	instance.load()

	return instance
}

func Service() *service {
	return srv
}

type service struct {
	facade.PlayerServiceBase[*db.PlayerTable]
}

func (p *service) load() {
}

// func (p *service) OnLogin(playerTable *db.PlayerTable, session *cproto.Session) {
// }

// func (p *service) OnLogined(playerTable *db.PlayerTable, session *cproto.Session) {
// }

// func (p *service) OnLogout(playerTable *db.PlayerTable) {
// }

// func (p *service) OnReset(playerTable *db.PlayerTable, time *ctime.CherryTime, byLogin bool) {
// }

// func (p *service) Push(playerTable *db.PlayerTable, session *cproto.Session) {
// }

// ChangePush 道具变更推送
func (p *service) ChangePush(playerID int64, idList ...int32) {
	if len(idList) < 1 {
		return
	}

	var (
		itemTable = db.GetItemTable(playerID)
		rsp       = &pb.ItemList{
			Currencies: map[int32]*pb.Currency{},
		}
	)

	for _, id := range idList {
		// 不推送地图里面的资源
		if enum.IsMapCurrency(id) {
			continue
		}

		entity := itemTable.CurrencyMap.GetEntity(id)
		proto := entity.ToProto()
		rsp.Currencies[entity.ID] = &proto
	}

	if len(rsp.Currencies) < 1 {
		return
	}

	sessions.PushPlayer(playerID, nameRoute.PushGamePlayer_ItemChange, rsp)
}

func (p *service) Contain(playerID int64, id int32) int32 {
	itemTable := db.GetItemTable(playerID)

	if _, found := data.Item.GetByID(id); !found {
		return code.ConfigNotFound_Item
	}

	if itemTable.CurrencyMap.Get(id) < 1 {
		return code.ItemNotEnough
	}

	return code.OK
}

func (p *service) Enough(playerID int64, id int32, num int64) bool {
	itemTable := db.GetItemTable(playerID)
	availableNum := itemTable.CurrencyMap.Get(id)
	if availableNum < 1 || availableNum < num {
		return false
	}

	return true
}

func (p *service) Add(playerID int64, id int32, num int64, origin ao.Origin, save, push bool) (types.Asset, int32) {
	itemTable := db.GetItemTable(playerID)

	row, found := data.Item.GetByID(id)
	if !found {
		return types.NoneAsset, code.ConfigNotFound_Item
	}

	if row.ParseType != enum.AssetType_Currency {
		return types.NoneAsset, code.CurrencyTypeError
	}

	if num < 1 {
		return types.NoneAsset, code.ItemNumError
	}

	_, ok := itemTable.CurrencyMap.Increase(id, num)
	if !ok {
		return types.NoneAsset, code.ItemNotEnough
	}

	if save {
		itemTable.Save2Queue()
	}

	if push {
		p.ChangePush(playerID, id)
	}

	returnAsset := types.Asset{
		ID:  id,
		Num: num,
	}

	return returnAsset, code.OK
}

func (p *service) Sub(playerID int64, id int32, num int64, origin ao.Origin, save, push bool) int32 {
	itemTable := db.GetItemTable(playerID)

	if num < 1 {
		return code.ItemNumError
	}

	_, found := data.Item.GetByID(id)
	if !found {
		return code.ConfigNotFound_Item
	}

	// 优先扣除绑定资源，再扣除非绑定资源
	changeAssets, ok := itemTable.CurrencyMap.Decrease(id, num)
	if !ok {
		return code.ItemNotEnough
	}

	if save {
		itemTable.Save2Queue()
	}

	var changeIDList []int32
	for _, asset := range changeAssets {
		changeIDList = append(changeIDList, asset.ID)
	}

	if push {
		p.ChangePush(playerID, changeIDList...)
	}

	return code.OK
}