const { stripIndents } = require('common-tags');
// eslint-disable-next-line no-unused-vars
const { Message } = require('discord.js');
const { Console } = require('winston/lib/winston/transports');

const { Collection, Util, Emojis, Constants } = require('../../util/');
const { User, GuildMember } = require('../extensions/'); 
const { Warn, Unmute, Mute, Kick, Softban, Unban, Ban } = require('./infractions/');
// eslint-disable-next-line no-unused-vars
const Infraction = require('./interfaces/Infraction');

const Constant = {
    MaxTargets: 10, //10+(10*premium-tier), theoretical max = 40
    Infractions: {
        WARN: Warn,
        UNMUTE: Unmute,
        MUTE: Mute,
        KICK: Kick,
        SOFTBAN: Softban,
        UNBAN: Unban,
        BAN: Ban
    },
    Opposites: {
        MUTE: "UNMUTE",
        BAN: "UNBAN"
    },
    Hierarchy: {
        WARN: 0,
        MUTE: 1,
        KICK: 2,
        SOFTBAN: 3,
        BAN: 4
    }
};

class ModerationManager {

    constructor(client) {

        this.client = client;
        this.callbacks = new Collection();

        this._permissionCheck = null;
        
    }

    async initialize() {

        //TODO: Load infractions for non-cached guilds...
        this.client.storageManager.mongodb.infractions.find({
            duration: { $gt: 0 },
            guild: { $in: this.client.guilds.cache.keyArray() },
            _callbacked: false
        }).then((results) => {
            this.client.logger.info(`Filtering ${results.length} infractions for callback.`);
            this._handleExpirations(results);
        });

    }

