MafiaTelegramBot/MafiaTelegramBot/Controllers/RoomController.cs

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using MafiaTelegramBot.DataBase;
using MafiaTelegramBot.Game;
using MafiaTelegramBot.Resources;

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

        public static async Task<ResultCode> CreateNewGame(User owner, string roomName, bool extended, string secretPhrase = null)
        {
            var gameExists = await Task.Run(() => OpenedGames.ContainsKey(roomName));
            return await Task.Run(async () =>
            {
                if (gameExists) return ResultCode.GameAlreadyExists;
                if (!await owner.SetRoomKey(secretPhrase ?? roomName)) return ResultCode.UserAlreadyInGame;
                var room = secretPhrase == null
                    ? new GameRoom {Creator = owner, RoomName = roomName, IsExtended = extended}
                    : new PrivateGameRoom {Creator = owner, RoomName = roomName, IsExtended = extended};
                OpenedGames.Add(secretPhrase ?? roomName, room);
                room.Players.Add(owner.Id, owner);
                return ResultCode.CodeOk;
            });
        }

        public static async Task<ResultCode> ConnectToGame(User player, string roomKey)
        {
            return await Task.Run(async () =>
            {
                if (!OpenedGames.ContainsKey(roomKey)) return ResultCode.RoomDoesNotExist;
                if (OpenedGames[roomKey].IsFilled()) return ResultCode.RoomIsFilled;
                if (!await player.SetRoomKey(roomKey)) return ResultCode.UserAlreadyInGame;
                OpenedGames[roomKey].Players.Add(player.Id, player);
                return ResultCode.CodeOk;
            });
        }

        public static async Task<List<User>> GetPlayers(string roomKey)
        {
            return await Task.Run( ()=>
            {
                var room = OpenedGames[roomKey];
                var users = room.Players.Values.ToList();
                return users;
            });
        }
        
        public static async Task<ResultCode> LeaveFromGame(User player)
        {
            return await Task.Run(async () =>
            {
                var roomKey = player.GetRoomKey();
                if (!await player.RemoveGame()) return ResultCode.UserNotInGame;
                OpenedGames[roomKey].Players.Remove(player.Id);
                if (OpenedGames[roomKey].Players.Count == 0) OpenedGames.Remove(roomKey);
                return ResultCode.CodeOk;
            });
        }

        public static async Task<List<GameRoom>> GetPublicRooms()
        {
            return await Task.Run(() =>
            {
                var rooms = OpenedGames.Values.ToList();
                List<GameRoom> publicRooms = new List<GameRoom>();
                int countRooms = 0;
                foreach (var room in rooms)
                {
                    if (room.IsPrivate) continue;
                    if (room.IsFilled()) continue;
                    publicRooms.Add(room);
                    countRooms++;
                    if (countRooms == 10) break;
                }
                return publicRooms;
            });
        }
        
        public static async Task<GameRoom> GetRoom(string roomKey)
        {
            return await Task.Run( ()=>
            {
                var room = OpenedGames[roomKey];
                return room;
            });
        }
    }
}