package gudusoft.gsqlparser.resolver2.scope;

import gudusoft.gsqlparser.nodes.TCTE;
import gudusoft.gsqlparser.nodes.TCTEList;
import gudusoft.gsqlparser.resolver2.ScopeType;
import gudusoft.gsqlparser.resolver2.matcher.DefaultNameMatcher;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.matcher.VendorNameMatcher;
import gudusoft.gsqlparser.resolver2.namespace.CTENamespace;
import gudusoft.gsqlparser.resolver2.namespace.INamespace;
import gudusoft.gsqlparser.sqlenv.ESQLDataObjectType;

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.
     *
     * <p>Cleanup follow-up to S15: route compare through {@link INameMatcher}
     * (sourced from the {@link GlobalScope} at the root of the scope chain)
     * so per-dialect quoted-vs-unquoted rules apply. CTEs are table-like
     * references, so when the matcher is a {@link VendorNameMatcher}, route
     * through {@link ESQLDataObjectType#dotTable} explicitly because BigQuery
     * and MySQL have divergent table-vs-column rules.</p>
     *
     * @param cteName the CTE name to check
     * @return true if CTE exists, false otherwise
     */
    public boolean hasCTE(String cteName) {
        if (cteName == null) {
            return false;
        }

        INameMatcher matcher = findNameMatcher();
        for (String existingName : cteMap.keySet()) {
            if (cteNameMatches(matcher, existingName, cteName)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Get a CTE namespace by name.
     *
     * <p>Cleanup follow-up to S15: see {@link #hasCTE(String)} javadoc for
     * the matcher-routing rationale.</p>
     *
     * @param cteName the CTE name
     * @return the CTENamespace, or null if not found
     */
    public CTENamespace getCTE(String cteName) {
        if (cteName == null) {
            return null;
        }

        INameMatcher matcher = findNameMatcher();
        for (Map.Entry<String, CTENamespace> entry : cteMap.entrySet()) {
            String existingName = entry.getKey();
            if (cteNameMatches(matcher, existingName, cteName)) {
                return entry.getValue();
            }
        }

        return null;
    }

    private static boolean cteNameMatches(INameMatcher matcher, String existingName, String cteName) {
        if (matcher instanceof VendorNameMatcher) {
            return ((VendorNameMatcher) matcher).matches(existingName, cteName, ESQLDataObjectType.dotTable);
        }
        return matcher.matches(existingName, cteName);
    }

    /**
     * Walk the parent chain to find the {@link GlobalScope}'s name matcher.
     * Falls back to {@link DefaultNameMatcher} for synthetic-scope unit tests
     * that do not include a {@code GlobalScope} in the chain.
     */
    private INameMatcher findNameMatcher() {
        IScope cursor = this;
        while (cursor != null && !(cursor instanceof EmptyScope)) {
            if (cursor instanceof GlobalScope) {
                INameMatcher m = ((GlobalScope) cursor).getNameMatcher();
                if (m != null) return m;
                break;
            }
            IScope next = cursor.getParent();
            if (next == cursor) break;
            cursor = next;
        }
        return new DefaultNameMatcher();
    }

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