# scripts/ai_coverage_gap.py
"""
Reads coverage.json, finds uncovered functions, and uses Claude
to generate missing test cases.
"""
import json
import os
import ast
from pathlib import Path
from anthropic import Anthropic

client = Anthropic()

def load_coverage_report(path: str = "coverage.json") -> dict:
    with open(path) as f:
        return json.load(f)

def find_uncovered_functions(
    coverage_data: dict,
    threshold: float = 0.80
) -> list[dict]:
    """Return functions with coverage below threshold."""
    gaps = []

    for filepath, file_data in coverage_data["files"].items():
        if "test_" in filepath or "/tests/" in filepath:
            continue

        missing_lines = set(file_data.get("missing_lines", []))
        if not missing_lines:
            continue

        # Parse AST to find function boundaries
        try:
            source = Path(filepath).read_text()
            tree = ast.parse(source)
        except Exception:
            continue

        for node in ast.walk(tree):
            if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
                continue

            func_lines = set(range(node.lineno, node.end_lineno + 1))
            uncovered = func_lines & missing_lines
            coverage_pct = 1 - len(uncovered) / len(func_lines) if func_lines else 1.0

            if coverage_pct < threshold:
                # Extract function source
                source_lines = source.split("\n")
                func_source = "\n".join(
                    source_lines[node.lineno - 1:node.end_lineno]
                )
                gaps.append({
                    "file": filepath,
                    "function": node.name,
                    "coverage": round(coverage_pct, 2),
                    "missing_lines": sorted(uncovered),
                    "source": func_source
                })

    return sorted(gaps, key=lambda x: x["coverage"])

def generate_tests_for_function(gap: dict) -> str:
    """Ask Claude to write tests for an uncovered function."""
    prompt = f"""Write pytest test cases for this Python function.
The function currently has {int(gap['coverage'] * 100)}% coverage.
Missing lines: {gap['missing_lines']}

Focus on:
1. The uncovered branches (error cases, edge inputs, boundary values)
2. Each test should test one specific scenario
3. Use descriptive test names that explain the scenario
4. Include any necessary fixtures or mocks as inline setup

Function from {gap['file']}:
```python
{gap['source']}

# AI-generated tests for process_refund
import pytest
from unittest.mock import patch, MagicMock
from src.payment_processor import process_refund, RefundLimitExceeded, TransactionNotFound

class TestProcessRefund:
    def test_raises_when_transaction_id_empty(self):
        with pytest.raises(ValueError, match="transaction_id is required"):
            process_refund("", 50.0, "customer request")

    def test_raises_when_amount_zero(self):
        with pytest.raises(ValueError, match="must be positive"):
            process_refund("txn_123", 0, "test")

    def test_raises_when_amount_negative(self):
        with pytest.raises(ValueError, match="must be positive"):
            process_refund("txn_123", -10.0, "test")

    def test_raises_when_amount_exceeds_limit(self):
        with pytest.raises(RefundLimitExceeded):
            process_refund("txn_123", 999999.0, "large refund")

    def test_raises_when_transaction_not_found(self):
        with patch("src.payment_processor.db") as mock_db:
            mock_db.get_transaction.return_value = None
            with pytest.raises(TransactionNotFound):
                process_refund("txn_missing", 50.0, "test")

    def test_returns_already_refunded_for_duplicate(self):
        with patch("src.payment_processor.db") as mock_db:
            mock_txn = MagicMock()
            mock_txn.status = "refunded"
            mock_db.get_transaction.return_value = mock_txn
            result = process_refund("txn_123", 50.0, "duplicate")
            assert result["status"] == "already_refunded"

    def test_successful_refund_returns_refund_id(self):
        with patch("src.payment_processor.db") as mock_db, \
             patch("src.payment_processor.payment_gateway") as mock_gw, \
             patch("src.payment_processor.audit_log"):
            mock_txn = MagicMock()
            mock_txn.status = "completed"
            mock_db.get_transaction.return_value = mock_txn
            mock_gw.refund.return_value = MagicMock(refund_id="ref_abc")
            result = process_refund("txn_123", 50.0, "customer request")
            assert result["status"] == "success"
            assert result["refund_id"] == "ref_abc"

HIGH_RISK_PATTERNS = [
    "payment", "auth", "refund", "delete", "admin",
    "permission", "credential", "token", "charge"
]

def score_gap_risk(gap: dict) -> float:
    base_score = 1.0 - gap["coverage"]  # more uncovered = higher score
    risk_multiplier = 1.0

    # Boost risk score for high-value paths
    name_lower = (gap["function"] + gap["file"]).lower()
    if any(pattern in name_lower for pattern in HIGH_RISK_PATTERNS):
        risk_multiplier = 3.0

    # Boost for functions with many uncovered branches
    if len(gap["missing_lines"]) > 10:
        risk_multiplier *= 1.5

    return base_score * risk_multiplier

def prioritize_gaps(gaps: list[dict]) -> list[dict]:
    for gap in gaps:
        gap["risk_score"] = score_gap_risk(gap)
    return sorted(gaps, key=lambda x: x["risk_score"], reverse=True)