package gudusoft.gsqlparser.catalog.runtime;

import gudusoft.gsqlparser.sqlenv.CanonKey;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierComponentRole;
import gudusoft.gsqlparser.sqlenv.IdentifierInputForm;
import gudusoft.gsqlparser.sqlenv.IdentifierRolePolicy;
import gudusoft.gsqlparser.sqlenv.IdentifierService;

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

/**
 * Identity of one named catalog object, built from EXPLICIT semantic roles (stage S0R of
 * docs/refactor/identifier_identity_display_separation_plan.md).
 *
 * <h3>What this replaces and why</h3>
 * The deleted {@code QualifiedCanonKey} inferred each component's role from how many components the
 * name had. That is a guess, and it is wrong in both directions: it read BigQuery
 * {@code customer.name} as {@code table.column} when the repository's own {@code FieldPath} and
 * {@code TestBigQueryNestedColumns} say it is base column plus STRUCT field — and BigQuery folds
 * table names case-sensitively while folding column names case-insensitively, so the guess changed
 * the ANSWER, not merely the label. It also had no server level at all, so SQL Server's
 * {@code srv.db.dbo.t} had its server compared as a catalog.
 *
 * <p>Here nothing is inferred. Each component carries its role; each OBJECT component carries its
 * entity kind; the sequence is validated by {@link CatalogNameGrammar} at construction; and the
 * comparison rules for each component come from the one mapping that owns them
 * ({@link IdentifierRolePolicy} for role-decided components,
 * {@link CatalogIdentifierPolicy#comparisonTypeOfKind} for objects).
 *
 * <h3>Equality</h3>
 * Two keys are equal iff they have the same terminal kind, the same number of components, and
 * component-wise equal role, kind and {@link CanonKey} — plus an equal database link. So a table
 * named {@code x} never equals a view named {@code x}, and {@code db.s.t} never equals a name whose
 * first component is a server.
 *
 * <h3>In-process only</h3>
 * It contains {@link CanonKey}s, whose collation payloads are stable only within one JVM and
 * collator configuration. Do NOT stringify it to produce a {@code CatalogObjectId}: that type
 * promises cross-snapshot stability, which this cannot give. Use {@code PersistentIdentifierKey}
 * for anything persisted, and never {@code CanonKey.getCanonText()} or this type's
 * {@code toString()}.
 */
public final class CatalogObjectKey {

    /** One component: its role, its entity kind when it is an object, and its canonical key. */
    public static final class Component {
        private final IdentifierComponentRole role;
        private final CatalogObjectKind kind;
        private final CanonKey key;

        Component(IdentifierComponentRole role, CatalogObjectKind kind, CanonKey key) {
            this.role = role;
            this.kind = kind;
            this.key = key;
        }

        public IdentifierComponentRole getRole() {
            return role;
        }

        /** The entity kind, non-null exactly when the role is {@link IdentifierComponentRole#OBJECT}. */
        public CatalogObjectKind getKind() {
            return kind;
        }

        public CanonKey getKey() {
            return key;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) {
                return true;
            }
            if (o == null || getClass() != o.getClass()) {
                return false;
            }
            Component that = (Component) o;
            return role == that.role && kind == that.kind && key.equals(that.key);
        }

        @Override
        public int hashCode() {
            int h = role.hashCode();
            h = 31 * h + (kind == null ? 0 : kind.hashCode());
            return 31 * h + key.hashCode();
        }

