package gudusoft.gsqlparser.sqlenv.compat;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.catalog.diagnostic.CatalogDiagnostic;
import gudusoft.gsqlparser.catalog.diagnostic.CatalogDiagnosticSink;
import gudusoft.gsqlparser.catalog.input.model.IdentifierConfig;
import gudusoft.gsqlparser.catalog.runtime.CatalogContext;
import gudusoft.gsqlparser.catalog.runtime.CatalogEntry;
import gudusoft.gsqlparser.catalog.runtime.CatalogIdentifierPolicy;
import gudusoft.gsqlparser.catalog.runtime.CatalogObjectKind;
import gudusoft.gsqlparser.catalog.runtime.CatalogQualifiedName;
import gudusoft.gsqlparser.catalog.runtime.CatalogResolutionResult;
import gudusoft.gsqlparser.catalog.runtime.CatalogResolver;
import gudusoft.gsqlparser.catalog.runtime.CatalogRuntime;
import gudusoft.gsqlparser.catalog.runtime.CatalogSearchPath;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.TSQLCatalog;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;
import gudusoft.gsqlparser.sqlenv.TSQLSchemaObject;
import gudusoft.gsqlparser.sqlenv.catalog.ICatalogProvider;

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

/**
 * Lazy bridge from the legacy {@link ICatalogProvider} hook to a new-world
 * {@link CatalogRuntime}. Plan §5.3 / §8.3.
 *
 * <p>Read path: {@link #findObject} delegates to the wrapped provider first; on miss it asks
 * the runtime resolver, materializes the hit via {@link CatalogEntryToSQLEnvMapper}, writes
 * the resulting {@link TSQLSchemaObject} into the delegate's overlay so subsequent lookups
 * within the same parse never re-cross the bridge, and returns it. On miss-after-runtime
 * the method returns {@code null} (preserves today's "missing object" semantics).</p>
 *
 * <p>Write path: {@link #addObject} writes straight to the delegate. DDL discovered
 * mid-parse and temp-table registrations therefore go to the existing legacy overlay
 * (the {@code CatalogStoreProvider} default for a {@link TSQLEnv}); they never touch the
 * immutable {@code CatalogSnapshot} owned by the runtime — the runtime overlay stays
 * untouched here on purpose, the bridge's job is to feed the legacy lookup path.</p>
 *
 * <p>All other {@link ICatalogProvider} methods delegate verbatim to the wrapped provider.
 * Construction validates that the runtime, delegate, mapper and target env are non-null.
 * Lookups silently return {@code null} on null arguments to mirror the legacy contract:
 * {@code TSQLEnv.doSearchSchemaObject} only invokes the provider when at least three
 * normalized segments are present, but defensive null handling here matches the rest of
 * the {@link ICatalogProvider} contract.</p>
 */
public final class CatalogBackedCatalogProvider implements ICatalogProvider {

    private final CatalogRuntime runtime;
    private final ICatalogProvider delegate;
    private final CatalogEntryToSQLEnvMapper mapper;
    private final TSQLEnv targetEnv;
    private final IdentifierConfig identifierConfig;
    private final CatalogDiagnosticSink diagnosticSink;

    public CatalogBackedCatalogProvider(CatalogRuntime runtime, ICatalogProvider delegate,
                                        CatalogEntryToSQLEnvMapper mapper, TSQLEnv targetEnv) {
        this(runtime, delegate, mapper, targetEnv,
            /* identifierConfig */ null, /* diagnosticSink */ null);
    }

    /**
     * Convenience constructor without a diagnostic sink. Equivalent to
     * {@link #CatalogBackedCatalogProvider(CatalogRuntime, ICatalogProvider,
     * CatalogEntryToSQLEnvMapper, TSQLEnv, IdentifierConfig, CatalogDiagnosticSink)}
     * with {@code diagnosticSink=null}.
     */
    public CatalogBackedCatalogProvider(CatalogRuntime runtime, ICatalogProvider delegate,
                                        CatalogEntryToSQLEnvMapper mapper, TSQLEnv targetEnv,
                                        IdentifierConfig identifierConfig) {
        this(runtime, delegate, mapper, targetEnv, identifierConfig, /* diagnosticSink */ null);
    }

