package gudusoft.gsqlparser.pp2.region;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.EResolverType;
import gudusoft.gsqlparser.ETokenType;
import gudusoft.gsqlparser.TGSqlParser;
import gudusoft.gsqlparser.TSourceToken;
import gudusoft.gsqlparser.TSyntaxError;
import gudusoft.gsqlparser.pp2.Pp2FormatOptions;
import gudusoft.gsqlparser.pp2.token.Pp2Token;
import gudusoft.gsqlparser.pp2.token.Pp2TokenStream;
import gudusoft.gsqlparser.pp2.token.TokenRole;

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

/**
 * Parses statement regions produced by
 * {@link StatementBoundaryDetector#detect(Pp2TokenStream, EDbVendor)} and
 * tags each one as {@link RegionParseOutcome.Status#AST_OK AST_OK},
 * {@link RegionParseOutcome.Status#AST_ERROR AST_ERROR}, or
 * {@link RegionParseOutcome.Status#TRIVIA TRIVIA}.
 *
 * <h2>Per-region parsing with fresh parsers on success</h2>
 *
 * <p>{@link #parseAll(List)} pre-marks every {@code TRIVIA} range and every
 * non-trivia range whose source slice exceeds
 * {@link Pp2FormatOptions#maxRegionParseChars} (the latter becomes
 * {@code AST_ERROR} with an engine note). Every remaining range is parsed
 * individually. The pool's single parser serves as the <b>probe</b>; if the
 * probe parse succeeds, the engine re-parses the same slice into a freshly
 * allocated {@link TGSqlParser} so the outcome's
 * {@link RegionParseOutcome#getParser()} contains exactly one statement and
 * can be handed to {@code FormatterFactory.pp(parser, opt)} without
 * rendering its siblings. {@code AST_ERROR} outcomes do not need a
 * dedicated parser — the lexical fallback (S14 / S31) renders them.
 *
 * <p>This is plan §13/R1's "fresh parser per region" contingency adopted as
 * the default. The cost is one extra parser allocation and re-parse per
 * {@code AST_OK} region; the benefit is that every outcome returned from a
 * single {@code parseAll} call is mutually valid in any consumption order
 * and {@code GuardedAstDelegate} (S13) can safely invoke pp's
 * statement-iterating renderer on each one without observing neighbours.
 *
 * <p>A previous draft of this engine attempted a "lazy full-script first"
 * optimisation: one {@code parse()} on the entire original SQL, with all
 * happy-path outcomes sharing the parser snapshot. That broke
 * {@code FormatterFactory.pp(parser, opt)} which iterates every statement
 * in {@code parser.sqlstatements} — each outcome would have rendered the
 * whole script. The optimisation is deferred (plan §16/Q3 / S37) and may
 * be re-introduced once a render API that targets a single statement
 * exists.
 *
 * <h2>Safety valves and failure modes</h2>
 *
 * <ul>
 *   <li>Regions whose source span exceeds
 *       {@link Pp2FormatOptions#maxRegionParseChars} skip the parse attempt
 *       entirely and are returned as {@code AST_ERROR} with an engine note —
 *       the lexical fallback (S14 / S31) handles the rendering.</li>
 *   <li>Any {@link Throwable} thrown by {@link TGSqlParser#parse()} is
 *       caught and converted to an {@code AST_ERROR} outcome. The pool is
 *       still reset before the next attempt, so a single misbehaving region
 *       does not corrupt the rest of the script.</li>
 *   <li>Trivia regions — those containing nothing but whitespace, line
 *       comments, block comments, and (optionally) the trailing terminator —
 *       are short-circuited to {@code TRIVIA} without invoking the parser.</li>
 * </ul>
 *
 * <h2>AST lifetime</h2>
 *
 * <p>The pool is size-1. Each {@link #parseRegion(StatementRange)} call
 * overwrites the prior region's parser state in place, which means a
 * {@link RegionParseOutcome#getParser() parser} reference from an earlier
 * {@code parseRegion} call becomes stale once the next call returns. See
 * {@link RegionParseOutcome the outcome class Javadoc} for the contract.
 * {@link #parseAll(List)}, by contrast, allocates a fresh parser per
 * {@code AST_OK} region, so outcomes returned from a single
 * {@code parseAll} call are mutually valid and outlive the engine call
 * itself (each carries an isolated parser of its own).
 *
 * <p>This class is single-threaded by construction (the pool's threading
 * contract); concurrent use is undefined.
 *
 * <p>Plan reference: §5.1, §7.3/S12, §7.4/S12, §10.4, §13/R1.
 */
