package gudusoft.gsqlparser.catalog.input.model;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;
import gudusoft.gsqlparser.sqlenv.IdentifierInputForm;
import gudusoft.gsqlparser.sqlenv.TSQLEnv;

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

/**
 * Top-level immutable catalog model produced by {@code CatalogInputReader}s and consumed by
 * the runtime + bridge layers.
 *
 * <p>Plan §6 (artifact layout) / §7.1 (schema). Format-agnostic: JSON / YAML / DDL / dbt
 * manifests / vendor dumps all funnel into this shape.</p>
 *
 * <p>The build-time checks here cover only structural invariants. Deeper consistency
 * (duplicate qualified names, identifier round-trip, table↔column referential integrity)
 * is enforced by {@code CatalogModelValidator} per plan §9.6 — see Round 3 (T1B.2).</p>
 */
public final class UnifiedCatalogModel {

    /** Default {@code apiVersion} carried by manifests that don't set one. Plan Q9. */
    public static final String DEFAULT_API_VERSION = "1";

    private final String apiVersion;
    private final EDbVendor vendor;
    private final IdentifierConfig identifierConfig;
    private final DefaultsConfig defaults;
    private final List<CatalogModel> catalogs;
    private final CatalogSourceInfo sourceInfo;
    private final IdentifierInputForm nameForm;
    private final boolean nameFormDeclared;

    private UnifiedCatalogModel(Builder b) {
        if (b.vendor == null) {
            throw new IllegalArgumentException("UnifiedCatalogModel.vendor is required");
        }
        this.vendor = b.vendor;
        this.apiVersion = (b.apiVersion == null || b.apiVersion.isEmpty())
            ? DEFAULT_API_VERSION
            : b.apiVersion;
        this.identifierConfig = (b.identifierConfig == null)
            ? IdentifierConfig.defaultsFor(b.vendor)
            : b.identifierConfig;
        this.defaults = (b.defaults == null) ? DefaultsConfig.empty() : b.defaults;
        this.catalogs = Collections.unmodifiableList(new ArrayList<CatalogModel>(b.catalogs));
        this.sourceInfo = b.sourceInfo;
        this.nameForm = (b.nameForm == null) ? IdentifierInputForm.SQL_LEXICAL : b.nameForm;
        this.nameFormDeclared = b.nameFormDeclared && b.nameForm != null;
    }

    public static Builder builder() {
        return new Builder();
    }

    public String apiVersion() {
        return apiVersion;
    }

    public EDbVendor vendor() {
        return vendor;
    }

    public IdentifierConfig identifierConfig() {
        return identifierConfig;
    }

    public DefaultsConfig defaults() {
        return defaults;
    }

    public List<CatalogModel> catalogs() {
        return catalogs;
    }

    /** Provenance of this model. May be {@code null} for in-memory / programmatic builds. */
    public CatalogSourceInfo sourceInfo() {
        return sourceInfo;
    }

    /**
     * How every object name in this model is written: as SQL text
     * ({@link IdentifierInputForm#SQL_LEXICAL}, {@code "Amount"} / {@code [Order ID]}, an
     * undelimited name folds the way the vendor folds it) or as the name the database
     * catalog holds ({@link IdentifierInputForm#CATALOG_STORED}, {@code Amount} IS the
     * stored name). One form per model: a single input must not mix the two.
     *
     * <p>A model built in code defaults to {@code SQL_LEXICAL}, which is how names were
     * always treated. {@code JsonManifestCatalogInputReader} defaults a manifest file to
     * {@code CATALOG_STORED}; a file overrides either default with a root {@code nameForm}.
     * See docs/refactor/identifier/README.md, "Catalog inputs and name output".</p>
     */
    public IdentifierInputForm nameForm() {
        return nameForm;
    }

