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) — reserved for
 *       a future strict-mode switch. The current engine does not read this
 *       field and always recovers ordinary parse failures.</li>
 *   <li><b>{@link #maxLineWidth}</b> (default 120) — reserved soft-wrap target.
 *       The current pp2 renderers do not read this field.</li>
 *   <li><b>{@link #errorRegionStrategy}</b> (default {@link ErrorRegionStrategy#PRESERVE}) —
 *       reserved strategy selector for lexical {@code ERROR_REGION}s. The
 *       current engine does not read this field.</li>
 *   <li><b>{@link #maxErrorRegionSize}</b> (default 10000 chars) — caps the
 *       token span the island recognizer annotates as an {@code ERROR_REGION}.
 *       The current layout pipeline records that boundary but does not use it
 *       to select a different renderer.</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}) —
 *       preserves comments across region boundaries. The alternative
 *       re-anchor/reflow policies remain experimental and are not fully
 *       implemented by the region assembler.</li>
 *   <li><b>{@link #showIndentMarkers}</b> (default {@code false}) — reserved
 *       diagnostic option. The current pp2 renderers do not read this field.</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 {

    /** Reserved strategies for rendering parse-failed lexical regions. */
    public enum ErrorRegionStrategy {
        /** Planned raw-source preservation strategy. Default reserved value. */
        PRESERVE,
        /** Planned light token-spacing strategy. */
        LIGHT_FORMAT,
        /** Planned full lexical-island strategy. */
        BEST_EFFORT
    }

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

    private final GFmtOpt gfmtOpt;

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

    /** Reserved strict-mode switch; the current engine always recovers parse failures. */
    public boolean tolerantMode = true;

    /** Reserved soft line-wrap target; currently has no effect. */
    public int maxLineWidth = 120;

    /** Reserved error-region strategy selector; currently has no effect. */
    public ErrorRegionStrategy errorRegionStrategy = ErrorRegionStrategy.PRESERVE;

    /** Maximum character span annotated as an ERROR_REGION by island recognition. */
    public int maxErrorRegionSize = 10000;

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

    /** Comment policy; PRESERVE is implemented, alternatives remain experimental. */
    public CommentPolicy commentPolicy = CommentPolicy.PRESERVE;

    /** Reserved indent-marker option; currently has no effect. */
    public boolean showIndentMarkers = false;

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

    /**
     * Whether a parseable input is handed straight to {@code pp}.
     *
     * <p>When {@code true} (the default) and the whole input parses, pp2 first
     * formats the whole document with {@code FormatterFactory.pp} using these
     * same options, and returns <b>that text unchanged</b> as an {@code OK}
     * result provided it is token-equivalent to the input. Only when the
     * whole-document parse fails, or pp throws, or pp's output drops or
     * rewrites a token, does the regional pipeline run.
     *
     * <p>This is what makes pp2 byte-identical to pp on parseable SQL: not an
     * imitation of pp's layout rules, but pp itself. Set it to {@code false}
     * only to exercise the regional pipeline directly (the regional pipeline
     * reparses statement ranges independently, and its reassembled text was
     * not byte-identical to whole-document pp on 60 of 1000 parseable corpus
     * inputs — which is why this path exists).
     */
    public boolean wholeDocumentFastPath = true;

    /**
     * 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;

    /**
     * Transformations of tokens or comments that the caller asked for and that
     * pp2's content guards must therefore accept, in their exact expected form
     * (see {@link gudusoft.gsqlparser.pp2.token.TransformPolicy}). Default:
     * none, the plain content check.
     */
    public gudusoft.gsqlparser.pp2.token.TransformPolicy transformPolicy =
        gudusoft.gsqlparser.pp2.token.TransformPolicy.NONE;

    // ---- 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
     */
    /**
     * Wrap an existing {@code GFmtOpt} <b>without copying</b>: pp2 formats
     * with this very instance and its {@code sessionId}. Use it when the
     * options must stay registered in {@link GFmtOptFactory} under that id,
     * because parts of pp re-read their options by session id; the caller
     * owns the instance and releases it ({@link GFmtOptFactory#remove}).
     *
     * @param gfmtOpt must not be {@code null}
     * @throws NullPointerException if {@code gfmtOpt} is null
     */
    public static Pp2FormatOptions wrap(GFmtOpt gfmtOpt) {
        return new Pp2FormatOptions(gfmtOpt);
    }

    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;
    }
}