package gudusoft.gsqlparser.dlineage.dynamicsql;

/**
 * One provenance-tagged fragment of a materialized dynamic-SQL string.
 *
 * <p>A materialized string is an ordered fragment sequence whose concatenated
 * {@link #text} equals the rendered SQL exactly. Each fragment is either:
 * <ul>
 *   <li>{@link Kind#LITERAL} — text proven to be the exact runtime characters:
 *       a string literal, or the output of a transform proven byte-exact for
 *       the vendor;</li>
 *   <li>{@link Kind#HOLE} — text standing in for a value the evaluator could
 *       not prove exactly: an unbound variable's own token, an unfoldable
 *       expression's placeholder, or the output of a transform that is folded
 *       for display but NOT proven byte-exact ({@link HoleOrigin#INEXACT_TRANSFORM}).</li>
 * </ul>
 *
 * <p>Consumers (the per-edge publication proof, design doc
 * {@code dynamic-sql-fragment-provenance-design.md}) must treat every HOLE as
 * arbitrary runtime text; no lineage evidence may rest on HOLE characters. The
 * legacy {@code SqlStringValue.state}/{@code text} contract is unchanged —
 * fragments are additional provenance carried alongside it.
 */
public final class SqlFragment {

    /** Fragment class: exact literal text vs. unproven stand-in text. */
    public enum Kind { LITERAL, HOLE }

    /** Why a HOLE exists — which producer limitation created it. */
    public enum HoleOrigin {
        /** A variable/parameter never bound and never assigned a foldable value. */
        UNBOUND_VARIABLE,
        /** A bare (non-variable) identifier used as a value — data-dependent. */
        NON_VARIABLE_IDENT,
        /** A function call the evaluator does not fold. */
        OPAQUE_CALL,
        /** An expression form the evaluator does not model. */
        UNSUPPORTED_EXPR,
        /** Evaluation hit a configured resource bound. */
        RESOURCE_LIMIT,
        /**
         * A transform was folded for display but its output is not proven
         * byte-exact against vendor runtime semantics (CAST/CONVERT padding and
         * styles, collation-aware REPLACE/UPPER/LOWER, whitespace-class TRIM,
         * non-default QUOTENAME delimiters, numeric rendering).
         */
        INEXACT_TRANSFORM,
        /**
         * A variable whose last visible assignment read from a query
         * ({@code SELECT @v = col FROM t ...}): its value is runtime data. The
         * hole keeps the assignment's own rendering (the source column name as a
         * placeholder) but is named after the VARIABLE, and {@link #valueOrigin}
         * describes the column / expression the value would come from.
         */
        QUERY_ASSIGNED_VARIABLE,
        /**
         * A variable whose value depends on control flow the evaluator cannot
         * decide: assigned inside an undecidable IF / WHILE branch, declared
         * there, or assigned by a driver loop whose iteration is unknown.
         */
        FLOW_DEPENDENT_VARIABLE
    }

