const RoleMenu = require('../models/RoleMenu');
const ServerConfig = require('../models/ServerConfig');
const {MessageActionRow, MessageSelectMenu} = require("discord.js");
const checkPerm = require('../util/perm');
const locales = require("../util/locale");

// slashcommand handler
async function addRoleMenu(interaction) {
    const config = await ServerConfig.findOne({guildID: interaction.guild.id.toString()});
    console.log('addrolemenu 20210926T2132')
    // let locale = 'en';
    // if (config != null) {
    //     locale = config.locale;
    // }

    const locale = config?.locale || 'en'
    const functionLocale = locales.get(locale).components.roleMenu;
    const messageLocale = locales.get(locale).misc.messageTemplates.roleDropdown;
    if (!(await checkPerm(interaction.member, 'role_menu'))) {
        await interaction.reply({content: functionLocale.accessDenied, ephemeral: true});
        return;
    }
    const channel = interaction.options.getChannel('channel');
    const messageContent = interaction.options.getString('message');
    const type = interaction.options.getString('type');
    const verification = interaction.options.getBoolean('verification');
    const row1 = new MessageActionRow()
        .addComponents(
            new MessageSelectMenu()
                .setCustomId('selectRole')
                .setPlaceholder(messageLocale.placeholder)
                .addOptions([
                    {
                        label: messageLocale.selectResetText,
                        value: 'select_reset'
                    }
                ])
                .addOptions([
                    {
                        label: 'Debug Option 1',
                        value: 'option1',
                        emoji: '1️⃣'
                    }
                ])
                .addOptions([
                    {
                        label: 'Debug Option 2',
                        value: 'option2',
                        emoji: '2️⃣'
                    }
                ])
                .setMaxValues(2)
                .setMinValues(0)
        );
    const msg = await channel.send({content: messageContent, components: [row1]});
    let menu = new RoleMenu();
    menu.guildID = channel.guild.id;
    menu.channelID = channel.id;
    menu.messageID = msg.id;
    menu.verification = verification;
    menu.type = type;
    menu.roles = [];
    await menu.save();
    await interaction.reply({content: functionLocale.roleMenuCreated, ephemeral: true});
}

async function deleteRoleMenu(interaction) {
    const config = await ServerConfig.findOne({guildID: interaction.guild.id.toString()});
    let locale = 'en';
    if (config != null) {
        locale = config.locale;
    }
    const functionLocale = locales.get(locale).components.roleMenu;
    if (!(await checkPerm(interaction.member, 'role_menu'))) {
        await interaction.reply({content: functionLocale.accessDenied, ephemeral: true})
        return;
    }
    const channel = interaction.options.getChannel('channel');
    const messageID = interaction.options.getString('message_id');
    let menu = await RoleMenu.findOne({guildID: channel.guild.id, channelID: channel.id, messageID});
    if (channel.isText()) {
        var message = null;
        var messageSuccess = true;
        try {
            message = await channel.messages.fetch(messageID);
        } catch (e) {
            messageSuccess = false;
        }
        if (messageSuccess) {
            if (message != null) {
                if (menu != null) {
                    try {
                        await RoleMenu.deleteOne({_id: menu._id});
                        await message.delete();
                        await interaction.reply({content: functionLocale.roleMenuDeleted, ephemeral: true});
                    } catch (e) {
                        await interaction.reply({content: functionLocale.roleMenuDeletedFailed, ephemeral: true});
                    }
                } else {
                    await interaction.reply({content: functionLocale.notMenuMessage, ephemeral: true});
                }
            } else {
                await interaction.reply({content: functionLocale.messageIdNotFound, ephemeral: true});
            }
        } else {
            await interaction.reply({content: functionLocale.invalidMessageId, ephemeral: true})
        }
    } else {
        await interaction.reply({content: functionLocale.channelNotText, ephemeral: true});
    }
}

