"""Before/after image comparison module."""

from typing import Dict, Any, List, Tuple, Optional
from scoring.engine import ScoreResponse


def compare_scores(original: ScoreResponse, revised: ScoreResponse) -> Dict[str, Any]:
    """
    Compare two scored images and produce delta analysis.
    
    Returns dict with:
        original_overall, revised_overall, delta_overall,
        improvements, regressions, next_recommendations, all_deltas
    """
    orig_scores = original.sub_scores
    rev_scores = revised.sub_scores
    
    # Compute deltas
    all_deltas = {}
    for key in orig_scores:
        if key in rev_scores:
            all_deltas[key] = round(rev_scores[key] - orig_scores[key], 1)
    
    # Identify improvements (>5) and regressions (<-5)
    MEANINGFUL = 5.0
    improvements = [(k, v) for k, v in all_deltas.items() if v > MEANINGFUL]
    regressions = [(k, v) for k, v in all_deltas.items() if v < -MEANINGFUL]
    
    # Sort by magnitude
    improvements.sort(key=lambda x: -x[1])
    regressions.sort(key=lambda x: x[1])
    
    # Next recommendations: weakest sub-scores in revised version
    # Exclude improvement_potential
    filtered_rev = {k: v for k, v in rev_scores.items() if k != "improvement_potential"}
    next_targets = sorted(filtered_rev.items(), key=lambda x: x[1])[:3]
    
    # Build next recommendations
    readable_names = {
        "concept_match": "Concept Match",
        "visual_focus": "Visual Focus",
        "readability": "Readability",
        "complexity_balance": "Complexity Balance",
        "communication_clarity": "Communication Clarity",
        "neural_richness": "Neural Richness",
        "memorability_proxy": "Memorability",
    }
    
    next_recommendations = []
    for name, score in next_targets:
        readable = readable_names.get(name, name)
        next_recommendations.append({
            "sub_score": name,
            "current_score": score,
            "message": f"Further improve {readable.lower()} (currently {score:.0f}/100) — this is your weakest remaining dimension."
        })
    
    return {
        "original_overall": round(original.overall_score, 1),
        "revised_overall": round(revised.overall_score, 1),
        "delta_overall": round(revised.overall_score - original.overall_score, 1),
        "improvements": improvements[:5],
        "regressions": regressions[:5],
        "next_recommendations": next_recommendations,
        "all_deltas": all_deltas,
    }


def format_comparison_result(result: Dict[str, Any]) -> str:
    """Format comparison result as human-readable text."""
    lines = []
    
    orig = result["original_overall"]
    rev = result["revised_overall"]
    delta = result["delta_overall"]
    
    if delta > 0:
        lines.append(f"📈 Overall improved: {orig:.0f} → {rev:.0f} (+{delta:.0f} points)")
    elif delta < 0:
        lines.append(f"📉 Overall decreased: {orig:.0f} → {rev:.0f} ({delta:.0f} points)")
    else:
        lines.append(f"➡️ Overall unchanged: {orig:.0f} → {rev:.0f}")
    
    if result["improvements"]:
        lines.append("\n✅ Improvements:")
        for name, val in result["improvements"]:
            lines.append(f"   • {name}: +{val:.0f} points")
    
    if result["regressions"]:
        lines.append("\n⚠️ Regressions:")
        for name, val in result["regressions"]:
            lines.append(f"   • {name}: {val:.0f} points")
    
    if result["next_recommendations"]:
        lines.append("\n📋 Next recommended edits:")
        for rec in result["next_recommendations"]:
            lines.append(f"   • {rec['message']}")
    
    return "\n".join(lines)