"use strict";
/* TODO

join message should contain your current position in the queue, editing it to keep it current
*/
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.QueueCommands = exports.discordInit = void 0;
const discord_js_1 = require("discord.js");
const fs = __importStar(require("fs"));
const util_1 = require("./util");
//load queues from file
if (!fs.existsSync('./queues.json'))
    fs.writeFileSync('./queues.json', '{}');
const _QUEUE = fs.readFileSync('./queues.json').toString(), QUEUE = new Map();
try {
    let queueJson = JSON.parse(_QUEUE);
    for (let channelId of queueJson) {
        let { teamsize } = queueJson[channelId];
        if (teamsize)
            QUEUE.set(channelId, { teamsize, players: [] });
    }
}
catch (e) { }
function SaveQueue() {
    let queueJson = Object.fromEntries(QUEUE), queueFileJson = {};
    for (let channelId of QUEUE.keys())
        queueFileJson[channelId] = { teamsize: queueJson[channelId].teamsize };
    fs.writeFileSync('./queues.json', JSON.stringify(queueFileJson, null, 2));
}
async function checkQueue(channel) {
    let info = QUEUE.get(channel.id);
    if (!info)
        return;
    if (info.players.length > info.teamsize) {
        let team = info.players.splice(0, info.teamsize).map(m => m.toString());
        let embed = new discord_js_1.MessageEmbed()
            .setTitle('Team')
            .setDescription(team.join('\n'));
        await channel.send({ embeds: [embed] });
    }
}
var Queue;
(function (Queue) {
    function create(channelId, teamsize) {
        if (!QUEUE.has(channelId)) {
            QUEUE.set(channelId, { teamsize, players: [] });
            SaveQueue();
        }
    }
    Queue.create = create;
    function remove(channelId) {
        if (QUEUE.has(channelId)) {
            QUEUE.delete(channelId);
            SaveQueue();
        }
    }
    Queue.remove = remove;
    function addPlayer(channelId, member) {
        if (QUEUE.has(channelId)) {
            QUEUE.delete(channelId);
        }
    }
    Queue.addPlayer = addPlayer;
    function removePlayer(channelId, member) {
        if (QUEUE.has(channelId)) {
            QUEUE.delete(channelId);
        }
    }
    Queue.removePlayer = removePlayer;
})(Queue || (Queue = {}));
SaveQueue();
async function discordInit(client) {
    for (let channelId in QUEUE.keys()) {
        let info = QUEUE.get(channelId), channel = await client.channels.fetch(channelId);
        if (!info) { //no idea what could cause this but TS complains
            Queue.remove(channelId);
            continue;
        }
        if (!channel || !(channel instanceof discord_js_1.TextChannel)) {
            console.error(`Unable to find channel ${channelId} for teams of ${info?.teamsize}`);
            Queue.remove(channelId);
            continue;
        }
        channel.send('The bot has just restarted and anybody in the queues have been reset');
    }
}
exports.discordInit = discordInit;
var QueueCommands;
(function (QueueCommands) {
    /**
     * get the queueInfo of an interaction
     * @param interaction
     * @throws errorMessage class if it does not exist
     * @returns queue info
     */
    function getInfo(interaction) {
        let info = QUEUE.get(interaction.channelId);
        if (!info)
            throw (0, util_1.emsg)('There is not an active queue in this channel, type `/queue` to create one');
        return info;
    }
    /**
     * compiles all the get functions above
     * @param interaction
     * @throws if another get function throws
     * @returns object containing each
     */
    const getAll = (interaction) => ({
        member: (0, util_1.getMember)(interaction),
        channel: (0, util_1.getChannel)(interaction),
        info: getInfo(interaction)
    });
    /**
     * checks if the interaction data is already in the queue
     * @param interaction
     * @returns boolean
     */
    function queueContains(interaction) {
        let { member, info } = getAll(interaction);
        if (info.players.map(m => m.id).includes(member.id))
            return true;
        return false;
    }
    QueueCommands.queueContains = queueContains;
    /**
     * creates a queue from an interaction
     * @param interaction
     * @throws errorMessage class if it cannot be left
     */
    function queueCreate(interaction) {
        (0, util_1.memberIsModThrow)(interaction);
        let { channelId } = interaction, teamsize = interaction.options.getInteger('teamsize', true);
        if (QUEUE.has(channelId))
            throw (0, util_1.emsg)(`There is already an active queue in this channel for teams of ${QUEUE.get(channelId)?.teamsize}`);
        Queue.create(channelId, teamsize);
        interaction.reply(`A queue for teams of ${teamsize} has been started`);
    }
    QueueCommands.queueCreate = queueCreate;
    /**
     * opens a queue
     * @param interaction
     * @throws errorMessage class if it cannot be left
     */
    async function open(interaction) {
        queueCreate(interaction);
    }
    QueueCommands.open = open;
    /**
     * closes a queue
     * @param interaction
     * @throws errorMessage class if it cannot be joined
     */
    async function close(interaction) {
        (0, util_1.memberIsModThrow)(interaction);
        QUEUE.delete(interaction.channelId);
        await interaction.reply('Queue has been reset');
    }
    QueueCommands.close = close;
    /**
     * gives info about the queue
     * @param interaction
     * @throws errorMessage class if it cannot be left
     */
    async function queue(interaction) {
        let info = getInfo(interaction);
        let embed = new discord_js_1.MessageEmbed()
            .setTitle('Active Queue')
            .addField('Team Size', info.teamsize.toString(), true)
            .addField('Players Joined', info.players.length.toString(), true)
            .setFooter({ text: 'type /join' });
        await interaction.reply({ embeds: [embed], ephemeral: true });
    }
    QueueCommands.queue = queue;
    /**
     * joins a queue
     * @param interaction
     * @throws errorMessage class if it cannot be readied
     */
    async function join(interaction) {
        let { member, info, channel } = getAll(interaction);
        if (queueContains(interaction))
            throw (0, util_1.emsg)('You are already in the queue');
        info.players.push(member);
        QUEUE.set(interaction.channelId, info);
        await interaction.reply('Joined the queue');
        checkQueue(channel);
    }
    QueueCommands.join = join;
    /**
     * leaves a queue
     * @param interaction
     * @throws errorMessage class if it cannot be reset
     */
    async function leave(interaction) {
        let { member, info } = getAll(interaction);
        if (!queueContains(interaction))
            throw (0, util_1.emsg)('You aren\'t in the queue');
        info.players.splice(info.players.indexOf(member), 1);
        QUEUE.set(interaction.channelId, info);
        await interaction.reply('Left the queue');
    }
    QueueCommands.leave = leave;
})(QueueCommands = exports.QueueCommands || (exports.QueueCommands = {}));