package gudusoft.gsqlparser.pp2.render;

import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.pp.logger.PPLogger;
import gudusoft.gsqlparser.pp2.Pp2FormatOptions;
import gudusoft.gsqlparser.pp2.RendererId;
import gudusoft.gsqlparser.pp2.region.RegionParseOutcome;
import gudusoft.gsqlparser.pp2.region.StatementRange;
import gudusoft.gsqlparser.pp2.token.Pp2Token;
import gudusoft.gsqlparser.pp2.token.Pp2TokenStream;
import gudusoft.gsqlparser.pp2.token.TokenRole;
import gudusoft.gsqlparser.pp2.zone.CommentPolicy;

/**
 * The MVP fallback renderer (plan §7.3/S14): walks the region's slice of a
 * {@link Pp2TokenStream} and emits each token's text with light spacing.
 * No clause-level layout, no recognition pipeline — pure token passthrough.
 *
 * <h2>Why it exists</h2>
 *
 * <p>{@link GuardedAstDelegate} (S13) only fires on regions whose source
 * actually parses. Everything else — invalid SQL, partial scripts, vendor
 * fragments the parser doesn't yet support — needs a renderer that
 * guarantees <b>every solid input token appears in the output, in order</b>
 * without throwing or losing bytes. Until the lexical island pipeline
 * (S31) ships, the conservative renderer is the only safety net the engine
 * has. Even after S31 lands it stays as the last-resort renderer for
 * cases where the island pipeline itself throws.
 *
 * <h2>Output shape</h2>
 *
 * <p>Two operating modes, selected by
 * {@link Pp2FormatOptions#commentPolicy}:
 *
 * <ul>
 *   <li><b>{@link CommentPolicy#PRESERVE} (default):</b> emit each token's
 *       original preceding whitespace verbatim — the renderer is a
 *       byte-exact passthrough modulo the inter-region leading trivia,
 *       which is handed off to the region assembler (S15).</li>
 *   <li><b>{@link CommentPolicy#REANCHOR} / {@link CommentPolicy#REFLOW}:</b>
 *       a single space between consecutive tokens, with a {@code "\n"}
 *       inserted after every {@code ";"}. No other layout choices are
 *       made — the renderer never reorders, never drops, never merges.</li>
 * </ul>
 *
 * <p>Regardless of policy, tokens carrying the
 * {@link TokenRole#NO_FORMAT_ZONE} role are emitted with their original
 * preceding whitespace, so {@code --BEGIN_NO_FORMAT}/{@code --END_NO_FORMAT}
 * blocks survive byte-exact through any policy.
 *
 * <h2>Leading-trivia ownership</h2>
 *
 * <p>The renderer never emits leading whitespace for the <i>first</i>
 * token of the range — that whitespace belongs to the inter-region gap
 * handled by the assembler (S15). The renderer's output starts with the
 * first token's text and ends with the last token's text. Trailing
 * trivia after the last token is similarly the assembler's responsibility.
 *
 * <h2>Content-preservation guarantee</h2>
 *
 * <p>Every {@link Pp2Token} in the range contributes its text to the
 * output exactly once, in source order; nothing is dropped, reordered, or
 * collapsed. This guarantee is verified by
 * {@link gudusoft.gsqlparser.pp2.token.TokenEquivalence} in
 * {@code ConservativeTokenRendererTest}.
 *
 * <p>Plan reference: §5.2, §7.3/S14, §7.4/S14.
 */
public final class ConservativeTokenRenderer implements RegionRenderer {

    private long renderedRegionCount;
    private long emittedTokenCount;

    /** Number of regions {@code render(...)} has produced output for. */
    public long getRenderedRegionCount() { return renderedRegionCount; }

    /** Number of tokens emitted across all rendered regions. */
    public long getEmittedTokenCount() { return emittedTokenCount; }

    @Override
    public RendererId id() { return RendererId.CONSERVATIVE; }

