Program.cs

using System.Globalization;
using System.Net;
using System.Reflection;
using System.Text;
using System.Text.RegularExpressions;
using DetectLanguage;
using DisCatSharp;
using DisCatSharp.ApplicationCommands;
using DisCatSharp.CommandsNext;
using DisCatSharp.CommandsNext.Converters;
using DisCatSharp.CommandsNext.Exceptions;
using DisCatSharp.Entities;
using DisCatSharp.Enums;
using DisCatSharp.EventArgs;
using DisCatSharp.Exceptions;
using DisCatSharp.Interactivity;
using DisCatSharp.Interactivity.Enums;
using DisCatSharp.Interactivity.Extensions;
using DisCatSharp.Lavalink;
using DisCatSharp.Net;
using EconomyBot.Logging;
using Spectre.Console;

namespace EconomyBot;

public class Program {
    private static readonly Logger logger = Logger.getClassLogger("Main");

    public static LavalinkSession LavalinkNode = null!;
    public static MusicService musicService = null!;
    public static ImagesModule imagesModule = null!;
    public static ToxicityHandler toxicity = null!;
    public static WilteryHandler wiltery = null!;

    public static DetectLanguageClient languageClient = null!;

    public static DiscordEmoji cube = null!;

    public static bool lavalinkInit = false;
    public static bool hasSetup = false;

    public static DiscordClient client = null!;
    
    private static readonly Dictionary<ulong, PlaybackState> savedPlaybackStates = new();
    private static DateTime lastReconnectionAttempt = DateTime.MinValue;
    private static DateTime lastSaveAttempt = DateTime.MinValue;
    private static DateTime lastRestoreAttempt = DateTime.MinValue;
    private static readonly Lock reconnectionLock = new();
    private static readonly Lock saveStateLock = new();
    private static readonly Lock restoreStateLock = new();
    private static bool needsLavalinkReconnection = false;

    public const ulong LOG = 838920584879800343;
    public static ulong HALLOFFAME = 1078991955633127474;
    public const ulong UKRAYINSKIJ_KANAL = 1153439320435335278;
    public const ulong POLISH_CHANNEL = 1156695554462597120;
    public const ulong ZOO = 1149817703922675823;
    public const ulong HUNGARY_CHANNEL = 1154903997510062181;
    public const ulong MY_GUILD = 838843082110664756;
    public const ulong BUG_REPORT_CATEGORY = 1472268871791808790;


    // shut up compiler
    private Program() {
        _ = Main(null!);
    }


