"""Minimal end-to-end smoke tests for the web API app module."""

from __future__ import annotations

import builtins
from pathlib import Path
from types import SimpleNamespace

import pytest

from services.shared.dto import ResearchTaskDTO, ResearchTaskListDTO


@pytest.fixture()
def web_api_module(isolated_research_task_store, reload_web_api_app, monkeypatch):
    """Load the web API app against an isolated research task store."""
    _ = isolated_research_task_store
    monkeypatch.setattr(builtins, "clear_report_log", lambda: None, raising=False)
    return reload_web_api_app()


@pytest.fixture()
def client(web_api_module):
    return web_api_module.app.test_client()


def test_system_status_happy_path(client):
    response = client.get("/api/system/status")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload == {
        "success": True,
        "started": False,
        "starting": False,
    }


def test_process_status_happy_path(client):
    response = client.get("/api/status")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["insight"]["port"] == 8501
    assert isinstance(payload["insight"]["status"], str)
    assert isinstance(payload["insight"]["output_lines"], int)
    assert payload["forum"] == {
        "status": "stopped",
        "port": None,
        "output_lines": 0,
    }


def test_crawler_jobs_route_is_available_through_web_api_app(client, monkeypatch):
    import backend.crawler.routes as crawler_routes

    if not hasattr(crawler_routes, "CRAWLER_APP_SERVICE"):
        pytest.skip("CRAWLER_APP_SERVICE route wiring has not landed in this workspace yet.")

    class _FakeCrawlerAppService:
        def build_crawler_jobs_payload(self):
            return {
                "current_job": {"id": "crawl-2"},
                "jobs": [{"id": "crawl-2"}, {"id": "crawl-1"}],
            }

    monkeypatch.setattr(
        crawler_routes,
        "CRAWLER_APP_SERVICE",
        _FakeCrawlerAppService(),
        raising=False,
    )

    response = client.get("/api/crawler/jobs")

    assert response.status_code == 200
    assert response.get_json() == {
        "success": True,
        "current_job": {"id": "crawl-2"},
        "jobs": [{"id": "crawl-2"}, {"id": "crawl-1"}],
    }


def test_crawler_start_and_stop_routes_are_available_through_web_api_app(client, monkeypatch):
    import backend.crawler.routes as crawler_routes

    if not hasattr(crawler_routes, "CRAWLER_APP_SERVICE"):
        pytest.skip("CRAWLER_APP_SERVICE route wiring has not landed in this workspace yet.")

    class _FakeCrawlerAppService:
        def __init__(self) -> None:
            self.start_calls: list[dict[str, object]] = []
            self.stop_calls = 0

        def start_crawler(self, payload: dict[str, object]) -> dict[str, object]:
            self.start_calls.append(payload)
            return {"message": "crawler started", "job_id": "crawl-2"}

        def stop_crawler(self) -> dict[str, object]:
            self.stop_calls += 1
            return {"message": "crawler stopped"}

    fake_service = _FakeCrawlerAppService()
    monkeypatch.setattr(
        crawler_routes,
        "CRAWLER_APP_SERVICE",
        fake_service,
        raising=False,
    )

    start_response = client.post("/api/crawler/start", json={"platform": "xiaohongshu"})
    assert start_response.status_code == 200
    assert start_response.get_json() == {
        "success": True,
        "message": "crawler started",
        "job_id": "crawl-2",
    }
    assert fake_service.start_calls == [{"platform": "xiaohongshu"}]

    stop_response = client.post("/api/crawler/stop")
    assert stop_response.status_code == 200
    assert stop_response.get_json() == {
        "success": True,
        "message": "crawler stopped",
    }
    assert fake_service.stop_calls == 1


def test_runtime_routes_and_socket_handlers_are_registered(web_api_module):
    route_rules = {rule.rule for rule in web_api_module.app.url_map.iter_rules()}

    assert "/" in route_rules
    assert "/api/status" in route_rules
    assert "/api/search" in route_rules
    assert "/api/system/shutdown" in route_rules

    socket_handlers = getattr(web_api_module.socketio.server, "handlers", {}).get("/", {})
    assert "connect" in socket_handlers
    assert "request_status" in socket_handlers


def test_web_api_module_keeps_only_required_compat_exports(web_api_module):
    assert hasattr(web_api_module, "_APP_MODULE")
    assert hasattr(web_api_module._APP_MODULE, "cleanup_handler")
    assert hasattr(web_api_module._APP_MODULE, "search_hooks")
    assert not hasattr(web_api_module, "_REGISTERED_CLEANUP_HANDLER")
    assert not hasattr(web_api_module, "SEARCH_HOOKS")
    assert not hasattr(web_api_module, "RUNTIME_SERVICES")
    assert not hasattr(web_api_module, "SEARCH_HOOK_BINDINGS")
    assert not hasattr(web_api_module, "ROUTE_DEPENDENCIES")
    assert not hasattr(web_api_module, "SOCKET_EVENT_DEPENDENCIES")


def test_index_redirects_to_frontend_dev_server_when_configured(
    isolated_research_task_store,
    reload_web_api_app,
    monkeypatch,
):
    _ = isolated_research_task_store
    monkeypatch.setenv("BETTAFISH_FRONTEND_DEV_URL", "http://localhost:5173/")

    web_api_module = reload_web_api_app()
    client = web_api_module.app.test_client()

    response = client.get("/")

    assert response.status_code == 302
    assert response.headers["Location"] == "http://localhost:5173"


def test_research_task_creation_and_snapshot_happy_path(client):
    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Test Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
            "benchmark_venues": ["Benchmark Venue A"],
            "notes": "Focus on service and guided experience",
        },
    )

    assert create_response.status_code == 200
    create_payload = create_response.get_json()
    assert create_payload["success"] is True
    task = create_payload["task"]
    assert task["title"] == "Test Venue"
    assert task["status"] == "draft"
    assert "Test Venue" in task["generated_query"]
    assert create_payload["active_task"]["id"] == task["id"]
    assert any(item["id"] == task["id"] for item in create_payload["tasks"])

    snapshot_response = client.get("/api/research/tasks")
    assert snapshot_response.status_code == 200
    snapshot_payload = snapshot_response.get_json()
    assert snapshot_payload["success"] is True
    assert snapshot_payload["active_task"]["id"] == task["id"]


