import { DebugBuilder } from "../modules/debugger.mjs";
const log = new DebugBuilder("client", "pdabWrappers");
import { connectToChannel, leaveVoiceChannel, checkIfConnectedToVC, initDiscordBotClient, requestDiscordUsername, requestDiscordID, requestDiscordClientClose, closePdabSocketServer, setDiscordClientPrsense, startPdabSocketServer } from './pdabHandler.mjs';
import { openOP25, closeOP25 } from '../op25Handler/op25Handler.mjs';

let activeDiscordClient = undefined;

/**
 * Join the requested server VC and listen to the requested system
 * @param {object} joinData The object containing all the information to join the server
 */
export const joinDiscordVC = async (joinData) => {
    log.INFO("Join requested: ", joinData);
    const connection = await new Promise(async (res) => {
        // Check if a client already exists 
        log.INFO("Checking if there is a client open");
        if (!await checkIfClientIsOpen()) {
            log.INFO("There is no open client, starting it now");
            await startPdabSocketServer();
            // Open an instance of OP25
            log.INFO("Starting OP25")
            openOP25(joinData.system);

            // Open a new client and join the requested channel with the requested ID
            initDiscordBotClient(joinData.clientID, () => {
                log.INFO("Started PDAB");

                log.INFO("Setting the presense of the bot");
                setDiscordClientPrsense(joinData.system);

                // Add the client object to the IO instance
                log.INFO("Connecting to channel")
                connectToChannel(joinData.channelID, (connectionStatus) => {
                    log.INFO("Bot Connected to VC:", connectionStatus);
                    res(connectionStatus);
                });
            });
        } else {
            // Join the requested channel with the requested ID
            log.INFO("There is an open client");

            log.INFO("Connecting to channel")
            const connection = connectToChannel(joinData.channelID);
            log.INFO("Bot Connected to VC::");
            res(connection);
        }
    });

    return connection;
}

/**
 * Leave VC on the requested server
 * @param {string} guildId The guild ID to disconnect from VC
 */
export const leaveDiscordVC = async (guildId) => {
    log.INFO("Leave requested");
    if (await checkIfConnectedToVC(guildId)) {
        const clientRemainsOpen = await leaveVoiceChannel(guildId);
        log.INFO("Client should remain open: ", clientRemainsOpen);
        if (!clientRemainsOpen) {
            log.INFO("There are no open VC connections");
            await closeOP25();

            // Close the python client
            await requestDiscordClientClose();

            // Close the IPC server
            await closePdabSocketServer();
        }
    }
}

/**
 * Check if the bot is connected to a discord VC in the given server
 * @param {string} guildId The guild id to check the connection status in 
 * @returns {boolean} If the node is connected to VC in the given guild
 */
export const checkIfDiscordVCConnected = async (guildId) => {
    log.INFO("Requested status check");
    if (await checkIfConnectedToVC(guildId)) {
        log.INFO("There is an open VC connection");
        return (true);
    } else {
        return (false);
    }
}

/**
 * Get the username of the bot in a given guild 
 * (there may be a server nickname given to the bot in a certain guild)
 * @param {string} guildId The guild id to check the connection status in 
 * @returns {string} The username of the bot in the given guild's VC
 */
export const getDiscordUsername = async (guildId) => {
    log.INFO("Requested username");
    if (checkIfClientIsOpen()) {
        return await requestDiscordUsername(guildId)
    } else return (undefined);
}

/**
 * Get the ID of the currently running bot 
 * @returns {string} The ID of the active client
 */
export const getDiscordID = async () => {
    log.INFO("Requested ID");
    if (checkIfClientIsOpen()) {
        return await requestDiscordID();
    }
    else return (undefined);
}


/**
 * Check if there is an open discord client
 * @returns {boolean} If the client is open or not
 */
export const checkIfClientIsOpen = async () => {
    if (activeDiscordClient) {
        return (true);
    }
    return (false);
}