package gudusoft.gsqlparser.sqlenv;


import gudusoft.gsqlparser.TBaseType;

import java.util.*;

/**
 * SQL schema, contains a list of schema objects.
 */
public class TSQLSchema extends TSQLObject {


    public String getQualifiedName(){
        return catalog.name+"."+name;
    }

    private TSQLCatalog catalog;

    public TSQLCatalog getCatalog() {
        return catalog;
    }


    // IdentifierService for consistent key generation (lazy initialization).
    // volatile: duplicate (equivalent) instances under a racy lazy init are harmless,
    // but a partially constructed instance must never be published to another thread.
    private volatile IdentifierService identifierService;

    // ===== Phase 6: Schema seal mechanism for thread-safety hardening =====
    /**
     * Seal state flag (volatile for thread visibility).
     */
    private volatile boolean sealed = false;

    /**
     * Seal this schema to prevent further modifications (Phase 6).
     *
     * <p>See  for detailed documentation.
     */
    public void seal() {
        this.sealed = true;
    }

    /**
     * Check if this schema is sealed (Phase 6).
     *
     * @return true if sealed, false otherwise
     */
    public boolean isSealed() {
        return sealed;
    }

    /**
     * Check if schema is not sealed, throw exception if sealed and enforcement is enabled.
     *
     * @throws IllegalStateException if sealed and TBaseType.ENFORCE_CATALOG_SEAL is true
     */
    private void checkNotSealed() {
        if (sealed && TBaseType.ENFORCE_CATALOG_SEAL) {
            throw new IllegalStateException("Cannot modify sealed schema. Call seal() marks schema as read-only.");
        }
    }

    /**
     * Create a new instance of the schema, added to the catalog.
     *
     * @param sqlCatalog catalog contains this schema
     * @param schemaName name of the schema
     */
    public TSQLSchema(TSQLCatalog sqlCatalog,String schemaName){
        super(sqlCatalog.getSqlEnv(), schemaName,ESQLDataObjectType.dotSchema);
        this.catalog = sqlCatalog;
        this.catalog.addSchema(this);
    }

    /**
     * The identifier service of the environment this object belongs to (lazy initialization).
     *
     * <p>Inherited, never rebuilt from the vendor: this object's local indexes are part of the
     * same catalog the environment's {@link CatalogStore} indexes, so keying them under the
     * vendor default while the environment ran a per-category configuration would let one half
     * of a lookup answer a question the other half never asked.
     */
    private IdentifierService getIdentifierService() {
        if (identifierService == null) {
            if (this.sqlEnv == null) {
                // Every catalog object is created against an environment; with none there is no
                // vendor and no configuration to inherit, so say so instead of guessing one.
                throw new IllegalStateException(getClass().getSimpleName()
                        + " has no TSQLEnv, so it has no identifier configuration to compare with");
            }
            identifierService = this.sqlEnv.getIdentifierService();
        }
        return identifierService;
    }



    public List<TSQLSchemaObject> getSchemaObjectList() {
        List<TSQLSchemaObject> schemaObjectList = new LinkedList<>();
        synchronized (schemaObjectMap) {
            for(TSQLSchemaObject schemaObject: schemaObjectMap.values()){
                if(schemaObject instanceof TSQLProcedure){
                    if(((TSQLProcedure)schemaObject).isOraclePackageProcedure()){
                        continue;
                    }
                }
                schemaObjectList.add(schemaObject);
            }
        }
        return schemaObjectList;
    }

    public List<TSQLSchemaObject> getPackageObjectList(TSQLOraclePackage oraclePackage) {
        List<TSQLSchemaObject> schemaObjectList = new LinkedList<>();
        synchronized (schemaObjectMap) {
            for (TSQLSchemaObject schemaObject : schemaObjectMap.values()) {
                if (schemaObject instanceof TSQLProcedure) {
                    if (!((TSQLProcedure) schemaObject).isOraclePackageProcedure()) {
                        continue;
                    }
                    TSQLProcedure procedure = (TSQLProcedure) schemaObject;
                    if (procedure.getOraclePackage() == oraclePackage) {
                        schemaObjectList.add(schemaObject);
                    }
                }
            }
        }
        return schemaObjectList;
    }

    // Every vendor keys this map with QualifiedCanonKey (one segment plus object
    // type) built from the environment's own IdentifierService, so the answer here
    // is the answer the configured IdentifierProfile gives. It used to be a
    // Snowflake/BigQuery allowlist with legacy String keys for the other 52
    // vendors, which made TSQLEnv's two searchTable overloads disagree: the String
    // overload reaches CatalogStore and honors the profile, the TObjectName overload
    // reaches this map and did not. A configured per-category rule was then honored
    // or ignored depending on which overload the caller happened to use, and
    // dlineage uses both (DataFlowAnalyzer passes a TObjectName, ModelFactory and
    // Table pass a String). The legacy key was also the LOOSER of the two, so the
    // disagreement surfaced as a confident hit on an object the configuration calls
    // a different object, which nothing downstream flags.
    private final Map<Object, TSQLSchemaObject> schemaObjectMap =
            Collections.synchronizedMap(new LinkedHashMap<Object, TSQLSchemaObject>());


