package gudusoft.gsqlparser.ir.semantic.binding;

import gudusoft.gsqlparser.ir.semantic.ColumnRef;
import gudusoft.gsqlparser.nodes.TTable;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

/**
 * Slice 65 — per-{@code SELECT} merged-key scope for {@code JOIN ... USING}.
 *
 * <p>Slice 64 admitted {@code JOIN ... USING (k)} at the predicate side
 * ({@code joinColumnRefs}). Slice 65 lifts the output / non-JOIN-ON
 * clause side: unqualified references to a USING merged key (in
 * SELECT / WHERE / GROUP BY / HAVING / ORDER BY) resolve to the merged
 * source list of every relation in the USING(k) equivalence class.
 *
 * <p>Equivalence classes are per-key (DSU over USING joins); multiple
 * disconnected classes can exist for the same key name. {@link #has}
 * tells whether a name is a USING key; {@link #isAmbiguous} signals
 * either disconnected-class ambiguity or an out-of-class same-named
 * column (caller throws with {@link #ambiguityReason}).
 *
 * <p>Each {@code SemanticIRBuilder.buildSelectStatementImpl} invocation
 * resets its provider's using scope to {@link #EMPTY} at entry, then
 * optionally narrows the provider with its own scope. This prevents an
 * enclosing SELECT's USING from leaking into recursive nested builds
 * (predicate-subquery bodies, scalar-subquery bodies, set-op branch
 * bodies, CTE bodies, FROM-subquery bodies).
 */
public final class UsingScope {

    public static final UsingScope EMPTY = new UsingScope(
            Collections.<String, List<MergedKeyEntry>>emptyMap(),
            Collections.<String, String>emptyMap());

    /**
     * One equivalence class of FROM-clause relations connected by a
     * specific USING key.
     */
    public static final class EquivalenceClass {
        private final String key;
        private final List<TTable> members;

        public EquivalenceClass(String key, List<TTable> members) {
            if (key == null || key.isEmpty()) {
                throw new IllegalArgumentException("key must not be null/empty");
            }
            if (members == null || members.isEmpty()) {
                throw new IllegalArgumentException(
                        "equivalence class must have at least one member");
            }
            this.key = key.toLowerCase(Locale.ROOT);
            this.members = Collections.unmodifiableList(new ArrayList<>(members));
        }

        public String getKey() { return key; }
        public List<TTable> getMembers() { return members; }
    }

    /**
     * One merged-key entry: a class and its FROM-ordered merged source
     * column refs (narrowed by catalog when available).
     */
    public static final class MergedKeyEntry {
        private final EquivalenceClass equivClass;
        private final List<ColumnRef> sources;

        public MergedKeyEntry(EquivalenceClass equivClass, List<ColumnRef> sources) {
            if (equivClass == null) {
                throw new IllegalArgumentException("equivClass must not be null");
            }
            if (sources == null) {
                throw new IllegalArgumentException("sources must not be null");
            }
            this.equivClass = equivClass;
            this.sources = Collections.unmodifiableList(new ArrayList<>(sources));
        }

        public EquivalenceClass getEquivClass() { return equivClass; }
        public List<ColumnRef> getSources() { return sources; }
    }

    private final Map<String, List<MergedKeyEntry>> entriesByName;
    private final Map<String, String> ambiguityReasonByName;
    /**
     * Slice — catalog-less {@code NATURAL JOIN} degrade fallback. Ordered
     * (FROM-order) list of relation aliases that participate in a
     * NATURAL join whose shared-key set could not be computed (no catalog
     * metadata). Under NATURAL semantics the join keys merge into a single
     * output column, so an unqualified reference to such a column is
     * unambiguous; but without a catalog the binder can't enumerate the
     * keys to pick a side. When this list is non-empty, an unqualified
     * column reference that fails to bind is resolved deterministically to
     * the left-side (first) relation rather than rejected as
     * {@code COLUMN_BINDING_NON_EXACT} — honoring the degrade-not-fail
     * principle (GSP R6). Empty for non-NATURAL FROM clauses, so genuine
     * unqualified ambiguity in plain joins still errors.
     */
    private final List<String> naturalDegradeRelations;

    public UsingScope(Map<String, List<MergedKeyEntry>> entriesByName,
                      Map<String, String> ambiguityReasonByName) {
        this(entriesByName, ambiguityReasonByName,
                Collections.<String>emptyList());
    }

    public UsingScope(Map<String, List<MergedKeyEntry>> entriesByName,
                      Map<String, String> ambiguityReasonByName,
                      List<String> naturalDegradeRelations) {
        Map<String, List<MergedKeyEntry>> entriesCopy =
                new LinkedHashMap<>();
        for (Map.Entry<String, List<MergedKeyEntry>> e : entriesByName.entrySet()) {
            String key = e.getKey() == null ? null : e.getKey().toLowerCase(Locale.ROOT);
            if (key == null || key.isEmpty() || e.getValue() == null || e.getValue().isEmpty()) {
                continue;
            }
            entriesCopy.put(key, Collections.unmodifiableList(new ArrayList<>(e.getValue())));
        }
        this.entriesByName = Collections.unmodifiableMap(entriesCopy);
        Map<String, String> reasonCopy = new HashMap<>();
        for (Map.Entry<String, String> e : ambiguityReasonByName.entrySet()) {
            String key = e.getKey() == null ? null : e.getKey().toLowerCase(Locale.ROOT);
            if (key == null || key.isEmpty() || e.getValue() == null) continue;
            reasonCopy.put(key, e.getValue());
        }
        this.ambiguityReasonByName = Collections.unmodifiableMap(reasonCopy);
        List<String> degradeCopy = new ArrayList<>();
        if (naturalDegradeRelations != null) {
            for (String a : naturalDegradeRelations) {
                if (a != null && !a.isEmpty()) degradeCopy.add(a);
            }
        }
        this.naturalDegradeRelations = Collections.unmodifiableList(degradeCopy);
    }

