package gudusoft.gsqlparser.dlineage.dynamicsql;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EExpressionType;
import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.TStatementList;
import gudusoft.gsqlparser.dlineage.DataFlowAnalyzer;
import gudusoft.gsqlparser.dlineage.dataflow.model.Option;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.column;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.dataflow;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.relationship;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.sourceColumn;
import gudusoft.gsqlparser.dlineage.dataflow.model.xml.table;
import gudusoft.gsqlparser.dlineage.dynamicsql.RoutineSummaryEdge.Endpoint;
import gudusoft.gsqlparser.dlineage.dynamicsql.RoutineSummaryEdge.EndpointKind;
import gudusoft.gsqlparser.nodes.TExpression;
import gudusoft.gsqlparser.nodes.TFunctionCall;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TParseTreeVisitor;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * B2 (design {@code routine-summary-scc-design.md} §2.2, §3): intraprocedural
 * base-summary extraction — the reachability QUOTIENT of one routine's
 * analyzed relation graph.
 *
 * <p><b>No-inline-callee / binding-independence — how it is actually
 * enforced</b> (corrected per codex-B2-r1 finding 1): a fresh
 * {@link DataFlowAnalyzer} instance blocks CROSS-FILE leakage only; the
 * analyzer will still inline a SAME-UNIT callee's body through its
 * procedure-DDL map. The contract therefore rests on PER-DEFINITION
 * slicing: {@link #extractAll(String)} splits a unit into single-definition
 * texts and each slice is analyzed with no sibling present, so callee
 * bodies are absent by construction and calls surface as raw call sites
 * (+ CALLS_UNRESOLVED). {@link #extract(String)} requires a
 * single-definition input for the same reason. Oracle package statements
 * are the documented exception (members share one statement; B4).
 *
 * <p><b>Closure semantics</b> (mirrors the inline engine's fdd/fdr duality,
 * never OR-merging): per boundary pair, an {@code fdd} summary edge means at
 * least one interior path made of {@code fdd} hops only; an {@code fdr}
 * summary edge means at least one interior path containing an {@code fdr}
 * hop. Both may coexist. Propagation is an iterative worklist (explicit
 * {@link Deque}; the relation graph is arbitrary — cycles from variable
 * reassignment converge because the propagated sets are monotone).
 *
 * <p>The extractor caches per definition text (analysis-scoped: one
 * extractor instance per analysis).
 */
public final class RoutineSummaryExtractor {

    private final EDbVendor vendor;
    private final Map<String, RoutineSummary> cache = new HashMap<String, RoutineSummary>();

    public RoutineSummaryExtractor(EDbVendor vendor) {
        this.vendor = vendor;
    }

    /**
     * Extract base summaries for EVERY routine defined in a unit, each from a
     * PER-DEFINITION slice analyzed alone (codex-B2-r1 finding 1: analyzing
     * the whole unit lets the analyzer inline same-unit callee bodies through
     * its procedure-DDL map — slicing is what actually enforces
     * no-inline-callee; a same-unit callee is then simply absent, and the
     * call surfaces as a raw call site + CALLS_UNRESOLVED).
     *
     * <p>Oracle packages: members share one CREATE PACKAGE [BODY] statement
     * and cannot be sliced apart — the package statement is summarized whole,
     * and intra-package sibling composition is deferred to B4 (parity slice).
     */
    public List<RoutineSummary> extractAll(String unitText) {
        List<RoutineSummary> summaries = new ArrayList<RoutineSummary>();
        RoutineCatalog catalog = new RoutineCatalog(vendor,
                Collections.singletonList(unitText),
                new HashMap<String, TStatementList>());
        RoutineCatalog.UnitIndex index = catalog.indexOf(unitText);
        if (index == null) {
            summaries.add(new RoutineSummary(null, null, null,
                    RoutineSummary.Completeness.OPAQUE,
                    Collections.singletonList("PARSE_FAILED")));
            return summaries;
        }
        for (RoutineCatalog.Definition def : index.definitions) {
            summaries.add(extract(definitionSlice(def)));
        }
        // Oracle packages: members live in memberDefinitions, not definitions
        // (codex-B2-r2 new issue 1). B4a summarizes each member from its OWN
        // re-wrapped single-member slice (see RoutineCatalog.PackageContext).
        // A package whose members cannot all be sliced falls back to the B2/B3
        // behavior — one whole-package summary held PARTIAL by the
        // PACKAGE_SCOPE_DEFERRED gate — so a slicing failure degrades to the
        // previously shipped result instead of dropping the package.
        // Sliceability is decided PER PACKAGE, not per member: a package is
        // either fully represented by per-member slices or not sliced at all.
        // Mixing the two would emit per-member summaries AND a whole-package
        // summary covering those same routines — double coverage.
        Map<TCustomSqlStatement, List<RoutineCatalog.Definition>> byPackage =
                new LinkedHashMap<TCustomSqlStatement, List<RoutineCatalog.Definition>>();
        for (RoutineCatalog.Definition member : index.memberDefinitions) {
            TCustomSqlStatement pkg = packageStatementOf(member);
            if (pkg == null) {
                continue;
            }
            List<RoutineCatalog.Definition> members = byPackage.get(pkg);
            if (members == null) {
                members = new ArrayList<RoutineCatalog.Definition>();
                byPackage.put(pkg, members);
            }
            members.add(member);
        }
        for (Map.Entry<TCustomSqlStatement, List<RoutineCatalog.Definition>> e
                : byPackage.entrySet()) {
            List<RoutineSummary> sliced = sliceMembers(e.getKey(), e.getValue());
            if (sliced != null) {
                summaries.addAll(sliced);
            } else {
                summaries.add(extract(e.getKey().toString()));
            }
        }
        return summaries;
    }

    /**
     * Per-member summaries for ONE package, or null when the package must not
     * be sliced at all (caller then falls back to the B2/B3 whole-package
     * summary, held PARTIAL by the PACKAGE_SCOPE_DEFERRED gate — i.e. the
     * previously shipped extraction SHAPE; it does not recover lineage the
     * analyzer never produced).
     *
     * <p>Returning null on ANY problem is what keeps slicing sound: a package
     * is either fully covered by member slices or not sliced at all.
     */
    private List<RoutineSummary> sliceMembers(TCustomSqlStatement pkg,
            List<RoutineCatalog.Definition> members) {
        // A package initialization block (`... BEGIN <stmts> END pkg;`) is
        // stored on the PACKAGE's own body statements, not on any member, so
        // no member slice can carry it (codex-B4a-r2 finding 1).
        //
        // MEASURED: dlineage emits ZERO relationships for a package
        // initializer today, so nothing is lost either way — verified against
        // master with the whole B4a diff stashed. This guard therefore does
        // not fix a regression; it keeps slicing from claiming coverage of a
        // construct it structurally cannot carry, so that if the analyzer
        // ever learns to read initializers the whole-package path picks them
        // up instead of the slice silently dropping them.
        if (pkg instanceof gudusoft.gsqlparser.stmt.TBlockSqlStatement) {
            gudusoft.gsqlparser.stmt.TBlockSqlStatement block =
                    (gudusoft.gsqlparser.stmt.TBlockSqlStatement) pkg;
            if (block.getBodyStatements() != null
                    && block.getBodyStatements().size() > 0) {
                return null;
            }
        }
        List<RoutineSummary> sliced = new ArrayList<RoutineSummary>();
        for (RoutineCatalog.Definition member : members) {
            // A SPEC declaration has no body — nothing to summarize. Its
            // signature already reached the catalog via memberDefinitions.
            // specOnly is a PACKAGE-wide flag, so it does NOT catch a forward
            // declaration sitting inside a package BODY; that needs the
            // per-member body check (codex-B4a-r1 finding 1).
            if (member.specOnly || !hasBody(member.stmt)) {
                continue;
            }
            String slice = memberSlice(member);
            if (slice == null) {
                return null;
            }
            RoutineSummary summary = extract(slice);
            if (summary.getCompleteness() == RoutineSummary.Completeness.OPAQUE) {
                // Re-wrap did not survive the parser (unusual declaration
                // section, dialect edge). Fall back rather than publish OPAQUE.
                return null;
            }
            sliced.add(summary);
        }
        return sliced;
    }

    /**
     * True when a package member actually carries an implementation.
     *
     * <p>A forward declaration inside a package BODY ({@code PROCEDURE foo(p
     * NUMBER);} ahead of its definition) and a call specification (EXTERNAL /
     * LANGUAGE JAVA) both parse to the same node type as a real member but
     * hold zero body statements. Summarizing one would publish a SECOND
     * summary under the implementation's own {@link RoutineIdentity}; the
     * applier's duplicate-definition handling then discards that identity
     * outright and the real routine's effects are lost (codex-B4a-r1
     * finding 1). Body presence is the per-member discriminator —
     * {@code Definition.specOnly} is package-wide and cannot see this.
     */
    private static boolean hasBody(TCustomSqlStatement stmt) {
        if (!(stmt instanceof gudusoft.gsqlparser.stmt.TBlockSqlStatement)) {
            // Unknown member shape — keep the pre-existing behavior of
            // summarizing it rather than silently dropping a real routine.
            return true;
        }
        gudusoft.gsqlparser.stmt.TBlockSqlStatement block =
                (gudusoft.gsqlparser.stmt.TBlockSqlStatement) stmt;
        return block.getBodyStatements() != null
                && block.getBodyStatements().size() > 0;
    }

    /**
     * B4a: rebuild ONE package member as a standalone single-member package —
     * header + package globals + this member only + {@code END}. Returns null
     * when the member carries no re-wrap context or its own text is
     * unavailable.
     */
    private static String memberSlice(RoutineCatalog.Definition member) {
        RoutineCatalog.PackageContext ctx = member.pkgContext;
        if (ctx == null || ctx.qualifiedName == null || member.stmt == null) {
            return null;
        }
        String memberText = member.stmt.toString();
        if (memberText == null) {
            return null;
        }
        memberText = memberText.trim();
        if (memberText.length() == 0) {
            return null;
        }
        // Member nodes end at END <name> with the terminating semicolon owned
        // by the enclosing declare list, so it must be re-added here.
        if (!memberText.endsWith(";")) {
            memberText = memberText + ";";
        }
        StringBuilder slice = new StringBuilder();
        slice.append("CREATE OR REPLACE PACKAGE BODY ")
                .append(ctx.qualifiedName).append(" AS\n");
        if (ctx.globalsText != null) {
            slice.append(ctx.globalsText);
        }
        slice.append("  ").append(memberText).append("\n");
        slice.append("END");
        if (ctx.endName != null && ctx.endName.length() > 0) {
            slice.append(" ").append(ctx.endName);
        }
        slice.append(";\n");
        return slice.toString();
    }

    /** The enclosing CREATE PACKAGE statement of a member definition. */
    private static TCustomSqlStatement packageStatementOf(
            RoutineCatalog.Definition member) {
        TCustomSqlStatement stmt = member.stmt;
        while (stmt != null
                && !(stmt instanceof gudusoft.gsqlparser.stmt.oracle.TPlsqlCreatePackage)) {
            stmt = stmt.getParentStmt();
        }
        return stmt;
    }

    /** The standalone analyzable text of one definition (its own statement,
     *  re-anchored under its effective USE database when one applies). */
    private String definitionSlice(RoutineCatalog.Definition def) {
        String text = def.stmt.toString();
        if (vendor == EDbVendor.dbvmssql && def.db != null && def.db.length() > 0) {
            return "USE " + def.db + "\nGO\n" + text;
        }
        return text;
    }

    /** Extract (or return the cached) base summary of ONE routine definition.
     *  The input must contain a single definition — feeding a multi-routine
     *  unit here reintroduces same-unit callee inlining; use
     *  {@link #extractAll(String)} for whole units. */
    public RoutineSummary extract(String routineDefinitionText) {
        RoutineSummary cached = cache.get(routineDefinitionText);
        if (cached != null) {
            return cached;
        }
        RoutineSummary summary = doExtract(routineDefinitionText);
        cache.put(routineDefinitionText, summary);
        return summary;
    }

    private RoutineSummary doExtract(String text) {
        RoutineCatalog catalog = new RoutineCatalog(vendor,
                Collections.singletonList(text),
                new HashMap<String, TStatementList>());
        RoutineCatalog.UnitIndex index = catalog.indexOf(text);
        if (index == null) {
            // Unit failed to parse — dlineage would swallow this into its
            // error list, but §2.6 reserves OPAQUE for exactly this case.
            return new RoutineSummary(null, null, null,
                    RoutineSummary.Completeness.OPAQUE,
                    Collections.singletonList("PARSE_FAILED"));
        }
        RoutineIdentity identity = identityOf(index);
        dataflow df = analyze(text);
        if (df == null) {
            return new RoutineSummary(identity, null, null,
                    RoutineSummary.Completeness.OPAQUE,
                    Collections.singletonList("ANALYSIS_FAILED"));
        }
        RelationGraph graph = RelationGraph.of(df);
        Closure closure = closeGraph(graph);
        Set<RoutineSummaryEdge> edges = closure.edges;
        CollectedBody body = collectCallSiteAsts(text);
        List<CallSiteRef> callSites = callSites(body.sites, df, graph, closure);
        List<RoutineSummary.RawCallSite> calls =
                new ArrayList<RoutineSummary.RawCallSite>();
        for (CallSiteRef site : callSites) {
            calls.add(site.getRaw());
        }
        List<String> reasons = new ArrayList<String>();
        if (df.getErrors() != null && !df.getErrors().isEmpty()) {
            reasons.add("ANALYSIS_ERRORS");
        }
        if (containsDynamicSql(text)) {
            reasons.add("DYNAMIC_SQL_UNRESOLVED");
        }
        if (!calls.isEmpty()) {
            // Base summaries never include callee effects (no-inline-callee):
            // any call site means the summary under-approximates until B3
            // composes it — a COMPLETE claim here would let B6 replace inline
            // analysis and silently lose the callee flow (codex-B2-r1 f6).
            reasons.add("CALLS_UNRESOLVED");
        }
        if (index != null && index.definitions.size()
                + index.memberDefinitions.size() > 1) {
            reasons.add("MULTIPLE_DEFINITIONS_IN_UNIT");
        }
        // Deferred-construct gates (codex-B2-r2 finding 2): the B2 endpoint
        // model has no RETURN / ref-cursor / package-global kinds, so any
        // routine whose effects can flow through one must be PARTIAL — a
        // COMPLETE claim would let B6 replace inline analysis and lose them.
        if (identity != null
                && (identity.getKind() == RoutineKind.FUNCTION
                        || identity.getKind() == RoutineKind.PACKAGE_MEMBER_FUNCTION)) {
            reasons.add("RETURN_ENDPOINT_DEFERRED");
        }
        if (identity != null) {
            for (String typeText : identity.getParamTypeNames()) {
                // non-identifier-compare: normalized declared-type text screen
                if (typeText.contains("CURSOR")) {
                    reasons.add("REF_CURSOR_DEFERRED");
                    break;
                }
            }
        }
        if (index != null && !index.memberDefinitions.isEmpty()) {
            reasons.add("PACKAGE_SCOPE_DEFERRED");
        }
        // A body-level RETURN with a value defers the routine for BOTH kinds
        // (T-SQL procedures return status values too — codex-B3-r2 finding
        // 4b), and its pseudo-resultset is indistinguishable from a genuine
        // SELECT result set in the model — suppress positional INSERT…EXEC
        // composition entirely (sound under-approximation; finding 4c).
        Map<String, List<String>> shapes = graph.terminalShapes;
        if (body.returnsValue) {
            if (!reasons.contains("RETURN_ENDPOINT_DEFERRED")) {
                reasons.add("RETURN_ENDPOINT_DEFERRED");
            }
            shapes = Collections.emptyMap();
        }
        RoutineSummary.Completeness completeness = reasons.isEmpty()
                ? RoutineSummary.Completeness.COMPLETE
                : RoutineSummary.Completeness.PARTIAL;
        return new RoutineSummary(identity, edges, calls, callSites,
                shapes, completeness, reasons);
    }

    // ------------------------------------------------------------------
    // Graph model shared by the worklist closure and (in tests) the naive
    // differential implementation.
    // ------------------------------------------------------------------

    /** The analyzed relation graph with boundary classification. */
    static final class RelationGraph {
        /** node key -> outgoing (targetKey, "1" when the hop is fdr) pairs. */
        final Map<String, List<String[]>> out = new HashMap<String, List<String[]>>();
        /** node key -> boundary endpoint (absent for interior nodes). */
        final Map<String, Endpoint> boundary = new HashMap<String, Endpoint>();
        /** interior function-hop display name per node (absent when none). */
        final Map<String, String> functionName = new HashMap<String, String>();
        final Set<String> nodes = new LinkedHashSet<String>();
        /** B3: terminal result-set qualified display name -> its columns in
         *  projection order (for positional INSERT…EXEC composition). */
        final Map<String, List<String>> terminalShapes =
                new LinkedHashMap<String, List<String>>();

        static RelationGraph of(dataflow df) {
            RelationGraph g = new RelationGraph();
            Map<String, table> parentById = new HashMap<String, table>();
            Map<String, EndpointKind> kindByParent = new HashMap<String, EndpointKind>();
            Set<String> resultsetIds = new HashSet<String>();
            Map<String, List<String>> terminalNameOccurrences =
                    new HashMap<String, List<String>>();
            if (df.getTables() != null) {
                for (table t : df.getTables()) {
                    parentById.put(t.getId(), t);
                    String name = t.getName() == null ? "" : t.getName();
                    kindByParent.put(t.getId(), name.startsWith("#")
                            ? EndpointKind.TEMP_COLUMN : EndpointKind.TABLE_COLUMN);
                }
            }
            if (df.getVariables() != null) {
                for (table v : df.getVariables()) {
                    parentById.put(v.getId(), v);
                    String subType = v.getSubType() == null ? ""
                            : v.getSubType().toLowerCase(Locale.ROOT);
                    // non-identifier-compare: subType is a fixed mode-token vocabulary
                    boolean formal = subType.equals("in") || subType.equals("out")
                            || subType.equals("output") || subType.equals("inout")
                            || subType.equals("argument");
                    if (formal) {
                        kindByParent.put(v.getId(), EndpointKind.FORMAL);
                    }
                    // locals stay interior (absent from kindByParent)
                }
            }
            List<String> rsIdOrder = new ArrayList<String>();
            if (df.getResultsets() != null) {
                for (table rs : df.getResultsets()) {
                    parentById.put(rs.getId(), rs);
                    resultsetIds.add(rs.getId());
                    rsIdOrder.add(rs.getId());
                }
            }
            // Edges + node registration.
            Set<String> parentsWithOutgoing = new HashSet<String>();
            if (df.getRelationships() != null) {
                for (relationship rel : df.getRelationships()) {
                    String type = rel.getType();
                    // non-identifier-compare: relationship type token
                    boolean fdd = "fdd".equals(type);
                    boolean fdr = "fdr".equals(type);
                    if (!fdd && !fdr) {
                        continue;
                    }
                    if (rel.getTarget() == null || rel.getSources() == null) {
                        continue;
                    }
                    String targetKey = key(rel.getTarget().getParent_id(),
                            rel.getTarget().getColumn());
                    for (sourceColumn src : rel.getSources()) {
                        String sourceKey = key(src.getParent_id(), src.getColumn());
                        g.nodes.add(sourceKey);
                        g.nodes.add(targetKey);
                        List<String[]> hops = g.out.get(sourceKey);
                        if (hops == null) {
                            hops = new ArrayList<String[]>();
                            g.out.put(sourceKey, hops);
                        }
                        hops.add(new String[] { targetKey, fdr ? "1" : "0" });
                        parentsWithOutgoing.add(src.getParent_id());
                    }
                }
            }
            // §4.1 ROW-dominates across the quotient: an fdr edge into a
            // RESULTSET's synthetic RelationRows column is a row gate on that
            // statement occurrence — fan it out as fdr hops to the sibling
            // columns so a filter composes into downstream fdr edges (the
            // design's base.f → t rows → c example). RESULTSET parents only:
            // resultset ids are occurrence-scoped (one per statement), while
            // physical-table models are REUSED across statements, so fanning
            // out on a table parent would smear one statement's condition
            // onto unrelated statements' flows (codex-B2-r1 finding 4). A
            // table's row gate stays visible as a boundary edge targeting
            // the table's own RelationRows node instead.
            List<String> relationRowsNodes = new ArrayList<String>();
            for (String node : g.nodes) {
                int sep = node.indexOf(' ');
                // non-identifier-compare: RelationRows is dlineage's fixed synthetic column name
                if ("RelationRows".equals(node.substring(sep + 1))
                        && resultsetIds.contains(node.substring(0, sep))) {
                    relationRowsNodes.add(node);
                }
            }
            for (String rowsNode : relationRowsNodes) {
                String parentId = rowsNode.substring(0, rowsNode.indexOf(' '));
                for (String sibling : new ArrayList<String>(g.nodes)) {
                    if (sibling.equals(rowsNode)
                            || !sibling.startsWith(parentId + " ")) {
                        continue;
                    }
                    List<String[]> hops = g.out.get(rowsNode);
                    if (hops == null) {
                        hops = new ArrayList<String[]>();
                        g.out.put(rowsNode, hops);
                    }
                    hops.add(new String[] { sibling, "1" });
                }
            }
            // Terminal-resultset duplicate-name ordinals in OCCURRENCE order
            // (df.getResultsets() order — codex-B2-r2: lexicographic id sort
            // is not occurrence order and both differential sides would have
            // repeated the mistake).
            for (String id : rsIdOrder) {
                if (parentsWithOutgoing.contains(id)) {
                    continue;
                }
                table rs = parentById.get(id);
                if (rs == null || rs.isFunction()) {
                    continue;
                }
                String name = rs.getName() == null ? id : rs.getName();
                List<String> ids = terminalNameOccurrences.get(name);
                if (ids == null) {
                    ids = new ArrayList<String>();
                    terminalNameOccurrences.put(name, ids);
                }
                ids.add(id);
            }
            // Boundary classification per node.
            for (String node : g.nodes) {
                int sep = node.indexOf(' ');
                String parentId = node.substring(0, sep);
                String column = node.substring(sep + 1);
                EndpointKind kind = kindByParent.get(parentId);
                table parent = parentById.get(parentId);
                String parentName = parent == null || parent.getName() == null
                        ? parentId : parent.getName();
                if (kind != null) {
                    g.boundary.put(node, new Endpoint(kind, parentName, column));
                } else if (resultsetIds.contains(parentId)) {
                    boolean isFunction = parent != null && parent.isFunction();
                    if (isFunction) {
                        g.functionName.put(node, parentName);
                    } else if (!parentsWithOutgoing.contains(parentId)) {
                        // Terminal resultset: no column of it feeds anything —
                        // this is a routine OUTPUT result set (§2.2 boundary).
                        // Duplicate display names get "#k" by occurrence order.
                        List<String> dup = terminalNameOccurrences.get(parentName);
                        String qualified = dup != null && dup.size() > 1
                                ? parentName + "#" + dup.indexOf(parentId)
                                : parentName;
                        g.boundary.put(node, new Endpoint(
                                EndpointKind.RESULT_SET_COLUMN, qualified, column));
                        if (!g.terminalShapes.containsKey(qualified)) {
                            List<String> shape = new ArrayList<String>();
                            if (parent != null && parent.getColumns() != null) {
                                for (column c : parent.getColumns()) {
                                    // non-identifier-compare: RelationRows is dlineage's fixed synthetic column name
                                    if ("RelationRows".equals(c.getName())
                                            || "system".equals(c.getSource())) {
                                        continue;
                                    }
                                    shape.add(c.getName());
                                }
                            }
                            g.terminalShapes.put(qualified, shape);
                        }
                    }
                    // Non-terminal, non-function resultsets stay interior.
                }
            }
            return g;
        }

        static String key(String parentId, String column) {
            return (parentId == null ? "" : parentId) + ' '
                    + (column == null ? "" : column);
        }
    }

    /** Result of {@link #closeGraph}: summary edges plus the full per-node
     *  reach map (B3 consumes the latter for call-site actual reach). */
    static final class Closure {
        final Map<String, Map<String, PathAttr>> reach;
        final Set<RoutineSummaryEdge> edges;

        Closure(Map<String, Map<String, PathAttr>> reach,
                Set<RoutineSummaryEdge> edges) {
            this.reach = reach;
            this.edges = edges;
        }
    }

    /** B2-compatible view of {@link #closeGraph}: the summary edges only. */
    static Set<RoutineSummaryEdge> close(RelationGraph g) {
        return closeGraph(g).edges;
    }

    /**
     * Worklist closure: per node, the map boundary-source-key →
     * {reachable via fdd-only path, reachable via fdr-bearing path,
     * functions on value paths}. Monotone joins ⇒ convergence.
     *
     * <p>Propagation continues THROUGH boundary nodes: a path formal → table
     * → formal is two summary edges AND the transitive pair, matching the
     * inline engine's shared-model transitivity.
     */
    static Closure closeGraph(RelationGraph g) {
        Map<String, Map<String, PathAttr>> reach =
                new HashMap<String, Map<String, PathAttr>>();
        Deque<String> worklist = new ArrayDeque<String>();
        for (String node : g.nodes) {
            if (g.boundary.containsKey(node)) {
                Map<String, PathAttr> self = new HashMap<String, PathAttr>();
                PathAttr attr = new PathAttr();
                attr.valueOnly = true;
                self.put(node, attr);
                reach.put(node, self);
                worklist.push(node);
            }
        }
        while (!worklist.isEmpty()) {
            String node = worklist.pop();
            Map<String, PathAttr> nodeReach = reach.get(node);
            if (nodeReach == null) {
                continue;
            }
            List<String[]> hops = g.out.get(node);
            if (hops == null) {
                continue;
            }
            for (String[] hop : hops) {
                String target = hop[0];
                boolean hopFdr = "1".equals(hop[1]);
                String targetFunction = g.functionName.get(target);
                Map<String, PathAttr> targetReach = reach.get(target);
                if (targetReach == null) {
                    targetReach = new HashMap<String, PathAttr>();
                    reach.put(target, targetReach);
                }
                boolean changed = false;
                for (Map.Entry<String, PathAttr> e : nodeReach.entrySet()) {
                    PathAttr in = e.getValue();
                    PathAttr outAttr = targetReach.get(e.getKey());
                    if (outAttr == null) {
                        outAttr = new PathAttr();
                        targetReach.put(e.getKey(), outAttr);
                    }
                    boolean nvo = in.valueOnly && !hopFdr;
                    boolean nfr = in.withFdr || hopFdr;
                    if (nvo && !outAttr.valueOnly) {
                        outAttr.valueOnly = true;
                        changed = true;
                    }
                    if (nfr && !outAttr.withFdr) {
                        outAttr.withFdr = true;
                        changed = true;
                    }
                    if (nvo) {
                        Set<String> fns = new TreeSet<String>(in.functions);
                        if (targetFunction != null) {
                            fns.add(targetFunction);
                        }
                        if (!outAttr.functions.containsAll(fns)) {
                            outAttr.functions.addAll(fns);
                            changed = true;
                        }
                    }
                }
                if (changed) {
                    worklist.push(target);
                }
            }
        }
        Set<RoutineSummaryEdge> edges = new LinkedHashSet<RoutineSummaryEdge>();
        for (Map.Entry<String, Map<String, PathAttr>> e : reach.entrySet()) {
            Endpoint target = g.boundary.get(e.getKey());
            if (target == null) {
                continue;
            }
            for (Map.Entry<String, PathAttr> s : e.getValue().entrySet()) {
                if (s.getKey().equals(e.getKey())) {
                    continue; // self-seed
                }
                Endpoint source = g.boundary.get(s.getKey());
                if (source == null) {
                    continue;
                }
                PathAttr attr = s.getValue();
                if (attr.valueOnly) {
                    edges.add(new RoutineSummaryEdge(source, target, "fdd",
                            attr.functions));
                }
                if (attr.withFdr) {
                    edges.add(new RoutineSummaryEdge(source, target, "fdr", null));
                }
            }
        }
        return new Closure(reach, edges);
    }

    /**
     * B3: forward reach from ONE node (a call-site OUT actual) to the graph's
     * boundary endpoints. Same monotone worklist as {@link #closeGraph}, but
     * seeded at an arbitrary (typically interior) node — the closure's own
     * reach map is seeded only at boundaries, so this direction needs its own
     * pass. Returns boundary endpoint → path attributes.
     */
    static Map<Endpoint, PathAttr> forwardReach(RelationGraph g, String seed) {
        Map<Endpoint, PathAttr> result = new LinkedHashMap<Endpoint, PathAttr>();
        for (Map.Entry<String, PathAttr> e : forwardReachAll(g, seed).entrySet()) {
            Endpoint boundary = g.boundary.get(e.getKey());
            if (boundary != null) {
                result.put(boundary, e.getValue());
            }
        }
        return result;
    }

    /** Forward reach over ALL nodes (interior included) — the intra-caller
     *  bridge for call-to-call composition needs interior locals
     *  (codex-B3-r1 finding 5). */
    static Map<String, PathAttr> forwardReachAll(RelationGraph g, String seed) {
        Map<String, PathAttr> attrs = new HashMap<String, PathAttr>();
        PathAttr self = new PathAttr();
        self.valueOnly = true;
        attrs.put(seed, self);
        Deque<String> worklist = new ArrayDeque<String>();
        worklist.push(seed);
        while (!worklist.isEmpty()) {
            String node = worklist.pop();
            PathAttr in = attrs.get(node);
            List<String[]> hops = g.out.get(node);
            if (hops == null || in == null) {
                continue;
            }
            for (String[] hop : hops) {
                String target = hop[0];
                boolean hopFdr = "1".equals(hop[1]);
                PathAttr out = attrs.get(target);
                if (out == null) {
                    out = new PathAttr();
                    attrs.put(target, out);
                }
                boolean changed = false;
                boolean nvo = in.valueOnly && !hopFdr;
                boolean nfr = in.withFdr || hopFdr;
                if (nvo && !out.valueOnly) {
                    out.valueOnly = true;
                    changed = true;
                }
                if (nfr && !out.withFdr) {
                    out.withFdr = true;
                    changed = true;
                }
                if (changed) {
                    worklist.push(target);
                }
            }
        }
        return attrs;
    }

    /** Monotone per-(source,node) path attributes. */
    static final class PathAttr {
        boolean valueOnly;
        boolean withFdr;
        final Set<String> functions = new TreeSet<String>();
    }

    // ------------------------------------------------------------------
    // Support: isolated analysis, identity, raw call sites.
    // ------------------------------------------------------------------

    private dataflow analyze(String text) {
        try {
            Option opt = new Option();
            opt.setVendor(vendor);
            opt.setOutput(false);
            opt.setShowJoin(true);
            // SHADOW analyzers run identity-first pools: package overloads in
            // a whole-package slice keep separated formal/cursor pools
            // (codex-B3-r1 finding 7 — the mode must actually be exercised).
            opt.setIdentityFirstVariablePools(true);
            // Base-summary edges currently have no per-edge dynamic-site
            // provenance. Never flatten an inner dynamic-SQL relationship
            // into that static edge set: an incomplete LEGACY fold can name
            // the wrong source/target yet would otherwise look identical to
            // a proven static relationship during call-site composition.
            opt.setAnalyzeDynamicSql(false);
            DataFlowAnalyzer analyzer = new DataFlowAnalyzer(text, opt);
            analyzer.generateDataFlow();
            return analyzer.getDataFlow();
        } catch (RuntimeException ex) {
            return null;
        } catch (StackOverflowError err) {
            return null;
        }
    }

    private static RoutineIdentity identityOf(RoutineCatalog.UnitIndex index) {
        if (!index.definitions.isEmpty()) {
            return index.definitions.get(0).identity;
        }
        if (!index.memberDefinitions.isEmpty()) {
            return index.memberDefinitions.get(0).identity;
        }
        return null;
    }

    // ------------------------------------------------------------------
    // B3: call sites with AST actuals + caller-side boundary reach.
    // ------------------------------------------------------------------

    /** AST-side view of one call site before model reach is attached. */
    private static final class CallSiteAst {
        final String rawName;
        final TCustomSqlStatement stmt;
        final List<CallSiteRef.Actual> actuals;
        final gudusoft.gsqlparser.stmt.TInsertSqlStatement enclosingInsert;

        CallSiteAst(String rawName, TCustomSqlStatement stmt,
                List<CallSiteRef.Actual> actuals,
                gudusoft.gsqlparser.stmt.TInsertSqlStatement enclosingInsert) {
            this.rawName = rawName;
            this.stmt = stmt;
            this.actuals = actuals;
            this.enclosingInsert = enclosingInsert;
        }
    }

    /** Everything one body walk collects: call sites + RETURN-with-value. */
    private static final class CollectedBody {
        final List<CallSiteAst> sites = new ArrayList<CallSiteAst>();
        boolean returnsValue;
    }

    /** AST-level facts shared by BOTH CallSiteRef construction paths (the
     *  reach-enriched extractor path and the AST-only B0 contract path —
     *  codex-B3-r2 finding 4a): INSERT…EXEC column list / missing-list flag
     *  and the {@code @ret = EXEC} status target. */
    private void enrichAstFacts(CallSiteRef ref, CallSiteAst ast) {
        if (ast.enclosingInsert != null) {
            if (ast.enclosingInsert.getColumnList() != null
                    && ast.enclosingInsert.getColumnList().size() > 0) {
                List<TObjectName> columnNames = new ArrayList<TObjectName>();
                for (int i = 0; i < ast.enclosingInsert.getColumnList().size(); i++) {
                    columnNames.add(ast.enclosingInsert.getColumnList()
                            .getObjectName(i));
                }
                ref.setInsertColumnNames(columnNames);
            } else {
                // No explicit column list: ordinals are unknowable
                // without a catalog — the binder reports PARTIAL.
                ref.setInsertWithoutColumnList(true);
            }
        }
        if (ast.stmt instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlExecute) {
            ref.setReturnStatusTarget(
                    ((gudusoft.gsqlparser.stmt.mssql.TMssqlExecute) ast.stmt)
                            .getReturnStatus());
        }
    }

    /** Collect the slice's call sites and attach the caller-side reach the
     *  SHADOW composition step needs (design §2.3): per IN actual, the caller
     *  boundary endpoints feeding it; per OUT actual, the caller boundary
     *  endpoints its value reaches downstream. */
    private List<CallSiteRef> callSites(List<CallSiteAst> asts, dataflow df,
            RelationGraph g, Closure closure) {
        List<CallSiteRef> result = new ArrayList<CallSiteRef>();
        List<table> variables = df.getVariables() == null
                ? Collections.<table>emptyList() : df.getVariables();
        List<table> tables = df.getTables() == null
                ? Collections.<table>emptyList() : df.getTables();
        for (CallSiteAst ast : asts) {
            Map<Integer, Set<Endpoint>> inFdd = new LinkedHashMap<Integer, Set<Endpoint>>();
            Map<Integer, Set<Endpoint>> inFdr = new LinkedHashMap<Integer, Set<Endpoint>>();
            Map<Integer, Set<Endpoint>> outFdd = new LinkedHashMap<Integer, Set<Endpoint>>();
            Map<Integer, Set<Endpoint>> outFdr = new LinkedHashMap<Integer, Set<Endpoint>>();
            Map<Integer, Set<String>> inNodes = new LinkedHashMap<Integer, Set<String>>();
            Map<Integer, Map<String, Integer>> outReachNodes =
                    new LinkedHashMap<Integer, Map<String, Integer>>();
            for (CallSiteRef.Actual actual : ast.actuals) {
                if (actual.isLiteral() || actual.isDefaultToken()) {
                    continue; // no source binds (inline parity / declared default)
                }
                List<TObjectName> leafs = actual.getBareReference() != null
                        ? Collections.singletonList(actual.getBareReference())
                        : actual.getLeafReferences();
                for (TObjectName leaf : leafs) {
                    String node = nodeKeyForLeaf(leaf, variables, tables);
                    if (node == null) {
                        continue;
                    }
                    Set<String> ownNodes = inNodes.get(actual.getPosition());
                    if (ownNodes == null) {
                        ownNodes = new LinkedHashSet<String>();
                        inNodes.put(actual.getPosition(), ownNodes);
                    }
                    ownNodes.add(node);
                    Endpoint selfBoundary = g.boundary.get(node);
                    if (selfBoundary != null) {
                        addEndpoint(inFdd, actual.getPosition(), selfBoundary);
                    }
                    Map<String, PathAttr> reach = closure.reach.get(node);
                    if (reach != null) {
                        for (Map.Entry<String, PathAttr> e : reach.entrySet()) {
                            if (e.getKey().equals(node)) {
                                continue;
                            }
                            Endpoint source = g.boundary.get(e.getKey());
                            if (source == null) {
                                continue;
                            }
                            if (e.getValue().valueOnly) {
                                addEndpoint(inFdd, actual.getPosition(), source);
                            }
                            if (e.getValue().withFdr) {
                                addEndpoint(inFdr, actual.getPosition(), source);
                            }
                        }
                    }
                    // Forward reach for potential OUT targets: only bare
                    // actuals qualify (an expression is never a writable
                    // lvalue — the binder drops those with a diagnostic).
                    // Interior nodes are kept too: they anchor the
                    // intra-caller bridge for call-to-call composition.
                    if (actual.getBareReference() != null) {
                        Map<String, Integer> nodeFlavors =
                                outReachNodes.get(actual.getPosition());
                        if (nodeFlavors == null) {
                            nodeFlavors = new LinkedHashMap<String, Integer>();
                            outReachNodes.put(actual.getPosition(), nodeFlavors);
                        }
                        for (Map.Entry<String, PathAttr> e
                                : forwardReachAll(g, node).entrySet()) {
                            int bits = (e.getValue().valueOnly ? 1 : 0)
                                    | (e.getValue().withFdr ? 2 : 0);
                            Integer prior = nodeFlavors.get(e.getKey());
                            nodeFlavors.put(e.getKey(),
                                    prior == null ? bits : (prior | bits));
                            Endpoint boundary = g.boundary.get(e.getKey());
                            if (boundary == null) {
                                continue;
                            }
                            if (e.getValue().valueOnly) {
                                addEndpoint(outFdd, actual.getPosition(), boundary);
                            }
                            if (e.getValue().withFdr) {
                                addEndpoint(outFdr, actual.getPosition(), boundary);
                            }
                        }
                    }
                }
            }
            List<Endpoint> insertTargets = insertTargetsOf(ast, tables);
            int argCount = ast.actuals.size();
            CallSiteRef ref = new CallSiteRef(
                    new RoutineSummary.RawCallSite(ast.rawName, argCount),
                    ast.stmt, ast.actuals, insertTargets,
                    inFdd, inFdr, outFdd, outFdr);
            ref.setInNodes(inNodes);
            ref.setOutReachNodes(outReachNodes);
            enrichAstFacts(ref, ast);
            result.add(ref);
        }
        return result;
    }

    private static void addEndpoint(Map<Integer, Set<Endpoint>> map, int position,
            Endpoint endpoint) {
        Set<Endpoint> set = map.get(position);
        if (set == null) {
            set = new LinkedHashSet<Endpoint>();
            map.put(position, set);
        }
        set.add(endpoint);
    }

    /** INSERT…EXEC positional targets: the INSERT's explicit column list
     *  resolved against the analyzed target table. Null when the call is not
     *  INSERT-consumed or the column list is absent (the binder reports the
     *  latter as PARTIAL — ordinals are never guessed). */
    private List<Endpoint> insertTargetsOf(CallSiteAst ast, List<table> tables) {
        if (ast.enclosingInsert == null
                || ast.enclosingInsert.getColumnList() == null
                || ast.enclosingInsert.getColumnList().size() == 0
                || ast.enclosingInsert.getTargetTable() == null) {
            return null;
        }
        String targetName = ast.enclosingInsert.getTargetTable().toString();
        String display = targetName;
        for (table t : tables) {
            if (t.getName() != null && sameQualifiedTable(targetName, t.getName())) {
                display = t.getName();
                break;
            }
        }
        List<Endpoint> targets = new ArrayList<Endpoint>();
        // #tmp targets are TEMP endpoints — the same classification the
        // graph builder applies to '#'-prefixed tables (codex-B3-r3 f5).
        List<String> displayParts = SQLUtil.parseNames(display);
        String displaySimple = displayParts.isEmpty()
                ? display : displayParts.get(displayParts.size() - 1);
        EndpointKind kind = displaySimple.startsWith("#")
                ? EndpointKind.TEMP_COLUMN : EndpointKind.TABLE_COLUMN;
        for (int i = 0; i < ast.enclosingInsert.getColumnList().size(); i++) {
            targets.add(new Endpoint(kind, display,
                    ast.enclosingInsert.getColumnList().getObjectName(i).toString()));
        }
        return targets;
    }

    /** Suffix-tolerant qualified table-name comparison (call text vs model
     *  display name), segment-by-segment through the canonical facade. */
    private boolean sameQualifiedTable(String a, String b) {
        List<String> pa = SQLUtil.parseNames(a);
        List<String> pb = SQLUtil.parseNames(b);
        int n = Math.min(pa.size(), pb.size());
        if (n == 0) {
            return false;
        }
        for (int i = 1; i <= n; i++) {
            if (!SQLUtil.sameName(vendor, ESQLDataObjectType.dotTable,
                    pa.get(pa.size() - i), pb.get(pb.size() - i))) {
                return false;
            }
        }
        return true;
    }

    /** Model node key for one actual leaf reference: a declared variable
     *  (formal or local) matched by name, else a qualified table column.
     *  Null when the leaf matches nothing the analyzed model knows. */
    private String nodeKeyForLeaf(TObjectName leaf, List<table> variables,
            List<table> tables) {
        String text = leaf.toString();
        List<String> parts = SQLUtil.parseNames(text);
        String simple = parts.isEmpty() ? text : parts.get(parts.size() - 1);
        for (table v : variables) {
            if (v.getName() == null) {
                continue;
            }
            // A USE-re-anchored slice qualifies variable display names
            // (e.g. "Db.dbo.@v") — match on the LAST segment, not the whole
            // name (codex-B3-r1 finding 2).
            List<String> varParts = SQLUtil.parseNames(v.getName());
            String varSimple = varParts.isEmpty()
                    ? v.getName() : varParts.get(varParts.size() - 1);
            if (SQLUtil.sameName(vendor, ESQLDataObjectType.dotColumn,
                    simple, varSimple)) {
                String columnName = v.getColumns() != null && !v.getColumns().isEmpty()
                        ? v.getColumns().get(0).getName() : v.getName();
                return RelationGraph.key(v.getId(), columnName);
            }
        }
        if (parts.size() >= 2) {
            String tablePart = text.substring(0, text.lastIndexOf('.'));
            for (table t : tables) {
                if (t.getName() != null && sameQualifiedTable(tablePart, t.getName())) {
                    return RelationGraph.key(t.getId(), simple);
                }
            }
        }
        return null;
    }

    /** AST-only call sites of a statement text (no model-side reach) — the
     *  B0 contract entry of {@link CatalogRoutineCallBinder} binds these.
     *  Carries the same AST-level facts as the enriched path (INSERT…EXEC
     *  columns, return-status target — codex-B3-r2 finding 4a). */
    List<CallSiteRef> callSitesOfStatementText(String text) {
        List<CallSiteRef> result = new ArrayList<CallSiteRef>();
        for (CallSiteAst ast : collectCallSiteAsts(text).sites) {
            CallSiteRef ref = new CallSiteRef(
                    new RoutineSummary.RawCallSite(ast.rawName, ast.actuals.size()),
                    ast.stmt, ast.actuals, null, null, null, null, null);
            enrichAstFacts(ref, ast);
            result.add(ref);
        }
        return result;
    }

    /** Parse the slice and collect its call-site statements with actuals,
     *  plus body-level RETURN-with-value detection. Best-effort: a parse
     *  crash leaves the result empty (summaries stay usable; completeness
     *  gating happens on the analysis side). */
    private CollectedBody collectCallSiteAsts(String text) {
        CollectedBody body = new CollectedBody();
        List<CallSiteAst> sites = body.sites;
        try {
            gudusoft.gsqlparser.TGSqlParser parser =
                    new gudusoft.gsqlparser.TGSqlParser(vendor);
            parser.sqltext = text;
            if (parser.parse() != 0) {
                return body;
            }
            Deque<TCustomSqlStatement> stack = new ArrayDeque<TCustomSqlStatement>();
            Set<TCustomSqlStatement> visited = Collections.newSetFromMap(
                    new java.util.IdentityHashMap<TCustomSqlStatement, Boolean>());
            Map<TCustomSqlStatement, gudusoft.gsqlparser.stmt.TInsertSqlStatement>
                    insertOf = new java.util.IdentityHashMap<TCustomSqlStatement,
                            gudusoft.gsqlparser.stmt.TInsertSqlStatement>();
            for (int i = 0; i < parser.sqlstatements.size(); i++) {
                stack.push(parser.sqlstatements.get(i));
            }
            while (!stack.isEmpty()) {
                TCustomSqlStatement stmt = stack.pop();
                if (!visited.add(stmt)) {
                    continue; // getStatements/getBodyStatements can overlap
                }
                if (stmt instanceof gudusoft.gsqlparser.stmt.TInsertSqlStatement) {
                    gudusoft.gsqlparser.stmt.TInsertSqlStatement insert =
                            (gudusoft.gsqlparser.stmt.TInsertSqlStatement) stmt;
                    if (insert.getExecuteStmt() != null) {
                        insertOf.put(insert.getExecuteStmt(), insert);
                        stack.push(insert.getExecuteStmt());
                    }
                } else if (stmt instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlExecute) {
                    gudusoft.gsqlparser.stmt.mssql.TMssqlExecute exec =
                            (gudusoft.gsqlparser.stmt.mssql.TMssqlExecute) stmt;
                    // getSqlText() != null is dynamic EXEC('...') — that stays
                    // with the dynamic-SQL machinery, not routine binding.
                    if (exec.getModuleName() != null && exec.getSqlText() == null) {
                        String rawName = exec.getModuleName().toString();
                        // sp_executesql/sp_execute_external_script are dynamic
                        // executors, not static callees. EXEC @module_var is
                        // indirect and cannot bind from the variable spelling.
                        if (!isDynamicExecutorName(rawName)
                                && !isIndirectMssqlExecute(rawName)) {
                            // Recover the ;N group the parser drops from the
                            // AST name (numbered procedures — codex-B3-r1 f6).
                            String group = RoutineCatalog.numberedGroupAfter(
                                    exec.getModuleName());
                            if (group != null) {
                                rawName = rawName + ";" + group;
                            }
                            sites.add(new CallSiteAst(rawName,
                                    exec, mssqlActuals(exec), insertOf.get(exec)));
                        }
                    }
                } else if (stmt instanceof gudusoft.gsqlparser.stmt.TCallStatement) {
                    gudusoft.gsqlparser.stmt.TCallStatement call =
                            (gudusoft.gsqlparser.stmt.TCallStatement) stmt;
                    if (call.getRoutineName() != null
                            && !isDynamicExecutorName(
                                    call.getRoutineName().toString())) {
                        sites.add(new CallSiteAst(
                                call.getRoutineName().toString(), call,
                                expressionActuals(call.getArgs()), null));
                    }
                } else if (stmt instanceof gudusoft.gsqlparser.stmt.oracle.TBasicStmt) {
                    // Oracle bare procedure calls inside PL/SQL bodies parse as
                    // expression statements, NOT TCallStatement — missing them
                    // let a calling summary claim COMPLETE (B2 gap, fixed here).
                    gudusoft.gsqlparser.stmt.oracle.TBasicStmt basic =
                            (gudusoft.gsqlparser.stmt.oracle.TBasicStmt) stmt;
                    TExpression expr = basic.getExpr();
                    if (expr != null
                            && expr.getExpressionType() == EExpressionType.function_t
                            && expr.getFunctionCall() != null
                            && expr.getFunctionCall().getFunctionName() != null) {
                        TFunctionCall fc = expr.getFunctionCall();
                        String rawName = fc.getFunctionName().toString();
                        if (!isDynamicExecutorName(rawName)) {
                            sites.add(new CallSiteAst(rawName, basic,
                                    expressionActuals(fc.getArgs()), null));
                        }
                    } else if (expr != null
                            && expr.getExpressionType() == EExpressionType.simple_object_name_t
                            && expr.getObjectOperand() != null) {
                        sites.add(new CallSiteAst(expr.getObjectOperand().toString(),
                                basic, new ArrayList<CallSiteRef.Actual>(), null));
                    }
                } else if (stmt instanceof gudusoft.gsqlparser.stmt.mssql.TMssqlReturn) {
                    if (((gudusoft.gsqlparser.stmt.mssql.TMssqlReturn) stmt)
                            .getReturnExpr() != null) {
                        body.returnsValue = true;
                    }
                } else if (stmt instanceof gudusoft.gsqlparser.stmt.TReturnStmt) {
                    if (((gudusoft.gsqlparser.stmt.TReturnStmt) stmt)
                            .getExpression() != null) {
                        body.returnsValue = true;
                    }
                }
                TStatementList children = stmt.getStatements();
                if (children != null) {
                    for (int i = 0; i < children.size(); i++) {
                        stack.push(children.get(i));
                    }
                }
                if (stmt instanceof gudusoft.gsqlparser.stmt.TBlockSqlStatement) {
                    TStatementList bodyStatements =
                            ((gudusoft.gsqlparser.stmt.TBlockSqlStatement) stmt)
                                    .getBodyStatements();
                    if (bodyStatements != null) {
                        for (int i = 0; i < bodyStatements.size(); i++) {
                            stack.push(bodyStatements.get(i));
                        }
                    }
                }
            }
        } catch (RuntimeException ex) {
            // call collection is best-effort; summaries stay usable
        }
        return body;
    }

    /** Dynamic executor APIs carry generated SQL, not a statically named
     *  routine call that the summary binder may resolve against user/catalog
     *  definitions. Comparison goes through the vendor identifier facade so
     *  quoting/case cannot reopen the frozen-call inventory. */
    private boolean isDynamicExecutorName(String rawName) {
        if (rawName == null) {
            return false;
        }
        if (vendor == EDbVendor.dbvmssql) {
            List<String> parts = SQLUtil.parseNames(rawName);
            String simple = parts.isEmpty()
                    ? rawName : parts.get(parts.size() - 1);
            return SQLUtil.sameName(vendor, ESQLDataObjectType.dotProcedure,
                    simple, "sp_executesql")
                    || SQLUtil.sameName(vendor,
                            ESQLDataObjectType.dotProcedure, simple,
                            "sp_execute_external_script");
        }
        if (vendor == EDbVendor.dbvoracle) {
            return SQLUtil.compareIdentifier(vendor,
                    ESQLDataObjectType.dotProcedure,
                    rawName, "DBMS_SQL.PARSE")
                    || SQLUtil.compareIdentifier(vendor,
                            ESQLDataObjectType.dotProcedure,
                            rawName, "SYS.DBMS_SQL.PARSE");
        }
        return false;
    }

    /** SQL Server's unquoted {@code EXEC @name} is an indirect procedure
     *  invocation. The variable spelling is not the callee identity (while
     *  {@code EXEC [@name]} may legitimately call a quoted static routine). */
    private static boolean isIndirectMssqlExecute(String rawName) {
        return rawName != null && rawName.trim().startsWith("@");
    }

    /** Actuals of a T-SQL EXEC: named/positional, OUTPUT flag, value shape. */
    private List<CallSiteRef.Actual> mssqlActuals(
            gudusoft.gsqlparser.stmt.mssql.TMssqlExecute exec) {
        List<CallSiteRef.Actual> actuals = new ArrayList<CallSiteRef.Actual>();
        if (exec.getParameters() == null) {
            return actuals;
        }
        for (int i = 0; i < exec.getParameters().size(); i++) {
            gudusoft.gsqlparser.nodes.TExecParameter param =
                    exec.getParameters().getExecParameter(i);
            if (param == null) {
                continue;
            }
            String named = param.getParameterName() == null
                    ? null : param.getParameterName().toString();
            boolean out = param.getParameterMode() == TBaseType.parameter_mode_out
                    || param.getParameterMode() == TBaseType.parameter_mode_output;
            actuals.add(actualOf(i, named, out, param.getParameterValue()));
        }
        return actuals;
    }

    /** Actuals of an expression-list call (Oracle CALL / bare PL/SQL call):
     *  positional, with {@code formal => value} named notation unwrapped. */
    private List<CallSiteRef.Actual> expressionActuals(
            gudusoft.gsqlparser.nodes.TExpressionList args) {
        List<CallSiteRef.Actual> actuals = new ArrayList<CallSiteRef.Actual>();
        if (args == null) {
            return actuals;
        }
        for (int i = 0; i < args.size(); i++) {
            TExpression arg = args.getExpression(i);
            if (arg == null) {
                continue;
            }
            String named = null;
            TExpression value = arg;
            if (arg.getExpressionType() == EExpressionType.ref_arrow_t
                    && arg.getLeftOperand() != null && arg.getRightOperand() != null) {
                named = arg.getLeftOperand().toString();
                value = arg.getRightOperand();
            }
            // PL/SQL has no call-site OUT marker; the declared mode decides.
            actuals.add(actualOf(i, named, false, value));
        }
        return actuals;
    }

    /** Classify one actual value expression: literal / bare reference /
     *  expression with leaf fan-in. */
    private CallSiteRef.Actual actualOf(int position, String named, boolean out,
            TExpression value) {
        if (value == null) {
            return new CallSiteRef.Actual(position, named, out, null, null, null, false);
        }
        EExpressionType type = value.getExpressionType();
        // Bare keyword actuals parse as source tokens: DEFAULT means "use
        // the declared default" (distinct kind — compatibility requires
        // one); NULL is a plain literal (codex-B3-r2 finding 11).
        if (type == EExpressionType.simple_source_token_t) {
            String token = value.toString().trim();
            if ("DEFAULT".equalsIgnoreCase(token)) { // non-identifier-compare: DEFAULT keyword token
                return new CallSiteRef.Actual(position, named, out, null, null, null,
                        false, true);
            }
            if ("NULL".equalsIgnoreCase(token)) { // non-identifier-compare: NULL keyword token
                return new CallSiteRef.Actual(position, named, out, null, null, null,
                        true);
            }
        }
        if (isCompileTimeLiteral(value)) {
            return new CallSiteRef.Actual(position, named, out, null, null, null, true);
        }
        if (type == EExpressionType.simple_object_name_t
                && value.getObjectOperand() != null) {
            return new CallSiteRef.Actual(position, named, out,
                    value.getObjectOperand(), null, null, false);
        }
        final List<TObjectName> leafs = new ArrayList<TObjectName>();
        final Set<TObjectName> functionNames = Collections.newSetFromMap(
                new java.util.IdentityHashMap<TObjectName, Boolean>());
        value.acceptChildren(new TParseTreeVisitor() {
            @Override
            public void preVisit(TFunctionCall fc) {
                if (fc.getFunctionName() != null) {
                    functionNames.add(fc.getFunctionName());
                }
            }

            @Override
            public void preVisit(TObjectName name) {
                leafs.add(name);
            }
        });
        List<TObjectName> filtered = new ArrayList<TObjectName>();
        for (TObjectName leaf : leafs) {
            if (!functionNames.contains(leaf)) {
                filtered.add(leaf);
            }
        }
        return new CallSiteRef.Actual(position, named, out, null, filtered,
                value.toString(), false);
    }

    /** Compile-time literal shapes: plain constants and sign-prefixed
     *  constants. Deliberately NOT {@code null_t} — that is the IS NULL
     *  PREDICATE type, whose operand fan-in must survive (codex-B3-r2
     *  finding 11); a bare NULL actual is a source token handled above. */
    private static boolean isCompileTimeLiteral(TExpression value) {
        EExpressionType type = value.getExpressionType();
        if (type == EExpressionType.simple_constant_t) {
            return true;
        }
        if (type == EExpressionType.unary_minus_t
                || type == EExpressionType.unary_plus_t) {
            TExpression operand = value.getRightOperand() != null
                    ? value.getRightOperand() : value.getLeftOperand();
            return operand != null && operand.getExpressionType()
                    == EExpressionType.simple_constant_t;
        }
        return false;
    }

    private boolean containsDynamicSql(String text) {
        // Cheap lexical screen for the PARTIAL flag only (never used for
        // binding): EXEC(<expr>) / sp_executesql / EXECUTE IMMEDIATE.
        String lower = text.toLowerCase(Locale.ROOT);
        return lower.contains("sp_executesql")
                || lower.contains("execute immediate")
                || lower.contains("dbms_sql.parse")
                || lower.matches("(?s).*\\bexec(ute)?\\s*\\(.*");
    }
}