package gudusoft.gsqlparser.catalog.input;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.catalog.diagnostic.CatalogDiagnosticSink;
import gudusoft.gsqlparser.catalog.input.model.IdentifierConfig;
import gudusoft.gsqlparser.catalog.runtime.CatalogSearchPath;

import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;

/**
 * Caller-supplied knobs that drive both the input reader and the runtime provider.
 *
 * <p>Plan §7.1. Immutable; build via {@link #builder()}.</p>
 *
 * <p>Defaults match the Phase 1 reference paths: {@code loadingMode=EAGER},
 * {@code strict=false}, {@code normalizeOnLoad=true}, includes columns / views /
 * routines, no caps. {@code identifierConfig} defaults to
 * {@link IdentifierConfig#defaultsFor(EDbVendor) defaultsFor(vendor)} when unset.</p>
 */
public final class CatalogLoadOptions {

    private final EDbVendor vendor;
    private final String defaultCatalog;
    private final String defaultSchema;
    private final String defaultServer;
    private final CatalogSearchPath searchPath;
    private final CatalogLoadingMode loadingMode;
    private final boolean strict;
    private final boolean normalizeOnLoad;
    private final long ttlMillis;
    private final int maxEagerObjects;
    private final int maxFetchesPerAnalysis;
    private final boolean includeColumns;
    private final boolean includeViews;
    private final boolean includeRoutines;
    private final IdentifierConfig identifierConfig;
    private final boolean explicitIdentifierConfig;
    private final CatalogDiagnosticSink diagnosticSink;
    private final Map<String, Object> providerProperties;

    private CatalogLoadOptions(Builder b) {
        if (b.vendor == null) {
            throw new IllegalArgumentException("CatalogLoadOptions.vendor is required");
        }
        if (b.ttlMillis < 0) {
            throw new IllegalArgumentException(
                "CatalogLoadOptions.ttlMillis must be >= 0 (got " + b.ttlMillis + ")");
        }
        if (b.maxEagerObjects < 0) {
            throw new IllegalArgumentException(
                "CatalogLoadOptions.maxEagerObjects must be >= 0 (got " + b.maxEagerObjects + ")");
        }
        if (b.maxFetchesPerAnalysis < 0) {
            throw new IllegalArgumentException(
                "CatalogLoadOptions.maxFetchesPerAnalysis must be >= 0 (got "
                    + b.maxFetchesPerAnalysis + ")");
        }
        this.vendor = b.vendor;
        this.defaultCatalog = b.defaultCatalog;
        this.defaultSchema = b.defaultSchema;
        this.defaultServer = b.defaultServer;
        this.searchPath = b.searchPath != null ? b.searchPath : CatalogSearchPath.empty();
        this.loadingMode = b.loadingMode != null ? b.loadingMode : CatalogLoadingMode.EAGER;
        this.strict = b.strict;
        this.normalizeOnLoad = b.normalizeOnLoad;
        this.ttlMillis = b.ttlMillis;
        this.maxEagerObjects = b.maxEagerObjects;
        this.maxFetchesPerAnalysis = b.maxFetchesPerAnalysis;
        this.includeColumns = b.includeColumns;
        this.includeViews = b.includeViews;
        this.includeRoutines = b.includeRoutines;
        // Only auto-default when the caller did not explicitly pass an identifierConfig.
        // The caller-explicit flag matters because the validator and downstream consumers
        // need to know whether to prefer the model's IdentifierConfig (when no override was
        // supplied) or this one. When the caller did supply an explicit config we still
        // validate vendor consistency.
        this.explicitIdentifierConfig = b.identifierConfig != null;
        this.identifierConfig = b.identifierConfig != null
            ? b.identifierConfig : IdentifierConfig.defaultsFor(b.vendor);
        if (this.identifierConfig.vendor() != b.vendor) {
            throw new IllegalArgumentException(
                "CatalogLoadOptions: identifierConfig.vendor=" + this.identifierConfig.vendor()
                    + " does not match vendor=" + b.vendor);
        }
        this.diagnosticSink = b.diagnosticSink;
        this.providerProperties = Collections.unmodifiableMap(
            new LinkedHashMap<String, Object>(b.providerProperties));
    }

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

