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)
    private IdentifierService identifierService;

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

    /**
     * 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;
    }

    private boolean isView = false;

    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;
    }

    private 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() {
        List<TSQLColumn> columnList = new LinkedList<>();
        synchronized (columnMap) {
            for(String column: columnMap.keySet()){
                columnList.add(columnMap.get(column));
            }
        }
        return columnList;
    }

    private Map<String, TSQLColumn> columnMap = Collections.synchronizedMap(new LinkedHashMap<String, TSQLColumn>( ));

    /**
     * add a new column to the table
     *
     * @param columnName column name
     */
    public void addColumn(String columnName){
        checkNotSealed();  // Phase 6: Prevent modification after seal
        if (!searchColumn(columnName)){
            TSQLColumn newColumn = new TSQLColumn(this, columnName);

            // ===== Legacy path: Update columnMap with SQLUtil normalization =====
            String legacyKey = SQLUtil.getIdentifierNormalColumnName(this.sqlEnv.getDBVendor(), columnName);
            columnMap.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)) {
                        columnMap.put(key, newColumn);
                    }
                } catch (Throwable ignore) {
                    // Silently fail to maintain backward compatibility
                }
            }

        }
    }

    public void addColumn(String columnName, TTypeName columnDataType){
        checkNotSealed();  // Phase 6: Prevent modification after seal
        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);
            columnMap.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)) {
                        columnMap.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<>();
        synchronized (columnMap) {
            for(String column: columnMap.keySet()){
                TSQLColumn s = columnMap.get(column);
                if (columnNameOnly){
                    columns.add(s.name);
                }else{
                    columns.add(this.name+"."+ s.name);
                }

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

        return columns;
    }

}