galactic-bot/structure/client/components/observers/CommandHandler.js

const { stripIndents } = require('common-tags');
const escapeRegex = require('escape-string-regexp');

const { Observer } = require('../../../interfaces/');

class CommandHandler extends Observer {

    constructor(client) {

        super(client, {
            name: 'commandHandler',
            priority: 5,
            guarded: true
        });

        this.client = client;

        this.hooks = [
            ['message', this.handleMessage.bind(this)]
        ];


    }

    async handleMessage(message) {

        //const time1 =  new Date().getTime();

        if(!this.client._built
            || message.webhookID
            || message.author.bot
            || (message.guild && !message.guild.available)) return undefined;

        if(message.guild && !message.member) {
            await message.guild.members.fetch(message.author.id);
        }

        const content = message.content;
        const args = content.split(' ');
        const { command, newArgs } = await this._getCommand(message, args);
        if(!command) return undefined;

        message.command = command;

        await this.handleCommand(message, newArgs);

        //const time2 =  new Date().getTime();
        //console.log(`${time2-time1}ms`);

    }

    async _getCommand(message, [arg1, arg2, ...args]) {

        const prefix = this.client._options.bot.prefix; //Change this for guild prefix settings.
        let command = null;
        let remains = [];

        if(arg1 && arg1.startsWith(prefix)) {
            const commandName = arg1.slice(1);
            command = await this._matchCommand(message, commandName);
            remains = [arg2, ...args];
        } else if(arg1 && arg2 && arg1.startsWith('<@')){
            const pattern = new RegExp(`^(<@!?${this.client.user.id}>)`, 'i');
            if(arg2 && pattern.test(arg1)) {
                command = await this._matchCommand(message, arg2);
            }
            remains = args
        }

        return { command, newArgs: remains };

    }


    async _matchCommand(message, commandName) {

        const command = this.client.resolver.components(commandName, 'command', true)[0];
        if(!command) return null;
        
        //Eventually search for custom commands here.

        return command;

    }

    /* Command Handling */

    async handleCommand(message, args) {
        
        const inhibitor = await this._handleInhibitors(message);
        if(inhibitor.error) {
            message.channel.send(`${inhibitor.resolveable} failed to pass.`);
            return undefined;
        }

        const parsedArguments = await this._parseArguments(message, args);



    }

    async _handleInhibitors(message) {

        const inhibitors = this.client.registry.components.filter(c=>c.type === 'inhibitor' && !c.disabled);
        if(inhibitors.size === 0) return { error: false };

        const promises = [];
        for(const inhibitor of inhibitors.values()) {
            if(inhibitor.guild && !message.guild) continue;
            promises.push((async () => {
                let inhibited = inhibitor.execute(message);
                if(inhibited instanceof Promise) inhibited = await inhibited;
                return inhibited;
            })());
        }

        const reasons = (await Promise.all(promises)).filter(p=>p.error);
        if(reasons.length === 0) return { error: false };
        
        reasons.sort((a, b) => b.inhibitor.priority - a.inhibitor.priority);
        return reasons[0];

    }