    public final Kind kind;
    /** Exact rendered text this fragment contributes to the materialized SQL. Never null. */
    public final String text;
    /** HOLE only: why the hole exists; null for LITERAL. */
    public final HoleOrigin origin;
    /** HOLE only: the variable/function/expression name that caused it; may be null. */
    public final String originName;
    /** HOLE only: human-readable cause; null for LITERAL. */
    public final String reason;
    /**
     * HOLE only: true when the hole's runtime VALUE is unknown (an unbound variable, or a
     * transform applied to one). False for an {@code INEXACT_TRANSFORM} computed entirely
     * from literals, where the value is known and only its byte-exactness against vendor
     * runtime semantics is unproven. The distinction matters to consumers deciding whether
     * a folded identifier is a runtime TEMPLATE ({@code UPPER(@X)} — unknown) or merely an
     * unproven rendering of a known name ({@code UPPER('src')} — known). Always false for
     * LITERAL fragments.
     */
    public final boolean valueUnknown;
    /**
     * Where the value came from. LITERAL: the seed of an exact value — null for
     * ordinary SQL string fragments; constant-relation values use a stable
     * description such as {@code INSERT VALUES row 2 of @Source}. HOLE: the
     * data source the unknown value would be read from, when the evaluator saw
     * it ({@code dbo.SSF_Entity.Entity} for a {@link HoleOrigin#QUERY_ASSIGNED_VARIABLE});
     * null when unknown.
     */
    public final String valueOrigin;
    /**
     * Source offsets, end-exclusive, of the fragment's origin in the analyzed
     * text: for a LITERAL the seeding expression; for a HOLE the place the
     * value was last defined — the assignment target of a query-assigned or
     * flow-dependent variable, the declaration of an unbound parameter or of a
     * declared-but-unassigned variable, otherwise the reference that produced
     * the hole. {@code -1} when the origin is not in the analyzed text.
     */
    public final long sourceStartOffset;
    public final long sourceEndOffset;
    /**
     * The same origin span as line / column: 1-based, end-exclusive end column,
     * in the coordinate system of {@code TSourceToken.lineNo / columnNo}.
     * {@code -1} when unknown. Populated for HOLE fragments whose origin is a
     * source node; LITERAL fragments carry offsets only.
     */
    public final int sourceStartLine;
    public final int sourceStartColumn;
    public final int sourceEndLine;
    public final int sourceEndColumn;
    /**
     * LITERAL only: where the characters of {@link #text} sit in the analyzed source, one piece per string literal
     * token they were read from (Mantis 4851); empty when unknown, as for the output of a transform. Positional
     * metadata only, no part of the fragment's provenance: merging and {@link #hasSameLiteralProvenance} ignore it.
     */
    public final java.util.List<SourcePiece> pieces;

    private SqlFragment(Kind kind, String text, HoleOrigin origin, String originName, String reason,
            boolean valueUnknown, String valueOrigin, long sourceStartOffset,
            long sourceEndOffset) {
        this(kind, text, origin, originName, reason, valueUnknown, valueOrigin,
                sourceStartOffset, sourceEndOffset, -1, -1, -1, -1);
    }

    private SqlFragment(Kind kind, String text, HoleOrigin origin, String originName, String reason,
            boolean valueUnknown, String valueOrigin, long sourceStartOffset,
            long sourceEndOffset, int sourceStartLine, int sourceStartColumn,
            int sourceEndLine, int sourceEndColumn) {
        this(kind, text, origin, originName, reason, valueUnknown, valueOrigin, sourceStartOffset, sourceEndOffset,
                sourceStartLine, sourceStartColumn, sourceEndLine, sourceEndColumn,
                java.util.Collections.<SourcePiece>emptyList());
    }

    private SqlFragment(Kind kind, String text, HoleOrigin origin, String originName, String reason,
            boolean valueUnknown, String valueOrigin, long sourceStartOffset,
            long sourceEndOffset, int sourceStartLine, int sourceStartColumn,
            int sourceEndLine, int sourceEndColumn, java.util.List<SourcePiece> pieces) {
        this.pieces = pieces;
        this.kind = kind;
        this.text = text == null ? "" : text;
        this.origin = origin;
        this.originName = originName;
        this.reason = reason;
        this.valueUnknown = valueUnknown;
        this.valueOrigin = valueOrigin;
        this.sourceStartOffset = sourceStartOffset;
        this.sourceEndOffset = sourceEndOffset;
        this.sourceStartLine = sourceStartLine;
        this.sourceStartColumn = sourceStartColumn;
        this.sourceEndLine = sourceEndLine;
        this.sourceEndColumn = sourceEndColumn;
    }

    public static SqlFragment literal(String text) {
        return new SqlFragment(Kind.LITERAL, text, null, null, null, false,
                null, -1L, -1L);
    }

    /** Exact literal value with its procedure-body seed provenance. */
    public static SqlFragment literal(String text, String valueOrigin,
            long sourceStartOffset, long sourceEndOffset) {
        return new SqlFragment(Kind.LITERAL, text, null, null, null, false,
                valueOrigin, sourceStartOffset, sourceEndOffset);
    }

