package net.tylermurphy.ken.command;

import net.dv8tion.jda.api.EmbedBuilder;
import net.dv8tion.jda.api.JDA;
import net.dv8tion.jda.api.entities.*;
import net.dv8tion.jda.api.entities.channel.middleman.GuildMessageChannel;
import net.dv8tion.jda.api.events.guild.member.GuildMemberJoinEvent;
import net.dv8tion.jda.api.events.guild.member.GuildMemberRemoveEvent;
import net.dv8tion.jda.api.events.interaction.command.SlashCommandInteractionEvent;
import net.dv8tion.jda.api.events.interaction.component.ButtonInteractionEvent;
import net.dv8tion.jda.api.events.interaction.component.SelectMenuInteractionEvent;
import net.dv8tion.jda.api.hooks.ListenerAdapter;
import net.dv8tion.jda.api.interactions.InteractionHook;
import net.dv8tion.jda.api.interactions.commands.OptionMapping;
import net.dv8tion.jda.api.interactions.components.ActionRow;
import net.dv8tion.jda.api.interactions.components.LayoutComponent;
import net.dv8tion.jda.api.interactions.components.buttons.Button;
import net.dv8tion.jda.api.interactions.components.selections.SelectMenu;
import net.dv8tion.jda.api.requests.restaction.WebhookMessageCreateAction;
import net.dv8tion.jda.api.utils.FileUpload;
import net.tylermurphy.ken.Ken;
import net.tylermurphy.ken.command.game.Claim;
import net.tylermurphy.ken.command.game.Money;
import net.tylermurphy.ken.command.game.Roulette;
import net.tylermurphy.ken.command.game.Slots;
import net.tylermurphy.ken.command.fun.*;
import net.tylermurphy.ken.command.game.*;
import net.tylermurphy.ken.command.main.*;
import net.tylermurphy.ken.command.moderation.*;
import net.tylermurphy.ken.command.music.*;
import net.tylermurphy.ken.command.music.Queue;
import net.tylermurphy.ken.command.nsfw.*;
import net.tylermurphy.ken.command.selfrole.*;
import net.tylermurphy.ken.command.social.Sticker;

import java.awt.*;
import java.lang.reflect.Method;
import java.util.*;
import java.util.List;

public class Responder extends ListenerAdapter {

    private final Register register;

    public Responder(JDA api) {
        this.register = new Register(api);
    }

    public void registerCommands(){
        Object[] objects = new Object[]{
                new Coinflip(),
                new Dice(),
                new Eject(),
                new AddRole(),
                new DeleteRole(),
                new AddRolesPage(),
                new DeleteRolesPage(),
                new Roles(),
                new Help(),
                new Purge(),
                new ForceSkip(),
                new Join(),
                new Leave(),
                new Loop(),
                new LoopQueue(),
                new NowPlaying(),
                new Pause(),
                new Play(),
                new Queue(),
                new Remove(),
                new Resume(),
                new Skip(),
                new Stop(),
                new Danbooru(),
                new E621(),
                new Gelbooru(),
                new Hentai(),
                new Konachan(),
                new nHentai(),
                new Rule34(),
                new Yandere(),
                new Money(),
                new Slots(),
                new Claim(),
                new Headpat(),
                new Roulette(),
                new GayMeme(),
                new CrabRave(),
                new Wank(),
                new Ban(),
                new TempBan(),
                new Kick(),
                new UnBan(),
                new Mute(),
                new UnMute(),
                new SetJoining(),
                new History(),
                new Sticker()
        };
        Arrays.stream(objects).forEach(register::register);
    }