    @Override
    public String render(RegionParseOutcome outcome,
                         Pp2TokenStream stream,
                         Pp2FormatOptions opts) {
        if (outcome == null) throw new NullPointerException("outcome");
        if (stream == null) throw new NullPointerException("stream");
        if (opts == null) throw new NullPointerException("opts");

        StatementRange range = outcome.getRange();
        int start = range.getStartTokenIndex();
        int end = Math.min(range.getEndTokenIndex(), stream.size());
        if (start >= end) {
            // Empty range — a valid rendering for an empty region. Returning
            // "" here matches the RegionRenderer contract ("" is not the
            // fall-through sentinel).
            renderedRegionCount++;
            return "";
        }

        boolean preserve = opts.commentPolicy == CommentPolicy.PRESERVE;
        StringBuilder out = new StringBuilder();
        boolean prevWasSemicolon = false;
        boolean prevWasLineComment = false;
        String parsedSql = outcome.getParsedSql();
        int parsedSqlBase = range.getStartOffset();

        for (int i = start; i < end; ) {
            Pp2Token tok;
            try {
                tok = stream.get(i);
            } catch (Throwable t) {
                // Defensive: the stream should never throw on a valid index
                // but the renderer's no-throw contract is absolute.
                PPLogger.error(t);
                PPLogger.info("ConservativeTokenRenderer: stream.get(" + i
                    + ") threw; truncating output. range=" + range);
                break;
            }
            if (tok == null) { i++; continue; }

            if (tok.hasRole(TokenRole.NO_FORMAT_ZONE)) {
                // Emit the entire contiguous NO_FORMAT_ZONE span byte-exact
                // by slicing the source bytes from parsedSql. This recovers
                // the original linebreak-vs-blank ordering that the token
                // stream's precedingLinebreaks/precedingBlanks counts lose.
                int spanEnd = i;
                while (spanEnd < end
                    && stream.get(spanEnd).hasRole(TokenRole.NO_FORMAT_ZONE)) {
                    spanEnd++;
                }
                // Route the inter-token separator through the standard
                // path so PRESERVE preserves indentation, prevWasLineComment
                // forces a newline (with preserved indent in PRESERVE
                // mode), and prevWasSemicolon / fall-through still apply.
                // Codex round-2 P2 #1: the previous version called
                // ensureTrailingNewline() which dropped PRESERVE indent in
                // the "-- c\n  --BEGIN_NO_FORMAT" case.
                if (i > start) {
                    appendSeparator(out, stream.get(i), preserve,
                        prevWasSemicolon, prevWasLineComment);
                }
                String spanText = sliceFrozenZone(parsedSql, parsedSqlBase,
                    stream, i, spanEnd - 1);
                if (spanText == null) {
                    // Source slicing failed (e.g., outcome.getParsedSql() did
                    // not cover the absolute offsets, or text did not
                    // round-trip). Fall back to per-token emission so
                    // content is still preserved.
                    for (int j = i; j < spanEnd; j++) {
                        Pp2Token zoneTok = stream.get(j);
                        if (j > i) {
                            appendOriginalWhitespace(out, zoneTok);
                        }
                        String t2 = zoneTok.getText();
                        if (t2 != null) out.append(t2);
                        emittedTokenCount++;
                    }
                } else {
                    out.append(spanText);
                    emittedTokenCount += (spanEnd - i);
                }
                Pp2Token last = stream.get(spanEnd - 1);
                String lastText = last.getText();
                prevWasSemicolon = lastText != null && ";".equals(lastText);
                // --END_NO_FORMAT is itself a line comment; force the next
                // token to start on a new line so a non-PRESERVE renderer
                // does not splice "--END_NO_FORMAT SELECT 2" into one line.
                prevWasLineComment = isLineComment(last);
                i = spanEnd;
                continue;
            }

            String text = tok.getText();
            if (text == null) text = "";

            if (i > start) {
                appendSeparator(out, tok, preserve, prevWasSemicolon,
                    prevWasLineComment);
            }
            out.append(text);

            prevWasSemicolon = ";".equals(text);
            prevWasLineComment = isLineComment(tok);
            emittedTokenCount++;
            i++;
        }

        renderedRegionCount++;
        return out.toString();
    }

    private static boolean isLineComment(Pp2Token tok) {
        if (tok == null) return false;
        return tok.hasRole(TokenRole.COMMENT_LINE);
    }

