const escapeRegex = require('escape-string-regexp');
const { Structures } = require('discord.js');

const Guild = Structures.extend('Guild', (Guild) => {

    class ExtendedGuild extends Guild {

        constructor(...args) {

            super(...args);

            this._settings = null; //internal cache of current guild's settings; should ALWAYS stay the same as database.
            this._permissions = null; //internal cache, should always match database.

        }

        //Fetch and cache settings
        async settings() {
            if(!this._settings) this._settings = this.client.transactionHandler.send({ provider: 'mongodb', request: { collection: 'guilds', type: 'findOne', query: { guildId: this.id } } });
            if(this._settings instanceof Promise) this._settings = await this._settings || null;
            if(!this._settings) this._settings = { guildId: this.id, ...this.client.defaultConfig };
            return this._settings;
        }

        //Fetch and cache perms
        async permissions() {
            if(!this._permissions) this._permissions = this.client.transactionHandler.send({ provider: 'mongodb', request: { collection: 'permissions', type: 'findOne', query: { guildId: this.id } } });
            if(this._permissions instanceof Promise) this._permissions = await this._permissions || null;
            if(!this._permissions) this._permissions = { guildId: this.id };
            return this._permissions;
        }

        /* Settings Wrapper */

        async _deleteSettings() { //Delete whole entry - remove
            try {
                await this.client.transactionHandler.send({
                    provider: 'mongodb',
                    request: {
                        type: 'remove',
                        collection: 'guilds',
                        query: {
                            guildId: this.id
                        }
                    }
                });
                this._settings = this.client.defaultConfig;
                this._storageLog(`Database Delete (guild:${this.id}).`);
            } catch(error) {
                this._storageError(error);
            }
            return true;
        }

        async _updateSettings(data) { //Update property (upsert true) - updateOne
            try {
                await this.client.transactionHandler.send({
                    provider: 'mongodb',
                    request: {
                        type: 'updateOne',
                        collection: 'guilds',
                        query: {
                            guildId: this.id
                        },
                        data
                    }
                });
                this._settings = { 
                    ...this._settings,
                    ...data
                };
                this._storageLog(`Database Update (guild:${this.id}).`);
            } catch(error) {
                this._storageError(error);
            }
            return true;
        }

        async _removeSettings(value) { //Remove property
            if(this.client.defaultConfig[value]) {
                await this._updateSettings(this.client.defaultConfig[value]);
                return undefined;
            }
            try {
                await this.client.transactionHandler.send({
                    provider: 'mongodb',
                    request: {
                        type: 'removeProperty',
                        collection: 'guilds',
                        query: {
                            guildId: this.id
                        },
                        data: [
                            value
                        ]
                    }
                });
                this._storageLog(`Database Remove (guild:${this.id}).`);
                delete this._settings[value];
            } catch(error) {
                this._storageError(error);
            }
            return true;
        }  

        /* Language Formatting */

        format(key, parameters = {}) {

            const language = this._settings.locale || 'en_us'; //this._settings.language or something idk

            let value = this.client.localeLoader.languages[language][key];
            for(const [param, val] of Object.entries(parameters)) {
                value = value.replace(new RegExp(`{${escapeRegex(param.toLowerCase())}}`, 'giu'), val);
            }
            return value;
            
        }

        /* Resolver Shortcuts */

        async resolveMembers(members, strict = false) {

            return this.client.resolver.resolveMembers(members, this, strict);

        }

        async resolveMember(member, strict) {

            return await this.client.resolver.resolveMembers(member, this, strict);

        }

        resolveChannels(channels, strict = false) {

            return this.client.resolver.resolveChannels(channels, this, strict);

        }

        resolveChannel(channel, strict) {

            return this.client.resolver.resolveChannel(channel, this, strict);

        }

        async resolveRoles(roles, strict = false) {

            return await this.client.resolver.resolveRoles(roles, this, strict);

        }

        async resolveRole(role, strict) {
            
            return await this.client.resolver.resolveRole(role, this, strict);

        }


        /* Logging */

        _storageLog(log) {
            this.client.logger.debug(log);
        }

        _storageError(error) {
            this.client.logger.error(`Database Error (guild:${this.id}) : \n${error.stack || error}`);
        }

        get prefix() {
            return this._settings.prefix;
        }

    }

    return ExtendedGuild;

});

module.exports = Guild;