package sessions

import (
	cherryApp "f1-game/internal/cherry_app"
	"f1-game/internal/constant"
	nameActor "f1-game/internal/name/actor"
	nameRemote "f1-game/internal/name/remote"
	"f1-game/internal/pb"

	cherryFacade "github.com/cherry-game/cherry/facade"
	clog "github.com/cherry-game/cherry/logger"
	"github.com/cherry-game/cherry/net/parser/pomelo"
	cproto "github.com/cherry-game/cherry/net/proto"
)

func PushWithSession(session *cproto.Session, route string, v any) {
	pomelo.PushWithUID(actor, session.AgentPath, session.Uid, route, v)
}

func PushPlayer(playerID int64, route string, v any) {
	session, found := GetSession(playerID)
	if !found {
		clog.Warnf("[PushPlayer] Session not found. [playerID = %d, route = %s]", playerID, route)
		return
	}

	pomelo.PushWithUID(actor, session.AgentPath, session.Uid, route, v)
}

func PushPlayers(playerIDS []int64, route string, v any) {
	agentPathUIDMaps := GetAgentPathWithPlayerIDS(playerIDS)

	for agentPath, uids := range agentPathUIDMaps {
		pomelo.PushWithUIDS(actor, agentPath, uids, false, route, v)
	}
}

func PushGame(gameNodeID string, route string, v any) {
	data, err := cherryApp.Serializer().Marshal(v)
	if err != nil {
		clog.Warnf("[PushGame] Marshal error. data = %+v", v)
		return
	}

	rsp := &pb.GatePusher{
		Type:     pb.GatePusher_GameNode,
		StrValue: gameNodeID,
		Route:    route,
		Data:     data,
	}

	cherryApp.CallType(constant.NodeGate, nameActor.GateUser, nameRemote.User_PlayerPush, rsp)
}

func PushMap(mapNodeID string, route string, v any) {
	data, err := cherryApp.Serializer().Marshal(v)
	if err != nil {
		clog.Warnf("[PushMap] Marshal error. data = %+v", v)
		return
	}

	rsp := &pb.GatePusher{
		Type:     pb.GatePusher_Map,
		StrValue: mapNodeID,
		Route:    route,
		Data:     data,
	}

	cherryApp.CallType(constant.NodeGate, nameActor.GateUser, nameRemote.User_PlayerPush, rsp)
}

func KickPlayer(playerID int64, reason any, closed bool) {
	session, found := GetSession(playerID)
	if !found {
		clog.Debugf("[KickPlayer] Kick fail,session not found. [playerID = %d, reason = %s, close = %v]",
			playerID, reason, closed,
		)
		return
	}

	pomelo.KickUID(actor, session.AgentPath, session.Uid, reason, closed)
}

func KickPlayers(playerIDS []int64, reason any, closed bool) {
	reasonData, err := cherryApp.Serializer().Marshal(reason)
	if err != nil {
		clog.Warnf("[KickPlayers] Marshal error. reason = %+v", reason)
		return
	}

	rsp := &pb.GateKick{
		Type:    pb.GateKick_Player,
		I64List: playerIDS,
		Reason:  reasonData,
		Closed:  closed,
	}

	cherryApp.ActorSystem().CallType(
		constant.NodeGate,
		nameActor.GateUser,
		nameRemote.User_PlayerKick,
		rsp,
	)
}

func KickUIDS(uids []cherryFacade.UID, reason any, closed bool, filterNodeID ...string) {
	reasonData, err := cherryApp.Serializer().Marshal(reason)
	if err != nil {
		clog.Warnf("[KickUIDS] Marshal error. reason = %+v", reason)
		return
	}

	rsp := &pb.GateKick{
		Type:          pb.GateKick_UID,
		I64List:       uids,
		Reason:        reasonData,
		Closed:        closed,
		FilterNodeIDS: filterNodeID,
	}

	cherryApp.ActorSystem().CallType(
		constant.NodeGate,
		nameActor.GateUser,
		nameRemote.User_PlayerKick,
		rsp,
	)
}

func KickGame(gameNodeID string, reason any, closed bool) {
	reasonData, err := cherryApp.Serializer().Marshal(reason)
	if err != nil {
		clog.Warnf("[KickGame] Marshal error. reason = %+v", reason)
		return
	}

	rsp := &pb.GateKick{
		Type:     pb.GateKick_GameNode,
		StrValue: gameNodeID,
		Reason:   reasonData,
		Closed:   closed,
	}

	cherryApp.CallType(
		constant.NodeGate,
		nameActor.GateUser,
		nameRemote.User_PlayerKick,
		rsp,
	)
}

func KickMap(mapNodeID string, reason any, closed bool) {
	reasonData, err := cherryApp.Serializer().Marshal(reason)
	if err != nil {
		clog.Warnf("[KickMap] Marshal error. reason = %+v", reason)
		return
	}

	rsp := &pb.GateKick{
		Type:     pb.GateKick_MapNode,
		StrValue: mapNodeID,
		Reason:   reasonData,
		Closed:   closed,
	}

	cherryApp.CallType(
		constant.NodeGate,
		nameActor.GateUser,
		nameRemote.User_PlayerKick,
		rsp,
	)
}