package gudusoft.gsqlparser.lineage.v2.producer;

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

import gudusoft.gsqlparser.EDbVendor;
import gudusoft.gsqlparser.lineage.v2.SqllrResources;
import gudusoft.gsqlparser.lineage.v2.identity.SegmentKeyV1;
import gudusoft.gsqlparser.sqlenv.IdentifierProfile;

/**
 * Whether an analysis may mint portable SQL-LR identities, and with which key function.
 *
 * <p>The standard's rule data, not GSP's name service, decides a document's canonical keys, so a portable
 * identity is only honest when GSP analyses under the same naming policy that the dependency snapshot declares
 * ({@code lineage-spec/snapshots/FORMAT.md}, Section 6: different settings are a different snapshot). The
 * producer ships one snapshot, the draft snapshot, so:</p>
 * <ul>
 *   <li>a dialect outside the snapshot's six rule sets mints no portable identity (its endpoints are
 *   {@code LOCAL});</li>
 *   <li>for one of the six, the analysis must run under GSP's default profile for the vendor, whose flags are
 *   the snapshot's effective flags and collations; any other effective profile (other flags, a group or
 *   object-type override) is refused with {@link SqllrProducerException}, never published under a snapshot
 *   that does not describe it.</li>
 * </ul>
 *
 * @since 4.2.17
 */
public final class IdentityPolicy {

    /** The error code of a refused configuration. */
    public static final String CONFIGURATION_UNSUPPORTED = "PRODUCER_CONFIGURATION_UNSUPPORTED";

    private static final Map<EDbVendor, String> DIALECTS;

    static {
        Map<EDbVendor, String> map = new EnumMap<EDbVendor, String>(EDbVendor.class);
        map.put(EDbVendor.dbvoracle, "oracle");
        map.put(EDbVendor.dbvmssql, "sqlserver");
        map.put(EDbVendor.dbvazuresql, "sqlserver");
        map.put(EDbVendor.dbvmysql, "mysql");
        map.put(EDbVendor.dbvpostgresql, "postgresql");
        map.put(EDbVendor.dbvbigquery, "bigquery");
        map.put(EDbVendor.dbvsnowflake, "snowflake");
        DIALECTS = Collections.unmodifiableMap(map);
    }

    private final EDbVendor vendor;
    private final String dialect;
    private final SegmentKeyV1 keys;

    private IdentityPolicy(EDbVendor vendor, String dialect, SegmentKeyV1 keys) {
        this.vendor = vendor;
        this.dialect = dialect;
        this.keys = keys;
    }

    /**
     * The SQL-LR dialect code of a vendor whose identifier rules the draft snapshot carries, or {@code null}.
     * Derived dialects (Greenplum, Redshift, GaussDB, ...) are not mapped: their naming rules are not the
     * parent's.
     */
    public static String dialectCode(EDbVendor vendor) {
        return DIALECTS.get(vendor);
    }

    /** The vendors that can mint portable identities. */
    public static Map<EDbVendor, String> portableVendors() {
        return DIALECTS;
    }

    /**
     * The policy of one analysis.
     *
     * @param vendor    the analysed vendor
     * @param effective the analysis's frozen identifier profile; {@code null} means the vendor default
     * @throws SqllrProducerException {@link #CONFIGURATION_UNSUPPORTED} when the vendor has a rule set but the
     *                                profile differs from the vendor default the draft snapshot describes
     */
    public static IdentityPolicy of(EDbVendor vendor, IdentifierProfile effective) {
        String dialect = dialectCode(vendor);
        if (dialect == null) {
            return new IdentityPolicy(vendor, null, null);
        }
        // the parser analyses Azure SQL as SQL Server (TGSqlParser), so its frozen profile names dbvmssql
        EDbVendor analysed = effective != null ? effective.getVendor() : vendor;
        if (!dialect.equals(dialectCode(analysed))) {
            throw new SqllrProducerException(CONFIGURATION_UNSUPPORTED, "the analysis profile is for " + analysed
                    + ", not for the requested " + vendor);
        }
        IdentifierProfile standard = IdentifierProfile.forVendor(analysed, IdentifierProfile.VendorFlags.defaults());
        if (effective != null && !effective.hasSameEffectivePolicyAs(standard)) {
            throw new SqllrProducerException(CONFIGURATION_UNSUPPORTED, "the identifier profile of this analysis ("
                    + effective + ") is not the " + vendor + " default that the shipped dependency snapshot "
                    + "describes; portable identities would be minted under rules the document does not declare");
        }
        SegmentKeyV1 keys = SegmentKeyV1.draft(dialect);
        checkSnapshotMatchesDefaults(dialect, keys);
        return new IdentityPolicy(vendor, dialect, keys);
    }

    /**
     * The draft snapshot's effective settings must be GSP's vendor defaults; a snapshot change that breaks this
     * fails here instead of minting keys under the wrong rules.
     */
    static void checkSnapshotMatchesDefaults(String dialect, SegmentKeyV1 keys) {
        IdentifierProfile.VendorFlags defaults = IdentifierProfile.VendorFlags.defaults();
        Map<String, Object> expected = new LinkedHashMap<String, Object>();
        Map<String, String> collations = new LinkedHashMap<String, String>();
        if ("mysql".equals(dialect)) {
            expected.put("lowerCaseTableNames", Long.valueOf(defaults.mysqlLowerCaseTableNames));
            expected.put("ansiQuotes", Boolean.valueOf(defaults.mysqlAnsiQuotes));
        } else if ("snowflake".equals(dialect)) {
            expected.put("quotedIdentifiersIgnoreCase", Boolean.valueOf(defaults.snowflakeQuotedIdentifiersIgnoreCase));
        } else if ("bigquery".equals(dialect)) {
            expected.put("datasetCaseInsensitive", Boolean.FALSE);
        } else if ("sqlserver".equals(dialect)) {
            collations.put("INSTANCE", defaults.defaultCollation);
            collations.put("DATABASE", defaults.defaultCollation);
        }
        if (!expected.equals(keys.getFlags()) || !collations.equals(keys.getCollations())) {
            throw new IllegalStateException("the shipped snapshot's " + dialect + " settings " + keys.getFlags() + " "
                    + keys.getCollations() + " are not GSP's defaults " + expected + " " + collations);
        }
    }

    public EDbVendor getVendor() {
        return vendor;
    }

    /** The dialect code, or {@code null} when the vendor mints no portable identity. */
    public String getDialect() {
        return dialect;
    }

    /** Whether endpoints of this analysis can be {@code PORTABLE} at all. */
    public boolean isPortable() {
        return keys != null;
    }

    /** The key function; {@code null} when {@link #isPortable()} is false. */
    public SegmentKeyV1 getKeys() {
        return keys;
    }

    /**
     * The id of the snapshot in force: the shipped one, also for a dialect outside its rule sets, whose analysis still
     * runs under its algorithms, profiles and canonical forms and mints no portable identity (the analysis context
     * requires the id, spec Section 6.2; plan 06 gate E4).
     */
    public String getSnapshotId() {
        return (String) ((Map<?, ?>) SqllrResources.json(SegmentKeyV1.DRAFT_SNAPSHOT)).get("snapshotId");
    }
}