    /** Exact literal value read from one string literal token, with where its characters sit (Mantis 4851). */
    public static SqlFragment literal(String text, SourcePiece piece) {
        return piece == null ? literal(text)
                : new SqlFragment(Kind.LITERAL, text, null, null, null, false, null, -1L, -1L, -1, -1, -1, -1,
                        java.util.Collections.singletonList(piece));
    }

    /**
     * The LITERAL that {@code a} followed by {@code b} make when merged: {@code a}'s provenance, as before, and the
     * pieces of both, those of {@code b} moved past {@code a}'s text.
     */
    static SqlFragment mergedLiteral(SqlFragment a, SqlFragment b) {
        java.util.List<SourcePiece> pieces = java.util.Collections.emptyList();
        if (!a.pieces.isEmpty() || !b.pieces.isEmpty()) {
            pieces = new java.util.ArrayList<SourcePiece>(a.pieces.size() + b.pieces.size());
            pieces.addAll(a.pieces);
            for (SourcePiece p : b.pieces) pieces.add(p.shifted(a.text.length()));
        }
        return new SqlFragment(Kind.LITERAL, a.text + b.text, null, null, null, false, a.valueOrigin,
                a.valueOrigin == null ? -1L : a.sourceStartOffset, a.valueOrigin == null ? -1L : a.sourceEndOffset,
                -1, -1, -1, -1, pieces);
    }

    /**
     * {@code length} characters of a LITERAL's text, from {@code textStart}, read from one string literal token of the
     * analyzed source (Mantis 4851): where each sits there, so that what GSP analyzes inside the string reports
     * positions in the source. {@code ''} is one character of the text and two of the source; the token keeps its
     * quotes, a one-letter prefix such as N, and its line breaks.
     */
    public static final class SourcePiece {
        public final int textStart;
        public final int length;
        private final long tokenLine;
        private final long tokenColumn;
        private final String tokenText;
        private final int contentStart;

        private SourcePiece(int textStart, int length, long tokenLine, long tokenColumn, String tokenText,
                int contentStart) {
            this.textStart = textStart;
            this.length = length;
            this.tokenLine = tokenLine;
            this.tokenColumn = tokenColumn;
            this.tokenText = tokenText;
            this.contentStart = contentStart;
        }

        /**
         * The piece of string literal token {@code token} whose content decodes to {@code decoded}: null unless the
         * token is a single-quoted literal (with at most a one-letter prefix) whose content, {@code ''} read as one
         * quote, is exactly {@code decoded}.
         */
        public static SourcePiece of(gudusoft.gsqlparser.TSourceToken token, String decoded) {
            if (token == null || decoded == null || token.lineNo <= 0 || token.columnNo <= 0) return null;
            String raw = token.toString();
            if (raw == null) return null;
            int q = raw.indexOf('\'');
            if (q < 0 || q > 1) return null;
            StringBuilder content = new StringBuilder();
            int j = q + 1;
            boolean closed = false;
            while (j < raw.length()) {
                char ch = raw.charAt(j);
                if (ch == '\'') {
                    if (j + 1 < raw.length() && raw.charAt(j + 1) == '\'') {
                        content.append('\'');
                        j += 2;
                        continue;
                    }
                    closed = true;
                    j++;
                    break;
                }
                content.append(ch);
                j++;
            }
            if (!closed || j != raw.length() || !content.toString().equals(decoded)) return null;
            return new SourcePiece(0, decoded.length(), token.lineNo, token.columnNo, raw, q + 1);
        }

        SourcePiece shifted(int by) {
            return new SourcePiece(textStart + by, length, tokenLine, tokenColumn, tokenText, contentStart);
        }

