package gudusoft.gsqlparser.resolver2.expansion;

import gudusoft.gsqlparser.nodes.TExpression;
import gudusoft.gsqlparser.nodes.TObjectName;
import gudusoft.gsqlparser.nodes.TResultColumn;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * Expands SELECT * to explicit column lists.
 *
 * <p>Star expansion is crucial for:
 * - Understanding exactly which columns are selected
 * - Data lineage tracking
 * - Query refactoring
 * - Schema evolution analysis
 *
 * <p>Supports multiple star expansion scenarios:
 * 1. Simple star: SELECT * FROM t1
 * 2. Qualified star: SELECT t1.* FROM t1 JOIN t2
 * 3. Multiple stars: SELECT t1.*, t2.* FROM t1 JOIN t2
 * 4. Mixed: SELECT t1.*, t2.id FROM t1 JOIN t2
 * 5. Nested: SELECT * FROM (SELECT * FROM t1) sub
 *
 * <p>Example:
 * <pre>
 * -- Input:
 * SELECT * FROM employees
 *
 * -- Expanded (if metadata available):
 * SELECT employees.id, employees.name, employees.salary
 * FROM employees
 * </pre>
 */
public class StarColumnExpander {

    /** Whether to include table qualifiers in expanded columns */
    private final boolean includeTableQualifier;

    /** Whether to expand stars in subqueries recursively */
    private final boolean expandSubqueries;

    public StarColumnExpander() {
        this(true, true);
    }

    public StarColumnExpander(boolean includeTableQualifier, boolean expandSubqueries) {
        this.includeTableQualifier = includeTableQualifier;
        this.expandSubqueries = expandSubqueries;
    }

    /**
     * Expand a star column to explicit column list.
     *
     * @param starColumn the star column (SELECT *)
     * @param namespace the namespace to expand from
     * @return list of expanded columns, or empty if expansion not possible
     */
    public List<ExpandedColumn> expandStar(TResultColumn starColumn, INamespace namespace) {
        List<ExpandedColumn> expandedColumns = new ArrayList<>();

        if (starColumn == null || namespace == null) {
            return expandedColumns;
        }

        // Check if this is actually a star column
        if (!isStarColumn(starColumn)) {
            return expandedColumns;
        }

        // Get all columns from the namespace
        Map<String, ColumnSource> columnSources = namespace.getAllColumnSources();

        if (columnSources == null || columnSources.isEmpty()) {
            return expandedColumns;
        }

        // Create expanded column for each source column
        for (Map.Entry<String, ColumnSource> entry : columnSources.entrySet()) {
            String columnName = entry.getKey();
            ColumnSource source = entry.getValue();

            ExpandedColumn expanded = new ExpandedColumn(
                columnName,
                source,
                starColumn,
                includeTableQualifier
            );

            expandedColumns.add(expanded);
        }

        return expandedColumns;
    }

    /**
     * Expand qualified star (e.g., t1.*) to explicit column list.
     *
     * @param starColumn the star column (SELECT t1.*)
     * @param namespace the namespace to expand from
     * @param tableAlias the table qualifier (e.g., "t1")
     * @return list of expanded columns, or empty if expansion not possible
     */
    public List<ExpandedColumn> expandQualifiedStar(
            TResultColumn starColumn,
            INamespace namespace,
            String tableAlias) {

        List<ExpandedColumn> expandedColumns = new ArrayList<>();

        if (starColumn == null || namespace == null || tableAlias == null) {
            return expandedColumns;
        }

        // Get all columns from the namespace
        Map<String, ColumnSource> columnSources = namespace.getAllColumnSources();

        if (columnSources == null || columnSources.isEmpty()) {
            return expandedColumns;
        }

        // Create expanded column for each source column
        for (Map.Entry<String, ColumnSource> entry : columnSources.entrySet()) {
            String columnName = entry.getKey();
            ColumnSource source = entry.getValue();

            ExpandedColumn expanded = new ExpandedColumn(
                columnName,
                source,
                starColumn,
                tableAlias,
                includeTableQualifier
            );

            expandedColumns.add(expanded);
        }

        return expandedColumns;
    }