        @Override
        public String toString() {
            return role + (kind == null ? "" : "(" + kind + ")") + "=" + key;
        }
    }

    private final List<Component> components;
    private final CatalogObjectKind terminalKind;
    private final CatalogHierarchy hierarchy;
    private final CanonKey databaseLink;
    private final int hash;

    private CatalogObjectKey(List<Component> components, CatalogObjectKind terminalKind,
                             CatalogHierarchy hierarchy, CanonKey databaseLink) {
        this.components = Collections.unmodifiableList(new ArrayList<Component>(components));
        this.terminalKind = terminalKind;
        this.hierarchy = hierarchy;
        this.databaseLink = databaseLink;
        int h = this.components.hashCode();
        h = 31 * h + terminalKind.hashCode();
        h = 31 * h + hierarchy.hashCode();
        this.hash = 31 * h + (databaseLink == null ? 0 : databaseLink.hashCode());
    }

    // ------------------------------------------------------------------ builder

    /**
     * Assembles a key one component at a time. <strong>Deliberately not public.</strong> It is the
     * widest and least compiler-guided construction path, so while the grammar is still growing it
     * would be the way an unexamined shape gets built. Callers use the named factories below, which
     * state the topology and the parent relationship. If production later proves a general entry
     * point necessary, it should take an explicit layout and run the full grammar.
     */
    static Builder builder(IdentifierService service, CatalogHierarchy hierarchy) {
        return new Builder(service, hierarchy);
    }

    /** @see #builder(IdentifierService, CatalogHierarchy) */
    static final class Builder {
        private final IdentifierService service;
        private final CatalogHierarchy hierarchy;
        private final List<IdentifierComponentRole> roles = new ArrayList<IdentifierComponentRole>();
        private final List<CatalogObjectKind> kinds = new ArrayList<CatalogObjectKind>();
        private final List<CanonKey> keys = new ArrayList<CanonKey>();
        private CanonKey databaseLink;
        private boolean databaseLinkInherited;

        private Builder(IdentifierService service, CatalogHierarchy hierarchy) {
            if (service == null) {
                throw new IllegalArgumentException("an identifier service is required: it carries "
                        + "the vendor profile the component keys are computed under");
            }
            if (hierarchy == null) {
                throw new IllegalArgumentException("the namespace topology must be declared");
            }
            this.service = service;
            this.hierarchy = hierarchy;
        }

        /** A container component — server, catalog or schema. */
        public Builder container(IdentifierComponentRole role, String text, IdentifierInputForm form) {
            if (role == IdentifierComponentRole.OBJECT) {
                throw new IllegalArgumentException("use object(kind, text, form) for an object");
            }
            ESQLDataObjectType type = IdentifierRolePolicy.comparisonTypeOf(role);
            return add(role, null, requireKey(text, type, form, role.toString()));
        }

        /** A named object component, with the entity kind that decides how its name folds. */
        public Builder object(CatalogObjectKind kind, String text, IdentifierInputForm form) {
            ESQLDataObjectType type = CatalogIdentifierPolicy.comparisonTypeOfKind(kind);
            return add(IdentifierComponentRole.OBJECT, kind,
                    requireKey(text, type, form, "OBJECT(" + kind + ")"));
        }

        /** The base column of a relation. */
        public Builder baseColumn(String text, IdentifierInputForm form) {
            ESQLDataObjectType type =
                    IdentifierRolePolicy.comparisonTypeOf(IdentifierComponentRole.BASE_COLUMN);
            return add(IdentifierComponentRole.BASE_COLUMN, null,
                    requireKey(text, type, form, "BASE_COLUMN"));
        }

        /**
         * An Oracle-style database link. Stored out of line because it qualifies the whole name
         * rather than occupying a position in the hierarchy — but it does participate in equality,
         * since {@code t@remote} and {@code t} are different objects.
         */
        public Builder databaseLink(String text, IdentifierInputForm form) {
            if (databaseLink != null) {
                throw new IllegalArgumentException(databaseLinkInherited
                        ? "this identity already carries its parent's database link; a child of a "
                        + "remote object is part of the same remote identity and may not change it"
                        : "a name has one database link");
            }
            ESQLDataObjectType type =
                    IdentifierRolePolicy.comparisonTypeOf(IdentifierComponentRole.DATABASE_LINK);
            this.databaseLink = requireKey(text, type, form, "DATABASE_LINK");
            return this;
        }

        private Builder add(IdentifierComponentRole role, CatalogObjectKind kind, CanonKey key) {
            roles.add(role);
            kinds.add(kind);
            keys.add(key);
            return this;
        }

        private CanonKey requireKey(String text, ESQLDataObjectType type, IdentifierInputForm form,
                                    String what) {
            if (text == null || text.isEmpty()) {
                throw new IllegalArgumentException(what + " component has no text; an absent level "
                        + "is not an empty name — build a CatalogLookupName instead");
            }
            CanonKey key = service.canonKeyOf(text, type, form);
            if (key == null) {
                throw new IllegalStateException("no canonical key for " + what + " text " + text);
            }
            return key;
        }

        /**
         * Validates the whole sequence and builds the key.
         *
         * @param terminalKind what the name as a whole denotes; must agree with the last component
         */
        CatalogObjectKey build(CatalogObjectKind terminalKind) {
            CatalogNameGrammar.validateResolvedIdentity(roles, kinds, terminalKind, hierarchy);
            if (databaseLink != null && !databaseLinkInherited) {
                // Only a DIRECTLY declared link is checked against the shapes a remote reference is
                // known to take. An inherited one needs no re-check and must not be re-judged: a
                // column of a remote table is perfectly reachable as `t@remote.c`, and rejecting it
                // would mean a remote relation could have no remote columns.
                CatalogNameGrammar.requireLinkableTerminal(terminalKind);
            }
            List<Component> components = new ArrayList<Component>(roles.size());
            for (int i = 0; i < roles.size(); i++) {
                components.add(new Component(roles.get(i), kinds.get(i), keys.get(i)));
            }
            requireCompatibleRuleDomains(keys, databaseLink);
            return new CatalogObjectKey(components, terminalKind, hierarchy, databaseLink);
        }
    }

    /**
     * Every component of one identity must be composable with the others.
     *
     * <p>This is what stops an Oracle parent from being composed with a MySQL-canonicalized column:
     * such a key can never equal the correctly built one, and the lookup misses silently. Getting
     * the strictness right took two corrections, both of which were false NEGATIVES of their own:
     *
     * <ul>
     *   <li>comparing the producing SERVICES split two genuinely equal identities apart, because two
     *       services for one profile that differ only in carrying a {@code CollatorProvider} produce
     *       identical fold-based keys;</li>
     *   <li>requiring every component to use the same fold-versus-collation MECHANISM split a valid
     *       identity apart at its column, because one profile may fold its name group and collate
     *       its column group.</li>
     * </ul>
     *
     * So the rule is: one rule policy everywhere, and one collation domain among the components that
     * collate at all.
     */
    private static void requireCompatibleRuleDomains(List<CanonKey> keys, CanonKey databaseLink) {
        List<CanonKey> all = new ArrayList<CanonKey>(keys);
        if (databaseLink != null) {
            all.add(databaseLink);
        }
        CanonKey first = all.get(0);
        String collatorDomain = first.getCollatorDomainId();
        for (int i = 1; i < all.size(); i++) {
            CanonKey key = all.get(i);
            // The POLICY must match everywhere, and policy equality is transitive, so comparing
            // against the first component is sufficient for this half.
            if (!first.sameRulePolicyAs(key)) {
                throw new IllegalArgumentException("component " + i + " was canonicalized under "
                        + key.describeRuleDomain() + " but component 0 under "
                        + first.describeRuleDomain()
                        + ": a key mixing rule policies could never equal the correctly built one, "
                        + "and the lookup would miss silently");
            }
            // The COLLATOR half is not transitive: a fold-based key is compatible with collator A
            // and with collator B while A and B are incompatible, so a loop against component 0
            // would accept [fold, A, B]. Accumulate the first collation domain seen and require
            // every other collating component to agree with it.
            String keyDomain = key.getCollatorDomainId();
            if (keyDomain == null) {
                continue;
            }
            if (collatorDomain == null) {
                collatorDomain = keyDomain;
            } else if (!collatorDomain.equals(keyDomain)) {
                throw new IllegalArgumentException("component " + i + " collates under " + keyDomain
                        + " but another component collates under " + collatorDomain
                        + ": two collators produce incomparable payloads");
            }
        }
    }

    // ------------------------------------------------- parent-plus-local factories

    /**
     * A catalog, optionally under a server. Parts are passed SEPARATELY — a caller holding them
     * apart must not join them, because joining and re-splitting is how boundary information is
     * lost.
     *
     * <p>A catalog needs nothing above it: a name without a server means the local server, which is
     * an absence rather than a missing level.
     */
    public static CatalogObjectKey catalog(IdentifierService service, CatalogHierarchy hierarchy,
                                          String server, String catalog, IdentifierInputForm form) {
        Builder builder = builder(service, hierarchy);
        if (server != null && !server.isEmpty()) {
            builder.container(IdentifierComponentRole.SERVER, server, form);
        }
        return builder.container(IdentifierComponentRole.CATALOG, catalog, form)
                .build(CatalogObjectKind.CATALOG);
    }

    /**
     * A schema inside an already-identified catalog. The parent is REQUIRED on a topology that has a
     * catalog level: a schema identity that does not name its catalog is not resolved, and keying it
     * would collide with the same schema name in another catalog. Use
     * {@link #rootSchema} for a topology that genuinely has no catalog.
     */
    public static CatalogObjectKey schemaIn(IdentifierService service, CatalogObjectKey parentCatalog,
                                           String schema, IdentifierInputForm form) {
        requireNonNullParent(parentCatalog, "schema");
        requireKindOf(parentCatalog, CatalogObjectKind.CATALOG, "schema");
        Builder builder = builder(service, parentCatalog.hierarchy);
        replay(builder, parentCatalog);
        return builder.container(IdentifierComponentRole.SCHEMA, schema, form)
                .build(CatalogObjectKind.SCHEMA);
    }

    /**
     * A schema under a topology that has no catalog level. The topology must say so — that is what
     * proves the missing catalog is structural rather than unresolved.
     */
    public static CatalogObjectKey rootSchema(IdentifierService service, CatalogHierarchy hierarchy,
                                              String schema, IdentifierInputForm form) {
        requireNoCatalog(hierarchy, "schema");
        return builder(service, hierarchy)
                .container(IdentifierComponentRole.SCHEMA, schema, form)
                .build(CatalogObjectKind.SCHEMA);
    }

    /** An object inside an already-identified schema. */
    public static CatalogObjectKey objectInSchema(IdentifierService service, CatalogObjectKey parentSchema,
                                                 CatalogObjectKind kind, String localName,
                                                 IdentifierInputForm form) {
        requireNonNullParent(parentSchema, "object");
        requireKindOf(parentSchema, CatalogObjectKind.SCHEMA, "object");
        Builder builder = builder(service, parentSchema.hierarchy);
        replay(builder, parentSchema);
        return builder.object(kind, localName, form).build(kind);
    }

    /**
     * An object directly inside a catalog, for a schemaless topology such as MySQL's. The topology
     * must declare that it has no schema level; otherwise the missing schema is an omission and this
     * is a lookup, not an identity.
     */
    public static CatalogObjectKey objectInCatalogOnly(IdentifierService service,
                                                      CatalogObjectKey parentCatalog,
                                                      CatalogObjectKind kind, String localName,
                                                      IdentifierInputForm form) {
        requireNonNullParent(parentCatalog, "object");
        requireKindOf(parentCatalog, CatalogObjectKind.CATALOG, "object");
        requireNoSchema(parentCatalog.hierarchy, "object");
        Builder builder = builder(service, parentCatalog.hierarchy);
        replay(builder, parentCatalog);
        return builder.object(kind, localName, form).build(kind);
    }

    /**
     * An object at the root of a topology with no container levels at all. Rare and deliberately
     * awkward to reach: on any dialect that HAS containers, a bare object name is a lookup.
     */
    public static CatalogObjectKey rootObject(IdentifierService service, CatalogHierarchy hierarchy,
                                              CatalogObjectKind kind, String localName,
                                              IdentifierInputForm form) {
        if (hierarchy != CatalogHierarchy.ROOT_ONLY) {
            throw new IllegalArgumentException("topology " + hierarchy + " has container levels, so "
                    + "a bare object name is not a resolved identity — build a CatalogLookupName");
        }
        return builder(service, hierarchy).object(kind, localName, form).build(kind);
    }

    /** A column of an already-identified relation. */
    public static CatalogObjectKey column(IdentifierService service, CatalogObjectKey parentRelation,
                                         String localName, IdentifierInputForm form) {
        requireNonNullParent(parentRelation, "column");
        if (!CatalogNameGrammar.isRelation(parentRelation.terminalKind)) {
            throw new IllegalArgumentException("a " + parentRelation.terminalKind
                    + " has no columns; only a table, view or materialized view does");
        }
        Builder builder = builder(service, parentRelation.hierarchy);
        replay(builder, parentRelation);
        return builder.baseColumn(localName, form).build(CatalogObjectKind.COLUMN);
    }

    /** An index, constraint or package member of an already-identified parent object. */
    public static CatalogObjectKey childObject(IdentifierService service, CatalogObjectKey parent,
                                              CatalogObjectKind childKind, String localName,
                                              IdentifierInputForm form) {
        requireNonNullParent(parent, "child object");
        Builder builder = builder(service, parent.hierarchy);
        replay(builder, parent);
        return builder.object(childKind, localName, form).build(childKind);
    }

    /**
     * The same identity, reached through a database link. This is the only PUBLIC way to attach one,
     * because the general builder is package-private — without it a caller could inherit a link but
     * never declare one.
     *
     * <p>The local key must already be complete, and its terminal must be a shape a remote reference
     * is known to take. Descendants composed onto the result inherit the link, which is correct: a
     * column of a remote table is reachable as {@code t@remote.c}.
     */
    public static CatalogObjectKey atDatabaseLink(IdentifierService service,
                                                  CatalogObjectKey completeLocalKey,
                                                  String link, IdentifierInputForm form) {
        requireNonNullParent(completeLocalKey, "remote reference");
        if (completeLocalKey.databaseLink != null) {
            throw new IllegalArgumentException("this identity already carries a database link");
        }
        CatalogNameGrammar.requireLinkableTerminal(completeLocalKey.terminalKind);
        Builder builder = builder(service, completeLocalKey.hierarchy);
        replay(builder, completeLocalKey);
        builder.databaseLinkInherited = false;
        return builder.databaseLink(link, form).build(completeLocalKey.terminalKind);
    }

    private static void requireNonNullParent(CatalogObjectKey parent, String what) {
        if (parent == null) {
            throw new IllegalArgumentException("a " + what + " needs its parent's identity: it is "
                    + "scoped by the parent and has no meaning without it");
        }
    }

    private static void requireKindOf(CatalogObjectKey parent, CatalogObjectKind expected,
                                      String what) {
        if (parent.terminalKind != expected) {
            throw new IllegalArgumentException("a " + what + "'s parent is a " + expected
                    + ", not a " + parent.terminalKind);
        }
    }

    private static void requireNoCatalog(CatalogHierarchy hierarchy, String what) {
        if (hierarchy == null || hierarchy.hasCatalog()) {
            throw new IllegalArgumentException("topology " + hierarchy + " has a catalog level, so a "
                    + what + " that does not name it is not resolved");
        }
    }

    private static void requireNoSchema(CatalogHierarchy hierarchy, String what) {
        if (hierarchy.hasSchema()) {
            throw new IllegalArgumentException("topology " + hierarchy + " has a schema level, so an "
                    + what + " directly in a catalog is not resolved — name the schema, or declare a "
                    + "schemaless topology");
        }
    }

    /**
     * Re-seeds a builder with an existing key's components. The components are already canonical, so
     * nothing is re-parsed or re-folded — which is the point of composing from a parent identity
     * rather than re-deriving one from a joined string. An inherited database link is carried along
     * and may not then be changed: a child of a remote object is part of the same remote identity.
     */
    private static void replay(Builder builder, CatalogObjectKey parent) {
        if (parent.databaseLink != null) {
            builder.databaseLink = parent.databaseLink;
            builder.databaseLinkInherited = true;
        }
        for (Component component : parent.components) {
            builder.add(component.role, component.kind, component.key);
        }
    }

    // ------------------------------------------------------------------ accessors

    /** The components, outermost first. Never empty. */
    public List<Component> getComponents() {
        return components;
    }

    /** What the name as a whole denotes. */
    public CatalogObjectKind getTerminalKind() {
        return terminalKind;
    }

    /** The namespace topology this identity was declared complete against. */
    public CatalogHierarchy getHierarchy() {
        return hierarchy;
    }

    /**
     * A description of the rule domain this identity's components were canonicalized under, for
     * diagnostics. It is NOT part of equality: equality is component-wise {@link CanonKey} equality,
     * and two keys whose components are equal are the same identity regardless of which service
     * object produced them.
     */
    public String describeRuleDomain() {
        return components.get(0).getKey().describeRuleDomain();
    }

    /** The database link qualifying this name, or null. */
    public CanonKey getDatabaseLink() {
        return databaseLink;
    }

    public int size() {
        return components.size();
    }

    /** The innermost component — the object or column this key names. */
    public Component getLeaf() {
        return components.get(components.size() - 1);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        CatalogObjectKey that = (CatalogObjectKey) o;
        if (terminalKind != that.terminalKind || hierarchy != that.hierarchy
                || !components.equals(that.components)) {
            return false;
        }
        return databaseLink == null ? that.databaseLink == null
                : databaseLink.equals(that.databaseLink);
    }

    @Override
    public int hashCode() {
        return hash;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("CatalogObjectKey(").append(terminalKind).append(") ");
        for (int i = 0; i < components.size(); i++) {
            if (i > 0) {
                sb.append(" / ");
            }
            sb.append(components.get(i));
        }
        if (databaseLink != null) {
            sb.append(" @").append(databaseLink);
        }
        return sb.toString();
    }
}