from __future__ import annotations

from pathlib import Path

import pytest

from services.application.report import ReportJobQueryService
from services.application.report import (
    ReportArtifactNotFoundError,
    ReportLogAccessError,
    ReportJobNotFoundError,
    ReportJobNotReadyError,
)
from services.shared.dto import ResearchTaskDTO, ReportJobDTO


class _FakeReportTask:
    def __init__(self, dto: ReportJobDTO) -> None:
        self._dto = dto

    def to_dto(self) -> ReportJobDTO:
        return self._dto


class _FakeRuntimeReportTask:
    def __init__(self, payload: dict[str, object]) -> None:
        self._payload = payload

    def to_dict(self) -> dict[str, object]:
        return dict(self._payload)


class _FakeRuntimeExportTask:
    def __init__(
        self,
        *,
        task_id: str = "report-1",
        status: str = "completed",
        html_content: str = "",
        report_file_path: str = "",
        report_file_name: str = "",
        ir_file_path: str = "",
        query: str = "report query",
        engine_result: dict[str, object] | None = None,
    ) -> None:
        self.task_id = task_id
        self.status = status
        self.html_content = html_content
        self.report_file_path = report_file_path
        self.report_file_name = report_file_name
        self.ir_file_path = ir_file_path
        self.query = query
        self.engine_result = engine_result or {}

    def to_dict(self) -> dict[str, object]:
        return {
            "task_id": self.task_id,
            "status": self.status,
            "report_file_path": self.report_file_path,
            "report_file_name": self.report_file_name,
            "ir_file_path": self.ir_file_path,
            "query": self.query,
            "has_result": bool(self.html_content or self.report_file_path),
            "engine_result": dict(self.engine_result),
        }


def test_get_report_job_dto_returns_none_for_blank_id():
    service = ReportJobQueryService(report_job_getter=lambda _job_id: None)

    assert service.get_report_job_dto("") is None
    assert service.get_report_job_dto("   ") is None


def test_get_report_job_dto_reads_back_existing_report_job():
    report_dto = ReportJobDTO(
        id="report-1",
        research_task_id="task-report-service",
        status="completed",
        output_path="reports/report-1.html",
        output_format="html",
        artifacts={"report_file_ready": True},
        last_action="Report generated",
        updated_at="2026-04-17T10:00:00",
    )
    service = ReportJobQueryService(
        report_job_getter=lambda report_job_id: _FakeReportTask(report_dto) if report_job_id == "report-1" else None
    )

    dto = service.get_report_job_dto("report-1")

    assert dto is not None
    assert dto.id == "report-1"
    assert dto.to_response_item()["task_id"] == "report-1"
    assert dto.to_response_item()["engine_result"]["engine_name"] == "report"
    assert dto.to_response_item()["engine_result"]["status"] == "completed"
    assert dto.to_response_item()["engine_result"]["artifacts"]["report_file_ready"] is True


def test_get_report_job_dto_can_coerce_runtime_dict_via_shared_mapper():
    service = ReportJobQueryService(
        report_job_getter=lambda report_job_id: {
            "task_id": report_job_id,
            "research_task_id": "task-report-service",
            "status": "running",
            "progress": 35,
            "report_file_path": "reports/report-raw.html",
            "report_file_name": "report-raw.html",
            "query": "raw runtime report",
        }
    )

    dto = service.get_report_job_dto("report-raw")

    assert dto is not None
    assert dto.id == "report-raw"
    assert dto.research_task_id == "task-report-service"
    assert dto.status == "rendering"
    assert dto.output_path == "reports/report-raw.html"


