from __future__ import annotations

from copy import deepcopy
from datetime import datetime, timedelta

from services.application.research import (
    ResearchTaskService,
    ResearchTaskTransitionError,
)
from services.shared.events import TaskLifecycleStage, TaskLifecycleStatus
from services.shared.models import ResearchTaskStatus
from services.shared.observability import InMemoryEventRecorder
from services.shared.timeline import InMemoryTaskTimelineStore, create_task_timeline_tracker


class _FakeResearchTaskStore:
    _MISSING = object()

    def __init__(self):
        self._tasks: list[dict] = []
        self._active_task_id: str | None = None
        self._counter = 0

    def upsert(self, payload: dict):
        self._counter += 1
        now = datetime(2026, 1, 1, 12, 0, 0) + timedelta(minutes=self._counter)
        record = {
            "task_id": f"task-{self._counter}",
            "venue_name": payload.get("venue_name", ""),
            "notes": payload.get("notes", ""),
            "generated_query": payload.get("generated_query", ""),
            "status": payload.get("status", "draft"),
            "unified_status": payload.get("unified_status", payload.get("status", "draft")),
            "status_label": payload.get("status", "draft"),
            "last_action": payload.get("last_action", ""),
            "created_at": now.isoformat(),
            "updated_at": now.isoformat(),
            "venue_type": payload.get("venue_type", "museum"),
            "time_range": payload.get("time_range", "recent_90_days"),
            "city": payload.get("city", ""),
            "benchmark_venues": payload.get("benchmark_venues", []),
            "crawler_job_id": payload.get("crawler_job_id"),
            "analysis_run_id": payload.get("analysis_run_id"),
            "report_job_id": payload.get("report_job_id"),
            "crawler_defaults": {},
        }
        self._tasks.append(record)
        self._active_task_id = record["task_id"]
        return deepcopy(record), self.snapshot()

    def snapshot(self, limit: int = 12):
        tasks = [deepcopy(task) for task in self._tasks[-limit:]][::-1]
        active_task = next((deepcopy(task) for task in self._tasks if task["task_id"] == self._active_task_id), None)
        return {"active_task": active_task, "tasks": tasks}

    def get_task(self, task_id: str):
        task = next((task for task in self._tasks if task["task_id"] == task_id), None)
        return deepcopy(task) if task else None

    def activate(self, task_id: str):
        if not any(task["task_id"] == task_id for task in self._tasks):
            return None
        self._active_task_id = task_id
        return self.snapshot()

    def update_status(
        self,
        task_id: str,
        *,
        status: str | None = None,
        unified_status: str | None = None,
        last_action: str | None = None,
        query: str | None = None,
        crawler_job_id=_MISSING,
        analysis_run_id=_MISSING,
        report_job_id=_MISSING,
    ):
        task = next((task for task in self._tasks if task["task_id"] == task_id), None)
        if task is None:
            return None
        if status is not None:
            task["status"] = status
        if unified_status is not None:
            task["unified_status"] = unified_status
        if last_action is not None:
            task["last_action"] = last_action
        if query is not None:
            task["generated_query"] = query
        if crawler_job_id is not self._MISSING:
            task["crawler_job_id"] = crawler_job_id
        if analysis_run_id is not self._MISSING:
            task["analysis_run_id"] = analysis_run_id
        if report_job_id is not self._MISSING:
            task["report_job_id"] = report_job_id
        task["updated_at"] = (datetime.fromisoformat(task["updated_at"]) + timedelta(minutes=1)).isoformat()
        return deepcopy(task)


def _build_timeline_tracker():
    timeline_store = InMemoryTaskTimelineStore()
    event_recorder = InMemoryEventRecorder()
    tracker = create_task_timeline_tracker(
        timeline_store=timeline_store,
        event_recorder=event_recorder,
        source="tests.research_task_service",
    )
    return tracker, timeline_store, event_recorder


def test_create_task_records_created_lifecycle_event():
    tracker, timeline_store, event_recorder = _build_timeline_tracker()
    service = ResearchTaskService(_FakeResearchTaskStore(), timeline_tracker=tracker)

    created = service.create_task({"venue_name": "Timeline Museum", "city": "Shanghai"})

    entry = timeline_store.latest(created.id)
    assert entry is not None
    assert entry.stage == TaskLifecycleStage.CREATED
    assert entry.status == TaskLifecycleStatus.PENDING
    assert entry.action == "任务已保存为草稿"
    assert entry.metadata["operation"] == "create_task"
    assert entry.metadata["research_status"] == "draft"
    assert event_recorder.events[-1].event_name == "task.created.pending"