    /**
     * Construct a bridge provider with an explicit {@link IdentifierConfig} and an
     * optional {@link CatalogDiagnosticSink}. When {@code identifierConfig} is
     * {@code null} the bridge falls back to {@link IdentifierConfig#defaultsFor(EDbVendor)};
     * non-null configs are honored so snapshot keys built under (e.g.) MySQL
     * {@code lower_case_table_names=2} or MSSQL collation overrides match at lookup time.
     *
     * <p>Diagnostics emitted by the runtime resolver (fetch-cap WARNs/ERRORs, partial
     * results, fetch failures) are forwarded to {@code diagnosticSink} when configured.
     * The {@link ICatalogProvider#findObject} contract still returns {@code null} on
     * miss (no behavior change for legacy callers), but a configured sink lets a
     * caller observe what the runtime saw — required for plan §10.6 fetch-cap
     * diagnostics to be visible at the bridge layer.</p>
     */
    public CatalogBackedCatalogProvider(CatalogRuntime runtime, ICatalogProvider delegate,
                                        CatalogEntryToSQLEnvMapper mapper, TSQLEnv targetEnv,
                                        IdentifierConfig identifierConfig,
                                        CatalogDiagnosticSink diagnosticSink) {
        if (runtime == null) {
            throw new IllegalArgumentException(
                "CatalogBackedCatalogProvider: runtime must not be null");
        }
        if (delegate == null) {
            throw new IllegalArgumentException(
                "CatalogBackedCatalogProvider: delegate must not be null");
        }
        if (mapper == null) {
            throw new IllegalArgumentException(
                "CatalogBackedCatalogProvider: mapper must not be null");
        }
        if (targetEnv == null) {
            throw new IllegalArgumentException(
                "CatalogBackedCatalogProvider: targetEnv must not be null");
        }
        if (runtime.vendor() != targetEnv.getDBVendor()) {
            throw new IllegalArgumentException(
                "CatalogBackedCatalogProvider: runtime.vendor=" + runtime.vendor()
                    + " does not match targetEnv.vendor=" + targetEnv.getDBVendor());
        }
        if (identifierConfig != null && identifierConfig.vendor() != runtime.vendor()) {
            throw new IllegalArgumentException(
                "CatalogBackedCatalogProvider: identifierConfig.vendor=" + identifierConfig.vendor()
                    + " does not match runtime.vendor=" + runtime.vendor());
        }
        this.runtime = runtime;
        this.delegate = delegate;
        this.mapper = mapper;
        this.targetEnv = targetEnv;
        this.identifierConfig = identifierConfig != null
            ? identifierConfig : IdentifierConfig.defaultsFor(runtime.vendor());
        this.diagnosticSink = diagnosticSink;
    }

    @Override
    public TSQLCatalog getCatalog(String catalogName) {
        return delegate.getCatalog(catalogName);
    }

    @Override
    public TSQLCatalog createCatalog(String catalogName) {
        return delegate.createCatalog(catalogName);
    }

    @Override
    public List<TSQLCatalog> getAllCatalogs() {
        return delegate.getAllCatalogs();
    }

    @Override
    public String getDefaultCatalogName() {
        return delegate.getDefaultCatalogName();
    }

    @Override
    public void setDefaultCatalogName(String name) {
        delegate.setDefaultCatalogName(name);
    }

