package gudusoft.gsqlparser.catalog.runtime;

import gudusoft.gsqlparser.sqlenv.IdentifierComponentRole;
import gudusoft.gsqlparser.sqlenv.IdentifierInputForm;

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

/**
 * A <strong>request</strong> to find a catalog object — explicitly NOT an identity (stage S0R of
 * docs/refactor/identifier_identity_display_separation_plan.md).
 *
 * <h3>Why a lookup is a different type from a key</h3>
 * {@code t}, {@code s.t} and {@code db..t} are all normal things to write, and none of them is a
 * complete identity: the first two leave levels unstated, and the third states that a level was
 * written but left empty. Only after defaults and the search path supply the missing context does a
 * {@link CatalogObjectKey} exist. Collapsing the two ideas into one type is what let {@code db..t}
 * be keyed as {@code db.dbo.t}, which silently binds the wrong object whenever the session default
 * schema is not {@code dbo}.
 *
 * <h3>Three states, never two</h3>
 * <ul>
 *   <li>{@link SlotState#ABSENT} — the dialect or declared layout genuinely has no such level.
 *       MySQL has no schema level; there is nothing missing.</li>
 *   <li>{@link SlotState#OMITTED} — the level EXISTS and the caller did not name it. {@code db..t}
 *       omits its schema; a bare {@code t} omits both. A resolver must supply it before an identity
 *       can be built, and {@link CatalogObjectKey} refuses to contain one.</li>
 *   <li>{@link SlotState#PRESENT} — named, with its text and the provenance of that text.</li>
 * </ul>
 *
 * Conflating ABSENT with OMITTED loses the only signal that tells "this dialect has no schemas"
 * apart from "the user did not say which schema", and an empty string conflates both with a level
 * named by the empty name.
 */
public final class CatalogLookupName {

    /** Whether a hierarchy level is inapplicable, unstated, or named. */
    public enum SlotState {
        ABSENT,
        OMITTED,
        PRESENT
    }

    /** One level of the request. */
    public static final class Slot {
        private final IdentifierComponentRole role;
        private final SlotState state;
        private final String text;
        private final IdentifierInputForm form;
        private final CatalogObjectKind kind;

        Slot(IdentifierComponentRole role, SlotState state, String text, IdentifierInputForm form,
             CatalogObjectKind kind) {
            this.role = role;
            this.state = state;
            this.text = text;
            this.form = form;
            this.kind = kind;
        }

        public IdentifierComponentRole getRole() {
            return role;
        }

        public SlotState getState() {
            return state;
        }

        /** The text, only when {@link #getState()} is PRESENT. */
        public String getText() {
            return text;
        }

        /** Where the text came from, only when PRESENT. */
        public IdentifierInputForm getForm() {
            return form;
        }

        /** The entity kind for an OBJECT slot. */
        public CatalogObjectKind getKind() {
            return kind;
        }

        @Override
        public String toString() {
            if (state != SlotState.PRESENT) {
                return role + "=" + state;
            }
            return role + (kind == null ? "" : "(" + kind + ")") + "=" + text + "/" + form;
        }
    }

    private final List<Slot> slots;
    private final CatalogObjectKind terminalKind;
    private final CatalogHierarchy hierarchy;
    private final CatalogParentConstraint parentConstraint;
    private final String databaseLink;
    private final IdentifierInputForm databaseLinkForm;

    private CatalogLookupName(List<Slot> slots, CatalogObjectKind terminalKind,
                              CatalogHierarchy hierarchy, CatalogParentConstraint parentConstraint,
                              String databaseLink, IdentifierInputForm databaseLinkForm) {
        this.slots = Collections.unmodifiableList(new ArrayList<Slot>(slots));
        this.terminalKind = terminalKind;
        this.hierarchy = hierarchy;
        this.parentConstraint = parentConstraint;
        this.databaseLink = databaseLink;
        this.databaseLinkForm = databaseLinkForm;
    }

    /**
     * A request against a declared namespace topology. The topology is required: whether a missing
     * schema is an OMISSION or simply inapplicable is what it answers, and no component list can.
     */
    public static Builder builder(CatalogHierarchy hierarchy) {
        return new Builder(hierarchy);
    }

