import { MessageActionRow, MessageButton, MessageButtonStyleResolvable, MessageComponent, MessageMenu, MessageMenuOption } from 'discord-buttons';
import { Message, TextChannel } from 'discord.js';
const Discord = require('discord.js'),
    client = new Discord.Client(),
    disbut = require('discord-buttons');
disbut(client);

declare interface OptMenuOptions {
    label: string;
    emoji?: string;
    val: string;
    desc?: string;
    roleid: string;
    default?: boolean;
}

declare interface OptMenu {
    type: 'menu';
    message: string;
    palceholder: string;
    id: string;
    max: number|'all';
    options: OptMenuOptions[];
}

declare interface OptRowButton {
    style: MessageButtonStyleResolvable;
    label: string;
    id: string;
    roleid: string;
}

declare interface OptRow {
    type: 'row';
    message: string;
    buttons: [OptRowButton?, OptRowButton?, OptRowButton?, OptRowButton?, OptRowButton?];
}

const InteractionRoles: (OptRow|OptMenu)[] = [
    {
        type: 'menu',
        message: 'Pronouns',
        palceholder: '',
        id: 'rolemenu',
        max: 'all',
        options: [
            {
                label: 'They/Them',
                val: 'they',
                roleid: '861453442387279872'
            },
            {
                label: 'He/Him',
                val: 'he',
                roleid: '861453443188129872'
            },
            {
                label: 'She/Her',
                val: 'she',
                roleid: '861453442777219112'
            },
            {
                label: 'It/Its',
                val: 'it',
                roleid: '862687464543223809'
            },
            {
                label: 'Fae/Faer',
                val: 'fae',
                roleid: '862687559464386601'
            },
            {
                label: 'Any',
                val: 'any',
                roleid: '861453441422983169'
            }
        ]
    },
    {
        type: 'menu',
        message: 'Role Color',
        palceholder: '',
        id: 'colormenu',
        max: 1,
        options: [
            {
                label: 'red',
                val: 'red',
                roleid: '863621755774959626'
            },
            {
                label: 'pink',
                val: 'pink',
                roleid: '863621801191931904'
            },
            {
                label: 'orange',
                val: 'orange',
                roleid: '863621849153273876'
            },
            {
                label: 'green',
                val: 'green',
                roleid: '863621885366894592'
            },
            {
                label: 'mint green',
                val: 'mint green',
                roleid: '863622000512860190'
            },
            {
                label: 'blue',
                val: 'blue',
                roleid: '863622336573079603'
            },
            {
                label: 'light blue',
                val: 'light blue',
                roleid: '863622365316513793'
            },
            {
                label: 'periwinkle',
                val: 'periwinkle',
                roleid: '863622403775266816'
            },
            {
                label: 'purple',
                val: 'purple',
                roleid: '863622442790682674'
            },
            {
                label: 'blank',
                val: 'blank',
                roleid: '',
                default: true
            }
        ]
    },
    {
        type: 'menu',
        message: 'Other Roles',
        palceholder: '',
        id: 'otherrolesmenu',
        max: 'all',
        options: [
            {
                label: 'Movie Night',
                val: 'movie',
                roleid: '862883242436591617'
            }
        ]
    }
];

function sendMenu(c: TextChannel, menuOpts: OptMenu) {

    let select = new MessageMenu()
        .setID(menuOpts.id)
        .setPlaceholder(menuOpts.palceholder)
        .setMaxValues(menuOpts.max === 'all' ? menuOpts.options.length : menuOpts.max)
        .setMinValues(0);

    for (let i = 0; i < menuOpts.options.length; i++) {

        let opts: OptMenuOptions = menuOpts.options[i];

        let option = new MessageMenuOption()
            .setLabel(opts.label)
            .setValue(opts.val);

        if (opts.emoji && opts.emoji.length)
            option.setEmoji(opts.emoji);

        if (opts.desc && opts.desc.length)
            option.setDescription(opts.desc);

        if (opts.default)
            option.setDefault();

        select.addOption(option);

    }

    c.send(menuOpts.message, select);
}

function sendRow(c: TextChannel, rowOpts: OptRow) {

    let row = new MessageActionRow();

    for (let i = 0; i < rowOpts.buttons.length; i++) {

        let opts: OptRowButton = rowOpts.buttons[i];

        let option = new MessageButton()
            .setStyle(opts.style)
            .setLabel(opts.label) 
            .setID(opts.id);

        row.addComponent(option);

    }

    c.send(rowOpts.message, row);
}

client.on('message', (m: Message) => {

    if (m.author.id === '167336999844315137' && m.content === '.') {

        for (let i = 0; i < InteractionRoles.length; i++) {
            switch (InteractionRoles[i].type) {
                case 'menu':
                    sendMenu(m.channel as TextChannel, InteractionRoles[i] as OptMenu);
                    break;
                case 'row':
                    sendRow(m.channel as TextChannel, InteractionRoles[i] as OptRow);
                    break;
            }
        }

    }

});

client.on('clickMenu', (menu: MessageComponent) => {
    menu.reply.think(true).then(async () => {

        let menus = InteractionRoles.filter(opt => opt.type === 'menu' && opt.id === menu.id);

        if (menus.length) {
            let m = menus[0] as OptMenu,
                vals = menu.values || [];

            let changed: {
                add: string[],
                rem: string[]
            } = {
                add: [],
                rem: []
            }

            for (let i = 0; i < m.options.length; i++) {

                let opt = m.options[i],
                    {roleid} = opt;
                
                if (roleid) {

                    let role = await menu.guild.roles.fetch(roleid);

                    if (vals && vals.includes(opt.val) && !menu.clicker.member.roles.cache.some(r => r.id === role.id)) {
                        await menu.clicker.member.roles.add(role);
                        changed.add.push(role.name);
                    } else if (menu.clicker.member.roles.cache.some(r => r.id === role.id)) {
                        await menu.clicker.member.roles.remove(role);
                        changed.rem.push(role.name);
                    }

                }

            }
        }

        menu.reply.edit('Updated Roles');

    });
});

client.on('clickButton', (button: MessageComponent) => {
    button.reply.think(true).then(async () => {

        let rows = InteractionRoles.filter(opt => opt.type === 'row');

        for (let i = 0; i < rows.length; i++) {
            let row = rows[i] as OptRow;
            let matchingButtons = row.buttons.filter(opt => opt.id === button.id);

            if (matchingButtons.length) {
                await button.clicker.member.roles.add(matchingButtons[0].roleid);
                break;
            }
        }

        button.reply.edit('Updated Roles');

    });
});
    
client.login(require('fs').readFileSync('../token').toString());