package gudusoft.gsqlparser.analyzer.v2.callgraph;

import gudusoft.gsqlparser.analyzer.v2.ETableAccessKind;
import gudusoft.gsqlparser.ir.bound.*;

import java.util.*;

/**
 * Call graph built from a {@link BoundProgram}.
 * <p>
 * Nodes represent routines; edges represent calls between routines.
 * Table accesses are tracked per node. All traversal algorithms use
 * iterative BFS (no recursion) to avoid stack overflow on deep graphs.
 */
public class CallGraph {

    private final Map<String, CallGraphNode> nodes;
    private final List<CallEdge> edges;

    // Adjacency lists for efficient queries
    private final Map<String, List<CallEdge>> outgoing; // caller -> edges
    private final Map<String, List<CallEdge>> incoming; // callee -> edges

    private CallGraph() {
        this.nodes = new LinkedHashMap<String, CallGraphNode>();
        this.edges = new ArrayList<CallEdge>();
        this.outgoing = new HashMap<String, List<CallEdge>>();
        this.incoming = new HashMap<String, List<CallEdge>>();
    }

    /**
     * Builds a CallGraph from a BoundProgram.
     */
    public static CallGraph buildFrom(BoundProgram program) {
        CallGraph graph = new CallGraph();

        // Create nodes from routineIndex
        for (Map.Entry<String, BoundRoutineSymbol> entry : program.getRoutineIndex().entrySet()) {
            BoundRoutineSymbol sym = entry.getValue();
            CallGraphNode node = new CallGraphNode(
                    sym.getRoutineId(),
                    sym.getRoutineName(),
                    sym.getPackageName(),
                    sym.getRoutineKind(),
                    sym.getDeclarationAnchor());
            graph.nodes.put(sym.getRoutineId(), node);
        }

        // Create edges from routine refs
        for (BoundRoutineRef ref : program.getAllRoutineRefs()) {
            String callerId = ref.getProperty("owningRoutineId");
            if (callerId == null) {
                continue;
            }

            String calleeId;
            if (ref.getBindingStatus() == EBindingStatus.EXACT
                    && ref.getResolvedRoutine() != null) {
                calleeId = ref.getResolvedRoutine().getRoutineId();
            } else {
                // Create an external/unresolved node
                calleeId = ref.getOriginalText();
                if (!graph.nodes.containsKey(calleeId)) {
                    CallGraphNode extNode = new CallGraphNode(
                            calleeId, ref.getOriginalText(), null,
                            ERoutineKind.PROCEDURE, null);
                    graph.nodes.put(calleeId, extNode);
                }
            }

            CallEdge edge = new CallEdge(
                    callerId, calleeId,
                    ref.getSourceAnchor(),
                    ref.getEvidence(),
                    ref.getConfidence());
            graph.edges.add(edge);

            if (!graph.outgoing.containsKey(callerId)) {
                graph.outgoing.put(callerId, new ArrayList<CallEdge>());
            }
            graph.outgoing.get(callerId).add(edge);

            if (!graph.incoming.containsKey(calleeId)) {
                graph.incoming.put(calleeId, new ArrayList<CallEdge>());
            }
            graph.incoming.get(calleeId).add(edge);
        }

        // Assign table accesses from object refs
        for (BoundObjectRef objRef : program.getAllObjectRefs()) {
            String routineId = objRef.getProperty("owningRoutineId");
            if (routineId == null) {
                continue;
            }
            CallGraphNode node = graph.nodes.get(routineId);
            if (node == null) {
                continue;
            }

            ETableAccessKind accessKind = TableAccessExtractor.inferAccessKind(objRef);
            node.addTableAccess(new TableAccess(
                    objRef.getOriginalText(), accessKind, objRef.getSourceAnchor()));
        }

        return graph;
    }

    // ---- Query APIs ----

    public Map<String, CallGraphNode> getNodes() {
        return Collections.unmodifiableMap(nodes);
    }

    public List<CallEdge> getEdges() {
        return Collections.unmodifiableList(edges);
    }

    public CallGraphNode getNode(String routineId) {
        return nodes.get(routineId);
    }

    /**
     * Returns the direct callees of the given routine.
     */
    public List<String> getDirectCallees(String routineId) {
        List<CallEdge> out = outgoing.get(routineId);
        if (out == null) {
            return Collections.emptyList();
        }
        List<String> result = new ArrayList<String>();
        for (CallEdge edge : out) {
            if (!result.contains(edge.getCalleeRoutineId())) {
                result.add(edge.getCalleeRoutineId());
            }
        }
        return result;
    }

    /**
     * Returns the direct callers of the given routine.
     */
    public List<String> getDirectCallers(String routineId) {
        List<CallEdge> in = incoming.get(routineId);
        if (in == null) {
            return Collections.emptyList();
        }
        List<String> result = new ArrayList<String>();
        for (CallEdge edge : in) {
            if (!result.contains(edge.getCallerRoutineId())) {
                result.add(edge.getCallerRoutineId());
            }
        }
        return result;
    }

    /**
     * Returns all transitively reachable callees using iterative BFS.
     */
    public Set<String> getTransitiveCallees(String routineId, int maxDepth) {
        Set<String> visited = new LinkedHashSet<String>();
        Deque<String> queue = new ArrayDeque<String>();
        Map<String, Integer> depthMap = new HashMap<String, Integer>();

        queue.add(routineId);
        depthMap.put(routineId, 0);

        while (!queue.isEmpty()) {
            String current = queue.poll();
            int currentDepth = depthMap.get(current);

            if (currentDepth >= maxDepth) {
                continue;
            }

            for (String callee : getDirectCallees(current)) {
                if (!visited.contains(callee) && !callee.equals(routineId)) {
                    visited.add(callee);
                    if (!depthMap.containsKey(callee)) {
                        depthMap.put(callee, currentDepth + 1);
                        queue.add(callee);
                    }
                }
            }
        }
        return visited;
    }

    /**
     * Returns all transitive callers using iterative BFS.
     */
    public Set<String> getTransitiveCallers(String routineId, int maxDepth) {
        Set<String> visited = new LinkedHashSet<String>();
        Deque<String> queue = new ArrayDeque<String>();
        Map<String, Integer> depthMap = new HashMap<String, Integer>();

        queue.add(routineId);
        depthMap.put(routineId, 0);

        while (!queue.isEmpty()) {
            String current = queue.poll();
            int currentDepth = depthMap.get(current);

            if (currentDepth >= maxDepth) {
                continue;
            }

            for (String caller : getDirectCallers(current)) {
                if (!visited.contains(caller) && !caller.equals(routineId)) {
                    visited.add(caller);
                    if (!depthMap.containsKey(caller)) {
                        depthMap.put(caller, currentDepth + 1);
                        queue.add(caller);
                    }
                }
            }
        }
        return visited;
    }

    /**
     * Finds all nodes that access a given table.
     */
    public List<CallGraphNode> getNodesAccessingTable(String tableName, ETableAccessKind filter) {
        String normalizedSearch = TableAccessExtractor.normalizeTableName(tableName);
        List<CallGraphNode> result = new ArrayList<CallGraphNode>();
        for (CallGraphNode node : nodes.values()) {
            for (TableAccess ta : node.getTableAccesses()) {
                String normalizedTable = TableAccessExtractor.normalizeTableName(ta.getTableName());
                if (normalizedTable.equals(normalizedSearch)) {
                    if (filter == null || ta.getAccessKind() == filter
                            || ta.getAccessKind() == ETableAccessKind.READ_WRITE) {
                        result.add(node);
                        break;
                    }
                }
            }
        }
        return result;
    }

}