def test_build_task_report_resource_payload_stays_empty_without_linked_job():
    calls: list[str] = []
    service = ReportJobQueryService(report_job_getter=lambda report_job_id: calls.append(report_job_id))

    payload = service.build_task_report_resource_payload(
        research_task_id="task-report-service",
        task=ResearchTaskDTO(
            id="task-report-service",
            status="reporting",
            last_action="Waiting for report job",
            updated_at="2026-04-17T11:00:00",
        ),
    )

    assert calls == []
    assert payload["task_id"] == "task-report-service"
    assert payload["report"]["report_job_id"] is None
    assert payload["report"]["current_job"] is None
    assert payload["report"]["engine_result"] is None
    assert payload["report"]["jobs"] == []
    assert payload["report"]["summary"]["status"] == "idle"
    assert payload["report"]["summary"]["last_action"] == "Waiting for report job"
    assert payload["report"]["history"]["has_jobs"] is False


def test_build_task_report_resource_payload_marks_missing_linked_job_as_unavailable():
    calls: list[str] = []
    service = ReportJobQueryService(
        report_job_getter=lambda report_job_id: calls.append(report_job_id) or None
    )

    payload = service.build_task_report_resource_payload(
        research_task_id="task-report-service",
        report_job_id="report-missing",
        task=ResearchTaskDTO(
            id="task-report-service",
            status="reporting",
            last_action="Waiting for linked report job",
            updated_at="2026-04-17T11:30:00",
        ),
    )

    assert calls == ["report-missing"]
    assert payload["report"]["report_job_id"] == "report-missing"
    assert payload["report"]["current_job"] is None
    assert payload["report"]["jobs"] == []
    assert payload["report"]["summary"]["status"] == "idle"
    assert payload["report"]["summary"]["task_status"] == "reporting"
    assert payload["report"]["summary"]["last_action"] == "Waiting for linked report job"
    assert payload["report"]["history"]["has_linked_job"] is True
    assert payload["report"]["history"]["linked_job_available"] is False
    assert payload["report"]["history"]["linked_job_is_current"] is False


def test_build_task_report_resource_payload_returns_only_linked_job_view():
    linked_report = ReportJobDTO(
        id="report-9",
        research_task_id="task-report-service",
        status="completed",
        output_path="reports/report-9.html",
        output_format="html",
        artifacts={"report_file_ready": True, "has_result": True},
        last_action="Report ready",
        updated_at="2026-04-17T12:00:00",
    )
    service = ReportJobQueryService(
        report_job_getter=lambda report_job_id: _FakeReportTask(linked_report) if report_job_id == "report-9" else None
    )

    payload = service.build_task_report_resource_payload(
        research_task_id="task-report-service",
        report_job_id="report-9",
        task=ResearchTaskDTO(
            id="task-report-service",
            status="reporting",
            last_action="Report linked",
            updated_at="2026-04-17T11:59:00",
        ),
    )

    assert payload["task_id"] == "task-report-service"
    assert payload["report"]["report_job_id"] == "report-9"
    assert payload["report"]["current_job"]["id"] == "report-9"
    assert payload["report"]["current_job"]["engine_result"]["engine_name"] == "report"
    assert payload["report"]["current_job"]["engine_result"]["status"] == "completed"
    assert payload["report"]["engine_result"]["engine_name"] == "report"
    assert payload["report"]["engine_result"]["status"] == "completed"
    assert payload["report"]["engine_result"]["artifacts"]["report_file_path"] == "reports/report-9.html"
    assert [item["id"] for item in payload["report"]["jobs"]] == ["report-9"]
    assert payload["report"]["summary"]["current_job_id"] == "report-9"
    assert payload["report"]["summary"]["output_ready"] is True
    assert payload["report"]["summary"]["output_path"] == "reports/report-9.html"
    assert payload["report"]["history"]["linked_job_available"] is True
    assert payload["report"]["history"]["linked_job_is_current"] is True


