#!/usr/bin/env python3
"""
Generate comparison report from sandbox test results.
"""

import json
import os
from datetime import datetime

SANDBOX_DIR = os.path.dirname(os.path.abspath(__file__))

def load_results():
    """Load comparison results."""
    results_path = os.path.join(SANDBOX_DIR, 'comparison_results.json')
    with open(results_path) as f:
        return json.load(f)

def analyze_verdicts(results):
    """Analyze verdict distribution across conditions."""
    verdict_counts = {
        "A": {"MAKE_NOW": 0, "HIGH_PRIORITY": 0, "WORTH_MAKING": 0, "NEEDS_RESEARCH": 0, "SKIP": 0, "ERROR": 0},
        "B": {"MAKE_NOW": 0, "HIGH_PRIORITY": 0, "WORTH_MAKING": 0, "NEEDS_RESEARCH": 0, "SKIP": 0, "ERROR": 0},
        "C": {"MAKE_NOW": 0, "HIGH_PRIORITY": 0, "WORTH_MAKING": 0, "NEEDS_RESEARCH": 0, "SKIP": 0, "ERROR": 0},
    }

    for r in results['results']:
        for cond in ["A", "B", "C"]:
            verdict = r["results"][cond].get("verdict", "ERROR")
            # Normalize verdict
            if verdict in verdict_counts[cond]:
                verdict_counts[cond][verdict] += 1
            else:
                verdict_counts[cond]["ERROR"] += 1

    return verdict_counts

def analyze_scores(results):
    """Analyze score distribution across conditions."""
    scores = {"A": [], "B": [], "C": []}

    for r in results['results']:
        for cond in ["A", "B", "C"]:
            score = r["results"][cond].get("score", 0)
            if score > 0:
                scores[cond].append(score)

    return {
        cond: {
            "mean": sum(s) / len(s) if s else 0,
            "max": max(s) if s else 0,
            "min": min(s) if s else 0,
            "scores": s
        }
        for cond, s in scores.items()
    }

def analyze_title_patterns(results):
    """Analyze patterns in title generation."""
    patterns = {
        "A": {"generic_count": 0, "specific_count": 0, "titles": []},
        "B": {"generic_count": 0, "specific_count": 0, "titles": []},
        "C": {"generic_count": 0, "specific_count": 0, "titles": []},
    }

    # Markers of generic titles
    generic_markers = [
        "Here's ", "How to ", "Why Your ", "The ", "A Framework",
        "Decision Tree", "What You Need", "Everything You",
    ]

    # Markers of specific/story-based titles
    specific_markers = [
        "I ", "My ", "He ", "She ", "The time ", "ago",
        "$", "%", "year", "month", "day", "hour",
    ]

    for r in results['results']:
        for cond in ["A", "B", "C"]:
            title = r["results"][cond].get("title", "")
            patterns[cond]["titles"].append(title)

            # Check for generic markers
            is_generic = any(marker.lower() in title.lower() for marker in generic_markers)

            # Check for specific markers
            is_specific = any(marker.lower() in title.lower() for marker in specific_markers)

            if is_specific and not is_generic:
                patterns[cond]["specific_count"] += 1
            elif is_generic:
                patterns[cond]["generic_count"] += 1

    return patterns

def find_best_examples(results):
    """Find the clearest examples where B/C outperformed A."""
    examples = []

    for r in results['results']:
        a = r["results"]["A"]
        b = r["results"]["B"]
        c = r["results"]["C"]

        # Find cases where B or C has MAKE_NOW and A doesn't
        if ("MAKE_NOW" in b.get("verdict", "") or "MAKE_NOW" in c.get("verdict", "")) and "MAKE_NOW" not in a.get("verdict", ""):
            examples.append({
                "test_id": r["test_id"],
                "topics": r["sample_topics"],
                "A": {"title": a["title"], "verdict": a["verdict"], "score": a["score"]},
                "B": {"title": b["title"], "verdict": b["verdict"], "score": b["score"]},
                "C": {"title": c["title"], "verdict": c["verdict"], "score": c["score"]},
            })

    return examples

