package gudusoft.gsqlparser.pp2;

import gudusoft.gsqlparser.pp.para.GFmtOpt;
import gudusoft.gsqlparser.pp.para.GFmtOptFactory;
import gudusoft.gsqlparser.pp2.zone.CommentPolicy;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.List;

/**
 * Configuration for the pp2 fault-tolerant SQL formatter.
 *
 * <p>Composes — does not extend — {@link GFmtOpt}. Composition is deliberate
 * (plan §5.5): inheritance would couple pp2's option surface to every future
 * change to {@code GFmtOpt} and force {@code protected} shims. The wrapped
 * {@code GFmtOpt} carries all of pp's options (case rules, alignment, indent,
 * etc.); the pp2-specific fields below extend that surface with the knobs
 * pp2's region/recovery/fallback pipeline needs.
 *
 * <p>The {@link #from(GFmtOpt)} factory <b>copies field values by reflection</b>
 * into a freshly-allocated {@code GFmtOpt} so that:
 * <ul>
 *   <li>pp2 tuning never leaks back to the caller's {@code GFmtOpt}, and</li>
 *   <li>each {@code Pp2FormatOptions} carries its own {@code sessionId} so
 *       pp's session-keyed caches in {@code FormatterFactory},
 *       {@code ProcessorFactory}, and {@code MediatorFactory} are not poisoned
 *       by pp2's invocations.</li>
 * </ul>
 *
 * <p>The reflection copier is risk R17's mitigation: when {@code GFmtOpt} gains
 * a new public instance field, the copier picks it up automatically. The S2
 * test {@code Pp2FormatOptionsTest} verifies field-by-field equality after
 * {@code from()}.
 *
 * <h2>Field semantics</h2>
 *
 * <ul>
 *   <li><b>{@link #tolerantMode}</b> ({@code true} by default) — when
 *       {@code true} the engine never throws on a parse failure; it routes
 *       the region to the lexical fallback. When {@code false} the engine
 *       raises a {@link Pp2ParseException} with the parser diagnostics
 *       attached.</li>
 *   <li><b>{@link #maxLineWidth}</b> (default 120) — soft wrap target for the
 *       lexical island renderer. Hard guarantees are not made; identifier
 *       names and literals are never split.</li>
 *   <li><b>{@link #errorRegionStrategy}</b> (default {@link ErrorRegionStrategy#PRESERVE}) —
 *       how to render a region the engine could not parse and the lexical
 *       fallback flagged as an {@code ERROR_REGION}.</li>
 *   <li><b>{@link #maxErrorRegionSize}</b> (default 10000 chars) — error
 *       regions larger than this are clamped; the overflow is emitted as a
 *       raw-text passthrough with an {@code INFO} diagnostic.</li>
 *   <li><b>{@link #maxRegionParseChars}</b> (default 200000 chars) — safety
 *       valve: regions whose source span exceeds this length skip per-region
 *       parsing entirely and go straight to the fallback renderer.</li>
 *   <li><b>{@link #commentPolicy}</b> (default {@link CommentPolicy#PRESERVE}) —
 *       how to anchor comments across region boundaries.</li>
 *   <li><b>{@link #showIndentMarkers}</b> (default {@code false}) — Delphi-style
 *       {@code |} debug rendering of indent levels in the lexical fallback
 *       output. Diagnostic only.</li>
 *   <li><b>{@link #astOverlayEnabled}</b> (default {@code false}) — feature flag
 *       for the v3 AST overlay annotator. Off in v2; flipping it on in v2
 *       activates the annotator scaffold from slice S33 but does not change
 *       rendering output.</li>
 * </ul>
 *
 * <p>Mutability matches {@code GFmtOpt}'s convention: fields are public and
 * mutable so existing callers can tune options ergonomically. Concurrent
 * mutation while a {@code Pp2Formatter} call is in flight is undefined.
 */
public class Pp2FormatOptions {

    /** Strategy for rendering parse-failed, lexical-fallback regions. */
    public enum ErrorRegionStrategy {
        /** Emit the raw source text verbatim. Safest. Default. */
        PRESERVE,
        /** Apply light token spacing only; never reorder or drop tokens. */
        LIGHT_FORMAT,
        /** Apply the full lexical island pipeline; may rearrange whitespace. */
        BEST_EFFORT
    }

    // ---- pp options surface (composed, not inherited) -------------------

    private final GFmtOpt gfmtOpt;

    // ---- pp2 knobs ------------------------------------------------------

    /** When {@code true}, parse failures route to fallback; never throws. */
    public boolean tolerantMode = true;

    /** Soft line-wrap target (lexical island renderer only). */
    public int maxLineWidth = 120;

    /** How to render error regions. */
    public ErrorRegionStrategy errorRegionStrategy = ErrorRegionStrategy.PRESERVE;

