MafiaTelegramBot/MafiaTelegramBot/Game/GameRooms/GameRoom.Role.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using MafiaTelegramBot.Game.GameRoles;
using MafiaTelegramBot.Resources;
using Timer = System.Timers.Timer;

namespace MafiaTelegramBot.Game.GameRooms
{
    public partial class GameRoom
    {
        public abstract class Role
        {
            protected readonly GameRoom Room;
            protected readonly Player Player;
            public readonly Dictionary<long, string> KnownRoles = new();
            protected long NightTargetId = -1;
            public long MafiaTargetId = -1;
            public abstract double ColorRole
            {
                get;
                set;
            }
            

            public readonly ManualResetEvent TalkingActionComplete = new(false);
            public readonly ManualResetEvent VoteActionComplete = new(false);
            protected int MessageId = -1;
            protected int MafiaMessageId = -1;
            protected List<Player> NightTargetList = null;
            public abstract Roles RoleKey { get; }
            
            public virtual Task NightAction() { return Task.CompletedTask; }
            public virtual Task SetMafiaTarget(long userId) { return Task.CompletedTask; }
            public virtual Task ApplyNightActionResult() { return Task.CompletedTask; }
            public virtual Task SetNightTarget(long userId) { return Task.CompletedTask; }

            public virtual async Task CancelNightActionResult(string message)
            {
                if (MessageId != -1)
                {
                    await Room.PlayersCh.EditTo(Player.Id, MessageId, strings.activity_blocked);
                    NightTargetId = -2;
                }
                if (MafiaMessageId != -1)
                {
                    Player.IsSpeaker = false;
                    await Room.PlayersCh.EditTo(Player.Id, MafiaMessageId, strings.activity_blocked);
                    MafiaTargetId = -2;
                }
                await Room.PlayersCh.SendTo(Player.ChatId, message);
            }

            public virtual async Task<string> IsWon()
            {
                return await Task.Run(() => "");
            }
            public virtual async Task Dispatch()
            {
                if (Room.PlayersRole.ContainsKey(Roles.Hooker)
                    && Room.PlayersRole[Roles.Hooker].Count == 1 
                    && Room.PlayersRole[Roles.Hooker][0].CurrentRole.NightTargetId == Player.Id)
                {
                    await Room.PlayersCh.SendExcept(Player.Id, $"{strings.villagers_want_dispatch} {Player.NickName}, {strings.player_not_died_he_has_alibi}");
                }
                else
                {
                    if (!Player.IsBlocked)
                    {
                        await Room.PlayersCh.SendExcept(Player.Id, $"{strings.to_player} {Player.NickName} {strings.issued_posthumous_minute}");
                        await Room.PlayersCh.SendTo(Player.ChatId, strings.you_will_be_dispatched);
                        await SpeakAction(enableTimer: true);
                    }
                    await Kill();
                    await Room.PlayersCh.Send($"({Player.TurnOrder}) {Player.NickName} {strings.dispatched}");
                }
            }

            public virtual async Task Kill()
            {
                if (Room.PlayersRole.ContainsKey(Roles.Hooker)
                    && Room.PlayersRole[Roles.Hooker].Count == 1
                    && Room.PlayersRole[Roles.Hooker][0].CurrentRole.NightTargetId == Player.Id
                    && !Room.IsDay)
                    await Room.PlayersRole[Roles.Hooker][0].CurrentRole.Kill();
                else
                {
                    Player.IsAlive = false;
                    if (Room.PlayersRole.ContainsKey(Roles.Parasite)
                        && Room.PlayersRole[Roles.Parasite].Count == 1
                        && ((ParasiteRole) Room.PlayersRole[Roles.Parasite][0].CurrentRole).ParentId == Player.Id)
                    {
                        await Room.PlayersRole[Roles.Parasite][0].CurrentRole.Kill();
                        if(Room.IsDay) await Room.PlayersCh.Send($"{strings.for_unknown_reasons_died} {Room.PlayersRole[Roles.Parasite][0].NickName}");
                        await Room.PlayersCh.SendTo(Room.PlayersRole[Roles.Parasite][0].Id,
                            strings.your_carrier_player_has_died);
                    }
                        
                }
            }

            protected async Task SetRandomNightTarget()
            {
                var inGamePlayers = NightTargetList.Where(p => Room.Players.ContainsKey(p.Id)).ToArray();
                if (inGamePlayers.Length == 0)
                {
                    NightTargetId = -1;
                    await Room.PlayersCh.EditTo(Player.Id, MessageId, strings.nothing_to_choose);
                }
                else
                {
                    NightTargetId = NightTargetList[Utilities.Rnd.Next(NightTargetList.Count)].Id;
                    await Room.PlayersCh.EditTo(Player.Id, MessageId,
                        $"{strings.automatically_choosed_target} {Room.Players[NightTargetId].NickName}");
                }
            }

