package gudusoft.gsqlparser.resolver2.inference;

import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;

import java.util.*;

/**
 * Engine for inferring column-to-table relationships without metadata.
 *
 * <p>The inference engine collects evidence from various sources in the SQL
 * statement and uses it to infer which columns belong to which tables.
 * This is particularly useful when:
 * - Database metadata is not available
 * - Dealing with SELECT * without schema information
 * - Analyzing SQL from unknown sources
 *
 * <p>Inference process:
 * 1. Collect evidence from SQL statement (WHERE, JOIN, SELECT, etc.)
 * 2. Aggregate evidence by table and column
 * 3. Calculate confidence scores
 * 4. Generate inferred column sources
 *
 * <p>Example:
 * <pre>
 * SELECT * FROM employees e
 * WHERE e.department_id = 10
 *   AND e.salary > 50000
 *
 * Inference:
 * - "department_id" column exists in "employees" (confidence: 0.95)
 * - "salary" column exists in "employees" (confidence: 0.95)
 * </pre>
 */
public class InferenceEngine {

    /** Evidence collected for inference */
    private final List<InferenceEvidence> evidenceList = new ArrayList<>();

    /** Inferred columns by table */
    private final Map<String, Set<String>> inferredColumnsByTable = new HashMap<>();

    /** Evidence aggregated by table.column */
    private final Map<String, List<InferenceEvidence>> evidenceByColumn = new HashMap<>();

    /**
     * Add a piece of evidence for inference.
     *
     * @param evidence the evidence to add
     */
    public void addEvidence(InferenceEvidence evidence) {
        if (evidence == null) {
            return;
        }

        evidenceList.add(evidence);

        // Index by table.column
        String key = makeKey(evidence.getTableName(), evidence.getColumnName());
        evidenceByColumn.computeIfAbsent(key, k -> new ArrayList<>()).add(evidence);

        // Track inferred columns
        inferredColumnsByTable
            .computeIfAbsent(evidence.getTableName(), k -> new HashSet<>())
            .add(evidence.getColumnName());
    }

    /**
     * Add multiple pieces of evidence.
     *
     * @param evidences the evidence to add
     */
    public void addAllEvidence(Collection<InferenceEvidence> evidences) {
        if (evidences != null) {
            for (InferenceEvidence evidence : evidences) {
                addEvidence(evidence);
            }
        }
    }

    /**
     * Get all inferred columns for a table.
     *
     * @param tableName the table name
     * @return set of inferred column names, or empty set if none
     */
    public Set<String> getInferredColumns(String tableName) {
        Set<String> columns = inferredColumnsByTable.get(tableName);
        return columns != null ? new HashSet<>(columns) : Collections.emptySet();
    }

    /**
     * Get all evidence for a specific table.column.
     *
     * @param tableName the table name
     * @param columnName the column name
     * @return list of evidence, or empty list if none
     */
    public List<InferenceEvidence> getEvidence(String tableName, String columnName) {
        String key = makeKey(tableName, columnName);
        List<InferenceEvidence> evidence = evidenceByColumn.get(key);
        return evidence != null ? new ArrayList<>(evidence) : Collections.emptyList();
    }

    /**
     * Calculate the combined confidence for a table.column based on all evidence.
     *
     * <p>Combines multiple pieces of evidence using formula:
     * <pre>
     * combined = 1 - ∏(1 - conf_i)
     * </pre>
     *
     * This means:
     * - Multiple pieces of evidence increase confidence
     * - Evidence is independent (multiplicative combination)
     * - Result is always in [0, 1]
     *
     * @param tableName the table name
     * @param columnName the column name
     * @return combined confidence [0.0, 1.0], or 0.0 if no evidence
     */
    public double calculateConfidence(String tableName, String columnName) {
        List<InferenceEvidence> evidence = getEvidence(tableName, columnName);

        if (evidence.isEmpty()) {
            return 0.0;
        }

        // Combine confidence using complementary probability
        double complementaryProduct = 1.0;
        for (InferenceEvidence ev : evidence) {
            complementaryProduct *= (1.0 - ev.getConfidence());
        }

        return 1.0 - complementaryProduct;
    }

    /**
     * Create an inferred ColumnSource for a table.column.
     *
     * @param tableName the table name
     * @param columnName the column name
     * @param table the TTable object (may be null if not available)
     * @return ColumnSource with inferred confidence, or null if no evidence
     */
    public ColumnSource createInferredColumnSource(
            String tableName,
            String columnName,
            TTable table) {

        List<InferenceEvidence> evidence = getEvidence(tableName, columnName);
        if (evidence.isEmpty()) {
            return null;
        }

        double confidence = calculateConfidence(tableName, columnName);

        // Build evidence description
        StringBuilder evidenceDesc = new StringBuilder();
        evidenceDesc.append("inferred from: ");
        for (int i = 0; i < evidence.size(); i++) {
            if (i > 0) evidenceDesc.append(", ");
            evidenceDesc.append(evidence.get(i).getEvidenceType());
        }

        // Create a namespace-less ColumnSource (we don't have actual metadata)
        // This is a marker that indicates the column was inferred
        return new ColumnSource(
            null,  // namespace not available for inferred columns
            columnName,
            evidence.get(0).getSourceNode(),  // Use first evidence as source
            confidence,
            evidenceDesc.toString()
        ) {
            // Override to return the table we inferred for
            @Override
            public TTable getFinalTable() {
                return table;
            }
        };
    }

    /**
     * Get all tables that have inferred columns.
     *
     * @return set of table names with inferred columns
     */
    public Set<String> getTablesWithInferences() {
        return new HashSet<>(inferredColumnsByTable.keySet());
    }

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

    /**
     * Get total number of inferred columns across all tables.
     *
     * @return inferred column count
     */
    public int getInferredColumnCount() {
        int count = 0;
        for (Set<String> columns : inferredColumnsByTable.values()) {
            count += columns.size();
        }
        return count;
    }

    /**
     * Clear all evidence and inferred columns.
     */
    public void clear() {
        evidenceList.clear();
        inferredColumnsByTable.clear();
        evidenceByColumn.clear();
    }

    /**
     * Get statistics about the inference engine state.
     *
     * @return summary string
     */
    public String getStatistics() {
        return String.format(
            "InferenceEngine[tables=%d, columns=%d, evidence=%d]",
            inferredColumnsByTable.size(),
            getInferredColumnCount(),
            evidenceList.size()
        );
    }

    /**
     * Make a key for indexing table.column evidence.
     */
    private String makeKey(String tableName, String columnName) {
        return tableName + "." + columnName;
    }

    @Override
    public String toString() {
        return getStatistics();
    }
}