const ESMCommand = require("../esm_command");
module.exports = class ESMCommand_Server_Initialization extends ESMCommand {
    constructor(bot) {
        super(bot);
        this.permissions = {
            restricted: true
        };
    }

    async fromServer() {
        let retryCount = 0;

        // Update the DB
        let server = await this.db.serverInitialization(this.serverID, this.params);
        let community = await this.db.getCommunity(server.community_id);
        let guild = null;

        // Attempt to find the Discord Guild. This will fail if they kicked the bot (in which case, we will disconnect their connection)
        while (this.util.isEmpty(guild) && retryCount < 10) {
            guild = await this.ESMBot.getGuild(community.guild_id);
            if (!this.util.isEmpty(guild)) break;
            await this.util.sleep(5000);
            retryCount++;
        }

        // We failed after 10 tries (just in case Discord is having issues)
        if (this.util.isEmpty(guild)) {
            console.log("disconnecting server, no guild");
            return this.wss.disconnect(server.id);
        }

        let data = {
            function_name: "postServerInitialization",
            server_id: this.serverID,
            is_premium: true,
            territory_admins: []
        };

        // Compile the territory admins
        await this.compileTerritoryAdmins(community, guild, data);

        // Compile the Settings
        await this.compileSettings(server, data);

        // Compile the Rewards
        await this.compileRewards(server, data);

        // Let commands through
        this.wss.unlockServer(server.id);

        this.send({
            server_id: server.id,
            command: "post_initialization",
            parameters: data
        });

        this.ESMBot.logger.success(`'${server.id}' has successfully connected`);
    }

    async compileTerritoryAdmins(community, guild, data) {
        let fetch = async () => {
            let territory_admins = _.keys(community.territory_admins);

            let roles = await guild.roles.fetch();
            for (let role_arr of roles.cache) {
                let id = role_arr[0];
                let role = role_arr[1];
                if (!role.permissions.has("ADMINISTRATOR") && !(territory_admins.includes(id))) continue;

                let roleMembers = [];
                try {
                    roleMembers = role.members;
                } catch (error) {};


                for (let member_array of roleMembers) {
                    let id = member_array[0];
                    let steamUID = await this.db.getSteamUIDFromID(id);
                    if (this.util.isEmpty(steamUID)) continue;

                    data.territory_admins.push(steamUID);
                }
            }
        };

        // This is stupid
        await fetch();

        // Get the owner
        let ownerUID = await this.db.getSteamUIDFromID(guild.ownerID);
        if (!this.util.isEmpty(ownerUID)) {
            if (!data.territory_admins.includes(ownerUID)) {
                data.territory_admins.push(ownerUID);
            }
        }

        data.territory_admins = this.util.arrayToString(data.territory_admins);
    }

    async compileRewards(server, data) {
        data.reward_player_poptabs = server.rewards.player_poptabs;
        data.reward_locker_poptabs = server.rewards.locker_poptabs;
        data.reward_respect = server.rewards.respect;
        let items = [];
        _.each(server.rewards.items, (quantity, item) => {
            items.push([item, quantity]);
        });
        data.reward_items = this.util.arrayToString(items);
    }

    async compileSettings(server, data) {
        _.each(server.settings, (value, key) => {
            this.compileSetting(key, value, data);
        });

        // We use a boolean for Exile Threads
        data.request_thread_type = data.request_thread_type === "exile";

        // Correct the taxes/gambing (We take in a whole number, we need to convert it to a decimal)
        data.taxes_territory_payment = data.taxes_territory_payment / 100;
        data.taxes_territory_upgrade = data.taxes_territory_upgrade / 100;
        // data.gambling_payout = data.gambling_payout / 100;
        // data.gambling_win_chance = data.gambling_win_chance / 100;
    }

    compileSetting(name, setting, data, parentNames = []) {
        if (_.isPlainObject(setting)) {
            let names = _.clone(parentNames);
            names.push(name);
            _.each(setting, (value, key) => {
                this.compileSetting(key, value, data, names);
            });
        } else {
            if (_.isEmpty(parentNames)) {
                data[name] = setting;
            } else {
                data[`${parentNames.join("_")}_${name}`] = setting;
            }
        }
    }
};