package gudusoft.gsqlparser.sqlenv.compat;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.catalog.input.CatalogLoadOptions;
import gudusoft.gsqlparser.catalog.runtime.CatalogRuntime;
import gudusoft.gsqlparser.sqlenv.TSQLCatalog;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.catalog.ICatalogProvider;

/**
 * Lazy bridge: a {@link TSQLEnv} subclass whose only job is to install
 * {@link CatalogBackedCatalogProvider} via the legacy {@link ICatalogProvider} hook.
 *
 * <p>Plan §5.3 / §8.3. Per spike {@code bridge-access-trace.md} no method override is
 * required: {@link TSQLEnv#doSearchSchemaObject} already dispatches to
 * {@link ICatalogProvider#findObject} for fully-qualified lookups, and the legacy
 * mutation paths ({@code addFunction}, {@code setDefaultCatalogName}, {@code addObject})
 * land naturally on the wrapped delegate.</p>
 *
 * <p>The constructor calls {@code super(vendor)} (which builds the default
 * {@code CatalogStoreProvider}), captures that as the delegate, and then installs the
 * {@link CatalogBackedCatalogProvider} wrapper via the protected
 * {@code setCatalogProviderForCompatibility} hook added in P1D.1. Subsequent
 * {@link #getCatalogProvider()} calls return the bridged provider; lookups missing
 * from the legacy overlay will round-trip through the runtime resolver, materialize
 * via {@link CatalogEntryToSQLEnvMapper}, and be cached back into the delegate so the
 * next lookup is O(1).</p>
 *
 * <p>{@link #initSQLEnv()} is a no-op: the runtime is the metadata source, the bridge
 * is just a thin compatibility veneer. Construction also applies defaults from
 * {@link CatalogLoadOptions} (default catalog / schema / server) so the bridge plays the
 * same active-context role as the corresponding eager-loaded {@link TSQLEnv}.</p>
 */
public final class CatalogRuntimeToSQLEnvBridge extends TSQLEnv {

    private final CatalogRuntime runtime;
    private final CatalogLoadOptions options;

    /**
     * Construct a bridge for the given runtime. Vendor is read from the runtime; the
     * options carry the default catalog/schema/server applied to {@link TSQLEnv}.
     *
     * @param runtime the runtime that owns the snapshot, overlay, and lazy provider.
     * @param options optional load options; {@code null} is allowed — defaults are
     *                read from the runtime alone in that case.
     */
    public CatalogRuntimeToSQLEnvBridge(CatalogRuntime runtime, CatalogLoadOptions options) {
        super(requireRuntime(runtime).vendor());
        this.runtime = runtime;
        this.options = options;
        applyDefaults(options);
        ICatalogProvider delegate = getCatalogProvider();
        CatalogBackedCatalogProvider bridged = new CatalogBackedCatalogProvider(
            runtime, delegate, new CatalogEntryToSQLEnvMapper(), this,
            options != null ? options.identifierConfig() : null,
            options != null ? options.diagnosticSink() : null);
        setCatalogProviderForCompatibility(bridged);
    }

    /** Construct a bridge for the given runtime and explicit vendor. Vendor must match. */
    public CatalogRuntimeToSQLEnvBridge(EDbVendor vendor, CatalogRuntime runtime,
                                        CatalogLoadOptions options) {
        super(vendor);
        if (runtime == null) {
            throw new IllegalArgumentException(
                "CatalogRuntimeToSQLEnvBridge: runtime must not be null");
        }
        if (vendor == null) {
            throw new IllegalArgumentException(
                "CatalogRuntimeToSQLEnvBridge: vendor must not be null");
        }
        if (runtime.vendor() != vendor) {
            throw new IllegalArgumentException(
                "CatalogRuntimeToSQLEnvBridge: runtime.vendor=" + runtime.vendor()
                    + " does not match vendor=" + vendor);
        }
        this.runtime = runtime;
        this.options = options;
        applyDefaults(options);
        ICatalogProvider delegate = getCatalogProvider();
        CatalogBackedCatalogProvider bridged = new CatalogBackedCatalogProvider(
            runtime, delegate, new CatalogEntryToSQLEnvMapper(), this,
            options != null ? options.identifierConfig() : null,
            options != null ? options.diagnosticSink() : null);
        setCatalogProviderForCompatibility(bridged);
    }

    /** The runtime's catalog IS the metadata, although nothing is registered until it is asked for. */
    @Override
    public boolean hasCatalogMetadata() {
        return true;
    }

    /**
     * The runtime backing this bridge. Useful for tests that want to inspect the
     * snapshot/overlay directly without reaching through {@link #getCatalogProvider}.
     */
    public CatalogRuntime runtime() {
        return runtime;
    }

    /**
     * Load options the bridge was constructed with, or {@code null} if none. Retained so
     * downstream callers can introspect the loading mode / fetch caps without re-reading
     * the runtime.
     */
    public CatalogLoadOptions options() {
        return options;
    }

    @Override
    public void initSQLEnv() {
        // The runtime IS the metadata source; nothing to materialize lazily here.
        // Legacy callers that build a TSQLEnv via parser.sqlenv = bridge expect
        // initSQLEnv() to be a no-op when metadata is supplied externally.
    }

    private static CatalogRuntime requireRuntime(CatalogRuntime runtime) {
        if (runtime == null) {
            throw new IllegalArgumentException(
                "CatalogRuntimeToSQLEnvBridge: runtime must not be null");
        }
        return runtime;
    }

    private void applyDefaults(CatalogLoadOptions opts) {
        if (opts == null) return;
        if (opts.defaultCatalog() != null && !opts.defaultCatalog().isEmpty()) {
            setDefaultCatalogName(opts.defaultCatalog());
        }
        if (opts.defaultSchema() != null && !opts.defaultSchema().isEmpty()) {
            setDefaultSchemaName(opts.defaultSchema());
        }
        if (opts.defaultServer() != null && !opts.defaultServer().isEmpty()) {
            setDefaultServerName(opts.defaultServer());
        }
        // Pre-register an empty default catalog/schema in the legacy catalogList so the
        // legacy {@code TSQLEnv.doSearchSchemaObject} '..table' fallback can find them
        // and route through {@code catalogProvider.findObject} (= the bridge's lookup
        // path). Without this, unqualified names like {@code SELECT * FROM employees}
        // never reach the bridge: the legacy path iterates {@code catalogList} which is
        // empty until something is materialized through the bridge, and the iteration
        // body — which is what calls findObject — never runs. Registering empties is
        // safe: the catalog/schema are real {@code TSQLCatalog}/{@code TSQLSchema}
        // instances that hold zero materialized objects until the bridge populates them
        // on demand.
        if (opts.defaultCatalog() != null && !opts.defaultCatalog().isEmpty()) {
            TSQLCatalog c = getSQLCatalog(opts.defaultCatalog(), true);
            if (c != null && opts.defaultSchema() != null && !opts.defaultSchema().isEmpty()) {
                c.getSchema(opts.defaultSchema(), true);
            }
        }
    }
}