package gudusoft.gsqlparser.pp2.render;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.pp.logger.PPLogger;
import gudusoft.gsqlparser.pp.para.GFmtOpt;
import gudusoft.gsqlparser.pp.stmtformatter.FormatterFactory;
import gudusoft.gsqlparser.pp2.Pp2FormatOptions;
import gudusoft.gsqlparser.pp2.RendererId;
import gudusoft.gsqlparser.pp2.region.RegionParseOutcome;
import gudusoft.gsqlparser.pp2.token.DoubleQuotedStrings;
import gudusoft.gsqlparser.pp2.token.Pp2TokenStream;
import gudusoft.gsqlparser.pp2.token.TokenEquivalence;

/**
 * The "fast lane" pp2 renderer: hands an {@code AST_OK} region's parser to
 * the existing {@code FormatterFactory.pp(parser, opt)} machinery, then
 * runs a {@link TokenEquivalence} guard on the result to catch any drift
 * between input and output.
 *
 * <h2>Two failure modes</h2>
 *
 * <ol>
 *   <li><b>{@code pp()} throws</b> — possible because pp's mediators /
 *       processors traverse arbitrary AST shapes and may break on edge
 *       cases the parser accepts but pp does not yet handle. The throwable
 *       is logged via {@link PPLogger#error(Throwable)} and the delegate
 *       returns {@code null} so the engine falls through to the next
 *       renderer in the chain.</li>
 *   <li><b>{@code pp()} silently drifts</b> — produces output that no
 *       longer round-trips back to the original token sequence (a comment
 *       dropped, a literal rewritten, etc.). The
 *       {@link TokenEquivalence#equalsModuloFormatting} guard from S10
 *       detects this. Failures are logged via {@link PPLogger#info(String)}
 *       and the delegate returns {@code null}.</li>
 * </ol>
 *
 * <p>The guard is plan-mandated insurance against pp drift. Plan §13/R4
 * names this as the explicit mitigation; the guard converts silent bugs
 * into a recoverable fall-through plus a log line.
 *
 * <h2>Inputs the delegate can rely on</h2>
 *
 * <p>The engine only dispatches {@code AST_OK} outcomes to this renderer,
 * so the delegate assumes:
 * <ul>
 *   <li>{@link RegionParseOutcome#getStatus()} is
 *       {@link RegionParseOutcome.Status#AST_OK AST_OK} —
 *       defended by an explicit guard returning {@code null} otherwise.</li>
 *   <li>{@link RegionParseOutcome#getParser()} is non-null and holds
 *       exactly one statement (the S12 contract — verified by
 *       {@code ParseRecoveryEngineTest.parseAll_outcomeParserRendersOnlyItsRegion}).</li>
 *   <li>{@link RegionParseOutcome#getParsedSql()} is the source slice the
 *       parser actually saw (with MSSQL/Sybase {@code GO} stripped) — the
 *       guard compares pp's output against this slice, not the raw range
 *       text.</li>
 * </ul>
 *
 * <p>Plan reference: §5.2, §7.3/S13, §7.4/S13, §10.2, §13/R4.
 */
public class GuardedAstDelegate implements RegionRenderer {

    private final EDbVendor vendor;
    private long guardFailureCount;
    private long throwableCount;
    private long successCount;
    /** The stream last scanned for double-quoted strings, and the offset after which they begin. */
    private Pp2TokenStream scannedStream;
    private long stringsAfter = DoubleQuotedStrings.NONE;

    /**
     * Construct a delegate for the supplied vendor. The vendor is used by
     * the {@link TokenEquivalence} guard to tokenise both the input and the
     * output for the comparison.
     *
     * @throws NullPointerException if {@code vendor} is null
     */
    public GuardedAstDelegate(EDbVendor vendor) {
        if (vendor == null) throw new NullPointerException("vendor");
        this.vendor = vendor;
    }

    public EDbVendor getVendor() { return vendor; }

    /** Count of regions that passed both the parse and the guard. */
    public long getSuccessCount() { return successCount; }

    /** Count of regions where pp() threw. */
    public long getThrowableCount() { return throwableCount; }

    /** Count of regions where pp() returned text that failed the guard. */
    public long getGuardFailureCount() { return guardFailureCount; }

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

    @Override
    public String render(RegionParseOutcome outcome,
                         Pp2TokenStream stream,
                         Pp2FormatOptions opts) {
        if (outcome == null) throw new NullPointerException("outcome");
        if (opts == null) throw new NullPointerException("opts");
        // The engine only dispatches AST_OK outcomes here, but defend the
        // contract anyway so a future caller's mistake is loud, not silent.
        if (outcome.getStatus() != RegionParseOutcome.Status.AST_OK) {
            return null;
        }
        TGSqlParser parser = outcome.getParser();
        if (parser == null) {
            PPLogger.info("GuardedAstDelegate: AST_OK outcome with null parser "
                + "(should be impossible per S12 contract): " + outcome);
            return null;
        }

        return renderWith(parser, outcome.getParsedSql(), opts, stringsAtStart(outcome, stream));
    }