    private QualifiedCanonKey schemaKey(String name, ESQLDataObjectType type, IdentifierInputForm form) {
        // This API receives a LOCAL name: a dot inside it is content, not a new
        // level. The terminal type also keeps same-named tables/routines separate.
        CanonKey key = sqlEnv.getIdentifierService().canonKeyOf(name, type, form);
        return new QualifiedCanonKey(Collections.singletonList(key), type);
    }

//    public boolean addTable(TSQLTable sqlTable){
//        return addDataObject(sqlTable);
//    }
//
//    public boolean addProcedure(TSQLProcedure sqlProcedure){
//        return addDataObject(sqlProcedure);
//    }
//
//    public boolean addFunction(TSQLFunction sqlFunction){
//        return addDataObject(sqlFunction);
//    }
//
//    public boolean addTrigger(TSQLTrigger sqlTrigger){
//        return addDataObject(sqlTrigger);
//    }

    /**
     * add database object
     *
     * <p>One index, one key function. The type-specific maps and the SQL Server bucketed
     * index that used to be written alongside this one are gone: they keyed themselves
     * independently of the environment's {@link IdentifierProfile}, so they could only
     * agree with it by coincidence.
     *
     * @param schemaObject schema object to add
     */
    protected void addSchemaObject(TSQLSchemaObject schemaObject){
        // same monitor as createSchemaObject: registration of one object must be
        // atomic across all indexes (reentrant when called from createSchemaObject
        // via the schema-object constructors).
        // Note: env.putSchemaObject (and thus the catalog provider) runs while this
        // monitor is held — in-tree providers never call back into schema/env
        // creation; a custom ICatalogProvider that does could deadlock.
        synchronized (schemaObjectMap) {
            checkNotSealed();  // Phase 6: checked under the mutation lock (seal() itself takes no monitor, so this narrows, not closes, the seal race)
            // getName() is the stored spelling this object was registered under, so it
            // enters as CATALOG_STORED; findSchemaObject takes SQL_LEXICAL because its
            // argument is a spelling out of a statement. Encoding both ends through the
            // same service is what keeps the two forms from folding differently.
            schemaObjectMap.put(schemaKey(schemaObject.getName(), schemaObject.getDataObjectType(),
                    IdentifierInputForm.CATALOG_STORED), schemaObject);
            this.catalog.getSqlEnv().putSchemaObject(schemaObject.getQualifiedName(), schemaObject);
        }
    }

    TSQLSchemaObject findSchemaObject(ESQLDataObjectType dataObjectType, String schemaObjectName) {
        // No fallback after a canonical miss. The old key folded more aggressively
        // than several vendors' real rules, so a retry under it would turn Oracle
        // "Orders" or Snowflake "Orders" into ORDERS and hand back a DIFFERENT
        // object while reporting a hit.
        TSQLSchemaObject result = schemaObjectMap.get(schemaKey(schemaObjectName, dataObjectType,
                IdentifierInputForm.SQL_LEXICAL));
        return result;
    }


    /**
     * create a oracle package belong to this schema
     *
     * @param oraclePackageName oracle package name
     * @return an instance of the oracle package
     */
    public TSQLOraclePackage createOraclePackage(String oraclePackageName){
        return (TSQLOraclePackage)createSchemaObject(oraclePackageName,ESQLDataObjectType.dotOraclePackage);
    }

    /**
     * create a procedure belong to this schema
     *
     * @param procedureName procedure name
     * @return an instance of the SQL procedure
     */
    public TSQLProcedure createProcedure(String procedureName){
        return (TSQLProcedure)createSchemaObject(procedureName,ESQLDataObjectType.dotProcedure);
    }

    public TSQLProcedure createProcedure(String procedureName, ESQLDataObjectType type){
        return (TSQLProcedure)createSchemaObject(procedureName,type);
    }

    /**
     * create a function belong to this schema
     *
     * @param functionName function name
     * @return an instance of the SQL function.
     */
    public TSQLFunction createFunction(String functionName){
        return (TSQLFunction)createSchemaObject(functionName,ESQLDataObjectType.dotFunction);
    }

    /**
     * create a trigger belong to this schema
     *
     * @param triggerName trigger name
     * @return an instance of the SQL trigger.
     */
    public TSQLTrigger createTrigger(String triggerName){
        return (TSQLTrigger)createSchemaObject(triggerName,ESQLDataObjectType.dotTrigger);
    }

    /**
     * create a synonyms belong to this schema
     *
     * @param synonymsName synonyms name
     * @return an instance of the SQL synonyms
     */
    public TSQLSynonyms createSynonyms(String synonymsName){
        return (TSQLSynonyms)createSchemaObject(synonymsName,ESQLDataObjectType.dotSynonyms);
    }

