package gudusoft.gsqlparser.pp2.token;

import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSourceTokenList;
import gudusoft.gsqlparser.pp2.FormatDiagnostic;

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

/**
 * Byte-authority for a pp2 format call. Every character of the input is
 * owned by exactly one {@link SourceSpan}.
 *
 * <p>This is the Codex Round-3 insight that makes "no byte ever lost" a
 * concrete guarantee. {@link Pp2TokenStreamBuilder} (S7) is allowed to
 * normalize whitespace and CRLF because the ledger preserves the raw
 * bytes; the assembler (S15) can restore them when emitting output.
 *
 * <h2>Coverage invariant</h2>
 *
 * <p>For every ledger {@code l} produced by {@link #build(String, TSourceTokenList)}:
 * <pre>
 *   l.getSpans().get(0).getStartOffset() == 0
 *   l.getSpans().get(N-1).getEndOffset() == input.length()
 *   span[i].getEndOffset() == span[i+1].getStartOffset()  // no gaps, no overlaps
 *   Σ span.getText() == original input                    // bytes recovered
 * </pre>
 *
 * <h2>RAW_FALLBACK spans</h2>
 *
 * <p>Any range the tokenizer did not cover — usually a vendor-parser
 * tokenization gap, occasionally an unclosed string the lexer truncated —
 * is recorded as a {@link SourceSpan.Kind#RAW_FALLBACK} span with the
 * verbatim source text. The engine emits a {@code FormatDiagnostic} for
 * each such span so the result advertises the recovery. Legal SQL on the
 * five major vendors produces zero {@code RAW_FALLBACK} spans (verified
 * by {@code SourceSpanLedgerTest}).
 *
 * <p>Plan reference: §7.3/S8, §7.4/S8, §10.3 (the construction sketch).
 */
public final class SourceSpanLedger {

    private final String source;
    private final List<SourceSpan> spans;
    private final int rawFallbackCount;
    private final List<FormatDiagnostic> diagnostics;

    private SourceSpanLedger(String source, List<SourceSpan> spans,
                             int rawFallbackCount,
                             List<FormatDiagnostic> diagnostics) {
        this.source = source;
        this.spans = spans;
        this.rawFallbackCount = rawFallbackCount;
        this.diagnostics = diagnostics;
    }

