#!/usr/bin/env python3
"""
Run Layer 4 v4 pipeline on top MAKE_NOW premise from each channel.

For each channel:
1. Load opportunities file
2. Find highest weighted_score MAKE_NOW premise
3. Run Script Director → Script Evaluator → (Revise if needed)
4. Save output to output/layer4_{channel}.json
"""

import json
import sys
from pathlib import Path
from datetime import datetime, timezone

# Add project root to path
sys.path.insert(0, str(Path(__file__).parent))

from video_generation import run_layer4_v4_pipeline

OUTPUT_DIR = Path(__file__).parent / "output"

CHANNELS = [
    "why_you_do_that",
    "how_it_actually_works",
    "sixty_second_rabbit_hole",
    "designed_to_trick_you",
    "the_money_thing",
    "what_happens_next",
    "one_minute_history"
]


def find_top_make_now(opportunities_data: dict) -> tuple:
    """Find the MAKE_NOW opportunity with highest weighted_score."""
    opportunities = opportunities_data.get("opportunities", [])

    make_now_opps = [
        (i, opp) for i, opp in enumerate(opportunities)
        if opp.get("verdict") == "MAKE_NOW"
    ]

    if not make_now_opps:
        return None, None

    # Sort by weighted_score descending
    make_now_opps.sort(key=lambda x: x[1].get("weighted_score", 0), reverse=True)

    return make_now_opps[0]  # (index, opportunity)


def run_channel(channel_id: str) -> dict:
    """Run Layer 4 v4 pipeline for top MAKE_NOW in channel."""

    print(f"\n{'='*70}")
    print(f"CHANNEL: {channel_id}")
    print(f"{'='*70}")

    # Load opportunities file
    opp_file = OUTPUT_DIR / f"analysis_opportunities_{channel_id}.json"
    if not opp_file.exists():
        print(f"  [ERROR] File not found: {opp_file}")
        return {"channel": channel_id, "error": "File not found"}

    with open(opp_file, "r") as f:
        data = json.load(f)

    # Find top MAKE_NOW
    idx, opportunity = find_top_make_now(data)

    if opportunity is None:
        print(f"  [ERROR] No MAKE_NOW opportunities found")
        return {"channel": channel_id, "error": "No MAKE_NOW opportunities"}

    premise = opportunity.get("premise", opportunity.get("suggested_title", "Unknown"))
    weighted_score = opportunity.get("weighted_score", 0)

    print(f"  Selected: [{idx}] {premise[:60]}...")
    print(f"  Weighted Score: {weighted_score}")
    print(f"  Research: {'Yes' if opportunity.get('research_completed') else 'No'}")

    # Check for research
    if not opportunity.get("research_completed"):
        print(f"  [WARN] No research data - script quality may be limited")

    # Run v4 pipeline
    print(f"\n  Running Layer 4 v4 Pipeline...")

    try:
        result = run_layer4_v4_pipeline(
            opportunity=opportunity,
            channel_id=channel_id,
            target_duration=90,
            max_iterations=2
        )
    except Exception as e:
        print(f"  [ERROR] Pipeline failed: {e}")
        return {
            "channel": channel_id,
            "premise": premise,
            "error": str(e)
        }

    # Extract results
    script = result.get("script", {})
    evaluation = result.get("evaluation", {})

    composite_score = evaluation.get("composite_score", 0)
    verdict = evaluation.get("verdict", "UNKNOWN")
    iteration_count = result.get("iteration_count", 1)
    production_ready = result.get("production_ready", False)
    critical_failures = evaluation.get("critical_failures", [])

    print(f"\n  Results:")
    print(f"    Iterations: {iteration_count}")
    print(f"    Composite Score: {composite_score:.2f}")
    print(f"    Verdict: {verdict}")
    print(f"    Production Ready: {production_ready}")
    if critical_failures:
        print(f"    Critical Failures: {len(critical_failures)}")
        for cf in critical_failures[:3]:  # Show first 3
            print(f"      - {cf.get('dimension')}: {cf.get('issue', '')[:60]}")

    # Save output
    output_file = OUTPUT_DIR / f"layer4_{channel_id}.json"
    output_data = {
        "channel": channel_id,
        "premise": premise,
        "opportunity_index": idx,
        "weighted_score": weighted_score,
        "script": script,
        "evaluation": evaluation,
        "director_metadata": result.get("director_metadata"),
        "evaluator_metadata": result.get("evaluator_metadata"),
        "iteration_count": iteration_count,
        "all_iterations": result.get("all_iterations", []),
        "production_ready": production_ready,
        "generated_at": datetime.now(timezone.utc).isoformat()
    }

    with open(output_file, "w") as f:
        json.dump(output_data, f, indent=2)

    print(f"\n  Saved: {output_file}")

    return {
        "channel": channel_id,
        "premise": premise,
        "weighted_score": weighted_score,
        "composite_score": composite_score,
        "verdict": verdict,
        "iteration_count": iteration_count,
        "production_ready": production_ready,
        "critical_failures": [cf.get("dimension") for cf in critical_failures],
        "output_file": str(output_file)
    }


