package gudusoft.gsqlparser.sqlenv;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.util.SQLUtil;

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

/**
 * Assigns a per-segment {@link ESQLDataObjectType} to the segments of a qualified SQL name
 * (stage S0 of docs/refactor/identifier_identity_display_separation_plan.md).
 *
 * <p>A qualified name does not have one object type — {@code db.s.t.c} is a catalog, a
 * schema, a table and a column, and each segment is compared under the rules of its own
 * kind. Which position means what depends on the vendor's hierarchy depth, the kind of
 * object the name as a whole denotes, and how many segments were written. This class is
 * the single place that decision is expressed.
 *
 * <p><strong>It is deliberately a pure function of (vendor, objectType, segments).</strong>
 * It reads no session state, no {@code ThreadLocal} and no catalog, so the same name always
 * plans the same way.
 *
 * <p><strong>Relation to {@link SQLUtil#compareIdentifier}.</strong> That method carries the
 * same assignment inline, as nested conditionals around pairwise comparisons. This class
 * exists so an identity <em>key</em> can be built from the assignment
 * ({@link QualifiedCanonKey}). It is NOT a copy: it keeps segment boundaries that method
 * joins away, and it parses vendor-aware where that method does not, so the two diverge on
 * an enumerated set of shapes where this class is correct and that method is not.
 * {@code QualifiedCanonKeyEquivalenceProofTest} walks every vendor, every mapped object type
 * and every ordered pair of shapes, and every divergence is pinned there with its exact
 * expected values. Stage S2 must make {@code compareIdentifier} delegate here, at which point
 * those divergences become fixes; S0 changes no production call site.
 *
 * <h3>Surplus segments keep their boundaries</h3>
 * When a name carries more segments than the hierarchy has levels, the surplus segments stay
 * SEPARATE levels, each typed as the innermost kind: {@code db.s.t.c.sub.sub2} plans as
 * catalog {@code db}, schema {@code s}, table {@code t}, then three column-typed levels
 * {@code c}, {@code sub}, {@code sub2}.
 *
 * <p>This deliberately differs from {@link SQLUtil#compareIdentifier}, which joins the
 * surplus back into one dotted string and compares it as a single name. That join loses the
 * distinction between a path and a name that contains a dot, and an identity key built on it
 * merges two different objects:
 *
 * <pre>
 * Oracle, dotColumn:   c.d.s.a.f   vs   c.d.s."A.F"
 *   5 segments [c,d,s,a,f]         vs   4 segments [c,d,s,"A.F"]
 *   joined leaf text: A.F          vs   A.F          &lt;- collide
 * </pre>
 *
 * The second name is one column whose own text contains a dot — legal on Oracle
 * ({@code CREATE TABLE t ("A.F" NUMBER)}) — and it is not the field {@code f} of column
 * {@code a}. Case folding changes letters, never where the boundaries are, so the two can
 * only be told apart by keeping the segmentation. {@code compareIdentifier} happens to
 * answer {@code false} for this pair, but only because it compares raw segment counts first
 * and never reaches its own join; the join does decide pairs of equal arity, and there this
 * class and that method diverge. Every such divergence is enumerated with exact expected
 * values in {@code QualifiedCanonKeyEquivalenceProofTest}.
 */
public final class QualifiedNameHierarchy {

    private QualifiedNameHierarchy() {
    }

    /** One planned segment: its text exactly as written, plus the kind it is compared as. */
    public static final class Segment {
        private final String text;
        private final ESQLDataObjectType type;

        Segment(String text, ESQLDataObjectType type) {
            this.text = text;
            this.type = type;
        }

        /** Segment text as written, delimiters and case intact. Never normalized here. */
        public String getText() {
            return text;
        }

        public ESQLDataObjectType getType() {
            return type;
        }

        @Override
        public String toString() {
            return type + ":" + text;
        }
    }

    /**
     * Splits {@code qualifiedName} into segments the way the identity path must see it.
     *
     * <p>Vendor-aware: BigQuery's {@code `project.dataset.table`} becomes three segments.
     * {@link SQLUtil#compareIdentifier} calls the vendor-blind overload and therefore sees
     * that shape as ONE segment — a defect of that method, recorded as a pinned divergence
     * in the S0 proof test and due for repair in S2. Do not "fix" the divergence by making
     * this method vendor-blind.
     */
    public static List<String> split(EDbVendor vendor, String qualifiedName) {
        return SQLUtil.parseNames(qualifiedName, vendor);
    }

    /**
     * Plans the segment types for a qualified name.
     *
     * @param vendor     the dialect whose hierarchy depth applies
     * @param objectType what the name as a whole denotes
     * @param segments   the already-split segments, in written order
     * @return exactly one {@link Segment} per input segment — hierarchy types while they
     *         last, then the innermost type for each surplus segment, with no text joined;
     *         {@code null} when this (vendor, objectType) pair has no hierarchy mapping —
     *         see {@link #hasHierarchyMapping}
     */
    public static List<Segment> plan(EDbVendor vendor, ESQLDataObjectType objectType, List<String> segments) {
        if (segments == null || segments.isEmpty() || objectType == null) {
            return null;
        }

        boolean supportCatalog = TSQLEnv.supportCatalog(vendor);
        boolean supportSchema = TSQLEnv.supportSchema(vendor);

        // TSQLEnv.supportCatalog() returns true unconditionally today, so compareIdentifier's
        // schema-only and neither-level branches are unreachable. Rather than mirror dead
        // code that cannot be tested, refuse here; the proof test asserts supportCatalog()
        // holds for every vendor, so a future change to it fails loudly instead of silently
        // planning names under a hierarchy this class never modelled.
        if (!supportCatalog) {
            return null;
        }

        List<Segment> plan = supportSchema
                ? planCatalogSchema(objectType, segments)
                : planCatalogOnly(objectType, segments);
        return plan == null ? null : Collections.unmodifiableList(plan);
    }