    /**
     * Build a ledger from the original SQL string and the parser's token
     * list. Tokens are visited in {@code offset} order. Malformed tokenizer
     * output — negative offsets, tokens past the input boundary, or
     * overlapping/out-of-order spans (observed with CRLF line endings after an
     * unbalanced construct on Windows / git autocrlf) — is <b>tolerated</b>,
     * not fatal: out-of-range tokens are skipped or clamped, overlaps are
     * clamped to the running cursor, and a {@link FormatDiagnostic} records
     * each recovery. This keeps the fault-tolerant contract (no throw; every
     * input byte still owned by exactly one span via RAW_FALLBACK gap filling).
     *
     * @throws NullPointerException if {@code source} or {@code tokens} is null
     */
    public static SourceSpanLedger build(String source, TSourceTokenList tokens) {
        if (source == null) throw new NullPointerException("source");
        if (tokens == null) throw new NullPointerException("tokens");

        // Diagnostics are collected across both passes (the bounds pass below
        // and the coverage walk) so every tolerated malformation is observable.
        List<FormatDiagnostic> diags = new ArrayList<FormatDiagnostic>();

        // Collect (offset, length, kind, text) tuples sorted by offset so
        // the coverage walk is deterministic even if the lexer produced
        // tokens out of source order (it shouldn't, but).
        //
        // A fault-tolerant formatter must never crash on malformed tokenizer
        // output. The GSP lexer can emit tokens with offsets/lengths that
        // violate the TSourceTokenList contract on adverse input — notably
        // CRLF line endings (Windows / git autocrlf) after an unbalanced or
        // truncated construct, which produce out-of-order / overlapping spans.
        // Rather than throw (which would abort the whole format via Pp2Engine's
        // top-level catch and surface as FAILED), we tolerate these: skip a
        // token whose offset is negative or past the input, and clamp one that
        // runs past the input boundary, recording a diagnostic each time. Any
        // bytes a skipped token would have covered are picked up by the
        // RAW_FALLBACK gap/tail filling below, so no input byte is lost. All
        // bounds arithmetic uses long to avoid integer overflow on a
        // pathologically large offset.
        List<int[]> idx = new ArrayList<int[]>(tokens.size());
        for (int i = 0; i < tokens.size(); i++) {
            TSourceToken t = tokens.get(i);
            if (t == null) {
                throw new NullPointerException("tokens[" + i + "]");
            }
            String text = t.toString();
            if (text == null || text.isEmpty()) {
                // Empty tokens (Removed sentinels, etc.) contribute no bytes;
                // skip rather than attempt to anchor them.
                continue;
            }
            long startL = t.offset;
            long endL = startL + text.length();
            if (startL < 0 || startL >= source.length()) {
                diags.add(new FormatDiagnostic(
                    FormatDiagnostic.Severity.WARNING, 0, source.length(),
                    "token at index " + i + " has out-of-range offset "
                        + startL + " (input length " + source.length()
                        + ") — skipped, bytes recovered as RAW_FALLBACK"));
                continue;
            }
            int start = (int) startL;
            int end;
            if (endL > source.length()) {
                end = source.length();
                diags.add(new FormatDiagnostic(
                    FormatDiagnostic.Severity.WARNING, start, source.length(),
                    "token at index " + i + " (offset " + start + ", length "
                        + text.length() + ") extends past input length "
                        + source.length() + " — clamped"));
            } else {
                end = (int) endL;
            }
            idx.add(new int[] {start, end, i});
        }
        // Sort by start offset (stable, ties broken by tokenIndex).
        idx.sort((a, b) -> {
            if (a[0] != b[0]) return Integer.compare(a[0], b[0]);
            return Integer.compare(a[2], b[2]);
        });

        List<SourceSpan> spans = new ArrayList<SourceSpan>(idx.size() * 2 + 2);
        int cursor = 0;
        int rawCount = 0;
        for (int[] entry : idx) {
            int start = entry[0];
            int end = entry[1];
            TSourceToken t = tokens.get(entry[2]);

            if (start < cursor) {
                // Fully contained in an already-emitted span is the GSP
                // lexer "${name}" quirk — see TokenCoverage Javadoc.
                if (TokenCoverage.isFullyShadowed(t, cursor)) {
                    continue;
                }
                // Adds no new bytes (ends at or before the cursor): skip; the
                // bytes are already owned by an earlier span.
                if (end <= cursor) {
                    continue;
                }
                // Partial overlap (start < cursor < end). On adverse input the
                // GSP lexer can emit overlapping spans (e.g. CRLF after an
                // unbalanced construct). A fault-tolerant formatter must not
                // throw: clamp this token's start to the cursor so the coverage
                // invariant (no overlaps) holds, emit only its non-overlapping
                // tail [cursor, end], and record a diagnostic. The overlapping
                // prefix [start, cursor] is already covered by the previous
                // span, so reconstruction (Σ span.text == source) still holds.
                diags.add(new FormatDiagnostic(
                    FormatDiagnostic.Severity.WARNING,
                    start, end,
                    "overlapping token at index " + entry[2] + " (offset "
                        + start + ", end " + end + ") clamped to [" + cursor
                        + ", " + end + "] — tokenizer span overlap tolerated"));
                SourceSpan.Kind clampedKind = classifyToken(t.tokentype);
                spans.add(new SourceSpan(cursor, end, clampedKind,
                    source.substring(cursor, end)));
                cursor = end;
                continue;
            }
            if (start > cursor) {
                // Tokenizer gap: cover with a RAW_FALLBACK span and emit a
                // diagnostic so the result advertises the recovery.
                spans.add(new SourceSpan(cursor, start,
                    SourceSpan.Kind.RAW_FALLBACK,
                    source.substring(cursor, start)));
                diags.add(new FormatDiagnostic(
                    FormatDiagnostic.Severity.WARNING,
                    cursor, start,
                    "tokenizer gap recovered as RAW_FALLBACK ("
                        + (start - cursor) + " chars)"));
                rawCount++;
            }
            SourceSpan.Kind kind = classifyToken(t.tokentype);
            // Normally a token's text equals its source bytes, but if its end
            // was clamped (out-of-range, above) the token text is longer than
            // its span; use the source slice so reconstruction (Σ span.text ==
            // source) holds exactly.
            String spanText = t.toString();
            if (spanText.length() != end - start) {
                spanText = source.substring(start, end);
            }
            spans.add(new SourceSpan(start, end, kind, spanText));
            cursor = end;
        }
        if (cursor < source.length()) {
            // Trailing un-tokenized bytes: trailing whitespace usually shows
            // up as ttwhitespace tokens, but if anything was missed we
            // record it as RAW_FALLBACK rather than truncate.
            String tail = source.substring(cursor);
            // Classify trailing whitespace correctly so it doesn't trip the
            // "zero RAW_FALLBACK on legal SQL" smoke. A trailing newline
            // outside any tokenized span is TRIVIA, not RAW_FALLBACK.
            SourceSpan.Kind kind = isPureWhitespace(tail)
                ? SourceSpan.Kind.TRIVIA
                : SourceSpan.Kind.RAW_FALLBACK;
            spans.add(new SourceSpan(cursor, source.length(), kind, tail));
            if (kind == SourceSpan.Kind.RAW_FALLBACK) {
                diags.add(new FormatDiagnostic(
                    FormatDiagnostic.Severity.WARNING,
                    cursor, source.length(),
                    "trailing tokenizer gap recovered as RAW_FALLBACK ("
                        + (source.length() - cursor) + " chars)"));
                rawCount++;
            }
        }

        return new SourceSpanLedger(source,
            Collections.unmodifiableList(spans),
            rawCount,
            Collections.unmodifiableList(diags));
    }