    /**
     * Parses a FLAT name under a layout the caller DECLARES, against a topology the caller DECLARES.
     * The parser verifies the component count against the layout and refuses otherwise; it never
     * chooses the layout, which is the whole point — choosing is the defect.
     *
     * <p>Where the layout has a container OBJECT whose exact kind a flat name cannot carry — a
     * column's parent may be a table, a view or a materialized view — the FAMILY is recorded
     * instead, derived from the layout itself. A lookup legitimately knows only the family; only a
     * resolved {@link CatalogObjectKey} carries the exact kind.
     *
     * <p>Prefer {@link #builder(CatalogHierarchy)} with the parts passed separately. This exists for
     * callers whose input genuinely is one string.
     *
     * @throws IllegalArgumentException if the component count does not match the declared layout
     */
    public static CatalogLookupName ofDeclaredLayout(List<String> components,
                                                     CatalogNameLayout layout,
                                                     IdentifierInputForm form,
                                                     CatalogObjectKind terminalKind,
                                                     CatalogHierarchy hierarchy) {
        if (components == null || layout == null) {
            throw new IllegalArgumentException("components and layout are both required");
        }
        if (components.size() != layout.size()) {
            throw new IllegalArgumentException("declared layout " + layout + " has " + layout.size()
                    + " components but the name has " + components.size()
                    + "; the caller must declare the layout its name actually has, and the parser "
                    + "will not pick one");
        }

        if (!layout.permitsTerminalKind(terminalKind)) {
            throw new IllegalArgumentException("layout " + layout + " does not describe a "
                    + terminalKind + "; a layout states a SHAPE, and using a child layout to seek a "
                    + "container object would describe that object as a child of another");
        }
        Builder builder = builder(hierarchy);
        // A level the topology HAS but the declared layout does not write is OMITTED. That is not a
        // guess: the layout states what was written and the topology states what exists, so the
        // difference between them is exactly "exists but unnamed".
        for (IdentifierComponentRole container : hierarchy.containers()) {
            if (!layout.roles().contains(container)) {
                builder.omitted(container);
            }
        }
        CatalogParentConstraint containerFamily = containerFamilyOf(layout, terminalKind);
        if (containerFamily != null) {
            builder.parentConstraint(containerFamily);
        }
        for (int i = 0; i < components.size(); i++) {
            IdentifierComponentRole role = layout.roleAt(i);
            String text = components.get(i);
            if (text == null || text.isEmpty()) {
                // An empty component in a declared layout is an OMISSION, not a name: `db..t`.
                builder.omitted(role);
                continue;
            }
            if (role == IdentifierComponentRole.OBJECT) {
                boolean terminal = i == components.size() - 1;
                if (terminal) {
                    builder.object(terminalKind, text, form);
                } else {
                    // The container's exact kind is not expressible here; the family above is.
                    builder.containerObject(text, form);
                }
            } else if (role == IdentifierComponentRole.BASE_COLUMN) {
                builder.baseColumn(text, form);
            } else {
                builder.present(role, text, form);
            }
        }
        return builder.build(terminalKind);
    }

    /**
     * The family a layout's container object belongs to, or null when the layout has no container
     * object. Derived from the LAYOUT, which is declared — not from the component count.
     */
    private static CatalogParentConstraint containerFamilyOf(CatalogNameLayout layout,
                                                             CatalogObjectKind terminalKind) {
        int objects = 0;
        boolean terminalIsColumn = false;
        for (int i = 0; i < layout.size(); i++) {
            if (layout.roleAt(i) == IdentifierComponentRole.OBJECT) {
                objects++;
            }
            if (i == layout.size() - 1
                    && layout.roleAt(i) == IdentifierComponentRole.BASE_COLUMN) {
                terminalIsColumn = true;
            }
        }
        if (terminalIsColumn && objects >= 1) {
            return CatalogParentConstraint.RELATION;
        }
        if (objects >= 2) {
            return layout == CatalogNameLayout.CATALOG_SCHEMA_PACKAGE_MEMBER
                    ? CatalogParentConstraint.ROUTINE_CONTAINER
                    : CatalogParentConstraint.RELATION;
        }
        return null;
    }

    /** @see #builder() */
    public static final class Builder {
        private final List<Slot> slots = new ArrayList<Slot>();
        private final CatalogHierarchy hierarchy;
        private CatalogParentConstraint parentConstraint;
        private boolean parentConstraintSupplied;
        private String databaseLink;
        private IdentifierInputForm databaseLinkForm;

        private Builder(CatalogHierarchy hierarchy) {
            if (hierarchy == null) {
                throw new IllegalArgumentException("a lookup must declare its namespace topology: "
                        + "that is what distinguishes an inapplicable level from an unnamed one");
            }
            this.hierarchy = hierarchy;
        }

