package de.spark61.structurevoid.utils.command;

import de.spark61.structurevoid.DiscordBotSystem;
import de.spark61.structurevoid.events.GlobalChat;
import de.spark61.structurevoid.utils.SimpleEmbed;
import de.spark61.structurevoid.utils.logs.ConsoleColor;
import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.Permission;
import net.dv8tion.jda.api.entities.Guild;
import net.dv8tion.jda.api.entities.Member;
import net.dv8tion.jda.api.entities.Message;
import net.dv8tion.jda.api.entities.TextChannel;
import net.dv8tion.jda.api.events.message.MessageReceivedEvent;
import net.dv8tion.jda.api.events.message.MessageUpdateEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter;

import java.awt.*;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.time.Instant;
import java.time.OffsetDateTime;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.TimeUnit;

public class CommandHandler extends ListenerAdapter {
    private Map<String, Command> commands;

    public CommandHandler() {
        this.commands = new HashMap<>();
    }

    public boolean existsCommand(String command) {
        return commands.containsKey(command.toLowerCase());
    }

    public void registerCommand(String name, Command command) {
        commands.put(name.toLowerCase(), command);
    }

    public String getPrefix(Guild guild) {
        return createRowIfNotExists(guild);
    }

    private String createRowIfNotExists(Guild guild) {
        ResultSet resultSet = DiscordBotSystem.getMySQL().query("SELECT * FROM `guilds` WHERE `botid`='" + guild.getJDA().getSelfUser().getId() + "'&&`guildid`='" + guild.getId() + "'");

        try {
            if (resultSet.next()) {
                return resultSet.getString("prefix");
            }
            resultSet.close();
            DiscordBotSystem.getMySQL().update("INSERT INTO `guilds` (`botid`, `guildid`, `prefix`, `language`, `isBetaGuild`, `isPremiumGuild`) VALUES ('" + guild.getJDA().getSelfUser().getId() + "', '" + guild.getId() + "', '!', 'German', '0', '0')");
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return "!";
    }

    public void setPrefix(String prefix, Guild guild) {
        createRowIfNotExists(guild);
        DiscordBotSystem.getMySQL().update("UPDATE `guilds` SET `prefix`='" + prefix + "' WHERE `botid`='" + guild.getJDA().getSelfUser().getId() + "'&&`guildid`='" + guild.getId() + "'");
        System.out.println("changed " + guild.getName() + " prefix to " + prefix);
    }

    @Override
    public void onMessageReceived(MessageReceivedEvent event) {
        if(!event.getChannelType().isGuild()) return;

        executeCommand(event.getMessage(), event.getMember(), event.getTextChannel());
    }

    @Override
    public void onMessageUpdate(MessageUpdateEvent event) {
        if(!event.getChannelType().isGuild()) return;

        executeCommand(event.getMessage(), Objects.requireNonNull(event.getMember()), event.getTextChannel());
    }

    private void executeCommand(Message message, Member member, TextChannel textChannel){
        if(member.getUser().isBot()) return;

        if(GlobalChat.isGlobalTextChannel(textChannel)) return;

        Member selfUser = member.getGuild().getMemberById(member.getJDA().getSelfUser().getId());

        assert selfUser != null;

        String messageString = message.getContentRaw();
        String prefix = getPrefix(member.getGuild());

        if (messageString.startsWith(prefix)) {
            messageString = messageString.substring(prefix.length());
            String command = messageString.split(" ")[0].toLowerCase();

            if (commands.containsKey(command.toLowerCase())) {
                if(selfUser.hasPermission(Permission.MESSAGE_MANAGE)) message.delete().queue();
                if (!isDeactivated(member.getGuild().getId(), member.getJDA().getSelfUser().getId(), command)) {
                    if (!canExecuteCommand(command, member, textChannel)) return;

                    if(!selfUser.hasPermission(Permission.ADMINISTRATOR)){
                        if(selfUser.hasPermission(Permission.MESSAGE_WRITE)){
                            DiscordBotSystem.getLanguageSystem().getMessages(member, "error", "needAdministratorPermission").queue(message1 ->
                                    new SimpleEmbed()
                                            .setColor(Color.RED)
                                            .setCurrentTimeStamp()
                                            .setTitle(message1.getTranslation("error"))
                                            .setDescription(message1.getTranslation("needAdministratorPermission"))
                                            .setFooter(message.getAuthor())
                                            .send(textChannel, 15, TimeUnit.SECONDS));
                        }
                        return;
                    }

                    OffsetDateTime time = message.getTimeCreated().plusHours(1);
                    System.out.println(ConsoleColor.GREEN + "[" + time.getHour() + ":" + time.getMinute() + " " + time.getDayOfMonth() + "." + time.getMonth().getValue() + "." + time.getYear() + "] " + message.getAuthor().getAsTag() + " execute " + message.getContentRaw());

                    String args = "";
                    if (command.length() + 1 < messageString.length()) {
                        args = messageString.substring(command.length() + 1);
                    }
                    commands.get(command).execute(new CommandEvent(message, args, prefix));
                } else {
                    DiscordBotSystem.getLanguageSystem().getMessages(member, "disabled", "disabledCommand").queue(message1 ->
                            new SimpleEmbed()
                                    .setColor(Color.RED)
                                    .setCurrentTimeStamp()
                                    .setTitle(message1.getTranslation("disabled"))
                                    .setDescription(message1.getTranslation("disabledCommand"))
                                    .setFooter(message.getAuthor())
                                    .send(textChannel, 15, TimeUnit.SECONDS));
                }
            }
        }
    }

    private boolean canExecuteCommand(String command, Member member, TextChannel channel) {
        ResultSet resultSet = DiscordBotSystem.getMySQL().query("SELECT * FROM `commands` WHERE `name`='" + command + "'");

        try {
            if (resultSet.next()) {
                if (resultSet.getBoolean("isBeta")) {
                    if (isBetaGuild(member.getGuild())) return true;

                    DiscordBotSystem.getLanguageSystem().getMessages(member, "error", "betaCommandError").queue(languageMessages -> {
                        channel.sendMessage(new EmbedBuilder()
                                .setTimestamp(Instant.now())
                                .setFooter(member.getUser().getAsTag(), member.getUser().getAvatarUrl())
                                .setColor(Color.RED)
                                .setTitle(languageMessages.getTranslation("error"))
                                .setDescription(languageMessages.getTranslation("betaCommandError"))
                                .build()).queue(message1 -> message1.delete().queueAfter(15, TimeUnit.SECONDS));
                    });

                    return false;
                } else if (resultSet.getBoolean("isPremium")) {
                    if (isPremiumGuild(member.getGuild())) return true;
                    DiscordBotSystem.getLanguageSystem().getMessages(member, "error", "premiumCommandError").queue(languageMessages -> {
                        channel.sendMessage(new EmbedBuilder()
                                .setTimestamp(Instant.now())
                                .setFooter(member.getUser().getAsTag(), member.getUser().getAvatarUrl())
                                .setColor(Color.RED)
                                .setTitle(languageMessages.getTranslation("error"))
                                .setDescription(languageMessages.getTranslation("premiumCommandError"))
                                .build()).queue(message1 -> message1.delete().queueAfter(15, TimeUnit.SECONDS));
                    });
                    return false;
                }
            }
            resultSet.next();
        } catch (SQLException e) {
            e.printStackTrace();
        }


        return true;
    }

    private boolean isBetaGuild(Guild guild) {
        ResultSet resultSet = DiscordBotSystem.getMySQL().query("SELECT * FROM `guilds` WHERE `botid`='" + guild.getJDA().getSelfUser().getId() + "'&&`guildid`='" + guild.getId() + "'");

        try {
            boolean returned = false;
            if (resultSet.next()) {
                returned = resultSet.getBoolean("isBetaGuild");
            }
            resultSet.close();
            return returned;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }

    private boolean isPremiumGuild(Guild guild) {
        ResultSet resultSet = DiscordBotSystem.getMySQL().query("SELECT * FROM `guilds` WHERE `botid`='" + guild.getJDA().getSelfUser().getId() + "'&&`guildid`='" + guild.getId() + "'");

        try {
            boolean returned = false;
            if (resultSet.next()) {
                returned = resultSet.getBoolean("isPremiumGuild");
            }
            resultSet.close();
            return returned;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }

    private boolean isDeactivated(String guildId, String botId, String command) {
        ResultSet resultSet = DiscordBotSystem.getMySQL().query("SELECT * FROM `botv3`.`guildcommands` WHERE guildcommands.`botid`='" + botId + "'&&`guildcommands`.`guildid`='" + guildId + "'&&guildcommands.`isDeactivated`='1'&&guildcommands.`command`='" + command + "'");
        try {
            if (resultSet.next()) {
                return resultSet.getBoolean("isDeactivated");
            }
            resultSet.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }
}