    /**
     * Slice the byte-exact source text for the NO_FORMAT_ZONE span covering
     * stream tokens {@code [first, last]} (inclusive). Returns {@code null}
     * if any input is unusable, OR if the slice does not round-trip to the
     * expected first/last token texts.
     *
     * <p>{@code parsedSql} is the engine-supplied region source slice. The
     * absolute offsets carried by {@link TSourceToken} are translated into
     * relative positions by subtracting {@code base = range.startOffset}.
     *
     * <p>The text-match validation catches the case where
     * {@code parsedSql} is not the contiguous source bytes for the range
     * (e.g., the engine stripped a trailing {@code GO} for MSSQL, or any
     * future normalization shifted offsets). When the slice's leading
     * characters don't match the first token's text — or trailing don't
     * match the last token's text — we treat the source as untrusted and
     * fall back to per-token emission so content is still preserved.
     */
    private static String sliceFrozenZone(String parsedSql, int base,
                                          Pp2TokenStream stream,
                                          int first, int last) {
        if (parsedSql == null) return null;
        Pp2Token f = stream.get(first);
        Pp2Token l = stream.get(last);
        if (f == null || l == null) return null;
        TSourceToken fSt = f.getSourceToken();
        TSourceToken lSt = l.getSourceToken();
        if (fSt == null || lSt == null) return null;
        String lText = l.getText();
        if (lText == null) lText = "";
        int relStart = (int) fSt.offset - base;
        int relEnd = (int) lSt.offset + lText.length() - base;
        if (relStart < 0 || relEnd > parsedSql.length() || relStart > relEnd) {
            return null;
        }
        // Defensive: verify every token in the span round-trips to the
        // expected source bytes at its relative offset. A non-null but
        // wrong slice can happen if parsedSql is not the contiguous range
        // source (e.g., GO-stripped). Endpoint-only validation could be
        // fooled by a coincidental match at the boundaries; checking
        // every token catches a middle-section shift. (Codex R2 P2 #2.)
        for (int k = first; k <= last; k++) {
            Pp2Token t = stream.get(k);
            if (t == null) return null;
            TSourceToken st = t.getSourceToken();
            if (st == null) return null;
            String text = t.getText();
            if (text == null) text = "";
            int rel = (int) st.offset - base;
            if (rel < relStart || rel + text.length() > relEnd) return null;
            if (!parsedSql.regionMatches(rel, text, 0, text.length())) {
                return null;
            }
        }
        return parsedSql.substring(relStart, relEnd);
    }

    /**
     * Append the inter-token whitespace separator preceding {@code tok}.
     * Precedence:
     *
     * <ol>
     *   <li>Previous token was a line comment ({@code --} or {@code #})
     *       → emit {@code "\n"}. Without this, a non-PRESERVE renderer
     *       would splice {@code "-- comment SELECT 2"} into one line and
     *       comment out the next token. The check fires BEFORE the
     *       policy branches so it applies under both PRESERVE and
     *       non-PRESERVE: if PRESERVE's source whitespace already has a
     *       linebreak, we use that; otherwise we force one in.</li>
     *   <li>{@code PRESERVE} policy → emit original
     *       {@code precedingLinebreaks} + {@code precedingBlanks}. Two
     *       source tokens that were directly adjacent stay adjacent.</li>
     *   <li>Previous solid token was {@code ;} → emit {@code "\n"}. The
     *       "linebreak after ;" rule (plan §7.3/S14). PRESERVE mode skips
     *       this branch — the source whitespace is the source of truth.</li>
     *   <li>Otherwise → emit a single space.</li>
     * </ol>
     *
     * <p>{@code NO_FORMAT_ZONE} tokens are not routed here — the caller
     * handles the contiguous zone by source-slicing for byte-exact
     * fidelity.
     */
    private static void appendSeparator(StringBuilder out, Pp2Token tok,
                                        boolean preserve,
                                        boolean prevWasSemicolon,
                                        boolean prevWasLineComment) {
        if (prevWasLineComment) {
            if (preserve) {
                // PRESERVE: emit original whitespace, but guarantee at
                // least one newline so the line comment terminates.
                int linebreaks = tok.getPrecedingLinebreaks();
                if (linebreaks <= 0) {
                    out.append('\n');
                } else {
                    for (int k = 0; k < linebreaks; k++) out.append('\n');
                }
                int blanks = tok.getPrecedingBlanks();
                for (int k = 0; k < blanks; k++) out.append(' ');
            } else {
                out.append('\n');
            }
            return;
        }
        if (preserve) {
            appendOriginalWhitespace(out, tok);
            return;
        }
        if (prevWasSemicolon) {
            out.append('\n');
            return;
        }
        out.append(' ');
    }

    private static void appendOriginalWhitespace(StringBuilder out, Pp2Token tok) {
        int linebreaks = tok.getPrecedingLinebreaks();
        for (int k = 0; k < linebreaks; k++) out.append('\n');
        int blanks = tok.getPrecedingBlanks();
        for (int k = 0; k < blanks; k++) out.append(' ');
    }
}