def test_set_task_status_records_lifecycle_event_with_runtime_links():
    tracker, timeline_store, _event_recorder = _build_timeline_tracker()
    service = ResearchTaskService(_FakeResearchTaskStore(), timeline_tracker=tracker)
    created = service.create_task({"venue_name": "Status Timeline Museum", "city": "Shanghai"})

    updated = service.set_task_status(
        created.id,
        status="reporting",
        last_action="Report in progress",
        crawler_job_id="crawl-1",
        analysis_run_id="analysis-1",
        report_job_id="report-1",
    )

    entry = timeline_store.latest(updated.id)
    assert entry is not None
    assert entry.stage == TaskLifecycleStage.REPORTING
    assert entry.status == TaskLifecycleStatus.RUNNING
    assert entry.action == "Report in progress"
    assert entry.payload["crawler_job_id"] == "crawl-1"
    assert entry.payload["analysis_run_id"] == "analysis-1"
    assert entry.payload["report_job_id"] == "report-1"
    assert entry.metadata["operation"] == "set_task_status"


def test_sync_analysis_runtime_status_records_runtime_metadata():
    tracker, timeline_store, _event_recorder = _build_timeline_tracker()
    service = ResearchTaskService(_FakeResearchTaskStore(), timeline_tracker=tracker)
    created = service.create_task({"venue_name": "Analysis Timeline Museum", "city": "Shanghai"})

    service.sync_analysis_runtime_status(
        created.id,
        analysis_status="failed",
        last_action="analysis failed",
        analysis_run_id="analysis-2",
    )

    entry = timeline_store.latest(created.id)
    assert entry is not None
    assert entry.stage == TaskLifecycleStage.PREPARING
    assert entry.status == TaskLifecycleStatus.PENDING
    assert entry.metadata["operation"] == "sync_analysis_runtime_status"
    assert entry.metadata["analysis_status"] == "failed"
    assert entry.source == "application.research.task_service.analysis_runtime"


def test_transition_task_rejection_does_not_record_timeline_event():
    tracker, timeline_store, _event_recorder = _build_timeline_tracker()
    service = ResearchTaskService(_FakeResearchTaskStore(), timeline_tracker=tracker)
    created = service.create_task({"venue_name": "Transition Timeline Museum", "city": "Hangzhou"})

    try:
        service.transition_task(created.id, next_status=ResearchTaskStatus.COMPLETED)
    except ResearchTaskTransitionError:
        pass
    else:
        raise AssertionError("Expected invalid transition to raise ResearchTaskTransitionError")

    entries = timeline_store.list_entries(created.id)
    assert len(entries) == 1
    assert entries[0].metadata["operation"] == "create_task"


def test_set_task_status_persists_unified_status_round_trip():
    store = _FakeResearchTaskStore()
    service = ResearchTaskService(store)

    created = service.create_task(
        {
            "venue_name": "Status Test Museum",
            "city": "Shanghai",
            "venue_type": "museum",
            "research_focus": "strengths_improvements",
            "time_range": "recent_90_days",
        }
    )

    updated = service.set_task_status(
        created.id,
        status="queued",
        last_action="Task entered queued state",
        analysis_run_id="analysis-run-123",
    )
    reloaded = service.get_task_dto(created.id)

    assert updated.status == "queued"
    assert updated.analysis_run_id == "analysis-run-123"
    assert reloaded.status == "queued"
    assert reloaded.analysis_run_id == "analysis-run-123"
    assert reloaded.last_action == "Task entered queued state"
    assert reloaded.legacy_payload["status"] == "researching"
    assert reloaded.legacy_payload["unified_status"] == "queued"
    assert reloaded.legacy_payload["analysis_run_id"] == "analysis-run-123"


def test_set_task_status_persists_crawler_job_id_without_overwriting_analysis_link():
    store = _FakeResearchTaskStore()
    service = ResearchTaskService(store)

    created = service.create_task(
        {
            "venue_name": "Crawler Link Museum",
            "city": "Shanghai",
            "venue_type": "museum",
            "research_focus": "strengths_improvements",
            "time_range": "recent_90_days",
        }
    )

    service.set_task_status(
        created.id,
        status="queued",
        analysis_run_id="analysis-run-123",
    )
    updated = service.set_task_status(
        created.id,
        status="crawling",
        last_action="Crawler linked",
        crawler_job_id="crawl-job-123",
    )
    reloaded = service.get_task_dto(created.id)

    assert updated.crawler_job_id == "crawl-job-123"
    assert updated.analysis_run_id == "analysis-run-123"
    assert reloaded.crawler_job_id == "crawl-job-123"
    assert reloaded.analysis_run_id == "analysis-run-123"
    assert reloaded.legacy_payload["crawler_job_id"] == "crawl-job-123"