    public void onSlashCommandInteraction(SlashCommandInteractionEvent event) {

        // Make sure the Bot can Talk
        if(!event.getChannel().canTalk()) return;

        // Bots are not allowed to use commands
        if (event.getMember() == null || event.getUser().isBot()) return;

        // Get Command Information From Invoke
        final String invoke = event.getName().toLowerCase(Locale.ROOT);

        Method method = register.getCommand(invoke);

        // Check Permissions
        if(!event.getMember().hasPermission(register.getPermission(invoke))) {
            EmbedBuilder builder = Ken.getInstance().getDefaultEmbed()
                    .appendDescription(":x: **Invalid Permissions**\n")
                    .appendDescription("You require the "+ register.getPermission(invoke)+" permission to use this command.");
            event.replyEmbeds(builder.build()).setEphemeral(true).queue();
            return;
        }

        // Get slash command options if there are any
        List<Object> args = getOptions(event.getOptions());

        // Get parameters to send to Method
        Object[] parameters = new Object[method.getParameterTypes().length];
        Class<?>[] types = method.getParameterTypes();
        for(int i = 0; i < types.length; i++){
            if(types[i] == Member.class){
                parameters[i] = event.getMember();
            } else if(types[i] == GuildMessageChannel.class){
                parameters[i] = event.getGuildChannel();
            } else if(types[i] == Guild.class) {
                parameters[i] = event.getGuild();
            } else if(types[i] == List.class) {
                parameters[i] = args;
            } else {
                parameters[i] = null;
            }
        }

        // Invoke Method and Respond to User
        try {
            Object temp = method.invoke(register.getHandle(method.getDeclaringClass().getName()), parameters);
            Response response = (Response)temp;
            event.deferReply(response.isError()).queue();
            reply(response, event.getHook());
        } catch (Exception e) {
            e.printStackTrace();
            EmbedBuilder builder = Ken.getInstance().getDefaultEmbed()
                    .setColor(Color.RED)
                    .setTitle(":x: **Error**")
                    .setDescription(e.getCause() != null ? e.getCause().getMessage() : e.getMessage());
            event.getHook().sendMessageEmbeds(builder.build()).setEphemeral(true).queue();
        }
    }

    public void onButtonInteraction(ButtonInteractionEvent event) {

        // Make sure the Bot can Talk
        if(!event.getChannel().canTalk()) return;
        // Bots are not allowed to use commands
        if (event.getMember() == null || event.getUser().isBot()) return;

        // Get Command Information From Invoke
        final String invoke = event.getComponentId().toLowerCase(Locale.ROOT).split("_")[0];
        Method method = register.getButtonCallback(invoke);

        // Get parameters to send to Method
        Object[] parameters = new Object[method.getParameterTypes().length];
        Class<?>[] types = method.getParameterTypes();
        for(int i = 0; i < types.length; i++){
            if(types[i] == Member.class){
                parameters[i] = event.getMember();
            } else if(types[i] == GuildMessageChannel.class){
                parameters[i] = event.getGuildChannel();
            } else if(types[i] == Guild.class) {
                parameters[i] = event.getGuild();
            } else if(types[i] == Button.class) {
                parameters[i] = event.getButton();
            } else if(types[i] == Message.class) {
                parameters[i] = event.getMessage();
            } else if(types[i] == String.class) {
                parameters[i] = event.getComponentId().substring(invoke.length()+1);
            } else {
                parameters[i] = null;
            }
        }

        // Invoke Method and Respond to User
        try {
            event.deferEdit().queue();
            Object temp = method.invoke(register.getHandle(method.getDeclaringClass().getName()), parameters);
            Response response = (Response) temp;
            edit(response, event.getHook());
        } catch (Exception e) {
            EmbedBuilder builder = Ken.getInstance().getDefaultEmbed()
                    .setColor(Color.RED)
                    .setTitle(":x: **Error**")
                    .setDescription(e.getCause().getMessage());
            event.getHook().editOriginalEmbeds(builder.build()).queue();
            event.getHook().editOriginalComponents(new ArrayList<>()).queue();
        }

    }

    public void onSelectMenuInteraction(SelectMenuInteractionEvent event) {

        // Make sure the Bot can Talk
        if(!event.getChannel().canTalk()) return;
        // Bots are not allowed to use commands
        if (event.getMember() == null || event.getUser().isBot()) return;

        // Get Command Information From Invoke
        final String invoke = event.getComponentId().toLowerCase(Locale.ROOT).split("_")[0];
        Method method = register.getSelectMenuCallback(invoke);

        // Get parameters to send to Method
        Object[] parameters = new Object[method.getParameterTypes().length];
        Class<?>[] types = method.getParameterTypes();
        for(int i = 0; i < types.length; i++){
            if(types[i] == Member.class){
                parameters[i] = event.getMember();
            } else if(types[i] == GuildMessageChannel.class){
                parameters[i] = event.getGuildChannel();
            } else if(types[i] == Guild.class) {
                parameters[i] = event.getGuild();
            } else if(types[i] == SelectMenu.class) {
                parameters[i] = event.getSelectMenu();
            } else if(types[i] == Message.class) {
                parameters[i] = event.getMessage();
            } else if(types[i] == String.class){
                parameters[i] = event.getValues().get(0);
            } else {
                parameters[i] = null;
            }
        }

        // Invoke Method and Respond to User
        try {
            Object temp = method.invoke(register.getHandle(method.getDeclaringClass().getName()), parameters);
            Response response = (Response) temp;
            event.deferReply(response.isError()).queue();
            reply(response, event.getHook());
        } catch (Exception e) {
            EmbedBuilder builder = Ken.getInstance().getDefaultEmbed()
                    .setColor(Color.RED)
                    .setTitle(":x: **Error**")
                    .setDescription(e.getCause().getMessage());
            event.getHook().sendMessageEmbeds(builder.build()).queue();
            event.getHook().editOriginalComponents(new ArrayList<>()).queue();
        }
    }