def generate_report(results):
    """Generate the full comparison report."""
    verdicts = analyze_verdicts(results)
    scores = analyze_scores(results)
    patterns = analyze_title_patterns(results)
    best_examples = find_best_examples(results)

    report = []
    report.append("=" * 80)
    report.append("SANDBOX COMPARISON REPORT: CURIOSITY GAP DIAGNOSIS")
    report.append("=" * 80)
    report.append(f"Generated: {datetime.now().isoformat()}")
    report.append(f"Clusters tested: {len(results['results'])}")
    report.append("")

    # Executive Summary
    report.append("-" * 80)
    report.append("EXECUTIVE SUMMARY")
    report.append("-" * 80)
    report.append("")

    make_now_a = verdicts["A"]["MAKE_NOW"]
    make_now_b = verdicts["B"]["MAKE_NOW"]
    make_now_c = verdicts["C"]["MAKE_NOW"]

    report.append(f"MAKE_NOW verdicts:")
    report.append(f"  Baseline (A):       {make_now_a}/10")
    report.append(f"  Curiosity Mining (B): {make_now_b}/10")
    report.append(f"  Unclustered (C):    {make_now_c}/10")
    report.append("")

    report.append(f"Average hookability score:")
    report.append(f"  Baseline (A):       {scores['A']['mean']:.2f}")
    report.append(f"  Curiosity Mining (B): {scores['B']['mean']:.2f}")
    report.append(f"  Unclustered (C):    {scores['C']['mean']:.2f}")
    report.append("")

    report.append(f"Title pattern analysis:")
    report.append(f"  Baseline (A):       {patterns['A']['generic_count']} generic, {patterns['A']['specific_count']} specific")
    report.append(f"  Curiosity Mining (B): {patterns['B']['generic_count']} generic, {patterns['B']['specific_count']} specific")
    report.append(f"  Unclustered (C):    {patterns['C']['generic_count']} generic, {patterns['C']['specific_count']} specific")
    report.append("")

    # Key Finding
    report.append("-" * 80)
    report.append("KEY FINDING")
    report.append("-" * 80)
    report.append("")

    if make_now_b > make_now_a or make_now_c > make_now_a:
        report.append("✅ HYPOTHESIS SUPPORTED: The revised prompts (B and C) found more")
        report.append("   'MAKE_NOW' quality hooks than the baseline.")
        report.append("")
        report.append("   The current pipeline's clustering + prompt combination appears to be")
        report.append("   abstracting away specific details that create viral hooks.")
    else:
        report.append("❌ HYPOTHESIS NOT SUPPORTED: The baseline performed equally or better.")
    report.append("")

    # Best Examples
    report.append("-" * 80)
    report.append("BEST EXAMPLES: Where B/C Found Better Hooks Than A")
    report.append("-" * 80)
    report.append("")

    for ex in best_examples:
        report.append(f"📊 {ex['test_id']}")
        report.append(f"   Topics: {ex['topics'][:2]}")
        report.append("")
        report.append(f"   [A] BASELINE: \"{ex['A']['title']}\"")
        report.append(f"       Verdict: {ex['A']['verdict']}, Score: {ex['A']['score']}")
        report.append("")
        report.append(f"   [B] CURIOSITY: \"{ex['B']['title']}\"")
        report.append(f"       Verdict: {ex['B']['verdict']}, Score: {ex['B']['score']}")
        report.append("")
        report.append(f"   [C] UNCLUSTERED: \"{ex['C']['title']}\"")
        report.append(f"       Verdict: {ex['C']['verdict']}, Score: {ex['C']['score']}")
        report.append("")
        report.append("-" * 40)
        report.append("")

    # Verdict Distribution
    report.append("-" * 80)
    report.append("VERDICT DISTRIBUTION")
    report.append("-" * 80)
    report.append("")

    for cond, label in [("A", "Baseline"), ("B", "Curiosity Mining"), ("C", "Unclustered")]:
        report.append(f"[{cond}] {label}:")
        for verdict, count in sorted(verdicts[cond].items(), key=lambda x: -x[1]):
            if count > 0:
                report.append(f"    {verdict}: {count}")
        report.append("")

    # All Titles
    report.append("-" * 80)
    report.append("ALL GENERATED TITLES")
    report.append("-" * 80)
    report.append("")

    for r in results['results']:
        report.append(f"📊 {r['test_id']}")
        for cond in ["A", "B", "C"]:
            title = r["results"][cond].get("title", "N/A")
            verdict = r["results"][cond].get("verdict", "N/A")
            score = r["results"][cond].get("score", 0)
            report.append(f"   [{cond}] ({verdict}, {score:.1f}) {title}")
        report.append("")

    # Recommendations
    report.append("-" * 80)
    report.append("RECOMMENDATIONS")
    report.append("-" * 80)
    report.append("")

    if patterns['B']['specific_count'] > patterns['A']['specific_count']:
        report.append("1. ADOPT PROMPT B APPROACH: The 'curiosity mining' prompt consistently")
        report.append("   finds more specific, story-based hooks from the same clustered data.")
        report.append("")

    if make_now_c >= make_now_b:
        report.append("2. CONSIDER REDUCING CLUSTERING: The unclustered approach (C) found")
        report.append("   hooks of comparable or better quality, suggesting clustering may")
        report.append("   be obscuring individual post quality.")
        report.append("")

    report.append("3. HYBRID APPROACH: Consider a two-pass system:")
    report.append("   - First pass: Scan raw posts for 'standout' hooks (specific numbers,")
    report.append("     personal stories, counterintuitive outcomes)")
    report.append("   - Second pass: Cluster remaining posts for theme analysis")
    report.append("   - This preserves both the 'diamond' individual posts and broader patterns")
    report.append("")

    return "\n".join(report)


if __name__ == "__main__":
    results = load_results()
    report = generate_report(results)

    # Print to console
    print(report)

    # Save to file
    report_path = os.path.join(SANDBOX_DIR, 'comparison_report.txt')
    with open(report_path, 'w') as f:
        f.write(report)

    print(f"\n\nReport saved to: {report_path}")