public final class ParseRecoveryEngine {

    private final EDbVendor vendor;
    private final String originalSql;
    private final Pp2FormatOptions opts;
    private final Pp2TokenStream stream;
    private final ParserPool pool;

    public ParseRecoveryEngine(EDbVendor vendor,
                               String originalSql,
                               Pp2TokenStream stream,
                               Pp2FormatOptions opts) {
        if (vendor == null) throw new NullPointerException("vendor");
        if (originalSql == null) throw new NullPointerException("originalSql");
        if (stream == null) throw new NullPointerException("stream");
        if (opts == null) throw new NullPointerException("opts");
        this.vendor = vendor;
        this.originalSql = originalSql;
        this.opts = opts;
        this.stream = stream;
        this.pool = new ParserPool(vendor);
    }

    /** Pool access — exposed for tests / introspection. */
    public ParserPool getPool() { return pool; }

    /** EDbVendor this engine targets. */
    public EDbVendor getVendor() { return vendor; }

    /**
     * Parse all ranges. The pipeline:
     *
     * <ol>
     *   <li>Tag every {@code TRIVIA} range up front (no parser involvement).</li>
     *   <li>Tag every non-trivia range whose source slice exceeds
     *       {@link Pp2FormatOptions#maxRegionParseChars} as {@code AST_ERROR}
     *       with an engine note.</li>
     *   <li>For every remaining range, run a probe parse on the pool. On
     *       {@code AST_OK}, re-parse the slice into a freshly-allocated
     *       {@link TGSqlParser} so the outcome's parser holds exactly one
     *       statement and is safe to hand to
     *       {@code FormatterFactory.pp(parser, opt)}.</li>
     * </ol>
     *
     * @param ranges non-null list of statement ranges, in source order
     * @return one outcome per input range, in the same order
     * @throws NullPointerException if {@code ranges} or any element is null
     */
    public List<RegionParseOutcome> parseAll(List<StatementRange> ranges) {
        if (ranges == null) throw new NullPointerException("ranges");
        for (StatementRange r : ranges) {
            if (r == null) throw new NullPointerException("ranges contains null");
        }

        RegionParseOutcome[] outArr = new RegionParseOutcome[ranges.size()];

        // Steps 1+2: classify trivia and pre-mark oversized non-trivia ranges.
        // Both short-circuit without touching the parser.
        List<Integer> needParse = new ArrayList<Integer>();
        for (int i = 0; i < ranges.size(); i++) {
            StatementRange r = ranges.get(i);
            String slice = sliceFor(r);
            if (isTrivia(r)) {
                outArr[i] = RegionParseOutcome.trivia(r, slice);
                continue;
            }
            if (slice.length() > opts.maxRegionParseChars) {
                outArr[i] = oversized(r, slice);
                continue;
            }
            needParse.add(i);
        }

        // Step 3: probe-with-pool, promote-to-fresh-parser-on-success per
        // range. Each AST_OK outcome owns a dedicated parser so siblings do
        // not appear in pp(parser, opt) output.
        for (int idx : needParse) {
            outArr[idx] = parseRegionWithFreshParserOnSuccess(ranges.get(idx));
        }
        return wrap(outArr);
    }

    private static List<RegionParseOutcome> wrap(RegionParseOutcome[] arr) {
        return Collections.unmodifiableList(new ArrayList<RegionParseOutcome>(
            java.util.Arrays.asList(arr)));
    }

    private RegionParseOutcome oversized(StatementRange r, String slice) {
        return RegionParseOutcome.astError(r, slice,
            Collections.<TSyntaxError>emptyList(),
            "region exceeds maxRegionParseChars=" + opts.maxRegionParseChars
                + " (size=" + slice.length() + ")");
    }