def test_research_task_resource_collection_and_detail_aliases(client):
    create_response = client.post(
        "/api/research-tasks",
        json={
            "venue_name": "Alias Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )

    assert create_response.status_code == 200
    create_payload = create_response.get_json()
    task = create_payload["task"]
    assert create_payload["success"] is True
    assert create_payload["active_task"]["id"] == task["id"]

    collection_response = client.get("/api/research-tasks")
    assert collection_response.status_code == 200
    collection_payload = collection_response.get_json()
    assert collection_payload["success"] is True
    assert collection_payload["active_task"]["id"] == task["id"]

    detail_response = client.get(f"/api/research-tasks/{task['id']}")
    assert detail_response.status_code == 200
    detail_payload = detail_response.get_json()
    assert detail_payload["success"] is True
    assert detail_payload["task"]["id"] == task["id"]
    assert detail_payload["task"]["title"] == task["title"]
    assert detail_payload["task"]["status"] == task["status"]


def test_research_task_resource_aliases_delegate_to_task_scoped_services(client, monkeypatch):
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Alias Resource Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    created_task = create_response.get_json()["task"]

    def build_task_analysis_run_payload(task_id: str):
        assert task_id == created_task["id"]
        return {
            "task_id": task_id,
            "analysis_run_id": None,
            "analysis_run": None,
        }

    def build_task_analysis_resource_payload(task_id: str):
        assert task_id == created_task["id"]
        return {"task_id": task_id, "analysis": {"status": "idle"}}

    def build_task_analysis_runs_payload(task_id: str):
        assert task_id == created_task["id"]
        return {
            "task_id": task_id,
            "analysis_run_id": None,
            "analysis_runs": [],
        }

    class _FakeCrawlerAppService:
        def build_task_crawler_resource_payload(self, *, research_task_id, crawler_job_id=None, task=None):
            assert research_task_id == created_task["id"]
            assert crawler_job_id is None
            assert task is not None
            assert task.id == created_task["id"]
            return {"task_id": research_task_id, "crawler": {"status": "idle"}}

    class _FakeReportAppService:
        def build_task_report_resource_payload(self, *, research_task_id, report_job_id=None, task=None):
            assert research_task_id == created_task["id"]
            assert report_job_id is None
            assert task is not None
            assert task.id == created_task["id"]
            return {"task_id": research_task_id, "report": {"status": "idle"}}

    monkeypatch.setattr(
        research_routes.RESEARCH_TASK_VIEW_APP_SERVICE,
        "build_task_analysis_run_payload",
        build_task_analysis_run_payload,
    )
    monkeypatch.setattr(
        research_routes.RESEARCH_TASK_VIEW_APP_SERVICE,
        "build_task_analysis_resource_payload",
        build_task_analysis_resource_payload,
    )
    monkeypatch.setattr(
        research_routes.RESEARCH_TASK_VIEW_APP_SERVICE,
        "build_task_analysis_runs_payload",
        build_task_analysis_runs_payload,
    )
    monkeypatch.setattr(research_routes, "RESEARCH_CRAWLER_APP_SERVICE", _FakeCrawlerAppService(), raising=False)
    monkeypatch.setattr(research_routes, "RESEARCH_REPORT_APP_SERVICE", _FakeReportAppService(), raising=False)

    analysis_run_response = client.get(f"/api/research-tasks/{created_task['id']}/analysis-run")
    analysis_response = client.get(f"/api/research-tasks/{created_task['id']}/analysis")
    analysis_runs_response = client.get(f"/api/research-tasks/{created_task['id']}/analysis-runs")
    crawler_response = client.get(f"/api/research-tasks/{created_task['id']}/crawler")
    report_response = client.get(f"/api/research-tasks/{created_task['id']}/report")

    assert analysis_run_response.status_code == 200
    assert analysis_run_response.get_json() == {
        "success": True,
        "task_id": created_task["id"],
        "analysis_run_id": None,
        "analysis_run": None,
    }
    assert analysis_response.status_code == 200
    assert analysis_response.get_json() == {
        "success": True,
        "task_id": created_task["id"],
        "analysis": {"status": "idle"},
    }
    assert analysis_runs_response.status_code == 200
    assert analysis_runs_response.get_json() == {
        "success": True,
        "task_id": created_task["id"],
        "analysis_run_id": None,
        "analysis_runs": [],
    }
    assert crawler_response.status_code == 200
    assert crawler_response.get_json() == {
        "success": True,
        "task_id": created_task["id"],
        "crawler": {"status": "idle"},
    }
    assert report_response.status_code == 200
    assert report_response.get_json() == {
        "success": True,
        "task_id": created_task["id"],
        "report": {"status": "idle"},
    }


def test_research_task_view_collection_aggregates_task_scoped_resources(client, monkeypatch):
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research-tasks",
        json={
            "venue_name": "Task View Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    created_task = create_response.get_json()["task"]
    task_snapshot = ResearchTaskListDTO(
        active_task=ResearchTaskDTO(
            id=created_task["id"],
            title=created_task["title"],
            generated_query=created_task["generated_query"],
            status="reporting",
            crawler_job_id="crawler-3",
            report_job_id="report-9",
            last_action="Report linked",
            updated_at="2026-04-22T13:00:00",
        ),
        tasks=[
            ResearchTaskDTO(
                id=created_task["id"],
                title=created_task["title"],
                generated_query=created_task["generated_query"],
                status="reporting",
                crawler_job_id="crawler-3",
                report_job_id="report-9",
                last_action="Report linked",
                updated_at="2026-04-22T13:00:00",
            )
        ],
    )

    class _FakeCrawlerAppService:
        def build_task_crawler_resource_payload(self, *, research_task_id, crawler_job_id=None, task=None):
            assert research_task_id == created_task["id"]
            assert crawler_job_id == "crawler-3"
            assert task is not None
            return {
                "task_id": research_task_id,
                "crawler": {
                    "crawler_job_id": crawler_job_id,
                    "status": "completed",
                    "current_job": {
                        "id": "crawler-3",
                        "status": "completed",
                    },
                    "summary": {"last_action": "Crawler ready", "platform": "xiaohongshu"},
                    "history": {"linked_job_available": True, "linked_job_is_current": True},
                },
            }

    class _FakeAnalysisAppService:
        def get_task_analysis_resource_dto(self, *, research_task_id, analysis_run_id=None, task=None):
            assert research_task_id == created_task["id"]
            assert analysis_run_id is None
            assert task is not None
            return SimpleNamespace(
                to_response_payload=lambda: {
                    "task_id": research_task_id,
                    "analysis": {
                        "status": "completed",
                        "current_run": {
                            "id": "analysis-2",
                            "status": "completed",
                        },
                        "summary": {
                            "last_action": "Analysis ready",
                            "engine_count": 3,
                        },
                        "history": {"run_count": 1},
                    },
                }
            )

    class _FakeReportAppService:
        def build_task_report_resource_payload(self, *, research_task_id, report_job_id=None, task=None):
            assert research_task_id == created_task["id"]
            assert report_job_id == "report-9"
            assert task is not None
            return {
                "task_id": research_task_id,
                "report": {
                    "report_job_id": report_job_id,
                    "status": "completed",
                    "current_job": {
                        "id": "report-9",
                        "task_id": "report-9",
                        "status": "completed",
                        "report_file_path": "reports/report-9.html",
                    },
                    "engine_result": {
                        "engine_name": "report",
                        "status": "completed",
                        "success": True,
                        "summary": "Report ready",
                        "artifacts": {
                            "report_file_path": "reports/report-9.html",
                            "report_file_ready": True,
                        },
                        "metrics": {"progress_percent": 100},
                    },
                    "summary": {
                        "last_action": "Report ready",
                        "linked_job_id": "report-9",
                        "current_job_id": "report-9",
                    },
                    "history": {"linked_job_available": True, "linked_job_is_current": True},
                },
            }

    monkeypatch.setattr(research_routes.RESEARCH_TASK_APP_SERVICE, "get_task_snapshot", lambda: task_snapshot)
    monkeypatch.setattr(research_routes, "RESEARCH_ANALYSIS_APP_SERVICE", _FakeAnalysisAppService(), raising=False)
    monkeypatch.setattr(research_routes, "RESEARCH_CRAWLER_APP_SERVICE", _FakeCrawlerAppService(), raising=False)
    monkeypatch.setattr(research_routes, "RESEARCH_REPORT_APP_SERVICE", _FakeReportAppService(), raising=False)

    response = client.get("/api/research-tasks/task-views")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["active_task_id"] == created_task["id"]
    assert len(payload["task_views"]) == 1
    assert payload["task_views"][0]["task_id"] == created_task["id"]
    assert payload["task_views"][0]["task"]["id"] == created_task["id"]
    assert payload["task_views"][0]["task"]["report_job_id"] == "report-9"
    assert payload["task_views"][0]["task"]["unified_task"]["report_job_id"] == "report-9"
    assert payload["task_views"][0]["analysis"]["status"] == "completed"
    assert payload["task_views"][0]["analysis"]["current_run"]["id"] == "analysis-2"
    assert payload["task_views"][0]["analysis"]["summary"]["engine_count"] == 3
    assert payload["task_views"][0]["analysis"]["history"]["run_count"] == 1
    assert payload["task_views"][0]["crawler"]["status"] == "completed"
    assert payload["task_views"][0]["crawler"]["current_job"]["id"] == "crawler-3"
    assert payload["task_views"][0]["crawler"]["summary"]["platform"] == "xiaohongshu"
    assert payload["task_views"][0]["crawler"]["history"]["linked_job_is_current"] is True
    assert payload["task_views"][0]["report"]["status"] == "completed"
    assert payload["task_views"][0]["report"]["report_job_id"] == "report-9"
    assert payload["task_views"][0]["report"]["current_job"]["id"] == "report-9"
    assert payload["task_views"][0]["report"]["engine_result"]["engine_name"] == "report"
    assert payload["task_views"][0]["report"]["engine_result"]["status"] == "completed"
    assert (
        payload["task_views"][0]["report"]["engine_result"]["artifacts"]["report_file_path"]
        == "reports/report-9.html"
    )
    assert payload["task_views"][0]["report"]["summary"]["linked_job_id"] == "report-9"
    assert payload["task_views"][0]["report"]["history"]["linked_job_available"] is True


def test_research_task_resource_activate_alias_switches_active_task(client):
    first_response = client.post(
        "/api/research-tasks",
        json={
            "venue_name": "Active Alias Venue A",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    first_task = first_response.get_json()["task"]

    second_response = client.post(
        "/api/research-tasks",
        json={
            "venue_name": "Active Alias Venue B",
            "city": "Hangzhou",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    second_task = second_response.get_json()["task"]

    activate_response = client.post(f"/api/research-tasks/{first_task['id']}/activate")

    assert activate_response.status_code == 200
    activate_payload = activate_response.get_json()
    assert activate_payload["success"] is True
    assert activate_payload["active_task"]["id"] == first_task["id"]
    assert {task["id"] for task in activate_payload["tasks"]} == {
        first_task["id"],
        second_task["id"],
    }


def test_search_uses_task_query_from_application_service(client, web_api_module, monkeypatch):
    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Search Test Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    captured: dict[str, object] = {}

    def fake_dispatch_search_request(**kwargs):
        captured.update(kwargs)
        return {"success": True, "accepted": True, "message": "ok"}

    monkeypatch.setattr(
        web_api_module._APP_MODULE.search_hooks,
        "dispatch_search_request",
        fake_dispatch_search_request,
    )

    response = client.post(
        "/api/search",
        json={
            "research_task_id": task["id"],
        },
    )

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert captured["research_task_id"] == task["id"]
    assert "Search Test Venue" in str(captured["query"])


def test_search_smoke_exposes_mock_completed_analysis_outputs_via_task_resource(
    client,
    web_api_module,
    monkeypatch,
    isolated_research_task_store,
):
    import backend.research_routes as research_routes
    from services.shared.models import AnalysisRunStatus

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Completed Analysis Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]
    run_store = isolated_research_task_store.analysis_run_store

    def fake_dispatch_search_request(**kwargs):
        run = run_store.create_run(
            research_task_id=kwargs["research_task_id"],
            query=str(kwargs["query"]),
            engines=["query", "insight"],
        )
        run.status = AnalysisRunStatus.COMPLETED
        run.started_at = run.created_at
        run.finished_at = run.created_at
        run.last_action = "Mock query + insight completed"
        run.progress.current = 2
        run.progress.total = 2
        run.progress.percent = 100.0
        run.progress.stage = AnalysisRunStatus.COMPLETED.value
        run.progress.message = run.last_action
        run.partial_results["query"] = {
            "engine_name": "query",
            "success": True,
            "status": "completed",
            "summary": "Collected venue review snippets",
            "artifacts": {"sources": ["news", "map_reviews"]},
            "metrics": {"duration_seconds": 1.1},
        }
        run.partial_results["insight"] = {
            "engine_name": "insight",
            "success": True,
            "status": "completed",
            "summary": "Visitors praise curation and staff guidance",
            "artifacts": {"themes": ["curation", "staff_guidance"]},
            "metrics": {"duration_seconds": 1.4},
        }
        run.metrics.update(
            {
                "engine_count": 2,
                "success_count": 2,
                "failure_count": 0,
            }
        )
        run = run_store.save_run(run)
        research_routes.RESEARCH_TASK_APP_SERVICE.sync_analysis_runtime_status(
            kwargs["research_task_id"],
            analysis_status=run.status.value,
            generated_query=str(kwargs["query"]),
            analysis_run_id=run.id,
            last_action=run.last_action,
        )
        return {
            "success": True,
            "accepted": True,
            "analysis_run_id": run.id,
            "message": run.last_action,
        }

    monkeypatch.setattr(
        web_api_module._APP_MODULE.search_hooks,
        "dispatch_search_request",
        fake_dispatch_search_request,
    )

    search_response = client.post("/api/search", json={"research_task_id": task["id"]})

    assert search_response.status_code == 200
    search_payload = search_response.get_json()
    assert search_payload["success"] is True
    assert search_payload["accepted"] is True
    assert search_payload["message"] == "Mock query + insight completed"

    analysis_response = client.get(f"/api/research/tasks/{task['id']}/analysis")

    assert analysis_response.status_code == 200
    payload = analysis_response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == task["id"]
    assert payload["analysis"]["analysis_run_id"] == search_payload["analysis_run_id"]
    assert payload["analysis"]["status"] == "completed"
    assert payload["analysis"]["task_status"] == "analyzing"
    assert payload["analysis"]["current_run"]["id"] == search_payload["analysis_run_id"]
    assert payload["analysis"]["current_run"]["partial_results"]["query"]["summary"] == (
        "Collected venue review snippets"
    )
    assert payload["analysis"]["current_run"]["partial_results"]["query"]["engine_name"] == "query"
    assert payload["analysis"]["current_run"]["partial_results"]["insight"]["artifacts"]["themes"] == [
        "curation",
        "staff_guidance",
    ]
    assert payload["analysis"]["summary"]["current_result_count"] == 2
    assert payload["analysis"]["summary"]["last_action"] == "Mock query + insight completed"
    assert payload["analysis"]["history"]["linked_run_is_current"] is True
    assert payload["analysis"]["stats"]["terminal_run_count"] == 1
    assert payload["analysis"]["stats"]["current_result_engine_count"] == 2


def test_research_task_analysis_run_endpoint_returns_null_when_task_has_no_run(client):
    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Analysis Pending Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    response = client.get(f"/api/research/tasks/{task['id']}/analysis-run")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload == {
        "success": True,
        "task_id": task["id"],
        "analysis_run_id": None,
        "analysis_run": None,
    }


def test_research_task_analysis_run_endpoint_returns_persisted_run(
    client,
    isolated_research_task_store,
):
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Analysis Complete Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    run_store = isolated_research_task_store.analysis_run_store
    run = run_store.create_run(
        research_task_id=task["id"],
        query=task["generated_query"],
        engines=["query", "insight"],
    )
    run.partial_results["query"] = {
        "success": True,
        "status": "completed",
        "summary": "query complete",
        "artifacts": {"sources": ["reviews"]},
        "metrics": {"duration_seconds": 0.8},
    }
    run.metrics["success_count"] = 1
    run.metrics["failure_count"] = 1
    run_store.save_run(run)
    research_routes.RESEARCH_TASK_APP_SERVICE.set_task_status(
        task["id"],
        status="analyzing",
        last_action="Analysis run linked",
        generated_query=task["generated_query"],
        analysis_run_id=run.id,
    )

    response = client.get(f"/api/research/tasks/{task['id']}/analysis-run")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == task["id"]
    assert payload["analysis_run_id"] == run.id
    assert payload["analysis_run"]["id"] == run.id
    assert payload["analysis_run"]["run_id"] == run.id
    assert payload["analysis_run"]["research_task_id"] == task["id"]
    assert payload["analysis_run"]["partial_results"]["query"]["success"] is True
    assert payload["analysis_run"]["partial_results"]["query"]["engine_name"] == "query"
    assert payload["analysis_run"]["unified_run"]["id"] == run.id


def test_research_task_analysis_run_endpoint_falls_back_to_latest_persisted_run(
    client,
    isolated_research_task_store,
):
    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Analysis Fallback Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    run_store = isolated_research_task_store.analysis_run_store
    older_run = run_store.create_run(
        research_task_id=task["id"],
        query=f"{task['generated_query']} older",
        engines=["query"],
    )
    older_run = run_store.save_run(older_run)

    newer_run = run_store.create_run(
        research_task_id=task["id"],
        query=f"{task['generated_query']} newer",
        engines=["insight"],
    )
    newer_run.partial_results["insight"] = {
        "success": True,
        "status": "completed",
        "summary": "latest result",
        "artifacts": {"themes": ["latest"]},
        "metrics": {"duration_seconds": 0.7},
    }
    newer_run = run_store.save_run(newer_run)

    response = client.get(f"/api/research/tasks/{task['id']}/analysis-run")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["analysis_run_id"] is None
    assert payload["analysis_run"]["id"] == newer_run.id
    assert payload["analysis_run"]["id"] != older_run.id
    assert payload["analysis_run"]["run_id"] == newer_run.id
    assert payload["analysis_run"]["partial_results"]["insight"]["success"] is True
    assert payload["analysis_run"]["partial_results"]["insight"]["engine_name"] == "insight"


def test_research_task_analysis_runs_endpoint_returns_history(
    client,
    isolated_research_task_store,
):
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Analysis History Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    run_store = isolated_research_task_store.analysis_run_store
    older_run = run_store.create_run(
        research_task_id=task["id"],
        query=f"{task['generated_query']} older",
        engines=["query"],
    )
    older_run.partial_results["query"] = "timeout while waiting for upstream reviews"
    older_run = run_store.save_run(older_run)

    newer_run = run_store.create_run(
        research_task_id=task["id"],
        query=f"{task['generated_query']} newer",
        engines=["insight", "query"],
    )
    newer_run.partial_results["insight"] = {
        "success": True,
        "status": "completed",
        "summary": "insight complete",
        "artifacts": {"themes": ["curation"]},
        "metrics": {"duration_seconds": 1.0},
    }
    newer_run.metrics["success_count"] = 1
    newer_run.metrics["failure_count"] = 1
    newer_run = run_store.save_run(newer_run)

    research_routes.RESEARCH_TASK_APP_SERVICE.set_task_status(
        task["id"],
        status="analyzing",
        last_action="Linked latest analysis history",
        generated_query=task["generated_query"],
        analysis_run_id=newer_run.id,
    )

    response = client.get(f"/api/research/tasks/{task['id']}/analysis-runs")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == task["id"]
    assert payload["analysis_run_id"] == newer_run.id
    assert [run["id"] for run in payload["analysis_runs"]] == [newer_run.id, older_run.id]
    assert payload["analysis_runs"][0]["run_id"] == newer_run.id
    assert payload["analysis_runs"][0]["partial_results"]["insight"]["success"] is True
    assert payload["analysis_runs"][1]["partial_results"]["query"]["engine_name"] == "query"
    assert payload["analysis_runs"][1]["partial_results"]["query"]["status"] == "failed"
    assert payload["analysis_runs"][1]["partial_results"]["query"]["error"]["message"] == (
        "timeout while waiting for upstream reviews"
    )


def test_research_task_analysis_resource_endpoint_returns_current_run_and_history(
    client,
    isolated_research_task_store,
):
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Analysis Resource Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    run_store = isolated_research_task_store.analysis_run_store
    older_run = run_store.create_run(
        research_task_id=task["id"],
        query=f"{task['generated_query']} older",
        engines=["query"],
    )
    older_run = run_store.save_run(older_run)

    current_run = run_store.create_run(
        research_task_id=task["id"],
        query=f"{task['generated_query']} current",
        engines=["insight", "query"],
    )
    current_run.partial_results["insight"] = {
        "success": True,
        "status": "completed",
        "summary": "insight complete",
        "artifacts": {"themes": ["insight"]},
        "metrics": {"duration_seconds": 1.2},
    }
    current_run = run_store.save_run(current_run)

    research_routes.RESEARCH_TASK_APP_SERVICE.set_task_status(
        task["id"],
        status="analyzing",
        last_action="Linked analysis resource view",
        generated_query=task["generated_query"],
        analysis_run_id=current_run.id,
    )

    response = client.get(f"/api/research/tasks/{task['id']}/analysis")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == task["id"]
    assert payload["analysis"]["analysis_run_id"] == current_run.id
    assert payload["analysis"]["current_run"]["id"] == current_run.id
    assert payload["analysis"]["current_run"]["run_id"] == current_run.id
    assert [run["id"] for run in payload["analysis"]["runs"]] == [current_run.id, older_run.id]
    assert payload["analysis"]["summary"]["current_run_id"] == current_run.id
    assert payload["analysis"]["summary"]["run_count"] == 2
    assert payload["analysis"]["history"]["has_history"] is True
    assert payload["analysis"]["history"]["linked_run_is_current"] is True
    assert payload["analysis"]["stats"]["total_runs"] == 2
    assert payload["analysis"]["stats"]["unique_engines"] == ["insight", "query"]


def test_research_task_analysis_resource_endpoint_preserves_linked_run_fallback_flags(
    client,
    isolated_research_task_store,
):
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Analysis Linked Fallback Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    run_store = isolated_research_task_store.analysis_run_store
    older_run = run_store.create_run(
        research_task_id=task["id"],
        query=f"{task['generated_query']} older",
        engines=["query"],
    )
    older_run = run_store.save_run(older_run)

    latest_run = run_store.create_run(
        research_task_id=task["id"],
        query=f"{task['generated_query']} latest",
        engines=["insight"],
    )
    latest_run.partial_results["insight"] = {
        "success": True,
        "status": "completed",
        "summary": "latest result",
        "artifacts": {"themes": ["latest"]},
        "metrics": {"duration_seconds": 0.7},
    }
    latest_run = run_store.save_run(latest_run)

    research_routes.RESEARCH_TASK_APP_SERVICE.set_task_status(
        task["id"],
        status="analyzing",
        last_action="Linked missing analysis run",
        generated_query=task["generated_query"],
        analysis_run_id="analysis-missing",
    )

    response = client.get(f"/api/research/tasks/{task['id']}/analysis")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == task["id"]
    assert payload["analysis"]["analysis_run_id"] == "analysis-missing"
    assert payload["analysis"]["current_run"]["id"] == latest_run.id
    assert [run["id"] for run in payload["analysis"]["runs"]] == [latest_run.id, older_run.id]
    assert payload["analysis"]["summary"]["linked_run_id"] == "analysis-missing"
    assert payload["analysis"]["history"]["linked_run_available"] is False
    assert payload["analysis"]["history"]["linked_run_is_current"] is False


def test_research_task_analysis_resource_endpoint_preserves_multi_engine_partial_results(
    client,
    isolated_research_task_store,
):
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Analysis Multi Engine Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    run_store = isolated_research_task_store.analysis_run_store
    current_run = run_store.create_run(
        research_task_id=task["id"],
        query=task["generated_query"],
        engines=["query", "media", "insight"],
    )
    current_run.partial_results["query"] = {
        "success": True,
        "status": "completed",
        "summary": "query complete",
        "artifacts": {"sources": ["reviews"]},
        "metrics": {"duration_seconds": 0.9},
    }
    current_run.partial_results["media"] = {
        "success": True,
        "status": "completed",
        "summary": "media complete",
        "artifacts": {"report_preview": "media preview"},
        "metrics": {"duration_seconds": 1.3},
    }
    current_run.partial_results["insight"] = {
        "success": True,
        "status": "completed",
        "summary": "insight complete",
        "artifacts": {"themes": ["service"]},
        "metrics": {"duration_seconds": 1.7},
    }
    current_run.metrics["success_count"] = 3
    current_run.metrics["failure_count"] = 0
    current_run = run_store.save_run(current_run)

    research_routes.RESEARCH_TASK_APP_SERVICE.set_task_status(
        task["id"],
        status="completed",
        last_action="All engine outputs linked",
        generated_query=task["generated_query"],
        analysis_run_id=current_run.id,
    )

    response = client.get(f"/api/research/tasks/{task['id']}/analysis")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == task["id"]
    assert payload["analysis"]["current_run"]["id"] == current_run.id
    assert payload["analysis"]["current_run"]["run_id"] == current_run.id
    assert payload["analysis"]["current_run"]["partial_results"]["query"]["success"] is True
    assert payload["analysis"]["current_run"]["partial_results"]["media"]["success"] is True
    assert payload["analysis"]["current_run"]["partial_results"]["insight"]["success"] is True
    assert payload["analysis"]["current_run"]["partial_results"]["media"]["engine_name"] == "media"
    assert payload["analysis"]["summary"]["current_result_count"] == 3
    assert payload["analysis"]["stats"]["runs_with_results"] == 1
    assert set(payload["analysis"]["stats"]["unique_engines"]) == {"query", "media", "insight"}


def test_research_task_analysis_resource_endpoint_normalizes_current_run_legacy_results_and_failures(
    client,
    isolated_research_task_store,
):
    import backend.research_routes as research_routes
    from services.shared.models import AnalysisRunStatus, ErrorInfo

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Analysis Canonical Contract Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    run_store = isolated_research_task_store.analysis_run_store
    current_run = run_store.create_run(
        research_task_id=task["id"],
        query=task["generated_query"],
        engines=["query", "insight"],
    )
    current_run.status = AnalysisRunStatus.PARTIAL
    current_run.last_action = "Query failed but insight still produced output"
    current_run.error = ErrorInfo(message="1 engine failed")
    current_run.partial_results["query"] = "timeout while waiting for upstream reviews"
    current_run.partial_results["insight"] = {
        "themes": ["service", "curation"],
        "duration_seconds": 1.6,
    }
    current_run = run_store.save_run(current_run)

    research_routes.RESEARCH_TASK_APP_SERVICE.set_task_status(
        task["id"],
        status="analyzing",
        last_action=current_run.last_action,
        generated_query=task["generated_query"],
        analysis_run_id=current_run.id,
    )

    response = client.get(f"/api/research/tasks/{task['id']}/analysis")

    assert response.status_code == 200
    payload = response.get_json()
    query_result = payload["analysis"]["current_run"]["partial_results"]["query"]
    insight_result = payload["analysis"]["current_run"]["partial_results"]["insight"]

    assert payload["success"] is True
    assert payload["task_id"] == task["id"]
    assert payload["analysis"]["analysis_run_id"] == current_run.id
    assert payload["analysis"]["status"] == "partial"
    assert payload["analysis"]["current_run"]["id"] == current_run.id
    assert payload["analysis"]["summary"]["last_action"] == current_run.last_action
    assert payload["analysis"]["summary"]["error"]["message"] == "1 engine failed"
    assert payload["analysis"]["summary"]["current_result_count"] == 2
    assert payload["analysis"]["stats"]["current_success_result_count"] == 1
    assert payload["analysis"]["stats"]["current_failed_result_count"] == 1
    assert query_result["engine_name"] == "query"
    assert query_result["status"] == "failed"
    assert query_result["success"] is False
    assert query_result["summary"] == "timeout while waiting for upstream reviews"
    assert query_result["error"]["message"] == "timeout while waiting for upstream reviews"
    assert insight_result["engine_name"] == "insight"
    assert insight_result["status"] == "completed"
    assert insight_result["success"] is True
    assert insight_result["summary"] == "insight completed"
    assert insight_result["artifacts"]["themes"] == ["service", "curation"]
    assert insight_result["metrics"]["duration_seconds"] == 1.6


def test_research_task_crawler_resource_endpoint_returns_empty_resource_without_linked_job(client):
    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Crawler Resource Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    response = client.get(f"/api/research/tasks/{task['id']}/crawler")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == task["id"]
    assert payload["crawler"]["crawler_job_id"] is None
    assert payload["crawler"]["current_job"] is None
    assert payload["crawler"]["jobs"] == []
    assert payload["crawler"]["summary"]["status"] == "idle"
    assert payload["crawler"]["history"]["has_jobs"] is False


def test_research_task_crawler_resource_endpoint_returns_linked_job_view(client, monkeypatch):
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Crawler Linked Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    created_task = create_response.get_json()["task"]
    research_routes.RESEARCH_TASK_APP_SERVICE.set_task_status(
        created_task["id"],
        status="crawling",
        last_action="Crawler linked",
        crawler_job_id="crawl-7",
    )

    class _FakeResearchCrawlerAppService:
        def build_task_crawler_resource_payload(self, *, research_task_id, crawler_job_id=None, task=None):
            assert research_task_id == created_task["id"]
            assert crawler_job_id == "crawl-7"
            return {
                "task_id": research_task_id,
                "crawler": {
                    "crawler_job_id": crawler_job_id,
                    "status": "running",
                    "task_status": getattr(task, "status", ""),
                    "current_job": {"id": "crawl-7", "job_id": "crawl-7", "status": "running"},
                    "jobs": [{"id": "crawl-7", "job_id": "crawl-7", "status": "running"}],
                    "summary": {"linked_job_id": crawler_job_id, "job_count": 1},
                    "history": {"linked_job_available": True, "linked_job_is_current": True},
                },
            }

    monkeypatch.setattr(
        research_routes,
        "RESEARCH_CRAWLER_APP_SERVICE",
        _FakeResearchCrawlerAppService(),
        raising=False,
    )

    response = client.get(f"/api/research/tasks/{created_task['id']}/crawler")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == created_task["id"]
    assert payload["crawler"]["crawler_job_id"] == "crawl-7"
    assert payload["crawler"]["current_job"]["id"] == "crawl-7"
    assert payload["crawler"]["jobs"][0]["id"] == "crawl-7"
    assert payload["crawler"]["summary"]["job_count"] == 1
    assert payload["crawler"]["history"]["linked_job_available"] is True


def test_crawler_start_smoke_exposes_mock_completed_crawler_output_via_task_resource(client, monkeypatch):
    import backend.crawler.routes as crawler_routes
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Crawler Completed Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    created_task = create_response.get_json()["task"]
    crawler_job_id = "crawl-completed-9"

    class _FakeCrawlerAppService:
        def start_crawler(self, payload: dict[str, object]) -> dict[str, object]:
            assert payload["research_task_id"] == created_task["id"]
            research_routes.RESEARCH_TASK_APP_SERVICE.set_task_status(
                created_task["id"],
                status="analyzing",
                last_action="Crawler completed and analysis can continue",
                generated_query=created_task["generated_query"],
                crawler_job_id=crawler_job_id,
            )
            return {
                "message": "crawler completed",
                "job_id": crawler_job_id,
            }

    class _FakeResearchCrawlerAppService:
        def build_task_crawler_resource_payload(self, *, research_task_id, crawler_job_id=None, task=None):
            assert research_task_id == created_task["id"]
            assert crawler_job_id == "crawl-completed-9"
            return {
                "task_id": research_task_id,
                "crawler": {
                    "crawler_job_id": crawler_job_id,
                    "status": "completed",
                    "task_status": getattr(task, "status", ""),
                    "current_job": {
                        "id": crawler_job_id,
                        "job_id": crawler_job_id,
                        "status": "completed",
                        "platform": "xhs",
                        "keywords": ["Shanghai", "Crawler Completed Venue"],
                        "last_action": "Collected 18 notes and 64 comments",
                        "result_summary": {"notes": 18, "comments": 64},
                    },
                    "jobs": [{
                        "id": crawler_job_id,
                        "job_id": crawler_job_id,
                        "status": "completed",
                        "platform": "xhs",
                    }],
                    "summary": {
                        "linked_job_id": crawler_job_id,
                        "current_job_id": crawler_job_id,
                        "job_count": 1,
                        "status": "completed",
                        "last_action": "Collected 18 notes and 64 comments",
                    },
                    "history": {
                        "has_jobs": True,
                        "linked_job_available": True,
                        "linked_job_is_current": True,
                    },
                },
            }

    monkeypatch.setattr(
        crawler_routes,
        "CRAWLER_APP_SERVICE",
        _FakeCrawlerAppService(),
        raising=False,
    )
    monkeypatch.setattr(
        research_routes,
        "RESEARCH_CRAWLER_APP_SERVICE",
        _FakeResearchCrawlerAppService(),
        raising=False,
    )

    start_response = client.post(
        "/api/crawler/start",
        json={
            "platform": "xhs",
            "keywords": "Shanghai Crawler Completed Venue",
            "research_task_id": created_task["id"],
        },
    )

    assert start_response.status_code == 200
    assert start_response.get_json() == {
        "success": True,
        "message": "crawler completed",
        "job_id": crawler_job_id,
    }

    snapshot_response = client.get("/api/research/tasks")

    assert snapshot_response.status_code == 200
    snapshot_payload = snapshot_response.get_json()
    assert snapshot_payload["success"] is True
    assert snapshot_payload["active_task"]["id"] == created_task["id"]
    assert snapshot_payload["active_task"]["status"] == "analyzing"
    assert snapshot_payload["active_task"]["crawler_job_id"] == crawler_job_id

    resource_response = client.get(f"/api/research/tasks/{created_task['id']}/crawler")

    assert resource_response.status_code == 200
    payload = resource_response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == created_task["id"]
    assert payload["crawler"]["crawler_job_id"] == crawler_job_id
    assert payload["crawler"]["status"] == "completed"
    assert payload["crawler"]["task_status"] == "analyzing"
    assert payload["crawler"]["current_job"]["id"] == crawler_job_id
    assert payload["crawler"]["current_job"]["result_summary"]["notes"] == 18
    assert payload["crawler"]["summary"]["linked_job_id"] == crawler_job_id
    assert payload["crawler"]["summary"]["current_job_id"] == crawler_job_id
    assert payload["crawler"]["summary"]["status"] == "completed"
    assert payload["crawler"]["summary"]["last_action"] == "Collected 18 notes and 64 comments"
    assert payload["crawler"]["history"]["linked_job_is_current"] is True


def test_forum_log_routes_expose_host_summary_from_runtime_log(client):
    from utils.runtime_paths import LOGS_DIR

    log_dir = Path(LOGS_DIR)
    log_dir.mkdir(parents=True, exist_ok=True)
    forum_log_path = log_dir / "forum.log"
    original_content = forum_log_path.read_text(encoding="utf-8") if forum_log_path.exists() else None
    forum_log_path.write_text(
        "\n".join([
            "[2026-04-22T10:50:00Z][Query Agent] Collected venue review snippets",
            "[2026-04-22T10:50:01Z][Insight Agent] Visitors consistently praise the guided route",
            "[2026-04-22T10:50:02Z][HOST] Summary: curation and staff guidance stand out across engines",
        ]) + "\n",
        encoding="utf-8",
    )

    try:
        log_response = client.get("/api/forum/log")
        history_response = client.post("/api/forum/log/history", json={"position": 0, "max_lines": 2})
        second_history_response = client.post(
            "/api/forum/log/history",
            json={"position": history_response.get_json()["position"], "max_lines": 2},
        )

        assert log_response.status_code == 200
        log_payload = log_response.get_json()
        assert log_payload["success"] is True
        assert len(log_payload["log_lines"]) == 3
        assert log_payload["parsed_messages"][-1] == {
            "timestamp": "2026-04-22T10:50:02Z",
            "source": "HOST",
            "content": "Summary: curation and staff guidance stand out across engines",
        }
        assert log_payload["engine_result"]["engine_name"] == "forum"
        assert log_payload["engine_result"]["status"] == "completed"
        assert log_payload["engine_result"]["summary"] == (
            "Summary: curation and staff guidance stand out across engines"
        )
        assert log_payload["engine_result"]["artifacts"]["host_summary"] == (
            "Summary: curation and staff guidance stand out across engines"
        )
        assert log_payload["engine_result"]["metrics"]["host_summary_count"] == 1

        assert history_response.status_code == 200
        history_payload = history_response.get_json()
        assert history_payload["success"] is True
        assert history_payload["log_lines"] == [
            "[2026-04-22T10:50:00Z][Query Agent] Collected venue review snippets",
            "[2026-04-22T10:50:01Z][Insight Agent] Visitors consistently praise the guided route",
        ]
        assert history_payload["has_more"] is True
        assert history_payload["position"] > 0
        assert history_payload["engine_result"]["engine_name"] == "forum"
        assert history_payload["engine_result"]["status"] == "stopped"
        assert history_payload["engine_result"]["summary"] == "Visitors consistently praise the guided route"
        assert history_payload["engine_result"]["metrics"]["host_summary_count"] == 0

        assert second_history_response.status_code == 200
        second_history_payload = second_history_response.get_json()
        assert second_history_payload["success"] is True
        assert second_history_payload["log_lines"] == [
            "[2026-04-22T10:50:02Z][HOST] Summary: curation and staff guidance stand out across engines"
        ]
        assert second_history_payload["has_more"] is False
        assert second_history_payload["engine_result"]["status"] == "completed"
        assert second_history_payload["engine_result"]["artifacts"]["host_summary"] == (
            "Summary: curation and staff guidance stand out across engines"
        )
        assert second_history_payload["engine_result"]["metrics"]["host_summary_count"] == 1
    finally:
        if original_content is None:
            forum_log_path.unlink(missing_ok=True)
        else:
            forum_log_path.write_text(original_content, encoding="utf-8")


def test_research_task_report_resource_endpoint_returns_empty_resource_without_linked_job(client):
    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Report Resource Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    task = create_response.get_json()["task"]

    response = client.get(f"/api/research/tasks/{task['id']}/report")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == task["id"]
    assert payload["report"]["report_job_id"] is None
    assert payload["report"]["current_job"] is None
    assert payload["report"]["jobs"] == []
    assert payload["report"]["summary"]["status"] == "idle"
    assert payload["report"]["history"]["has_jobs"] is False


def test_research_task_report_resource_endpoint_returns_linked_job_view(client, monkeypatch):
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Report Linked Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    created_task = create_response.get_json()["task"]
    original_get_task_dto = research_routes.RESEARCH_TASK_APP_SERVICE.get_task_dto

    def _get_task_dto_with_report_link(task_id):
        task_dto = original_get_task_dto(task_id)
        if task_id != created_task["id"]:
            return task_dto
        return task_dto.model_copy(
            update={
                "report_job_id": "report-7",
                "status": "reporting",
                "last_action": "Report linked",
            }
        )

    class _FakeResearchReportAppService:
        def build_task_report_resource_payload(self, *, research_task_id, report_job_id=None, task=None):
            assert research_task_id == created_task["id"]
            assert report_job_id == "report-7"
            return {
                "task_id": research_task_id,
                "report": {
                    "report_job_id": report_job_id,
                    "status": "completed",
                    "task_status": getattr(task, "status", ""),
                    "current_job": {
                        "id": "report-7",
                        "task_id": "report-7",
                        "research_task_id": research_task_id,
                        "status": "completed",
                    },
                    "jobs": [
                        {
                            "id": "report-7",
                            "task_id": "report-7",
                            "research_task_id": research_task_id,
                            "status": "completed",
                        }
                    ],
                    "summary": {
                        "linked_job_id": report_job_id,
                        "current_job_id": "report-7",
                        "job_count": 1,
                        "output_ready": True,
                    },
                    "history": {"linked_job_available": True, "linked_job_is_current": True},
                },
            }

    monkeypatch.setattr(research_routes.RESEARCH_TASK_APP_SERVICE, "get_task_dto", _get_task_dto_with_report_link)
    monkeypatch.setattr(
        research_routes,
        "RESEARCH_REPORT_APP_SERVICE",
        _FakeResearchReportAppService(),
        raising=False,
    )

    response = client.get(f"/api/research/tasks/{created_task['id']}/report")

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == created_task["id"]
    assert payload["report"]["report_job_id"] == "report-7"
    assert payload["report"]["task_status"] == "reporting"
    assert payload["report"]["current_job"]["id"] == "report-7"
    assert payload["report"]["jobs"][0]["id"] == "report-7"
    assert payload["report"]["summary"]["job_count"] == 1
    assert payload["report"]["summary"]["output_ready"] is True
    assert payload["report"]["history"]["linked_job_available"] is True


def test_research_task_report_resource_returns_503_when_report_service_is_not_configured(client, monkeypatch):
    import backend.research_routes as research_routes

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Report Missing Wiring Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    created_task = create_response.get_json()["task"]

    monkeypatch.setattr(research_routes, "_REPORT_APP_SERVICE", None, raising=False)

    response = client.get(f"/api/research/tasks/{created_task['id']}/report")

    assert response.status_code == 503
    assert response.get_json() == {
        "success": False,
        "message": "Report service is not configured.",
    }


def test_report_generate_links_report_job_back_to_research_task(client, monkeypatch):
    import services.engines.report.flask_interface as report_runtime

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Report Generate Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    created_task = create_response.get_json()["task"]

    report_runtime.REPORT_TASK_RUNTIME.replace_registry([], current_task=None)

    class _FakeThread:
        def __init__(self, target=None, args=(), daemon=False):
            self.target = target
            self.args = args
            self.daemon = daemon
            self.started = False

        def start(self):
            self.started = True

    monkeypatch.setattr(report_runtime, "report_agent", object(), raising=False)
    monkeypatch.setattr(report_runtime, "clear_report_log", lambda: None)
    monkeypatch.setattr(
        report_runtime,
        "check_engines_ready",
        lambda: {"ready": True, "missing_files": [], "files_found": []},
    )
    monkeypatch.setattr(report_runtime.threading, "Thread", _FakeThread)

    response = client.post(
        "/api/report/generate",
        json={
            "query": created_task["generated_query"],
            "research_task_id": created_task["id"],
        },
    )

    assert response.status_code == 200
    payload = response.get_json()
    assert payload["success"] is True
    assert payload["task_id"].startswith("report_")
    assert payload["task"]["research_task_id"] == created_task["id"]

    snapshot_response = client.get("/api/research/tasks")
    snapshot_payload = snapshot_response.get_json()
    active_task = snapshot_payload["active_task"]

    assert active_task["id"] == created_task["id"]
    assert active_task["status"] == "reporting"
    assert active_task["report_job_id"] == payload["task_id"]


def test_report_generate_exposes_linked_runtime_job_via_task_scoped_report_resource(client, monkeypatch):
    import services.engines.report.flask_interface as report_runtime

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Report Resource Linked Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    created_task = create_response.get_json()["task"]

    report_runtime.REPORT_TASK_RUNTIME.replace_registry([], current_task=None)

    class _FakeThread:
        def __init__(self, target=None, args=(), daemon=False):
            self.target = target
            self.args = args
            self.daemon = daemon

        def start(self):
            return None

    monkeypatch.setattr(report_runtime, "report_agent", object(), raising=False)
    monkeypatch.setattr(report_runtime, "clear_report_log", lambda: None)
    monkeypatch.setattr(
        report_runtime,
        "check_engines_ready",
        lambda: {"ready": True, "missing_files": [], "files_found": []},
    )
    monkeypatch.setattr(report_runtime.threading, "Thread", _FakeThread)

    generate_response = client.post(
        "/api/report/generate",
        json={
            "query": created_task["generated_query"],
            "research_task_id": created_task["id"],
        },
    )

    assert generate_response.status_code == 200
    report_job_id = generate_response.get_json()["task_id"]

    report_response = client.get(f"/api/research/tasks/{created_task['id']}/report")

    assert report_response.status_code == 200
    payload = report_response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == created_task["id"]
    assert payload["report"]["report_job_id"] == report_job_id
    assert payload["report"]["status"] == "pending"
    assert payload["report"]["task_status"] == "reporting"
    assert payload["report"]["current_job"]["id"] == report_job_id
    assert payload["report"]["current_job"]["research_task_id"] == created_task["id"]
    assert payload["report"]["jobs"][0]["id"] == report_job_id
    assert payload["report"]["summary"]["current_job_id"] == report_job_id
    assert payload["report"]["summary"]["linked_job_id"] == report_job_id
    assert payload["report"]["history"]["linked_job_available"] is True
    assert payload["report"]["history"]["linked_job_is_current"] is True


def test_report_generate_completed_job_exposes_output_via_task_scoped_resource_and_result_routes(
    client,
    monkeypatch,
):
    import services.engines.report.flask_interface as report_runtime

    create_response = client.post(
        "/api/research/tasks",
        json={
            "venue_name": "Report Completed Venue",
            "city": "Shanghai",
            "research_focus": "strengths_improvements",
            "venue_type": "museum",
            "time_range": "recent_90_days",
        },
    )
    created_task = create_response.get_json()["task"]

    report_runtime.REPORT_TASK_RUNTIME.replace_registry([], current_task=None)

    class _FakeThread:
        def __init__(self, target=None, args=(), daemon=False):
            self.target = target
            self.args = args
            self.daemon = daemon

        def start(self):
            return None

    monkeypatch.setattr(report_runtime, "report_agent", object(), raising=False)
    monkeypatch.setattr(report_runtime, "clear_report_log", lambda: None)
    monkeypatch.setattr(
        report_runtime,
        "check_engines_ready",
        lambda: {"ready": True, "missing_files": [], "files_found": []},
    )
    monkeypatch.setattr(report_runtime.threading, "Thread", _FakeThread)
    monkeypatch.setattr(report_runtime.ReportTask, "persist_snapshot", lambda self: None)
    monkeypatch.setattr(
        report_runtime.REPORT_QUERY_SERVICE,
        "_file_exists",
        lambda path: path == "/virtual/report-completed.html",
    )
    monkeypatch.setattr(
        report_runtime,
        "send_file",
        lambda file_path, mimetype, as_attachment, download_name: report_runtime.Response(
            f"{file_path}|{download_name}|{as_attachment}",
            mimetype=mimetype,
        ),
    )

    generate_response = client.post(
        "/api/report/generate",
        json={
            "query": created_task["generated_query"],
            "research_task_id": created_task["id"],
        },
    )

    assert generate_response.status_code == 200
    report_job_id = generate_response.get_json()["task_id"]

    runtime_task = report_runtime.REPORT_TASK_RUNTIME.get_task(report_job_id)
    assert runtime_task is not None
    runtime_task.report_file_path = "/virtual/report-completed.html"
    runtime_task.report_file_name = "report-completed.html"
    runtime_task.html_content = "<h1>completed smoke report</h1>"

    runtime_task.update_status("completed", progress=100)

    snapshot_response = client.get("/api/research/tasks")
    snapshot_payload = snapshot_response.get_json()
    active_task = snapshot_payload["active_task"]

    assert active_task["id"] == created_task["id"]
    assert active_task["status"] == "completed"
    assert active_task["report_job_id"] == report_job_id

    report_response = client.get(f"/api/research/tasks/{created_task['id']}/report")

    assert report_response.status_code == 200
    payload = report_response.get_json()
    assert payload["success"] is True
    assert payload["task_id"] == created_task["id"]
    assert payload["report"]["report_job_id"] == report_job_id
    assert payload["report"]["status"] == "completed"
    assert payload["report"]["task_status"] == "completed"
    assert payload["report"]["current_job"]["id"] == report_job_id
    assert payload["report"]["current_job"]["report_file_ready"] is True
    assert payload["report"]["current_job"]["report_file_name"] == "report-completed.html"
    assert payload["report"]["current_job"]["report_file_path"] == "/virtual/report-completed.html"
    assert payload["report"]["current_job"]["has_result"] is True
    assert payload["report"]["current_job"]["engine_result"]["engine_name"] == "report"
    assert payload["report"]["current_job"]["engine_result"]["status"] == "completed"
    assert payload["report"]["summary"]["output_ready"] is True
    assert payload["report"]["summary"]["output_path"] == "/virtual/report-completed.html"
    assert payload["report"]["summary"]["output_format"] == "html"
    assert payload["report"]["history"]["linked_job_available"] is True
    assert payload["report"]["history"]["linked_job_is_current"] is True
    assert payload["report"]["engine_result"]["engine_name"] == "report"
    assert payload["report"]["engine_result"]["status"] == "completed"
    assert payload["report"]["engine_result"]["artifacts"]["report_file_path"] == "/virtual/report-completed.html"

    result_response = client.get(f"/api/report/result/{report_job_id}/json")
    download_response = client.get(f"/api/report/download/{report_job_id}")

    assert result_response.status_code == 200
    result_payload = result_response.get_json()
    assert result_payload["success"] is True
    assert result_payload["html_content"] == "<h1>completed smoke report</h1>"
    assert result_payload["task"]["task_id"] == report_job_id
    assert result_payload["task"]["status"] == "completed"
    assert result_payload["task"]["research_task_id"] == created_task["id"]
    assert result_payload["task"]["report_file_ready"] is True
    assert result_payload["task"]["report_file_name"] == "report-completed.html"
    assert result_payload["task"]["report_file_path"] == "/virtual/report-completed.html"
    assert result_payload["task"]["query"] == created_task["generated_query"]
    assert result_payload["task"]["has_result"] is True
    assert result_payload["task"]["engine_result"]["engine_name"] == "report"
    assert result_payload["task"]["engine_result"]["status"] == "completed"
    assert result_payload["task"]["engine_result"]["artifacts"]["report_file_path"] == "/virtual/report-completed.html"
    assert result_payload["task"]["unified_task"]["engine_result"]["status"] == "completed"
    assert download_response.status_code == 200
    assert download_response.mimetype == "text/html"
    assert (
        download_response.get_data(as_text=True)
        == "/virtual/report-completed.html|report-completed.html|True"
    )


def test_report_status_and_tasks_routes_delegate_to_query_service(client, monkeypatch):
    import services.engines.report.flask_interface as report_runtime

    monkeypatch.setattr(
        report_runtime.REPORT_QUERY_SERVICE,
        "build_report_status_payload",
        lambda: {
            "success": True,
            "initialized": True,
            "engines_ready": True,
            "files_found": ["query.md"],
            "missing_files": [],
            "current_task": {
                "task_id": "report-1",
                "status": "running",
                "engine_result": {"engine_name": "report", "status": "rendering"},
            },
            "tasks": [
                {
                    "task_id": "report-1",
                    "status": "running",
                    "engine_result": {"engine_name": "report", "status": "rendering"},
                }
            ],
        },
    )
    monkeypatch.setattr(
        report_runtime.REPORT_QUERY_SERVICE,
        "build_report_tasks_payload",
        lambda: {
            "success": True,
            "current_task": {
                "task_id": "report-2",
                "status": "pending",
                "engine_result": {"engine_name": "report", "status": "pending"},
            },
            "tasks": [
                {
                    "task_id": "report-2",
                    "status": "pending",
                    "engine_result": {"engine_name": "report", "status": "pending"},
                }
            ],
        },
    )

    status_response = client.get("/api/report/status")
    tasks_response = client.get("/api/report/tasks")

    assert status_response.status_code == 200
    assert status_response.get_json() == {
        "success": True,
        "initialized": True,
        "engines_ready": True,
        "files_found": ["query.md"],
        "missing_files": [],
        "current_task": {
            "task_id": "report-1",
            "status": "running",
            "engine_result": {"engine_name": "report", "status": "rendering"},
        },
        "tasks": [
            {
                "task_id": "report-1",
                "status": "running",
                "engine_result": {"engine_name": "report", "status": "rendering"},
            }
        ],
    }
    assert tasks_response.status_code == 200
    assert tasks_response.get_json() == {
        "success": True,
        "current_task": {
            "task_id": "report-2",
            "status": "pending",
            "engine_result": {"engine_name": "report", "status": "pending"},
        },
        "tasks": [
            {
                "task_id": "report-2",
                "status": "pending",
                "engine_result": {"engine_name": "report", "status": "pending"},
            }
        ],
    }


def test_report_progress_route_delegates_to_query_service(client, monkeypatch):
    import services.engines.report.flask_interface as report_runtime

    monkeypatch.setattr(
        report_runtime.REPORT_QUERY_SERVICE,
        "build_report_progress_payload",
        lambda task_id: {
            "success": True,
            "task": {
                "task_id": task_id,
                "status": "running",
                "progress": 55,
                "engine_result": {"engine_name": "report", "status": "rendering"},
            },
        },
    )

    response = client.get("/api/report/progress/report-live")

    assert response.status_code == 200
    assert response.get_json() == {
        "success": True,
        "task": {
            "task_id": "report-live",
            "status": "running",
            "progress": 55,
            "engine_result": {"engine_name": "report", "status": "rendering"},
        },
    }


def test_report_stream_route_returns_404_for_unknown_task(client):
    response = client.get("/api/report/stream/report-missing")

    assert response.status_code == 404
    assert response.get_json()["success"] is False


def test_report_stream_route_replays_history_with_sse_headers(client):
    import services.engines.report.flask_interface as report_runtime

    task = report_runtime.ReportTask(query="stream smoke", task_id="report-stream-smoke")
    task.publish_event("status", {"status": "running", "progress": 25})
    task.publish_event("completed", {"status": "completed", "progress": 100})
    first_event, second_event = task.history_since(None)
    task.status = "completed"
    task.progress = 100
    report_runtime.REPORT_TASK_RUNTIME.replace_registry([task], current_task=task)

    try:
        response = client.get(
            f"/api/report/stream/{task.task_id}",
            headers={"Last-Event-ID": str(first_event["id"])},
            buffered=True,
        )
    finally:
        report_runtime.REPORT_TASK_RUNTIME.replace_registry([], current_task=None)

    body = response.get_data(as_text=True)

    assert response.status_code == 200
    assert response.mimetype == "text/event-stream"
    assert response.headers["Cache-Control"] == "no-cache"
    assert response.headers["X-Accel-Buffering"] == "no"
    assert f"id: {first_event['id']}" not in body
    assert f"id: {second_event['id']}" in body
    assert "event: completed" in body
    assert '"status": "completed"' in body


def test_report_cancel_route_delegates_to_app_service(client, monkeypatch):
    import services.engines.report.flask_interface as report_runtime

    calls: list[str] = []

    class _FakeReportAppService:
        def cancel_report(self, task_id: str):
            calls.append(task_id)
            return {
                "message": "cancelled by service",
                "task": {"task_id": task_id, "status": "cancelled"},
            }

    monkeypatch.setattr(report_runtime, "REPORT_APP_SERVICE", _FakeReportAppService(), raising=False)

    response = client.post("/api/report/cancel/report-9")

    assert response.status_code == 200
    assert response.get_json() == {
        "success": True,
        "message": "cancelled by service",
        "task": {"task_id": "report-9", "status": "cancelled"},
    }
    assert calls == ["report-9"]


def test_report_log_routes_delegate_to_application_services(client, monkeypatch):
    import services.engines.report.flask_interface as report_runtime

    monkeypatch.setattr(
        report_runtime.REPORT_QUERY_SERVICE,
        "build_report_log_payload",
        lambda: {"success": True, "log_lines": ["line-1", "line-2"]},
    )

    class _FakeReportAppService:
        def clear_report_log(self):
            return {"message": "日志已清空"}

    monkeypatch.setattr(report_runtime, "REPORT_APP_SERVICE", _FakeReportAppService(), raising=False)

    log_response = client.get("/api/report/log")
    clear_response = client.post("/api/report/log/clear")

    assert log_response.status_code == 200
    assert log_response.get_json() == {"success": True, "log_lines": ["line-1", "line-2"]}
    assert clear_response.status_code == 200
    assert clear_response.get_json() == {"success": True, "message": "日志已清空"}


def test_report_templates_route_delegates_to_query_service(client, monkeypatch):
    import services.engines.report.flask_interface as report_runtime

    monkeypatch.setattr(
        report_runtime.REPORT_QUERY_SERVICE,
        "build_report_templates_payload",
        lambda: {
            "success": True,
            "templates": [
                {
                    "name": "briefing",
                    "filename": "briefing.md",
                    "description": "Briefing template",
                    "size": 18,
                }
            ],
            "template_dir": "/virtual/templates",
        },
    )

    response = client.get("/api/report/templates")

    assert response.status_code == 200
    assert response.get_json() == {
        "success": True,
        "templates": [
            {
                "name": "briefing",
                "filename": "briefing.md",
                "description": "Briefing template",
                "size": 18,
            }
        ],
        "template_dir": "/virtual/templates",
    }


def test_report_result_and_download_routes_delegate_to_query_service(client, monkeypatch):
    import services.engines.report.flask_interface as report_runtime

    monkeypatch.setattr(
        report_runtime.REPORT_QUERY_SERVICE,
        "build_report_html_payload",
        lambda task_id: {
            "task": {
                "task_id": task_id,
                "status": "completed",
                "engine_result": {"engine_name": "report", "status": "completed"},
            },
            "html_content": f"<h1>{task_id}</h1>",
        },
    )
    monkeypatch.setattr(
        report_runtime.REPORT_QUERY_SERVICE,
        "build_report_result_payload",
        lambda task_id: {
            "success": True,
            "task": {
                "task_id": task_id,
                "status": "completed",
                "engine_result": {"engine_name": "report", "status": "completed"},
            },
            "html_content": f"<h1>{task_id}</h1>",
        },
    )
    monkeypatch.setattr(
        report_runtime.REPORT_QUERY_SERVICE,
        "build_report_download_descriptor",
        lambda task_id: {
            "file_path": "/virtual/report.html",
            "download_name": f"{task_id}.html",
            "mimetype": "text/html",
        },
    )
    monkeypatch.setattr(
        report_runtime,
        "send_file",
        lambda file_path, mimetype, as_attachment, download_name: report_runtime.Response(
            f"{file_path}|{download_name}|{as_attachment}",
            mimetype=mimetype,
        ),
    )

    html_response = client.get("/api/report/result/report-delegated")
    json_response = client.get("/api/report/result/report-delegated/json")
    download_response = client.get("/api/report/download/report-delegated")

    assert html_response.status_code == 200
    assert html_response.mimetype == "text/html"
    assert html_response.get_data(as_text=True) == "<h1>report-delegated</h1>"

    assert json_response.status_code == 200
    assert json_response.get_json() == {
        "success": True,
        "task": {
            "task_id": "report-delegated",
            "status": "completed",
            "engine_result": {"engine_name": "report", "status": "completed"},
        },
        "html_content": "<h1>report-delegated</h1>",
    }

    assert download_response.status_code == 200
    assert download_response.mimetype == "text/html"
    assert download_response.get_data(as_text=True) == "/virtual/report.html|report-delegated.html|True"


def test_report_export_routes_use_query_service_export_source(client, monkeypatch):
    import services.engines.report.flask_interface as report_runtime

    class _FakeReportExportService:
        def export_markdown(self, task_id: str):
            assert task_id == "report-export"
            return {
                "file_path": "/virtual/output/report-export.md",
                "download_name": "report-export.md",
                "mimetype": "text/markdown",
            }

        def export_pdf(self, task_id: str, *, optimize_layout: bool = True):
            assert task_id == "report-export"
            assert optimize_layout is False
            return {
                "content_bytes": b"%PDF-delegated",
                "download_name": "report-export.pdf",
                "mimetype": "application/pdf",
            }

    monkeypatch.setattr(report_runtime, "REPORT_EXPORT_SERVICE", _FakeReportExportService(), raising=False)
    monkeypatch.setattr(
        report_runtime,
        "send_file",
        lambda file_path, mimetype, as_attachment, download_name: report_runtime.Response(
            f"{file_path}|{download_name}|{as_attachment}",
            mimetype=mimetype,
        ),
    )
    markdown_response = client.get("/api/report/export/md/report-export")
    pdf_response = client.get("/api/report/export/pdf/report-export?optimize=false")

    assert markdown_response.status_code == 200
    assert markdown_response.mimetype == "text/markdown"
    assert markdown_response.get_data(as_text=True) == "/virtual/output/report-export.md|report-export.md|True"

    assert pdf_response.status_code == 200
    assert pdf_response.mimetype == "application/pdf"
    assert pdf_response.get_data() == b"%PDF-delegated"


def test_report_export_pdf_from_ir_route_returns_pdf_bytes(client, monkeypatch):
    import services.engines.report.renderers as report_renderers
    import services.engines.report.utils.dependency_check as dependency_check

    calls: list[tuple[dict[str, object], bool]] = []

    class _FakePDFRenderer:
        def render_to_bytes(self, document_ir, *, optimize_layout=True):
            calls.append((document_ir, optimize_layout))
            return b"%PDF-from-ir"

    monkeypatch.setattr(
        dependency_check,
        "check_pango_available",
        lambda: (True, "ready"),
    )
    monkeypatch.setattr(report_renderers, "PDFRenderer", _FakePDFRenderer)

    document_ir = {"metadata": {"topic": "smoke"}, "sections": []}

    response = client.post(
        "/api/report/export/pdf-from-ir",
        json={"document_ir": document_ir, "optimize": False},
    )

    assert response.status_code == 200
    assert response.mimetype == "application/pdf"
    assert response.get_data() == b"%PDF-from-ir"
    assert 'attachment; filename="report_smoke_' in response.headers["Content-Disposition"]
    assert calls == [(document_ir, False)]


def test_report_export_pdf_from_ir_route_rejects_non_object_json_body(client, monkeypatch):
    import services.engines.report.utils.dependency_check as dependency_check

    monkeypatch.setattr(
        dependency_check,
        "check_pango_available",
        lambda: (True, "ready"),
    )

    response = client.post("/api/report/export/pdf-from-ir", json=["not", "an", "object"])

    assert response.status_code == 400
    assert response.get_json() == {
        "success": False,
        "error": "请求体必须是JSON对象",
    }


def test_report_export_pdf_from_ir_route_requires_document_ir(client, monkeypatch):
    import services.engines.report.utils.dependency_check as dependency_check

    monkeypatch.setattr(
        dependency_check,
        "check_pango_available",
        lambda: (True, "ready"),
    )

    response = client.post("/api/report/export/pdf-from-ir", json={"optimize": True})

    assert response.status_code == 400
    assert response.get_json() == {
        "success": False,
        "error": "缺少document_ir参数",
    }


def test_report_export_pdf_from_ir_route_returns_503_when_pdf_dependency_missing(client, monkeypatch):
    import services.engines.report.utils.dependency_check as dependency_check

    monkeypatch.setattr(
        dependency_check,
        "check_pango_available",
        lambda: (False, "pango missing"),
    )

    response = client.post(
        "/api/report/export/pdf-from-ir",
        json={"document_ir": {"metadata": {"topic": "blocked"}}},
    )

    assert response.status_code == 503
    assert response.get_json() == {
        "success": False,
        "error": "PDF 导出功能不可用：缺少系统依赖",
        "details": '请查看根目录 README.md "源码启动"的第二步（PDF 导出依赖）了解安装方法',
        "help_url": "https://github.com/666ghj/BettaFish#2-安装-pdf-导出所需系统依赖可选",
        "system_message": "pango missing",
    }