package gudusoft.gsqlparser.sqlenv;

import gudusoft.gsqlparser.EDbVendor;

import java.util.Arrays;
import java.util.Objects;

/**
 * Canonical identity of a single SQL identifier segment under one vendor's identifier
 * rules (unification plan stage P0c, docs/refactor/identifier_normalization_unification_plan.md).
 *
 * <p>Two keys compare equal iff they were produced in the same rule domain — vendor,
 * object group, the whole effective policy (per-group AND per-category rules plus vendor
 * flags, including the default collation), the effective rule cell of the category and
 * collator identity — AND their canonical payloads match. The payload is
 * the {@link IdentifierService#keyForMap} text for fold-based rules, or the
 * {@link java.text.CollationKey} bytes (from the same collator the equality path uses)
 * for collation-based rules. The comparison <em>rule</em> that selected the payload is
 * deliberately NOT part of equality: under quoted-case-preserving vendors, unquoted
 * {@code foo} (folded to {@code FOO}) and quoted {@code "FOO"} (preserved as {@code FOO})
 * must converge on the same key even though different rules produced them.
 *
 * <p><strong>In-process only.</strong> Collation key bytes are only stable within one
 * JVM/collator configuration; never persist or exchange CanonKeys. Custom
 * {@link CollatorProvider} subclasses are isolated by class name — two instances of the
 * same class with different behavior cannot be distinguished.
 */
public final class CanonKey {

    private final EDbVendor vendor;
    private final IdentifierProfile.ObjectGroup group;
    private final IdentifierProfile policy;
    private final IdentifierRules ruleDomain;
    private final String collatorId;      // null for fold-based keys
    private final String canonText;       // fold payload; diagnostic-only for collation keys
    private final byte[] collationKey;    // null for fold-based keys

    CanonKey(EDbVendor vendor, IdentifierProfile.ObjectGroup group, IdentifierProfile policy,
             IdentifierRules ruleDomain, String collatorId, String canonText, byte[] collationKey) {
        this.vendor = vendor;
        this.group = group;
        this.policy = policy;
        this.ruleDomain = ruleDomain;
        this.collatorId = collatorId;
        this.canonText = canonText;
        this.collationKey = collationKey;
    }

    public EDbVendor getVendor() {
        return vendor;
    }

    public IdentifierProfile.ObjectGroup getGroup() {
        return group;
    }

    /** Canonical text payload. For collation-based keys this is diagnostic only. */
    public String getCanonText() {
        return canonText;
    }

    public boolean isCollationBased() {
        return collationKey != null;
    }

    /**
     * Whether two canonical keys were produced under the same RULE POLICY — vendor and policy
     * fingerprint (stage S0R).
     *
     * <p>This deliberately says nothing about the collator. Two components of ONE qualified identity
     * legitimately use different object groups, and a profile may fold one group while collating
     * another, so requiring the same mechanism split a valid catalog/schema/table/column identity
     * apart at the column. Policy equality is the part that is always required and is transitive.
     */
    public boolean sameRulePolicyAs(CanonKey other) {
        // Full effective-strategy equality, not the fingerprint: the fingerprint is a 32-bit hash
        // and two different per-category strategies can collide in it. It stays the fast path
        // inside IdentifierProfile.equals.
        return other != null && vendor == other.vendor
                && policy.hasSameEffectivePolicyAs(other.policy);
    }

    /**
     * The effective rule cell this key's payload was produced under — the key's
     * <em>rule domain</em> within the profile ({@link IdentifierProfile#ruleDomainOf}).
     *
     * <p>Part of equality since per-category configuration exists: two categories of one
     * {@link IdentifierProfile.ObjectGroup} may now compare differently, so the group alone no
     * longer says which relation produced the payload. Under a profile that does not split a
     * group, every category of that group shares this cell and the keys stay interchangeable
     * exactly as before.
     *
     * @return the resolved rule cell; never null
     */
    public IdentifierRules getRuleDomain() {
        return ruleDomain;
    }

    /**
     * The collation domain this key's payload belongs to, or null when the key FOLDS rather than
     * collates.
     *
     * <p>A composite identity may mix fold-based and collation-based components, but every
     * collation-based component must belong to the SAME collation domain: two different collators
     * produce incomparable payloads.
     */
    public String getCollatorDomainId() {
        return collatorId;
    }

    /**
     * Whether these two keys may sit in one composite identity: the same rule policy, and — when
     * both collate — the same collator.
     *
     * <p><strong>This relation is NOT transitive.</strong> A fold-based key is compatible with a key
     * collated by A and also with one collated by B, while A and B are not compatible with each
     * other. So a composite identity must NOT be validated by comparing every component against the
     * first one; that loop would accept {@code [fold, A, B]}. Accumulate the first non-null
     * {@link #getCollatorDomainId()} across all components and compare every other against it.
     */
    public boolean isRuleCompatibleWith(CanonKey other) {
        if (!sameRulePolicyAs(other)) {
            return false;
        }
        if (collatorId == null || other.collatorId == null) {
            return true;
        }
        return collatorId.equals(other.collatorId);
    }

    /** A short description of this key's rule domain, for diagnostics only. */
    public String describeRuleDomain() {
        return vendor + "/policy:" + policy.getFingerprint() + "/cell:" + ruleDomain
                + (isCollationBased() ? "/collator:" + collatorId : "/fold");
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        CanonKey that = (CanonKey) o;
        if (vendor != that.vendor || group != that.group
                || !ruleDomain.equals(that.ruleDomain)
                || !Objects.equals(collatorId, that.collatorId)
                || !policy.hasSameEffectivePolicyAs(that.policy)) {
            return false;
        }
        if (collationKey != null || that.collationKey != null) {
            return Arrays.equals(collationKey, that.collationKey);
        }
        return Objects.equals(canonText, that.canonText);
    }

    @Override
    public int hashCode() {
        int result = Objects.hash(vendor, group, policy.getFingerprint(), ruleDomain, collatorId);
        result = 31 * result + (collationKey != null ? Arrays.hashCode(collationKey) : Objects.hashCode(canonText));
        return result;
    }

    @Override
    public String toString() {
        return "CanonKey{" + vendor + "/" + group
                + (collationKey != null ? "/collation[" + canonText + "]" : "/" + canonText) + "}";
    }
}