//Config
import { getTOKEN, getGuildID, getApplicationID } from './utilities/configHandler.js';
// Commands
import ping from './commands/ping.js';
import join from './commands/join.js';
import leave from './commands/leave.js';
import status from './commands/status.js';
// Debug
import ModuleDebugBuilder from "./utilities/moduleDebugBuilder.js";
const log = new ModuleDebugBuilder("bot", "app");
// Modules
import { Client, GatewayIntentBits } from 'discord.js';
// Utilities
import registerCommands from './utilities/registerCommands.js';

/**
 * Host Process Object Builder
 *
 * This constructor is used to easily construct responses to the host process
 */
class HPOB {
    /**
     * Build an object to be passed to the host process
     * @param command The command to that was run ("Status", "Join", "Leave", "ChgPreSet")
     * @param response The response from the command that was run
     */
    constructor(command = "Status"||"Join"||"Leave"||"ChgPreSet", response) {
        this.cmd = command;
        this.msg = response;
    }
}

// Create the Discord client
const client = new Client({
    intents: [
        GatewayIntentBits.Guilds,
        GatewayIntentBits.GuildMessages,
        GatewayIntentBits.MessageContent,
        GatewayIntentBits.GuildVoiceStates
    ]
});

/**
 *  When the parent process sends a message, this will interpret the message and act accordingly
 *
 * DRB IPC Message Structure:
 * msg.cmd = The command keyword; Commands covered on the server side
 * msg.params = An array containing the parameters for the command
 *
 */
process.on('message', (msg) => {
    log.DEBUG('IPC Message: ', msg);
    const guildID = getGuilds()[0];

    log.DEBUG("Guild Name: ", getGuildNameFromID(guildID));
    switch (msg.cmd) {
        // Check the status of the bot
        case "Status":
            log.INFO("Status command run from IPC");

            status({guildID: guildID, callback: (statusObj) => {
                    log.DEBUG("Status Object string: ", statusObj);
                    if (!statusObj.voiceConnection) return process.send(new HPOB("Status", "VDISCONN"));
                }});
            break;

        // Check the params for a server ID and if so join the server
        case "Join":
            log.INFO("Join command run from IPC");

            join({guildID: guildID, guildObj: client.guilds.cache.get(guildID), channelID: msg.params.channelID, callback: () => {
                    process.send(new HPOB("Join", "AIDS"));
                }})
            break;

        // Check to see if the bot is in a server and if so leave
        case "Leave":
            log.INFO("Leave command run from IPC");

            leave({guildID: guildID, callback: (response) => {
                    process.send(new HPOB("Leave", response));
                }});
            break;

        default:
            // Command doesn't exist
            log.INFO("Unknown command run from IPC");
            break;
    }
})

// When the client is connected and ready
client.on('ready', () =>{
    log.INFO(`${client.user.tag} is ready`)
    process.send({'msg': "INIT READY"});
});

/*
* Saved For later
client.on('messageCreate', (message) => {
    log.DEBUG(`Message Sent by: ${message.author.tag}\n\t'${message.content}'`);
});
*/

// When a command is sent
client.on('interactionCreate', (interaction) => {
    if (interaction.isChatInputCommand()){
        switch (interaction.commandName) {
            case "ping":
                ping(interaction);
                break;
            case "join":
                join({ interaction: interaction });
                break;
            case "leave":
                leave({ interaction: interaction });
                break;
            case "status":
                status({ interaction: interaction });
                break;
            default:
                interaction.reply({ content: 'Command not found, try one that exists', fetchReply: true })
                    .then((message) => log.DEBUG(`Reply sent with content ${message.content}`))
                    .catch((err) => log.ERROR(err));
        }
    }
})

function loginBot(){
    client.login(getTOKEN());
}

function getGuilds() {
    return client.guilds.cache.map(guild => guild.id)
}

function getGuildNameFromID(guildID) {
    return client.guilds.cache.map((guild) => {
        if (guild.id === guildID) return guild.name;
    })[0]
}

function main(){
    registerCommands(() => {
        loginBot();
    });
}

main();
//module.exports = client;