    /**
     * create a synonyms belong to this schema and record its base target.
     *
     * <p>If a synonym with the same name already exists it is returned with its
     * base target updated. Any of {@code sourceDatabase}/{@code sourceSchema} may
     * be {@code null} to mean "the synonym's own database/schema"; cross-database
     * base targets are allowed.
     *
     * @param synonymsName   synonyms name
     * @param sourceDatabase base database/catalog, or {@code null}
     * @param sourceSchema   base schema, or {@code null}
     * @param sourceName     base object name
     * @return an instance of the SQL synonyms
     */
    public TSQLSynonyms createSynonyms(String synonymsName, String sourceDatabase, String sourceSchema, String sourceName){
        TSQLSynonyms synonyms = createSynonyms(synonymsName);
        if (synonyms != null) {
            synonyms.setBaseTarget(sourceDatabase, sourceSchema, sourceName);
        }
        return synonyms;
    }

    /**
     * create a table belong to this schema. If table with the same name already exists in the schema
     * return the existing table.
     *
     * @param tableName table name
     * @return an instance of the SQL table
     */
    public TSQLTable createTable(String tableName){
        return (TSQLTable)createSchemaObject(tableName,ESQLDataObjectType.dotTable);
    }

    public TSQLTable createTable(String tableName, int priority){
        return (TSQLTable)createSchemaObject(tableName,ESQLDataObjectType.dotTable, priority);
    }

    // Use the same identity path as get-or-create: canonical keys for Snowflake
    // and BigQuery, the bucketed/hierarchical/legacy chain for other vendors.
    public boolean containsTable(String tableName) {
        return findSchemaObject(ESQLDataObjectType.dotTable, tableName) != null;
    }

    public TSQLTable findTable(String tableName) {
        return (TSQLTable) findSchemaObject(ESQLDataObjectType.dotTable, tableName);
    }

    public TSQLSynonyms findSynonyms(String synonymsName) {
        return (TSQLSynonyms) findSchemaObject(ESQLDataObjectType.dotSynonyms, synonymsName);
    }
    
        public TSQLSchemaObject findSchemaObject(String schemaObjectName) {
                TSQLSchemaObject object = findSchemaObject(ESQLDataObjectType.dotFunction, schemaObjectName);
                if (object == null) {
                        object = findSchemaObject(ESQLDataObjectType.dotProcedure, schemaObjectName);
                }
                if (object == null) {
                        object = findSchemaObject(ESQLDataObjectType.dotTrigger, schemaObjectName);
                }
                if (object == null) {
                        object = findSchemaObject(ESQLDataObjectType.dotOraclePackage, schemaObjectName);
                }
                if (object == null) {
                        object = findSchemaObject(ESQLDataObjectType.dotSynonyms, schemaObjectName);
                }
                return object;
        }

    /**
     *
     * @param schemaObjectName 该名称不带 catalog, schema 前缀
     * @param dataObjectType
     * @return
     */
    public TSQLSchemaObject createSchemaObject(String schemaObjectName, ESQLDataObjectType dataObjectType){
        return createSchemaObject(schemaObjectName, dataObjectType, 0);
    }

    /**
     *
     * @param schemaObjectName 该名称不带 catalog, schema 前缀
     * @param dataObjectType
     * @param priority
     * @return
     */
    protected TSQLSchemaObject createSchemaObject(String schemaObjectName, ESQLDataObjectType dataObjectType, int priority){
        TSQLSchemaObject result = null;
        // synchronized so concurrent get-or-create of the same object can't produce
        // duplicate twins (columns added to the losing twin would be invisible).
        // The schema-object constructors re-enter this monitor via addSchemaObject —
        // reentrant, keep both on the same lock or the race comes back.
        synchronized (schemaObjectMap) {
            TSQLSchemaObject schemaObject = findSchemaObject(dataObjectType, schemaObjectName);
            if (schemaObject == null){
                switch (dataObjectType){
                    case dotTable:
                        result = new TSQLTable(this,schemaObjectName);
                        break;
                    case dotOraclePackage:
                        result = new TSQLOraclePackage(this,schemaObjectName);
                        break;
                    case dotProcedure:
                        result = new TSQLProcedure(this,schemaObjectName);
                        break;
                    case dotFunction:
                        result = new TSQLFunction(this,schemaObjectName);
                        break;
                    case dotTrigger:
                        result = new TSQLTrigger(this,schemaObjectName);
                        break;
                    case dotSynonyms:
                        result = new TSQLSynonyms(this,schemaObjectName);
                        break;
                }
            }else if (dataObjectType == schemaObject.getDataObjectType()){
                result = schemaObject;
            }else{
                System.out.println("object name conflict:"+getQualifiedName()+"."+schemaObjectName+",type:"+dataObjectType+" VS "+schemaObject.getQualifiedName()+", type:"+schemaObject.getDataObjectType());
            };

            if (result!=null && priority > result.getPriority()) {
                result.setPriority(priority);
            }
        }
        return result;
    }

}