package gudusoft.gsqlparser.resolver2.model;

import gudusoft.gsqlparser.nodes.TParseTreeNode;
import gudusoft.gsqlparser.resolver2.inference.EvidenceType;

/**
 * Unified evidence model for column resolution.
 *
 * <p>This class consolidates the scattered evidence/confidence information
 * from various resolver components into a single, consistent structure.
 * It provides:
 * <ul>
 *   <li>Structured evidence type (enum, not string magic values)</li>
 *   <li>Confidence weight with clear semantics</li>
 *   <li>Traceability through source location and node</li>
 *   <li>Human-readable messages for debugging</li>
 * </ul>
 *
 * <h3>Confidence Score Semantics</h3>
 * The confidence score represents "how verifiable is this resolution":
 * <ul>
 *   <li><b>1.0 (Definite)</b>: Hard evidence - DDL/metadata/explicit definition</li>
 *   <li><b>~0.9 (High-confidence)</b>: Qualified reference without metadata verification</li>
 *   <li><b>~0.7 (Inferred)</b>: Star column inference, CTE reverse fill</li>
 *   <li><b>~0.5 (Weak)</b>: Context-based guess, should not auto-resolve</li>
 * </ul>
 *
 * @see EvidenceType
 * @see ColumnSource
 */
public class ResolutionEvidence {

    /** Type of evidence */
    private final EvidenceType type;

    /** Confidence weight [0.0, 1.0] */
    private final double weight;

    /** Human-readable description of how evidence was obtained */
    private final String message;

    /** Location in source where this evidence originates */
    private final SourceLocation location;

    /** The AST node that provides this evidence (optional, for debugging) */
    private final TParseTreeNode sourceNode;

    /**
     * Create a new ResolutionEvidence with all fields.
     *
     * @param type The evidence type
     * @param weight Confidence weight [0.0, 1.0]
     * @param message Human-readable description
     * @param location Source location
     * @param sourceNode The AST node (optional)
     */
    public ResolutionEvidence(EvidenceType type, double weight, String message,
                               SourceLocation location, TParseTreeNode sourceNode) {
        this.type = type != null ? type : EvidenceType.INFERRED_FROM_USAGE;
        this.weight = Math.max(0.0, Math.min(1.0, weight));
        this.message = message;
        this.location = location;
        this.sourceNode = sourceNode;
    }

    /**
     * Create a ResolutionEvidence without source node.
     */
    public ResolutionEvidence(EvidenceType type, double weight, String message, SourceLocation location) {
        this(type, weight, message, location, null);
    }

    /**
     * Create a ResolutionEvidence from an AST node.
     */
    public ResolutionEvidence(EvidenceType type, double weight, String message, TParseTreeNode node) {
        this(type, weight, message, node != null ? new SourceLocation(node) : null, node);
    }

    /**
     * Create a simple ResolutionEvidence with just type and weight.
     */
    public ResolutionEvidence(EvidenceType type, double weight) {
        this(type, weight, null, (SourceLocation) null, null);
    }

    // ========== Factory Methods for Common Evidence Types ==========

    /**
     * Create evidence for metadata-backed resolution (DDL, SQLEnv).
     * Confidence: 1.0 (definite)
     */
    public static ResolutionEvidence fromMetadata(String tableName, String columnName, TParseTreeNode node) {
        return new ResolutionEvidence(
            EvidenceType.METADATA,
            1.0,
            "Column '" + columnName + "' found in metadata for table '" + tableName + "'",
            node
        );
    }

    /**
     * Create evidence for DDL-defined column (CREATE TABLE in same script).
     * Confidence: 1.0 (definite)
     */
    public static ResolutionEvidence fromDDL(String tableName, String columnName, TParseTreeNode node) {
        return new ResolutionEvidence(
            EvidenceType.METADATA,
            1.0,
            "Column '" + columnName + "' defined in DDL for table '" + tableName + "'",
            node
        );
    }

    /**
     * Create evidence for qualified reference (table.column).
     * Confidence: 0.95 if we have metadata, 0.9 otherwise
     */
    public static ResolutionEvidence fromQualifiedReference(String tableName, String columnName,
                                                             boolean hasMetadata, TParseTreeNode node) {
        double confidence = hasMetadata ? 0.95 : 0.9;
        return new ResolutionEvidence(
            EvidenceType.QUALIFIED_REFERENCE,
            confidence,
            "Qualified reference: " + tableName + "." + columnName,
            node
        );
    }

    /**
     * Create evidence for unqualified reference.
     * Confidence depends on number of tables in scope.
     */
    public static ResolutionEvidence fromUnqualifiedReference(String columnName, int tableCount,
                                                               TParseTreeNode node) {
        double confidence = tableCount == 1 ? 0.8 : 0.5;
        return new ResolutionEvidence(
            EvidenceType.UNQUALIFIED_REFERENCE,
            confidence,
            "Unqualified reference: " + columnName + " (" + tableCount + " tables in scope)",
            node
        );
    }