    /**
     * Parse a single region. Never throws.
     *
     * <p>Behaviour:
     * <ol>
     *   <li>If the region is {@link #isTrivia(StatementRange) trivia},
     *       returns {@link RegionParseOutcome.Status#TRIVIA TRIVIA} without
     *       touching the parser.</li>
     *   <li>If the region's source span exceeds
     *       {@code opts.maxRegionParseChars}, returns
     *       {@code AST_ERROR} with an engine note. Skips parsing entirely.</li>
     *   <li>Otherwise resets the pool, hands the region source slice to the
     *       parser, and captures the outcome. Any {@code Throwable} from
     *       {@code parse()} is wrapped as {@code AST_ERROR}.</li>
     * </ol>
     */
    public RegionParseOutcome parseRegion(StatementRange range) {
        if (range == null) throw new NullPointerException("range");
        String src = sliceFor(range);

        if (isTrivia(range)) {
            return RegionParseOutcome.trivia(range, src);
        }
        if (src.length() > opts.maxRegionParseChars) {
            return oversized(range, src);
        }

        pool.reset();
        TGSqlParser parser = pool.borrow();
        return parseSliceInto(parser, range, src);
    }

    /**
     * Per-region fallback variant: attempt the parse via the pool, and on
     * {@code AST_OK} re-run the parse on a freshly-allocated parser dedicated
     * to this outcome. {@code AST_ERROR} outcomes do not need a dedicated
     * parser; they're rendered by the lexical fallback in S14/S31, not by
     * {@code FormatterFactory.pp(parser, opt)}.
     */
    private RegionParseOutcome parseRegionWithFreshParserOnSuccess(StatementRange range) {
        String src = sliceFor(range);
        if (isTrivia(range)) return RegionParseOutcome.trivia(range, src);
        if (src.length() > opts.maxRegionParseChars) return oversized(range, src);

        // Probe with the pool first — cheap, and avoids allocating a parser
        // for AST_ERROR regions.
        pool.reset();
        TGSqlParser pooled = pool.borrow();
        RegionParseOutcome probe = parseSliceInto(pooled, range, src);
        if (probe.getStatus() != RegionParseOutcome.Status.AST_OK) {
            return probe;
        }
        // Promote the success onto a dedicated, fresh parser so the outcome's
        // AST is not invalidated by a later pool reset within this parseAll
        // call.
        TGSqlParser fresh = new TGSqlParser(vendor);
        return parseSliceInto(fresh, range, src);
    }

    /**
     * Run a parse of {@code src} on the supplied parser and convert the
     * outcome to a {@link RegionParseOutcome}. Never throws.
     */
    private RegionParseOutcome parseSliceInto(TGSqlParser parser,
                                              StatementRange range,
                                              String src) {
        parser.sqltext = src;
        // pp2 is a FORMATTER: it needs the parse tree, never semantic name
        // resolution (column->table linking). Auto-running TSQLResolver2 on
        // every region parse dominates time AND heap — on a script with
        // hundreds of regions it pushes the formatter into GC thrash / OOM
        // under a constrained heap (-Xmx512m), even though the formatted output
        // is identical with or without resolution. Disabling the resolver per
        // region is the single biggest pp2-side scaling lever (plan §13/R14,
        // R16; surfaced in S36, gates S37). Set after sqltext and immune to
        // ParserPool.reset()/prepareForReuse() which resets options.
        parser.setResolverType(EResolverType.NONE);
        int rc;
        try {
            rc = parser.parse();
        } catch (Throwable t) {
            // Snapshot whatever diagnostics the parser may have collected
            // before throwing; do not rely on getSyntaxErrors() being safe to
            // call, but try.
            List<TSyntaxError> partial = safeSyntaxErrors(parser);
            return RegionParseOutcome.astError(range, src, partial,
                "parser threw: " + t.getClass().getSimpleName()
                    + (t.getMessage() != null ? ": " + t.getMessage() : ""));
        }

        List<TSyntaxError> errors = safeSyntaxErrors(parser);
        if (rc == 0 && parser.getErrorCount() == 0) {
            return RegionParseOutcome.astOk(range, src,
                parser.getSqlstatements(), parser);
        }
        return RegionParseOutcome.astError(range, src, errors,
            errors.isEmpty() ? "parser returned " + rc + " with no diagnostics" : null);
    }