async function addRoleToMenu(interaction) {
    const config = await ServerConfig.findOne({guildID: interaction.guild.id.toString()});
    let locale = 'en';
    if (config != null) {
        locale = config.locale;
    }
    const functionLocale = locales.get(locale).components.roleMenu;
    if (!(await checkPerm(interaction.member, 'role_menu'))) {
        await interaction.reply({content: functionLocale.accessDenied, ephemeral: true})
        return;
    }
    const channel = interaction.options.getChannel('channel');
    const messageID = interaction.options.getString('message_id');
    const role = interaction.options.getRole('role')
    if (channel.isText()) {
        var message = null;
        var messageSuccess = true;
        try {
            message = await channel.messages.fetch(messageID);
        } catch (e) {
            messageSuccess = false;
        }
        if (messageSuccess) {
            if (message != null) {
                let menu = await RoleMenu.findOne({
                    guildID: channel.guild.id,
                    channelID: channel.id,
                    messageID
                });
                if (menu != null) {
                    let components = message.components;
                    if (!menu.roles.map((role) => role.roleID).includes(role.id.toString())) {
                        components[0].components[0].addOptions({
                            label: role.name,
                            value: role.name.toLowerCase().replace(" ", "_")
                        });
                        menu.roles.push({
                            text: role.name,
                            value: role.name.toLowerCase().replace(" ", "_"),
                            roleID: role.id
                        });
                        await menu.save();
                        await message.edit({content: message.content, components});
                        await interaction.reply({
                            content: functionLocale.roleAdded.replaceAll("$$ROLE$$", `${role.name}`),
                            ephemeral: true
                        });
                    } else {
                        await interaction.reply({
                            content: functionLocale.roleAlreadyAdded.replaceAll('$$ROLE$$', `${role.name}`),
                            ephemeral: true
                        });
                    }
                } else {
                    await interaction.reply({content: functionLocale.notMenuMessage, ephemeral: true});
                }
            } else {
                await interaction.reply({content: functionLocale.messageIdNotFound, ephemeral: true});
            }
        } else {
            await interaction.reply({content: functionLocale.invalidMessageId, ephemeral: true})
        }
    } else {
        await interaction.reply({content: functionLocale.channelNotText, ephemeral: true});
    }
}

async function deleteRoleFromMenu(interaction) {
    const config = await ServerConfig.findOne({guildID: interaction.guild.id.toString()});
    let locale = 'en';
    if (config != null) {
        locale = config.locale;
    }
    const functionLocale = locales.get(locale).components.roleMenu;
    if (!(await checkPerm(interaction.member, 'role_menu'))) {
        await interaction.reply({content: functionLocale.accessDenied, ephemeral: true})
        return;
    }
    const channel = interaction.options.getChannel('channel');
    const messageID = interaction.options.getString('message_id');
    const role = interaction.options.getRole('role');
    if (channel.isText()) {
        var message = null;
        var messageSuccess = true;
        try {
            message = await channel.messages.fetch(messageID);
        } catch (e) {
            messageSuccess = false;
        }
        if (messageSuccess) {
            if (message != null) {
                let menu = await RoleMenu.findOne({
                    guildID: channel.guild.id,
                    channelID: channel.id,
                    messageID
                });
                if (menu != null) {
                    if (menu.roles.map((role) => role.roleID).includes(role.id.toString())) {
                        const value = menu.roles[menu.roles.map(role => role.roleID).indexOf(role.id.toString())].value;
                        const index1 = menu.roles.map(role => role.value).indexOf(value);
                        menu.roles.splice(index1, 1);
                        const index2 = message.components[0].components[0].options
                            .map(option => option.value).indexOf(value);
                        message.components[0].components[0].options
                            .splice(index2, 1);
                        await message.edit({content: message.content, components: message.components});
                        await menu.save();
                        await interaction.reply({
                            content: functionLocale.roleRemoved.replaceAll('$$ROLE$$', `${role.name}`),
                            ephemeral: true
                        });
                    } else {
                        await interaction.reply({
                            content: functionLocale.roleNotRemoved.replaceAll('$$ROLE$$', `${role.name}`),
                            ephemeral: true
                        });
                    }
                } else {
                    await interaction.reply({content: functionLocale.notMenuMessage, ephemeral: true});
                }
            } else {
                await interaction.reply({content: functionLocale.messageIdNotFound, ephemeral: true});
            }
        } else {
            await interaction.reply({content: functionLocale.invalidMessageId, ephemeral: true})
        }
    } else {
        await interaction.reply({content: functionLocale.channelNotText, ephemeral: true});
    }
}