    public static async Task Main(string[] args) {
        // logging

        // set global exception handler
        AppDomain.CurrentDomain.UnhandledException += (sender, eventArgs) => {
            logger.error(eventArgs.ExceptionObject as Exception ?? throw new InvalidOperationException());
        };
        AppDomain.CurrentDomain.ProcessExit += (sender, eventArgs) => {
            logger.info("Exiting...");
        };

        Logger.setLogLevel(LogLevel.INFO);

        Constants.init();

        var discord = new DiscordClient(new DiscordConfiguration {
            TokenType = TokenType.Bot,
            Token = Constants.token,
            Intents = DiscordIntents.All,
            ReconnectIndefinitely = true
        });
        client = discord;

        // error handling

        var endpoint = new ConnectionEndpoint {
            Hostname = "127.0.0.1", // From your server configuration.
            Port = 2333 // From your server configuration
        };

        var lavalinkConfig = new LavalinkConfiguration {
            Password = "youshallnotpass", // From your server configuration.
            RestEndpoint = endpoint,
            SocketEndpoint = endpoint
        };

        var lavalink = discord.UseLavalink();
        var commands = discord.UseCommandsNext(new CommandsNextConfiguration {
            StringPrefixes = [".", "!!"],
        });
        //var ApplicationCommands = discord.UseApplicationCommands(new ApplicationCommandsConfiguration {
        //    ServiceProvider = services
        //});
        try {
            //ApplicationCommands.RegisterCommands<ChatModuleSlash>();
            //ApplicationCommands.RegisterGlobalCommands<MusicModuleSlash>();
            //ApplicationCommands.RegisterGlobalCommands<ImagesModuleSlash>();
            commands.CommandErrored += errorHandler;
            commands.RegisterCommands<ChatModule>();
            commands.RegisterCommands<MusicModule>();
            commands.RegisterCommands<ImagesModule>();
            commands.RegisterCommands<BotModule>();
        }
        catch (Exception e) {
            if (e is BadRequestException ex) {
                logger.error(ex.JsonMessage ?? "No message? wtf");
            }

            logger.error(e.Message);
        }

        discord.UseInteractivity(new InteractivityConfiguration {
            Timeout = TimeSpan.FromSeconds(180),
            PollBehaviour = PollBehaviour.KeepEmojis,
            AckPaginationButtons = true
        });
        discord.MessageCreated += messageHandler;
        discord.MessagesBulkDeleted += messageDeleteHandler;
        discord.Ready += async (sender, _) => {
            await setup(sender, lavalink, lavalinkConfig);
            if (needsLavalinkReconnection) {
                needsLavalinkReconnection = false;
                await lavalinkReconnect();
            }
        };
        discord.Resumed += async (_, _) => {
            if (needsLavalinkReconnection) {
                needsLavalinkReconnection = false;
                await lavalinkReconnect();
            }
        };
        //discord.GuildDownloadCompleted += (sender, _) => setupB(sender, lavalink, lavalinkConfig);
        discord.MessageDeleted += messageDeleteHandler;
        discord.GuildMemberAdded += roleHandler;

        discord.GetCommandsNext().UnregisterConverter<TimeSpan>();
        discord.GetCommandsNext().RegisterConverter(new CustomTimeSpanConverter());
        #pragma warning disable CS1998 // Async method lacks 'await' operators and will run synchronously
        discord.ClientErrored += async (sender, e) => {
            logger.error($"An error occurred while connecting to Discord with type {e.EventName}");
            logger.error(e.Exception);
        };
        discord.SocketErrored += async (sender, e) => {
            logger.error(e.Exception);
            await saveAllPlaybackStates();
        };
        #pragma warning restore CS1998 // Async method lacks 'await' operators and will run synchronously
        await discord.ConnectAsync();
        MemoryUtils.cleanGC();
        var timer = new PeriodicTimer(TimeSpan.FromMinutes(10));

        while (await timer.WaitForNextTickAsync()) {
            try {
                MemoryUtils.cleanGC();
                foreach (var file in Directory.GetParent(Directory.GetCurrentDirectory())!.EnumerateFiles()) {
                    file.Delete();
                }

                logger.info("Pruned cached images.");
            }
            catch (Exception e) {
                // file is in use, ignore
                AnsiConsole.WriteException(e);
            }
        }

        // hold console window
        await Task.Delay(-1);
    }

    private static async Task roleHandler(DiscordClient sender, GuildMemberAddEventArgs e) {
        const ulong roleID = 1352463350533197989u;
        var role = await e.Guild.GetRoleAsync(roleID);
        await e.Member.GrantRoleAsync(role);
    }

    private static async Task messageDeleteHandler(DiscordClient sender, MessageBulkDeleteEventArgs e) {
        foreach (var message in e.Messages) {
            await actualMessageDeleteHandler(e.Channel, message);
        }
    }

