package gudusoft.gsqlparser.catalog.runtime;

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.catalog.input.CatalogLoadingMode;
import gudusoft.gsqlparser.catalog.input.model.DefaultsConfig;

import java.util.Collections;
import java.util.EnumSet;
import java.util.LinkedHashSet;
import java.util.Objects;
import java.util.Set;

/**
 * Bounded request handed to {@link CatalogProvider#snapshot(CatalogQuery)}.
 *
 * <p>Plan §7.2. {@code requestedNames} empty means "all" (eager); non-empty restricts to
 * the explicit set (lazy). Caps from {@code CatalogLoadOptions} are folded in before the
 * query reaches the provider. {@link #requestedKinds()} empty means "all kinds".</p>
 */
public final class CatalogQuery {

    private final EDbVendor vendor;
    private final DefaultsConfig defaults;
    private final CatalogSearchPath searchPath;
    private final Set<CatalogQualifiedName> requestedNames;
    private final Set<CatalogObjectKind> requestedKinds;
    private final boolean includeColumns;
    private final boolean includeViews;
    private final boolean includeRoutines;
    private final CatalogLoadingMode loadingMode;
    private final long ttlMillis;
    private final int maxFetchesPerAnalysis;

    private CatalogQuery(Builder b) {
        if (b.vendor == null) {
            throw new IllegalArgumentException("CatalogQuery.vendor is required");
        }
        if (b.ttlMillis < 0) {
            throw new IllegalArgumentException(
                "CatalogQuery.ttlMillis must be >= 0 (got " + b.ttlMillis + ")");
        }
        if (b.maxFetchesPerAnalysis < 0) {
            throw new IllegalArgumentException(
                "CatalogQuery.maxFetchesPerAnalysis must be >= 0 (got "
                    + b.maxFetchesPerAnalysis + ")");
        }
        this.vendor = b.vendor;
        this.defaults = b.defaults != null ? b.defaults : DefaultsConfig.empty();
        this.searchPath = b.searchPath != null ? b.searchPath : CatalogSearchPath.empty();
        this.requestedNames = Collections.unmodifiableSet(
            new LinkedHashSet<CatalogQualifiedName>(b.requestedNames));
        this.requestedKinds = b.requestedKinds.isEmpty()
            ? Collections.<CatalogObjectKind>emptySet()
            : Collections.unmodifiableSet(EnumSet.copyOf(b.requestedKinds));
        this.includeColumns = b.includeColumns;
        this.includeViews = b.includeViews;
        this.includeRoutines = b.includeRoutines;
        this.loadingMode = b.loadingMode != null ? b.loadingMode : CatalogLoadingMode.EAGER;
        this.ttlMillis = b.ttlMillis;
        this.maxFetchesPerAnalysis = b.maxFetchesPerAnalysis;
    }

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

    public EDbVendor vendor() {
        return vendor;
    }

    public DefaultsConfig defaults() {
        return defaults;
    }

    public CatalogSearchPath searchPath() {
        return searchPath;
    }

    public Set<CatalogQualifiedName> requestedNames() {
        return requestedNames;
    }

    public Set<CatalogObjectKind> requestedKinds() {
        return requestedKinds;
    }

    public boolean includeColumns() {
        return includeColumns;
    }

    public boolean includeViews() {
        return includeViews;
    }

    public boolean includeRoutines() {
        return includeRoutines;
    }

    public CatalogLoadingMode loadingMode() {
        return loadingMode;
    }

    public long ttlMillis() {
        return ttlMillis;
    }

    public int maxFetchesPerAnalysis() {
        return maxFetchesPerAnalysis;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof CatalogQuery)) return false;
        CatalogQuery that = (CatalogQuery) o;
        return includeColumns == that.includeColumns
            && includeViews == that.includeViews
            && includeRoutines == that.includeRoutines
            && ttlMillis == that.ttlMillis
            && maxFetchesPerAnalysis == that.maxFetchesPerAnalysis
            && vendor == that.vendor
            && defaults.equals(that.defaults)
            && searchPath.equals(that.searchPath)
            && requestedNames.equals(that.requestedNames)
            && requestedKinds.equals(that.requestedKinds)
            && loadingMode == that.loadingMode;
    }

    @Override
    public int hashCode() {
        return Objects.hash(vendor, defaults, searchPath, requestedNames, requestedKinds,
            includeColumns, includeViews, includeRoutines, loadingMode, ttlMillis,
            maxFetchesPerAnalysis);
    }

    @Override
    public String toString() {
        return "CatalogQuery{vendor=" + vendor
            + ", names=" + requestedNames.size()
            + ", kinds=" + requestedKinds
            + ", mode=" + loadingMode + '}';
    }

    public static final class Builder {

        private EDbVendor vendor;
        private DefaultsConfig defaults;
        private CatalogSearchPath searchPath;
        private final Set<CatalogQualifiedName> requestedNames = new LinkedHashSet<CatalogQualifiedName>();
        private final Set<CatalogObjectKind> requestedKinds = EnumSet.noneOf(CatalogObjectKind.class);
        private boolean includeColumns = true;
        private boolean includeViews = true;
        private boolean includeRoutines = true;
        private CatalogLoadingMode loadingMode;
        private long ttlMillis;
        private int maxFetchesPerAnalysis;

        private Builder() {
        }

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

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

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

        public Builder addRequestedName(CatalogQualifiedName v) {
            if (v == null) {
                throw new IllegalArgumentException("CatalogQuery requested name may not be null");
            }
            this.requestedNames.add(v);
            return this;
        }

        public Builder addRequestedKind(CatalogObjectKind v) {
            if (v == null) {
                throw new IllegalArgumentException("CatalogQuery requested kind may not be null");
            }
            this.requestedKinds.add(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 loadingMode(CatalogLoadingMode v) {
            this.loadingMode = v;
            return this;
        }

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

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

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