        /**
         * Writes the source line and column of each character of this piece into {@code lines} and {@code columns},
         * at index {@code base + textStart + k} for its k-th character; returns the position just past its last
         * character, the literal's closing quote, where a value concatenated after it is spliced in.
         */
        public long[] fill(long[] lines, long[] columns, int base) {
            long line = tokenLine, column = tokenColumn;
            int j = 0;
            for (; j < contentStart; j++) {
                if (breaksLine(tokenText, j)) { line++; column = 1; } else { column++; }
            }
            for (int k = 0; k < length && j < tokenText.length(); k++) {
                int at = base + textStart + k;
                if (at >= 0 && at < lines.length) {
                    lines[at] = line;
                    columns[at] = column;
                }
                char ch = tokenText.charAt(j);
                if (ch == '\'' && j + 1 < tokenText.length() && tokenText.charAt(j + 1) == '\'') {
                    j += 2;
                    column += 2;
                } else {
                    if (breaksLine(tokenText, j)) { line++; column = 1; } else { column++; }
                    j++;
                }
            }
            return new long[] {line, column};
        }

        /** Whether character {@code j} ends a line as the lexer counts lines: LF, or a CR not followed by LF. */
        private static boolean breaksLine(String text, int j) {
            char ch = text.charAt(j);
            return ch == '\n' || (ch == '\r' && (j + 1 >= text.length() || text.charAt(j + 1) != '\n'));
        }
    }

    /**
     * Hole with the default value-knowledge for its origin: every origin except
     * {@code INEXACT_TRANSFORM} stands in for a value nobody knows; an inexact transform
     * defaults to value-known (computed from literals). A transform over a PARTIAL input
     * must use the explicit overload with {@code valueUnknown=true}.
     */
    public static SqlFragment hole(String renderedText, HoleOrigin origin, String originName, String reason) {
        HoleOrigin resolved = origin == null ? HoleOrigin.UNSUPPORTED_EXPR : origin;
        return new SqlFragment(Kind.HOLE, renderedText, resolved, originName, reason,
                resolved != HoleOrigin.INEXACT_TRANSFORM, null, -1L, -1L);
    }

    public static SqlFragment hole(String renderedText, HoleOrigin origin, String originName, String reason,
            boolean valueUnknown) {
        return new SqlFragment(Kind.HOLE, renderedText,
                origin == null ? HoleOrigin.UNSUPPORTED_EXPR : origin, originName, reason, valueUnknown,
                null, -1L, -1L);
    }

    /**
     * Hole with full provenance: the data source its value would come from
     * ({@code valueOrigin}, may be null) and the origin span in the analyzed
     * text (see {@link #sourceStartOffset} / {@link #sourceStartLine}; pass
     * {@code -1} for unknown).
     */
    public static SqlFragment hole(String renderedText, HoleOrigin origin, String originName, String reason,
            boolean valueUnknown, String valueOrigin, long sourceStartOffset, long sourceEndOffset,
            int sourceStartLine, int sourceStartColumn, int sourceEndLine, int sourceEndColumn) {
        return new SqlFragment(Kind.HOLE, renderedText,
                origin == null ? HoleOrigin.UNSUPPORTED_EXPR : origin, originName, reason, valueUnknown,
                valueOrigin, sourceStartOffset, sourceEndOffset,
                sourceStartLine, sourceStartColumn, sourceEndLine, sourceEndColumn);
    }

    /** True when the origin span is known in line / column form. */
    public boolean hasSourceSpan() {
        return sourceStartLine > 0 && sourceStartColumn > 0;
    }

    public boolean isLiteral() {
        return kind == Kind.LITERAL;
    }

    boolean hasSameLiteralProvenance(SqlFragment other) {
        if (other == null || !isLiteral() || !other.isLiteral()) {
            return false;
        }
        if (valueOrigin == null ? other.valueOrigin != null : !valueOrigin.equals(other.valueOrigin)) {
            return false;
        }
        return sourceStartOffset == other.sourceStartOffset
                && sourceEndOffset == other.sourceEndOffset;
    }

    @Override
    public String toString() {
        return kind == Kind.LITERAL
                ? "L[" + text + "]"
                : "H[" + text + " <" + origin + (originName != null ? ":" + originName : "") + ">]";
    }
}