    private static async Task actualMessageDeleteHandler(DiscordChannel channel, DiscordMessage message) {
        if (message.Attachments.Count != 0 && message.Channel.Id != LOG) {
            // long wait so wrap it in task.run
            _ = Task.Run(async () => {
                var guid = Guid.NewGuid();
                using var httpClient = new HttpClient();
                foreach (var a in message.Attachments) {
                    var path = "";
                    try {
                        path = Directory.GetCurrentDirectory() + a.Filename;
                        var ext = Path.GetExtension(path);
                        path += guid + ext;
                        //slap the correct extension on it
                        using var response = await httpClient.GetAsync(a.Url.ToString());
                        response.EnsureSuccessStatusCode();
                        await using var fs = new FileStream(path, FileMode.Create);
                        await response.Content.CopyToAsync(fs);
                    }
                    catch (WebException exception) {
                        logger.warn(exception);
                        throw;
                    }
                    catch (Exception e) {
                        await channel.SendMessageAsync("Penis happened!");
                        // log the fucking error
                        await channel.SendMessageAsync(e.ToString());
                    }

                    var file = new FileStream(path, FileMode.Open);
                    await (await client.GetGuildAsync(838843082110664756)!).GetChannel(LOG)!
                        .SendMessageAsync(new DiscordMessageBuilder().AddFile(file));
                }
            });
        }

        if (message.Author == client.CurrentUser && message.Channel.Id != LOG) {
            var server = await client.GetGuildAsync(838843082110664756);
            _ = Task.Run(async () => {
                await Task.Delay(3000); // stupid discord doesnt update logs immediately
                var logs = await server.GetAuditLogsAsync(10, actionType: AuditLogActionType.MessageDelete);
                var deleter = logs.FirstOrDefault(log =>
                        log is DiscordAuditLogMessageEntry entry && entry.Target.Id == message.Id)?
                    .UserResponsible?.Username ?? "unknown";
                await server.GetChannel(LOG)!
                    .SendMessageAsync($"{message.Content} deleted by {deleter}");
            });
        }
    }

    private static async Task messageDeleteHandler(DiscordClient sender, MessageDeleteEventArgs e) {
        await actualMessageDeleteHandler(e.Channel, e.Message);
    }