def test_build_report_status_payload_merges_runtime_status_and_snapshot():
    service = ReportJobQueryService(
        report_engine_status_getter=lambda: {
            "ready": True,
            "files_found": ["report_agent.py"],
            "missing_files": [],
        },
        report_tasks_snapshot_getter=lambda: {
            "current_task": {
                "task_id": "report-1",
                "status": "running",
                "progress": 42,
            },
            "tasks": [
                {
                    "task_id": "report-1",
                    "status": "running",
                    "progress": 42,
                },
                {
                    "task_id": "report-0",
                    "status": "completed",
                    "progress": 100,
                },
            ],
        },
        report_initialized_getter=lambda: True,
    )

    payload = service.build_report_status_payload()

    assert payload["success"] is True
    assert payload["initialized"] is True
    assert payload["engines_ready"] is True
    assert payload["files_found"] == ["report_agent.py"]
    assert payload["missing_files"] == []
    assert payload["current_task"]["task_id"] == "report-1"
    assert payload["current_task"]["status"] == "running"
    assert payload["current_task"]["progress"] == 42
    assert payload["current_task"]["engine_result"]["engine_name"] == "report"
    assert payload["current_task"]["engine_result"]["status"] == "rendering"
    assert payload["current_task"]["engine_result"]["metrics"]["progress_percent"] == 42
    assert payload["current_task"]["unified_task"]["status"] == "rendering"
    assert payload["tasks"][0]["task_id"] == "report-1"
    assert payload["tasks"][0]["status"] == "running"
    assert payload["tasks"][0]["progress"] == 42
    assert payload["tasks"][0]["engine_result"]["status"] == "rendering"
    assert payload["tasks"][0]["unified_task"]["status"] == "rendering"
    assert payload["tasks"][1]["task_id"] == "report-0"
    assert payload["tasks"][1]["status"] == "completed"
    assert payload["tasks"][1]["progress"] == 100


def test_build_report_tasks_payload_returns_snapshot_only():
    service = ReportJobQueryService(
        report_tasks_snapshot_getter=lambda: {
            "current_task": {"task_id": "report-2", "status": "pending"},
            "tasks": [{"task_id": "report-2", "status": "pending"}],
        }
    )

    payload = service.build_report_tasks_payload()

    assert payload["success"] is True
    assert payload["current_task"]["task_id"] == "report-2"
    assert payload["current_task"]["status"] == "pending"
    assert payload["current_task"]["progress"] == 0
    assert payload["current_task"]["engine_result"]["engine_name"] == "report"
    assert payload["current_task"]["engine_result"]["status"] == "pending"
    assert payload["current_task"]["unified_task"]["status"] == "pending"
    assert payload["tasks"][0]["task_id"] == "report-2"
    assert payload["tasks"][0]["status"] == "pending"
    assert payload["tasks"][0]["progress"] == 0
    assert payload["tasks"][0]["engine_result"]["status"] == "pending"


def test_build_report_progress_payload_returns_runtime_task_dict():
    runtime_payload = {
        "task_id": "report-live",
        "status": "running",
        "progress": 73,
        "has_result": False,
        "engine_result": {
            "engine_name": "report",
            "status": "running",
            "success": True,
            "summary": "draft report sections compiled",
            "artifacts": {"report_preview": "Section A"},
        },
    }
    service = ReportJobQueryService(
        report_job_getter=lambda report_job_id: _FakeRuntimeReportTask(runtime_payload)
        if report_job_id == "report-live"
        else None
    )

    payload = service.build_report_progress_payload("report-live")

    assert payload["success"] is True
    assert payload["task"]["task_id"] == "report-live"
    assert payload["task"]["status"] == "running"
    assert payload["task"]["progress"] == 73
    assert payload["task"]["engine_result"]["engine_name"] == "report"
    assert payload["task"]["engine_result"]["status"] == "running"
    assert payload["task"]["engine_result"]["summary"] == "draft report sections compiled"
    assert payload["task"]["engine_result"]["artifacts"]["report_preview"] == "Section A"
    assert payload["task"]["engine_result"]["metrics"]["progress_percent"] == 73
    assert payload["task"]["unified_task"]["status"] == "rendering"


