package gudusoft.gsqlparser.analyzer.v2.impact;

import gudusoft.gsqlparser.analyzer.v2.ETableAccessKind;
import gudusoft.gsqlparser.analyzer.v2.ImpactEntry;
import gudusoft.gsqlparser.analyzer.v2.ImpactResult;
import gudusoft.gsqlparser.analyzer.v2.callgraph.CallEdge;
import gudusoft.gsqlparser.analyzer.v2.callgraph.CallGraph;
import gudusoft.gsqlparser.analyzer.v2.callgraph.CallGraphNode;
import gudusoft.gsqlparser.analyzer.v2.callgraph.TableAccess;
import gudusoft.gsqlparser.ir.common.SourceAnchor;

import java.util.*;

/**
 * Impact analysis engine using real BFS traversal with path reconstruction.
 * <p>
 * Provides accurate graph distances (not sequential counters) and
 * reconstructed shortest paths from source to each impacted entity.
 */
public class ImpactEngine {

    private ImpactEngine() {}

    /**
     * Computes routine impact: finds all routines and tables transitively
     * affected by a change to the given routine, using forward BFS.
     *
     * @param callGraph  the call graph to traverse
     * @param routineId  the source routine to analyze impact from
     * @param maxDepth   maximum BFS depth (from config)
     * @return impact result with real graph distances and reconstructed paths
     */
    public static ImpactResult getRoutineImpact(CallGraph callGraph, String routineId, int maxDepth) {
        if (callGraph == null) {
            return emptyResult();
        }

        // BFS forward from source
        Map<String, Integer> distance = new LinkedHashMap<String, Integer>();
        Map<String, String> predecessor = new LinkedHashMap<String, String>();
        Deque<String> queue = new ArrayDeque<String>();

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

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

            if (currentDepth >= maxDepth) {
                continue;
            }

            for (String callee : callGraph.getDirectCallees(current)) {
                if (!distance.containsKey(callee)) {
                    distance.put(callee, currentDepth + 1);
                    predecessor.put(callee, current);
                    queue.add(callee);
                }
            }
        }

        // Build results
        List<ImpactEntry> impactedRoutines = new ArrayList<ImpactEntry>();
        List<ImpactEntry> impactedTables = new ArrayList<ImpactEntry>();

        // Include the source routine's own table accesses at depth 0
        collectTableImpact(callGraph, routineId, 0,
                Collections.singletonList(routineId), impactedTables);

        for (Map.Entry<String, Integer> entry : distance.entrySet()) {
            String nodeId = entry.getKey();
            if (nodeId.equals(routineId)) {
                continue; // skip source
            }
            int depth = entry.getValue();
            List<String> path = reconstructPath(predecessor, routineId, nodeId);

            CallGraphNode node = callGraph.getNode(nodeId);
            String displayName = node != null ? node.getRoutineName() : nodeId;
            SourceAnchor anchor = node != null ? node.getDeclarationAnchor() : null;

            impactedRoutines.add(new ImpactEntry(
                    nodeId, displayName, depth, path, anchor));

            // Collect table accesses for this callee
            collectTableImpact(callGraph, nodeId, depth, path, impactedTables);
        }

        return new ImpactResult(impactedRoutines, impactedTables);
    }

    /**
     * Computes table impact: finds all routines affected by a change to the given table.
     * Uses reverse BFS from each direct accessor to find transitive callers.
     *
     * @param callGraph    the call graph
     * @param tableName    the table name to analyze
     * @param accessFilter optional filter (null = all access types)
     * @param maxDepth     maximum BFS depth
     * @return impact result
     */
    public static ImpactResult getTableImpact(CallGraph callGraph, String tableName,
                                               ETableAccessKind accessFilter, int maxDepth) {
        if (callGraph == null) {
            return emptyResult();
        }

        List<CallGraphNode> directAccessors =
                callGraph.getNodesAccessingTable(tableName, accessFilter);

        List<ImpactEntry> impactedRoutines = new ArrayList<ImpactEntry>();
        List<ImpactEntry> impactedTables = new ArrayList<ImpactEntry>();

        // Add the table itself at depth 0
        impactedTables.add(new ImpactEntry(
                tableName, tableName, 0,
                Collections.singletonList(tableName), null));

        Set<String> seen = new LinkedHashSet<String>();

        for (CallGraphNode accessor : directAccessors) {
            String accessorId = accessor.getRoutineId();
            if (!seen.add(accessorId)) {
                continue;
            }

            // Direct accessor at depth 1
            List<String> directPath = new ArrayList<String>();
            directPath.add(tableName);
            directPath.add(accessorId);

            impactedRoutines.add(new ImpactEntry(
                    accessorId, accessor.getRoutineName(), 1,
                    directPath, accessor.getDeclarationAnchor()));

            // Reverse BFS from accessor to find transitive callers
            Map<String, Integer> callerDistance = new LinkedHashMap<String, Integer>();
            Map<String, String> callerPredecessor = new LinkedHashMap<String, String>();
            Deque<String> queue = new ArrayDeque<String>();

            callerDistance.put(accessorId, 0);
            queue.add(accessorId);

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

                if (currentDepth >= maxDepth - 1) { // -1 because accessor is already depth 1
                    continue;
                }

                for (String caller : callGraph.getDirectCallers(current)) {
                    if (!callerDistance.containsKey(caller) && seen.add(caller)) {
                        callerDistance.put(caller, currentDepth + 1);
                        callerPredecessor.put(caller, current);
                        queue.add(caller);

                        int totalDepth = currentDepth + 2; // +2 = table→accessor + caller chain
                        List<String> callerPath = new ArrayList<String>();
                        callerPath.add(tableName);
                        // Reconstruct accessor → ... → caller
                        List<String> chainPath = reconstructPath(
                                callerPredecessor, accessorId, caller);
                        callerPath.addAll(chainPath);

                        CallGraphNode callerNode = callGraph.getNode(caller);
                        String name = callerNode != null ? callerNode.getRoutineName() : caller;
                        SourceAnchor callerAnchor = callerNode != null
                                ? callerNode.getDeclarationAnchor() : null;

                        impactedRoutines.add(new ImpactEntry(
                                caller, name, totalDepth, callerPath, callerAnchor));
                    }
                }
            }
        }

        return new ImpactResult(impactedRoutines, impactedTables);
    }

    /**
     * Reconstructs the shortest path from source to target using the predecessor map.
     */
    private static List<String> reconstructPath(Map<String, String> predecessor,
                                                 String source, String target) {
        List<String> path = new ArrayList<String>();
        String current = target;
        while (current != null && !current.equals(source)) {
            path.add(current);
            current = predecessor.get(current);
        }
        path.add(source);
        Collections.reverse(path);
        return path;
    }

    private static void collectTableImpact(CallGraph callGraph, String routineId,
                                            int depth, List<String> basePath,
                                            List<ImpactEntry> impactedTables) {
        CallGraphNode node = callGraph.getNode(routineId);
        if (node == null) {
            return;
        }
        for (TableAccess ta : node.getTableAccesses()) {
            List<String> tablePath = new ArrayList<String>(basePath);
            tablePath.add(ta.getTableName());
            impactedTables.add(new ImpactEntry(
                    ta.getTableName(), ta.getTableName(), depth,
                    tablePath, ta.getAnchor()));
        }
    }

    private static ImpactResult emptyResult() {
        return new ImpactResult(
                Collections.<ImpactEntry>emptyList(),
                Collections.<ImpactEntry>emptyList());
    }
}