"""A slow RAG lesson must not block the server's event loop.

rag_lesson used to call the synchronous retrieval and inference client directly inside an async
handler, so a 15-18 s Claude call froze every other request (health checks, learning paths,
lists) until it returned.
"""
from __future__ import annotations

import asyncio
import json
import os
import time
from unittest.mock import patch

import httpx

os.environ["ANTHROPIC_API_KEY"] = "mock-key-for-testing"

import main as main_module
from main import app
from services.ai_client import REASONER_MODEL

BLOCKING_SECONDS = 1.0
CHUNKS = [
    {
        "content": "A rational function is a quotient of two polynomial functions.",
        "source_file": "SHS_GM_Q1.pdf",
        "score": 0.95,
        "content_domain": "general",
    }
]
PAYLOAD = {
    "topic": "Rational Functions",
    "subject": "General Mathematics",
    "quarter": 1,
    "lessonTitle": "Introduction to Rational Functions",
}
LESSON_JSON = json.dumps({
    "sections": [
        {"type": "introduction", "content": "Intro."},
        {"type": "key_concepts", "content": "Concepts."},
        {"type": "video", "content": "Video."},
        {"type": "worked_examples", "examples": [{"problem": "Example."}]},
        {"type": "important_notes", "bulletPoints": ["Note."]},
        {"type": "try_it_yourself", "practiceProblems": [{"question": "Practice."}]},
        {"type": "summary", "content": "Summary."},
    ]
})


def _blocking_retrieval(*_args: object, **_kwargs: object) -> tuple[list[dict[str, object]], str]:
    time.sleep(BLOCKING_SECONDS)
    return CHUNKS, "exact_file"


class _BlockingInferenceClient:
    def generate_from_messages(self, _request: object) -> str:
        time.sleep(BLOCKING_SECONDS)
        return LESSON_JSON


def _blocking_reasoner_stream(*_args: object, **_kwargs: object) -> str:
    time.sleep(BLOCKING_SECONDS)
    return LESSON_JSON


async def _verified(reference_text: str, generated_text: str) -> dict[str, object]:
    return {"verified": True, "pCorrect": 0.95}


async def _lesson_while_polling_health() -> tuple[int, float, float]:
    """Poll /health for as long as the lesson runs; return the longest gap between answered polls."""
    transport = httpx.ASGITransport(app=app)
    async with httpx.AsyncClient(transport=transport, base_url="http://test", headers={"Authorization": "Bearer test-token"}) as client:
        started = time.perf_counter()
        lesson_task = asyncio.create_task(client.post("/api/rag/lesson", json=PAYLOAD))
        answered_at = [time.perf_counter()]
        while not lesson_task.done():
            health = await client.get("/health")
            assert health.status_code == 200
            answered_at.append(time.perf_counter())
            await asyncio.sleep(0.05)
        lesson = await lesson_task
        lesson_seconds = time.perf_counter() - started
        longest_gap = max(later - earlier for earlier, later in zip(answered_at, answered_at[1:]))
        return lesson.status_code, longest_gap, lesson_seconds


def test_health_answers_while_a_rag_lesson_is_blocked_in_retrieval_and_inference() -> None:
    with patch.object(
        main_module.firebase_auth,
        "verify_id_token",
        return_value={"uid": "student_S", "role": "student"},
    ), patch("routes.rag_routes.retrieve_lesson_pdf_context", _blocking_retrieval), patch(
        "routes.rag_routes._get_inference_client", return_value=_BlockingInferenceClient()
    ), patch("routes.rag_routes._stream_reasoner_lesson", _blocking_reasoner_stream), patch(
        "routes.rag_routes._lesson_primary_model", return_value=REASONER_MODEL
    ), patch("routes.rag_routes.verify_lesson_factuality", _verified), patch(
        "routes.rag_routes._fetch_youtube_videos", return_value=[]
    ), patch("routes.rag_routes._log_rag_usage", return_value=None):
        lesson_status, longest_gap, lesson_seconds = asyncio.run(_lesson_while_polling_health())

    assert lesson_status == 200
    assert lesson_seconds >= 2 * BLOCKING_SECONDS
    assert longest_gap < BLOCKING_SECONDS / 2, f"/health went unanswered for {longest_gap:.2f}s behind a blocked lesson"