    /**
     * Create evidence for CTE explicit column list.
     * Confidence: 1.0 (explicit definition)
     */
    public static ResolutionEvidence fromCTEExplicitColumn(String cteName, String columnName,
                                                            TParseTreeNode node) {
        return new ResolutionEvidence(
            EvidenceType.CTE_COLUMN_LIST,
            1.0,
            "Explicit CTE column: " + cteName + "(" + columnName + ")",
            node
        );
    }

    /**
     * Create evidence for CTE implicit column (from subquery).
     * Confidence: 1.0 (defined in subquery)
     */
    public static ResolutionEvidence fromCTEImplicitColumn(String cteName, String columnName,
                                                            TParseTreeNode node) {
        return new ResolutionEvidence(
            EvidenceType.SUBQUERY_RESULT,
            1.0,
            "CTE implicit column from subquery: " + cteName + "." + columnName,
            node
        );
    }

    /**
     * Create evidence for star column inference (outer reference pushdown).
     * Confidence: 0.7-0.9 depending on context
     */
    public static ResolutionEvidence fromStarInference(String columnName, String namespaceName,
                                                        boolean isQualified, TParseTreeNode node) {
        double confidence = isQualified ? 0.9 : 0.7;
        return new ResolutionEvidence(
            EvidenceType.INFERRED_FROM_USAGE,
            confidence,
            "Inferred from outer reference to star namespace: " + namespaceName + "." + columnName,
            node
        );
    }

    /**
     * Create evidence for JOIN condition.
     * Confidence: 0.9 (explicit relationship)
     */
    public static ResolutionEvidence fromJoinCondition(String tableName, String columnName,
                                                        TParseTreeNode node) {
        return new ResolutionEvidence(
            EvidenceType.JOIN_CONDITION,
            0.9,
            "JOIN condition: " + tableName + "." + columnName,
            node
        );
    }

    /**
     * Create evidence for INSERT column list.
     * Confidence: 1.0 (explicit definition)
     */
    public static ResolutionEvidence fromInsertColumnList(String tableName, String columnName,
                                                           TParseTreeNode node) {
        return new ResolutionEvidence(
            EvidenceType.INSERT_COLUMN_LIST,
            1.0,
            "INSERT column: " + tableName + "." + columnName,
            node
        );
    }

    /**
     * Create evidence for UPDATE SET clause.
     * Confidence: 0.95 (explicit assignment)
     */
    public static ResolutionEvidence fromUpdateSet(String tableName, String columnName,
                                                    TParseTreeNode node) {
        return new ResolutionEvidence(
            EvidenceType.UPDATE_SET,
            0.95,
            "UPDATE SET: " + tableName + "." + columnName,
            node
        );
    }

    /**
     * Create evidence for SELECT list.
     * Confidence: 0.85
     */
    public static ResolutionEvidence fromSelectList(String tableName, String columnName,
                                                     TParseTreeNode node) {
        return new ResolutionEvidence(
            EvidenceType.SELECT_LIST,
            0.85,
            "SELECT list: " + tableName + "." + columnName,
            node
        );
    }

    /**
     * Create evidence for struct field access (BigQuery/Snowflake).
     * Confidence: inherits from base column resolution
     */
    public static ResolutionEvidence fromStructFieldAccess(String baseColumn, String fieldPath,
                                                            double baseConfidence, TParseTreeNode node) {
        return new ResolutionEvidence(
            EvidenceType.INFERRED_FROM_USAGE,
            baseConfidence,
            "Struct field access: " + baseColumn + "." + fieldPath,
            node
        );
    }

    /**
     * Create evidence for guess strategy application.
     * Confidence: 0.7 (guessed from candidates)
     */
    public static ResolutionEvidence fromGuessStrategy(String columnName, String chosenTable,
                                                        String strategy, TParseTreeNode node) {
        return new ResolutionEvidence(
            EvidenceType.INFERRED_FROM_USAGE,
            0.7,
            "Guessed by " + strategy + " strategy: " + chosenTable + "." + columnName,
            node
        );
    }

    /**
     * Create evidence from legacy string evidence.
     * This is for backward compatibility during migration.
     *
     * @deprecated Use specific factory methods instead
     */
    @Deprecated
    public static ResolutionEvidence fromLegacyEvidence(String legacyEvidence, double confidence,
                                                         TParseTreeNode node) {
        EvidenceType type = inferTypeFromLegacyEvidence(legacyEvidence);
        return new ResolutionEvidence(type, confidence, legacyEvidence, node);
    }

