package gudusoft.gsqlparser.resolver2.format;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.TAttributeNode;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.ScopeBuildResult;
import gudusoft.gsqlparser.resolver2.TSQLResolver2;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;
import gudusoft.gsqlparser.resolver2.namespace.TableNamespace;
import gudusoft.gsqlparser.sqlenv.CanonKey;
import gudusoft.gsqlparser.sqlenv.CollatorProvider;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierInputForm;
import gudusoft.gsqlparser.sqlenv.IdentifierProfile;
import gudusoft.gsqlparser.sqlenv.IdentifierService;
import gudusoft.gsqlparser.sqlenv.TSQLTable;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Decides which {@code t.*} entries of a {@code Tables:}/{@code Fields:} listing say nothing
 * the listing does not already say — from the identity of what was emitted, never from the
 * rendered text.
 *
 * <p>The rule (owner's, 2026-09-15): a star entry is listed only while it carries information.
 * Once every column of the table it stands for has reached the output under the same table
 * prefix, the star adds nothing and is dropped. Anything that cannot be PROVEN is kept — a
 * redundant star is a cosmetic extra, while a star dropped in error silently deletes the only
 * record that the table has further columns.
 *
 * <p>Why identity and not text. The namespace keys are the names as the catalog STORES them
 * and a rendered field is the spelling as the query WROTE it, minus the delimiters the display
 * layer strips. Oracle shows the two forms disagreeing in both directions: {@code SELECT c123}
 * renders {@code c123} against a stored {@code C123}, and
 * {@code CREATE TABLE t(foo int, "foo" int)} stores {@code FOO} and {@code foo}, both of which
 * render as {@code foo}. No single normalization of the rendered text recovers both, measured.
 * So every emitted entry is recorded with what produced it and joined to the namespace by one of
 * three stable identities:
 *
 * <ul>
 *   <li>the reference's own {@link ColumnSource}, when it IS the namespace's object (explicit
 *       references to a FROM table carry exactly that object);</li>
 *   <li>the {@link ColumnSource} resolver2 expanded a star into, recorded by
 *       {@link TSQLResolver2#getStarExpansionSource(TAttributeNode)} at expansion time;</li>
 *   <li>for a reference the resolver attributes to the star's table — the same {@link TTable}
 *       occurrence, its {@code getFinalTable()}, or another occurrence of the same catalog
 *       {@link TSQLTable} such as the {@code CREATE TABLE} that declared it — the namespace's
 *       own lookup of the reference's lexical spelling, {@code SQL_LEXICAL} against
 *       {@code CATALOG_STORED} through {@link IdentifierService}.</li>
 * </ul>
 *
 * <p>Two entries that render to the same text are one line in the output. A column that only
 * reached the output as such a shared line has not reached it in any way a reader can see, so it
 * does not count, and the star survives to say that the table has more.
 *
 * <p>One star text can stand for several table occurrences ({@code SELECT * FROM t; SELECT t.*
 * FROM t}); it is dropped only when every one of them is proven. And the star texts are kept
 * apart from the column entries by the callers, so a column whose bare display name happens to
 * be {@code *} can never be reached by the pruning at all.
 */
public final class StarRedundancyLedger {

    private static final class StarEntry {
        final String text;
        final String prefix;
        final TTable table;

        StarEntry(String text, String prefix, TTable table) {
            this.text = text;
            this.prefix = prefix;
            this.table = table;
        }
    }

    private static final class Emitted {
        final String prefix;
        final String rendered;
        final TObjectName column;
        final TTable table;
        final TAttributeNode attribute;
        final ColumnSource source;

        Emitted(String prefix, String rendered, TObjectName column, TTable table, TAttributeNode attribute,
                ColumnSource source) {
            this.prefix = prefix;
            this.rendered = rendered;
            this.column = column;
            this.table = table;
            this.attribute = attribute;
            this.source = source;
        }
    }

    /** Marks a rendered line that an entry NOT attributable to the star's table also produced. */
    private static final Object FOREIGN = new Object();

    private final ScopeBuildResult buildResult;
    private final TSQLResolver2 resolver;
    private final IdentifierService identifiers;
    private final List<StarEntry> stars = new ArrayList<StarEntry>();
    /**
     * Every recorded entry, in one list: a collision is a property of the WHOLE rendered line,
     * and two lines can be equal while their recorded prefixes differ (a table {@code x} with a
     * member {@code "y.z"} and a table {@code "x.y"} with a member {@code z} both print
     * {@code x.y.z} once the display layer has dropped the delimiters).
     */
    private final List<Emitted> emitted = new ArrayList<Emitted>();

    /**
     * @param resolver the resolver whose scope build the output was produced from; {@code null}
     *                 when there is none (the legacy resolver), in which case nothing can be
     *                 proven and every star is kept
     * @param vendor   the vendor whose identifier rules apply; {@code null} disables the lexical
     *                 join, which again only keeps stars
     */
    public StarRedundancyLedger(TSQLResolver2 resolver, EDbVendor vendor) {
        this.resolver = resolver;
        this.buildResult = resolver == null ? null : resolver.getScopeBuildResult();
        this.identifiers = identifierServiceFor(resolver, vendor);
    }

    /**
     * The identifier rules the lexical join runs under. The environment's own service when there
     * is one — it carries the configured SQL Server collation, and the namespace keys were made
     * by it — otherwise a service built the way {@code TSQLEnv} builds its own, collator included,
     * so a SQL Server comparison never falls back to plain Unicode folding.
     */
    private static IdentifierService identifierServiceFor(TSQLResolver2 resolver, EDbVendor vendor) {
        if (resolver != null && resolver.getSqlEnv() != null
                && resolver.getSqlEnv().getIdentifierService() != null) {
            return resolver.getSqlEnv().getIdentifierService();
        }
        if (vendor == null) return null;
        CollatorProvider collator = (vendor == EDbVendor.dbvmssql || vendor == EDbVendor.dbvazuresql)
                ? new CollatorProvider() : null;
        return new IdentifierService(
                IdentifierProfile.forVendor(vendor, IdentifierProfile.VendorFlags.defaults()), collator);
    }

    /** A star entry that would be written as {@code text}, standing for {@code table}, under {@code prefix}. */
    public void recordStar(String text, String prefix, TTable table) {
        if (text == null || prefix == null) return;
        stars.add(new StarEntry(text, prefix, table));
    }

    /** A column entry written as {@code rendered} for the reference {@code column}, shown under {@code prefix} as a column of {@code renderedTable}. */
    public void recordColumn(String prefix, String rendered, TObjectName column, TTable renderedTable) {
        if (prefix == null || rendered == null || column == null) return;
        emitted.add(new Emitted(prefix, rendered, column, renderedTable, null, null));
    }

    /** A column entry written as {@code rendered} from a star's expanded attribute. */
    public void recordExpandedAttribute(String prefix, String rendered, TAttributeNode attribute) {
        if (prefix == null || rendered == null || attribute == null) return;
        emitted.add(new Emitted(prefix, rendered, null, null, attribute, null));
    }

    /** A column entry written as {@code rendered} directly for a namespace member. */
    public void recordNamespaceColumn(String prefix, String rendered, ColumnSource source) {
        if (prefix == null || rendered == null || source == null) return;
        emitted.add(new Emitted(prefix, rendered, null, null, null, source));
    }

    /**
     * A line the writer put into its output WITHOUT a producer this ledger can name — an orphan's
     * {@code missed.} line, a DDL constraint column, a PIVOT output column. It can prove nothing,
     * but it still folds with recorded lines in the writer's de-duplication, and a member whose
     * only line it swallowed has not reached the reader. So it is bucketed like every other line.
     */
    public void recordForeignLine(String rendered) {
        if (rendered == null) return;
        emitted.add(new Emitted("", rendered, null, null, null, null));
    }

    public boolean hasStars() {
        return !stars.isEmpty();
    }

    public void clear() {
        stars.clear();
        emitted.clear();
    }

    /**
     * The star texts that every recorded occurrence proves redundant.
     *
     * @param finalLines every column line the writer has already put into its output, whether or
     *                   not it was recorded here. A line that reached the output without passing
     *                   through this ledger (an orphan {@code missed.} line, a DDL constraint
     *                   column) still folds with the recorded lines in the writer's
     *                   de-duplication, so it takes part in the collision accounting as a line
     *                   that stands for nothing this ledger can name.
     */
    public Set<String> redundantStarEntries(Collection<String> finalLines) {
        Set<String> unrecorded = new java.util.TreeSet<String>(String.CASE_INSENSITIVE_ORDER);
        if (finalLines != null) {
            unrecorded.addAll(finalLines);
            for (Emitted entry : emitted) unrecorded.remove(entry.rendered);
        }
        Map<String, Boolean> verdict = new LinkedHashMap<String, Boolean>();
        for (StarEntry star : stars) {
            boolean proven = isRedundant(star, unrecorded);
            Boolean earlier = verdict.get(star.text);
            verdict.put(star.text, earlier == null ? proven : (earlier && proven));
        }
        Set<String> redundant = new LinkedHashSet<String>();
        for (Map.Entry<String, Boolean> entry : verdict.entrySet()) {
            if (entry.getValue()) redundant.add(entry.getKey());
        }
        return redundant;
    }

    private boolean isRedundant(StarEntry star, Set<String> unrecordedLines) {
        if (buildResult == null || star.table == null) return false;
        INamespace namespace = buildResult.getNamespaceForTable(star.table);
        if (namespace == null) return false;
        Map<String, ColumnSource> declared = namespace.getAllColumnSources();
        if (declared == null || declared.isEmpty()) return false;

        // The column list has to be KNOWN and COMPLETE. A table without metadata still gets a
        // namespace — the star placeholder itself, plus whatever the query names, all
        // inferred_from_usage — and that shape says nothing about what the table really has.
        // Nor does "every member is definite": a table function with a partial alias list
        // (`FROM my_func() AS f("*")`) holds one definite member while the namespace itself
        // stays non-authoritative because the function's remaining outputs are unknown. Only
        // the namespace can say whether it enumerates the whole schema, and it says so with
        // MetadataState.FOUND.
        if (namespace.getMetadataState() != gudusoft.gsqlparser.resolver2.namespace.MetadataState.FOUND) {
            return false;
        }
        Set<ColumnSource> wanted = identitySet();
        for (ColumnSource source : declared.values()) {
            if (source == null || source.isInferred()) return false;
            wanted.add(source);
        }

        // EVERY line the writer will print goes into a bucket, not only the ones under this
        // star's prefix: a line only counts for a member if NOTHING else prints the same line.
        // Two catalog tables can render to one prefix (Oracle `t` and `"t"`), prefixes can differ
        // only by case, and equal lines can come from different prefixes altogether once the
        // display layer has dropped delimiters (`x."y.z"` and `"x.y".z` both print `x.y.z`). An
        // entry that cannot be attributed to a member of this table — including every entry
        // under another prefix, and every line that never passed through the ledger — marks its
        // line as shared, so no member can be counted as visible through it. Buckets use the
        // writers' equality (both de-duplicate lines case-insensitively).
        // non-identifier-compare: the writers' rendered-line de-duplication, mirrored
        Map<String, Set<Object>> byRendered =
                new java.util.TreeMap<String, Set<Object>>(String.CASE_INSENSITIVE_ORDER);
        for (Emitted entry : emitted) {
            boolean underThisPrefix = String.CASE_INSENSITIVE_ORDER.compare(entry.prefix, star.prefix) == 0;
            ColumnSource source = underThisPrefix ? attribute(entry, star.table, declared, wanted) : null;
            Set<Object> sharing = byRendered.get(entry.rendered);
            if (sharing == null) {
                sharing = Collections.newSetFromMap(new IdentityHashMap<Object, Boolean>());
                byRendered.put(entry.rendered, sharing);
            }
            sharing.add(source == null ? FOREIGN : source);
        }
        for (String line : unrecordedLines) {
            Set<Object> sharing = byRendered.get(line);
            if (sharing == null) {
                sharing = Collections.newSetFromMap(new IdentityHashMap<Object, Boolean>());
                byRendered.put(line, sharing);
            }
            sharing.add(FOREIGN);
        }
        // Every star text is a printed line too (a retained `"x.Y".*` prints `x.Y.*`, the same
        // line as table x's member named `Y.*`), so it shares like any other line.
        for (StarEntry other : stars) {
            Set<Object> sharing = byRendered.get(other.text);
            if (sharing == null) {
                sharing = Collections.newSetFromMap(new IdentityHashMap<Object, Boolean>());
                byRendered.put(other.text, sharing);
            }
            sharing.add(FOREIGN);
        }

        Set<ColumnSource> present = identitySet();
        for (Set<Object> sharing : byRendered.values()) {
            if (sharing.size() != 1) continue;
            Object only = sharing.iterator().next();
            if (only instanceof ColumnSource) present.add((ColumnSource) only);
        }
        return present.size() == wanted.size();
    }

    /**
     * The namespace member an emitted entry stands for, or {@code null} when that cannot be
     * established. Only members of {@code wanted} are ever returned.
     */
    private ColumnSource attribute(Emitted entry, TTable starTable, Map<String, ColumnSource> declared,
                                   Set<ColumnSource> wanted) {
        // A line with leading or trailing whitespace (a member named `"z "`) is not printed as
        // recorded — the writer trims its text — so it cannot vouch for the member.
        // non-identifier-compare: rendered text vs what the writer prints
        if (!entry.rendered.equals(entry.rendered.trim())) return null;
        // A name containing a line break is printed across two physical lines by both writers,
        // so no single printed line is the member's.
        if (entry.rendered.indexOf('\n') >= 0 || entry.rendered.indexOf('\r') >= 0) return null;
        if (entry.source != null) {
            return wanted.contains(entry.source) ? entry.source : null;
        }
        if (entry.attribute != null) {
            ColumnSource source = resolver == null ? null : resolver.getStarExpansionSource(entry.attribute);
            return source != null && wanted.contains(source) ? source : null;
        }
        if (entry.column == null) return null;

        ColumnSource own = entry.column.getColumnSource();
        if (own != null && wanted.contains(own)) return own;

        // The resolver attributed this reference to the star's table but handed it a
        // ColumnSource of its own (a reference traced through a subquery star carries a copy,
        // measured), or none at all (a CREATE TABLE column definition). The reference's lexical
        // spelling then selects the member through the namespace's own lookup rule.
        boolean sameTable = entry.table == starTable
                || (own != null && own.getFinalTable() == starTable)
                || sameCatalogTable(entry.table, starTable);
        if (!sameTable) return null;
        return lookupLexical(declared, entry.column.getColumnNameOnly());
    }

    private boolean sameCatalogTable(TTable a, TTable b) {
        TSQLTable catalogA = catalogTableOf(a);
        return catalogA != null && catalogA == catalogTableOf(b);
    }

    private TSQLTable catalogTableOf(TTable table) {
        if (table == null) return null;
        if (table.getResolvedTable() != null) return table.getResolvedTable();
        INamespace namespace = buildResult.getNamespaceForTable(table);
        if (namespace instanceof TableNamespace) {
            return ((TableNamespace) namespace).getResolvedTable();
        }
        return null;
    }

    private ColumnSource lookupLexical(Map<String, ColumnSource> declared, String lexical) {
        if (identifiers == null || lexical == null || lexical.isEmpty()) return null;
        CanonKey wanted = identifiers.canonKeyOf(lexical, ESQLDataObjectType.dotColumn,
                IdentifierInputForm.SQL_LEXICAL);
        for (Map.Entry<String, ColumnSource> entry : declared.entrySet()) {
            String stored = entry.getKey();
            if (stored == null || stored.isEmpty() || entry.getValue() == null) continue;
            CanonKey key = identifiers.canonKeyOf(stored, ESQLDataObjectType.dotColumn,
                    IdentifierInputForm.CATALOG_STORED);
            if (wanted.equals(key)) return entry.getValue();
        }
        return null;
    }

    private static Set<ColumnSource> identitySet() {
        return Collections.newSetFromMap(new IdentityHashMap<ColumnSource, Boolean>());
    }
}