const { Command, Argument } = require('../../../../interfaces/');

const { stripIndents } = require('common-tags');

class SettingCommand extends Command {

    constructor(client) {

        super(client, {
            name: 'setting',
            module: 'utility',
            description: "Sets user or guild settings.",
            aliases: [
                'settings',
                'set'
            ],
            arguments: [
                new Argument(client, {
                    name: 'user',
                    type: 'BOOLEAN',
                    types: ['VERBAL', 'FLAG'],
                    default: true
                }),
                new Argument(client, {
                    name: 'all',
                    type: 'BOOLEAN',
                    types: ['VERBAL', 'FLAG'],
                    default: true
                })
            ],
            memberPermissions: ['ADMINISTRATOR'],
            showUsage: true,
            
        });

        this.client = client;


    }

    async execute(message, { params, args }) {

        const type = (!message.guild || args.user) ? 'USER' : 'GUILD';

        const target = params[0].toLowerCase(); // params[0] should never be null, see showUsage
        if(target === 'list') {
            this._listSettings(message, type, Boolean(args.all));
            return undefined;
        } else if(target === 'reset') {
            if(message.channel.permissionsFor(message.member).missing('ADMINISTRATOR').length > 0) {
                await message.respond(message.format('C_SETTINGS_ADMINISTRATORERROR', { type: type.toLowerCase() }), { emoji: 'failure' });
                return undefined;
            }
            const prompt = await message.prompt(message.format('C_SETTINGS_RESET', { type: type.toLowerCase() }), { emoji: 'warning' });
            return await this._handleReset(prompt, message, type);
        } else if(target === 'walkthrough') {
            //TODO
            return undefined;
        }

        const settings = this.client.resolver.components(target, 'setting', false).sort(c=>c.resolve === type);
        const [ setting ] = settings;
        if(!setting) {
            await message.respond(message.format('C_SETTINGS_NONEXISTANT'), { emoji: 'failure' });
            return undefined;
        }

        //Setting permission handling
        if(setting.clientPermissions.length > 0) {
            const missing = message.channel.permissionsFor(message.guild.me).missing(command.clientPermissions);
            if(missing.length > 0) {
                await message.respond(message.format('C_SETTINGS_CLIENTPERMISSIONERROR', { setting: setting.moduleResolveable, missing: missing.join(', ')}), { emoji: 'failure' });
                return undefined;
            }
        } else if(setting.memberPermissions.length > 0) {
            const missing = message.channel.permissionsFor(message.member).missing(command.memberPermissions);
            if(missing.length > 0) {
                await message.respond(message.format('C_SETTINGS_MEMBERPERMISSIONERROR', { setting: setting.moduleResolveable, missing: missing.join(', ')}), { emoji: 'failure' });
                return undefined;
            }
        }

        const response = await setting.handle(message, params.splice(1));
        message.respond(response.msg, { emoji: response.error ? 'failure' : 'success' });

    }

    _listSettings(message, type, all) {
        if(!message.guild && type === 'GUILD') type = 'USER';

        const prefix = message.guild?.prefix || this.client._options.bot.prefix;

        let fields = [];
        const sorted = this.client.registry.components
            .filter(c=>c.type === 'module')
            .sort((a, b) => {
                const filter = c=>c.type === 'setting';
                return b.components.filter(filter) - a.components.filter(filter);
            });

        for(const module of sorted.values()) {
            let field = {
                name: module.id,
                value: '',
                inline: true
            };

            for(const setting of module.components.values()) {
                if(setting.type !== 'setting' 
                    || (setting.resolve !== type && !all)
                    || (setting.restricted && !all)) continue;
                field.value += `\`${setting.display}\`\n`;
            }
            if(field.value) fields.push(field);
        }

        const embed = {
            author: {
                name: `${type === 'GUILD' ? message.format('C_SETTINGS_GUILDSETTINGSTITLE') : message.format('C_SETTINGS_USERSETTINGSTITLE')}`,
                icon_url: type === 'GUILD' ? message.guild.iconURL() : message.author.avatarURL()
            },
            description: stripIndents`${message.format('C_SETTINGS_LISTSETTINGS', { prefix })}

            ${type === 'USER' ? '' : message.format('C_SETTINGS_LISTSETTINGSALT', { prefix })}`,
            fields
        };

        return message.embed(embed);

    }

    async _handleReset(prompt, message, type) {

        if(!prompt) return;
        const response = prompt.content.toLowerCase();
        const bool = this.client.resolver.resolveBoolean(response);
        if(bool === null) return message.respond(message.format('C_SETTINGS_RESETERROR'), { emoji: 'failure' });
        if(!bool) return message.respond(message.format('C_SETTINGS_RESETABORT'), { emoji: 'success' });

        type === 'USER'
            ? await message.author._deleteSettings()
            : await message.guild._deleteSettings();

        return message.respond(message.format('C_SETTINGS_RESETSUCCESS', { type: type.toLowerCase() }), { emoji: 'success' })

    }

}

module.exports = SettingCommand;