    /** Vendors with both a catalog and a schema level — every dialect except the four below. */
    private static List<Segment> planCatalogSchema(ESQLDataObjectType objectType, List<String> segments) {
        int n = segments.size();
        if (objectType == ESQLDataObjectType.dotColumn) {
            if (n >= 4) {
                return levels(segments,
                        ESQLDataObjectType.dotCatalog, ESQLDataObjectType.dotSchema,
                        ESQLDataObjectType.dotTable, ESQLDataObjectType.dotColumn);
            } else if (n == 3) {
                return levels(segments,
                        ESQLDataObjectType.dotSchema, ESQLDataObjectType.dotTable,
                        ESQLDataObjectType.dotColumn);
            } else if (n == 2) {
                return levels(segments, ESQLDataObjectType.dotTable, ESQLDataObjectType.dotColumn);
            }
            return levels(segments, ESQLDataObjectType.dotColumn);
        }
        if (isTableLevel(objectType)) {
            if (n >= 3) {
                return levels(segments,
                        ESQLDataObjectType.dotCatalog, ESQLDataObjectType.dotSchema, objectType);
            } else if (n == 2) {
                return levels(segments, ESQLDataObjectType.dotSchema, objectType);
            }
            return levels(segments, objectType);
        }
        if (objectType == ESQLDataObjectType.dotSchema) {
            if (n >= 2) {
                return levels(segments, ESQLDataObjectType.dotCatalog, ESQLDataObjectType.dotSchema);
            }
            return levels(segments, ESQLDataObjectType.dotSchema);
        }
        if (objectType == ESQLDataObjectType.dotCatalog) {
            return levels(segments, ESQLDataObjectType.dotCatalog);
        }
        return null;
    }

    /** MySQL, Teradata, Hive and Impala: one container level, named as a catalog. */
    private static List<Segment> planCatalogOnly(ESQLDataObjectType objectType, List<String> segments) {
        int n = segments.size();
        if (objectType == ESQLDataObjectType.dotColumn) {
            if (n >= 3) {
                return levels(segments,
                        ESQLDataObjectType.dotCatalog, ESQLDataObjectType.dotTable,
                        ESQLDataObjectType.dotColumn);
            } else if (n == 2) {
                return levels(segments, ESQLDataObjectType.dotTable, ESQLDataObjectType.dotColumn);
            }
            return levels(segments, ESQLDataObjectType.dotColumn);
        }
        if (isTableLevel(objectType)) {
            if (n >= 2) {
                return levels(segments, ESQLDataObjectType.dotCatalog, objectType);
            }
            return levels(segments, objectType);
        }
        // A schema-less dialect compares a schema name in its catalog bucket; that is what
        // compareIdentifier does, and the flags table has no separate schema rules there.
        if (objectType == ESQLDataObjectType.dotCatalog || objectType == ESQLDataObjectType.dotSchema) {
            return levels(segments, ESQLDataObjectType.dotCatalog);
        }
        return null;
    }

    /**
     * Object types that sit at the table level of the hierarchy — they are schema-qualified
     * and share the table's position. Kept as one predicate so the two branches above cannot
     * drift apart.
     */
    private static boolean isTableLevel(ESQLDataObjectType objectType) {
        return objectType == ESQLDataObjectType.dotTable
                || objectType == ESQLDataObjectType.dotSynonyms
                || objectType == ESQLDataObjectType.dotOraclePackage
                || objectType == ESQLDataObjectType.dotFunction
                || objectType == ESQLDataObjectType.dotProcedure
                || objectType == ESQLDataObjectType.dotTrigger;
    }

    /**
     * One planned level per segment: {@code types[i]} for as long as it lasts, then the
     * innermost type for every surplus segment. Segment text is never joined, so the plan
     * always has exactly {@code segments.size()} entries and the name's arity survives into
     * the key.
     */
    private static List<Segment> levels(List<String> segments, ESQLDataObjectType... types) {
        List<Segment> plan = new ArrayList<Segment>(segments.size());
        for (int i = 0; i < segments.size(); i++) {
            plan.add(new Segment(segments.get(i), types[Math.min(i, types.length - 1)]));
        }
        return plan;
    }

    /**
     * Whether this (vendor, objectType) pair has a hierarchy mapping at all.
     *
     * <p>{@code dotUnknown}, {@code dotRoutine}, {@code dotDblink}, {@code dotDataType} and
     * {@code dotParameter} have none. Note what {@link SQLUtil#compareIdentifier} does for
     * those: it falls through every branch and returns {@code false} — so it reports two
     * <em>identical</em> qualified names as different. An identity key cannot model a
     * non-reflexive relation, so {@link QualifiedCanonKey} refuses to build one instead of
     * reproducing that. The refusal is the honest answer; the {@code false} is a defect of
     * {@code compareIdentifier}, tracked for S2.
     */
    public static boolean hasHierarchyMapping(EDbVendor vendor, ESQLDataObjectType objectType) {
        return plan(vendor, objectType, Collections.singletonList("x")) != null;
    }
}