const { Setting } = require('../../../../interfaces/');
const emojis = require('../../../../../util/emojis.json');
const maxCharacters = 98;

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

class MuteSetting extends Setting {

    constructor(client) {

        super(client, {
            name: 'mute',
            module: 'moderation',
            aliases: [
                'muted',
                'muteType',
                'mutedType',
                'muteRole',
                'mutedRole',
                'createMute',
                'createMuteRole',
                'createMuted',
                'createMutedRole'
            ], //people really be stupid like that
            arguments: [
                {
                    name: 'create',
                    description: "A_CREATE_MUTE_SETTINGS",
                    type: 'BOOLEAN',
                    types: ['VERBAL'],
                    default: true
                },
                {
                    name: 'type',
                    description: "A_TYPE_MUTE_SETTINGS",
                    type: 'BOOLEAN',
                    types: ['VERBAL'],
                    default: true
                },
                {
                    name: 'text',
                    description: "A_TEXT_MUTE_SETTINGS",
                    type: 'BOOLEAN',
                    types: ['FLAG'],
                    default: true
                },
                {
                    name: 'voice',
                    description: "A_VOICE_MUTE_SETTINGS",
                    type: 'BOOLEAN',
                    types: ['FLAG'],
                    default: true
                }
            ],
            usage: '[type|role|create] [muted-role|mute-type]',
            examples: [
                'muterole Muted',
                'mutetype 1',
                'createmute galacticbot-mute'
            ],
            resolve: 'GUILD',
            default: {
                mute: {
                    role: null,
                    type: 0
                }
            }
        });
    
        this.client = client;

    }

    async handle(message, args) {

        const { params, parsedArguments } = await this._parseArguments(args, message.guild);
        args = params;

        if(['mutetype', 'mutedtype'].includes(message._settingCaller) || parsedArguments.type) {
            const num = args[0].toLowerCase() === 'type' ? args[1] || 0 : args[0];
            const number = parseInt(num);
            if(isNaN(number)) return {
                msg: message.format('S_MUTE_TYPENAN'),
                error: true
                
            };

            if(![0, 1, 2].includes(number)) return {
                msg: message.format('S_MUTE_TYPEINVALID'),
                error: true
            };

            await message.guild._updateSettings({
                [this.index]: {
                    ...message.guild._settings[this.index],
                    type: number
                }
            });
            return {
                msg: `${message.format('S_MUTE_TYPESUCCESS', { type: number })} ${message.format('S_MUTE_TYPESWITCH', { type: number }, true)}`,
                error: false
            };
        }

        let role = null,
            updatedPermissions = false,
            created = false,
            issues = [];
        if(parsedArguments.create || ['createmute', 'createmuted', 'createmutedrole', 'createmuterole'].includes(message._settingCaller)) {
            const missing = message.channel.permissionsFor(message.guild.me).missing('MANAGE_ROLES');
            if(missing.length > 0) return {
                msg: message.format('S_MUTE_ROLEMISSINGPERMISSION'),
                error: true
            };

            const foundRole = await message.guild.resolveRole(args.join(' '), true);
            if(foundRole) {
                const prompt = await message.prompt(message.format('S_MUTE_ROLEPROMPT', { name: foundRole.name, id: foundRole.id }), { emoji: 'loading' });
                const response = prompt.content.toLowerCase();
                const bool = this.client.resolver.resolveBoolean(response);
                if(bool === null) return { msg: message.format('S_MUTE_ROLEPROMPTERROR'), error: true };
                if(!bool) {
                    role = await this._createRole(message, args);
                    if(role.error) return role;
                    created = true;
                } else {
                    role = foundRole;
                }
            } else {
                role = await this._createRole(message, args);
                if(role.error) return role;
                created = true;
            }
            const channels = message.guild.channels.cache;
            for(const channel of channels.values()) {
                const configuration = channel.type === 'text'
                    ? { permissions: { SEND_MESSAGES: false, ADD_REACTIONS: false }, bitwise: 0x800 }
                    : { permissions: { CONNECT: false }, bitwise: 0x100000 };
                try {
                    console.log(channel.type)
                    if((channel.type === 'text' && !parsedArguments.voice) || (channel.type === 'voice' && !parsedArguments.text) || (!parsedArguments.text && !parsedArguments.voice)) {
                        if(channel.type === 'category') continue;
                        await channel.createOverwrite(role, configuration.permissions, super.reason(message.author));
                        for(const permission of channel.permissionOverwrites.values()) {
                            if(permission.type !== 'role') continue;
                            const r = await this.client.resolver.resolveRole(permission.id, true, message.guild);
                            if((permission.allow & configuration.bitwise) === configuration.bitwise) {
                                const info = {
                                    role: r.name,
                                    permission: channel.type === 'text' ? 'SEND_MESSAGES' : 'CONNECT',
                                    channel: channel.name,
                                    type: channel.type,
                                    emoji: channel.type === 'text' ? emojis['text-channel'] : emojis['voice-channel']
                                }
                                issues.push(info);
                            }
                        }
                    }
                } catch(err) {} //eslint-disable-line no-empty
            }
            updatedPermissions = true;
        } else {
            const search = args.join(' ');
            role = await this.client.resolver.resolveRole(search, true, message.guild);
        }

        if(!role) return {
            msg: message.format('S_MUTE_ROLEMISSING'),
            error: true
        };

        await message.guild._updateSettings({
            [this.index]: {
                ...message.guild._settings[this.index],
                role: role.id
            }
        });

        console.log(issues);

        return {
            msg: stripIndents`${message.format('S_MUTE_ROLESUCCESS', { role: role.name, type: created ? 'created' : 'set' })} ${updatedPermissions ? message.format('S_MUTE_GENERATEDPERMISSIONS') : message.format('S_MUTE_UNGENERATEDPERMISSIONS')}
                ${issues.length > 0 ? message.format('S_MUTE_ISSUES', { issues: issues.map(i=>`**\`${i.role}\`:** Has the \`${i.permission}\` permission in **${i.emoji}${i.channel}**.`).join('\n') }) : ''}`,
            error: false
        };

    }

    async _createRole(message, args) {
        let role = null;
        let name = args.join(' ') || 'Muted';
        if(name.length > maxCharacters) name = name.slice(0, maxCharacters);
        try {
            role = await message.guild.roles.create({
                data: {
                    name
                },
                reason: super.reason(message.author)
            });
        } catch(error) {
            return {
                msg: message.format('S_MUTE_ROLECREATEERROR'),
                error: true
            };
        }
        return role;
    }

    fields(guild) {
        return [
            {
                name: '》Muted Role',
                value: guild._settings[this.index]?.role ? `<@&${guild._settings[this.index].role}>` : '`N/A`',
                inline: true
            },
            {
                name: '》Mute Type',
                value: `\`${guild._settings[this.index]?.type || 0}\``,
                inline: true
            }
        ];
    }

}

module.exports = MuteSetting;