    /**
     * Classify a token type into a {@link SourceSpan.Kind}. Whitespace is
     * {@link SourceSpan.Kind#TRIVIA}; comments, string literals, and
     * quoted identifiers are {@link SourceSpan.Kind#PROTECTED}; everything
     * else is {@link SourceSpan.Kind#TOKEN}. Slice S9 extends this with
     * finer-grained protected-zone detection (hints, NO_FORMAT blocks).
     */
    public static SourceSpan.Kind classifyToken(ETokenType type) {
        if (type == null) return SourceSpan.Kind.TOKEN;
        switch (type) {
            case ttwhitespace:
            case ttreturn:
                return SourceSpan.Kind.TRIVIA;
            case ttsimplecomment:
            case ttbracketedcomment:
            case ttCPPComment:
            case ttsqstring:
            case ttdqstring:
            case ttdbstring:
            case ttbrstring:
                return SourceSpan.Kind.PROTECTED;
            default:
                return SourceSpan.Kind.TOKEN;
        }
    }

    private static boolean isPureWhitespace(String s) {
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c != ' ' && c != '\t' && c != '\n' && c != '\r'
                && c != '\f' && c != 0x0B) {
                return false;
            }
        }
        return true;
    }

    /** The original input the ledger was built from. */
    public String getSource() {
        return source;
    }

    /** Unmodifiable, byte-order-stable list of every span. */
    public List<SourceSpan> getSpans() {
        return spans;
    }

    /** Number of {@link SourceSpan.Kind#RAW_FALLBACK} spans in the ledger. */
    public int getRawFallbackCount() {
        return rawFallbackCount;
    }

    /**
     * Diagnostics emitted while building the ledger. Currently this list
     * has one {@link FormatDiagnostic.Severity#WARNING} entry per
     * {@link SourceSpan.Kind#RAW_FALLBACK} span; the engine appends these
     * to the per-call {@code Pp2FormatResult.diagnostics} list (S16).
     * Returns an unmodifiable view.
     */
    public List<FormatDiagnostic> getDiagnostics() {
        return diagnostics;
    }

    /** Convenience: rebuild the source by concatenating every span's text. */
    public String reconstruct() {
        StringBuilder sb = new StringBuilder(source.length());
        for (SourceSpan s : spans) sb.append(s.getText());
        return sb.toString();
    }

    @Override
    public String toString() {
        return "SourceSpanLedger{spans=" + spans.size()
            + " rawFallback=" + rawFallbackCount
            + " sourceLen=" + source.length() + "}";
    }
}