from __future__ import annotations

from collections import defaultdict
from typing import Any

EVALUATION_K_VALUES = (
    1,
    3,
    5,
)


def unique_document_ranking(
    results: list[dict[str, Any]],
) -> list[dict[str, Any]]:
    selected: list[dict[str, Any]] = []

    seen: set[str] = set()

    for item in results:
        document_path = str(item["document_path"])

        if document_path in seen:
            continue

        seen.add(document_path)

        selected.append(item)

    return selected


def first_relevant_rank(
    ranked_documents: list[dict[str, Any]],
    expected_documents: set[str],
) -> int | None:
    for rank, item in enumerate(
        ranked_documents,
        start=1,
    ):
        if item["document_path"] in expected_documents:
            return rank

    return None


def recall_at_k(
    ranked_documents: list[dict[str, Any]],
    expected_documents: set[str],
    k: int,
) -> float:
    if not expected_documents:
        return 0.0

    retrieved = {str(item["document_path"]) for item in ranked_documents[:k]}

    relevant_retrieved = retrieved & expected_documents

    return len(relevant_retrieved) / len(expected_documents)


def evaluate_question_mode(
    question: dict[str, Any],
    mode: str,
    results: list[dict[str, Any]],
) -> dict[str, Any]:
    ranked_documents = unique_document_ranking(results)

    expected_documents = {str(value) for value in question["expected_documents"]}

    rank = first_relevant_rank(
        ranked_documents,
        expected_documents,
    )

    reciprocal_rank = 0.0 if rank is None else 1.0 / rank

    row: dict[str, Any] = {
        "id": question["id"],
        "split": question.get("split"),
        "category": question.get(
            "category",
            "unknown",
        ),
        "difficulty": question.get(
            "difficulty",
            "unknown",
        ),
        "question": question["question"],
        "mode": mode,
        "expected_documents": sorted(expected_documents),
        "first_relevant_rank": rank,
        "reciprocal_rank": round(
            reciprocal_rank,
            6,
        ),
        "top_documents": [item["document_path"] for item in ranked_documents],
        "top_source_urls": [item.get("source_url") for item in ranked_documents],
    }

    for k in EVALUATION_K_VALUES:
        row[f"hit_at_{k}"] = 1 if (rank is not None and rank <= k) else 0

        row[f"recall_at_{k}"] = round(
            recall_at_k(
                ranked_documents,
                expected_documents,
                k,
            ),
            6,
        )

    return row


def average(
    values: list[float],
) -> float:
    if not values:
        return 0.0

    return sum(values) / len(values)


def aggregate_metrics(
    rows: list[dict[str, Any]],
) -> dict[str, Any]:
    if not rows:
        return {
            "questions": 0,
            "hit_at_1": 0.0,
            "hit_at_3": 0.0,
            "hit_at_5": 0.0,
            "mrr": 0.0,
            "recall_at_5": 0.0,
        }

    return {
        "questions": len(rows),
        "hit_at_1": round(
            average([float(row["hit_at_1"]) for row in rows]),
            6,
        ),
        "hit_at_3": round(
            average([float(row["hit_at_3"]) for row in rows]),
            6,
        ),
        "hit_at_5": round(
            average([float(row["hit_at_5"]) for row in rows]),
            6,
        ),
        "mrr": round(
            average([float(row["reciprocal_rank"]) for row in rows]),
            6,
        ),
        "recall_at_5": round(
            average([float(row["recall_at_5"]) for row in rows]),
            6,
        ),
    }


def aggregate_by_category(
    rows: list[dict[str, Any]],
) -> dict[
    str,
    dict[str, Any],
]:
    grouped: dict[
        str,
        list[dict[str, Any]],
    ] = defaultdict(list)

    for row in rows:
        category = str(
            row.get(
                "category",
                "unknown",
            )
        )

        grouped[category].append(row)

    return {
        category: aggregate_metrics(category_rows)
        for (
            category,
            category_rows,
        ) in sorted(grouped.items())
    }


def aggregate_by_difficulty(
    rows: list[dict[str, Any]],
) -> dict[
    str,
    dict[str, Any],
]:
    grouped: dict[
        str,
        list[dict[str, Any]],
    ] = defaultdict(list)

    for row in rows:
        difficulty = str(
            row.get(
                "difficulty",
                "unknown",
            )
        )

        grouped[difficulty].append(row)

    return {
        difficulty: aggregate_metrics(difficulty_rows)
        for (
            difficulty,
            difficulty_rows,
        ) in sorted(grouped.items())
    }