    @Override
    public TSQLSchemaObject findObject(String catalog, String schema, String objectName,
                                       ESQLDataObjectType type) {
        // 1. Delegate first — overlay/cache/last-good answer takes priority over
        //    re-crossing the bridge. This matches the §10.5 lookup precedence: the
        //    legacy delegate's overlay is the bridge's "Phase 1" before the snapshot.
        TSQLSchemaObject existing = delegate.findObject(catalog, schema, objectName, type);
        if (existing != null) {
            return existing;
        }
        if (objectName == null || objectName.isEmpty()) {
            return null;
        }
        CatalogObjectKind kind = mapType(type);
        if (kind == null) {
            return null;
        }

        // 2. Build a CatalogQualifiedName from the segments TSQLEnv passes us. The
        //    segments are already normalized by IdentifierService.normalizeSegment
        //    upstream (see TSQLEnv.doSearchSchemaObject), so going through the parse
        //    path again would (a) re-normalize an already-normalized value (mostly
        //    harmless but wasteful), and (b) split on dots inside quoted-embedded-dot
        //    names like Oracle "a.b"."c" that have already been segmented correctly
        //    upstream. Use the dedicated factory that takes already-split segments.
        //
        //    fromAlreadyNormalizedSegments only rejects null/empty inputs, and
        //    buildSegments guarantees at least one non-null/non-empty entry (the
        //    object name was non-null at the top of the method), so the factory
        //    cannot throw on this call site. If it ever does, that's a real bug
        //    in the upstream segment-builder — let it propagate so it's visible
        //    in diagnostics instead of being indistinguishable from a normal miss.
        EDbVendor vendor = runtime.vendor();
        List<String> segments = buildSegments(catalog, schema, objectName);
        CatalogQualifiedName name =
            CatalogIdentifierPolicy.fromAlreadyNormalizedSegments(segments, kind, vendor);

        // 3. Ask the runtime resolver. The resolver walks overlay → lazy cache →
        //    snapshot → on-miss provider fetch (when LAZY/AUTO) and applies the
        //    candidate-expansion ladder per plan §9.3 (defaults, search path, kind
        //    widening). The bridge is invoked only when TSQLEnv has at least three
        //    segments, so candidate expansion is mostly a no-op here — but the kind-
        //    widening step is what lets a TABLE lookup match a VIEW snapshot entry.
        CatalogContext ctx = CatalogContext.builder()
            .vendor(vendor)
            .activeCatalog(catalog)
            .activeSchema(schema)
            .searchPath(CatalogSearchPath.empty())
            .identifierConfig(identifierConfig)
            .build();
        CatalogResolver resolver = runtime.resolver();
        CatalogResolutionResult result = resolver.resolve(ctx, name);
        // Forward diagnostics from the resolver to the configured sink (if any) so
        // fetch-cap WARN/ERROR, partial-result INFO, and fetch-failed WARN are
        // visible at the bridge layer. Does nothing when no sink was configured —
        // findObject's null-on-miss contract is unaffected either way.
        forwardDiagnostics(result);
        if (!result.resolved() || !result.binding().isPresent()) {
            return null;
        }

        // 4. Materialize the runtime entry into the legacy schema-object shape via
        //    the mapper. Use CatalogRuntime.findEntry so we see the actual entry from
        //    overlay/lazyCache/snapshot (the binding alone does not carry properties);
        //    pull column children too so the materialized TSQLTable carries the columns
        //    the resolver's column push-down will read.
        CatalogQualifiedName resolvedName = result.binding().get().resolvedName();
        CatalogObjectKind resolvedKind = result.binding().get().kind();
        CatalogEntry entry = runtime.findEntry(resolvedName, resolvedKind);
        if (entry == null) {
            // Defensive: a resolver hit without a backing entry shouldn't happen with
            // the in-tree CatalogRuntime, but third-party CatalogResolver impls may
            // return a binding without populating the snapshot or lazy cache. Build a
            // synthetic entry from the binding so the mapper still has a CatalogEntry
            // to dispatch on. Columns will be empty for synthetic entries.
            entry = syntheticEntry(result);
        }
        List<CatalogEntry> columns = (resolvedKind == CatalogObjectKind.TABLE
            || resolvedKind == CatalogObjectKind.VIEW
            || resolvedKind == CatalogObjectKind.MATERIALIZED_VIEW)
            ? runtime.findChildren(entry.id(), CatalogObjectKind.COLUMN)
            : new ArrayList<CatalogEntry>();
        TSQLSchemaObject materialized = mapper.toSQLSchemaObject(entry, targetEnv, columns);
        // The mapper's addTable/addView/addProcedure paths invoke
        // TSQLEnv.putSchemaObject which already calls catalogProvider.addObject on the
        // delegate — no explicit cache write-back is needed here, doing one would
        // double-insert into CatalogStore.objectsByName.
        return materialized;
    }

    @Override
    public void addObject(TSQLSchemaObject object) {
        // DDL/temp-table writes must go to the delegate (the wrapped TSQLEnv's
        // overlay), never to the immutable snapshot. The runtime's CatalogOverlay is
        // a separate concept used only by callers that target the new SPI directly;
        // legacy callers writing through TSQLEnv keep using the legacy overlay so
        // their reads (which still go through the legacy code path) see their
        // writes immediately.
        delegate.addObject(object);
    }