    /**
     *
     *
     * @param {Infraction} Infraction
     * @param {Message} message
     * @param {object} { targets, reason, duration, data }
     * @return {object|Message} The successfully moderated targets of the response message for failure
     * @memberof ModerationManager
     */
    async handleInfraction(Infraction, message, info) {

        const { targets } = info;

        const maxTargets = Constant.MaxTargets + message.guild.premium*Constant.MaxTargets;
        if(targets.length > maxTargets) {
            return message.respond(stripIndents`${message.format('MODERATIONMANAGER_INFRACTION_MAXTARGETS', { maxTargets, type: Infraction.targetType })}
                ${maxTargets < 40 ? message.format('MODERATIONMANAGER_INFRACTION_MAXTARGETSALT') : ''}`, { emoji: 'failure' });
        }

        const silent = Boolean(message.guild._settings.silent || message.arguments.silent);
        const force = message.arguments?.force?.value || false;

        const original = null;
        const responses = [];
        for (const target of targets) {
            const response = await this._handleTarget(Infraction, target, {
                guild: message.guild,
                channel: message.channel,
                executor: message.member,
                arguments: message.arguments,
                reason: info.reason,
                duration: info.duration,
                data: info.data,
                force
            });
            responses.push({
                escalation: Infraction.type !== response.infraction.type,
                ...response
            });
        }

        const success = Boolean(responses.some((r) => !r.error));
        const succeeded = responses.filter((r) => !r.error);
        const failed = responses.filter((r) => r.error);

        const fatals = failed.filter((f) => f.fatal);
        if(fatals.length > 0) {
            const [ error ] = fatals;
            return message.respond(message.format(error.reason), { emoji: 'failure' });
        }

        const successes = {};
        const fails = {};
        for(const response of responses) {
            const { type, target } = response.infraction;
            if(!response.error) {
                if(!silent) {
                    if(successes[type]) {
                        successes[type].targets.push(target.display);
                    } else {
                        successes[type] = {
                            targets: [target.display],
                            infraction: response.infraction,
                            escalation: response.escalation
                        };
                    }
                }
            } else {
                if(fails[type]) {
                    fails[type].targets.push(target.display);
                } else {
                    fails[type] = {
                        targets: [target.display],
                        infraction: response.infraction,
                        reason: response.reason
                    };
                }
            }
        }

        const succeededTargets = succeeded.map((s) => s.infraction.target);
        const actions = await this._handleArguments(message, succeededTargets); //eslint-disable-line no-unused-vars

        let string = "";
        for(const [ , data ] of Object.entries(successes)) {
            if(silent) continue;
            const { dictionary, targetType } = data.infraction;
            const reason = data.escalation ? message.format('INFRACTION_ESCALATIONREASON') : Util.escapeMarkdown(data.infraction.reason);
            const str = `${Emojis.success} ${message.format('INFRACTION_SUCCESS', {
                infraction: dictionary.past,
                targetType: `${targetType.toLowerCase()}${data.targets.length === 1 ? '' : 's'}`,
                target: data.targets.map((t) => `**${Util.escapeMarkdown(t)}**`).join(' '),
                text: !data.escalation ? ` ${reason.length > 120 ? `for: \`${reason.substring(0, 117)}...\`` : `for: \`${reason}\``}` : ` because \`${reason}\``
            })}`;
            data.escalation ? string += str : string = `${str}\n${string}`; //eslint-disable-line 
        }

        for(const [ , data ] of Object.entries(fails)) {
            const { dictionary, targetType } = data.infraction;
            const str = `${Emojis.failure} ${message.format('INFRACTION_FAIL', {
                infraction: dictionary.present,
                targetType: `${targetType.toLowerCase()}${data.targets.length === 1 ? '' : 's'}`,
                target: data.targets.map((t) => `**${Util.escapeMarkdown(t)}**`).join(' '),
                reason: message.format(data.reason)
            })}`;
            (!data.escalation && !success) //eslint-disable-line
                ? string = `${str}\n${string}`
                : string += str;
        }

        if(success && silent) { //Delete message if silent.
            try {
                await message.delete();
            } catch(e) {} //eslint-disable-line no-empty
        }

        if(string) message.respond(string);
        return succeeded;

    }

    async _handleTarget(Infraction, target, info, automod = false) {
        const { guild, reason, force } = info;
        const { autoModeration, moderationPoints, silent } = guild._settings;
        const { type } = Infraction;

        let points = 0,
            expiration = 0;
        if(moderationPoints.enabled) {
            points = info.arguments?.points?.value || moderationPoints.points[type];
            expiration = info.arguments?.expiration?.value || moderationPoints.expirations[type];
            for(const [ phrase, amount ] of Object.entries(moderationPoints.associations)) {
                if(reason.toLowerCase().includes(phrase)) points = amount;
            }
        }

        const verify = async (infraction, escalated = false) => {
    
            let verification = infraction.verify(info.executor, target, info.channel);
            if(verification instanceof Promise) verification = await verification;
    
            if(verification.error) return {
                error: true,
                response: verification
            };
    
            if(infraction.targetType === 'USER') {
                const userTarget = target instanceof User ? target : target.user;
                const oldPoints = await userTarget.totalPoints(guild);

                const newPoints = oldPoints + infraction.points;
                if(autoModeration.enabled && points > 0 && !force && !automod && !escalated) {
                    let result = null;
                    for(let [ threshold, action ] of Object.entries(autoModeration.thresholds)) { //eslint-disable-line prefer-const
                        threshold = parseInt(threshold);
                        if(oldPoints >= threshold) {
                            if(autoModeration.usePrevious) {
                                result = {
                                    threshold,
                                    ...action
                                };
                            }
                            continue;
                        }
                        if(newPoints >= threshold) {
                            result = {
                                threshold,
                                ...action
                            };
                        }
                    }
                    if(result) {
                        return {
                            error: false,
                            escalation: result,
                            infraction
                        };
                    }
                }
            }

            return { error: false, infraction };

        };

        const infraction = new Infraction(this.client, {
            target,
            type,
            guild: info.guild,
            channel: info.channel,
            executor: info.executor,
            reason: info.reason,
            duration: info.duration,
            data: info.data,
            points,
            expiration,
            silent: silent || info.arguments.silent
        });

        let response = await verify(infraction);
        
        if(response.escalation) {
            if(Constant.Hierarchy[infraction.type] <= Constant.Hierarchy[response.escalation.type]) {
                const escalationClass = Constant.Infractions[response.escalation.type];
                const escalationInfraction = new escalationClass(this.client, {
                    target,
                    type: escalationClass.type,
                    guild: info.guild,
                    channel: info.channel,
                    executor: info.executor,
                    reason: stripIndents`${reason}
                        *${guild.format('INFRACTION_AUTOMODESCALATION')}*`,
                    duration: info.duration,
                    data: info.data,
                    points,
                    expiration,
                    silent: silent || info.arguments.silent
                });
                response = await verify(escalationInfraction, true);
            }
        }

        if(response.error) return response.response;

        response.infraction.totalPoints = await response.infraction.target.totalPoints(guild, { points, expiration, timestamp: response.infraction.timestamp });
        return response.infraction.execute();

    }

    // Similar to handleInfraction, but meant for automod, deals with only 1 target
    async autoModerate({ guild, action, message, reason, silent, data }) {

        const { autoModeration, moderationPoints } = guild._settings;

        let points = 0,
            expiration = 0,
            response = null;
        const { force } = action;
        const Infraction = Constant.Infractions[action.type];
        
        if (moderationPoints.enabled) {
            points = action.points || moderationPoints.points[action.type];
            expiration = action.expiration || moderationPoints.expirations[action.type];
        }

        const infractionData = {
            executor: guild.me,
            guild,
            channel: message.channel,
            message,
            target: message.member,
            reason,
            duration: action.duration,
            silent,
            data,
            points,
            expiration
        };

        const infraction = new Infraction(this.client, infractionData);

        const verification = await infraction.verify();
        if (verification.error) {
            this.client.logger.debug(`Automod infraction failed verification.\n${infraction.type}:\n${JSON.stringify(infractionData)}`);
            return; // Possibly add a automod error log channel setting and do something here -- skip for now
        }

        if (autoModeration.enabled && points && !force) {

            const userTarget = message.author;
            const oldPoints = await userTarget.totalPoints(guild);
            const newPoints = oldPoints + points;

            let result = null;
            // eslint-disable-next-line prefer-const
            for (let [threshold, action] of Object.entries(autoModeration.thresholds)) {
                threshold = parseInt(threshold);
                if (oldPoints >= threshold) continue;
                if (newPoints >= threshold) result = {
                    threshold,
                    ...action
                };
            }

            if (result && Constant.Hierarchy[infraction.type] <= Constant.Hierarchy[result.type]) {
                infractionData.duration = result.length;
                infractionData.reason += `\n*${message.format('INFRACTION_AUTOMODESCALATION')}*`;
                const escalation = new Constant.Infractions[result.type](this.client, infractionData);

                const verification = await escalation.verify();
                if (verification.error) {
                    this.client.logger.debug(`Automod escalated infraction failed verification.\n${infraction.type}:\n${JSON.stringify(infractionData)}`);
                    return; // Possibly add a automod error log channel setting and do something here -- skip for now
                }
                //: moderationPoints.expirations[escalation.type]
                escalation.totalPoints = await userTarget.totalPoints(guild, { points, expiration, timestamp: infraction.timestamp });

                response = await escalation.execute();

            } else {
                infraction.totalPoints = await userTarget.totalPoints(guild, { points, expiration, timestamp: infraction.timestamp });
            }

        }
        
        if (!response) response = await infraction.execute();

        if (response.error) this.client.logger.debug(`Automod infraction execution failed:\n${JSON.stringify(response)}`);
        // TODO:
        // Figure out what we want to do with these errors if anything apart from potentially log them
        // Most errors here would probably be permission issues/edge cases caused by server configuration/discord perms

    }
    
    async _handleArguments(message, targets) {
        
        const actions = {
            prune: async (message, argument, targets) => {
                const users = targets.map((t) => t.id);
                let messages = await message.channel.messages.fetch({
                    limit: argument.value
                });
                messages = messages.filter((m) => {
                    return users.includes(m.author.id) && m.deletable;
                });
                try {
                    await message.channel.bulkDelete(messages, true);
                } catch(err) {} //eslint-disable-line no-empty
                return messages.size;
            }
        };

        const responses = {};
        for(const arg of Object.values(message.arguments)) {
            // console.log(arg, targets);
            if(actions[arg.name]) {
                let action = actions[arg.name](message, arg, targets);
                if(action instanceof Promise) action = await action;
                responses[arg.name] = action;
            }
        }

        return responses;

    }

    async _handleExpirations(infractions = []) {

        const currentDate = Date.now();

        const resolve = async (i) => {
            this.client.logger.debug("Resolving infraction");
            const undoClass = Constant.Infractions[Constant.Opposites[i.type]];
            if(!undoClass) return false;

            const guild = this.client.guilds.resolve(i.guild);
            await guild.settings(); //just incase

            let target = null;
            if(i.targetType === 'USER') {
                target = await guild.members.resolve(i.target);
                if(!target) {
                    try {
                        target = await guild.members.fetch(i.target);
                    } catch(e) {} //eslint-disable-line no-empty
                    if(!target && i.type === 'BAN') {
                        try {
                            target = await this.client.users.fetch(i.target);
                        } catch(e) {} //eslint-disable-line no-empty
                    }
                }
            } else if(i.targetType === 'CHANNEL') {
                target = guild.channels.resolve(i.target);
            }
            
            if(!target) {
                this.client.logger.debug(`User left the guild or channel was deleted? Unable to resolve target.\n${i}`);
                return false;
            }

            const executor = guild.members.resolve(i.executor) || guild.me;

            await new undoClass(this.client, {
                reason: `AUTO-${Constant.Opposites[i.type]} from Case ${i.case}`,
                channel: guild.channels.resolve(i.channel),
                hyperlink: i.modLogMessage && i.modLogChannel ? `https://discord.com/channels/${i.guild}/${i.modLogChannel}/${i.modLogMessage}` : null,
                data: i.data,
                guild,
                target,
                executor
            }).execute();
            
            //TODO: Log this, should never error... hopefully.
            await this.client.storageManager.mongodb.infractions.updateOne(
                { _id: i._id },
                { _callbacked: true }
            ).catch((e) => {}); //eslint-disable-line no-empty, no-unused-vars, no-empty-function

            return true;

        };
        
        for(const infraction of infractions) {
            const expiration = infraction.timestamp + infraction.duration*1000;
            if(expiration-currentDate <= 0) {
                await resolve(infraction); 
                continue;
            }

            this.client.logger.debug(`Going to resolve infraction in: ${expiration-currentDate}`);

            this.callbacks.set(infraction.id, {
                timeout: setTimeout(async () => {
                    await resolve(infraction);
                }, expiration-currentDate),
                infraction
            });

        }

    }

    async _removeExpiration(expiration) {
        this.client.logger.debug(`Expired infraction ${expiration.infraction.type} for user ${expiration.infraction.target}.`);
        await this.client.storageManager.mongodb.infractions.updateOne(
            { id: expiration.infraction.id },
            { _callbacked: true }
        ).catch((e) => {}); //eslint-disable-line no-empty, no-unused-vars, no-empty-function
        clearTimeout(expiration.timeout); //just incase node.js is doing some bullshit
        this.callbacks.delete(expiration.infraction.id);
    }
    
}

module.exports = ModerationManager;