package gudusoft.gsqlparser.sqlenv;


import gudusoft.gsqlparser.TBaseType;
import gudusoft.gsqlparser.util.SQLUtil;

import java.util.*;

/**
 * In the most sql-implementation, Catalog is the anonymous of the Database.
 * So, use this class represents a database.
 */
public class TSQLCatalog extends TSQLObject {

    // IdentifierService for consistent key generation (lazy initialization).
    // volatile: concurrent lazy init may build duplicate (equivalent) instances,
    // but must never publish a partially constructed one to another thread.
    private volatile IdentifierService identifierService;

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

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

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

    /**
     * Check if catalog 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 catalog. Call seal() marks catalog as read-only.");
        }
    }

    /**
     * Get or create IdentifierService (lazy initialization)
     */
    private IdentifierService getIdentifierService() {
        if (identifierService == null) {
            IdentifierProfile profile = IdentifierProfile.forVendor(
                this.sqlEnv.getDBVendor(),
                IdentifierProfile.VendorFlags.defaults()
            );
            identifierService = new IdentifierService(profile, null);
        }
        return identifierService;
    }

    /**
     * create a catalog and add to the SQL environment.
     *
     * @param sqlEnv SQL environment
     * @param catalogName catalog name
     */
    public TSQLCatalog(TSQLEnv sqlEnv, String catalogName){
        super(sqlEnv,catalogName,ESQLDataObjectType.dotCatalog);
        this.sqlEnv.doAddCatalog(this);
    }

    /**
     * schema list in this catalog
     *
     * @return schema list
     */
    public List<TSQLSchema> getSchemaList() {
        List<TSQLSchema> schemaList = new LinkedList<>();
        synchronized (schemaMap) {
            for(String schema: schemaMap.keySet()){
                schemaList.add(schemaMap.get(schema));
            }
        }
        return schemaList;
    }

    private Map<String, TSQLSchema> schemaMap = Collections.synchronizedMap(new LinkedHashMap<String, TSQLSchema>( ));

    protected TSQLSchema searchSchema(String schemaName){
        // Phase 2: Use IdentifierService when hierarchical index is enabled
        if (TBaseType.USE_HIERARCHICAL_INDEX) {
            try {
                String key = getIdentifierService().keyForMap(schemaName, ESQLDataObjectType.dotSchema);
                TSQLSchema result = schemaMap.get(key);
                if (result != null) {
                    if (TBaseType.LOG_INDEX_HIT_RATE) {
                        System.out.println("[HierarchicalIndex] Catalog hit: schema - " + schemaName);
                    }
                    return result;
                }
            } catch (Throwable ignore) {
                // Fall through to legacy path
            }
        }

        // Legacy path: use SQLUtil normalization
        String name = SQLUtil.getIdentifierNormalName(this.sqlEnv.getDBVendor(), schemaName, ESQLDataObjectType.dotSchema);
        return schemaMap.get(name);
    }

    protected void addSchema(TSQLSchema sqlSchema) {
        // same monitor as getSchema: check-then-put must be atomic under
        // concurrent DDL registration (reentrant when called from getSchema
        // via the TSQLSchema constructor)
        synchronized (schemaMap) {
            checkNotSealed();  // Phase 6: checked under the mutation lock (seal() itself takes no monitor, so this narrows, not closes, the seal race)
            if (searchSchema(sqlSchema.name) == null) {
                // ===== Legacy path: Update schemaMap with SQLUtil normalization =====
                String name = SQLUtil.getIdentifierNormalName(this.sqlEnv.getDBVendor(), sqlSchema.name, ESQLDataObjectType.dotSchema);
                schemaMap.put(name, sqlSchema);

                // ===== New path: Also write with IdentifierService key =====
                if (TBaseType.USE_HIERARCHICAL_INDEX) {
                    try {
                        String key = getIdentifierService().keyForMap(sqlSchema.name, ESQLDataObjectType.dotSchema);
                        // Only write if the key is different from legacy key (avoid double-write)
                        if (!key.equalsIgnoreCase(name)) {
                            schemaMap.put(key, sqlSchema);
                        }
                    } catch (Throwable ignore) {
                        // Silently fail to maintain backward compatibility
                    }
                }
            }
        }
    }

    /**
     * get a schema instance from the catalog, create a new schema if this schema is not exist and the createIfNotExist parameter is true.
     *
     * @param schemaName schema name
     * @param createIfNotExist create a new schema if this schema is not exist and the createIfNotExist parameter is true.
     * @return the schema instance
     */
    public TSQLSchema getSchema(String schemaName, boolean createIfNotExist){
        TSQLSchema result = searchSchema(schemaName);
        if ((result == null)&&(createIfNotExist)){
            // synchronized so concurrent get-or-create of the same schema can't
            // produce duplicate twins; the TSQLSchema constructor re-enters this
            // monitor via addSchema (reentrant)
            synchronized (schemaMap) {
                result = searchSchema(schemaName);
                if (result == null){
                    result = new TSQLSchema(this,schemaName);
                }
            }
        }

        return result;
    }

    /**
     * create a schema under this catalog
     *
     * @param schemaName schema name
     * @return schema instance
     */
    public TSQLSchema createSchema(String schemaName){
        return getSchema(schemaName,true);
    }

}