def main():
    print("="*70)
    print("LAYER 4 v4 - TOP MAKE_NOW FROM EACH CHANNEL")
    print("="*70)
    print(f"Started: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    print(f"Channels: {len(CHANNELS)}")

    results = []

    for channel_id in CHANNELS:
        # Check if already completed
        output_file = OUTPUT_DIR / f"layer4_{channel_id}.json"
        if output_file.exists():
            print(f"\n[SKIP] {channel_id} - already completed, loading existing result")
            with open(output_file, "r") as f:
                existing = json.load(f)
            evaluation = existing.get("evaluation", {})
            results.append({
                "channel": channel_id,
                "premise": existing.get("premise", "?"),
                "weighted_score": existing.get("weighted_score", 0),
                "composite_score": evaluation.get("composite_score", 0),
                "verdict": evaluation.get("verdict", "?"),
                "iteration_count": existing.get("iteration_count", 1),
                "production_ready": existing.get("production_ready", False),
                "critical_failures": [cf.get("dimension") for cf in evaluation.get("critical_failures", [])],
                "output_file": str(output_file),
                "skipped": True
            })
            continue

        result = run_channel(channel_id)
        results.append(result)

    # Summary table
    print("\n")
    print("="*100)
    print("SUMMARY TABLE")
    print("="*100)
    print(f"{'Channel':<25} {'Premise':<30} {'Score':>6} {'Verdict':<18} {'Iter':>4} {'Failures'}")
    print("-"*100)

    for r in results:
        if "error" in r:
            print(f"{r['channel']:<25} ERROR: {r['error'][:60]}")
            continue

        premise_short = r['premise'][:28] + ".." if len(r['premise']) > 30 else r['premise']
        failures = ", ".join(r.get('critical_failures', [])[:2]) or "None"
        if len(failures) > 25:
            failures = failures[:22] + "..."

        print(f"{r['channel']:<25} {premise_short:<30} {r['composite_score']:>5.2f} {r['verdict']:<18} {r['iteration_count']:>4} {failures}")

    print("-"*100)

    # Stats
    successful = [r for r in results if "error" not in r]
    production_ready = [r for r in successful if r.get("production_ready")]

    print(f"\nTotal: {len(results)} channels")
    print(f"Successful: {len(successful)}")
    print(f"Production Ready: {len(production_ready)}")
    print(f"Average Score: {sum(r['composite_score'] for r in successful) / len(successful):.2f}" if successful else "N/A")

    # Save summary
    summary_file = OUTPUT_DIR / "layer4_summary.json"
    with open(summary_file, "w") as f:
        json.dump({
            "generated_at": datetime.now(timezone.utc).isoformat(),
            "channels_processed": len(results),
            "successful": len(successful),
            "production_ready": len(production_ready),
            "results": results
        }, f, indent=2)

    print(f"\nSummary saved: {summary_file}")


if __name__ == "__main__":
    main()