    private void reply(Response response, InteractionHook hook){
        if(response.isError()) {
            EmbedBuilder builder = Ken.getInstance().getDefaultEmbed()
                    .setColor(Color.RED)
                    .setDescription(response.getMessage());
            hook.sendMessageEmbeds(builder.build()).setEphemeral(true).queue();
        } else {
            WebhookMessageCreateAction<Message> message;
            if(response.hasEmbed()) {
                message = hook.sendMessageEmbeds(response.getEmbeds());
            } else {
                message = hook.sendMessage(response.getMessage());
            }
            if(response.hasButtons()) message = message.addActionRow(response.getButtons());
            if(response.hasSelectMenu()) message = message.addActionRow(response.getSelectMenu());
            if(response.hasFile()) message = message.addFiles(FileUpload.fromData(response.getFile(),response.getFileName()));
            message.setEphemeral(response.isHidden()).queue();
        }
    }

    private void edit(Response response, InteractionHook hook){
        if(response.isError()) {
            EmbedBuilder builder = Ken.getInstance().getDefaultEmbed()
                    .setColor(Color.RED)
                    .setDescription(response.getMessage());
            hook.sendMessageEmbeds(builder.build()).queue();
            hook.editOriginalComponents(new ArrayList<>()).queue();
        } else if(response.isDelete()) {
            hook.deleteOriginal().queue();
        } else {
            if(response.hasEmbed()) {
                hook.editOriginalEmbeds(response.getEmbeds()).queue();
            } else {
                hook.editOriginal(response.getMessage()).queue();
            }
            if(response.hasSelectMenu() || response.hasButtons()) {
                List<LayoutComponent> components = new ArrayList<>();
                if(response.hasButtons()) components.add(ActionRow.of(response.getButtons()));
                if(response.hasSelectMenu()) components.add(ActionRow.of(response.getSelectMenu()));
                hook.editOriginalComponents(components).queue();
            }
        }
    }

    private List<Object> getOptions(List<OptionMapping> options){
        List<Object> args = new ArrayList<>();
        options.forEach(option -> {
            switch (option.getType()) {
                case STRING -> args.add(option.getAsString());
                case INTEGER -> args.add(option.getAsInt());
                case NUMBER -> args.add(option.getAsDouble());
                case BOOLEAN -> args.add(option.getAsBoolean());
                case USER -> args.add(option.getAsMember());
                case CHANNEL -> args.add(option.getAsChannel());
                case ROLE -> args.add(option.getAsRole());
                case MENTIONABLE -> args.add(option.getAsMentionable());
                case ATTACHMENT -> args.add(option.getAsAttachment());
                default -> {
                }
            }
        });
        return args;
    }

    public void onGuildMemberJoin(GuildMemberJoinEvent event) {
        User user = event.getUser();
        Ken.getInstance().getDatabase().getUserTable().setData(user.getIdLong(), user.getName(), Integer.parseInt(user.getDiscriminator()));
        boolean setValue = true;
        String value = Ken.getInstance().getDatabase().getGuildSettingsTable().getData(event.getGuild().getIdLong(), "closeServer");
        if(value != null) setValue = Boolean.parseBoolean(value);
        if(!setValue){
            try {
                event.getGuild().kick(user).reason("Server is currently closed").queue();
                user.openPrivateChannel().queue(privateChannel -> {
                    EmbedBuilder builder = Ken.getInstance().getDefaultEmbed()
                            .appendDescription("Kicked from "+event.getGuild().getName() + " because the server is currently closed");
                    privateChannel.sendMessageEmbeds(builder.build()).queue();

                });
            } catch (Exception ignored){}
        }
    }

    public void onGuildMemberRemove(GuildMemberRemoveEvent event) {
        User user = event.getUser();
        Ken.getInstance().getDatabase().getUserTable().setData(user.getIdLong(), user.getName(), Integer.parseInt(user.getDiscriminator()));
    }

}