    @Override
    public boolean removeObject(TSQLSchemaObject object) {
        return delegate.removeObject(object);
    }

    @Override
    public void clear() {
        delegate.clear();
    }

    @Override
    public int size() {
        return delegate.size();
    }

    /**
     * Map a legacy {@link ESQLDataObjectType} to the new {@link CatalogObjectKind}.
     * Returns {@code null} for kinds that have no first-class runtime representation
     * (column, parameter, dblink, datatype, unknown) — the bridge then preserves
     * today's "missing object" semantics by returning null from {@link #findObject}.
     */
    static CatalogObjectKind mapType(ESQLDataObjectType type) {
        if (type == null) {
            return null;
        }
        switch (type) {
            case dotTable:
                // The runtime resolver already widens TABLE → VIEW / MATERIALIZED_VIEW
                // (plan §9.3) so a relation reference always finds a snapshot hit
                // regardless of whether it was registered as a table or a view.
                return CatalogObjectKind.TABLE;
            case dotFunction:
                return CatalogObjectKind.FUNCTION;
            case dotProcedure:
                return CatalogObjectKind.PROCEDURE;
            case dotOraclePackage:
                return CatalogObjectKind.PACKAGE;
            case dotTrigger:
                return CatalogObjectKind.TRIGGER;
            case dotSynonyms:
                return CatalogObjectKind.SYNONYM;
            case dotRoutine:
                return CatalogObjectKind.ROUTINE;
            default:
                // dotColumn, dotParameter, dotDblink, dotDataType, dotCatalog,
                // dotSchema, dotUnknown — no direct CatalogEntry materialization
                // path. The legacy resolver doesn't ask the bridge for these in
                // practice (column lookup goes through table-then-walk).
                return null;
        }
    }

    private void forwardDiagnostics(CatalogResolutionResult result) {
        if (diagnosticSink == null || result == null) {
            return;
        }
        List<CatalogDiagnostic> diags = result.diagnostics();
        if (diags == null || diags.isEmpty()) {
            return;
        }
        for (CatalogDiagnostic d : diags) {
            try {
                diagnosticSink.accept(d);
            } catch (RuntimeException ignored) {
                // A misbehaving sink must not break catalog lookup. Diagnostics are
                // best-effort — if the sink throws, fall through to null-on-miss.
            }
        }
    }

    /**
     * Build a list of already-normalized segments from the three legacy {@code findObject}
     * parameters. Drops null/empty entries so partial qualifications still produce a
     * valid 1- or 2-segment list. The resulting segments are fed verbatim to
     * {@link CatalogIdentifierPolicy#fromAlreadyNormalizedSegments} — no joining, no
     * re-splitting on dots, so quoted-embedded-dot names parsed correctly upstream
     * survive the round-trip.
     */
    static List<String> buildSegments(String catalog, String schema, String object) {
        List<String> out = new ArrayList<String>(3);
        if (catalog != null && !catalog.isEmpty()) out.add(catalog);
        if (schema != null && !schema.isEmpty()) out.add(schema);
        out.add(object);
        return out;
    }

    /**
     * Build a synthetic {@link CatalogEntry} for a binding when the actual entry is not
     * recoverable (e.g. third-party resolver impl that returns a binding without a
     * matching snapshot entry). The synthetic entry carries the binding's id, name,
     * kind, and properties — enough for the mapper to materialize the legacy object.
     */
    private static CatalogEntry syntheticEntry(CatalogResolutionResult result) {
        final gudusoft.gsqlparser.catalog.runtime.CatalogBinding b = result.binding().get();
        return new CatalogEntry() {
            @Override
            public gudusoft.gsqlparser.catalog.runtime.CatalogObjectId id() {
                return b.objectId();
            }

            @Override
            public CatalogQualifiedName name() {
                return b.resolvedName();
            }

            @Override
            public CatalogObjectKind kind() {
                return b.kind();
            }

            @Override
            public java.util.Map<String, Object> properties() {
                return b.properties();
            }
        };
    }
}