    public EDbVendor vendor() {
        return vendor;
    }

    public String defaultCatalog() {
        return defaultCatalog;
    }

    public String defaultSchema() {
        return defaultSchema;
    }

    public String defaultServer() {
        return defaultServer;
    }

    public CatalogSearchPath searchPath() {
        return searchPath;
    }

    public CatalogLoadingMode loadingMode() {
        return loadingMode;
    }

    public boolean strict() {
        return strict;
    }

    public boolean normalizeOnLoad() {
        return normalizeOnLoad;
    }

    public long ttlMillis() {
        return ttlMillis;
    }

    public int maxEagerObjects() {
        return maxEagerObjects;
    }

    public int maxFetchesPerAnalysis() {
        return maxFetchesPerAnalysis;
    }

    public boolean includeColumns() {
        return includeColumns;
    }

    public boolean includeViews() {
        return includeViews;
    }

    public boolean includeRoutines() {
        return includeRoutines;
    }

    public IdentifierConfig identifierConfig() {
        return identifierConfig;
    }

    /**
     * {@code true} when the caller passed an explicit {@link IdentifierConfig} via
     * {@link Builder#identifierConfig(IdentifierConfig)}; {@code false} when the value
     * returned by {@link #identifierConfig()} is the auto-filled vendor default.
     * Consumers that already have a model-supplied {@link IdentifierConfig} can use
     * this flag to decide whether to prefer the model's value over the auto-fill.
     */
    public boolean hasExplicitIdentifierConfig() {
        return explicitIdentifierConfig;
    }

    public CatalogDiagnosticSink diagnosticSink() {
        return diagnosticSink;
    }

    public Map<String, Object> providerProperties() {
        return providerProperties;
    }

    public static final class Builder {

        private EDbVendor vendor;
        private String defaultCatalog;
        private String defaultSchema;
        private String defaultServer;
        private CatalogSearchPath searchPath;
        private CatalogLoadingMode loadingMode;
        private boolean strict;
        private boolean normalizeOnLoad = true;
        private long ttlMillis;
        private int maxEagerObjects;
        private int maxFetchesPerAnalysis;
        private boolean includeColumns = true;
        private boolean includeViews = true;
        private boolean includeRoutines = true;
        private IdentifierConfig identifierConfig;
        private CatalogDiagnosticSink diagnosticSink;
        private final Map<String, Object> providerProperties = new LinkedHashMap<String, Object>();

        private Builder() {
        }

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

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

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

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

        public Builder searchPath(CatalogSearchPath v) {
            this.searchPath = v;
            return this;
        }

        public Builder loadingMode(CatalogLoadingMode v) {
            this.loadingMode = v;
            return this;
        }

        public Builder strict(boolean v) {
            this.strict = v;
            return this;
        }

        public Builder normalizeOnLoad(boolean v) {
            this.normalizeOnLoad = v;
            return this;
        }

        public Builder ttlMillis(long v) {
            this.ttlMillis = v;
            return this;
        }

        public Builder maxEagerObjects(int v) {
            this.maxEagerObjects = v;
            return this;
        }

        public Builder maxFetchesPerAnalysis(int v) {
            this.maxFetchesPerAnalysis = v;
            return this;
        }

        public Builder includeColumns(boolean v) {
            this.includeColumns = v;
            return this;
        }

        public Builder includeViews(boolean v) {
            this.includeViews = v;
            return this;
        }

        public Builder includeRoutines(boolean v) {
            this.includeRoutines = v;
            return this;
        }

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

        public Builder diagnosticSink(CatalogDiagnosticSink v) {
            this.diagnosticSink = v;
            return this;
        }

        public Builder providerProperty(String key, Object value) {
            if (key == null) {
                throw new IllegalArgumentException("providerProperty key may not be null");
            }
            this.providerProperties.put(key, value);
            return this;
        }

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