        /**
         * What is known about the parent of the object being sought, when it is a child. A LOOKUP
         * carries a FAMILY, not an exact kind: parsing {@code schema.relation.column} establishes
         * that the parent is a relation, not whether it will resolve to a table or a view.
         */
        public Builder parentConstraint(CatalogParentConstraint constraint) {
            if (constraint == null) {
                throw new IllegalArgumentException("a parent constraint of null says nothing; omit "
                        + "the call instead");
            }
            // Tracked by WHETHER it was supplied, not by its value. Comparing values let a caller
            // classify twice with the same answer — which is still double classification, and a
            // null-then-value sequence slipped through entirely.
            if (parentConstraintSupplied) {
                throw new IllegalArgumentException("the parent constraint was already supplied as "
                        + this.parentConstraint + "; stating it twice hides which call the caller "
                        + "meant");
            }
            this.parentConstraint = constraint;
            this.parentConstraintSupplied = true;
            return this;
        }

        /**
         * Refuses a second slot for a role that names a single level. The normalization step below
         * reorders slots into hierarchy order, and an earlier version took the FIRST slot of each
         * role — so a caller that supplied two catalogs silently lost one of them before the
         * uniqueness validator ever saw it. Rejecting at the point of addition is the only place
         * where both values are still in hand.
         */
        private void refuseDuplicate(IdentifierComponentRole role) {
            if (role == IdentifierComponentRole.OBJECT) {
                return;   // a relation plus its child, or a package plus its routine
            }
            for (Slot slot : slots) {
                if (slot.role == role) {
                    throw new IllegalArgumentException("a second " + role + " slot: "
                            + "this role names a single level, and keeping one of two values would "
                            + "discard the other silently");
                }
            }
        }

        /** The level exists and is named. */
        public Builder present(IdentifierComponentRole role, String text, IdentifierInputForm form) {
            if (text == null || text.isEmpty()) {
                throw new IllegalArgumentException("a PRESENT " + role + " needs text; use "
                        + "omitted(role) when the level exists but was not named, or absent(role) "
                        + "when the dialect has no such level");
            }
            if (form == null) {
                throw new IllegalArgumentException("a PRESENT slot needs its provenance");
            }
            refuseDuplicate(role);
            slots.add(new Slot(role, SlotState.PRESENT, text, form, null));
            return this;
        }

        /** A named object level, with its entity kind. */
        public Builder object(CatalogObjectKind kind, String text, IdentifierInputForm form) {
            if (kind == null) {
                throw new IllegalArgumentException("an object slot needs its kind");
            }
            if (text == null || text.isEmpty()) {
                throw new IllegalArgumentException("a PRESENT object needs text");
            }
            slots.add(new Slot(IdentifierComponentRole.OBJECT, SlotState.PRESENT, text, form, kind));
            return this;
        }

        /**
         * A named container object whose exact kind is not yet known — only the family, which the
         * request carries through {@link #parentConstraint}. This is what a flat
         * {@code schema.relation.column} can honestly say about its middle component.
         */
        public Builder containerObject(String text, IdentifierInputForm form) {
            if (text == null || text.isEmpty()) {
                throw new IllegalArgumentException("a PRESENT object needs text");
            }
            if (form == null) {
                throw new IllegalArgumentException("a PRESENT slot needs its provenance");
            }
            slots.add(new Slot(IdentifierComponentRole.OBJECT, SlotState.PRESENT, text, form, null));
            return this;
        }

        /**
         * A named column level. It installs the RELATION parent constraint itself: a column is
         * always a child of a relation, which is semantic knowledge rather than a guess, so making
         * every caller restate it would be ceremony that some caller eventually forgets.
         */
        public Builder baseColumn(String text, IdentifierInputForm form) {
            present(IdentifierComponentRole.BASE_COLUMN, text, form);
            if (parentConstraint == null) {
                // Installed by the type itself, so it does NOT count as the caller having
                // classified: a caller may still state RELATION explicitly once.
                parentConstraint = CatalogParentConstraint.RELATION;
            }
            return this;
        }

        /** The level exists but the caller did not name it — a resolver must supply it. */
        public Builder omitted(IdentifierComponentRole role) {
            refuseDuplicate(role);
            slots.add(new Slot(role, SlotState.OMITTED, null, null, null));
            return this;
        }

        /** The dialect or layout has no such level at all. */
        public Builder absent(IdentifierComponentRole role) {
            refuseDuplicate(role);
            slots.add(new Slot(role, SlotState.ABSENT, null, null, null));
            return this;
        }

        public Builder databaseLink(String text, IdentifierInputForm form) {
            if (databaseLink != null) {
                throw new IllegalArgumentException("a name has one database link");
            }
            if (text == null || text.isEmpty()) {
                throw new IllegalArgumentException("a database link with no text is not a link");
            }
            if (form == null) {
                throw new IllegalArgumentException("a database link needs its provenance");
            }
            this.databaseLink = text;
            this.databaseLinkForm = form;
            return this;
        }

