package gudusoft.gsqlparser.resolver2.inference;

import gudusoft.gsqlparser.EExpressionType;
import gudusoft.gsqlparser.nodes.*;
import gudusoft.gsqlparser.stmt.TSelectSqlStatement;

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

/**
 * Collects evidence for column inference from SQL statements.
 *
 * <p>The collector traverses various parts of SQL statements to gather
 * evidence about which columns belong to which tables. This is used
 * by the InferenceEngine to make educated guesses about column sources
 * when metadata is not available.
 *
 * <p>Evidence sources:
 * - WHERE clause: qualified and unqualified column references
 * - JOIN conditions: columns used in join predicates
 * - SELECT list: columns and expressions
 * - GROUP BY: grouped columns
 * - ORDER BY: sort columns
 * - INSERT statements: column lists
 * - UPDATE statements: SET clauses
 *
 * <p>Example:
 * <pre>
 * SELECT * FROM employees e
 * WHERE e.department_id = 10
 *
 * Evidence collected:
 * - "department_id" in "employees" (from qualified WHERE reference)
 * </pre>
 */
public class EvidenceCollector {

    /** Collected evidence */
    private final List<InferenceEvidence> evidence = new ArrayList<>();

    /**
     * Collect evidence from a SELECT statement.
     *
     * @param select the SELECT statement
     * @return list of collected evidence
     */
    public List<InferenceEvidence> collectFromSelect(TSelectSqlStatement select) {
        evidence.clear();

        if (select == null) {
            return new ArrayList<>(evidence);
        }

        // Collect from WHERE clause
        if (select.getWhereClause() != null &&
            select.getWhereClause().getCondition() != null) {
            collectFromExpression(select.getWhereClause().getCondition());
        }

        // Collect from JOIN conditions
        if (select.joins != null && select.joins.size() > 0) {
            collectFromJoins(select.joins);
        }

        // Collect from SELECT list
        if (select.getResultColumnList() != null) {
            collectFromResultColumns(select.getResultColumnList());
        }

        // Collect from GROUP BY
        if (select.getGroupByClause() != null &&
            select.getGroupByClause().getItems() != null) {
            collectFromGroupBy(select.getGroupByClause());
        }

        // Collect from HAVING
        if (select.getGroupByClause() != null &&
            select.getGroupByClause().getHavingClause() != null) {
            collectFromExpression(select.getGroupByClause().getHavingClause());
        }

        // Collect from ORDER BY
        if (select.getOrderbyClause() != null &&
            select.getOrderbyClause().getItems() != null) {
            collectFromOrderBy(select.getOrderbyClause());
        }

        return new ArrayList<>(evidence);
    }

    /**
     * Collect evidence from an expression (WHERE, HAVING, etc.).
     */
    private void collectFromExpression(TExpression expr) {
        if (expr == null) {
            return;
        }

        // Get all column references in the expression
        List<TObjectName> columns = expr.getColumnsInsideExpression();
        if (columns == null) {
            return;
        }

        for (TObjectName objName : columns) {
            collectFromObjectName(objName);
        }
    }

    /**
     * Collect evidence from a TObjectName (column reference).
     */
    private void collectFromObjectName(TObjectName objName) {
        if (objName == null) {
            return;
        }

        String columnName = objName.getColumnNameOnly();
        if (columnName == null || columnName.isEmpty()) {
            return;
        }

        // Check if it's a qualified reference (table.column)
        if (objName.getTableString() != null && !objName.getTableString().isEmpty()) {
            String tableName = objName.getTableString();
            evidence.add(InferenceEvidence.fromQualifiedReference(
                columnName,
                tableName,
                objName
            ));
        } else {
            // Unqualified reference - we can't determine table without context
            // This would need to be handled by the resolver with scope information
            // For now, we skip unqualified references in evidence collection
        }
    }

    /**
     * Collect evidence from JOIN conditions.
     */
    private void collectFromJoins(TJoinList joins) {
        if (joins == null) {
            return;
        }

        for (int i = 0; i < joins.size(); i++) {
            TJoin join = joins.getJoin(i);
            if (join == null) {
                continue;
            }

            // Collect from join items
            if (join.getJoinItems() != null) {
                for (int j = 0; j < join.getJoinItems().size(); j++) {
                    TJoinItem joinItem = join.getJoinItems().getJoinItem(j);
                    if (joinItem == null) {
                        continue;
                    }

                    // Collect from ON condition
                    if (joinItem.getOnCondition() != null) {
                        List<TObjectName> columns = joinItem.getOnCondition().getColumnsInsideExpression();
                        if (columns != null) {
                            for (TObjectName objName : columns) {
                                if (objName.getTableString() != null && !objName.getTableString().isEmpty()) {
                                    evidence.add(InferenceEvidence.fromJoinCondition(
                                        objName.getColumnNameOnly(),
                                        objName.getTableString(),
                                        objName
                                    ));
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * Collect evidence from SELECT list.
     */
    private void collectFromResultColumns(TResultColumnList resultColumns) {
        if (resultColumns == null) {
            return;
        }

        for (int i = 0; i < resultColumns.size(); i++) {
            TResultColumn rc = resultColumns.getResultColumn(i);
            if (rc == null || rc.getExpr() == null) {
                continue;
            }

            // Skip star columns for now (handled separately)
            if (rc.getExpr().getExpressionType() == EExpressionType.simple_object_name_t) {
                TObjectName objName = rc.getExpr().getObjectOperand();
                if (objName != null && !objName.toString().endsWith("*")) {
                    collectFromObjectName(objName);
                }
            } else {
                // Collect from complex expressions
                collectFromExpression(rc.getExpr());
            }
        }
    }

    /**
     * Collect evidence from GROUP BY clause.
     */
    private void collectFromGroupBy(TGroupBy groupBy) {
        if (groupBy == null || groupBy.getItems() == null) {
            return;
        }

        for (int i = 0; i < groupBy.getItems().size(); i++) {
            TGroupByItem item = groupBy.getItems().getGroupByItem(i);
            if (item != null && item.getExpr() != null) {
                collectFromExpression(item.getExpr());
            }
        }
    }

    /**
     * Collect evidence from ORDER BY clause.
     */
    private void collectFromOrderBy(TOrderBy orderBy) {
        if (orderBy == null || orderBy.getItems() == null) {
            return;
        }

        for (int i = 0; i < orderBy.getItems().size(); i++) {
            TOrderByItem item = orderBy.getItems().getOrderByItem(i);
            if (item != null && item.getSortKey() != null) {
                collectFromExpression(item.getSortKey());
            }
        }
    }

    /**
     * Get all collected evidence.
     *
     * @return list of evidence
     */
    public List<InferenceEvidence> getEvidence() {
        return new ArrayList<>(evidence);
    }

    /**
     * Clear all collected evidence.
     */
    public void clear() {
        evidence.clear();
    }

    /**
     * Get count of collected evidence.
     *
     * @return evidence count
     */
    public int getEvidenceCount() {
        return evidence.size();
    }
}