    private static async Task messageHandler(DiscordClient client, MessageCreateEventArgs e) {
        if (!hasSetup) {
            return;
        }

        // gore protection
        if (e.Author is DiscordMember m && (e.Message.Content.Contains("Screenshot_20230901_160903") ||
            e.Message.Attachments.Any(f => f.Url.ToString()!.Contains("Screenshot_20230901_160903")))) {
            await e.Guild.BanMemberAsync(m, 6);
        }

        // @everyone protection (only on our server)
        if (e.Guild?.Id == MY_GUILD && (e.Message.Content.Contains("@everyone") || e.Message.Content.Contains("@here"))) {
            await e.Message.RespondAsync("This server - and the world in general - would be better without your existence " + DiscordEmoji.FromName(client, ":pleading_face:"));
        }

        if (client.CurrentUser.Id == e.Author.Id) {
            return;
        }

        // Don't reply to webhooks with embeds. The bot might have sent them
        if (e.Message.WebhookMessage && e.Message.Embeds.Count > 0) {
            return;
        }

        // Bug report reminder for new forum posts in the bug report category
        {
            var ch = e.Channel;
            bool inBugCategory = false;
            while (ch != null) {
                if (ch.Id == BUG_REPORT_CATEGORY) {
                    inBugCategory = true;
                    break;
                }
                // resolve through guild cache if possible
                ch = ch.Parent?.Id is { } pid && e.Guild?.Channels.TryGetValue(pid, out var cached) == true
                    ? cached
                    : ch.Parent;
            }
            if (inBugCategory) {
                var hasAttachment = e.Message.Attachments.Count > 0;
                var hasLogLink = e.Message.Content.Contains("pastebin", StringComparison.OrdinalIgnoreCase) ||
                                 e.Message.Content.Contains("paste.ee", StringComparison.OrdinalIgnoreCase) ||
                                 e.Message.Content.Contains("hastebin", StringComparison.OrdinalIgnoreCase) ||
                                 e.Message.Content.Contains("gist.github", StringComparison.OrdinalIgnoreCase);
                if (!hasAttachment && !hasLogLink) {
                    await e.Message.RespondAsync(
                        "I'm not a mind-reader: can you please provide a crashlog (found in /reports), the system.log.txt and a detailed explanation of the crash's occurrence?");
                }
            }
        }

        // Only run funny replies/replacements on our server
        if (e.Guild?.Id != MY_GUILD) return;

        // conquest

        var lizardry = new List<string> {
            "ą",
            "Ą",
            "ć",
            "Ć",
            "ę",
            "Ę",
            "ł",
            "Ł",
            "ń",
            "Ń",
            "ó",
            "Ó",
            "ś",
            "Ś",
            "ź",
            "Ź",
            "Ś",
            "ż",
            "Ż"
        };

        // Cringe
        if ((e.Channel.Id != POLISH_CHANNEL && e.Channel.Id != ZOO && e.Channel.Id != HUNGARY_CHANNEL) && lizardry.Any(
                word =>
                    e.Message.Content.Contains(word, StringComparison.OrdinalIgnoreCase))) {
            await e.Message.CreateReactionAsync(DiscordEmoji.FromName(client, ":lizard:"));
        }

        var cute = new List<string> {
            "skull",
            "cringe",
            "\ud83d\udc80" // skull emoji
        };

        // Hoholness

        var hohol = "hohol";
        if (e.Message.Content.Contains(hohol, StringComparison.OrdinalIgnoreCase)) {
            await ((DiscordMember)e.Author).TimeoutAsync(DateTimeOffset.Now + TimeSpan.FromHours(1), "russian simp");
        }

        // Lizardry
        if (cute.Any(word =>
                e.Message.Content.Contains(word, StringComparison.OrdinalIgnoreCase))) {
            await e.Message.RespondAsync("You are a meanie >.<");
        }

        // Spam detection

        // base64 decode
        var word = new string(Encoding.UTF8.GetString(Convert.FromBase64String("bWZiem9iZQ==")).Select(c => char.IsLetter(c) ? (char)(c + (char.ToLower(c) < 'n' ? 13 : -13)) : c).ToArray());
        if (e.Message.Content.Contains(word, StringComparison.OrdinalIgnoreCase)) {
            await e.Message.DeleteAsync();
        }
        var word1 = new string(Encoding.UTF8.GetString(Convert.FromBase64String("Y2V2Zm1hbG54")).Select(c => char.IsLetter(c) ? (char)(c + (char.ToLower(c) < 'n' ? 13 : -13)) : c).ToArray());
        if (e.Message.Content.Contains(word1, StringComparison.OrdinalIgnoreCase)) {
            await e.Message.DeleteAsync();
        }

        // Ukrainian language promotion handler, don't trigger if it's a quote
        if (e.Channel.Id == UKRAYINSKIJ_KANAL && !e.Message.Content.Contains('"') && e.Message.Content.Length > 10) {
            var results = await languageClient.DetectAsync(e.Message.Content);
            bool isRussian = results.Any(r => r.language == "ru" && r.score > 1);
            bool isNotUkrainian = results.All(r => r.language != "uk");
            logger.info($"Language analysis:");
            foreach (var result in results) {
                logger.info($"    {result.language}, {result.score}");
                
            }

            if (isRussian && isNotUkrainian) {
                await e.Message.RespondAsync("москальська свиня");
            }
        }

        // Toxicity handler
        if (!e.Message.Content.StartsWith('.') && !e.Message.Content.StartsWith('/') && e.Message.Embeds.Count == 0 &&
            e.Message.Attachments.Count == 0) {
            await toxicity.handleMessage(client, e.Message);
            await wiltery.handleMessage(client, e.Message);
        }

        if (e.Author.Id == 947229156448538634) {
            await e.Message.CreateReactionAsync(DiscordEmoji.FromName(client, ":pinkpill:"));
        }

        var meowList = new List<string> {
            "cat",
            "kitty",
            "kitten",
            "meow",
            "purr",
            "feline",
            "nya",
            "miau"
        };
        // Meowing is too common
        /*if (meowList.Any(word =>
                e.Message.Content.Contains(word, StringComparison.OrdinalIgnoreCase) ||
                e.Message.Attachments.Any(a => a.Url.Contains(word, StringComparison.OrdinalIgnoreCase)))) {
            await e.Message.RespondAsync("*meow*");
        }*/
    }

