"""Per-file coverage threshold validation for quality-managed modules."""

from __future__ import annotations

import xml.etree.ElementTree as ET
from dataclasses import dataclass
from pathlib import Path
from typing import Any


@dataclass(frozen=True)
class CoverageRates:
    """Line and branch percentages reported for one source file."""

    line: float
    branch: float | None


def _load_percentages(xml_path: Path, root: Path) -> dict[str, CoverageRates]:
    """Load per-file line and branch percentages from a Cobertura report."""
    tree = ET.parse(xml_path)
    xml_root = tree.getroot()
    source_roots = [
        Path(node.text) for node in xml_root.findall("./sources/source") if node.text
    ]
    percentages: dict[str, CoverageRates] = {}
    for class_node in xml_root.findall(".//class"):
        filename = class_node.attrib.get("filename")
        line_rate = class_node.attrib.get("line-rate")
        branch_rate = class_node.attrib.get("branch-rate")
        if not filename or line_rate is None:
            continue
        normalized = filename.replace("\\", "/")
        if normalized.startswith("/"):
            key = Path(normalized).relative_to(root).as_posix()
        else:
            key = normalized
            for source_root in source_roots:
                candidate = source_root / filename
                if candidate.exists():
                    key = candidate.relative_to(root).as_posix()
                    break
        percentages[key] = CoverageRates(
            line=float(line_rate) * 100.0,
            branch=float(branch_rate) * 100.0 if branch_rate is not None else None,
        )
    return percentages


def run_check(contract: dict[str, Any], root: Path, xml_path: Path) -> list[str]:
    """Return human-readable issues for tracked files below the coverage floor.

    The report is intentionally per-file so a single weak module cannot hide
    behind aggregate suite coverage.
    """
    if not xml_path.exists():
        return [f"coverage xml missing: {xml_path.relative_to(root)}"]

    percentages = _load_percentages(xml_path, root)
    coverage_contract = contract.get("coverage", {})
    minimum = float(coverage_contract.get("minimum_percent", 95.0))
    branch_minimum = float(coverage_contract.get("minimum_branch_percent", 95.0))
    branch_tracked = {
        path.replace("\\", "/")
        for path in coverage_contract.get("branch_tracked_files", ())
    }
    issues: list[str] = []

    for relative_path in contract.get("coverage", {}).get("tracked_files", []):
        normalized = relative_path.replace("\\", "/")
        rates = percentages.get(normalized)
        if rates is None:
            issues.append(f"coverage missing for tracked file: {relative_path}")
            continue
        if rates.line + 1e-9 < minimum:
            issues.append(
                f"coverage below {minimum:.1f}%: {relative_path} ({rates.line:.1f}%)"
            )
        if normalized not in branch_tracked:
            continue
        if rates.branch is None:
            issues.append(f"branch coverage missing for tracked file: {relative_path}")
        elif rates.branch + 1e-9 < branch_minimum:
            issues.append(
                f"branch coverage below {branch_minimum:.1f}%: "
                f"{relative_path} ({rates.branch:.1f}%)"
            )

    return issues


def compute_workspace_line_coverage(
    contract: dict[str, Any],
    root: Path,
    xml_path: Path,
) -> float:
    """Compute mean line coverage across tracked files present in the XML."""

    if not xml_path.exists():
        return 0.0

    percentages = _load_percentages(xml_path, root)
    samples: list[float] = []
    for relative_path in contract.get("coverage", {}).get("tracked_files", []):
        normalized = relative_path.replace("\\", "/")
        rates = percentages.get(normalized)
        if rates is not None:
            samples.append(rates.line)
    if not samples:
        return 0.0
    return round(sum(samples) / len(samples), 3)