namespace Bot
{
    public class Bot
    {
        // Get all classes that use 'BaseCommandModule' so I can register them easily
        public static readonly List<BaseCommandModule> CommandModules = Reflection.InitializeClasses<BaseCommandModule>();
        // Get all classes that use 'ApplicationCommandModule' so I can register them easily
        public static readonly List<ApplicationCommandModule> SlashCommandModules = Reflection.InitializeClasses<ApplicationCommandModule>();
        // Get bot's credentials from a json file
        private static readonly Core.Config.Models.Credentials.CredentialsModel s_creds = Core.Config.Credentials.Creds;

        public static async Task Run()
        {
            Core.Config.Credentials.Set();

            DiscordShardedClient discord = new(new DiscordConfiguration()
            {
                Token = s_creds.Token,
                TokenType = TokenType.Bot,
                Intents = DiscordIntents.AllUnprivileged,
                AutoReconnect = true,
            });

            // Event handlers
            discord.MessageCreated += DiscordEventHandler.MessageCreated;
            discord.GuildCreated += DiscordEventHandler.GuildCreated;
            discord.GuildDeleted += DiscordEventHandler.GuildDeleted;
            discord.GuildMemberAdded += DiscordEventHandler.GuildMemberAdded;
            discord.GuildMemberRemoved += DiscordEventHandler.GuildMemberRemoved;

            // All the CommandsNext stuff is just for testing 
            IReadOnlyDictionary<int, CommandsNextExtension> commands = await discord.UseCommandsNextAsync(new CommandsNextConfiguration()
            {
                EnableDefaultHelp = false,
                EnableMentionPrefix = true,
                StringPrefixes = new[] { s_creds.Prefix }
            });

            // Register BaseCommandModule commands
            foreach (BaseCommandModule module in CommandModules)
            {
                commands.RegisterCommands(module.GetType());
            }

            // Setup command error handling for CommandsNext
            foreach (KeyValuePair<int, CommandsNextExtension> command in commands)
            {
                command.Value.CommandErrored += DiscordEventHandler.CommandErrored;
            }

            // Configure slash commands
            Task<IReadOnlyDictionary<int, SlashCommandsExtension>> slashCommands = discord.UseSlashCommandsAsync(new SlashCommandsConfiguration()
            {
                
            });

            IReadOnlyDictionary<int, SlashCommandsExtension> slashCommand = await slashCommands;

            // Register ApplicationCommandModule commands
            foreach (ApplicationCommandModule module in SlashCommandModules)
            {
                slashCommand.RegisterCommands(module.GetType());
            }

            // Setup command error handling for SlashCommands
            foreach (SlashCommandsExtension extension in slashCommand.Values)
            {
                extension.SlashCommandErrored += SlashEventHandler.CommandErrored;
            }

            discord.Ready += DiscordEventHandler.Ready;

            await discord.StartAsync();

            #region Example
            int guildsCount = 0;
            foreach (KeyValuePair<int, DiscordClient> shardClientPair in discord.ShardClients)
            {
                DiscordClient client = shardClientPair.Value;
                int count = client.Guilds.Count;
                Console.WriteLine($"Guild count for shard '{shardClientPair.Key}': {count}");
                guildsCount += count;
            }
            Console.WriteLine($"Total guilds: {guildsCount}");

            guildsCount = discord.ShardClients.Values.Select(e => e.Guilds.Count).ToList().Sum();
            Console.WriteLine($"Total guilds: {guildsCount}");
            #endregion

            //Core.Services.BotLists.PostStats(discord); Proper call

            await Task.Delay(-1);
        }
    }
}