    private static async Task setup(DiscordClient client, LavalinkExtension lavalink,
        LavalinkConfiguration lavalinkConfig) {
        // Wait a bit with lavalink init, Lavalink seems to start slower than the bot. Lazy solution is pretty much a sleep
        await Task.Delay(2000);
        LavalinkNode = await lavalink.ConnectAsync(lavalinkConfig);
        
        
        // dispose slsk client!!
        musicService?.slsk?.Dispose();
        
        musicService = new MusicService(lavalink, LavalinkNode);
        lavalinkInit = true;
        imagesModule = new ImagesModule();
        toxicity = new ToxicityHandler();
        wiltery = new WilteryHandler(Program.client);
        languageClient = new DetectLanguageClient(Constants.detectlanguagetoken);

        cube = await (await client.GetGuildAsync(838843082110664756)).GetEmojiAsync(839202645734457384);

        hasSetup = true;

        // don't need to wait!
        _ = setupB(client, lavalink, lavalinkConfig);

        logger.info("Setup done!");
    }
    
    private static async Task forceReconnectLavalink(DiscordClient client, LavalinkExtension lavalink,
        LavalinkConfiguration lavalinkConfig) {
        if (!lavalinkInit) {
            logger.info("Lavalink not initialized yet, skipping forced reconnection attempt");
            return;
        }

        try {
            logger.info("Forcing Lavalink reconnection...");
            
            if (musicService != null) {
                logger.info("Disposing old MusicService...");
                musicService.slsk?.Dispose();
                // Clear all guild data to force garbage collection
                foreach (var guildData in musicService.GetExistingGuildData()) {
                    try {
                        await guildData.DestroyPlayerAsync();
                    } catch (Exception destroyEx) {
                        logger.warn($"Error destroying player for {guildData.Guild.Name}: {destroyEx}");
                    }
                }
                musicService = null;
            }
            
            // Properly dispose old connections and data to prevent memory leaks
            if (LavalinkNode != null) {
                logger.info("Destroying old Lavalink node...");
                try {
                    await LavalinkNode.DestroyAsync();
                    logger.info("Successfully destroyed old Lavalink node");
                } catch (Exception disposeEx) {
                    logger.warn($"Error destroying old Lavalink node: {disposeEx}");
                }
            }
            
            // Force garbage collection to clean up old instances
            GC.Collect();
            GC.WaitForPendingFinalizers();
            GC.Collect();
            
            // Create fresh connection
            LavalinkNode = await lavalink.ConnectAsync(lavalinkConfig);
            musicService = new MusicService(lavalink, LavalinkNode);
            
            logger.info("Successfully force-reconnected to Lavalink!");
            
            await restoreAllPlaybackStates();
        }
        catch (Exception ex) {
            logger.error($"Failed to force-reconnect to Lavalink: {ex}");
            logger.error(ex);
        }
    }
    
    public static void markLavalinkReconnectionNeeded() {
        needsLavalinkReconnection = true;
        logger.info("Marked Lavalink reconnection as needed - will reconnect at end of Ready/Resumed event");
    }
    
    public static async Task lavalinkReconnect() {
        if (!lavalinkInit || musicService == null) {
            return;
        }
        
        lock (reconnectionLock) {
            // ignore if we attempted reconnection in the last 5 seconds (we're still doing it!!)
            if (DateTime.Now - lastReconnectionAttempt < TimeSpan.FromSeconds(5)) {
                logger.info("Skipping reconnection attempt - too recent");
                return;
            }
            lastReconnectionAttempt = DateTime.Now;
        }
        
        try {
            logger.info("Triggering Lavalink reconnection due to socket error...");
            
            var lavalinkConfig = new LavalinkConfiguration {
                Password = "youshallnotpass",
                RestEndpoint = new ConnectionEndpoint { Hostname = "127.0.0.1", Port = 2333 },
                SocketEndpoint = new ConnectionEndpoint { Hostname = "127.0.0.1", Port = 2333 }
            };
            
            var lavalink = client.GetLavalink();
            await forceReconnectLavalink(client, lavalink, lavalinkConfig);
        }
        catch (Exception ex) {
            logger.error($"Error during triggered Lavalink reconnection: {ex}");
        }
    }