    /** Convenience constructor for empty-ambiguity scopes. */
    private UsingScope(Map<String, List<MergedKeyEntry>> entriesByName,
                       boolean noAmbiguity) {
        this(entriesByName, Collections.<String, String>emptyMap());
    }

    /** True iff {@code name} matches a USING key in this scope (case-insensitive). */
    public boolean has(String name) {
        if (name == null) return false;
        return entriesByName.containsKey(name.toLowerCase(Locale.ROOT));
    }

    /**
     * True iff a bare unqualified {@code name} reference is ambiguous —
     * either because two disconnected USING classes carry the same key
     * name, or because catalog declares the same column on a relation
     * outside the (single) equivalence class.
     */
    public boolean isAmbiguous(String name) {
        if (name == null) return false;
        return ambiguityReasonByName.containsKey(name.toLowerCase(Locale.ROOT));
    }

    /** Diagnostic text for an ambiguous name. Returns {@code null} when not ambiguous. */
    public String ambiguityReason(String name) {
        if (name == null) return null;
        return ambiguityReasonByName.get(name.toLowerCase(Locale.ROOT));
    }

    /** All entries for a USING key. Empty when {@code !has(name)}. */
    public List<MergedKeyEntry> entriesFor(String name) {
        if (name == null) return Collections.emptyList();
        List<MergedKeyEntry> entries = entriesByName.get(name.toLowerCase(Locale.ROOT));
        return entries == null ? Collections.<MergedKeyEntry>emptyList() : entries;
    }

    /**
     * Returns the {@link MergedKeyEntry} whose equivalence class
     * contains {@code table} by object identity, or {@code null} if
     * {@code table} is not in any class for {@code name}.
     *
     * <p>{@code TTable} instances do not override {@code equals}, so
     * identity check is the only safe membership test.
     */
    public MergedKeyEntry entryContaining(String name, TTable table) {
        if (name == null || table == null) return null;
        List<MergedKeyEntry> entries = entriesByName.get(name.toLowerCase(Locale.ROOT));
        if (entries == null) return null;
        for (MergedKeyEntry entry : entries) {
            for (TTable member : entry.getEquivClass().getMembers()) {
                if (member == table) return entry;
            }
        }
        return null;
    }

    /**
     * Flattened sources of the SINGLE entry for {@code name}.
     *
     * @throws IllegalStateException when the scope has zero or multiple
     *         entries for {@code name} — callers must check
     *         {@link #has} and {@link #isAmbiguous} first.
     */
    public List<ColumnRef> mergedSourcesFor(String name) {
        if (name == null) {
            throw new IllegalArgumentException("name must not be null");
        }
        List<MergedKeyEntry> entries = entriesByName.get(name.toLowerCase(Locale.ROOT));
        if (entries == null || entries.isEmpty()) {
            throw new IllegalStateException(
                    "no merged-key entries for '" + name + "' (caller should check has() first)");
        }
        if (entries.size() > 1) {
            throw new IllegalStateException(
                    "multiple disconnected equivalence classes for '" + name
                            + "' (caller should check isAmbiguous() first)");
        }
        return entries.get(0).getSources();
    }

    /**
     * Whether this scope carries no information at all — neither merged-key
     * entries nor a NATURAL-degrade fallback. Callers install the scope on
     * the provider only when this is {@code false}.
     */
    public boolean isEmpty() {
        return entriesByName.isEmpty() && naturalDegradeRelations.isEmpty();
    }

    /**
     * True iff this scope carries at least one merged-key equivalence class —
     * i.e. the FROM clause has a {@code JOIN ... USING} (or a catalog-resolved
     * {@code NATURAL JOIN}) that produced merged keys. Distinct from
     * {@link #hasNaturalDegrade()}, which covers the catalog-less NATURAL case
     * where no keys could be enumerated. Used to anchor the degrade of an
     * otherwise-fatal unqualified column-binding miss: a USING join is a
     * structural reason an unqualified non-key column cannot be placed without
     * a catalog, so the analysis degrades rather than aborts.
     */
    public boolean hasMergedKeys() {
        return !entriesByName.isEmpty();
    }

    /**
     * True iff this FROM clause contains a catalog-less {@code NATURAL JOIN}
     * whose shared keys could not be enumerated, enabling the degrade
     * fallback for unqualified column references. See
     * {@link #naturalDegradeRelations}.
     */
    public boolean hasNaturalDegrade() {
        return !naturalDegradeRelations.isEmpty();
    }

    /**
     * The deterministic left-side relation alias to which an unbindable
     * unqualified reference degrades, or {@code null} when there is no
     * NATURAL-degrade fallback. This is the first (leftmost in FROM order)
     * NATURAL-join relation.
     */
    public String naturalDegradeFallbackAlias() {
        return naturalDegradeRelations.isEmpty()
                ? null : naturalDegradeRelations.get(0);
    }
}