package gudusoft.gsqlparser.resolver2.namespace;

import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.nodes.TTable;
import gudusoft.gsqlparser.resolver2.ColumnLevel;
import gudusoft.gsqlparser.resolver2.matcher.INameMatcher;
import gudusoft.gsqlparser.resolver2.model.ColumnSource;
import gudusoft.gsqlparser.resolver2.inference.InferenceEngine;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * Dynamic namespace for handling SELECT * without metadata.
 *
 * <p>This namespace represents a table or subquery where we have SELECT *
 * but no schema information. It dynamically infers columns based on:
 * - Usage in WHERE clauses
 * - Usage in JOIN conditions
 * - Usage in other parts of the query
 *
 * <p>Example scenario:
 * <pre>
 * -- No metadata available for employees table
 * SELECT * FROM employees e
 * WHERE e.department_id = 10
 *   AND e.salary > 50000
 *
 * DynamicStarSource will infer:
 * - "department_id" column (from WHERE clause)
 * - "salary" column (from WHERE clause)
 * </pre>
 *
 * <p>The inference is done lazily - columns are added as evidence is discovered
 * during resolution. This allows the resolver to handle queries without schema
 * information.
 *
 * <p>Confidence scoring:
 * - Qualified references (t.col): High confidence (0.95)
 * - JOIN conditions: Very high confidence (0.9)
 * - Unqualified references: Lower confidence (0.5-0.8)
 */
public class DynamicStarSource extends AbstractNamespace {

    /** The table this star source represents */
    private final TTable table;

    /** Inference engine for collecting evidence */
    private final InferenceEngine inferenceEngine;

    /** Dynamically discovered columns */
    private final Map<String, ColumnSource> dynamicColumns = new HashMap<>();

    /** Whether this source has been validated (evidence collected) */
    private boolean evidenceCollected = false;

    public DynamicStarSource(TTable table, INameMatcher nameMatcher) {
        super(table, nameMatcher);
        this.table = table;
        this.inferenceEngine = new InferenceEngine();
    }

    /**
     * Get the inference engine for this star source.
     * External code can add evidence to this engine.
     *
     * @return the inference engine
     */
    public InferenceEngine getInferenceEngine() {
        return inferenceEngine;
    }

    /**
     * Add a dynamically inferred column.
     *
     * @param columnName the column name
     * @param confidence the confidence score
     * @param evidence the evidence description
     * @return true if the column was added, false if it already exists
     */
    @Override
    public boolean addInferredColumn(String columnName, double confidence, String evidence) {
        if (columnName == null || columnName.isEmpty()) {
            return false;
        }

        // Check if column already exists
        for (String existing : dynamicColumns.keySet()) {
            if (nameMatcher.matches(existing, columnName)) {
                return false;  // Already exists
            }
        }

        // Create a column source for this inferred column
        ColumnSource columnSource = new ColumnSource(
            this,
            columnName,
            table,  // Use table as definition node
            confidence,
            evidence
        );

        dynamicColumns.put(columnName, columnSource);
        return true;
    }

    /**
     * Add a dynamically inferred column from an existing ColumnSource.
     * This is used for reverse inference (Principle 3: Star Column双向处理).
     *
     * @param columnName the column name
     * @param columnSource the column source with confidence and evidence
     */
    public void addInferredColumn(String columnName, ColumnSource columnSource) {
        if (columnName == null || columnName.isEmpty() || columnSource == null) {
            return;
        }

        dynamicColumns.put(columnName, columnSource);
    }

    /**
     * Infer columns from the inference engine's evidence.
     * This should be called after all evidence has been collected.
     */
    public void inferColumnsFromEvidence() {
        if (evidenceCollected) {
            return;  // Already done
        }

        evidenceCollected = true;

        // Get table name for matching evidence
        String tableName = table.getName();
        if (tableName == null || tableName.isEmpty()) {
            tableName = table.getAliasName();
        }

        if (tableName == null) {
            return;
        }

        // Get all inferred columns for this table
        Set<String> inferredColumns = inferenceEngine.getInferredColumns(tableName);

        for (String columnName : inferredColumns) {
            double confidence = inferenceEngine.calculateConfidence(tableName, columnName);
            ColumnSource columnSource = inferenceEngine.createInferredColumnSource(
                tableName,
                columnName,
                table
            );

            if (columnSource != null) {
                dynamicColumns.put(columnName, columnSource);
            }
        }
    }

    @Override
    protected void doValidate() {
        // Validation for dynamic star source means inferring columns from evidence
        inferColumnsFromEvidence();
    }

    @Override
    public ColumnLevel hasColumn(String columnName) {
        if (columnName == null) {
            return ColumnLevel.NOT_EXISTS;
        }

        // Ensure evidence has been collected
        if (!evidenceCollected) {
            inferColumnsFromEvidence();
        }

        // Check if we have inferred this column
        for (String knownColumn : dynamicColumns.keySet()) {
            if (nameMatcher.matches(knownColumn, columnName)) {
                return ColumnLevel.EXISTS;
            }
        }

        // For dynamic sources, we use MAYBE instead of NOT_EXISTS
        // because the column might exist but we haven't seen evidence yet
        return ColumnLevel.MAYBE;
    }

    @Override
    public ColumnSource resolveColumn(String columnName) {
        if (columnName == null) {
            return null;
        }

        // Ensure evidence has been collected
        if (!evidenceCollected) {
            inferColumnsFromEvidence();
        }

        // Find matching column
        for (Map.Entry<String, ColumnSource> entry : dynamicColumns.entrySet()) {
            if (nameMatcher.matches(entry.getKey(), columnName)) {
                return entry.getValue();
            }
        }

        // Column not found - but for dynamic sources, we could add it with low confidence
        // For now, return null
        return null;
    }

    @Override
    public Map<String, ColumnSource> getAllColumnSources() {
        // Ensure evidence has been collected
        if (!evidenceCollected) {
            inferColumnsFromEvidence();
        }

        return new HashMap<>(dynamicColumns);
    }

    @Override
    public TTable getFinalTable() {
        return table;
    }

    @Override
    public String getDisplayName() {
        String tableName = table.getName() != null ? table.getName() : table.getAliasName();
        return "DynamicStarSource(" + tableName + ")";
    }

    /**
     * Get the number of dynamically inferred columns.
     *
     * @return column count
     */
    public int getInferredColumnCount() {
        return dynamicColumns.size();
    }

    /**
     * Check if any columns have been inferred.
     *
     * @return true if columns were inferred, false otherwise
     */
    public boolean hasInferredColumns() {
        return !dynamicColumns.isEmpty();
    }

    /**
     * Get statistics about this dynamic star source.
     *
     * @return statistics string
     */
    public String getStatistics() {
        return String.format(
            "DynamicStarSource[table=%s, inferred=%d, evidence=%d]",
            table.getName() != null ? table.getName() : table.getAliasName(),
            dynamicColumns.size(),
            inferenceEngine.getEvidenceCount()
        );
    }

    @Override
    public boolean supportsDynamicInference() {
        return true;
    }

    @Override
    public Set<String> getInferredColumns() {
        return new HashSet<>(dynamicColumns.keySet());
    }

    @Override
    public boolean hasStarColumn() {
        // DynamicStarSource represents a star column by definition
        return true;
    }

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