    /**
     * Whether a statement before the region turned the quoted-identifier option off, so that every
     * double-quoted text of the region may be a string ({@link DoubleQuotedStrings}). The region is
     * parsed, formatted and checked without the statements before it; this is what its check must be
     * told about them.
     */
    private boolean stringsAtStart(RegionParseOutcome outcome, Pp2TokenStream stream) {
        if (stream == null || outcome.getRange() == null) return false;
        if (stream != scannedStream) {
            scannedStream = stream;
            stringsAfter = DoubleQuotedStrings.stringsAfter(vendor, stream);
        }
        int start = outcome.getRange().getStartTokenIndex();
        if (start < 0 || start >= stream.size() || stream.get(start).getSourceToken() == null) return false;
        return stream.get(start).getSourceToken().offset > stringsAfter;
    }

    /**
     * Render via the supplied parser. Exposed {@code protected} so tests
     * (in a different package) can drive guard-failure scenarios via a
     * subclass with a stand-in {@link #invokePpFormatter}. Not part of the
     * public API; production callers go through {@link #render}.
     */
    protected String renderWith(TGSqlParser parser, String inputSlice,
                                Pp2FormatOptions opts) {
        return renderWith(parser, inputSlice, opts, false);
    }

    /**
     * {@link #renderWith(TGSqlParser, String, Pp2FormatOptions)} for a region after a statement
     * that turned the quoted-identifier option off when {@code stringsAtStart}: the region's check
     * then refuses any change to a double-quoted text.
     */
    protected String renderWith(TGSqlParser parser, String inputSlice,
                                Pp2FormatOptions opts, boolean stringsAtStart) {
        GFmtOpt gfmt = opts.toGFmtOpt();
        String astOutput;
        try {
            astOutput = invokePpFormatter(parser, gfmt);
        } catch (Throwable t) {
            // pp's mediators / processors may break on AST shapes the
            // parser accepts. Recover by falling through to the next
            // renderer; log so the failure is visible during development.
            throwableCount++;
            PPLogger.error(t);
            PPLogger.info("GuardedAstDelegate: FormatterFactory.pp threw on a "
                + "region; falling through to next renderer. input=\""
                + previewForLog(inputSlice) + "\"");
            return null;
        }

        if (astOutput == null) {
            // pp() returning null would be unusual but is not a contract
            // violation. Treat the same as a guard failure (and emit a
            // fall-through null on our own).
            guardFailureCount++;
            PPLogger.info("GuardedAstDelegate: FormatterFactory.pp returned null"
                + " for input=\"" + previewForLog(inputSlice) + "\"");
            return null;
        }
        // Note: an empty-string output for a non-empty input slice will
        // naturally fail the TokenEquivalence guard below (input has solid
        // tokens, output has none), so we do not treat "" specially here —
        // the guard is authoritative.

        // Token-equivalence guard. The comparison is dialect-aware: same
        // vendor used to tokenise both sides; case-insensitive matches the
        // default formatter behaviour.
        boolean ok;
        try {
            ok = TokenEquivalence.equalsModuloFormatting(
                inputSlice, astOutput, opts, vendor, true, stringsAtStart);
        } catch (Throwable t) {
            // A throw from the guard itself should not crash the engine.
            // Treat as guard failure.
            guardFailureCount++;
            PPLogger.error(t);
            PPLogger.info("GuardedAstDelegate: TokenEquivalence guard threw; "
                + "falling through. input=\"" + previewForLog(inputSlice) + "\"");
            return null;
        }
        if (!ok) {
            guardFailureCount++;
            PPLogger.info("GuardedAstDelegate: AST delegate guard failed for "
                + "input=\"" + previewForLog(inputSlice)
                + "\" output=\"" + previewForLog(astOutput) + "\"");
            return null;
        }
        successCount++;
        return astOutput;
    }

    /**
     * Indirect-call seam so tests can subclass and substitute a deterministic
     * stand-in for {@code FormatterFactory.pp()}. Production code always
     * goes through the real formatter. {@code protected} so the tests in
     * a different package can override.
     */
    protected String invokePpFormatter(TGSqlParser parser, GFmtOpt opt) {
        return FormatterFactory.pp(parser, opt);
    }

    /** Truncate long inputs/outputs for log messages. */
    private static String previewForLog(String s) {
        if (s == null) return "<null>";
        final int max = 120;
        String oneLine = s.replace('\n', ' ').replace('\r', ' ');
        if (oneLine.length() <= max) return oneLine;
        return oneLine.substring(0, max) + "...(" + s.length() + " chars)";
    }
}