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_DEATH), typeof(BattlePlayerDeadPacketHandler), typeof(GameLoginListener))]
public class BattlePlayerDeadPacketHandler : 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_DEATH(player, 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_DEATH(player, result);
            return result;
        }
        
        var req_msg = recvMessage as ClientToGame;
        ArgumentNullReferenceCheckHelper.throwIfNull(req_msg, () => $"req_msg is null !!! - {player.toBasicString()}");

        var request = req_msg.Request.ReqBattlePlayerDeath;
        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_DEATH(player, result);
            return result;
        }

        var killer_guid = request.KillerGuid;
        var packet_create_time = request.PacketCreateTime;

        if (packet_create_time is not null)
        {
            Log.getLogger().info($"Player Deat packet received room_id : {room_id}, anchor_guid : {killer_guid}, packetCreateTime : {packet_create_time}, player : {player.toBasicString()}");
        }
        
        result = await playerDeadProcess(player, killer_guid, battle_instance_room);
        if (result.isFail()) return result;

        await killUserQuestCheck(killer_guid, battle_instance_room);

        return result;
    }

    public async Task killUserQuestCheck(string killerGuid, BattleInstanceRoom battleInstanceRoom)
    {
        battleInstanceRoom.m_instance_room.tryGetInstanceMember(killerGuid, out var killer);

        if (killer is null)
        {
            Log.getLogger().warn($"killer User not exist instance killerGuid : {killerGuid}, roomId :{battleInstanceRoom.m_instance_room.getMap().m_room_id} ");
            return;
        }

        var attribute = battleInstanceRoom.getEntityAttribute<BattleInstanceSnapshotAttribute>();
        NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
        if (false == attribute.m_combat_pod_mode.m_tactical_board.TryGetValue(killerGuid, out var boradInfo))
        {
            Log.getLogger().warn($"killer User not exist m_tactical_board killerGuid : {killerGuid}, roomId :{battleInstanceRoom.m_instance_room.getMap().m_room_id} ");
            return;
        }

        var kill_count = boradInfo.m_kill_count;
        await QuestManager.It.QuestCheck(killer, new QuestTpsPlayerKill(EQuestEventTargetType.TPS, EQuestEventNameType.PLAYERKILL, kill_count));
    }

    public async Task<Result> playerDeadProcess(Player player, string kilerUserGuid, BattleInstanceRoom battleInstanceRoom)
    {
        var dead_user_guid = player.getUserGuid();
        var dead_user_nickname = player.getUserNickname();
        
        var attribute = battleInstanceRoom.getEntityAttribute<BattleInstanceSnapshotAttribute>();
        NullReferenceCheckHelper.throwIfNull(attribute, () => $"attribute is null !!!");
        
        var fn_player_dead = async delegate()
        {
   
            bool need_pod_combat_drop_noti = false;
            using (var releaser = await battleInstanceRoom.getAsyncLock())
            {
                increaseKillDeadCount(attribute, kilerUserGuid, dead_user_guid);

                var current_owner_guid = attribute.m_combat_pod_mode.m_pod_combat.m_current_occupier_guid;
                need_pod_combat_drop_noti = dead_user_guid.Equals(current_owner_guid);
                
                if (need_pod_combat_drop_noti)
                {
                    attribute.m_combat_pod_mode.m_pod_combat.changeDropState(player.getCurrentPositionInfo().Pos);
                    attribute.modifiedEntityAttribute(true);
                }
            }

            Result fn_result = new();
            send_S2C_ACK_BATTLE_PLAYER_DEATH(player, fn_result);
            BattleRoomNotifyHelper.send_GS2C_NTF_PLAYER_DEATH(battleInstanceRoom, kilerUserGuid, dead_user_guid, player);
            if (need_pod_combat_drop_noti)
            {
                BattleRoomNotifyHelper.broadcast_GS2C_NTF_POD_COMBAT_STATE(battleInstanceRoom);    
            }

            battleInstanceRoom.m_instance_room.tryGetInstanceMember(kilerUserGuid, out var killer_player);
            string killer_nickname = string.Empty;
            if (killer_player is not null)
            {
                killer_nickname = killer_player.getUserNickname();
            }

            var log_action = new LogActionEx(LogActionType.BattleUserDead);
            var invoker = new BattleRoomPlayerDeadBusinessLog(dead_user_guid, dead_user_nickname, kilerUserGuid, killer_nickname
                , battleInstanceRoom.m_instance_room.getMap().m_room_id, attribute.m_combat_pod_mode.m_current_round, need_pod_combat_drop_noti);
            BusinessLogger.collectLogs(log_action, player, new List<ILogInvoker>(){invoker});
            
            return fn_result;


        };
        
        var result = await player.runTransactionRunnerSafely(TransactionIdType.BattleRoom, "BattlePlayerDead", fn_player_dead);
        if (result.isFail())
        {
            var err_msg = $"Failed to runTransactionRunnerSafelyWithTransGuid() !!! : {result.toBasicString()}, {player.toBasicString()}";
            Log.getLogger().error(err_msg);
            send_S2C_ACK_BATTLE_PLAYER_DEATH(player, result);
            return result;
        }

        return result;
    }

    private void increaseKillDeadCount(BattleInstanceSnapshotAttribute attribute, string kilerUserGuid, string deadUserGuid)
    {
        if (false == attribute.m_combat_pod_mode.m_tactical_board.TryGetValue(kilerUserGuid, out var killerTacticalBoardInfo))
        {
            killerTacticalBoardInfo = new(kilerUserGuid);
            attribute.m_combat_pod_mode.m_tactical_board.TryAdd(kilerUserGuid, killerTacticalBoardInfo);
        }
        killerTacticalBoardInfo.m_kill_count++;

        if (false == attribute.m_combat_pod_mode.m_tactical_board.TryGetValue(deadUserGuid, out var deadTacticalBoardInfo))
        {
            deadTacticalBoardInfo = new(deadUserGuid);
            attribute.m_combat_pod_mode.m_tactical_board.TryAdd(deadUserGuid, deadTacticalBoardInfo);
        }
        deadTacticalBoardInfo.m_Death_count++;
    }

    public bool send_S2C_ACK_BATTLE_PLAYER_DEATH(Player player, Result result)
    {
        var ack_packet = new ClientToGame();
        ack_packet.Response = new ClientToGameRes();

        ack_packet.Response.ErrorCode = result.ErrorCode;
        ack_packet.Response.AckBattlePlayerDeath = new ClientToGameRes.Types.GS2C_ACK_BATTLE_PLAYER_DEATH();

        if (false == GameServerApp.getServerLogic().onSendPacket(player, ack_packet))
        {
            return false;
        }

        return true;
    }
}