package gudusoft.gsqlparser.sqlenv;

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

import java.util.*;

/**
 * SQL table, includes a list of columns.
 */
public class TSQLTable extends TSQLSchemaObject {

    // 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: Table seal mechanism for thread-safety hardening =====
    /**
     * Seal state flag (volatile for thread visibility). No explicit initializer:
     * `this` escapes the base constructor into shared env indexes, so a subclass
     * initializer could overwrite a seal() issued by a concurrent early reader.
     */
    private volatile boolean sealed;

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

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

    /**
     * Check if table 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 table. Call seal() marks table 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;
    }

    // volatile, no explicit initializer: read lock-free by lineage/export paths
    // while addView on another thread sets it (and see the `sealed` note above)
    private volatile boolean isView;

    public void setView(boolean view) {
        isView = view;
    }

    /**
     * Used to check whether this is a view.
     *
     * @return true if this is a view.
     */
    public boolean isView() {
        return isView;
    }

    // volatile: written during registration, read lock-free by other threads
    private volatile String definition;

    public void setDefinition(String definition) {
        this.definition = definition;
    }

    /**
     * This is the script that used to create this view( {@link #isView()} returns true).
     *
     * @return sql script that used to create this view.
     */
    public String getDefinition() {
        return definition;
    }

    /**
     * create a new table belong to a schema
     *
     * @param sqlSchema schema
     * @param tableName table name
     */
    public TSQLTable(TSQLSchema sqlSchema, String tableName){
        super(sqlSchema,tableName,ESQLDataObjectType.dotTable);
    }

    /**
     * column list
     * @return a column list
     */
    public List<TSQLColumn> getColumnList() {
        Set<TSQLColumn> columnList = new LinkedHashSet<>();
        Map<String, TSQLColumn> m = columnMap();
        synchronized (m) {
            for(String column: m.keySet()){
                columnList.add(m.get(column));
            }
        }
        return new ArrayList<>(columnList);
    }

    // No field initializer: the TSQLSchemaObject constructor publishes `this` into
    // shared env indexes before subclass initializers run, so a field initializer
    // could overwrite a map a concurrent reader already lazily created. volatile +
    // double-checked lazy init in columnMap() makes early access safe instead.
    private volatile Map<String, TSQLColumn> columnMap;

    private Map<String, TSQLColumn> columnMap() {
        Map<String, TSQLColumn> m = columnMap;
        if (m == null) {
            synchronized (this) {
                if (columnMap == null) {
                    columnMap = Collections.synchronizedMap(new LinkedHashMap<String, TSQLColumn>( ));
                }
                m = columnMap;
            }
        }
        return m;
    }

    /**
     * add a new column to the table
     *
     * @param columnName column name
     */
    public void addColumn(String columnName){
        // search-then-put must be atomic: concurrent DDL registration on the same
        // (now deduplicated) table instance races here otherwise
        Map<String, TSQLColumn> m = columnMap();
        synchronized (m) {
            checkNotSealed();  // Phase 6: checked under the mutation lock (seal() itself takes no monitor, so this narrows, not closes, the seal race)
            if (!searchColumn(columnName)){
                TSQLColumn newColumn = new TSQLColumn(this, columnName);

                // ===== Legacy path: Update columnMap with SQLUtil normalization =====
                String legacyKey = SQLUtil.getIdentifierNormalColumnName(this.sqlEnv.getDBVendor(), columnName);
                m.put(legacyKey, newColumn);

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

            }
        }
    }

    public void addColumn(String columnName, TTypeName columnDataType){
        // search-then-put must be atomic (see addColumn(String))
        Map<String, TSQLColumn> m = columnMap();
        synchronized (m) {
            checkNotSealed();  // Phase 6: checked under the mutation lock (seal() itself takes no monitor, so this narrows, not closes, the seal race)
            if (!searchColumn(columnName)){
                TSQLColumn newColumn = new TSQLColumn(this, columnName, columnDataType);

                // ===== Legacy path: Update columnMap with SQLUtil normalization =====
                String legacyKey = SQLUtil.getIdentifierNormalColumnName(this.sqlEnv.getDBVendor(), columnName);
                m.put(legacyKey, newColumn);

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

    public boolean searchColumn(String columnName){
        // Phase 2: Use IdentifierService when hierarchical index is enabled
        if (TBaseType.USE_HIERARCHICAL_INDEX) {
            try {
                String key = getIdentifierService().keyForMap(columnName, ESQLDataObjectType.dotColumn);
                if (columnMap().containsKey(key)) {
                    if (TBaseType.LOG_INDEX_HIT_RATE) {
                        System.out.println("[HierarchicalIndex] Table hit: column - " + columnName);
                    }
                    return true;
                }
            } catch (Throwable ignore) {
                // Fall through to legacy path
            }
        }

        // Legacy path: use SQLUtil normalization
        return columnMap().containsKey(SQLUtil.getIdentifierNormalColumnName(this.sqlEnv.getDBVendor(), columnName));
    }

    public TSQLColumn getColumn(String columnName){
        // Phase 2: Use IdentifierService when hierarchical index is enabled
        if (TBaseType.USE_HIERARCHICAL_INDEX) {
            try {
                String key = getIdentifierService().keyForMap(columnName, ESQLDataObjectType.dotColumn);
                TSQLColumn result = columnMap().get(key);
                if (result != null) {
                    if (TBaseType.LOG_INDEX_HIT_RATE) {
                        System.out.println("[HierarchicalIndex] Table hit: column - " + columnName);
                    }
                    return result;
                }
            } catch (Throwable ignore) {
                // Fall through to legacy path
            }
        }

        // Legacy path: use SQLUtil normalization
        return columnMap().get(SQLUtil.getIdentifierNormalColumnName(this.sqlEnv.getDBVendor(), columnName));
    }


    public ArrayList<String> getColumns(boolean columnNameOnly ){
        ArrayList<String> columns = new ArrayList<>();
        Map<String, TSQLColumn> m = columnMap();
        synchronized (m) {
            for(String column: m.keySet()){
                TSQLColumn s = m.get(column);
                if (columnNameOnly){
                    columns.add(s.name);
                }else{
                    columns.add(this.name+"."+ s.name);
                }

               // columns.add(s.name);
            }
        }

        return columns;
    }

}