package gudusoft.gsqlparser.resolver2.scope;

import gudusoft.gsqlparser.nodes.TCTE;
import gudusoft.gsqlparser.nodes.TCTEList;
import gudusoft.gsqlparser.resolver2.ScopeType;
import gudusoft.gsqlparser.resolver2.namespace.CTENamespace;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;

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

/**
 * Scope for Common Table Expressions (WITH clause).
 * Manages visibility of CTEs defined in a WITH clause.
 *
 * <p>Example:
 * <pre>
 * WITH
 *   cte1 AS (SELECT id, name FROM users),
 *   cte2 AS (SELECT * FROM cte1 WHERE id > 100)  -- can reference cte1
 * SELECT * FROM cte2;  -- can reference both cte1 and cte2
 * </pre>
 *
 * <p>Key features:
 * - Multiple CTEs in same WITH clause
 * - CTEs can reference earlier CTEs in the same WITH clause
 * - Recursive CTE support (same CTE references itself)
 * - CTEs are visible to the main query and to later CTEs
 */
public class CTEScope extends ListBasedScope {

    /**
     * Map of CTE name to CTENamespace.
     * Preserves insertion order to handle forward references correctly.
     */
    private final Map<String, CTENamespace> cteMap;

    /**
     * The WITH clause CTE list node
     */
    private final TCTEList cteList;

    public CTEScope(IScope parent, TCTEList cteList) {
        super(parent, cteList, ScopeType.CTE);
        this.cteList = cteList;
        this.cteMap = new LinkedHashMap<>();
    }

    /**
     * Add a CTE to this scope.
     * CTEs are added in order, allowing later CTEs to reference earlier ones.
     *
     * @param cteName the CTE name (alias)
     * @param cteNamespace the CTE namespace
     */
    public void addCTE(String cteName, CTENamespace cteNamespace) {
        if (cteName == null || cteNamespace == null) {
            return;
        }

        // Store in map for name resolution
        cteMap.put(cteName, cteNamespace);

        // Add as child to ListBasedScope (makes it visible to parent queries)
        // CTEs are always non-nullable
        addChild(cteNamespace, cteName, false);
    }

    /**
     * Check if a CTE with the given name exists in this scope.
     *
     * @param cteName the CTE name to check
     * @return true if CTE exists, false otherwise
     */
    public boolean hasCTE(String cteName) {
        if (cteName == null) {
            return false;
        }

        // Use case-insensitive matching (standard SQL behavior)
        for (String existingName : cteMap.keySet()) {
            if (existingName.equalsIgnoreCase(cteName)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Get a CTE namespace by name.
     *
     * @param cteName the CTE name
     * @return the CTENamespace, or null if not found
     */
    public CTENamespace getCTE(String cteName) {
        if (cteName == null) {
            return null;
        }

        // Use case-insensitive matching (standard SQL behavior)
        for (Map.Entry<String, CTENamespace> entry : cteMap.entrySet()) {
            String existingName = entry.getKey();
            if (existingName.equalsIgnoreCase(cteName)) {
                return entry.getValue();
            }
        }

        return null;
    }

    /**
     * Get all CTEs in this scope.
     *
     * @return list of all CTE namespaces in definition order
     */
    public List<CTENamespace> getAllCTEs() {
        return new ArrayList<>(cteMap.values());
    }

    /**
     * Get the number of CTEs in this scope.
     *
     * @return CTE count
     */
    public int getCTECount() {
        return cteMap.size();
    }

    /**
     * Resolve a table name, checking CTEs first before delegating to parent.
     * This allows CTEs to shadow real tables.
     *
     * @param tableName the table name to resolve
     * @return the namespace for the CTE or table, or null if not found
     */
    @Override
    public INamespace resolveTable(String tableName) {
        // First check if it's a CTE in this scope
        CTENamespace cte = getCTE(tableName);
        if (cte != null) {
            return cte;
        }

        // Delegate to parent scope (might be a real table)
        return super.resolveTable(tableName);
    }

    /**
     * Check if this scope contains a recursive CTE.
     * A recursive CTE is one that references itself in its definition.
     *
     * @return true if any CTE in this scope is recursive
     */
    public boolean hasRecursiveCTE() {
        for (CTENamespace cte : cteMap.values()) {
            if (cte.isRecursive()) {
                return true;
            }
        }
        return false;
    }

    /**
     * Get all recursive CTEs in this scope.
     *
     * @return list of recursive CTE namespaces
     */
    public List<CTENamespace> getRecursiveCTEs() {
        List<CTENamespace> recursive = new ArrayList<>();
        for (CTENamespace cte : cteMap.values()) {
            if (cte.isRecursive()) {
                recursive.add(cte);
            }
        }
        return recursive;
    }

    public TCTEList getCTEList() {
        return cteList;
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder("CTEScope(");
        sb.append("count=").append(cteMap.size());

        if (!cteMap.isEmpty()) {
            sb.append(", ctes=[");
            boolean first = true;
            for (String cteName : cteMap.keySet()) {
                if (!first) {
                    sb.append(", ");
                }
                sb.append(cteName);
                first = false;
            }
            sb.append("]");
        }

        if (hasRecursiveCTE()) {
            sb.append(", recursive=true");
        }

        sb.append(")");
        return sb.toString();
    }
}