MafiaTelegramBot/MafiaTelegramBot/Models/Bot.cs

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using MafiaTelegramBot.DataBase.EntityDao;
using MafiaTelegramBot.Game;
using MafiaTelegramBot.Models.Commands;
using MafiaTelegramBot.Models.Inlines;
using MafiaTelegramBot.Models.Payments;
using MafiaTelegramBot.Resources;
using Telegram.Bot;
using Telegram.Bot.Types;
using Telegram.Bot.Types.Enums;
using Telegram.Bot.Types.ReplyMarkups;
using static MafiaTelegramBot.Logs;

namespace MafiaTelegramBot.Models
{
    public static class Bot
    {
        private static TelegramBotClient _client;
        private static List<Command> _commandsList;
        private static List<Query> _queriesList;
        private static List<Payment> _paymentsList;
        
        public static IReadOnlyList<Command> Commands => _commandsList.AsReadOnly();
        public static IReadOnlyList<Query> Queries => _queriesList.AsReadOnly();
        public static IReadOnlyList<Payment> Payments => _paymentsList.AsReadOnly();

        public static readonly List<long> UsersThatChangesNickname = new();
        public static readonly Dictionary<long, string> UsersThatCreatesRoom = new();
        public static readonly List<long> UserThatEntersPrivateCode = new();

        public static TelegramBotClient Get()
        {
            if (_client != null) return _client;
            InitCommands();
            InitQueries();
            InitPayments();
            _client = new TelegramBotClient(AppSettings.Token);
            return _client;
        }

        private static void InitCommands()
        {
            //TODO fill commands array
            _commandsList = new List<Command>
            {
                new StartCommand(),
                new CreateGameCommand(),
                new ConnectGameCommand(),
                new ShowProfileCommand(),
                new RoomSettingsCommand(),
                new LeaveCommand(),
                new LookPlayersListCommand(),
                new KickPlayerCommand(),
                new DissolveRoomCommand(),
                new StartGameCommand(),
                new AdminPanelCommand(),
                new FastGameCommand(),
            };
        }
        
        private static void InitQueries()
        {
            //TODO fill inline keyboard array
            _queriesList = new List<Query>
            {
                new ShowMyRolesQuery(),
                new ShopMenuQuery(),
                new SettingsProfileQuery(),
                new ChangeNickNameQuery(),
                new SettingsRoomQuery(),
                new ConnectToPrivateRoomQuery(),
                new SetPlayersMaximumQuery(),
                new ConnectToPublicRoomQuery(),
                new ConnectToSelectedRoomQuery(),
                new KickSelectedPlayerQuery(),
                new SwitchTimerQuery(),
                new ChangeRolesQuery(),
                new PlayersCountSettingsQuery(),
                new ApplyRolesChangeQuery(),
                new StartGameQuery(),
                new ShowMyExtendedStatsQuery(),
                new ChooseRoomViewQuery(),
                new ChooseGameTypeQuery(),
                new ChooseGameModeQuery(),
                new ConnectToRankedQuery(),
                new ConnectToNotRankedQuery(),
                new GiveToSelectedQuery(),
                new GiveRoleQuery(),
                new GiveToAllQuery(),
                new ContinueQuery(),
                new PackInfoQuery(),
                new PackOpenQuery(),
                new ShowMyPacksQuery(),
                new BackToProfileQuery(),
            };
        }
        
        private static void InitPayments()
        {
            //TODO fill inline keyboard array
            _paymentsList = new List<Payment>
            {
                new RandomRolePayment()
            };
        }

        public static async Task<Message> SendStickerAsync(long chatId, string fileId)
        {
            try
            {
                return await Get().SendStickerAsync(chatId, fileId, true);
            }
            catch (Exception e)
            {
                LogOutError(e.Message);
                return new Message();
            }
        }

        public static async Task<Message> SendHyperLink(long chatId, string message)
        {
            try
            {
                return await Get().SendTextMessageAsync(chatId, message, ParseMode.Html, disableNotification: true);
            }
            catch (Exception e)
            {
                LogOutError(e.Message);
                return new Message();
            }
        }
        
        public static async Task<Message> SendWithMarkdown2(long chatId, string message, IReplyMarkup replyMarkup = null)
        {
            try
            {
                var editedMessage = await Utilities.ToMarkdownString(message);
                return await Get().SendTextMessageAsync(chatId, editedMessage,
                    ParseMode.MarkdownV2, replyMarkup: replyMarkup, disableNotification: true);
            }
            catch (Exception e)
            {
                LogOutError(e.Message);
                return new Message();
            }
        }

        public static async Task<Message> EditMessageAsync(long chatId, int messageId, string message, InlineKeyboardMarkup keyboard = null)
        {
            try
            {
                var editedMessage = await Utilities.ToMarkdownString(message);
                return await Get().EditMessageTextAsync(chatId, messageId, editedMessage, ParseMode.MarkdownV2, replyMarkup: keyboard);
            }
            catch (Exception e)
            {
                LogOutError(e.Message);
                return new Message();
            }
        }

        public static async Task AnswerPreCheckoutQuery(string preCheckoutQueryId)
        {
            var token = new CancellationToken();
            await Get().AnswerPreCheckoutQueryAsync(preCheckoutQueryId, token);
        }

        public static async Task RegisterNewUser(Update update)
        {
            var chatId = update.Message.Chat.Id;
            var userId = update.Message.From.Id;
            var username = await Utilities.EscapeSpecific(update.Message.From.Username);
            var firstName = await Utilities.EscapeSpecific(update.Message.From.FirstName);
            var lastName = await Utilities.EscapeSpecific(update.Message.From.LastName);
            var nickName = "";
            if (firstName != "") nickName += firstName;
            if(lastName != "") nickName += nickName != "" ? $" {lastName}" : lastName;
            var user = new Player
            {
                Id = userId,
                ChatId = chatId,
                Username = username,
                NickName =  nickName
            };
            await UserDao.AddNew(user.User);
            await StatisticsDao.CreatePlayerStats(user.Id);
            UserDao.ActiveUsers.Add(user.Id, user);
        }
    }
}