using DSharpPlus;
using System.Threading.Tasks;
using System;
using Tomlet.Attributes;
using System.Linq;
using DSharpPlus.Entities;
using DSharpPlus.Exceptions;
using Microsoft.Extensions.Logging;

namespace MinecraftClient.ChatBots
{
    public class DiscordBridge : ChatBot
    {
        private DiscordClient? _client;
        private DiscordChannel? _channel;

        public static Configs Config = new();

        [TomlDoNotInlineObject]
        public class Configs
        {
            [NonSerialized]
            private const string BotName = "DiscordBridge";

            public bool Enabled = false;

            public string Token = "your bot token here";

            public ulong GuildId = 1018553894831403028L;

            public ulong ChannelId = 1018565295654326364L;

            public ulong[]? OwnerIds = new[] { 978757810781323276UL };

            public bool IgnoreMessagesSentByBots = true;
        }

        public override void Initialize()
        {
            Task.Run(async () => await MainAsync());
        }

        ~DiscordBridge()
        {
            Disconnect();
        }

        public override void OnUnload()
        {
            Disconnect();
        }

        private void Disconnect()
        {
            if (_client != null)
            {
                if (_channel != null)
                    _client.SendMessageAsync(_channel, new DiscordEmbedBuilder
                    {
                        Description = $"Disconnected from the MCC!",
                        Color = new DiscordColor(0xFF0000)
                    }).Wait();

                _client.DisconnectAsync().Wait();
            }
        }

        public override void GetText(string text)
        {
            if (_client == null || _channel == null)
                return;

            text = GetVerbatim(text).Trim();

            string message = "";
            string username = "";
            bool teleportRequest = false;

            if (IsPrivateMessage(text, ref message, ref username))
                message = $"**[Private Message]** {username}: `{message}`";
            else if (IsChatMessage(text, ref message, ref username))
                message = $"{username}: `{message}`";
            else if (IsTeleportRequest(text, ref username))
            {
                message = $"A new Teleport Request from **{username}**";
                teleportRequest = true;
            }
            else message = text;

            SendMessageToDiscord(message, teleportRequest);
        }

        private void SendMessageToDiscord(string message, bool teleportRequest = false)
        {
            if (_client == null || _channel == null)
                return;

            if (teleportRequest)
            {
                var messageBuilder = new DiscordMessageBuilder()
                .WithContent(message)
                .AddComponents(new DiscordButtonComponent(ButtonStyle.Success, "accept_teleport", "Accept"))
                .AddComponents(new DiscordButtonComponent(ButtonStyle.Danger, "deny_teleport", "Deny"));

                _client.SendMessageAsync(_channel, messageBuilder).Wait();
                return;
            }

            _client.SendMessageAsync(_channel, message).Wait();
        }

        async Task MainAsync()
        {
            try
            {
                if (string.IsNullOrEmpty(Config.Token.Trim()))
                {
                    LogToConsole(Translations.TryGet("bot.DiscordBridge.missing_token"));
                    UnloadBot();
                    return;
                }

                _client = new DiscordClient(new DiscordConfiguration()
                {
                    Token = Config.Token.Trim(),
                    TokenType = TokenType.Bot,
                    AutoReconnect = true,
                    Intents = DiscordIntents.All,
                    MinimumLogLevel = LogLevel.None
                });

                try
                {
                    await _client.GetGuildAsync(Config.GuildId);
                }
                catch (Exception e)
                {
                    if (e is NotFoundException)
                    {
                        LogToConsole(Translations.TryGet("bot.DiscordBridge.guild_not_found", Config.GuildId));
                        UnloadBot();
                        return;
                    }
                }

                try
                {
                    _channel = await _client.GetChannelAsync(Config.ChannelId);
                }
                catch (Exception e)
                {
                    if (e is NotFoundException)
                    {
                        LogToConsole(Translations.TryGet("bot.DiscordBridge.channel_not_found", Config.ChannelId));
                        UnloadBot();
                        return;
                    }
                }

                _client.MessageCreated += async (source, e) =>
                {
                    if (Config.IgnoreMessagesSentByBots && e.Author.IsBot)
                        return;

                    if (e.Guild.Id != Config.GuildId)
                        return;

                    if (e.Channel.Id != Config.ChannelId)
                        return;

                    if (!Config.OwnerIds!.Contains(e.Author.Id))
                        return;

                    string message = e.Message.Content.Trim();

                    if (message.StartsWith("."))
                    {
                        await e.Message.CreateReactionAsync(DiscordEmoji.FromName(_client, ":gear:"));
                        message = message[1..];
                        string? result = "";
                        PerformInternalCommand(message, ref result);
                        result = string.IsNullOrEmpty(result) ? "-" : result;
                        await e.Message.DeleteOwnReactionAsync(DiscordEmoji.FromName(_client, ":gear:"));
                        await e.Message.CreateReactionAsync(DiscordEmoji.FromName(_client, ":white_check_mark:"));
                        await e.Message.RespondAsync($"The command was executed with the result:\n```{result}```");
                    }
                    else SendText(message);
                };

                _client.ComponentInteractionCreated += async (s, e) =>
                {
                    if (!(e.Id.Equals("accept_teleport") || e.Id.Equals("deny_teleport")))
                        return;

                    string result = e.Id.Equals("accept_teleport") ? "Accepted :white_check_mark:" : "Denied :x:";
                    SendText(e.Id.Equals("accept_teleport") ? "/tpaccept" : "/tpdeny");
                    await e.Interaction.CreateResponseAsync(InteractionResponseType.UpdateMessage, new DiscordInteractionResponseBuilder().WithContent(result));
                };

                await _client.ConnectAsync();

                await _client.SendMessageAsync(_channel, new DiscordEmbedBuilder
                {
                    Description = $"Succesfully connected with the MCC!",
                    Color = new DiscordColor(0x00FF00)
                });

                await Task.Delay(-1);
            }
            catch (Exception e)
            {
                LogToConsole(Translations.TryGet("bot.DiscordBridge.unknown_error"));
                LogToConsole(e);
                return;
            }
        }
    }
}