package mapCall

import (
	capp "f1-game/internal/cherry_app"
	"f1-game/internal/code"
	"f1-game/internal/enum"
	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"
	dbLogic "f1-game/nodes/map/internal/db/data/logic"

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

var (
	Player = &playerCall{}
)

type playerCall struct{}

func (p *playerCall) AutoMarchRequest(playerID, leagueID int64, objectID int64, segments types.List[*dbLogic.AutoMarchSegment]) {
	req := &pb.AutoMarchRequest{
		PlayerID: playerID,
		LeagueID: leagueID,
		ObjectID: objectID,
	}

	for _, segment := range segments {
		req.List = append(req.List, &pb.AutoMarchReqestData{
			MarchType: int32(segment.MarchType),
			Start:     segment.StartPoint.ToProto(),
			End:       segment.EndPoint.ToProto(),
		})
	}

	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_AutoMarchRequest, req)
}

func (p *playerCall) NotifyRebornPush(playerID int64, x, y int32) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_NotifyRebornPush, &pb.Point{
		X: x,
		Y: y,
	})
}

func (p *playerCall) AutoDefendRequest(playerID, buildObjectID int64, teamIDs []int32) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_AutoDefendRequest, &pb.AutoDefendRequest{
		BuildObjectID: buildObjectID,
		TeamIDs:       teamIDs,
	})
}

func (p *playerCall) UpdateTeam(playerID int64, req *pb.UpdateTeam) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_UpdateTeam, req)
}

func (p *playerCall) AddAsset(playerID int64, itemID int32, itemCount int64, ao assetOrigin.Origin) int32 {
	addAssets := types.Assets{
		{
			ID:  itemID,
			Num: itemCount,
		},
	}
	return p.AddAssets(playerID, addAssets, ao)
}

func (p *playerCall) AddAssets(playerID int64, addAssets types.Assets, ao assetOrigin.Origin) int32 {
	return p.AddPBAssets(playerID, addAssets.ToProto(), ao)
}

func (p *playerCall) AddPBAssets(playerID int64, addAssets []*pb.Asset, ao assetOrigin.Origin) int32 {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_AssetAdd, &pb.PlayerAddAssets{
		AddAssets: addAssets,
		Origin:    ao.ID,
	})

	return code.OK
}

func (p *playerCall) UpdateWatcherPoint(playerID int64, point *pb.Point) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_UpdateWatcherPoint, point)
}

func (p *playerCall) MainCitySiege(playerID int64, mainCityObjectID int64) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_MainCitySiege, &pb.I64{
		Value: mainCityObjectID,
	})
}

func (p *playerCall) AutoDefendQuit(playerID, buildObjectID int64) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_AutoDefendQuit, &pb.I64{
		Value: buildObjectID,
	})
}

// AutoReborn 玩家自动重生
func (p *playerCall) AutoReborn(playerID int64) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_AutoReborn, nil)
}

func (p *playerCall) AutoRetreat(playerID int64, teamID int32, retreatState enum.MarchState, isRemoveRedeploy bool) {
	req := &pb.AutoRetreat{
		TeamID:           teamID,
		MarchState:       int32(retreatState),
		IsRemoveRedeploy: isRemoveRedeploy,
	}
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_AutoRetreat, req)
}

func (p *playerCall) MapPlayerBattleStart(playerID int64, req *pb.BattleReq) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_BattleStart, req)
}

func (p *playerCall) MapPlayerUpdateTeamState(playerID int64, teamID int32, teamState enum.TeamState) {
	target := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	req := &pb.I32I32{Key: teamID, Value: int32(teamState)}

	capp.Call(target, nameRemote.MapPlayer_UpdateTeamState, req)
}

func (p *playerCall) BattleReportAdd(playerID int64, req *pb.ReportGroup) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_ReportAdd, req)
}

func (p *playerCall) SubTeamTroopsNum(playerID int64, req *pb.TeamBattleDamage) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayer_SubTeamTroopsNum, req)
}

func (p *playerCall) ExchangeItemDeliver(req *pb.PlayerExchangeItemDeliver) int32 {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, req.PlayerID)
	return capp.Call(targetPath, nameRemote.MapPlayerExchange_ItemDeliver, req)
}

func (p *playerCall) ExchangeItemRetrieve(playerID int64, req *pb.ExchangeDetail) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayerExchange_ItemRetrieve, req)
}

func (p *playerCall) ExchangeItemCanceled(playerID int64, req *pb.ExchangeDetail) {
	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayerExchange_ItemCanceled, req)
}

func (p *playerCall) ExchangeItemRemove(playerID int64, actType enum.ExchangeActType, transactionID string) {
	req := &pb.I32Str{
		Key:   int32(actType),
		Value: transactionID,
	}

	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapPlayerExchange_ItemRemove, req)
}

func (p *playerCall) ScoutSearch(queueID int32, playerID, targetPlayerID int64) int32 {
	req := &pb.I32I64{
		Key:   queueID,
		Value: playerID,
	}

	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, targetPlayerID)
	errCode := capp.Call(targetPath, nameRemote.MapScout_Seach, req)

	return errCode
}

func (p *playerCall) ScoutSearchResult(queueID int32, playerID, targetPlayerID int64, targetPlayerName string, assets *types.Assets) {
	proto := assets.ToAssetListProto()

	req := &pb.ScoutSearchResult{
		QueueID:          queueID,
		TargetPlayerID:   targetPlayerID,
		TargetPlayerName: targetPlayerName,
		Assets:           &proto,
	}

	targetPath := cfacade.NewChildPath("", nameActor.Map_Player, playerID)
	capp.Call(targetPath, nameRemote.MapScout_SeachResult, req)
}