        public CatalogLookupName build(CatalogObjectKind terminalKind) {
            if (terminalKind == null) {
                throw new IllegalArgumentException("a lookup must say what kind it is looking for");
            }
            // Levels the topology does not have are marked ABSENT automatically. That is not a
            // guess: the topology DECLARED them inapplicable, and leaving them unrepresented is
            // what made a bare `t` report itself fully qualified.
            // Only levels at or ABOVE the requested terminal belong in the vector. A CATALOG lookup
            // that also carried a schema slot was claiming to name a schema while saying it sought a
            // catalog — two different requests wearing one shape.
            List<Slot> complete = new ArrayList<Slot>();
            for (IdentifierComponentRole container
                    : new IdentifierComponentRole[]{IdentifierComponentRole.SERVER,
                    IdentifierComponentRole.CATALOG, IdentifierComponentRole.SCHEMA}) {
                if (!CatalogNameGrammar.levelAppliesTo(container, terminalKind)) {
                    Slot stray = find(container);
                    if (stray != null) {
                        throw new IllegalArgumentException("a " + terminalKind + " lookup names a "
                                + container + ", which sits below what it seeks");
                    }
                    continue;
                }
                Slot existing = find(container);
                if (existing != null) {
                    complete.add(existing);
                } else if (container != IdentifierComponentRole.SERVER && !hierarchy.has(container)) {
                    complete.add(new Slot(container, SlotState.ABSENT, null, null, null));
                }
            }
            for (Slot slot : slots) {
                if (slot.role != IdentifierComponentRole.SERVER
                        && slot.role != IdentifierComponentRole.CATALOG
                        && slot.role != IdentifierComponentRole.SCHEMA) {
                    complete.add(slot);
                }
            }
            CatalogNameGrammar.validateLookup(complete, terminalKind, hierarchy, databaseLink,
                    databaseLinkForm, parentConstraint);
            return new CatalogLookupName(complete, terminalKind, hierarchy, parentConstraint,
                    databaseLink, databaseLinkForm);
        }

        private Slot find(IdentifierComponentRole role) {
            for (Slot slot : slots) {
                if (slot.role == role) {
                    return slot;
                }
            }
            return null;
        }
    }

    /** The slots, outermost first. */
    public List<Slot> getSlots() {
        return slots;
    }

    public CatalogObjectKind getTerminalKind() {
        return terminalKind;
    }

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

    /** What is known about the parent's kind, or null when the request names no child. */
    public CatalogParentConstraint getParentConstraint() {
        return parentConstraint;
    }

    public String getDatabaseLink() {
        return databaseLink;
    }

    public IdentifierInputForm getDatabaseLinkForm() {
        return databaseLinkForm;
    }

    /**
     * Whether every level this request needs is named, so an identity could be built without
     * consulting any default. An omission here is not an error — it is the normal reason a resolver
     * is involved.
     */
    public boolean isFullyQualified() {
        for (Slot slot : slots) {
            if (slot.state == SlotState.OMITTED) {
                return false;
            }
        }
        return true;
    }

    /**
     * The slot for a role, or null when this request has no such level.
     *
     * @throws IllegalArgumentException for {@link IdentifierComponentRole#OBJECT}, which may appear
     *         twice — a relation and its index. Returning the first silently would hand a caller
     *         asking for "the object" the container when it wanted the child. Use
     *         {@link #getTerminalSlot()}, {@link #getParentObjectSlot()} or {@link #getObjectSlots()}.
     */
    public Slot slotOf(IdentifierComponentRole role) {
        if (role == IdentifierComponentRole.OBJECT) {
            throw new IllegalArgumentException("OBJECT may appear twice, so asking for 'the' object "
                    + "slot is ambiguous; use getTerminalSlot(), getParentObjectSlot() or "
                    + "getObjectSlots()");
        }
        for (Slot slot : slots) {
            if (slot.role == role) {
                return slot;
            }
        }
        return null;
    }

    /** The innermost slot — what this request is actually looking for. */
    public Slot getTerminalSlot() {
        return slots.get(slots.size() - 1);
    }

    /** The object slot that contains the terminal, or null when the terminal has no object parent. */
    public Slot getParentObjectSlot() {
        Slot parent = null;
        for (int i = 0; i < slots.size() - 1; i++) {
            if (slots.get(i).role == IdentifierComponentRole.OBJECT) {
                parent = slots.get(i);
            }
        }
        return parent;
    }

    /** Every object slot, outermost first. */
    public List<Slot> getObjectSlots() {
        List<Slot> objects = new ArrayList<Slot>(2);
        for (Slot slot : slots) {
            if (slot.role == IdentifierComponentRole.OBJECT) {
                objects.add(slot);
            }
        }
        return Collections.unmodifiableList(objects);
    }

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