package gudusoft.gsqlparser.dlineage.dataflow.model;

import gudusoft.gsqlparser.dlineage.dynamicsql.DynamicSqlTrustMode;
import gudusoft.gsqlparser.dlineage.util.Pair3;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
 * A single dynamic-SQL execution site encountered by
 * {@link gudusoft.gsqlparser.dlineage.DataFlowAnalyzer}, together with whether the analyzer
 * could statically resolve it. Recording a site never mutates the core lineage model; consumers
 * may use its proof IDs to project a trustworthy subset of that already-computed model.
 *
 * <p>{@link Status} is observation-mode-aware:
 * <ul>
 *   <li>{@code RESOLVED} — a complete materialization parsed. In LEGACY mode this also preserves
 *       the historical classification of some incomplete sites for compatibility.</li>
 *   <li>{@code PARTIAL} — SHADOW analyzed incomplete text and retained the historical candidate
 *       relationships; {@link #getUnprovenRelationshipCount()} counts candidates whose
 *       per-edge proof is not available.</li>
 *   <li>{@code PARSE_ERROR} — a fully-known dynamic string whose {@code parse()} failed.</li>
 *   <li>{@code UNRESOLVED} — no usable candidate lineage was produced.</li>
 * </ul>
 *
 * <p>LEGACY's three original states correspond to the internal v2 extraction
 * states ({@code RESOLVED / AMBIGUOUS / PARSE_ERROR}); {@code PARTIAL} is an
 * additive SHADOW-only diagnostic state.
 *
 * <p>Positions follow the GSP convention: 1-based, end-exclusive, tagged with the per-statement
 * file hash (same shape as {@link ErrorInfo}).
 *
 * <p>For SHADOW consumers that must publish only independently proven
 * relationships, {@link #getObservedRelationshipIds()} identifies the full
 * relationship delta attributed to this site and
 * {@link #getProvenRelationshipIds()} identifies the subset backed by a
 * complete, hole-free materialization. IDs are scoped to this analyzer result
 * and correspond to relationship IDs in non-simple {@code dataflow} output.
 */
public final class DynamicSqlSite {

        /** The syntactic form of the dynamic-exec site. */
        public enum Kind {
                SP_EXECUTESQL,
                EXEC_STRING,
                EXECUTE_IMMEDIATE,
                DBMS_SQL,
                OTHER
        }

        /** Completeness/publication state of this dynamic SQL site. */
        public enum Status {
                RESOLVED,
                UNRESOLVED,
                PARSE_ERROR,
                /** Incomplete materialization retained for measurement in SHADOW mode. */
                PARTIAL
        }

        private final Kind kind;
        private final Status status;
        private final String reason;
        private final String diagnostic;
        private final Pair3<Long, Long, String> startPosition;
        private final Pair3<Long, Long, String> endPosition;
        private final int resolvedRelationshipCount;
        private final int partialRelationshipCount;
        private final int unprovenRelationshipCount;
        private final int unresolvedHoleCount;
        private final boolean holeCountExact;
        private final DynamicSqlTrustMode trustMode;
        private final List<Long> observedRelationshipIds;
        private final List<Long> provenRelationshipIds;
        private final List<UnresolvedFragment> unresolvedFragments;
        private final String materializedText;

        public DynamicSqlSite(Kind kind, Status status, String reason,
                        Pair3<Long, Long, String> startPosition, Pair3<Long, Long, String> endPosition,
                        int resolvedRelationshipCount, int partialRelationshipCount) {
                this(kind, status, reason, startPosition, endPosition, resolvedRelationshipCount,
                                partialRelationshipCount, 0, -1, false, DynamicSqlTrustMode.LEGACY,
                                Collections.<Long>emptyList(), Collections.<Long>emptyList(), null);
        }

        public DynamicSqlSite(Kind kind, Status status, String reason,
                        Pair3<Long, Long, String> startPosition, Pair3<Long, Long, String> endPosition,
                        int resolvedRelationshipCount, int partialRelationshipCount,
                        int unprovenRelationshipCount,
                        int unresolvedHoleCount, boolean holeCountExact, DynamicSqlTrustMode trustMode) {
                this(kind, status, reason, startPosition, endPosition, resolvedRelationshipCount,
                                partialRelationshipCount, unprovenRelationshipCount,
                                unresolvedHoleCount, holeCountExact, trustMode,
                                Collections.<Long>emptyList(), Collections.<Long>emptyList(), null);
        }

        public DynamicSqlSite(Kind kind, Status status, String reason,
                        Pair3<Long, Long, String> startPosition, Pair3<Long, Long, String> endPosition,
                        int resolvedRelationshipCount, int partialRelationshipCount,
                        int unprovenRelationshipCount,
                        int unresolvedHoleCount, boolean holeCountExact, DynamicSqlTrustMode trustMode,
                        List<Long> observedRelationshipIds, List<Long> provenRelationshipIds) {
                this(kind, status, reason, startPosition, endPosition,
                                resolvedRelationshipCount, partialRelationshipCount,
                                unprovenRelationshipCount, unresolvedHoleCount, holeCountExact,
                                trustMode, observedRelationshipIds, provenRelationshipIds, null);
        }

        public DynamicSqlSite(Kind kind, Status status, String reason,
                        Pair3<Long, Long, String> startPosition, Pair3<Long, Long, String> endPosition,
                        int resolvedRelationshipCount, int partialRelationshipCount,
                        int unprovenRelationshipCount,
                        int unresolvedHoleCount, boolean holeCountExact, DynamicSqlTrustMode trustMode,
                        List<Long> observedRelationshipIds, List<Long> provenRelationshipIds,
                        String diagnostic) {
                this(kind, status, reason, startPosition, endPosition,
                                resolvedRelationshipCount, partialRelationshipCount,
                                unprovenRelationshipCount, unresolvedHoleCount, holeCountExact,
                                trustMode, observedRelationshipIds, provenRelationshipIds, diagnostic,
                                Collections.<UnresolvedFragment>emptyList(), null);
        }

        public DynamicSqlSite(Kind kind, Status status, String reason,
                        Pair3<Long, Long, String> startPosition, Pair3<Long, Long, String> endPosition,
                        int resolvedRelationshipCount, int partialRelationshipCount,
                        int unprovenRelationshipCount,
                        int unresolvedHoleCount, boolean holeCountExact, DynamicSqlTrustMode trustMode,
                        List<Long> observedRelationshipIds, List<Long> provenRelationshipIds,
                        String diagnostic, List<UnresolvedFragment> unresolvedFragments,
                        String materializedText) {
                this.kind = kind;
                this.status = status;
                this.reason = reason;
                this.diagnostic = diagnostic;
                this.startPosition = startPosition;
                this.endPosition = endPosition;
                this.resolvedRelationshipCount = resolvedRelationshipCount;
                this.partialRelationshipCount = partialRelationshipCount;
                this.unprovenRelationshipCount = unprovenRelationshipCount;
                this.unresolvedFragments = unresolvedFragments == null || unresolvedFragments.isEmpty()
                                ? Collections.<UnresolvedFragment>emptyList()
                                : Collections.unmodifiableList(new ArrayList<UnresolvedFragment>(unresolvedFragments));
                // A listed fragment set IS the count: the two can never disagree.
                this.unresolvedHoleCount = this.unresolvedFragments.isEmpty() ? unresolvedHoleCount
                                : this.unresolvedFragments.size();
                this.holeCountExact = this.unresolvedFragments.isEmpty() ? holeCountExact : true;
                this.trustMode = trustMode == null ? DynamicSqlTrustMode.LEGACY : trustMode;
                this.observedRelationshipIds = immutableIds(observedRelationshipIds);
                this.provenRelationshipIds = immutableIds(provenRelationshipIds);
                this.materializedText = materializedText;
        }

        private static List<Long> immutableIds(List<Long> values) {
                if (values == null || values.isEmpty()) {
                        return Collections.emptyList();
                }
                return Collections.unmodifiableList(new ArrayList<Long>(values));
        }

        public Kind getKind() {
                return kind;
        }

        public Status getStatus() {
                return status;
        }

        /** Human-readable explanation; {@code null} for {@link Status#RESOLVED}. */
        public String getReason() {
                return reason;
        }

        /** Additive analysis note, kept separate from an unresolved reason. */
        public String getDiagnostic() {
                return diagnostic;
        }

        public Pair3<Long, Long, String> getStartPosition() {
                return startPosition;
        }

        public Pair3<Long, Long, String> getEndPosition() {
                return endPosition;
        }

        /**
         * Number of lineage edges this site produced into a <b>real</b> target column (a resolved base-table
         * column, not a T-SQL variable or placeholder). Intermediate result-set hops are not counted.
         * {@code > 0} iff the site's dynamic SQL yielded usable lineage.
         */
        public int getResolvedRelationshipCount() {
                return resolvedRelationshipCount;
        }

        /**
         * Number of lineage edges this site produced into an <b>unresolved</b> target — a T-SQL variable or
         * placeholder (e.g. {@code EXEC sp_executesql @sql} folded to {@code INSERT INTO @t SELECT ...}). These
         * are partial: a source is known but the target object is not.
         */
        public int getPartialRelationshipCount() {
                return partialRelationshipCount;
        }

        /** Historical candidate relationships SHADOW observed on incomplete text without a per-edge proof. */
        public int getUnprovenRelationshipCount() {
                return unprovenRelationshipCount;
        }

        /**
         * Number of unresolved splice fragments, or {@code -1} when the producer exposes only a
         * partial flag. Whenever {@link #getUnresolvedFragments()} is non-empty this IS its size
         * and {@link #isHoleCountExact()} is true; an exact positive count with an empty list
         * can only come from a producer that counted without listing (none in GSP itself).
         */
        public int getUnresolvedHoleCount() {
                return unresolvedHoleCount;
        }

        public boolean isHoleCountExact() {
                return holeCountExact;
        }

        /**
         * The unresolved fragments ("holes") of this site's argument, one per non-literal
         * fragment of its materialization, in string order: which variable / parameter /
         * expression the evaluator could not fold, why, where its value would come from, and
         * the origin span to highlight. Empty (never null) for a fully resolved site and for
         * a site the evaluator did not see (a dynamic site outside a procedure body, or a
         * vendor without the abstract evaluator) — check {@link #isHoleCountExact()} to tell
         * "no holes" from "not known".
         */
        public List<UnresolvedFragment> getUnresolvedFragments() {
                return unresolvedFragments;
        }

        /**
         * The argument as the evaluator materialized it, with every hole rendered as its
         * {@link UnresolvedFragment#getText()} (a compile-time literal argument is its own
         * text); {@code null} when the evaluator did not see the site or the argument did not
         * reduce to a string at all - the holes are still listed, but there is no honest
         * rendering of an unreduced value.
         */
        public String getMaterializedText() {
                return materializedText;
        }

        public DynamicSqlTrustMode getTrustMode() {
                return trustMode;
        }

        /** Relationship IDs attributed to this site, including unproven SHADOW candidates. */
        public List<Long> getObservedRelationshipIds() {
                return observedRelationshipIds;
        }

        /**
         * Relationship IDs whose analyzed text was complete, parsed, and contained
         * no unresolved provenance holes or placeholder targets.
         */
        public List<Long> getProvenRelationshipIds() {
                return provenRelationshipIds;
        }

        /**
         * True iff this site produced at least one resolved lineage edge (into a real target column).
         * In SHADOW this may be true for a PARTIAL site because candidate edges remain published for
         * comparison; check {@link #getStatus()} and {@link #getUnprovenRelationshipCount()} before
         * treating those edges as proven. A site with only unresolved-target edges or no edge returns false.
         */
        public boolean producedLineage() {
                return resolvedRelationshipCount > 0;
        }
}