MafiaTelegramBot/MafiaTelegramBot/Game/GameRooms/GameRoom.MessageHandler.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using MafiaTelegramBot.Controllers;
using MafiaTelegramBot.Game.GameRoles;
using MafiaTelegramBot.Models;
using MafiaTelegramBot.Resources;
using Telegram.Bot.Types;

namespace MafiaTelegramBot.Game.GameRooms
{
    public partial class GameRoom
    {
        public class MessageHandler
        {
            private readonly List<long> _exitingPlayers = new();
            
            private readonly GameRoom _room;

            public MessageHandler(GameRoom room)
            {
                _room = room;
            }

            public async Task<Message> Handle(Update update)
            {
                var text = update.Message.Text;
                var userId = update.Message.From.Id;
                if (!_room.Players.ContainsKey(userId)) return new Message();
                if(_exitingPlayers.Contains(userId)) await Leave(_room.Players[userId], update.Message.Text);
                else if (text == keyboard.look_players_list) await LookPlayers(_room.Players[userId]);
                else if (text == keyboard.leave) await Leave(_room.Players[userId]);
                else if (text == keyboard.end_turn)
                {
                    if (_room.IsDay && _room.Players[userId].IsSpeaker) _room.Players[userId].CurrentRole.TalkingActionComplete.Set();
                    else await _room.PlayersMessageChannel.SendTo(userId, strings.now_is_not_your_turn);
                }
                else await ForwardMessage(_room.Players[userId], text);
                return update.Message;
            }
            
            private async Task ForwardMessage(Player player, string message)
            {
                if(!_room.IsRunning) await _room.PlayersMessageChannel.SendExcept(player.Id, $"{player.NickName}: {message}");
                else
                {
                    if (!player.IsAlive) await _room.PlayersMessageChannel.SendTo(player.Id, strings.you_now_died);
                    else if (player.IsBlocked) await _room.PlayersMessageChannel.SendTo(player.Id, strings.you_blocked);
                    else if (!player.IsSpeaker) await _room.PlayersMessageChannel.SendTo(player.Id, strings.now_you_cant_speak);
                    else if (_room.IsDay) await _room.PlayersMessageChannel.SendExcept(player.Id, $"({player.TurnOrder}) {player.NickName}: {message}");
                    else
                    {
                        if (player.CurrentRole.ColorRole == 2)
                            await _room.MafiaMessageChannel.SendExcept(player.Id, $"({player.TurnOrder}) {player.NickName}: {message}");
                        if (player.GetRole() is Roles.Parasite)
                        {
                            var parasiteRole = player.CurrentRole as ParasiteRole;
                            await _room.PlayersMessageChannel.SendTo(parasiteRole!.ParentId, $"({player.TurnOrder}) {player.NickName}: {message}");
                        }
                        else if (_room.PlayersRole.ContainsKey(Roles.Parasite)
                                 && _room.PlayersRole[Roles.Parasite].Count == 1
                                 && ((ParasiteRole)_room.PlayersRole[Roles.Parasite][0].CurrentRole).ParentId == player.Id)
                        {
                            await _room.PlayersMessageChannel.SendTo(_room.PlayersRole[Roles.Parasite][0].Id, $"({player.TurnOrder}) {player.NickName}: {message}");
                        }
                    }
                }
            }

            private async Task LookPlayers(Player player)
            {
                var players = _room.Players.Values.ToArray();
                var nextPlayer = _room._turnOrder.Peek();
                var knownRoles = player.CurrentRole.KnownRoles;
                var message = strings.players_list;
                var stopIndex = -1;
                for (var i = 0; i != stopIndex; i = (i+1) % players.Length)
                {
                    i %= players.Length;
                    if (stopIndex == -1 && players[i].Id == nextPlayer.Id) stopIndex = i;
                    if (stopIndex == -1) continue;
                    var role =  knownRoles.ContainsKey(players[i].Id)
                        ? knownRoles[players[i].Id]
                        : "";
                    message +=
                        $"\n{(message == strings.players_list ? strings.next + " - " : "")}" +
                        $"({players[i].TurnOrder}) " +
                        $"{(players[i].Id == player.Id ? strings.you : players[i].NickName)} " +
                        $"({(players[i].IsAlive ? strings.alive : strings.died)}) " +
                        $"{role}";
                }
                await _room.PlayersMessageChannel.SendTo(player.Id, message);
            }

            private async Task Leave(Player player, string text = "")
            {
                var roomName = player.GetRoomName();
                if (_room.IsRunning)
                {
                    if (_exitingPlayers.Remove(player.Id))
                    {
                        if (text == strings.exit)
                        {
                            var resultCode = await RoomController.LeaveFromGame(player);
                            if (resultCode == ResultCode.CodeOk)
                                await Bot.SendWithMarkdown2(player.ChatId, $"{strings.you_leave_from_game} _*{roomName}*_", Keyboard.MainMenu);
                            else await Utilities.GetResultCodeMessage(resultCode, player.ChatId);
                        }
                    }
                    else
                    {
                        _exitingPlayers.Add(player.Id);
                        await _room.PlayersMessageChannel.SendTo(player.ChatId, $"{strings.confirm_exit} ```{strings.exit}``` {strings.to_confirm_exit}");
                    }
                }
            }
        }
    }
}