# smart_coverage.py
import json
import subprocess
from pathlib import Path
from anthropic import Anthropic

client = Anthropic()

def run_coverage(test_command: str = "pytest") -> dict:
    """Run tests with coverage and return the JSON report."""
    subprocess.run(
        [test_command, "--cov=src", "--cov-report=json", "--quiet"],
        check=True,
        capture_output=True
    )
    with open("coverage.json") as f:
        return json.load(f)

def classify_uncovered_lines(
    filepath: str,
    missing_lines: list[int]
) -> dict:
    """Classify missing lines into risk categories using Claude."""
    source_lines = Path(filepath).read_text().splitlines()
    uncovered_snippets = []

    for lineno in missing_lines[:20]:  # Limit to 20 lines per file
        if 0 < lineno <= len(source_lines):
            # Include 2 lines of context
            start = max(0, lineno - 3)
            end = min(len(source_lines), lineno + 2)
            snippet = "\n".join(
                f"{'>>>' if i + 1 == lineno else '   '} {i + 1}: {source_lines[i]}"
                for i in range(start, end)
            )
            uncovered_snippets.append(snippet)

    if not uncovered_snippets:
        return {"risk": "unknown", "categories": []}

    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=800,
        messages=[{
            "role": "user",
            "content": f"""Classify these uncovered code lines by risk category.

File: {filepath}

Uncovered lines (marked with >>>):
{chr(10).join(uncovered_snippets[:5])}

For each uncovered section, classify as:
- CRITICAL: Error handling, security checks, data validation, payment/auth logic
- HIGH: Business logic, state transitions, API request handling
- MEDIUM: Data transformation, utility functions
- LOW: Logging, debug code, UI formatting
- DEAD_CODE: Code that can never execute (always-false conditions, etc.)

Format: LINE: [number] | CATEGORY: [category] | REASON: [1 sentence why]"""
        }]
    )
    return {"analysis": response.content[0].text}

def generate_coverage_pr_comment(coverage_data: dict) -> str:
    """Generate a PR comment explaining coverage changes."""
    # Extract summary stats
    total = coverage_data.get("totals", {})
    covered_pct = total.get("percent_covered", 0)
    missing_lines = total.get("missing_lines", 0)
    num_statements = total.get("num_statements", 0)

    # Find files with low coverage
    files = coverage_data.get("files", {})
    low_coverage_files = [
        {
            "file": filepath,
            "coverage": round(data.get("summary", {}).get("percent_covered", 0), 1),
            "missing": data.get("summary", {}).get("missing_lines", 0)
        }
        for filepath, data in files.items()
        if data.get("summary", {}).get("percent_covered", 100) < 70
        and "test_" not in filepath
    ]
    low_coverage_files.sort(key=lambda x: x["coverage"])

    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=600,
        messages=[{
            "role": "user",
            "content": f"""Write a concise PR coverage comment for a code review.

Overall coverage: {covered_pct:.1f}%
Missing statements: {missing_lines} of {num_statements}

Files below 70% coverage:
{json.dumps(low_coverage_files[:5], indent=2)}

Write a 3-5 sentence comment that:
1. States the coverage percentage
2. Flags the riskiest uncovered files
3. Suggests 1-2 specific tests to add
4. Is constructive, not blocking

Keep it under 100 words. Use markdown."""
        }]
    )
    return response.content[0].text

def generate_coverage_report(output_format: str = "markdown") -> str:
    """Generate a full coverage analysis report."""
    coverage_data = run_coverage()
    total = coverage_data.get("totals", {})

    # Analyze worst-covered files
    files = coverage_data.get("files", {})
    file_analyses = []

    for filepath, data in list(files.items())[:5]:  # Top 5 worst
        if "test_" in filepath:
            continue
        missing = data.get("missing_lines", [])
        if missing:
            analysis = classify_uncovered_lines(filepath, missing)
            file_analyses.append({
                "file": filepath,
                "coverage": round(data.get("summary", {}).get("percent_covered", 0), 1),
                "analysis": analysis
            })

    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=2000,
        messages=[{
            "role": "user",
            "content": f"""Write a coverage analysis report for the engineering team.

Overall: {total.get('percent_covered', 0):.1f}% coverage
({total.get('num_statements', 0)} statements, {total.get('missing_lines', 0)} uncovered)

File analyses:
{json.dumps(file_analyses, indent=2)}

Report sections:
1. Executive Summary (2 sentences)
2. Risk Assessment (what's uncovered and why it matters)
3. Recommended test additions (3 specific tests, with function names)
4. Coverage debt estimate (rough hour estimate to reach 90%)

Format as {output_format}."""
        }]
    )
    return response.content[0].text

def analyze_coverage_trend(history: list[dict]) -> str:
    """Analyze coverage trend over time and predict when targets will be met."""
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=500,
        messages=[{
            "role": "user",
            "content": f"""Analyze this coverage trend and predict future trajectory.

Weekly coverage history:
{json.dumps(history, indent=2)}

Provide:
1. TREND: [Improving/Stable/Declining] with rate
2. PREDICTED_DATE: When will coverage reach 85% at current pace?
3. RISK_PERIODS: Any weeks where coverage dropped significantly?
4. RECOMMENDATION: One specific action to accelerate improvement"""
        }]
    )
    return response.content[0].text

# Example history
coverage_history = [
    {"week": "2026-02-01", "coverage": 71.2, "new_tests": 3},
    {"week": "2026-02-08", "coverage": 72.1, "new_tests": 5},
    {"week": "2026-02-15", "coverage": 71.8, "new_tests": 2},
    {"week": "2026-02-22", "coverage": 73.4, "new_tests": 8},
    {"week": "2026-03-01", "coverage": 74.9, "new_tests": 6},
    {"week": "2026-03-08", "coverage": 76.2, "new_tests": 7},
]

trend = analyze_coverage_trend(coverage_history)
print(trend)

def estimate_coverage_debt(coverage_data: dict, target_pct: float = 90.0) -> str:
    """Estimate engineering hours to reach coverage target."""
    total = coverage_data.get("totals", {})
    current_pct = total.get("percent_covered", 0)
    missing_lines = total.get("missing_lines", 0)
    num_statements = total.get("num_statements", 0)

    lines_needed = int(
        (target_pct / 100 * num_statements) - (current_pct / 100 * num_statements)
    )

    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=400,
        messages=[{
            "role": "user",
            "content": f"""Estimate coverage debt for a software team.

Current coverage: {current_pct:.1f}% ({missing_lines} uncovered statements)
Target: {target_pct}%
Lines that need tests: ~{lines_needed}

Assume:
- Simple unit tests: 15-20 min each, covers 3-8 lines
- Integration tests: 45-90 min each, covers 15-40 lines
- Mix: 70% unit tests, 30% integration tests

Estimate:
1. TOTAL_HOURS: Range in engineer-hours
2. SPRINT_ESTIMATE: At 20% of sprint capacity dedicated to test coverage
3. QUICK_WINS: Which types of tests to write first for best ROI"""
        }]
    )
    return response.content[0].text