package gudusoft.gsqlparser.catalog.runtime;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.catalog.diagnostic.CatalogDiagnostic;

import java.util.ArrayList;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;

/**
 * In-memory {@link CatalogSnapshot} backed by {@code Map<String, CatalogEntry>}s keyed via
 * {@link CatalogIdentifierPolicy#keyForMap(CatalogQualifiedName)}.
 *
 * <p>Plan §6 / §7.2. The fast path is the kind-segregated keyForMap lookup; on a miss for
 * COLLATION_BASED dialects (MSSQL with case-insensitive collation, MySQL
 * {@code lower_case_table_names=2}) the snapshot falls back to a linear scan via
 * {@link CatalogIdentifierPolicy#areEqual} — same contract as
 * {@code IdentifierService.canUseCompositeKey}.</p>
 *
 * <p>Construction goes through {@link #builder()}; the snapshot is immutable once built.
 * Children are precomputed at build time so {@link #children(CatalogObjectId, CatalogObjectKind)}
 * does not walk every entry.</p>
 */
public final class InMemoryCatalogSnapshot implements CatalogSnapshot {

    private final EDbVendor vendor;
    /** Outer key = kind; inner key = {@code keyForMap(name)} → entry. */
    private final Map<CatalogObjectKind, Map<String, CatalogEntry>> byKey;
    /** Per-kind list, used for the slow {@code areEqual} fallback. */
    private final Map<CatalogObjectKind, List<CatalogEntry>> byKind;
    private final Map<CatalogObjectId, Map<CatalogObjectKind, List<CatalogEntry>>> childrenByParent;
    private final List<CatalogDiagnostic> diagnostics;
    private final long materializedAtMillis;
    /**
     * Whether the snapshot's vendor uses {@code IdentifierService.areEqual} semantics
     * that {@code keyForMap} cannot fully capture. {@code false} for vendors where the
     * composite key is a complete equality key — in that case a key miss really means
     * "no entry" and the linear fallback can be skipped, keeping {@link #find} O(1)
     * even on 100k-table catalogs.
     */
    private final boolean needsAreEqualFallback;

    private InMemoryCatalogSnapshot(Builder b) {
        if (b.vendor == null) {
            throw new IllegalArgumentException("InMemoryCatalogSnapshot.vendor is required");
        }
        this.vendor = b.vendor;
        this.byKey = freezeNested(b.byKey);
        this.byKind = freezeListMap(b.byKind);
        this.childrenByParent = freezeChildren(b.childrenByParent);
        this.diagnostics = Collections.unmodifiableList(
            new ArrayList<CatalogDiagnostic>(b.diagnostics));
        this.materializedAtMillis = b.materializedAtMillis != 0
            ? b.materializedAtMillis : System.currentTimeMillis();
        this.needsAreEqualFallback = NeedsAreEqualFallback.forVendor(vendor);
    }

    public static Builder builder() {
        return new Builder();
    }

    @Override
    public EDbVendor vendor() {
        return vendor;
    }

    @Override
    public Optional<CatalogEntry> find(CatalogQualifiedName name, CatalogObjectKind kind) {
        if (name == null || kind == null) {
            return Optional.empty();
        }
        Map<String, CatalogEntry> bucket = byKey.get(kind);
        if (bucket != null) {
            CatalogEntry direct = bucket.get(CatalogIdentifierPolicy.keyForMap(name));
            if (direct != null) {
                return Optional.of(direct);
            }
        }
        // Slow fallback only for dialects whose normalize cannot be summarized by a
        // composite key (COLLATION_BASED). For Oracle / PostgreSQL / MySQL etc., the
        // keyForMap miss is a real miss — skipping the linear scan keeps find() O(1)
        // on 100k-entry snapshots.
        if (needsAreEqualFallback) {
            List<CatalogEntry> all = byKind.get(kind);
            if (all != null) {
                for (CatalogEntry entry : all) {
                    if (CatalogIdentifierPolicy.areEqual(entry.name(), name)) {
                        return Optional.of(entry);
                    }
                }
            }
        }
        return Optional.empty();
    }

    @Override
    public List<CatalogEntry> children(CatalogObjectId parent, CatalogObjectKind kind) {
        if (parent == null || kind == null) {
            return Collections.emptyList();
        }
        Map<CatalogObjectKind, List<CatalogEntry>> kindMap = childrenByParent.get(parent);
        if (kindMap == null) {
            return Collections.emptyList();
        }
        List<CatalogEntry> entries = kindMap.get(kind);
        return entries == null ? Collections.<CatalogEntry>emptyList() : entries;
    }

    @Override
    public List<CatalogDiagnostic> diagnostics() {
        return diagnostics;
    }

    @Override
    public long materializedAtMillis() {
        return materializedAtMillis;
    }