    /**
     * Expand all stars in a result column list.
     *
     * @param resultColumns the result columns
     * @param availableNamespaces list of available namespaces to expand from
     * @return expansion result with all expanded columns
     */
    public ExpansionResult expandAllStars(
            List<TResultColumn> resultColumns,
            List<INamespace> availableNamespaces) {

        ExpansionResult result = new ExpansionResult();

        if (resultColumns == null || availableNamespaces == null) {
            return result;
        }

        for (TResultColumn rc : resultColumns) {
            if (isStarColumn(rc)) {
                // This is a star column - expand it
                if (isQualifiedStar(rc)) {
                    // Qualified star: t1.*
                    String tableAlias = getStarQualifier(rc);
                    INamespace targetNamespace = findNamespaceByAlias(
                        availableNamespaces,
                        tableAlias
                    );

                    if (targetNamespace != null) {
                        List<ExpandedColumn> expanded = expandQualifiedStar(
                            rc,
                            targetNamespace,
                            tableAlias
                        );
                        result.addExpandedStar(rc, expanded);
                    } else {
                        result.addUnexpandableStar(rc, "Namespace not found: " + tableAlias);
                    }
                } else {
                    // Unqualified star: *
                    // Expand from all available namespaces
                    List<ExpandedColumn> allExpanded = new ArrayList<>();
                    for (INamespace ns : availableNamespaces) {
                        List<ExpandedColumn> expanded = expandStar(rc, ns);
                        allExpanded.addAll(expanded);
                    }

                    if (!allExpanded.isEmpty()) {
                        result.addExpandedStar(rc, allExpanded);
                    } else {
                        result.addUnexpandableStar(rc, "No columns available for expansion");
                    }
                }
            } else {
                // Not a star column - keep as is
                result.addNonStarColumn(rc);
            }
        }

        return result;
    }

    /**
     * Check if a result column is a star column (* or t.*)
     */
    private boolean isStarColumn(TResultColumn rc) {
        if (rc == null || rc.getExpr() == null) {
            return false;
        }

        TExpression expr = rc.getExpr();
        if (expr.getExpressionType() != gudusoft.gsqlparser.EExpressionType.simple_object_name_t) {
            return false;
        }

        TObjectName objName = expr.getObjectOperand();
        if (objName == null) {
            return false;
        }

        String str = objName.toString();
        return str != null && (str.equals("*") || str.endsWith(".*"));
    }

    /**
     * Check if a star column is qualified (t.*)
     */
    private boolean isQualifiedStar(TResultColumn rc) {
        if (!isStarColumn(rc)) {
            return false;
        }

        TObjectName objName = rc.getExpr().getObjectOperand();
        String str = objName.toString();
        return str != null && str.endsWith(".*") && str.length() > 2;
    }

    /**
     * Get the qualifier from a qualified star (t.* returns "t")
     */
    private String getStarQualifier(TResultColumn rc) {
        if (!isQualifiedStar(rc)) {
            return null;
        }

        TObjectName objName = rc.getExpr().getObjectOperand();
        String str = objName.toString();
        if (str != null && str.endsWith(".*")) {
            return str.substring(0, str.length() - 2);
        }

        return null;
    }

    /**
     * Find a namespace by alias/name
     */
    private INamespace findNamespaceByAlias(List<INamespace> namespaces, String alias) {
        if (namespaces == null || alias == null) {
            return null;
        }

        for (INamespace ns : namespaces) {
            // Check if namespace display name matches
            if (ns.getDisplayName() != null &&
                ns.getDisplayName().equalsIgnoreCase(alias)) {
                return ns;
            }

            // For table namespaces, check table name/alias
            if (ns.getFinalTable() != null) {
                String tableName = ns.getFinalTable().getName();
                String tableAlias = ns.getFinalTable().getAliasName();

                if ((tableName != null && tableName.equalsIgnoreCase(alias)) ||
                    (tableAlias != null && tableAlias.equalsIgnoreCase(alias))) {
                    return ns;
                }
            }
        }

        return null;
    }
}