def test_activate_task_returns_snapshot_with_requested_active_task():
    service = ResearchTaskService(_FakeResearchTaskStore())

    first = service.create_task({"venue_name": "Alpha Museum", "city": "Shanghai"})
    second = service.create_task({"venue_name": "Beta Museum", "city": "Suzhou"})

    initial_snapshot = service.get_task_snapshot()

    assert initial_snapshot.active_task is not None
    assert initial_snapshot.active_task.id == second.id

    activated_snapshot = service.activate_task(first.id)

    assert activated_snapshot.active_task is not None
    assert activated_snapshot.active_task.id == first.id
    assert {task.id for task in activated_snapshot.tasks} == {first.id, second.id}

    refreshed_snapshot = service.get_task_snapshot()
    assert refreshed_snapshot.active_task is not None
    assert refreshed_snapshot.active_task.id == first.id


def test_set_task_status_persists_report_job_id_without_overwriting_other_links():
    store = _FakeResearchTaskStore()
    service = ResearchTaskService(store)

    created = service.create_task(
        {
            "venue_name": "Report Link Museum",
            "city": "Shanghai",
            "venue_type": "museum",
            "research_focus": "strengths_improvements",
            "time_range": "recent_90_days",
        }
    )

    service.set_task_status(
        created.id,
        status="analyzing",
        analysis_run_id="analysis-run-321",
        crawler_job_id="crawl-job-321",
    )
    updated = service.set_task_status(
        created.id,
        status="reporting",
        last_action="Report linked",
        report_job_id="report-job-321",
    )
    reloaded = service.get_task_dto(created.id)

    assert updated.report_job_id == "report-job-321"
    assert updated.analysis_run_id == "analysis-run-321"
    assert updated.crawler_job_id == "crawl-job-321"
    assert reloaded.report_job_id == "report-job-321"
    assert reloaded.analysis_run_id == "analysis-run-321"
    assert reloaded.crawler_job_id == "crawl-job-321"
    assert reloaded.legacy_payload["report_job_id"] == "report-job-321"


def test_set_task_status_can_clear_report_job_id_without_touching_other_links():
    store = _FakeResearchTaskStore()
    service = ResearchTaskService(store)

    created = service.create_task(
        {
            "venue_name": "Report Clear Museum",
            "city": "Shanghai",
            "venue_type": "museum",
            "research_focus": "strengths_improvements",
            "time_range": "recent_90_days",
        }
    )

    service.set_task_status(
        created.id,
        status="reporting",
        crawler_job_id="crawl-job-654",
        analysis_run_id="analysis-run-654",
        report_job_id="report-job-654",
    )
    updated = service.set_task_status(
        created.id,
        status="analyzing",
        last_action="Report link cleared",
        report_job_id=None,
    )
    reloaded = service.get_task_dto(created.id)

    assert updated.report_job_id is None
    assert updated.analysis_run_id == "analysis-run-654"
    assert updated.crawler_job_id == "crawl-job-654"
    assert reloaded.report_job_id is None
    assert reloaded.analysis_run_id == "analysis-run-654"
    assert reloaded.crawler_job_id == "crawl-job-654"
    assert reloaded.legacy_payload["report_job_id"] is None


def test_sync_report_runtime_status_maps_runtime_states_to_unified_task_status():
    service = ResearchTaskService(_FakeResearchTaskStore())
    created = service.create_task({"venue_name": "Report Status Museum", "city": "Shanghai"})

    expected = {
        "pending": "reporting",
        "running": "reporting",
        "completed": "completed",
        "error": "failed",
        "cancelled": "cancelled",
    }

    for report_status, task_status in expected.items():
        updated = service.sync_report_runtime_status(
            created.id,
            report_status=report_status,
            last_action=f"report status -> {report_status}",
        )
        assert updated.status == task_status
        reloaded = service.get_task_dto(created.id)
        assert reloaded.status == task_status
        assert reloaded.last_action == f"report status -> {report_status}"


def test_sync_report_runtime_status_preserves_existing_links_while_updating_report_job_id():
    store = _FakeResearchTaskStore()
    service = ResearchTaskService(store)
    created = service.create_task(
        {
            "venue_name": "Report Sync Museum",
            "city": "Shanghai",
            "venue_type": "museum",
            "research_focus": "strengths_improvements",
            "time_range": "recent_90_days",
        }
    )

    service.set_task_status(
        created.id,
        status="analyzing",
        crawler_job_id="crawl-job-777",
        analysis_run_id="analysis-run-777",
    )

    updated = service.sync_report_runtime_status(
        created.id,
        report_status="running",
        report_job_id="report-job-777",
        last_action="report runtime synced",
    )
    reloaded = service.get_task_dto(created.id)

    assert updated.status == "reporting"
    assert updated.report_job_id == "report-job-777"
    assert updated.crawler_job_id == "crawl-job-777"
    assert updated.analysis_run_id == "analysis-run-777"
    assert reloaded.report_job_id == "report-job-777"
    assert reloaded.crawler_job_id == "crawl-job-777"
    assert reloaded.analysis_run_id == "analysis-run-777"
    assert reloaded.legacy_payload["report_job_id"] == "report-job-777"


