package gudusoft.gsqlparser.resolver2.namespace;

import gudusoft.gsqlparser.nodes.TAliasClause;
import gudusoft.gsqlparser.nodes.TMultiTarget;
import gudusoft.gsqlparser.nodes.TMultiTargetList;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TObjectNameList;
import gudusoft.gsqlparser.nodes.TResultColumn;
import gudusoft.gsqlparser.nodes.TResultColumnList;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.nodes.TValueClause;
import gudusoft.gsqlparser.resolver2.ColumnLevel;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;

import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;

/**
 * Namespace representing a VALUES table expression.
 *
 * VALUES tables define inline data with an optional alias and column names.
 * For example:
 * - VALUES (1, 'a'), (2, 'b') AS t(id, name)
 * - In Teradata MERGE: USING VALUES (:empno, :name, :salary) AS s(empno, name, salary)
 *
 * The ValuesNamespace provides columns defined in the alias clause.
 */
public class ValuesNamespace extends AbstractNamespace {

    private final TTable table;
    private final String alias;

    public ValuesNamespace(TTable table, String alias, INameMatcher nameMatcher) {
        super(table, nameMatcher);
        this.table = table;
        this.alias = alias;
    }

    public ValuesNamespace(TTable table, String alias) {
        this(table, alias, null);
    }

    @Override
    public String getDisplayName() {
        // Match test expectations - use "(values_table)" for consistency
        return "(values_table)";
    }

    @Override
    public TTable getFinalTable() {
        return table;
    }

    @Override
    public List<TTable> getAllFinalTables() {
        List<TTable> tables = new ArrayList<>();
        tables.add(table);
        return tables;
    }

    @Override
    protected void doValidate() {
        columnSources = new LinkedHashMap<>();

        // Extract columns from alias clause: AS t(name, empno, salary)
        TAliasClause aliasClause = table.getAliasClause();
        if (aliasClause != null) {
            TObjectNameList columns = aliasClause.getColumns();
            if (columns != null && columns.size() > 0) {
                // Get VALUES expressions from the first row to use as definition nodes
                // This allows sourceColumn to point to the actual VALUE expression (e.g., :empno)
                TResultColumn[] valueExpressions = getValueExpressions();

                for (int i = 0; i < columns.size(); i++) {
                    TObjectName colName = columns.getObjectName(i);
                    if (colName != null) {
                        String name = colName.toString();
                        // Use the corresponding VALUE expression as definition node if available
                        TResultColumn definitionNode = (valueExpressions != null && i < valueExpressions.length)
                            ? valueExpressions[i]
                            : null;

                        ColumnSource source = new ColumnSource(
                            this,
                            name,
                            definitionNode,  // VALUE expression for legacy sourceColumn sync
                            1.0,             // Definite - defined in alias clause
                            "values_alias_column"
                        );
                        columnSources.put(name, source);
                    }
                }
            }
        }
    }

    /**
     * Get the VALUE expressions from the first row of the VALUES clause.
     * These expressions map to the column names in the alias clause.
     *
     * For example: VALUES (:empno, :name, :salary) AS s(empno, name, salary)
     * Returns: [TResultColumn(:empno), TResultColumn(:name), TResultColumn(:salary)]
     *
     * @return Array of TResultColumn from the first row, or null if not available
     */
    private TResultColumn[] getValueExpressions() {
        // First try the preferred method: TValueClause.getRows()
        TValueClause valueClause = table.getValueClause();
        if (valueClause != null && valueClause.getRows() != null && !valueClause.getRows().isEmpty()) {
            TResultColumnList firstRow = valueClause.getRows().get(0);
            if (firstRow != null && firstRow.size() > 0) {
                int size = firstRow.size();
                TResultColumn[] result = new TResultColumn[size];
                for (int i = 0; i < size; i++) {
                    result[i] = firstRow.getResultColumn(i);
                }
                return result;
            }
        }

        // Fallback to deprecated method: TMultiTargetList for older parsers
        TMultiTargetList rowList = table.getRowList();
        if (rowList != null && rowList.size() > 0) {
            TMultiTarget firstRow = rowList.getMultiTarget(0);
            if (firstRow != null && firstRow.getColumnList() != null) {
                int size = firstRow.getColumnList().size();
                TResultColumn[] result = new TResultColumn[size];
                for (int i = 0; i < size; i++) {
                    result[i] = firstRow.getColumnList().getResultColumn(i);
                }
                return result;
            }
        }

        return null;
    }

    @Override
    public boolean hasStarColumn() {
        // VALUES tables don't support star expansion in the traditional sense
        return false;
    }

    @Override
    public boolean supportsDynamicInference() {
        // Columns are fixed by alias clause - don't dynamically infer
        return false;
    }

    @Override
    public ColumnLevel hasColumn(String columnName) {
        ensureValidated();

        // Check explicit columns from alias clause
        if (columnSources != null) {
            for (String existingCol : columnSources.keySet()) {
                if (nameMatcher.matches(existingCol, columnName)) {
                    return ColumnLevel.EXISTS;
                }
            }
        }

        // VALUES tables have a fixed set of columns
        return ColumnLevel.NOT_EXISTS;
    }

    @Override
    public ColumnSource resolveColumn(String columnName) {
        ensureValidated();

        // Resolve from known columns
        ColumnSource source = super.resolveColumn(columnName);
        if (source != null) {
            return source;
        }

        // VALUES tables do NOT auto-infer unknown columns
        return null;
    }

    /**
     * Get the alias for this VALUES table.
     */
    public String getAlias() {
        return alias;
    }

    public TTable getTable() {
        return table;
    }

    @Override
    public String toString() {
        return String.format("ValuesNamespace(%s, columns=%d)",
            alias != null ? alias : "(values_table)",
            columnSources != null ? columnSources.size() : 0);
    }
}