    public static async Task saveAllPlaybackStates() {
        if (!lavalinkInit || musicService == null) {
            return;
        }

        lock (saveStateLock) {
            // Debounce: ignore if we attempted save in the last 5 seconds
            if (DateTime.Now - lastSaveAttempt < TimeSpan.FromSeconds(5)) {
                logger.info("Skipping save attempt - too recent");
                return;
            }
            lastSaveAttempt = DateTime.Now;
        }

        try {
            logger.info("Saving playback states for guilds with active music...");
            
            foreach (var musicData in musicService.GetExistingGuildData()) {
                if (musicData.Player is { IsConnected: true } && musicData.queue.NowPlaying != null) {
                    var state = new PlaybackState {
                        CurrentTrack = musicData.queue.NowPlaying,
                        Position = musicData.GetCurrentPosition(),
                        WasPlaying = musicData.Player.CurrentTrack != null && !musicData.Player.Player.Paused,
                        WasPaused = musicData.Player.Player.Paused,
                        VoiceChannelId = musicData.Player.Channel?.Id,
                        CommandChannelId = musicData.CommandChannel?.Id,
                        Queue = new List<Track>(musicData.queue.Queue),
                        AutoQueue = new List<Track>(musicData.queue.autoQueue),
                        History = new List<Track>(musicData.queue.history),
                        ArtistQueue = new List<string>(musicData.queue.artistQueue),
                        RepeatHolder = musicData.queue.repeatHolder,
                        RepeatQueue = musicData.queue.repeatQueue,
                        EarrapeMode = musicData.queue.earrapeMode,
                        Volume = musicData.volume,
                        EqEnabled = musicData.eq
                    };
                    
                    savedPlaybackStates[musicData.Guild.Id] = state;
                    logger.info($"Saved playback state for guild {musicData.Guild.Name}");
                    
                    // Properly disconnect from voice channel to prevent stuck states
                    try {
                        if (musicData.Player != null && musicData.Player.IsConnected) {
                            await musicData.Player.DisconnectAsync();
                            logger.info($"Disconnected from voice channel in {musicData.Guild.Name}");
                        }
                    }
                    catch (Exception disconnectEx) {
                        logger.warn($"Failed to disconnect from voice channel in {musicData.Guild.Name}: {disconnectEx}");
                    }
                }
            }
        }
        catch (Exception ex) {
            logger.error($"Error saving playback states: {ex}");
        }
    }
    
