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.Models;
using MafiaTelegramBot.Resources;
using Telegram.Bot.Types;
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 List<Player> KnownRoles = new();
            protected long NightTargetId = -1;
            public readonly ManualResetEvent TalkingActionComplete = new(false);
            public readonly ManualResetEvent VoteActionComplete = new(false);
            protected int MessageId = -1;
            public abstract Roles RoleKey { get; }
            public virtual Task NightAction() { return Task.CompletedTask; }
            public virtual Task ApplyNightActionResult() { return Task.CompletedTask; }

            public async Task CancelNightActionResult(string message)
            {
                await Bot.EditMessageAsync(Player.ChatId, MessageId, strings.activity_blocked);
                NightTargetId = -1;
                MessageId = -1;
                await Bot.SendWithMarkdown2(Player.ChatId, message);
            }
            public virtual Task SetNightTarget(long userId) { return Task.CompletedTask; }
            
            public virtual async Task Dispatch()
            {
                await Room.PlayersCh.SendExcept(Player.Id, $"{strings.to_player} {Player.NickName} {strings.issued_posthumous_minute}");
                await OneMinuteSpeak();
                await Player.Kill();
            }

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

            public long GetNightTarget()
            {
                return NightTargetId;
            }

            public async Task OneMinuteSpeak()
            {
                TalkingActionComplete.Reset();
                await Bot.SendWithMarkdown2(Player.ChatId, $"{strings.your_turn}\n{strings.you_turn_say}", Keyboard.InGamePlayerMenuWithEndTurn);
                Player.IsSpeaker = true;
                var timer = new Timer(60 * 1000) {AutoReset = false};
                timer.Elapsed += (_, _) => TalkingActionComplete.Set();
                timer.Start();
                TalkingActionComplete.WaitOne();
                timer.Stop();
                await Bot.SendWithMarkdown2(Player.ChatId, strings.your_turn_ended, Keyboard.InGamePlayerMenu);
                Player.IsSpeaker = false;
            }

            public async Task VotingAction()
            {
                var voteTimer = new Timer(10 * 1000) {AutoReset = false};
                var alivePlayers = Room.Players.Values.Where(p => p.IsAlive).ToList();
                var message = await SendVotingList(alivePlayers, !Player.IsFirst);
                voteTimer.Elapsed += async (_, _) =>
                {
                    await Bot.EditMessageAsync(Player.ChatId, message.MessageId, strings.time_out);
                    if (Player.IsFirst)
                        await Room.PutUpVote(Player.Id, Player.Id);
                    else
                        await Room.PlayersCh.SendExcept(Player.Id, $"{Player.NickName} {strings.didnt_put_anyone}");
                    VoteActionComplete.Set();
                };
                if(Player.IsFirst) await Bot.SendWithMarkdown2(Player.Id, strings.user_not_choose);
                voteTimer.Start();
                VoteActionComplete.WaitOne();
                voteTimer.Stop();
                if(message!=null) await Bot.Get().DeleteMessageAsync(Player.ChatId, message.MessageId);
            }

            public async Task<Message> SendVotingList(List<Player> targets, bool skipButton = true)
            {
                VoteActionComplete.Reset();
                return await Bot.SendWithMarkdown2(Player.ChatId, $"{strings.put_up_vote}\n{strings.you_have_ten_seconds}", 
                    Keyboard.VoteKeyboard(targets, Player.Id, skipButton));
            }
            
            public async Task DefenceAction()
            {
                await Room.PlayersCh.SendExcept(Player.Id, $"{strings.now_defence} {Player.NickName}");
                await OneMinuteSpeak();
            }
            public static Role GetNewRoleInstance(Roles roleKey, GameRoom room, Player player)
            {
                return roleKey switch
                {
                    Roles.All => new NoneRole(),
                    Roles.None => new NoneRole(),
                    Roles.Doctor => new DoctorRole(room, player),
                    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.Parasite => new ParasiteRole(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),
                    _ => throw new ArgumentOutOfRangeException(nameof(roleKey), roleKey, null)
                };
            }
        }
    }
}