            protected Role(GameRoom room, Player player)
            {
                Room = room;
                Player = player;
            }

            public async Task SpeakAction(int seconds = 60, bool enableTimer = false)
            {
                await Room.PlayersCh.SendTo(Player.ChatId, $"{strings.your_turn}", Keyboard.InGamePlayerMenuWithEndTurn);
                Player.IsSpeaker = true;
                var timer = new Timer(seconds * 1000) {AutoReset = false};
                timer.Elapsed += (_, _) => TalkingActionComplete.Set();
                if (Room.TimerEnabled || enableTimer) timer.Start();
                TalkingActionComplete.WaitOne();
                if (Room.TimerEnabled || enableTimer) timer.Stop();
                TalkingActionComplete.Reset();
                await Room.PlayersCh.SendTo(Player.ChatId, strings.your_turn_ended, Keyboard.InGamePlayerMenu);
                Player.IsSpeaker = false;
            }

            public async Task VotingAction(bool isFirst = false)
            {
                var voteTimer = new Timer(20 * 1000) {AutoReset = false};
                var alivePlayers = Room.Players.Values.Where(p => p.IsAlive).Except(Room.VoteUpList).ToList();
                var message = await Room.PlayersCh.SendTo(Player.ChatId,
                    $"{strings.put_up_vote}\n{strings.you_have_twenty_seconds}{(isFirst ? "\n" + strings.user_not_choose : "")}",  
                    Keyboard.VoteKeyboard(alivePlayers, Player.Id, !isFirst));
                voteTimer.Elapsed += async (_, _) =>
                {
                    if (isFirst) await Room.PutUpVote(Player.Id, Player.Id, message.MessageId);
                    else await Room.PutUpVote(Player.Id, 0, message.MessageId);
                    VoteActionComplete.Set();
                };
                voteTimer.Start();
                VoteActionComplete.WaitOne();
                voteTimer.Stop();
                VoteActionComplete.Reset();
            }

            public ManualResetEvent VotingAction(List<Player> targets)
            {
                var stopVote = new ManualResetEvent(false);
                Task.Run(async() =>
                {
                    var message = await Room.PlayersCh.SendTo(Player.Id, strings.you_have_ten_seconds_to_vote, 
                        Keyboard.VoteKeyboard(targets, Player.Id, false, Callback.VoteToKill));
                    stopVote.WaitOne();
                    if (!Room.VoteKillList.ContainsKey(Player.Id) && Room.Players.ContainsKey(Player.Id))
                    {
                        var players = targets.Where(p => Room.Players.ContainsKey(p.Id)).ToArray();
                        if(players.Length == 0) await Room.PlayersCh.EditTo(Player.Id, message.MessageId, strings.nothing_to_choose);
                        else
                        {
                            var randomPlayer = players[Utilities.Rnd.Next(players.Length)];
                            await Room.PutUpVote(Player.Id, randomPlayer.Id, toKill: true);
                            await Room.PlayersCh.EditTo(Player.Id, message.MessageId, $"{strings.automatically_vote} ({randomPlayer.TurnOrder}) {randomPlayer.NickName}");
                        }
                    }
                });
                return stopVote;
            }

            public async Task DefenceAction()
            {
                await Room.PlayersCh.SendExcept(Player.Id, $"{strings.now_defence} ({Player.TurnOrder}) {Player.NickName}");
                await Room.PlayersCh.SendTo(Player.ChatId, strings.you_have_eigty_seconds_to_defence);
                await SpeakAction(90);
            }
            public static Role GetNewRoleInstance(Roles roleKey, GameRoom room, Player player)
            {
                return roleKey switch
                {
                    Roles.All => new NoneRole(),
                    Roles.None => new NoneRole(),
                    Roles.Mafia => new MafiaRole(room, player),
                    Roles.Don => new DonRole(room, player),
                    Roles.Cop => new CopRole(room, player),
                    Roles.Villager => new VillagerRole(room, player),
                    Roles.Hooker => new HookerRole(room, player),
                    Roles.Elder => new ElderRole(room, player),
                    Roles.Werewolf => new WerewolfRole(room, player),
                    Roles.Journalist => new JournalistRole(room, player),
                    Roles.Detective => new DetectiveRole(room, player),
                    Roles.Dame => new DameRole(room, player),
                    Roles.Lawyer => new LawyerRole(room, player),
                    Roles.Fool => new FoolRole(room, player),
                    Roles.Necromancer => new NecromancerRole(room, player),
                    Roles.Bodyguard => new BodyguardRole(room, player),
                    Roles.Doctor => new DoctorRole(room, player),
                    Roles.Parasite => new ParasiteRole(room, player),
                    _ => throw new ArgumentOutOfRangeException(nameof(roleKey), roleKey, null)
                };
            }
        }
    }
}