    private static async Task restoreAllPlaybackStates() {
        if (!lavalinkInit || musicService == null) {
            return;
        }

        lock (restoreStateLock) {
            // Debounce: ignore if we attempted restore in the last 5 seconds
            if (DateTime.Now - lastRestoreAttempt < TimeSpan.FromSeconds(5)) {
                logger.info("Skipping restore attempt - too recent");
                return;
            }
            lastRestoreAttempt = DateTime.Now;
        }

        try {
            logger.info("Restoring playback states for all guilds...");
            
            foreach (var (guildId, state) in savedPlaybackStates.ToList()) {
                try {
                    var guild = client.Guilds.Values.FirstOrDefault(g => g.Id == guildId);
                    if (guild == null) continue;

                    var musicData = await musicService.GetOrCreateDataAsync(guild);
                    
                    if (state.VoiceChannelId.HasValue && state.CurrentTrack != null) {
                        var voiceChannel = guild.GetChannel(state.VoiceChannelId.Value);
                        if (voiceChannel != null) {
                            // Ensure we're properly disconnected first
                            try {
                                if (musicData.Player != null && musicData.Player.IsConnected) {
                                    await musicData.Player.DisconnectAsync();
                                    logger.info($"Disconnected existing player from {guild.Name}");
                                }
                            }
                            catch (Exception disconnectEx) {
                                logger.warn($"Failed to disconnect existing player in {guild.Name}: {disconnectEx}");
                            }

                            // Create fresh player connection
                            await musicData.CreatePlayerAsync(voiceChannel);
                            logger.info($"Reconnected to voice channel in {guild.Name}");
                            
                            // Wait a moment for connection to stabilize
                            await Task.Delay(1000);
                            
                            musicData.queue.Queue.Clear();
                            musicData.queue.Queue.AddRange(state.Queue);
                            musicData.queue.autoQueue.Clear();
                            musicData.queue.autoQueue.AddRange(state.AutoQueue);
                            musicData.queue.history.Clear();
                            musicData.queue.history.AddRange(state.History);
                            musicData.queue.artistQueue.Clear();
                            musicData.queue.artistQueue.AddRange(state.ArtistQueue);
                            musicData.queue.repeatHolder = state.RepeatHolder;
                            musicData.queue.repeatQueue = state.RepeatQueue;
                            musicData.queue.earrapeMode = state.EarrapeMode;
                            
                            await musicData.SetVolumeAsync(state.Volume);
                            
                            if (state.EqEnabled != musicData.eq) {
                                musicData.toggleEQ();
                            }
                            
                            if (state.CommandChannelId.HasValue) {
                                musicData.CommandChannel = guild.GetChannel(state.CommandChannelId.Value);
                            }
                            
                            // Properly restore the current track through the queue system
                            musicData.queue.NowPlaying = state.CurrentTrack;
                            
                            if (musicData.Player != null && musicData.Player.IsConnected) {
                                if (state.WasPlaying && !state.WasPaused) {
                                    await musicData.Player.PlayAsync(state.CurrentTrack.track);
                                    await musicData.SeekAsync(state.Position, false);
                                    logger.info($"Resumed playback for guild {guild.Name} at {state.Position}");
                                } else if (state.WasPaused) {
                                    await musicData.Player.PlayAsync(state.CurrentTrack.track);
                                    await musicData.SeekAsync(state.Position, false);
                                    await musicData.PauseAsync();
                                    logger.info($"Restored paused state for guild {guild.Name} at {state.Position}");
                                }
                            } else {
                                logger.warn($"Cannot restore playback for guild {guild.Name} - player is null or disconnected");
                            }
                        }
                    }
                }
                catch (Exception ex) {
                    logger.error($"Error restoring playback state for guild {guildId}: {ex}");
                }
            }
            
            savedPlaybackStates.Clear();
            logger.info("Finished restoring playback states");
        }
        catch (Exception ex) {
            logger.error($"Error during playback state restoration: {ex}");
        }
    }

    private static Task setupB(DiscordClient client, LavalinkExtension lavalink,
        LavalinkConfiguration lavalinkConfig) {
        foreach (var guild in client.Guilds) {
            logger.info($"{guild.Value.Name}, {guild.Value.JoinedAt.ToString()}");
        }
        return Task.CompletedTask;
    }

    private static async Task errorHandler(CommandsNextExtension sender, CommandErrorEventArgs e) {
        switch (e.Exception) {
            // wrong number of arguments
            case ArgumentException when e.Exception.Message.Contains("overload"): {
                var command = e.Command.Name;
                var suppliedArgumentsLength = e.Context.RawArgumentString.Split().Length;

                // if args are empty, we don't have arguments
                if (string.IsNullOrWhiteSpace(e.Context.RawArgumentString)) {
                    suppliedArgumentsLength = 0;
                }

                var minArgumentLength = int.MaxValue;
                var maxArgumentLength = 0;
                // too few arguments? loop through all overloads and check if we don't have enough
                foreach (var overload in e.Command.Overloads) {
                    // too few
                    minArgumentLength = Math.Min(overload.Arguments.Count, minArgumentLength);
                    // too many
                    maxArgumentLength = Math.Max(overload.Arguments.Count, maxArgumentLength);
                }

                // professional logging:tm:
                logger.debug(suppliedArgumentsLength);
                logger.debug(maxArgumentLength);
                logger.debug(minArgumentLength);

                if (suppliedArgumentsLength > maxArgumentLength) {
                    await sender.Client.SendMessageAsync(e.Context.Channel,
                        $"Too many arguments for command `{command}`!");
                    logger.warn(e.Exception);
                    return;
                }

                if (suppliedArgumentsLength < minArgumentLength) {
                    await sender.Client.SendMessageAsync(e.Context.Channel,
                        $"Too few arguments for command `{command}`!");
                    logger.warn(e.Exception);
                    return;
                }

                // if correct number of arguments but bad type; print info

                await sender.Client.SendMessageAsync(e.Context.Channel, $"Wrong parameters for command `{command}`!");
                logger.warn(e.Exception);
                return;
            }
            case CommandNotFoundException ex:
                if (e.Command is not null && !e.Command.Name.All(char.IsLetterOrDigit)) {
                    // ignore "command"...
                    return;
                }

                var closestCommand =
                    ActualFuzz.partialFuzzItem(ex.CommandName, e.Context.CommandsNext.RegisteredCommands.Keys);
                await sender.Client.SendMessageAsync(e.Context.Channel, new DiscordMessageBuilder().AddEmbed(
                    new DiscordEmbedBuilder().WithColor(DiscordColor.HotPink)
                        .WithDescription(
                            $"I have no bloody idea what that command is, sorry, did you mean {closestCommand}?")
                        //.WithImageUrl("https://c.tenor.com/CR9Or4gKoAUAAAAC/menhera-menhera-chan.gif").Build()));
                        .Build()));
                return;
            default:
                logger.warn(e.Exception);
                await sender.Client.SendMessageAsync(e.Context.Channel,
                    $"Exception occurred, details below:\n```{e.Exception}```");
                break;
        }
    }
}

