using Google.Protobuf;
using Google.Protobuf.WellKnownTypes;


using ServerCore;
using ServerBase;
using ServerCommon;
using ServerCommon.BusinessLogDomain;
using MetaAssets;


using static ClientToGameReq.Types;
using static ClientToGameRes.Types;


namespace GameServer.PacketHandler;

[PacketHandler(typeof(ClientToGameReq), typeof(ClientToGameReq.Types.C2GS_REQ_BATTLE_PLAYER_RESPAWN), typeof(BattlePlayerRespawnPacketHandler), typeof(GameLoginListener))]
public class BattlePlayerRespawnPacketHandler : PacketRecvHandler
{
    public override async Task<Result> onProcessPacket(ISession entityWithSession, Google.Protobuf.IMessage recvMessage)
    {
        await Task.CompletedTask;

        var result = new Result();
        var err_msg = string.Empty;
        
        var server_logic = GameServerApp.getServerLogic();
        
        var player = entityWithSession as Player;
        NullReferenceCheckHelper.throwIfNull(player, () => $"player is null !!!");
        
        var server_config = server_logic.getServerConfig();
        bool is_battle_system_active = server_config.BattleSystemEnable;

        if (false == is_battle_system_active)
        {
            err_msg = $"is_battle_system_active is false!!!";
            result.setFail(ServerErrorCode.BattleInstanceInActive, err_msg);
            Log.getLogger().error(err_msg);
            send_S2C_ACK_BATTLE_PLAYER_RESPAWN(player, null, result);
            return result;
        }

        var room_id = player.getCurrentInstanceRoomId();
        var battle_instance_room = BattleInstanceManager.It.getBattleInstanceRoom(room_id);
        if (battle_instance_room == null)
        {
            err_msg = $"battle_instance_room is null : room_id - {room_id}";
            Log.getLogger().error(err_msg);
            result.setFail(ServerErrorCode.BattleInstanceInfoNotExist, err_msg);
            send_S2C_ACK_BATTLE_PLAYER_RESPAWN(player, null, result);
            return result;
        }
        
        var req_msg = recvMessage as ClientToGame;
        ArgumentNullReferenceCheckHelper.throwIfNull(req_msg, () => $"req_msg is null !!! - {player.toBasicString()}");

        var request = req_msg.Request.ReqBattlePlayerRespawn;
        if (null == request)
        {
            err_msg = $"failed to get request message : Invalid Request message - {req_msg.Request.MsgCase}";
            Log.getLogger().error(err_msg);
            result.setFail(ServerErrorCode.InvalidArgument, err_msg);
            send_S2C_ACK_BATTLE_PLAYER_RESPAWN(player, null, result);
            return result;
        }
        
        var packet_create_time = request.PacketCreateTime;
        if (packet_create_time is not null)
        {
            Log.getLogger().info($"Battle Player respawn packet received packetCreateTime : {packet_create_time}, player : {player.toBasicString()}");
        }
        
        
        AnchorInfo? anchor_info = null;
        var attribute = battle_instance_room.getEntityAttribute<BattleInstanceSnapshotAttribute>();
        var next_respawn_time = DateTimeHelper.Current;
        NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
        using (var releaser = await battle_instance_room.getAsyncLock())
        {
            

            (result, var pos_meta_guid) = BattleRoomHelper.getRandomRespawnPos(attribute, battle_instance_room);
            if (result.isFail())
            {
                send_S2C_ACK_BATTLE_PLAYER_RESPAWN(player, null, result);
                return result;
            }
        
            if (false == battle_instance_room.m_respawn_pos_anchors_meta.Contains(pos_meta_guid))
            {
                err_msg = $"respawn pos meta not exist pos_meta_guid : {pos_meta_guid}";
                result.setFail(ServerErrorCode.BattleInstanceUsableSpawnPointNotExist, err_msg);
                send_S2C_ACK_BATTLE_PLAYER_RESPAWN(player, null, result);
                return result;
            }
            
            var now = DateTimeHelper.Current;
            next_respawn_time = now.AddSeconds(battle_instance_room.m_ffa_config_meta.PlayerRespawnTime);

            attribute.m_combat_pod_mode.m_respawns.AddOrUpdate(pos_meta_guid, next_respawn_time, (key, old) => next_respawn_time);
            attribute.modifiedEntityAttribute(true);

            if (false == battle_instance_room.m_instance_room.getMap().m_anchors.TryGetValue(pos_meta_guid, out var anchorInfo))
            {
                err_msg = $"anchorInfo not exist pos_meta_guid : {pos_meta_guid}";
                result.setFail(ServerErrorCode.BattleInstanceNotExistAnchors, err_msg);
                send_S2C_ACK_BATTLE_PLAYER_RESPAWN(player, null, result);
                return result;
            }

            anchor_info = anchorInfo;
            
        }
        var cloned_anchor_pos = anchor_info.AnchorPos.Clone();
        cloned_anchor_pos.Z += 100;
        
        send_S2C_ACK_BATTLE_PLAYER_RESPAWN(player, cloned_anchor_pos, result);
        BattleRoomNotifyHelper.send_GS2C_NTF_PLAYER_RESPAWN(battle_instance_room, cloned_anchor_pos, player);

        //로그 남긴다.
        var invokers = new List<ILogInvoker>();
        var log_action = new LogActionEx(LogActionType.BattleUserRespawn);

        var round = attribute.m_combat_pod_mode.m_current_round;
        var round_state = attribute.m_combat_pod_mode.m_round_state_type;
        var users = battle_instance_room.m_instance_room.tryGetInstanceExistUserForLog();
        BattleRespawnBusinessLog business_log = new(room_id, round, round_state, player.getUserGuid(), player.getUserNickname(), anchor_info.AnchorGuid, next_respawn_time);
        invokers.Add(business_log);
        BusinessLogger.collectLogs(log_action, player, invokers);
        
        
        return result;
    }

    public bool send_S2C_ACK_BATTLE_PLAYER_RESPAWN(Player player, Pos? pos, Result result)
    {
        var ack_packet = new ClientToGame();
        ack_packet.Response = new ClientToGameRes();

        ack_packet.Response.ErrorCode = result.ErrorCode;
        ack_packet.Response.AckBattlePlayerRespawn = new ClientToGameRes.Types.GS2C_ACK_BATTLE_PLAYER_RESPAWN();

        if (result.isSuccess() && pos is not null)
        {
            ack_packet.Response.AckBattlePlayerRespawn.Pos = pos;
        }
        
        if (false == GameServerApp.getServerLogic().onSendPacket(player, ack_packet))
        {
            return false;
        }

        return true;
    }
}