    /**
     * Whether the input stated its {@link #nameForm()} itself, as opposed to receiving the
     * format's default. The validator uses it: a name that the two forms read differently is
     * worth a warning only while nobody has said which form was meant.
     */
    public boolean nameFormDeclared() {
        return nameFormDeclared;
    }

    /**
     * The SQL spelling of one of this model's names, per its {@link #nameForm()}. Every consumer
     * of a model reads names as SQL text (the validator, {@code SQLEnvCatalogLoader}, the runtime
     * snapshot built by {@code ModelBackedCatalogProvider}), so each of them passes a name
     * through here first. A {@code SQL_LEXICAL} name comes back unchanged; a
     * {@code CATALOG_STORED} name comes back as the delimited spelling of the same stored name
     * ({@link TSQLEnv#toLexical}). Keeping the rule here is what stops one consumer from
     * honouring the declaration while another ignores it.
     *
     * <p>Only single names follow the form. A dotted reference
     * ({@code SynonymModel.targetQualifiedName}, {@code ConstraintModel.referencedTable}) is SQL
     * text by construction: a stored name may itself contain a dot, so stored names joined with
     * dots could not be split back.</p>
     */
    public String lexical(ESQLDataObjectType role, String name) {
        return TSQLEnv.toLexical(vendor, role, name, nameForm);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof UnifiedCatalogModel)) return false;
        UnifiedCatalogModel that = (UnifiedCatalogModel) o;
        return apiVersion.equals(that.apiVersion)
            && vendor == that.vendor
            && identifierConfig.equals(that.identifierConfig)
            && defaults.equals(that.defaults)
            && catalogs.equals(that.catalogs)
            && Objects.equals(sourceInfo, that.sourceInfo)
            && nameForm == that.nameForm;
    }

    @Override
    public int hashCode() {
        return Objects.hash(apiVersion, vendor, identifierConfig, defaults, catalogs, sourceInfo, nameForm);
    }

    @Override
    public String toString() {
        return "UnifiedCatalogModel{apiVersion=" + apiVersion
            + ", vendor=" + vendor
            + ", catalogs=" + catalogs.size()
            + ", sourceInfo=" + sourceInfo + ", nameForm=" + nameForm + '}';
    }

    public static final class Builder {

        private String apiVersion;
        private EDbVendor vendor;
        private IdentifierConfig identifierConfig;
        private DefaultsConfig defaults;
        private final List<CatalogModel> catalogs = new ArrayList<CatalogModel>();
        private CatalogSourceInfo sourceInfo;
        private IdentifierInputForm nameForm;
        private boolean nameFormDeclared;

        private Builder() {
        }

        public Builder apiVersion(String v) {
            this.apiVersion = v;
            return this;
        }

        public Builder vendor(EDbVendor v) {
            this.vendor = v;
            return this;
        }

        public Builder identifierConfig(IdentifierConfig v) {
            this.identifierConfig = v;
            return this;
        }

        public Builder defaults(DefaultsConfig v) {
            this.defaults = v;
            return this;
        }

        public Builder addCatalog(CatalogModel v) {
            if (v == null) {
                throw new IllegalArgumentException("UnifiedCatalogModel catalog may not be null");
            }
            this.catalogs.add(v);
            return this;
        }

        public Builder sourceInfo(CatalogSourceInfo v) {
            this.sourceInfo = v;
            return this;
        }

        /** See {@link UnifiedCatalogModel#nameForm()}; {@code null} means {@code SQL_LEXICAL}. */
        public Builder nameForm(IdentifierInputForm v) {
            this.nameForm = v;
            this.nameFormDeclared = v != null;
            return this;
        }

        /**
         * The form to use when the input did not declare one: sets {@link #nameForm()} without
         * marking it as declared. For readers, which know their format's default.
         */
        public Builder defaultNameForm(IdentifierInputForm v) {
            if (!this.nameFormDeclared) {
                this.nameForm = v;
            }
            return this;
        }

        public UnifiedCatalogModel build() {
            return new UnifiedCatalogModel(this);
        }
    }
}