    /** Error regions larger than this are clamped. */
    public int maxErrorRegionSize = 10000;

    /** Regions larger than this skip per-region parsing entirely. */
    public int maxRegionParseChars = 200000;

    /** Comment-anchoring policy across region boundaries. */
    public CommentPolicy commentPolicy = CommentPolicy.PRESERVE;

    /** Emit {@code |} markers at each indent level (debug output). */
    public boolean showIndentMarkers = false;

    /** Feature flag for the v3 AST overlay annotator. */
    public boolean astOverlayEnabled = false;

    /**
     * When {@code true} (default), consecutive top-level statements that share
     * a physical line in the source (separated only by horizontal whitespace,
     * with no line break) are placed on their own lines in the output. When
     * {@code false}, the original inter-statement whitespace is preserved
     * verbatim — the legacy behaviour, which could leave several statements
     * running together on one line. Gaps that already contain a line break, or
     * that contain comments / non-whitespace trivia, are always preserved
     * verbatim regardless of this flag.
     */
    public boolean breakStatementsOnNewLine = true;

    // ---- construction ---------------------------------------------------

    /**
     * Internal constructor used by {@link #defaults()} and {@link #from(GFmtOpt)}.
     * Both factories supply a freshly-allocated {@code GFmtOpt}.
     *
     * @throws NullPointerException if {@code gfmtOpt} is null
     */
    Pp2FormatOptions(GFmtOpt gfmtOpt) {
        if (gfmtOpt == null) {
            throw new NullPointerException("gfmtOpt");
        }
        this.gfmtOpt = gfmtOpt;
    }

    /**
     * Construct with a fresh {@code GFmtOpt} carrying default values. The
     * underlying {@code GFmtOpt} is allocated via
     * {@link GFmtOptFactory#newInstance()} so it gets a unique
     * {@code sessionId} (used by pp's {@code FormatterFactory} caches).
     */
    public static Pp2FormatOptions defaults() {
        return new Pp2FormatOptions(GFmtOptFactory.newInstance());
    }

    /**
     * Construct from an existing {@code GFmtOpt} by <b>copying its public
     * instance fields</b> into a freshly-allocated {@code GFmtOpt}. The
     * caller's instance is not retained; subsequent mutations to it are
     * invisible to pp2, and pp2's mutations are invisible to the caller.
     *
     * <p>The {@code sessionId} field is {@code final} on {@code GFmtOpt}, so
     * the copy carries the new fresh {@code sessionId} from
     * {@link GFmtOptFactory#newInstance()} — not the source's.
     *
     * @param gfmtOpt must not be {@code null}
     * @throws NullPointerException if {@code gfmtOpt} is null
     */
    public static Pp2FormatOptions from(GFmtOpt gfmtOpt) {
        if (gfmtOpt == null) {
            throw new NullPointerException("gfmtOpt");
        }
        GFmtOpt copy = GFmtOptFactory.newInstance();
        copyPublicFields(gfmtOpt, copy);
        return new Pp2FormatOptions(copy);
    }

    /**
     * Reflection-based field copier. Walks every public, non-static,
     * non-{@code final} field on {@link GFmtOpt} and copies its value from
     * {@code src} to {@code dst}. Skipping {@code final} fields means
     * {@code sessionId} (which is {@code final}) is preserved from {@code dst}.
     *
     * <p>This is the R17 mitigation: a new public field on {@code GFmtOpt} is
     * picked up automatically. The S2 test verifies field-by-field equality.
     */
    private static void copyPublicFields(GFmtOpt src, GFmtOpt dst) {
        List<String> skipped = null;
        for (Field f : GFmtOpt.class.getFields()) {
            int mod = f.getModifiers();
            if (Modifier.isStatic(mod) || Modifier.isFinal(mod)) continue;
            try {
                f.set(dst, f.get(src));
            } catch (IllegalAccessException e) {
                // Should not happen for public fields, but record any holes
                // rather than swallow them silently.
                if (skipped == null) skipped = new ArrayList<String>();
                skipped.add(f.getName());
            }
        }
        if (skipped != null && !skipped.isEmpty()) {
            throw new IllegalStateException(
                "Pp2FormatOptions.from(): could not copy GFmtOpt fields: " + skipped);
        }
    }

    // ---- accessors ------------------------------------------------------

    /**
     * Return the wrapped {@code GFmtOpt}. pp2 hands this directly to
     * {@code FormatterFactory.pp()} when the
     * {@code gudusoft.gsqlparser.pp2.engine.Pp2Engine} (S16) dispatches a
     * parseable region to the AST delegate.
     */
    public GFmtOpt toGFmtOpt() {
        return gfmtOpt;
    }
}