package gudusoft.gsqlparser.dlineage.dynamicsql;

import gudusoft.gsqlparser.TCustomSqlStatement;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.dlineage.dynamicsql.RoutineSummaryEdge.Endpoint;

import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * B3 (design {@code routine-summary-scc-design.md} §2.2/§2.3): one call site
 * observed inside a summarized routine body, carrying the LOCAL actual-binding
 * information the {@link RoutineCallBinder} and the SHADOW composition step
 * need — while staying strictly binding-independent (nothing here references
 * the callee; resolution happens later against the analysis-wide catalog).
 *
 * <p>Two coordinate systems meet here and are deliberately kept apart:
 * <ul>
 * <li><b>AST-side</b>: the call statement and its actual argument expressions
 *     from the extractor's parse of the definition slice ({@link Actual}).</li>
 * <li><b>Model-side</b>: the caller's OWN boundary reach at each actual,
 *     computed from the same closure that produced the summary edges — for an
 *     IN actual, which caller boundary endpoints feed it
 *     ({@link #getInSourcesFdd}/{@link #getInSourcesFdr}); for an OUT actual,
 *     which caller boundary endpoints its value reaches downstream
 *     ({@link #getOutTargetsFdd}/{@link #getOutTargetsFdr}). Locals are
 *     quotiented out of the summary itself, so this per-call-site reach is
 *     exactly the information composition would otherwise lose.</li>
 * </ul>
 */
public final class CallSiteRef {

    /** One actual argument at the call site (AST-side view). */
    public static final class Actual {
        private final int position;
        private final String namedFormal;
        private final boolean outFlagged;
        private final TObjectName bareReference;
        private final List<TObjectName> leafReferences;
        private final String expressionText;
        private final boolean literal;
        private final boolean defaultToken;

        public Actual(int position, String namedFormal, boolean outFlagged,
                TObjectName bareReference, List<TObjectName> leafReferences,
                String expressionText, boolean literal) {
            this(position, namedFormal, outFlagged, bareReference,
                    leafReferences, expressionText, literal, false);
        }

        public Actual(int position, String namedFormal, boolean outFlagged,
                TObjectName bareReference, List<TObjectName> leafReferences,
                String expressionText, boolean literal, boolean defaultToken) {
            this.position = position;
            this.namedFormal = namedFormal;
            this.outFlagged = outFlagged;
            this.bareReference = bareReference;
            this.leafReferences = leafReferences == null
                    ? Collections.<TObjectName>emptyList()
                    : Collections.unmodifiableList(leafReferences);
            this.expressionText = expressionText;
            this.literal = literal;
            this.defaultToken = defaultToken;
        }

        /** True for an explicit {@code DEFAULT} actual: the declared default
         *  applies — the formal must HAVE one, and no source binds. */
        public boolean isDefaultToken() { return defaultToken; }

        /** 0-based position among the call's actuals (call-site order). */
        public int getPosition() { return position; }
        /** Formal name of a named-notation actual (mssql {@code @p = v}); null when positional. */
        public String getNamedFormal() { return namedFormal; }
        /** True when the call site flags this actual OUT/OUTPUT. */
        public boolean isOutFlagged() { return outFlagged; }
        /** Non-null when the actual is a bare variable/column reference. */
        public TObjectName getBareReference() { return bareReference; }
        /** Leaf object references inside an expression actual (fan-in rule). */
        public List<TObjectName> getLeafReferences() { return leafReferences; }
        /** Expression text when the actual is neither bare nor literal; else null. */
        public String getExpressionText() { return expressionText; }
        /** True when the actual is a compile-time literal (binds no source). */
        public boolean isLiteral() { return literal; }
    }

    private final RoutineSummary.RawCallSite raw;
    private final TCustomSqlStatement callStatement;
    private final List<Actual> actuals;
    /** INSERT…EXEC consumption: positional target table columns; null otherwise. */
    private final List<Endpoint> insertTargets;
    private final Map<Integer, Set<Endpoint>> inSourcesFdd;
    private final Map<Integer, Set<Endpoint>> inSourcesFdr;
    private final Map<Integer, Set<Endpoint>> outTargetsFdd;
    private final Map<Integer, Set<Endpoint>> outTargetsFdr;
    // --- codex-B3-r1 additions. Package-private mutators, set once by the
    // extractor right after construction (kept out of the constructor to
    // avoid a 13-parameter signature); immutable to consumers. ---
    /** INSERT…EXEC column-list object names (positional); empty otherwise. */
    private List<TObjectName> insertColumnNames = Collections.emptyList();
    /** True when the consuming INSERT has NO explicit column list — the
     *  binder must report PARTIAL, never guess ordinals (finding 4). */
    private boolean insertWithoutColumnList;
    /** {@code @ret = EXEC p} status capture target; null otherwise. */
    private TObjectName returnStatusTarget;
    /** Actual position → the actual's OWN model node keys (bare actuals):
     *  the intra-caller bridge anchor for call-to-call composition (finding 5). */
    private Map<Integer, Set<String>> inNodes = Collections.emptyMap();
    /** Actual position → every model node its value reaches, with flavor
     *  bits (1=fdd-only path exists, 2=fdr-bearing path exists). Interior
     *  nodes INCLUDED — this is what bridges A(@v OUTPUT); B(@v). */
    private Map<Integer, Map<String, Integer>> outReachNodes = Collections.emptyMap();

    public CallSiteRef(RoutineSummary.RawCallSite raw,
            TCustomSqlStatement callStatement, List<Actual> actuals,
            List<Endpoint> insertTargets,
            Map<Integer, Set<Endpoint>> inSourcesFdd,
            Map<Integer, Set<Endpoint>> inSourcesFdr,
            Map<Integer, Set<Endpoint>> outTargetsFdd,
            Map<Integer, Set<Endpoint>> outTargetsFdr) {
        this.raw = raw;
        this.callStatement = callStatement;
        this.actuals = actuals == null
                ? Collections.<Actual>emptyList()
                : Collections.unmodifiableList(actuals);
        this.insertTargets = insertTargets == null
                ? null : Collections.unmodifiableList(insertTargets);
        this.inSourcesFdd = unmodifiable(inSourcesFdd);
        this.inSourcesFdr = unmodifiable(inSourcesFdr);
        this.outTargetsFdd = unmodifiable(outTargetsFdd);
        this.outTargetsFdr = unmodifiable(outTargetsFdr);
    }

    private static Map<Integer, Set<Endpoint>> unmodifiable(
            Map<Integer, Set<Endpoint>> map) {
        return map == null
                ? Collections.<Integer, Set<Endpoint>>emptyMap()
                : Collections.unmodifiableMap(map);
    }

    public RoutineSummary.RawCallSite getRaw() { return raw; }
    /** The call statement from the extractor's slice parse (run-scoped AST). */
    public TCustomSqlStatement getCallStatement() { return callStatement; }
    public List<Actual> getActuals() { return actuals; }
    /** Positional INSERT…EXEC target columns; null when the call site is not
     *  consumed by an INSERT (or the INSERT has no explicit column list —
     *  the binder reports that case as PARTIAL, never guesses ordinals). */
    public List<Endpoint> getInsertTargets() { return insertTargets; }
    /** Actual position → caller boundary endpoints feeding it via fdd-only paths. */
    public Map<Integer, Set<Endpoint>> getInSourcesFdd() { return inSourcesFdd; }
    /** Actual position → caller boundary endpoints feeding it via fdr-bearing paths. */
    public Map<Integer, Set<Endpoint>> getInSourcesFdr() { return inSourcesFdr; }
    /** Actual position → caller boundary endpoints its value reaches via fdd-only paths. */
    public Map<Integer, Set<Endpoint>> getOutTargetsFdd() { return outTargetsFdd; }
    /** Actual position → caller boundary endpoints its value reaches via fdr-bearing paths. */
    public Map<Integer, Set<Endpoint>> getOutTargetsFdr() { return outTargetsFdr; }

    public List<TObjectName> getInsertColumnNames() { return insertColumnNames; }
    public boolean isInsertWithoutColumnList() { return insertWithoutColumnList; }
    public TObjectName getReturnStatusTarget() { return returnStatusTarget; }
    public Map<Integer, Set<String>> getInNodes() { return inNodes; }
    public Map<Integer, Map<String, Integer>> getOutReachNodes() { return outReachNodes; }

    void setInsertColumnNames(List<TObjectName> names) {
        this.insertColumnNames = names == null
                ? Collections.<TObjectName>emptyList()
                : Collections.unmodifiableList(names);
    }

    void setInsertWithoutColumnList(boolean flag) {
        this.insertWithoutColumnList = flag;
    }

    void setReturnStatusTarget(TObjectName target) {
        this.returnStatusTarget = target;
    }

    void setInNodes(Map<Integer, Set<String>> nodes) {
        this.inNodes = nodes == null
                ? Collections.<Integer, Set<String>>emptyMap()
                : Collections.unmodifiableMap(nodes);
    }

    void setOutReachNodes(Map<Integer, Map<String, Integer>> nodes) {
        this.outReachNodes = nodes == null
                ? Collections.<Integer, Map<String, Integer>>emptyMap()
                : Collections.unmodifiableMap(nodes);
    }

    @Override
    public String toString() {
        return raw + "[" + actuals.size() + " actuals]";
    }
}