"""
Report generation for benchmark results.

This module provides functions for generating detailed reports from benchmark results.
"""

import json

# import logging - replaced with loguru
from loguru import logger
from datetime import datetime, UTC
from typing import Any, Dict, Optional

# logger = logging.getLogger(__name__) - using loguru logger directly


def generate_report(
    metrics: Dict[str, Any],
    results_file: str,
    output_file: str = "evaluation_report.md",
    dataset_name: str = "Unknown",
    config_info: Optional[Dict[str, Any]] = None,
) -> str:
    """
    Generate a detailed report from evaluation results.

    Args:
        metrics: Dictionary of evaluation metrics
        results_file: Path to results file
        output_file: Path to save report
        dataset_name: Name of dataset
        config_info: Optional configuration information

    Returns:
        Path to the generated report file
    """
    # Load a sample of results for examples
    results = []
    try:
        with open(results_file, "r", encoding="utf-8") as f:
            for line in f:
                if line.strip():
                    results.append(json.loads(line))
    except Exception:
        logger.exception("Error loading results for report")
        results = []

    # Sample up to 5 correct and 5 incorrect examples
    correct_examples = [r for r in results if r.get("is_correct", False)][:5]
    incorrect_examples = [
        r
        for r in results
        if "is_correct" in r and not r.get("is_correct", False)
    ][:5]

    # Create report
    report = [
        f"# Evaluation Report: {dataset_name}",
        "",
        "## Summary",
        "",
        f"- **Total Examples**: {metrics.get('total_examples', 0)}",
        f"- **Graded Examples**: {metrics.get('graded_examples', 0)}",
        f"- **Correct Answers**: {metrics.get('correct', 0)}",
        f"- **Accuracy**: {metrics.get('accuracy', 0):.3f}",
    ]

    # Add confidence interval if available
    accuracy_ci = metrics.get("accuracy_ci")
    if accuracy_ci and accuracy_ci.get("sample_size", 0) > 0:
        report.append(
            f"- **95% CI**: [{accuracy_ci['lower']:.3f}, {accuracy_ci['upper']:.3f}] "
            f"(Wilson score, n={accuracy_ci['sample_size']})"
        )

    if "average_processing_time" in metrics:
        report.append(
            f"- **Average Processing Time**: {metrics['average_processing_time']:.2f} seconds"
        )

    if "average_confidence" in metrics:
        report.append(
            f"- **Average Confidence**: {metrics['average_confidence']:.2f}%"
        )

    if "error_count" in metrics and metrics["error_count"] > 0:
        report.append(f"- **Error Count**: {metrics['error_count']}")
        report.append(f"- **Error Rate**: {metrics['error_rate']:.3f}")

    report.append("")

    # Add per-category metrics if available
    if "categories" in metrics:
        report.extend(["## Category Performance", ""])

        for category, category_metrics in metrics["categories"].items():
            report.append(f"### {category}")
            report.append("")
            report.append(f"- **Total**: {category_metrics['total']}")
            report.append(f"- **Correct**: {category_metrics['correct']}")
            report.append(f"- **Accuracy**: {category_metrics['accuracy']:.3f}")
            cat_ci = category_metrics.get("accuracy_ci")
            if cat_ci and cat_ci.get("sample_size", 0) > 0:
                report.append(
                    f"- **95% CI**: [{cat_ci['lower']:.3f}, {cat_ci['upper']:.3f}]"
                )
            report.append("")

    # Add configuration info if provided
    if config_info:
        report.extend(["## Configuration", ""])

        for key, value in config_info.items():
            report.append(f"- **{key}**: {value}")

        report.append("")

    # Add example sections
    if correct_examples:
        report.extend(["## Example Correct Answers", ""])

        for idx, example in enumerate(correct_examples):
            report.extend(
                [
                    f"### Example {idx + 1}",
                    "",
                    f"**Question**: {example.get('problem', '')}",
                    "",
                    f"**Correct Answer**: {example.get('correct_answer', '')}",
                    "",
                    f"**Model Answer**: {example.get('extracted_answer', '')}",
                    "",
                    f"**Reasoning**: {example.get('reasoning', '')}",
                    "",
                ]
            )

    if incorrect_examples:
        report.extend(["## Example Incorrect Answers", ""])

        for idx, example in enumerate(incorrect_examples):
            report.extend(
                [
                    f"### Example {idx + 1}",
                    "",
                    f"**Question**: {example.get('problem', '')}",
                    "",
                    f"**Correct Answer**: {example.get('correct_answer', '')}",
                    "",
                    f"**Model Answer**: {example.get('extracted_answer', '')}",
                    "",
                    f"**Reasoning**: {example.get('reasoning', '')}",
                    "",
                ]
            )

    # Add timestamp
    timestamp = datetime.now(UTC).strftime("%Y-%m-%d %H:%M:%S")
    report.extend(
        [
            "## Metadata",
            "",
            f"- **Generated**: {timestamp}",
            f"- **Dataset**: {dataset_name}",
            "",
        ]
    )

    # Write report to file
    from ...security.file_write_verifier import write_file_verified

    content = "\n".join(report)
    write_file_verified(
        output_file,
        content,
        "benchmark.allow_file_output",
        context="benchmark report",
    )

    logger.info(f"Report saved to {output_file}")
    return output_file
