MafiaTelegramBot/MafiaTelegramBot/Controllers/RoomController.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using MafiaTelegramBot.DataBase.EntityDao;
using MafiaTelegramBot.Game;
using MafiaTelegramBot.Game.GameRoles;
using MafiaTelegramBot.Game.GameRooms;
using MafiaTelegramBot.Models;
using MafiaTelegramBot.Resources;

namespace MafiaTelegramBot.Controllers
{
    public static class RoomController
    {
        private static readonly Dictionary<string, GameRoom> OpenedGames = new();

        public static async Task<ResultCode> CreateNewGame(Player creator, string roomName, bool isExtended, bool isPrivate)
        {
            return await Task.Run( () =>
            {
                var roomKey = RoomEncrypter.GetCode(roomName);
                if (OpenedGames.ContainsKey(roomKey)) return ResultCode.GameAlreadyExists;
                if (!creator.SetRoomName(roomName)) return ResultCode.UserAlreadyInGame;
                GameRoom room = isExtended
                    ? new ExtendedGameRoom {Owner = creator, RoomName = roomName, IsPrivate = isPrivate}
                    : new NormalGameRoom {Owner = creator, RoomName = roomName, IsPrivate = isPrivate};
                OpenedGames.Add(roomKey, room);
                room.Players.Add(creator.Id, creator);
                
                room.SetTimer();
                UserDao.GetPlayerById(creator.Id).Result.StopTimer();
                
                return ResultCode.CodeOk;
            });
        }

        public static async Task<ResultCode> ConnectToGame(Player player, string roomKey)
        {
            return await Task.Run(async () =>
            {
                if (!OpenedGames.ContainsKey(roomKey)) return ResultCode.RoomDoesNotExist;
                var roomName = RoomEncrypter.GetName(roomKey);
                if (OpenedGames[roomKey].IsRunning) return ResultCode.GameAlreadyRunning;
                if (OpenedGames[roomKey].IsFilled()) return ResultCode.RoomIsFilled;
                if (!player.SetRoomName(roomName)) return ResultCode.UserAlreadyInGame;
                OpenedGames[roomKey].Players.Add(player.Id, player);

                if (OpenedGames[roomKey].Players.Count > Constants.PLAYER_DISABLE_TIMER)
                    OpenedGames[roomKey].StopTimer();
                UserDao.GetPlayerById(player.Id).Result.StopTimer();
                
                await OpenedGames[roomKey].PlayersCh.SendExcept(player.Id, $"{player.NickName} {strings.connected_to_game}");
                return ResultCode.CodeOk;
            });
        }

        public static List<Player> GetPlayers(string roomKey)
        {
                return OpenedGames[roomKey].Players.Values.ToList();
        }
        
        public static async Task<ResultCode> LeaveFromGame(Player player)
        {
            return await Task.Run(async () =>
            {
                var roomName = player.GetRoomName();
                var roomKey = RoomEncrypter.GetCode(roomName);
                if (!await player.RemoveGame()) return ResultCode.UserNotInGame;
                await OpenedGames[roomKey].Leave(player);
                if (!OpenedGames[roomKey].IsRunning &&
                    OpenedGames[roomKey].Players.Count <= Constants.PLAYER_DISABLE_TIMER)
                    await OpenedGames[roomKey].StartTimer();
                await UserDao.GetPlayerById(player.Id).Result.StartTimer();
                if (OpenedGames[roomKey].Players.Count >= 0) return ResultCode.CodeOk;
                RoomEncrypter.RemoveCode(roomName);
                OpenedGames.Remove(roomKey);
                return ResultCode.CodeOk;
            });
        }
        
        public static async Task DissolveRoom(string roomKey)
        {
            await Task.Run(async () =>
            {
                if (OpenedGames.ContainsKey(roomKey))
                {
                    await OpenedGames[roomKey].PlayersCh.Send(strings.room_dissolved, Keyboard.MainMenu);
                    foreach (var player in OpenedGames[roomKey].Players.Values) await player.RemoveGame();
                    RoomEncrypter.RemoveCode(OpenedGames[roomKey].RoomName);
                    OpenedGames[roomKey].DeleteTimer();
                    OpenedGames.Remove(roomKey);
                }
            });
        }

        public static async Task<List<GameRoom>> GetPublicRooms()
        {
            return await Task.Run(() =>
            {
                var rooms = OpenedGames.Values.ToList();
                foreach (var room in OpenedGames.Values.ToList().
                    Where(room => room.IsPrivate || room.IsFilled() || room.IsRunning)) rooms.Remove(room);
                return rooms;
            });
        }
        
        public static GameRoom GetRoom(string roomKey)
        {
            return OpenedGames[roomKey];
        }
    }
}