class APIScenarioExecutor {
    constructor(graph, apiTester) {
        this.graph = graph; // The graph data
        this.currentNodeId = this.findStartNodeId(); // Initialize at the 'start' node
        this.apiClient = new APIClient();
        this.apiTester = apiTester;
        this.visitedNodes = new Set(); // Keep track of visited nodes
    }

    // Helper method to find the start node ID
    findStartNodeId() {
        for (let nodeId in this.graph) {
            if (this.graph[nodeId].class === 'start') {
                return nodeId;
            }
        }
        return null; // Return null if no start node is found
    }

    // Method to execute the current node's API request if it's an 'api' node
    executeCurrentNode() {
        console.log(this.currentNodeId)
        if (!this.currentNodeId) {
            console.log('No current node to execute.');
            return;
        }

        const currentNode = this.graph[this.currentNodeId];
        if (currentNode && currentNode.class === 'api') {
            // get API model with currentNode.id
            let model = this.apiTester.getApiRequestModel(currentNode.id);
            this.apiClient.sendAPIRequest(model)
                .then(response => {
                    console.log(response);
                })
                .catch(error => {
                    console.log(error.name)
                    if (error.name === 'AbortError') {
                        console.log('Fetch aborted');
                    } else {
                        console.log('error3')
                    }
                });
            console.log(`Executing API request for node: ${currentNode.id} - ${currentNode.name}`);
        } else {
            console.log('Current node is not an API node or does not exist.');
        }
        this.visitedNodes.add(this.currentNodeId); // Mark this node as visited

    }

    // Method to move to the next node
    moveToNextNode() {
        const currentNode = this.graph[this.currentNodeId];
        console.log(currentNode);

        if (currentNode && currentNode.connections.length > 0) {
            // Find the next unvisited node
            const nextNode = currentNode.connections.find(nodeId => !this.visitedNodes.has(nodeId));
            if (nextNode) {
                this.currentNodeId = nextNode;
                console.log(`Moved to node: ${this.currentNodeId}`);
            } else {
                console.log('No more unvisited connections to move to.');
                this.currentNodeId = null; // No more nodes to visit
            }
        } else {
            console.log('Current node has no connections or does not exist.');
            this.currentNodeId = null; // No more nodes to visit
        }
    }

    // Method to execute the entire scenario from start to end
    executeAll() {
        while (this.currentNodeId) {
            console.log(this.currentNodeId)
            this.executeCurrentNode();
            this.moveToNextNode();
        }
        console.log('Completed execution of all API nodes.');
    }

    static extractGraphFromStart(homeData) {
        console.log(homeData)
        let graph = {};

        // Helper function to recursively build the graph
        function buildGraph(nodeId) {
            const node = homeData[nodeId];
            if (!node || graph[nodeId]) {
                // If the node doesn't exist or has already been visited, stop the recursion
                return;
            }

            // Initialize the node in the graph
            graph[nodeId] = {
                id: node.id,
                name: node.name,
                class: node.class,
                connections: []
            };

            // If the node has outputs, recursively add connected nodes
            if (node.outputs) {
                Object.values(node.outputs).forEach(output => {
                    output.connections.forEach(connection => {
                        graph[nodeId].connections.push(connection.node);
                        buildGraph(connection.node);  // Recurse
                    });
                });
            }
        }

        // Find the start node
        for (let nodeId in homeData) {
            if (homeData[nodeId].class === 'start') {
                buildGraph(nodeId);  // Start building the graph from the 'start' node
                break;  // Assuming there's only one start node
            }
        }

        return graph;
    }
}