MafiaTelegramBot/MafiaTelegramBot/Resources/Keyboard.cs

using System.Collections.Generic;
using MafiaTelegramBot.CustomCollections.Extensions;
using MafiaTelegramBot.Game;
using MafiaTelegramBot.Game.GameRoles;
using MafiaTelegramBot.Game.GameRooms;
using Telegram.Bot.Types.ReplyMarkups;

namespace MafiaTelegramBot.Resources
{
    public static class Keyboard
    {
        public static readonly ReplyKeyboardMarkup MainMenu = new(new[]
            {
                new KeyboardButton[] {keyboard.create_game},
                new KeyboardButton[] {keyboard.connect_game, keyboard.show_profile}
            }, true
        );
        
        public static readonly ReplyKeyboardMarkup OwnerGameMenu = new(new[]
            {
                new KeyboardButton[] {keyboard.begin_game, keyboard.room_settings},
                new KeyboardButton[] {keyboard.kick_player, keyboard.look_players_list},
                new KeyboardButton[] {keyboard.show_profile, keyboard.dissolve_room}
            }, true
        );
        
        public static readonly ReplyKeyboardMarkup PlayerGameMenu = new(new[]
            {
                new KeyboardButton[] {keyboard.show_profile, keyboard.look_players_list},
                new KeyboardButton[] {keyboard.leave}
            }, true
        );
        
        public static readonly ReplyKeyboardMarkup InGamePlayerMenu = new(new[]
            {
                new KeyboardButton[] {keyboard.look_players_list, keyboard.leave}
            }, true
        );
        
        public static readonly ReplyKeyboardMarkup InGamePlayerMenuWithEndTurn = new(new[]
            {
                new KeyboardButton[] {keyboard.look_players_list, keyboard.leave},
                new KeyboardButton[] {keyboard.end_turn}
            }, true
        );

        public static InlineKeyboardMarkup RoomTypeKeyboard(long userId, Callback callbackPrivate, Callback callbackPublic)
        {
            return new(new[]
            {
                InlineKeyboardButton.WithCallbackData(strings._public, $"{callbackPublic}|{userId}"),
                InlineKeyboardButton.WithCallbackData(strings._private, $"{callbackPrivate}|{userId}"),
            });
        }

        public static InlineKeyboardMarkup SetMaximumKeyboard(long userId)
        {
            return new (new[]
            {
                new[] {
                    InlineKeyboardButton.WithCallbackData(strings.minimum_players_count, $"{Callback.SetPlayersMaximum}|{userId}|6"),
                },
                new[] {
                    InlineKeyboardButton.WithCallbackData("7", $"{Callback.SetPlayersMaximum}|{userId}|7"),
                    InlineKeyboardButton.WithCallbackData("8", $"{Callback.SetPlayersMaximum}|{userId}|8"),
                    InlineKeyboardButton.WithCallbackData("9", $"{Callback.SetPlayersMaximum}|{userId}|9"),
                },
                new[] {
                    InlineKeyboardButton.WithCallbackData("10", $"{Callback.SetPlayersMaximum}|{userId}|10"),
                    InlineKeyboardButton.WithCallbackData("11", $"{Callback.SetPlayersMaximum}|{userId}|11"),
                    InlineKeyboardButton.WithCallbackData("12", $"{Callback.SetPlayersMaximum}|{userId}|12"),
                },
                new[] {
                    InlineKeyboardButton.WithCallbackData("13", $"{Callback.SetPlayersMaximum}|{userId}|13"),
                    InlineKeyboardButton.WithCallbackData("14", $"{Callback.SetPlayersMaximum}|{userId}|14"),
                    InlineKeyboardButton.WithCallbackData("15", $"{Callback.SetPlayersMaximum}|{userId}|15"),
                },
                new[] {
                    InlineKeyboardButton.WithCallbackData(strings.maximum_players_count, $"{Callback.SetPlayersMaximum}|{userId}|16"),
                }
            });
        }

        public static InlineKeyboardMarkup ProfileKeyboard(long userId)
        {
            return new (new[]
            {
                new[] {
                    InlineKeyboardButton.WithCallbackData(strings.shop, $"{Callback.ShopMenu}|{userId}"),
                    InlineKeyboardButton.WithCallbackData(strings.my_roles, $"{Callback.ShowMyRoles}|{userId}")
                },
                new[] {InlineKeyboardButton.WithCallbackData(strings.settings, $"{Callback.SettingsProfile}|{userId}")}
            });
        }

