"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.queueContains = exports.discordInit = exports.queueRemove = exports.queueCreate = void 0;
const discord_js_1 = require("discord.js");
const fs = __importStar(require("fs"));
const util_1 = require("./util");
const Lang = __importStar(require("./lang"));
//load queues from file
if (!fs.existsSync('./queues.json'))
    fs.writeFileSync('./queues.json', '{}');
const _QUEUE = fs.readFileSync('./queues.json').toString(), QUEUE = new Map();
try {
    const queueJson = JSON.parse(_QUEUE);
    for (const channelId in queueJson) {
        const { teamsize } = queueJson[channelId];
        if (teamsize !== 0)
            QUEUE.set(channelId, { teamsize, players: [] });
    }
}
catch (e) {
    //do nothing
}
function SaveQueue() {
    const queueJson = Object.fromEntries(QUEUE), queueFileJson = {};
    for (const channelId of QUEUE.keys())
        queueFileJson[channelId] = { teamsize: queueJson[channelId].teamsize };
    fs.writeFileSync('./queues.json', JSON.stringify(queueFileJson, null, 2));
}
async function checkQueue(channel) {
    const info = QUEUE.get(channel.id);
    if (!info)
        return;
    if (info.players.length >= info.teamsize) {
        const team = info.players.splice(0, info.teamsize).map(m => m.toString());
        //TODO add embeds to lang.ts
        const embed = new discord_js_1.MessageEmbed()
            .setTitle('Team')
            .setDescription(team.join('\n'));
        await channel.send({ embeds: [embed] });
    }
}
function queueCreate(channelId, teamsize) {
    if (!QUEUE.has(channelId)) {
        QUEUE.set(channelId, { teamsize, players: [] });
        SaveQueue();
    }
}
exports.queueCreate = queueCreate;
function queueRemove(channelId) {
    if (QUEUE.has(channelId)) {
        QUEUE.delete(channelId);
        SaveQueue();
    }
}
exports.queueRemove = queueRemove;
SaveQueue();
async function discordInit(client) {
    for (const channelId of QUEUE.keys()) {
        const info = QUEUE.get(channelId), channel = await client.channels.fetch(channelId);
        if (!info) { //no idea what could cause this but TS complains
            queueRemove(channelId);
            continue;
        }
        if (!channel || !(channel instanceof discord_js_1.TextChannel)) {
            console.error(Lang.get('error.discord.noChannel'), {
                channelId,
                teamsize: info.teamsize
            });
            queueRemove(channelId);
            continue;
        }
        channel.send(Lang.get('discord.botRestart'));
    }
}
exports.discordInit = discordInit;
/**
 * get the queueInfo of an interaction
 * @param interaction
 * @throws errorMessage class if it does not exist
 * @returns queue info
 */
function getInfo(interaction) {
    const info = QUEUE.get(interaction.channelId);
    if (!info)
        throw (0, util_1.emsg)('discord.noQueue');
    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) {
    const { member, info } = getAll(interaction);
    if (info.players.map(m => m.id).includes(member.id))
        return true;
    return false;
}
exports.queueContains = queueContains;
/**
 * opens a queue
 * @param interaction
 * @throws errorMessage class if it cannot be left
 */
function open(interaction) {
    (0, util_1.memberIsModThrow)(interaction);
    const { channelId } = interaction, teamsize = interaction.options.getInteger('teamsize', true);
    const existing = QUEUE.get(channelId);
    if (existing)
        throw (0, util_1.emsg)(Lang.get('error.discord.noCreate', {
            teamsize: existing.teamsize.toString()
        }));
    queueCreate(channelId, teamsize);
    interaction.reply(Lang.get('discord.create', {
        teamsize: teamsize.toString()
    }));
}
/**
 * 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(Lang.get('discord.close'));
}
/**
 * gives info about the queue
 * @param interaction
 * @throws errorMessage class if it cannot be left
 */
async function queue(interaction) {
    const info = getInfo(interaction);
    const 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' }); //TODO
    await interaction.reply({ embeds: [embed], ephemeral: true });
}
/**
 * joins a queue
 * @param interaction
 * @throws errorMessage class if it cannot be readied
 */
async function join(interaction) {
    const { member, info, channel } = getAll(interaction);
    if (queueContains(interaction))
        throw (0, util_1.emsg)('discord.inQueue');
    info.players.push(member);
    QUEUE.set(interaction.channelId, info);
    await interaction.reply(Lang.get('discord.join'));
    checkQueue(channel);
}
/**
 * leaves a queue
 * @param interaction
 * @throws errorMessage class if it cannot be reset
 */
async function leave(interaction) {
    const { member, info } = getAll(interaction);
    if (!queueContains(interaction))
        throw (0, util_1.emsg)('discord.notInQueue');
    info.players.splice(info.players.indexOf(member), 1);
    QUEUE.set(interaction.channelId, info);
    await interaction.reply(Lang.get('discord.leave'));
}
exports.QueueCommands = {
    open,
    close,
    queue,
    join,
    leave
};