public partial class CustomTimeSpanConverter : IArgumentConverter<TimeSpan> {
    private static Regex TimeSpanRegex { get; } =
        MyRegex();

    [GeneratedRegex(@"^(?<days>\d+d\s*)?(?<hours>\d{1,2}h\s*)?(?<minutes>\d{1,2}m\s*)?(?<seconds>\d{1,2}s\s*)?$",
        RegexOptions.Compiled | RegexOptions.ECMAScript)]
    private static partial Regex MyRegex();

    public Task<Optional<TimeSpan>> ConvertAsync(string value, CommandContext? ctx) {
        if (value == "0") {
            return Task.FromResult(Optional.FromNullable(TimeSpan.Zero));
        }
        if (int.TryParse(value, NumberStyles.Number, CultureInfo.InvariantCulture, out var result1)) {
            return Task.FromResult(Optional<TimeSpan>.None);
        }
        if (TimeSpan.TryParse(value, CultureInfo.InvariantCulture, out var result2)) {
            var _result2 = new TimeSpan(0, result2.Hours, result2.Minutes); // slash from h:m to m:s

            return Task.FromResult(Optional.FromNullable(_result2));
        }

        var strArray1 = new[] {
            "days",
            "hours",
            "minutes",
            "seconds"
        };
        var match = TimeSpanRegex.Match(value);
        if (!match.Success) {
            return Task.FromResult(Optional<TimeSpan>.None);
        }
        var days = 0;
        var hours = 0;
        var minutes = 0;
        var seconds = 0;
        for (result1 = 0; result1 < strArray1.Length; ++result1) {
            var groupname = strArray1[result1];
            var str = match.Groups[groupname].Value;
            if (!string.IsNullOrWhiteSpace(str)) {
                var ch = str[^1];
                int.TryParse(str.AsSpan(0, str.Length - 1), NumberStyles.Integer,
                    CultureInfo.InvariantCulture, out var result3);
                switch (ch) {
                    case 'd':
                        days = result3;
                        continue;
                    case 'h':
                        hours = result3;
                        continue;
                    case 'm':
                        minutes = result3;
                        continue;
                    case 's':
                        seconds = result3;
                        continue;
                    default:
                        continue;
                }
            }
        }

        result2 = new TimeSpan(days, hours, minutes, seconds);
        return Task.FromResult(Optional.FromNullable(result2));
    }
}

public class PlaybackState {
    public Track? CurrentTrack;
    public TimeSpan Position;
    public bool WasPlaying;
    public bool WasPaused;
    public ulong? VoiceChannelId;
    public ulong? CommandChannelId;
    public List<Track> Queue = new();
    public List<Track> AutoQueue = new();
    public List<Track> History = new();
    public List<string> ArtistQueue = new();
    public Track? RepeatHolder;
    public bool RepeatQueue;
    public bool EarrapeMode;
    public int Volume = 100;
    public bool EqEnabled;
}