def test_sync_report_runtime_status_rejects_unknown_runtime_status():
    service = ResearchTaskService(_FakeResearchTaskStore())
    created = service.create_task({"venue_name": "Report Status Guard Museum", "city": "Shanghai"})

    try:
        service.sync_report_runtime_status(created.id, report_status="paused")
    except ResearchTaskTransitionError as exc:
        assert "Unknown report runtime status: paused" in str(exc)
    else:
        raise AssertionError("Expected invalid report runtime status to raise ResearchTaskTransitionError")


def test_sync_analysis_runtime_status_maps_runtime_states_to_unified_task_status():
    service = ResearchTaskService(_FakeResearchTaskStore())
    created = service.create_task({"venue_name": "Analysis Status Museum", "city": "Shanghai"})

    expected = {
        "pending": "analyzing",
        "queued": "analyzing",
        "running": "analyzing",
        "partial": "analyzing",
        "completed": "analyzing",
        "failed": "ready",
        "cancelled": "cancelled",
    }

    for analysis_status, task_status in expected.items():
        updated = service.sync_analysis_runtime_status(
            created.id,
            analysis_status=analysis_status,
            last_action=f"analysis status -> {analysis_status}",
        )
        assert updated.status == task_status
        reloaded = service.get_task_dto(created.id)
        assert reloaded.status == task_status
        assert reloaded.last_action == f"analysis status -> {analysis_status}"


def test_sync_analysis_runtime_status_preserves_existing_links_while_updating_analysis_run_id():
    store = _FakeResearchTaskStore()
    service = ResearchTaskService(store)
    created = service.create_task(
        {
            "venue_name": "Analysis Sync Museum",
            "city": "Shanghai",
            "venue_type": "museum",
            "research_focus": "strengths_improvements",
            "time_range": "recent_90_days",
        }
    )

    service.set_task_status(
        created.id,
        status="reporting",
        crawler_job_id="crawl-job-888",
        report_job_id="report-job-888",
    )

    updated = service.sync_analysis_runtime_status(
        created.id,
        analysis_status="running",
        analysis_run_id="analysis-run-888",
        last_action="analysis runtime synced",
    )
    reloaded = service.get_task_dto(created.id)

    assert updated.status == "analyzing"
    assert updated.analysis_run_id == "analysis-run-888"
    assert updated.crawler_job_id == "crawl-job-888"
    assert updated.report_job_id == "report-job-888"
    assert reloaded.analysis_run_id == "analysis-run-888"
    assert reloaded.crawler_job_id == "crawl-job-888"
    assert reloaded.report_job_id == "report-job-888"
    assert reloaded.legacy_payload["analysis_run_id"] == "analysis-run-888"


def test_sync_analysis_runtime_status_rejects_unknown_runtime_status():
    service = ResearchTaskService(_FakeResearchTaskStore())
    created = service.create_task({"venue_name": "Analysis Status Guard Museum", "city": "Shanghai"})

    try:
        service.sync_analysis_runtime_status(created.id, analysis_status="paused")
    except ResearchTaskTransitionError as exc:
        assert "Unknown analysis runtime status: paused" in str(exc)
    else:
        raise AssertionError("Expected invalid analysis runtime status to raise ResearchTaskTransitionError")


def test_transition_task_rejects_invalid_transition_and_leaves_state_unchanged():
    service = ResearchTaskService(_FakeResearchTaskStore())
    created = service.create_task({"venue_name": "Transition Guard Museum", "city": "Hangzhou"})

    try:
        service.transition_task(created.id, next_status=ResearchTaskStatus.COMPLETED)
    except ResearchTaskTransitionError as exc:
        assert "draft -> completed" in str(exc)
        assert "ready, cancelled, archived" in str(exc)
    else:
        raise AssertionError("Expected invalid transition to raise ResearchTaskTransitionError")

    reloaded = service.get_task_dto(created.id)

    assert reloaded.status == "draft"
    assert reloaded.legacy_payload["status"] == "draft"
    assert reloaded.legacy_payload["unified_status"] == "draft"