// JavaScript Code Example
// Node Structure: Defines the processes and resources in the system
        const nodes = [
            { id: 'P1', type: 'process' },
            { id: 'P2', type: 'process' },
            { id: 'R1.1', type: 'resource', group: 'R1' },
            { id: 'R1.2', type: 'resource', group: 'R1' },
            { id: 'R2.1', type: 'resource', group: 'R2' }
        ];

// Links Structure: Defines the relationships (edges) between processes and resources
        const links = [
            { source: 'P1', target: 'R1.1' },
            { source: 'R1.2', target: 'P2' },
            { source: 'P2', target: 'R2.1' }
        ];

// Function to detect all circular waits (causing deadlocks) and return involved edges
        function detectAllCycleEdges(links) {
            let visited = new Set();    // Tracks nodes that have been fully processed
            let stack = new Set();      // Tracks nodes in the current DFS recursion
            let edgeStack = [];         // Tracks the edges being traversed in the current DFS path
            let allCycleEdges = [];     // To store all the cycles detected
        
        // Helper function to perform Depth-First Search (DFS) to find cycles
            function dfs(node) {
                if (stack.has(node)) {
                    // Cycle found: return the edges involved in this cycle
                    allCycleEdges.push([...edgeStack]); // Save a copy of the current edge stack
                    return;
                }
                if (visited.has(node)) {
                    // Node has already been fully processed, skip it
                    return;
                }
        
                // Mark the node as visited and add to the current recursion stack
                visited.add(node);
                stack.add(node);
        
                // Traverse all outgoing edges from the current node
                for (let link of links) {
                    if (link.source === node) {
                        // Add the current edge to the edge stack
                        edgeStack.push(link);
                        dfs(link.target); // Continue DFS to the target node
                        // Backtrack: remove the edge from the stack if no cycle found
                        edgeStack.pop();
                    }
                }
                // Backtrack: remove the node from the recursion stack
                stack.delete(node);
            }
            // Start DFS from each node in nodes1
            for (let node of nodes) {
                dfs(node.id); // Perform DFS starting from the node's ID
            }
            return allCycleEdges; // Return all cycles found
        }

// Function to calculate hold-wait edges (potential deadlock scenarios)
        function calc_hold_wait_edges(){
            yellowLinks=[];//empty 
            for(let link of links){
                const sourceNode = nodes.find(node => node.id === link.source.id || node.id === link.source);
                const targetNode = nodes.find(node => node.id === link.target.id || node.id === link.target);
                if(sourceNode.type==="resource" && targetNode.type==="process"){//hold wait can only form
                  //resource to process and + process to another resource
                    for (let link1 of links){
                        if(link.target===link1.source){
                            for(let link2 of links){
                                if(link2.source===link1.target){
                                    yellowLinks.push(link)
                                    yellowLinks.push(link1)
                                }
                            }
                        }
                        
                    }
                }
                
            }
            console.log("Yellow_links calculated : " , yellowLinks);
        }

// Function to add a new process node
        function addNode(value) {
            const numberOfNodes = value;
            // Check if the input is a valid number
            if (isNaN(numberOfNodes) || numberOfNodes <= 0) {
                let message="Please Enter a Valid Number that is greater than 1"; 
                show_message(message); 
                return;
            }
            
            for (let i = 0; i < numberOfNodes; i++) {
                const newNodeId = `P${nodes.filter((node) => node.type === "process").length + 1}`;
                const newNode = {
                    id: newNodeId,
                    type: "process",
                    x: width / 2,
                    y: height / 2,};
                nodes.push(newNode);
            }
            console.log("nodes : ", nodes);
            hide_addProcess()            //hide the form 
            renderGraph(); // Call renderGraph() once after adding all nodes
        }

// Function to add multiple resources (Adds m resource each having n resource instances)
            function addMultipleResources(value,value1) {
                let m = value;
                let n = value1
                // Validate inputs: Must be natural numbers (positive integers)
                if (isNaN(m) || isNaN(n) || m < 1 || n < 1 || !Number.isInteger(m) || !Number.isInteger(n)) {
                    let message="Please Enter a Valid Number that is greater than 1";
                    show_message(message); 
                    return;
                }
                // Find the highest existing resource number
                const resourceNumbers = nodes
                    .filter(node => node.type === 'resource')
                    .map(node => parseInt(node.id.split('.')[0].substring(1)))
                    .filter(num => !isNaN(num));
            
                let startingResourceNumber = (resourceNumbers.length > 0 ? Math.max(...resourceNumbers) : 0) + 1;
            
                // Create m resources, each with n instances
                for (let i = 0; i < m; i++) {
                    let resourceNumber = startingResourceNumber + i;
            
                    for (let j = 1; j <= n; j++) {
                        const newResourceId = `R${resourceNumber}.${j}`;
                        const newResource = { id: newResourceId, type: 'resource', group: `R${resourceNumber}` };
                        nodes.push(newResource);
                    }
                }
                console.log("nodes:", nodes);
                renderGraph();
            }

// Function to add a new resource instance
        function addResourceInstance(value) {
            const resourceNumber =value;
            if (resourceNumber) {
                const existingResources = nodes.filter(node => 
                    node.type === 'resource' && node.id.startsWith(`R${resourceNumber}.`)
                );
                if (existingResources.length > 0) {
                    let maxNumber = 0;
                    nodes.forEach(node => {
                        if (node.type === "resource" && node.id.startsWith(`R${resourceNumber}.`)) {
                            let match = node.id.match(/R\d+\.(\d+)$/); // Extract only the last numeric part
                            if (match) {
                                let num = parseInt(match[1]); // Convert to number
                                maxNumber = Math.max(maxNumber, num);
                            }
                        }
                    });
                    const newInstanceNumber = maxNumber + 1;            
                    const newResourceId = `R${resourceNumber}.${newInstanceNumber}`;
                    const newResource = { id: newResourceId, type: 'resource', group: `R${resourceNumber}` };
                    nodes.push(newResource);
                    console.log("nodes : " , nodes);
                } else {
                    const newResourceId = `R${resourceNumber}.1`;
                    const newResource = { id: newResourceId, type: 'resource', group: `R${resourceNumber}` };
                    nodes.push(newResource);
                    console.log("nodes : " , nodes);
                }
                renderGraph();
            }
        }