def test_build_report_progress_payload_returns_completed_fallback_when_missing():
    service = ReportJobQueryService(report_job_getter=lambda _report_job_id: None)

    payload = service.build_report_progress_payload("report-missing")

    assert payload["success"] is True
    assert payload["task"]["task_id"] == "report-missing"
    assert payload["task"]["status"] == "completed"
    assert payload["task"]["progress"] == 100
    assert payload["task"]["error_message"] == ""
    assert payload["task"]["has_result"] is True
    assert payload["task"]["report_file_ready"] is False
    assert payload["task"]["report_file_name"] == ""
    assert payload["task"]["report_file_path"] == ""
    assert payload["task"]["state_file_ready"] is False
    assert payload["task"]["state_file_path"] == ""
    assert payload["task"]["engine_result"]["engine_name"] == "report"
    assert payload["task"]["engine_result"]["status"] == "completed"
    assert payload["task"]["engine_result"]["summary"] == "report completed"
    assert payload["task"]["unified_task"]["id"] == "report-missing"
    assert payload["task"]["unified_task"]["status"] == "completed"


def test_build_report_result_payload_loads_html_from_runtime_loader():
    task = _FakeRuntimeExportTask(
        task_id="report-html",
        html_content="",
        engine_result={
            "engine_name": "report",
            "status": "completed",
            "success": True,
            "summary": "runtime result preserved",
            "artifacts": {"report_preview": "Executive summary ready"},
        },
    )

    def _load_result(task_record):
        task_record.html_content = "<h1>ready</h1>"

    service = ReportJobQueryService(
        report_job_getter=lambda report_job_id: task if report_job_id == "report-html" else None,
        report_result_loader=_load_result,
    )

    payload = service.build_report_result_payload("report-html")

    assert payload["success"] is True
    assert payload["html_content"] == "<h1>ready</h1>"
    assert payload["task"]["task_id"] == "report-html"
    assert payload["task"]["status"] == "completed"
    assert payload["task"]["report_file_path"] == ""
    assert payload["task"]["report_file_name"] == ""
    assert payload["task"]["ir_file_path"] == ""
    assert payload["task"]["query"] == "report query"
    assert payload["task"]["has_result"] is True
    assert payload["task"]["engine_result"]["engine_name"] == "report"
    assert payload["task"]["engine_result"]["status"] == "completed"
    assert payload["task"]["engine_result"]["summary"] == "runtime result preserved"
    assert payload["task"]["engine_result"]["artifacts"]["report_preview"] == "Executive summary ready"
    assert payload["task"]["report_file_path"] == ""
    assert payload["task"]["unified_task"]["status"] == "completed"
    assert payload["task"]["unified_task"]["engine_result"]["summary"] == "runtime result preserved"


def test_build_report_result_payload_raises_not_found_for_missing_task():
    service = ReportJobQueryService(report_job_getter=lambda _report_job_id: None)

    with pytest.raises(ReportJobNotFoundError):
        service.build_report_result_payload("report-missing")


def test_build_report_download_descriptor_returns_file_metadata():
    task = _FakeRuntimeExportTask(
        task_id="report-download",
        report_file_path="reports/report-download.html",
        report_file_name="download.html",
    )
    service = ReportJobQueryService(
        report_job_getter=lambda report_job_id: task if report_job_id == "report-download" else None,
        file_exists=lambda path: path == "reports/report-download.html",
    )

    descriptor = service.build_report_download_descriptor("report-download")

    assert descriptor == {
        "file_path": "reports/report-download.html",
        "download_name": "download.html",
        "mimetype": "text/html",
    }


def test_build_report_download_descriptor_rejects_incomplete_task():
    task = _FakeRuntimeExportTask(task_id="report-running", status="running")
    service = ReportJobQueryService(
        report_job_getter=lambda report_job_id: task if report_job_id == "report-running" else None,
    )

    with pytest.raises(ReportJobNotReadyError):
        service.build_report_download_descriptor("report-running")


def test_build_report_export_source_reads_document_ir():
    task = _FakeRuntimeExportTask(
        task_id="report-export",
        ir_file_path="reports/report-export.ir.json",
        query="museum insights",
    )
    service = ReportJobQueryService(
        report_job_getter=lambda report_job_id: task if report_job_id == "report-export" else None,
        file_exists=lambda path: path == "reports/report-export.ir.json",
        json_file_reader=lambda path: {"metadata": {"topic": "Museum"}, "path": path},
    )

    descriptor = service.build_report_export_source("report-export")

    assert descriptor["task"]["task_id"] == "report-export"
    assert descriptor["task_query"] == "museum insights"
    assert descriptor["task_record"] is task
    assert descriptor["ir_file_path"] == "reports/report-export.ir.json"
    assert descriptor["document_ir"] == {
        "metadata": {"topic": "Museum"},
        "path": "reports/report-export.ir.json",
    }


