import { createNode, getNodeByNuid, updateNodeByNuid } from "./mongoNodesWrappers.mjs"
import { createSystem, getSystemByName, updateSystemByName, getSystemsByNuid, deleteSystemByName } from "./mongoSystemsWrappers.mjs"

/**
 * Description
 * @param {any} socket
 * @param {any} command
 * @param {any} data
 * @returns {any}
 */
const sendNodeCommand = async (socket, command, data) => {
    // TODO - Check to see if the command exists
    // TODO - Check to see if the socket is alive?
    // TODO - Validate the given data
    socket.emit(command, data);
}

/**
 * Log the node into the network
 * @param {object} data The data sent from the node
 * @param {any} socket The socket the node is connected from
 * @returns {any}
 */
export const nodeLoginWrapper = async (data, socket) => {
    console.log(`Login requested from node: ${data.nuid}`, data);
    // Check to see if node exists
    var node = await getNodeByNuid(data.nuid);
    console.log("After grabbing", node);
    if (!node) {
        const insertedId = await createNode(data);
        node = await getNodeByNuid(data.nuid);
        console.log("Added new node to the database:", insertedId);
    }
    // Check for updates if so
    // Check for System updates

    // Add the socket/node connection
    socket.node = node;
    socket.id = node.nuid;

    return;
}

/**
 * Disconnect the client from the server
 * @param {string} socketId The socket ID that was disconnected
 * @returns {any}
 */
export const nodeDisconnectWrapper = async (socketId) => {
    return;
}

/**
 * Update node data in the database
 * @param {object} nodeData The data object sent from the node
 * @returns {any}
 */
export const nodeUpdateWrapper = async (nodeData) => {
    console.log("Data update sent by node: ", nodeData);
    const updateResults = await updateNodeByNuid(nodeData.nuid, nodeData);
    return;
}

/**
 * Wrapper to update the systems from the nearbySystems object passed from clients
 * @param {string} nuid The NUID of the node that sent the update
 * @param {object} nearbySystems The nearby systems object passed from the node to be updated
 * @returns {any}
 */
export const nearbySystemsUpdateWraper = async (nuid, nearbySystems) => {
    console.log("System updates sent by node: ", nuid, nearbySystems);
    // Check to see if the node removed any systems
    const existingSystems = await getSystemsByNuid(nuid);
    console.log("Existing systems:", existingSystems);
    if (existingSystems !== nearbySystems) {
        for (const existingSystem of existingSystems) {
            if (existingSystem.name in nearbySystems) {
                // Skip this system if it's in the given systems update
                continue;
            }

            console.log("System exists that was not given by node", existingSystem);
            // Check if this node was the only node on this system
            if (existingSystem.nodes.filter(node => node !== nuid).length === 0) {
                // Remove the system if so
                console.log("Given node was the only node on this system, removing the system...");
                await deleteSystemByName(existingSystem.name);
            } else {
                // Remove the node from the array if there are other nodes with this system
                console.log("Other nodes found on this system, removing the given NUID");
                existingSystem.nodes = existingSystem.nodes.filter(node => node !== nuid);
                console.log(existingSystem);
                await updateSystemByName(existingSystem.name, existingSystem);
            }
        }
    }

    // Add and update the given systems
    for (const nearbySystem in nearbySystems) {
        // Check if the system exists already on another node
        const existingSystem = await getSystemByName(nearbySystem);
        if (existingSystem) {
            // Verify the frequencies match (to make sure the name isn't just the same)            
            console.log(existingSystem.frequencies, nearbySystems[nearbySystem].frequencies, (JSON.stringify(existingSystem.frequencies) === JSON.stringify(nearbySystems[nearbySystem].frequencies)));

            if (JSON.stringify(existingSystem.frequencies) === JSON.stringify(nearbySystems[nearbySystem].frequencies)) {
                // The systems are the same                

                // Check if the current node is listed in the nodes, if not add it
                if (!existingSystem.nodes.includes(nuid)) {
                    existingSystem.nodes.push(nuid);
                    // Update the system with the added node
                    const updateResults = await updateSystemByName(nearbySystem, existingSystem);
                    if (updateResults) console.log("System updated", nearbySystem);
                }
            } else {
                // The systems are not the same
                // TODO - Implement logic to handle if system names match, but they are for different frequencies or have additional freqs
                
                // Check if the current node is listed in the nodes, if not add it
                if (!existingSystem.nodes.includes(nuid)) {
                    existingSystem.nodes.push(nuid);
                    nearbySystems[nearbySystem].nodes = existingSystem.nodes;
                }

                // Update the system with the added node
                const updateResults = await updateSystemByName(nearbySystem, nearbySystems[nearbySystem]);
                if (updateResults) console.log("System updated", nearbySystem);
            }
        }
        else {
            // Create a new system
            const newSystem = await createSystem(nearbySystem, nearbySystems[nearbySystem], nuid);
            console.log("New system created", nearbySystem, newSystem);
        }
    }
    return;
}


/**
 * Get the open socket connection ID for a node from the NUID 
 * @param {string} nuid The NUID to find within the open sockets
 * @returns {string|null} Will return the open socket ID or NULL
 */
const getSocketIdByNuid = async (nuid) => {
    for (const openSocket in openSockets) {
        if (openSockets[openSocket] == nuid)
            return openSocket;
    }
    return null;
}



const requestNodeJoinPreset = async () => {
    // Check for System updates
    // Test commands
    setTimeout(() => {
        const joinData = {
            'clientID': "MTE5NjAwNTM2ODYzNjExMjk3Nw.GuCMXg.24iNNofNNumq46FIj68zMe9RmQgugAgfrvelEA",
            'channelID': "367396189529833476",
            'preset': ""
        }
        sendNodeCommand(socket, "node-join", joinData);
    }, 2500)
}