    /** Total entry count across all kinds. Useful for logging / smoke tests. */
    public int size() {
        int n = 0;
        for (List<CatalogEntry> list : byKind.values()) n += list.size();
        return n;
    }

    private static Map<CatalogObjectKind, Map<String, CatalogEntry>> freezeNested(
            Map<CatalogObjectKind, Map<String, CatalogEntry>> in) {
        Map<CatalogObjectKind, Map<String, CatalogEntry>> out =
            new LinkedHashMap<CatalogObjectKind, Map<String, CatalogEntry>>(in.size());
        for (Map.Entry<CatalogObjectKind, Map<String, CatalogEntry>> e : in.entrySet()) {
            out.put(e.getKey(), Collections.unmodifiableMap(
                new LinkedHashMap<String, CatalogEntry>(e.getValue())));
        }
        return Collections.unmodifiableMap(out);
    }

    private static Map<CatalogObjectKind, List<CatalogEntry>> freezeListMap(
            Map<CatalogObjectKind, List<CatalogEntry>> in) {
        Map<CatalogObjectKind, List<CatalogEntry>> out =
            new LinkedHashMap<CatalogObjectKind, List<CatalogEntry>>(in.size());
        for (Map.Entry<CatalogObjectKind, List<CatalogEntry>> e : in.entrySet()) {
            out.put(e.getKey(), Collections.unmodifiableList(
                new ArrayList<CatalogEntry>(e.getValue())));
        }
        return Collections.unmodifiableMap(out);
    }

    private static Map<CatalogObjectId, Map<CatalogObjectKind, List<CatalogEntry>>> freezeChildren(
            Map<CatalogObjectId, Map<CatalogObjectKind, List<CatalogEntry>>> in) {
        Map<CatalogObjectId, Map<CatalogObjectKind, List<CatalogEntry>>> out =
            new LinkedHashMap<CatalogObjectId, Map<CatalogObjectKind, List<CatalogEntry>>>(in.size());
        for (Map.Entry<CatalogObjectId, Map<CatalogObjectKind, List<CatalogEntry>>> e : in.entrySet()) {
            out.put(e.getKey(), freezeListMap(e.getValue()));
        }
        return Collections.unmodifiableMap(out);
    }

    public static final class Builder {

        private EDbVendor vendor;
        private final Map<CatalogObjectKind, Map<String, CatalogEntry>> byKey =
            new LinkedHashMap<CatalogObjectKind, Map<String, CatalogEntry>>();
        private final Map<CatalogObjectKind, List<CatalogEntry>> byKind =
            new LinkedHashMap<CatalogObjectKind, List<CatalogEntry>>();
        private final Map<CatalogObjectId, Map<CatalogObjectKind, List<CatalogEntry>>> childrenByParent =
            new LinkedHashMap<CatalogObjectId, Map<CatalogObjectKind, List<CatalogEntry>>>();
        private final List<CatalogDiagnostic> diagnostics = new ArrayList<CatalogDiagnostic>();
        private long materializedAtMillis;

        private Builder() {
        }

        public Builder vendor(EDbVendor v) {
            this.vendor = v;
            return this;
        }

        /**
         * Add an entry with optional parent. {@code parent} may be {@code null} for top-level
         * objects (catalogs). Children are folded into the snapshot's {@code childrenByParent}
         * index immediately so the resulting snapshot can answer {@code children(...)} in
         * constant time per parent/kind.
         */
        public Builder put(CatalogEntry entry, CatalogObjectId parent) {
            if (entry == null) {
                throw new IllegalArgumentException("InMemoryCatalogSnapshot entry may not be null");
            }
            CatalogObjectKind kind = entry.kind();
            String key = CatalogIdentifierPolicy.keyForMap(entry.name());
            byKey.computeIfAbsent(kind, k -> new LinkedHashMap<String, CatalogEntry>()).put(key, entry);
            byKind.computeIfAbsent(kind, k -> new ArrayList<CatalogEntry>()).add(entry);
            if (parent != null) {
                childrenByParent
                    .computeIfAbsent(parent, k -> new LinkedHashMap<CatalogObjectKind, List<CatalogEntry>>())
                    .computeIfAbsent(kind, k -> new ArrayList<CatalogEntry>())
                    .add(entry);
            }
            return this;
        }

        public Builder put(CatalogEntry entry) {
            return put(entry, null);
        }

        public Builder addDiagnostic(CatalogDiagnostic d) {
            if (d != null) this.diagnostics.add(d);
            return this;
        }

        public Builder materializedAtMillis(long v) {
            this.materializedAtMillis = v;
            return this;
        }

        public InMemoryCatalogSnapshot build() {
            return new InMemoryCatalogSnapshot(this);
        }
    }
}