    /**
     * Infer EvidenceType from legacy string evidence.
     */
    private static EvidenceType inferTypeFromLegacyEvidence(String evidence) {
        if (evidence == null) {
            return EvidenceType.INFERRED_FROM_USAGE;
        }

        String lower = evidence.toLowerCase();

        if (lower.contains("metadata") || lower.contains("ddl") || lower.contains("sqlenv")) {
            return EvidenceType.METADATA;
        }
        if (lower.contains("qualified") || lower.contains("table.column")) {
            return EvidenceType.QUALIFIED_REFERENCE;
        }
        if (lower.contains("cte_explicit")) {
            return EvidenceType.CTE_COLUMN_LIST;
        }
        if (lower.contains("cte_implicit") || lower.contains("subquery")) {
            return EvidenceType.SUBQUERY_RESULT;
        }
        if (lower.contains("join")) {
            return EvidenceType.JOIN_CONDITION;
        }
        if (lower.contains("insert")) {
            return EvidenceType.INSERT_COLUMN_LIST;
        }
        if (lower.contains("update") || lower.contains("set")) {
            return EvidenceType.UPDATE_SET;
        }
        if (lower.contains("select")) {
            return EvidenceType.SELECT_LIST;
        }
        if (lower.contains("outer_reference") || lower.contains("star") || lower.contains("inferred")) {
            return EvidenceType.INFERRED_FROM_USAGE;
        }

        return EvidenceType.UNQUALIFIED_REFERENCE;
    }

    // ========== Getters ==========

    public EvidenceType getType() {
        return type;
    }

    public double getWeight() {
        return weight;
    }

    public String getMessage() {
        return message;
    }

    public SourceLocation getLocation() {
        return location;
    }

    public TParseTreeNode getSourceNode() {
        return sourceNode;
    }

    // ========== Utility Methods ==========

    /**
     * Check if this evidence represents a definite resolution.
     * Definite means confidence >= 1.0 (has hard evidence like DDL/metadata).
     */
    public boolean isDefinite() {
        return weight >= 1.0;
    }

    /**
     * Check if this evidence represents a high-confidence resolution.
     * High-confidence means confidence >= 0.9.
     */
    public boolean isHighConfidence() {
        return weight >= 0.9;
    }

    /**
     * Check if this evidence represents an inferred resolution.
     * Inferred means confidence < 1.0 or type is INFERRED_FROM_USAGE.
     */
    public boolean isInferred() {
        return weight < 1.0 || type == EvidenceType.INFERRED_FROM_USAGE;
    }

    /**
     * Create a copy with updated weight.
     */
    public ResolutionEvidence withWeight(double newWeight) {
        return new ResolutionEvidence(type, newWeight, message, location, sourceNode);
    }

    /**
     * Create a copy with appended message.
     */
    public ResolutionEvidence withAppendedMessage(String additionalMessage) {
        String newMessage = message != null
            ? message + "; " + additionalMessage
            : additionalMessage;
        return new ResolutionEvidence(type, weight, newMessage, location, sourceNode);
    }

    /**
     * Convert to legacy string evidence format.
     * For backward compatibility with existing code.
     */
    public String toLegacyEvidence() {
        // Map type to legacy string
        switch (type) {
            case METADATA:
                if (message != null && message.toLowerCase().contains("ddl")) {
                    return "ddl_metadata";
                }
                return "metadata";
            case QUALIFIED_REFERENCE:
                return "qualified_reference";
            case UNQUALIFIED_REFERENCE:
                return "unqualified_reference";
            case CTE_COLUMN_LIST:
                return "cte_explicit_column";
            case SUBQUERY_RESULT:
                return "cte_implicit_column";
            case JOIN_CONDITION:
                return "join_condition";
            case INSERT_COLUMN_LIST:
                return "insert_column_list";
            case UPDATE_SET:
                return "update_set";
            case SELECT_LIST:
                return "select_list";
            case INFERRED_FROM_USAGE:
                if (message != null) {
                    if (message.contains("outer_reference") || message.contains("outer reference")) {
                        return "outer_reference";
                    }
                    if (message.contains("star")) {
                        return "star_push_down";
                    }
                    if (message.contains("guess") || message.contains("strategy")) {
                        if (message.contains("nearest")) return "guess_strategy_nearest";
                        if (message.contains("farthest")) return "guess_strategy_farthest";
                    }
                    if (message.contains("struct_field") || message.contains("Struct field")) {
                        return "struct_field_access";
                    }
                }
                return "inferred_from_usage";
            default:
                return message != null ? message : "unknown";
        }
    }

    @Override
    public String toString() {
        StringBuilder sb = new StringBuilder();
        sb.append("ResolutionEvidence{type=").append(type);
        sb.append(", weight=").append(String.format("%.2f", weight));
        if (message != null) {
            sb.append(", msg='").append(message).append("'");
        }
        if (location != null) {
            sb.append(", loc=").append(location);
        }
        sb.append("}");
        return sb.toString();
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (!(obj instanceof ResolutionEvidence)) return false;

        ResolutionEvidence other = (ResolutionEvidence) obj;
        return type == other.type &&
               Double.compare(weight, other.weight) == 0 &&
               (message == null ? other.message == null : message.equals(other.message));
    }

    @Override
    public int hashCode() {
        int result = type.hashCode();
        long temp = Double.doubleToLongBits(weight);
        result = 31 * result + (int) (temp ^ (temp >>> 32));
        result = 31 * result + (message != null ? message.hashCode() : 0);
        return result;
    }
}