async function editRoleMenu(interaction) {
    const config = await ServerConfig.findOne({guildID: interaction.guild.id.toString()});
    let locale = 'en';
    if (config != null) {
        locale = config.locale;
    }
    const functionLocale = locales.get(locale).components.roleMenu;
    if (!(await checkPerm(interaction.member, 'role_menu'))) {
        await interaction.reply({content: functionLocale.accessDenied, ephemeral: true})
        return;
    }
    const channel = interaction.options.getChannel('channel');
    const messageID = interaction.options.getString('message_id');
    const messageContent = interaction.options.getString('message');
    const type = interaction.options.getString('type');
    const verification = interaction.options.getBoolean('verification');
    if (channel.isText()) {
        var message = null;
        var messageSuccess = true;
        try {
            message = await channel.messages.fetch(messageID);
        } catch (e) {
            messageSuccess = false;
        }
        if (messageSuccess) {
            if (message != null) {
                let menu = await RoleMenu.findOne({
                    guildID: channel.guild.id,
                    channelID: channel.id,
                    messageID
                });
                if (menu != null) {
                    if (messageContent != null) {
                        await message.edit({content: messageContent, components: message.components});
                    }
                    if (type != null) {
                        menu.type = type;
                    }
                    if (verification != null) {
                        menu.verification = verification;
                    }
                    await menu.save();
                    await interaction.reply({content: functionLocale.menuUpdated, ephemeral: true});

                } else {
                    await interaction.reply({content: functionLocale.notMenuMessage, ephemeral: true});
                }
            } else {
                await interaction.reply({content: functionLocale.messageIdNotFound, ephemeral: true});
            }
        } else {
            await interaction.reply({content: functionLocale.invalidMessageId, ephemeral: true})
        }
    } else {
        await interaction.reply({content: functionLocale.channelNotText, ephemeral: true});
    }
}

const slashCommandHandler = async (interaction, client) => {
    if (interaction.commandName === 'add_role_menu') {
        await addRoleMenu(interaction);
    } else if (interaction.commandName === 'delete_role_menu') {
        await deleteRoleMenu(interaction);
    } else if (interaction.commandName === 'add_role_to_menu') {
        await addRoleToMenu(interaction);
    } else if (interaction.commandName === 'delete_role_from_menu') {
        await deleteRoleFromMenu(interaction);
    } else if (interaction.commandName === 'edit_role_menu') {
        await editRoleMenu(interaction);
    }
}

/*const buttonHandler = async (interaction, client) => {

}*/

const selectMenuHandler = async (interaction, client) => {
    if (interaction.customId === 'selectRole') {
        const config = await ServerConfig.findOne({guildID: interaction.guild.id.toString()});
        const locale = config?.locale || 'en';
        const functionLocale = locales.get(locale).components.roleMenu;
        const guild = interaction.guild;
        const channel = interaction.channel;
        const message = interaction.message;
        const menu = await RoleMenu.findOne({
            guildID: guild.id,
            channelID: channel.id,
            messageID: message.id
        });
        if (menu != null) {
            if (interaction.values.includes('select_reset')) {
                const roleIDs = menu.roles.map(role => role.roleID);
                roleIDs.forEach(roleID => interaction.member.roles.remove(roleID));
                await interaction.reply({content: functionLocale.interactionMessage.roleRemoved, ephemeral: true});
            } else {
                const roleIDs = menu.roles.map(role => role.roleID);
                roleIDs.forEach(roleID => interaction.member.roles.remove(roleID));
                interaction.member.roles.add(roleIDs[menu.roles.map(role => role.value).indexOf(interaction.values[0])]);
                await interaction.reply({content: functionLocale.interactionMessage.roleAdded, ephemeral: true});
            }
        } else {
            await interaction.reply({content: functionLocale.internalError, ephemeral: true});
        }
    }
}



const newSlashCommandHandler = async (act, client) => {
}

const newSelectMenuHandler = async (act, client) => {
    if(act.customId !== 'selectRole') return;
    const config = await ServerConfig.findOne({guildID: act.guild.id.toString()});
    const locale = config?.locale || 'en';
    const functionLocale = locales.get(locale).components.roleMenu;
    const menu = await RoleMenu.findOne({
        guildID: act.guild.id,
        channelID: act.channel.id,
        messageID: act.message.id
    });
    if (menu) {
        const roleIDs = menu.roles.map(role => role.roleID);
        menu.roles.forEach(role => act.member.roles[act.values.includes[role.value] ? 'add' : 'remove'](role.id))
        // roleIDs.forEach(roleID => interaction.member.roles.remove(roleID));
        // act.member.roles.add(roleIDs[menu.roles.map(role => role.value).indexOf(act.values[0])]);
        await act.reply({content: functionLocale.interactionMessage.roleAdded, ephemeral: true});
    } else {
        await act.reply({content: functionLocale.internalError, ephemeral: true});
    }

}

module.exports = {
    slashCommandHandler: slashCommandHandler,
    //buttonHandler,
    selectMenuHandler: newSelectMenuHandler
}