        public static InlineKeyboardMarkup NormalExtendedKeyboard(long userId, string type)
        {
            return new (new[]
            {
                new[] {
                    InlineKeyboardButton.WithCallbackData(strings.standart, $"{Callback.MakeNormalGame}|{userId}|{type}"),
                    InlineKeyboardButton.WithCallbackData(strings.extended, $"{Callback.MakeExtendedGame}|{userId}|{type}")
                }
            });
        }

        public static InlineKeyboardMarkup ChangeNameKeyboard(long userId)
        {
            return new(InlineKeyboardButton.WithCallbackData(strings.change_name, $"{Callback.ChangeNickName}|{userId}"));
        }

        public static InlineKeyboardMarkup RoomsKeyboard(List<GameRoom> rooms, long userId)
        {
            var inlineButtons = new InlineKeyboardButton[rooms.Count][];
            for (var i = 0; i < rooms.Count && i < Constants.MAX_SHOWING_ROOMS; ++i) // buttons
            {
                var s = rooms[i].IsExtended ? "Р" : "C";
                inlineButtons[i] = new []
                {
                    InlineKeyboardButton.WithCallbackData(
                        $"[{s}] {rooms[i].RoomName} ({rooms[i].Players.Values.Count.ToString()}/{rooms[i].MaxPlayers.ToString()})",
                    $"{Callback.ConnectToSelectedRoom}|{userId}|{RoomEncrypter.GetCode(rooms[i].RoomName)}")
                };
            }
            return new InlineKeyboardMarkup(inlineButtons);
        }

        public static InlineKeyboardMarkup KickKeyboard(List<Player> users)
        {
            var inlineButtons = new InlineKeyboardButton[users.Count][];
            for (var i = 0; i < users.Count; ++i)
            {
                inlineButtons[i] = new[]
                {
                    InlineKeyboardButton.WithCallbackData($"{users[i].NickName} {strings.kick}",
                        $"{Callback.KickUser}|{users[i].Id}")
                };
            }
            return new InlineKeyboardMarkup(inlineButtons);
        }

        public static InlineKeyboardMarkup VoteKeyboard(List<Player> players, long userId, bool withSkipButton = true, Callback vote = Callback.Vote)
        {
            var inlineButtons = new InlineKeyboardButton[withSkipButton ?players.Count+1 :players.Count][];
            for (var i = 0; i<players.Count; ++i)
            {
                inlineButtons[i] = new[]
                {
                    InlineKeyboardButton.WithCallbackData($"({players[i].TurnOrder}) {players[i].NickName}", $"{vote}|{userId}|{players[i].Id}")
                };
            }
            if (withSkipButton) inlineButtons[players.Count] = new[]
                    {InlineKeyboardButton.WithCallbackData(strings.skip, $"{vote}|{userId}|0")};
            return inlineButtons;
        }

        public static InlineKeyboardMarkup NightChooseTargetKeyboard(List<Player> players, long userId, bool skipButton = false)
        {
            var inlineButtons = new InlineKeyboardButton[skipButton ?players.Count+1 : players.Count][];
            for (var i = 0; i<players.Count; ++i)
            {
                inlineButtons[i] = new[] {
                    InlineKeyboardButton.WithCallbackData($"({players[i].TurnOrder}) {players[i].NickName}", 
                        $"{Callback.NightTarget}|{userId}|{players[i].Id}")
                };
            }

            if (skipButton)
                inlineButtons[players.Count] = new[] 
                    { InlineKeyboardButton.WithCallbackData(strings.skip, $"{Callback.NightTarget}|{userId}|-1") };
            return inlineButtons;
        }

        public static InlineKeyboardMarkup DetectiveTargetKeyboard(List<Player> players, long userId)
        {
            var inlineButtons = new InlineKeyboardButton[players.Count][];
            for (var i = 0; i<players.Count; ++i)
            {
                inlineButtons[i] = new[] {
                    InlineKeyboardButton.WithCallbackData($"({players[i].TurnOrder}) {players[i].NickName} ({strings.check})", 
                        $"{Callback.DetectiveTarget}|{userId}|{players[i].Id}|check"),
                    InlineKeyboardButton.WithCallbackData($"({players[i].TurnOrder}) {players[i].NickName} ({strings.kill})", 
                        $"{Callback.DetectiveTarget}|{userId}|{players[i].Id}|kill"),
                };
            }
            return inlineButtons;
        }

