/* eslint-disable indent */
const { Infraction } = require('../interfaces/');

class MuteInfraction extends Infraction {

    static type = 'MUTE';

    constructor(client, opts = {}) {
        
        super(client, {
            targetType: 'USER',
            type: opts.type,
            message: opts.message,
            executor: opts.executor.user,
            target: opts.target.user,
            reason: opts.reason,
            guild: opts.guild,
            channel: opts.channel,
            arguments: opts.arguments,
            silent: opts.silent,
            duration: opts.duration,
            points: opts.points,
            expiration: opts.expiration,
            data: opts.data,
            hyperlink: opts.hyperlink
        });

        this.client = client;
        this.member = opts.target;

    }

    async execute() {
        
        const setting = this.guild._settings.mute;

        let role = null;
        if(setting.type !== 2) {
            role = await this.client.resolver.resolveRole(setting.role, true, this.guild);
        }

        let removed = [];
        switch(setting.type) {
            case 0:
                try {
                    this.member.roles.add(role, this._reason);
                } catch(e) {
                    return this._fail('C_MUTE_1FAIL');
                }
                break;
            case 1:
                removed = this.member.roles.cache.filter((r) => !r.managed && r.comparePositionTo(this.guild.me.roles.highest) < 0 && r.id !== this.guild.id);
                try {
                    this.member.roles.set([
                        ...this.member.roles.cache.filter((r) => r.managed || r.comparePositionTo(this.guild.me.roles.highest) > 0 || r.id === this.guild.id).array(),
                        role
                    ], this._reason);
                } catch(error) {
                    this.client.logger.error(`Mute infraction failed to calculate removeable roles, might want to check this out.\n${error.stack || error}`);
                    return this._fail('C_MUTE_2FAIL');
                }
                break;
            case 2:
                removed = this.member.roles.cache.filter((r) => !r.managed && r.comparePositionTo(this.guild.me.roles.highest) < 0 && r.id !== this.guild.id);
                try {
                    this.member.roles.set(this.member.roles.cache.filter((r) => r.managed || r.comparePositionTo(this.guild.me.roles.highest) > 0 || r.id === this.guild.id), this._reason);
                } catch(error) {
                    this.client.logger.error(`Mute infraction failed to calculate removeable roles, might want to check this out.\n${error.stack || error}`);
                    return this._fail('C_MUTE_3FAIL');
                }
                break;
        }

        this.data = {
            removedRoles: removed.map((r) => r.id),
            muteType: setting.type,
            muteRole: role ? role.id : null
        }; //Info will be saved in database and into the callback when resolved.

        const callback = this.client.moderationManager.callbacks.filter((c) => c.infraction.type === 'MUTE' 
            && c.infraction.target === this.target.id).first();
        
        if(callback) {
            this.data.removedRoles = [...new Set([...this.data.removedRoles, ...callback.infraction.data.removedRoles])];
            this.client.moderationManager._removeExpiration(callback);
        }

        // if(callbacks.size > 0) callbacks.map((c) => this.client.moderationManager._removeExpiration(c));

        await this.handle();
        return this._succeed();

    }

    async verify() {

        if(this.guild._settings.mute.type !== 2) {
            if(!this.guild._settings.mute.role) return this._fail('C_MUTE_NOMUTEROLE', true);

            const role = await this.client.resolver.resolveRole(this.guild._settings.mute.role, true, this.guild);
            if(!role) {
                this.guild._updateSettings({
                    mute: { 
                        ...this.guild._settings.mute,
                        role: null
                    }
                });
                return this._fail('C_MUTE_INVALIDMUTEROLE', true);
            }
        }

        return super._verify();
        
    }

}

module.exports = MuteInfraction;