    async _parseArguments(message, args = []) {

        const command = message.command;
        let parsedArguments = [];
        const parsedFlags = {};

        const { shortFlags, longFlags, keys } = await this._createFlags(command.arguments);
        const regex = new RegExp(`([0-9]*)(${Object.keys(longFlags).map(k=>escapeRegex(k)).join('|')})([0-9]*)`, 'i');
        console.log(regex);
        
        let currentArgument = null;
        let params = [];
        
        for(let i=0; i<args.length; i++) {
            const word = args[i];

            if(!word) continue;
            const [one,two,...chars] = word.split('');
            if(one === '-' && two !== '-') {
                const name = [ two, ...chars ].join('');
                if(!keys.includes(name)) continue;
                currentArgument = shortFlags[name];
                if(currentArgument.required && !args[i+1]) {
                    console.error(`Argument ${currentArgument.name} is required and was not provided.`);
                    return undefined; 
                }
                continue;
            } else if((one === '-' && two === '-') || one === '—') { //Handling for "long dash" on mobile phones x_x
                const name = one === '—' 
                    ? [ two, ...chars ].join('').toLowerCase()
                    : chars.join('').toLowerCase(); //can convert to lowercase now that shortFlags are out of the way.
                if(!keys.includes(name)) continue;
                currentArgument = longFlags[name];
                if(currentArgument.required && !args[i+1]) {
                    console.error(`Argument ${currentArgument.name} is required and was not provided.`);
                    return undefined; 
                }
                continue;
            } else {
                let match = regex.exec(word);
                if(match && match[2]) {
                    currentArgument = longFlags[match[2]];
                    if(params.length > 0 && ['INTEGER', 'FLOAT'].includes(currentArgument.type)) { //15 pts
                        console.log("asgsaiughasiguassag")
                        const lastItem = params[params.length-1];
                        const beforeError = await this._handleTypeParsing(currentArgument, lastItem);
                        if(beforeError) {
                            continue;
                        } else {
                            params.pop();
                            currentArgument.value = lastItem;
                            parsedArguments.push(currentArgument);
                            currentArgument = null;
                            continue;
                        }
                    }
                    const value = match[1] || match[3];
                    const error = await this._handleTypeParsing(currentArgument, value);
                    if(value) {
                        if(error) {
                            if(currentArgument.required) {
                                console.error(`Argument ${currentArgument.name} is required and failed to meet requirements.`);
                                return undefined; 
                            } else {
                                parsedArguments.push(currentArgument);
                                currentArgument = null;
                                continue;
                            }
                        } else {
                          currentArgument.value = value;
                          parsedArguments.push(currentArgument);
                          currentArgument = null;
                          continue;  
                        }
                    } else {
                        continue;
                    }
                } else {
                    if(currentArgument) {
                        const error = await this._handleTypeParsing(currentArgument, word);
                        if(error) {
                            if(currentArgument.default) {
                                params.push(word);
                                currentArgument.value = currentArgument.default;
                                parsedArguments.push(currentArgument);
                                currentArgument = null;
                                continue;
                            }
                            if(currentArgument.required) {
                                if(currentArgument.infinite) {
                                    if(currentArgument.value.length === 0) {
                                        console.error(`1 Argument ${currentArgument.name} is required and failed to meet requirements.`);
                                        return undefined; 
                                    } else {
                                        parsedArguments.push(currentArgument);
                                        currentArgument = null;
                                        params.push(word);
                                        continue;
                                    }
                                } else {
                                    console.error(`2 Argument ${currentArgument.name} is required and failed to meet requirements.`);
                                    return undefined; 
                                }
                            } else {
                                currentArgument = null;
                                params.push(word);
                                continue;
                            }
                        } else {
                            if(currentArgument.infinite) continue;
                            parsedArguments.push(currentArgument);
                            currentArgument = null;
                            continue;
                        }
                    } else {
                        params.push(word);
                        continue;
                    }
                }
            }

        }


        await message.channel.send(stripIndents`**arguments:** ${parsedArguments.map(a=>`${a.name}: ${a.value}`).join(' | ')}
            **words:** ${params.join(', ')}`);


    }

    async _handleTypeParsing(argument, string) {

        const parse = async (argument, string) => {

            const { error, value } = await this.constructor.parseType(argument.type, string); //Cannot access static functions through "this".
            if(error) return { error: true };
    
            if(['INTEGER', 'FLOAT'].includes(argument.type)) {
                const { min, max } = argument;
                if(value > max && max !== null) {
                    return { error: true };
                }
                if(value < min && min !== null) {
                    return { error: true };
                }
            }

            return { error: false, value };

        }

        const { error, value } = await parse(argument, string);

        if(!error) {
            argument.infinite 
                ? argument.value.push(value)
                : argument.value = value;
        }

        return error;

    }

    async _createFlags(args) {

        let shortFlags = {};
        let longFlags = {};
        let keys = [];

        for(const arg of args) {

            let letters = [];
            let names = [ arg.name, ...arg.aliases ];
            keys = [...keys, ...names];

            for(const name of names) {
                longFlags[name] = arg;

                if(!arg.types.includes('FLAG')) continue;

                let letter = name.slice(0, 1);
                if(letters.includes(letter)) continue;
                if(keys.includes(letter)) letter = letter.toUpperCase();
                if(keys.includes(letter)) break;

                keys.push(letter);
                letters.push(letter);

                shortFlags[letter] = arg;
            }
    
        }

        return { shortFlags, longFlags, keys };

    }

    static async parseType(type, str) { //this is in the class for a reason, will soon reference to a user resolver etc.

        //INTEGER AND FLOAT ARE SAME FUNCTION

        const types = {
            STRING: (str) => {
                return { error: false, value: `${str}` };
            },
            INTEGER: (str) => {
                const int = parseInt(str);
                if(Number.isNaN(int)) return { error: true }
                return { error: false, value: int };
            },
            FLOAT: (str) => {
                const float = parseInt(str);
                if(Number.isNaN(float)) return { error: true }
                return { error: false, value: float };
            },
            BOOLEAN: (str) => {
                const truthy = ['yes', 'y', 'true', 't', 'on', 'enable'];
                const falsey = ['no', 'n', 'false', 'f', 'off', 'disable'];
                if(typeof str === 'boolean') return { error: false, value: str };
    
                if(typeof str === 'string') str = str.toLowerCase();
                if(truthy.includes(str)) return { error: false, value: true };
                if(falsey.includes(str)) return { error: false, value: false };
                return { error: true };
            }
        }


        return await types[type](str);

    }


}

module.exports = CommandHandler;