        public static InlineKeyboardMarkup NightMafiaTargetKeyboard(List<Player> players, long userId)
        {
            var inlineButtons = new InlineKeyboardButton[players.Count + 1][];
            for (var i = 0; i<players.Count; ++i)
            {
                var isMafia = (players[i].GetRole() is Roles.Mafia or Roles.Don or Roles.Dame)
                               || (players[i].GetRole() is Roles.Werewolf && ((WerewolfRole) players[i].CurrentRole).IsMafia);
                inlineButtons[i] = new[]
                {
                    InlineKeyboardButton.WithCallbackData($"({players[i].TurnOrder}) " +
                        $"{players[i].NickName}{(isMafia ? " - " + players[i].GetRoleName() : "")}", 
                        $"{Callback.MafiaTarget}|{userId}|{players[i].Id}")
                };
            }
            inlineButtons[players.Count] = new[] {
                InlineKeyboardButton.WithCallbackData(strings.skip, $"{Callback.MafiaTarget}|{userId}|-4")
            };
            return inlineButtons;
        }

        public static InlineKeyboardMarkup SettingsRoomKeyboard(long userId, string timerStatus)
        {

            return new (new[]
            {
                new[] { InlineKeyboardButton.WithCallbackData(timerStatus, $"{Callback.SwitchTimer}|{userId}") },
                new[] { InlineKeyboardButton.WithCallbackData(strings.players_count, $"{Callback.PlayersCount}|{userId}") },
            });
        }

        public static InlineKeyboardMarkup StartExtendedRoomKeyboard(long userId)
        {
            return new (new[]
            {
                new[] { InlineKeyboardButton.WithCallbackData(strings.run_game, $"{Callback.StartGame}|{userId}") },
                new[] { InlineKeyboardButton.WithCallbackData(strings.change_roles, $"{Callback.ChangeRoles}|{userId}") }
            });
        }

        public static InlineKeyboardMarkup ChangeRolesKeyboard(long userId, string roomKey, ExtendedGameRoom room)
        {
            List<Roles> openedRoles = new();
            foreach (var player in room.Players.Values)
                openedRoles.ConcatenateUnique(player.OpenedRoles.ToList());
            var keyboard = new InlineKeyboardButton[3+openedRoles.Count][];
            keyboard[0] = new[]
            {
                InlineKeyboardButton.WithCallbackData($"{roles.Mafia}-",
                    $"{Callback.ApplyRolesChange}|{userId}|{roomKey}|{Roles.Mafia}|-"),
                InlineKeyboardButton.WithCallbackData($"{roles.Mafia}+",
                    $"{Callback.ApplyRolesChange}|{userId}|{roomKey}|{Roles.Mafia}|+"),
            };
            keyboard[1] = new[]
            {
                InlineKeyboardButton.WithCallbackData($"{roles.Villager}-",
                    $"{Callback.ApplyRolesChange}|{userId}|{roomKey}|{Roles.Villager}|-"),
                InlineKeyboardButton.WithCallbackData($"{roles.Villager}+",
                    $"{Callback.ApplyRolesChange}|{userId}|{roomKey}|{Roles.Villager}|+"),
            };
            for (var i = 0; i < openedRoles.Count; ++i)
            {
                var contain = room.CustomRoomSettings.ContainsKey(openedRoles[i]);
                    keyboard[2+i] = new []{ InlineKeyboardButton.WithCallbackData(
                        $"{roles.ResourceManager.GetString(openedRoles[i].ToString())} ({(contain ? 1 : 0)})",
                        $"{Callback.ApplyRolesChange}|{userId}|{roomKey}|{openedRoles[i]}"
                        )};
            }
            keyboard[openedRoles.Count+2] = new[]
            { InlineKeyboardButton.WithCallbackData(strings.run_game, $"{Callback.StartGame}|{userId}") };
            return keyboard;
        }
    }
}