package gudusoft.gsqlparser.sqlenv;

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

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.");
        }
    }

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

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

    /** A table of {@code sqlSchema} that the schema does not hold yet ({@link #newVersion()}). */
    private TSQLTable(TSQLSchema sqlSchema, String tableName, boolean unregistered){
        super(sqlSchema,tableName,ESQLDataObjectType.dotTable,unregistered);
    }

    /**
     * column list
     * @return a column list
     */
    public List<TSQLColumn> getColumnList() {
        Map<CanonKey, TSQLColumn> m = columnMap();
        synchronized (m) {
            return new ArrayList<>(m.values());
        }
    }

    // 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<CanonKey, TSQLColumn> columnMap;

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

    /**
     * add a new column to the table
     *
     * @param columnName column name
     */
    public void addColumn(String columnName){
        addColumn(columnName, null);
    }

    public void addColumn(String columnName, TTypeName columnDataType){
        // search-then-put must be atomic (see addColumn(String))
        Map<CanonKey, 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 (!m.containsKey(columnKey(columnName, IdentifierInputForm.SQL_LEXICAL))){
                TSQLColumn newColumn = new TSQLColumn(this, columnName, columnDataType);
                // getName() is already a stored name; never interpret it as SQL again.
                m.put(columnKey(newColumn.getName(), IdentifierInputForm.CATALOG_STORED), newColumn);
            }
        }
    }

    /**
     * Records that the table's width is not fully known: its definition or the lineage that wrote it back read a
     * star ({@code SELECT *}) it could not expand. The entry is stored as {@code *} and marked
     * ({@link TSQLColumn#isUnresolvedStar()}); it is not a column of the table, and a column the table already holds
     * under that name (a column NAMED {@code *}) is left as it is.
     */
    public void addUnresolvedStar(){
        Map<CanonKey, TSQLColumn> m = columnMap();
        synchronized (m) {
            checkNotSealed();
            if (!m.containsKey(columnKey("*", IdentifierInputForm.SQL_LEXICAL))){
                TSQLColumn star = new TSQLColumn(this, "*");
                star.setUnresolvedStar(true);
                m.put(columnKey(star.getName(), IdentifierInputForm.CATALOG_STORED), star);
            }
        }
    }

    /**
     * Replaces this table in its schema with a new table of the same name, columns, kind and definition, and returns
     * the new one. A statement that changes the table's columns (ALTER TABLE ... ADD COLUMN) changes the new table,
     * so a statement placed before it keeps the table it found there, with the columns it had then. The new table is
     * complete before the schema holds it.
     *
     * @return the table the schema now holds under this table's name
     */
    public TSQLTable newVersion(){
        // Made from the spellings this table and its columns were made from, so each is stored and keyed as here.
        TSQLTable next = new TSQLTable(getSchema(), getNameKeepCase(), true);
        next.setPriority(getPriority());
        next.setView(isView());
        next.setDefinition(getDefinition());
        Map<CanonKey, TSQLColumn> m = next.columnMap();
        synchronized (m) {
            for (TSQLColumn column : getColumnList()) {
                TSQLColumn copy = new TSQLColumn(next, column.getNameKeepCase(), column.getColumnDataType());
                copy.setUnresolvedStar(column.isUnresolvedStar());
                m.put(next.columnKey(copy.getName(), IdentifierInputForm.CATALOG_STORED), copy);
            }
        }
        getSchema().addSchemaObject(next);
        return next;
    }

    public boolean searchColumn(String columnName){
        return getColumn(columnName) != null;
    }

    /**
     * Whether every column of the table is known: it has columns, and none is a star it could not expand
     * ({@link #addUnresolvedStar()}). Only then does {@link #searchColumn} returning false prove the table has no
     * column of that name.
     *
     * @return true when the column list is complete
     */
    public boolean hasAllColumnsKnown(){
        List<TSQLColumn> columns = getColumnList();
        if (columns.isEmpty()) return false;
        for (TSQLColumn column : columns) {
            if ((column == null) || column.isUnresolvedStar()) return false;
        }
        return true;
    }

    public TSQLColumn getColumn(String columnName){
        return columnMap().get(columnKey(columnName, IdentifierInputForm.SQL_LEXICAL));
    }

    /**
     * Gives the column {@code columnName} the data type {@code columnDataType} when the column has none: another
     * definition of the table that knows the type completes the column, as when metadata from several files is
     * merged. A type the column already has is kept, and nothing happens when the table has no such column.
     *
     * @param columnName column name, as for {@link #addColumn(String, TTypeName)}
     * @param columnDataType the type; nothing happens when it is null
     */
    public void fillColumnDataType(String columnName, TTypeName columnDataType){
        if (columnDataType == null) return;
        Map<CanonKey, TSQLColumn> m = columnMap();
        synchronized (m) {
            checkNotSealed();
            TSQLColumn column = m.get(columnKey(columnName, IdentifierInputForm.SQL_LEXICAL));
            if ((column != null) && (column.getColumnDataType() == null)){
                column.setColumnDataType(columnDataType);
            }
        }
    }

    private CanonKey columnKey(String name, IdentifierInputForm form) {
        return getIdentifierService().canonKeyOf(name, ESQLDataObjectType.dotColumn, form);
    }

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

        return columns;
    }

}