package actorRemote

import (
	capp "f1-game/internal/cherry_app"
	"f1-game/internal/code"
	"f1-game/internal/enum"
	"f1-game/internal/extend/utils"
	nameActor "f1-game/internal/name/actor"
	nameRemote "f1-game/internal/name/remote"
	"f1-game/internal/pb"
	"f1-game/internal/types"
	assetOrigin "f1-game/nodes/game/player/asset/origin"

	cfacade "github.com/cherry-game/cherry/facade"
	clog "github.com/cherry-game/cherry/logger"
)

type gamePlayer struct {
}

func newGamePlayer() *gamePlayer {
	return &gamePlayer{}
}

func (p *gamePlayer) AssetAdd(gameNodeID string, playerID int64, addAssets types.Assets, ao assetOrigin.Origin) (*pb.AssetList, int32) {
	return p.assetOpt(gameNodeID, playerID, nameRemote.Player_AssetAdd, addAssets, ao)
}

// AssetAddAsync 异步添加资产
func (p *gamePlayer) AssetAddAsync(gameNodeID string, playerID int64, addAssets types.Assets, ao assetOrigin.Origin) {
	var (
		req = &pb.PlayerAddAssets{
			AddAssets: addAssets.ToProto(),
			Origin:    ao.ID,
		}
		path = cfacade.NewChildPath(gameNodeID, nameActor.GamePlayer, playerID)
	)

	errCode := capp.Call(path, nameRemote.Player_AssetAdd, req)
	if code.IsFail(errCode) {
		clog.Warnf("[playerID=%d] add assets failed. errCode: %d", playerID, errCode)
	}
}

func (p *gamePlayer) AssetCheck(gameNodeID string, playerID int64, assets types.Assets) int32 {
	var (
		req = &pb.AssetList{
			List: assets.ToProto(),
		}
		rsp  = &pb.I32{}
		path = cfacade.NewChildPath(gameNodeID, nameActor.GamePlayer, playerID)
	)

	errCode := capp.CallWait(path, nameRemote.Player_AssetCheck, req, rsp)
	if code.IsFail(errCode) {
		return errCode
	}

	return rsp.Value
}

func (p *gamePlayer) AssetSub(gameNodeID string, playerID int64, subAssets types.Assets, ao assetOrigin.Origin) (*pb.AssetList, int32) {
	return p.assetOpt(gameNodeID, playerID, nameRemote.Player_AssetSub, subAssets, ao)
}

func (p *gamePlayer) assetOpt(gameNodeID string, playerID int64, fn string, assets types.Assets, ao assetOrigin.Origin) (*pb.AssetList, int32) {
	var (
		req = &pb.PlayerAddAssets{
			AddAssets: assets.ToProto(),
			Origin:    ao.ID,
		}
		rsp  = &pb.AssetList{}
		path = cfacade.NewChildPath(gameNodeID, nameActor.GamePlayer, playerID)
	)

	errCode := capp.CallWait(path, fn, req, rsp)
	return rsp, errCode
}

// 调用gm指令
func (p *gamePlayer) SendGM(gameNodeID string, playerID int64, gm string) int32 {
	req := &pb.Str{
		Value: gm,
	}

	errCode := p.CallWait(gameNodeID, playerID, nameRemote.Player_SendGM, req, nil)

	return errCode
}

// 获取玩家信息
func (p *gamePlayer) GetPlayerInfo(gameNodeID string, playerID int64) (int32, *pb.PlayerDetailInfo) {
	req := &pb.I64{
		Value: playerID,
	}
	resp := &pb.PlayerDetailInfo{}

	errCode := p.CallWait(gameNodeID, playerID, nameRemote.Player_GetInfo, req, resp)

	return errCode, resp
}

func (p *gamePlayer) GamePlayerCallSystemMsg(gameNodeID string, playerID int64, msgType enum.ChatMsgType, asserts types.Assets, points types.Points, params ...any) {
	targetPath := cfacade.NewChildPath(gameNodeID, nameActor.GamePlayer, playerID)
	req := &pb.ParamsTemplate{
		Type:   int32(msgType),
		Params: utils.ToStringSlice(params...),
	}

	if asserts != nil {
		assertListProto := asserts.ToAssetListProto()
		req.Assets = &assertListProto
	}

	if points != nil {
		req.Points = points.ToProtos()
	}

	capp.Call(targetPath, nameRemote.Player_ChatMapSystemMsg, req)
}

func (p *gamePlayer) CallWait(gameNodeID string, playerID int64, funcName string, req, resp any) int32 {
	path := cfacade.NewChildPath(gameNodeID, nameActor.GamePlayer, playerID)
	return capp.CallWait(path, funcName, req, resp)
}

func (p *gamePlayer) Call(gameNodeID string, playerID int64, funcName string, req any) int32 {
	path := cfacade.NewChildPath(gameNodeID, nameActor.GamePlayer, playerID)
	return capp.Call(path, funcName, req)
}