    /**
     * True when the range contains no solid tokens — only whitespace,
     * comments, and at most a trailing terminator ({@code ;} or
     * vendor-specific {@code GO}). Trivia ranges are short-circuited to
     * {@code TRIVIA} and never reach the parser.
     *
     * <p>The last-token-as-terminator exclusion is keyed off
     * {@link StatementRange#getTerminator()} rather than text matching, so a
     * mid-statement identifier that happens to spell {@code GO} is still
     * treated as solid.
     */
    public boolean isTrivia(StatementRange range) {
        if (range == null) throw new NullPointerException("range");
        int lastIdx = range.getEndTokenIndex() - 1;
        StatementRange.Terminator term = range.getTerminator();
        for (int i = range.getStartTokenIndex(); i < range.getEndTokenIndex(); i++) {
            if (i >= stream.size()) break;
            // Skip the range's terminator slot for solid-detection purposes:
            // SEMICOLON is already filtered by isSolid via tokentype, but GO
            // is a keyword and would otherwise count as solid.
            if (i == lastIdx && term != StatementRange.Terminator.NONE) {
                continue;
            }
            Pp2Token t = stream.get(i);
            if (isSolid(t)) return false;
        }
        return true;
    }

    /**
     * Source slice covered by the range. Sliced from the original input via
     * the range's byte offsets (see the S11 hand-off note: parsing against
     * the original input preserves comment / whitespace context the parser
     * may key on for some shapes).
     *
     * <p>When the range's terminator is {@link StatementRange.Terminator#GO},
     * the trailing {@code GO} token is excluded from the slice. The GSP
     * MSSQL parser treats {@code GO} as a batch separator that splits the
     * stream into multiple {@code sqlstatements}, which would otherwise
     * trigger {@link RegionParseOutcome}'s multi-statement guard. Stripping
     * {@code GO} from the per-region slice keeps the parse contract
     * single-statement.
     */
    public String sliceFor(StatementRange range) {
        int start = range.getStartOffset();
        int end = sliceEndForParse(range);
        if (start < 0) start = 0;
        if (end > originalSql.length()) end = originalSql.length();
        if (end < start) end = start;
        return originalSql.substring(start, end);
    }

    /**
     * Compute the end offset to use when slicing this range's source for the
     * parser. Equal to {@link StatementRange#getEndOffset()} except when the
     * range's terminator is {@code GO}, in which case the {@code GO}
     * keyword token is dropped from the slice.
     */
    private int sliceEndForParse(StatementRange range) {
        if (range.getTerminator() != StatementRange.Terminator.GO) {
            return range.getEndOffset();
        }
        int lastIdx = range.getEndTokenIndex() - 1;
        if (lastIdx < range.getStartTokenIndex() || lastIdx >= stream.size()) {
            return range.getEndOffset();
        }
        TSourceToken goTok = stream.get(lastIdx).getSourceToken();
        if (goTok == null) return range.getEndOffset();
        return (int) goTok.offset;                 // cut right before GO
    }

    // ------------------------------------------------------------------ //
    //  Internals                                                          //
    // ------------------------------------------------------------------ //

    private static List<TSyntaxError> safeSyntaxErrors(TGSqlParser parser) {
        try {
            List<TSyntaxError> live = parser.getSyntaxErrors();
            if (live == null) return Collections.emptyList();
            return new ArrayList<TSyntaxError>(live);
        } catch (Throwable t) {
            return Collections.emptyList();
        }
    }

    private static boolean isSolid(Pp2Token t) {
        // NO_FORMAT_ZONE: opaque, but counts as solid because the renderer
        // emits it verbatim — we don't want to swallow a NO_FORMAT-only
        // region as TRIVIA.
        if (t.hasRole(TokenRole.NO_FORMAT_ZONE)) return true;
        // Prefer pp2 role annotations (set by ProtectedZoneDetector S9 when
        // the caller annotated the stream). Roles are vendor-agnostic and
        // therefore the authoritative source for "is this token a comment".
        if (t.hasRole(TokenRole.COMMENT_LINE)
            || t.hasRole(TokenRole.COMMENT_BLOCK)) {
            return false;
        }
        TSourceToken st = t.getSourceToken();
        if (st == null) return false;
        ETokenType type = st.tokentype;
        if (type == null) return false;
        switch (type) {
            case ttwhitespace:
            case ttreturn:
            case ttsimplecomment:
            case ttbracketedcomment:
            case ttCPPComment:
            case ttsemicolon:
            case ttstmt_delimiter:
            case ttRemoved:
                return false;
            default:
                // Also short-circuit on empty text — e.g. a deleted token.
                String text = t.getText();
                return text != null && text.length() > 0;
        }
    }
}