def test_build_report_export_source_raises_when_ir_file_missing():
    task = _FakeRuntimeExportTask(
        task_id="report-export-missing",
        ir_file_path="reports/missing.ir.json",
    )
    service = ReportJobQueryService(
        report_job_getter=lambda report_job_id: task if report_job_id == "report-export-missing" else None,
        file_exists=lambda _path: False,
    )

    with pytest.raises(ReportArtifactNotFoundError):
        service.build_report_export_source("report-export-missing")


def test_build_report_log_payload_returns_empty_when_file_missing():
    service = ReportJobQueryService(log_file_getter=lambda: "/virtual/missing.log")

    payload = service.build_report_log_payload()

    assert payload == {"success": True, "log_lines": []}


def test_build_report_log_payload_reads_and_filters_lines(monkeypatch):
    service = ReportJobQueryService(log_file_getter=lambda: "/virtual/report.log")

    class _FakeStat:
        st_size = 12

    class _FakeFile:
        def __enter__(self):
            return self

        def __exit__(self, exc_type, exc, tb):
            return False

        def readlines(self):
            return ["line-1\n", "\n", "line-2\r\n"]

    monkeypatch.setattr("services.application.report.query_service.Path.exists", lambda self: True)
    monkeypatch.setattr("services.application.report.query_service.Path.stat", lambda self: _FakeStat())
    monkeypatch.setattr("services.application.report.query_service.Path.open", lambda self, *args, **kwargs: _FakeFile())

    payload = service.build_report_log_payload()

    assert payload == {"success": True, "log_lines": ["line-1", "line-2"]}


def test_build_report_log_payload_raises_access_error_on_permission_issue(monkeypatch):
    service = ReportJobQueryService(log_file_getter=lambda: "/virtual/report.log")

    monkeypatch.setattr("services.application.report.query_service.Path.exists", lambda self: True)
    monkeypatch.setattr(
        "services.application.report.query_service.Path.stat",
        lambda self: type("_FakeStat", (), {"st_size": 10})(),
    )

    def _boom(self, *args, **kwargs):
        raise PermissionError("denied")

    monkeypatch.setattr("services.application.report.query_service.Path.open", _boom)

    with pytest.raises(ReportLogAccessError):
        service.build_report_log_payload()


def test_build_report_templates_payload_reads_markdown_templates(monkeypatch):
    service = ReportJobQueryService(
        report_initialized_getter=lambda: True,
        template_dir_getter=lambda: "/virtual/templates",
    )

    template_entries = [
        Path("/virtual/templates/briefing.md"),
        Path("/virtual/templates/notes.txt"),
        Path("/virtual/templates/weekly.md"),
    ]
    template_contents = {
        "briefing.md": "Briefing template\nsecond line",
        "weekly.md": "",
    }

    monkeypatch.setattr("services.application.report.query_service.Path.exists", lambda self: True)
    monkeypatch.setattr(
        "services.application.report.query_service.Path.iterdir",
        lambda self: list(template_entries),
    )
    monkeypatch.setattr(
        "services.application.report.query_service.Path.read_text",
        lambda self, encoding="utf-8": template_contents[self.name],
    )

    payload = service.build_report_templates_payload()

    assert payload == {
        "success": True,
        "templates": [
            {
                "name": "briefing",
                "filename": "briefing.md",
                "description": "Briefing template",
                "size": len("Briefing template\nsecond line"),
            },
            {
                "name": "weekly",
                "filename": "weekly.md",
                "description": "无描述",
                "size": 0,
            },
        ],
        "template_dir": "/virtual/templates",
    }