MafiaTelegramBot/MafiaTelegramBot/Resources/Keyboard.cs

using System;
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.fast_game},
                new KeyboardButton[] {keyboard.create_game},
                new KeyboardButton[] {keyboard.connect_game, keyboard.show_profile}
            }, true
        );
        
        public static readonly ReplyKeyboardMarkup AdminMainMenu = new(new[]
            {
                new KeyboardButton[] {keyboard.admin_panel},
                new KeyboardButton[] {keyboard.fast_game},
                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 RoomViewKeyboard(long userId, Callback callbackPrivate, Callback callbackPublic)
        {
            return new(new[]
            {
                InlineKeyboardButton.WithCallbackData(strings._public, $"{callbackPublic}|{userId}|0"),
                InlineKeyboardButton.WithCallbackData(strings._private, $"{callbackPrivate}|{userId}|0"),
            });
        }

        public static InlineKeyboardMarkup RoomTypeKeyboard(long userId)
        {
            return new(new[]
            {
                InlineKeyboardButton.WithCallbackData(strings.normal_game, $"{Callback.ConnectToNotRanked}|{userId}|0"),
                InlineKeyboardButton.WithCallbackData(strings.ranking_game, $"{Callback.ConnectToRanked}|{userId}|0"),
            });
        }

        public static InlineKeyboardMarkup AdminPanelKeyboard(long userId)
        {
            return new( new[]
                {
                    new [] { InlineKeyboardButton.WithCallbackData(strings.give_roles_to_all_players, $"{Callback.GiveToAll}|{userId}|0") },
                    new [] { InlineKeyboardButton.WithCallbackData(strings.give_role_to_selected_player, $"{Callback.GiveToSelected}|{userId}|0") },
                });
        }

        public static InlineKeyboardMarkup ChooseRoomView(long userId)
        {
            return new InlineKeyboardMarkup(new[]
            {
                InlineKeyboardButton.WithCallbackData(strings._public, $"{Callback.ChooseRoomView}|{userId}|{Constants.PUBLIC}"),
                InlineKeyboardButton.WithCallbackData(strings._private, $"{Callback.ChooseRoomView}|{userId}|{Constants.PRIVATE}"),
            });
        }

        public static InlineKeyboardMarkup ChooseModeKeyboard(long userId, string info)
        {
            return new InlineKeyboardMarkup(new[]
            {
                InlineKeyboardButton.WithCallbackData(strings.standard, $"{Callback.ChooseGameMode}|{userId}|{info}{Constants.STANDARD}"),
                InlineKeyboardButton.WithCallbackData(strings.extended, $"{Callback.ChooseGameMode}|{userId}|{info}{Constants.EXTENDED}"),
            });
        }

        public static InlineKeyboardMarkup ChooseTypeKeyboard(long userId, string info)
        {
            return info[0] == '0' 
            ? new InlineKeyboardMarkup(new[]
            {
                InlineKeyboardButton.WithCallbackData(strings.normal_game, $"{Callback.ChooseGameType}|{userId}|{info}{Constants.NORMAL}"),
                InlineKeyboardButton.WithCallbackData(strings.ranking_game, $"{Callback.ChooseGameType}|{userId}|{info}{Constants.RANKING}"),
            })
            : new InlineKeyboardMarkup(new[]
            {
                InlineKeyboardButton.WithCallbackData(strings.normal_game,
                    $"{Callback.ChooseGameType}|{userId}|{info}{Constants.NORMAL}"),
            });
        }

        public static InlineKeyboardMarkup SetMaximumKeyboard(long userId)
        {
            return new InlineKeyboardMarkup(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 InlineKeyboardMarkup(new[]
            {
                new[] {
                    InlineKeyboardButton.WithCallbackData(strings.shop, $"{Callback.ShopMenu}|{userId}"),
                    InlineKeyboardButton.WithCallbackData(strings.settings, $"{Callback.SettingsProfile}|{userId}")
                },
                new [] {InlineKeyboardButton.WithCallbackData(strings.my_roles, $"{Callback.ShowMyRoles}|{userId}")},
                new [] {InlineKeyboardButton.WithCallbackData(strings.extended_stats, $"{Callback.ShowMyExtendedStats}|{userId}")}
            });
        }

        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, int page)
        {
            var previousButton = page != 0;
            var nextButton = rooms.Count > (page + 1) * Constants.MAX_SHOWING_ROOMS;
            var buttonsCount = rooms.Count >= (page + 1) * Constants.MAX_SHOWING_ROOMS ? Constants.MAX_SHOWING_ROOMS : rooms.Count - page * Constants.MAX_SHOWING_ROOMS;
            if (previousButton || nextButton) buttonsCount++;
            var inlineButtons = new InlineKeyboardButton[buttonsCount][];
            var j = 0;
            for (var i = page * Constants.MAX_SHOWING_ROOMS; i < rooms.Count && i < Constants.MAX_SHOWING_ROOMS * (page + 1); ++i) // buttons
            {
                var s = rooms[i].IsExtended ? "Р" : "C";
                inlineButtons[j] = 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)}")
                };
                ++j;
            }
            if (previousButton && nextButton) inlineButtons[buttonsCount - 1] = new[]
            {
                InlineKeyboardButton.WithCallbackData(strings.previous, $"{Callback.ConnectToPublicRoom}|{userId}|{page-1}"),
                InlineKeyboardButton.WithCallbackData(strings.further, $"{Callback.ConnectToPublicRoom}|{userId}|{page+1}"),
            };
            else if (previousButton) inlineButtons[buttonsCount - 1] = new[]
            {
                InlineKeyboardButton.WithCallbackData(strings.previous, $"{Callback.ConnectToPublicRoom}|{userId}|{page-1}"),
            };
            else if (nextButton) inlineButtons[buttonsCount - 1] = new[]
            {
                InlineKeyboardButton.WithCallbackData(strings.further, $"{Callback.ConnectToPublicRoom}|{userId}|{page+1}"),
            };
            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;
        }

        public static InlineKeyboardMarkup GiveRoleKeyboard(long userId, long targetId)
        {
            var keyboard = new List<InlineKeyboardButton[]>();
            foreach (var role in (Roles[]) Enum.GetValues(typeof(Roles)))
            {
                if(role is Roles.All or Roles.None or Roles.Mafia or Roles.Doctor or Roles.Don or Roles.Villager or Roles.Cop) continue;
                keyboard.Add(new[]
                {
                    InlineKeyboardButton.WithCallbackData(
                        roles.ResourceManager.GetString(role.ToString()),
                        $"{Callback.GiveRole}|{userId}|{targetId}|{role}"
                    )
                });
            }
            return new InlineKeyboardMarkup(keyboard);
        }

        public static InlineKeyboardMarkup ContinueButton(long userId)
        {
            return new InlineKeyboardMarkup(new[]
                {
                    InlineKeyboardButton.WithCallbackData(strings._continue, $"{Callback.Continue}|{userId}")
                }
            );
        }
    }
}