from __future__ import annotations

from pathlib import Path

from apps.web_api.runtime.task_runtime_store import TaskRuntimeStore
from services.application.analysis import (
    AnalysisExecutionContext,
    AnalysisService,
    EngineContext,
    InMemoryAnalysisRunStore,
    SearchRequestSubmission,
)
from services.shared.models import AnalysisRunStatus, EngineExecutionError, EngineResult


class _FakeResearchTaskService:
    def __init__(self) -> None:
        self.query_calls: list[str] = []
        self.status_calls: list[dict[str, object]] = []

    def get_task_query(self, task_id: str) -> str:
        self.query_calls.append(task_id)
        return f"generated query for {task_id}"

    def sync_analysis_runtime_status(
        self,
        task_id: str,
        *,
        analysis_status: str,
        last_action: str,
        generated_query: str = "",
        analysis_run_id: str | None = None,
    ) -> None:
        self.status_calls.append(
            {
                "task_id": task_id,
                "analysis_status": analysis_status,
                "last_action": last_action,
                "generated_query": generated_query,
                "analysis_run_id": analysis_run_id,
            }
        )


class _FakeProcessRegistry:
    def __init__(self, running_apps: list[str]) -> None:
        self._running_apps = list(running_apps)
        self.calls: list[tuple[str, ...]] = []

    def running_apps(self, app_names) -> list[str]:
        app_tuple = tuple(app_names)
        self.calls.append(app_tuple)
        return [name for name in self._running_apps if name in app_tuple]


class _FakeThread:
    def __init__(self, *, target, kwargs, daemon) -> None:
        self.target = target
        self.kwargs = kwargs
        self.daemon = daemon
        self.started = False

    def start(self) -> None:
        self.started = True


def _successful_engine_result(
    engine_name: str,
    *,
    summary: str = "ok",
) -> EngineResult:
    return EngineResult(
        engine_name=engine_name,
        status="completed",
        success=True,
        summary=summary,
    )


def _build_execution_context(
    *,
    registry: _FakeProcessRegistry,
    check_app_status=lambda: None,
    log_dir: Path = Path("."),
    write_log=lambda *_args, **_kwargs: None,
) -> AnalysisExecutionContext:
    return AnalysisExecutionContext(
        process_registry=registry,
        check_app_status=check_app_status,
        log_dir=log_dir,
        write_log=write_log,
    )


def test_resolve_search_query_prefers_payload_query():
    task_service = _FakeResearchTaskService()
    service = AnalysisService(
        task_service,
        engine_runner=lambda context: _successful_engine_result(context.engine_name),
    )

    task_id, query = service.resolve_search_query(
        payload={"research_task_id": "task-1", "query": "payload query"},
    )

    assert task_id == "task-1"
    assert query == "payload query"
    assert task_service.query_calls == []


def test_resolve_search_query_falls_back_to_task_service_query():
    task_service = _FakeResearchTaskService()
    service = AnalysisService(
        task_service,
        engine_runner=lambda context: _successful_engine_result(context.engine_name),
    )

    task_id, query = service.resolve_search_query(payload={"research_task_id": "task-2"})

    assert task_id == "task-2"
    assert query == "generated query for task-2"
    assert task_service.query_calls == ["task-2"]


def test_submit_search_request_returns_empty_query_submission_when_resolved_query_is_empty():
    task_service = _FakeResearchTaskService()
    registry = _FakeProcessRegistry(["query"])
    service = AnalysisService(
        task_service,
        engine_runner=lambda context: _successful_engine_result(context.engine_name),
    )

    submission = service.submit_search_request(
        payload={},
        execution_context=_build_execution_context(registry=registry),
    )

    assert isinstance(submission, SearchRequestSubmission)
    assert submission.kind == "empty_query"
    assert submission.payload["success"] is False
    assert isinstance(submission.payload["message"], str)
    assert submission.payload["message"]
    assert registry.calls == []


def test_submit_search_request_returns_rejected_submission_when_dispatch_fails():
    task_service = _FakeResearchTaskService()
    registry = _FakeProcessRegistry([])
    status_checks: list[str] = []
    service = AnalysisService(
        task_service,
        engine_runner=lambda context: _successful_engine_result(context.engine_name),
    )

    submission = service.submit_search_request(
        payload={"research_task_id": "task-3", "query": "museum research"},
        execution_context=_build_execution_context(
            registry=registry,
            check_app_status=lambda: status_checks.append("checked"),
        ),
    )

    assert isinstance(submission, SearchRequestSubmission)
    assert submission.kind == "rejected"
    assert submission.payload["success"] is False
    assert submission.payload["message"] == "No running analysis engines are available."
    assert status_checks == ["checked"]


def test_get_analysis_run_reads_back_existing_run():
    task_service = _FakeResearchTaskService()
    run_store = InMemoryAnalysisRunStore()
    service = AnalysisService(
        task_service,
        engine_runner=lambda context: _successful_engine_result(context.engine_name),
        analysis_run_store=run_store,
    )
    run = run_store.create_run(
        research_task_id="task-lookup",
        query="museum query",
        engines=["query"],
    )

    loaded_run = service.get_analysis_run(run.id)

    assert loaded_run is not None
    assert loaded_run.id == run.id
    assert loaded_run.research_task_id == "task-lookup"


def test_dispatch_search_request_returns_failure_when_no_engines_are_running():
    task_service = _FakeResearchTaskService()
    registry = _FakeProcessRegistry([])
    status_checks: list[str] = []
    runtime_store = TaskRuntimeStore()
    service = AnalysisService(
        task_service,
        engine_runner=lambda context: _successful_engine_result(context.engine_name),
        task_runtime_store=runtime_store,
    )

    result = service.dispatch_search_request(
        research_task_id="task-3",
        query="museum research",
        process_registry=registry,
        check_app_status=lambda: status_checks.append("checked"),
        log_dir=Path("."),
        write_log=lambda *_args, **_kwargs: None,
    )

    assert result["success"] is False
    assert isinstance(result["message"], str)
    assert status_checks == ["checked"]
    assert registry.calls == [("insight", "media", "query")]
    assert task_service.status_calls[-1]["analysis_status"] == AnalysisRunStatus.FAILED.value
    runtime_task = runtime_store.get_task("task-3")
    assert runtime_task is not None
    assert runtime_task.status == "ready"
    assert runtime_task.analysis_run_id is None
    assert runtime_task.progress.stage == "ready"
    assert runtime_task.metrics == {
        "engine_count": 0,
        "success_count": 0,
        "failure_count": 0,
    }


def test_dispatch_search_request_accepts_work_and_starts_background_thread():
    task_service = _FakeResearchTaskService()
    registry = _FakeProcessRegistry(["media", "query"])
    status_checks: list[str] = []
    threads: list[_FakeThread] = []
    run_store = InMemoryAnalysisRunStore()
    runtime_store = TaskRuntimeStore()

    def fake_thread(*, target, kwargs, daemon):
        thread = _FakeThread(target=target, kwargs=kwargs, daemon=daemon)
        threads.append(thread)
        return thread

    service = AnalysisService(
        task_service,
        engine_runner=lambda context: _successful_engine_result(context.engine_name),
        analysis_run_store=run_store,
        task_runtime_store=runtime_store,
        thread_factory=fake_thread,
    )

    result = service.dispatch_search_request(
        research_task_id="task-4",
        query="forum sentiment",
        execution_context=_build_execution_context(
            registry=registry,
            check_app_status=lambda: status_checks.append("checked"),
        ),
    )

    assert result["success"] is True
    assert result["accepted"] is True
    assert result["running_apps"] == ["media", "query"]
    assert status_checks == ["checked"]
    assert len(threads) == 1
    assert threads[0].started is True
    assert result["analysis_run_id"]
    assert threads[0].kwargs["running_apps"] == ["media", "query"]
    assert threads[0].kwargs["analysis_run_id"] == result["analysis_run_id"]
    assert task_service.status_calls[-1]["analysis_status"] == AnalysisRunStatus.QUEUED.value
    assert task_service.status_calls[-1]["analysis_run_id"] == result["analysis_run_id"]

    run = run_store.get_run(result["analysis_run_id"])
    assert run is not None
    assert run.research_task_id == "task-4"
    assert run.engines == ["media", "query"]
    assert run.status == AnalysisRunStatus.QUEUED
    runtime_task = runtime_store.get_task("task-4")
    assert runtime_task is not None
    assert runtime_task.status == "analyzing"
    assert runtime_task.analysis_run_id == result["analysis_run_id"]
    assert runtime_task.engines == ["media", "query"]
    assert runtime_task.progress.stage == AnalysisRunStatus.QUEUED.value


def test_submit_search_request_uses_route_ready_dispatcher_without_runtime_kwargs():
    task_service = _FakeResearchTaskService()
    registry = _FakeProcessRegistry(["query"])
    service = AnalysisService(
        task_service,
        engine_runner=lambda context: _successful_engine_result(context.engine_name),
    )
    captured: list[dict[str, object]] = []

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

    submission = service.submit_search_request(
        payload={"research_task_id": "task-7", "query": "museum query"},
        execution_context=_build_execution_context(registry=registry),
        dispatch_search_request=route_ready_dispatcher,
    )

    assert isinstance(submission, SearchRequestSubmission)
    assert submission.kind == "accepted"
    assert submission.payload == {"success": True, "accepted": True, "message": "ok"}
    assert captured == [
        {
            "research_task_id": "task-7",
            "query": "museum query",
        }
    ]


def test_execute_search_dispatch_async_builds_engine_context_for_each_engine():
    task_service = _FakeResearchTaskService()
    log_calls: list[tuple[str, str]] = []
    run_store = InMemoryAnalysisRunStore()
    runtime_store = TaskRuntimeStore()
    captured_contexts: list[EngineContext] = []

    def engine_runner(context: EngineContext):
        captured_contexts.append(context)
        if context.engine_name == "insight":
            return _successful_engine_result(
                context.engine_name,
                summary=f"{context.engine_name}:{context.query}",
            )
        return EngineResult(
            engine_name=context.engine_name,
            status="failed",
            success=False,
            summary=f"{context.engine_name}:failed",
            error=EngineExecutionError(
                code=f"{context.engine_name}_failed",
                message=f"{context.engine_name}:failed",
                retryable=True,
            ),
        )

    service = AnalysisService(
        task_service,
        engine_runner=engine_runner,
        analysis_run_store=run_store,
        task_runtime_store=runtime_store,
    )
    run = run_store.create_run(
        research_task_id="task-5",
        query="city museum",
        engines=["insight", "query"],
    )

    service.execute_search_dispatch_async(
        analysis_run_id=run.id,
        research_task_id="task-5",
        query="city museum",
        running_apps=["insight", "query"],
        log_dir=Path("."),
        write_log=lambda _log_dir, app_name, line: log_calls.append((app_name, line)),
    )

    assert [(context.engine_name, context.research_task_id, context.query) for context in captured_contexts] == [
        ("insight", "task-5", "city museum"),
        ("query", "task-5", "city museum"),
    ]
    assert all(context.trace_id == run.id for context in captured_contexts)
    assert all(context.metadata == {} for context in captured_contexts)
    assert len(log_calls) == 4
    assert task_service.status_calls[-1]["analysis_status"] == AnalysisRunStatus.PARTIAL.value
    assert task_service.status_calls[-1]["generated_query"] == "city museum"
    assert task_service.status_calls[-1]["analysis_run_id"] == run.id
    assert "insight" in str(task_service.status_calls[-1]["last_action"])
    saved_run = run_store.get_run(run.id)
    assert saved_run is not None
    assert saved_run.status == AnalysisRunStatus.PARTIAL
    assert set(saved_run.partial_results) == {"insight", "query"}
    assert saved_run.partial_results["insight"]["engine_name"] == "insight"
    assert saved_run.partial_results["insight"]["status"] == "completed"
    assert saved_run.partial_results["insight"]["summary"] == "insight:city museum"
    assert saved_run.partial_results["query"]["status"] == "failed"
    assert saved_run.partial_results["query"]["error"]["code"] == "query_failed"
    assert saved_run.metrics["success_count"] == 1
    assert saved_run.metrics["failure_count"] == 1
    assert saved_run.metrics["engine_count"] == 2
    assert saved_run.finished_at is not None
    runtime_task = runtime_store.get_task("task-5")
    assert runtime_task is not None
    assert runtime_task.status == "analyzing"
    assert runtime_task.analysis_run_id == run.id
    assert runtime_task.progress.stage == AnalysisRunStatus.PARTIAL.value
    assert runtime_task.metrics["success_count"] == 1
    assert runtime_task.metrics["failure_count"] == 1
    assert set(runtime_task.partial_results) == {"insight", "query"}
    assert runtime_task.partial_results["query"]["engine_name"] == "query"
    assert runtime_task.partial_results["query"]["error"]["code"] == "query_failed"


def test_execute_search_dispatch_async_resets_to_ready_on_exception():
    task_service = _FakeResearchTaskService()
    run_store = InMemoryAnalysisRunStore()
    runtime_store = TaskRuntimeStore()

    def engine_runner(_context: EngineContext):
        raise RuntimeError("engine crashed")

    service = AnalysisService(
        task_service,
        engine_runner=engine_runner,
        analysis_run_store=run_store,
        task_runtime_store=runtime_store,
    )
    run = run_store.create_run(
        research_task_id="task-6",
        query="brand audit",
        engines=["query"],
    )

    service.execute_search_dispatch_async(
        analysis_run_id=run.id,
        research_task_id="task-6",
        query="brand audit",
        running_apps=["query"],
        log_dir=Path("."),
        write_log=lambda *_args, **_kwargs: None,
    )

    assert task_service.status_calls[-1]["analysis_status"] == AnalysisRunStatus.FAILED.value
    assert task_service.status_calls[-1]["analysis_run_id"] == run.id
    assert "engine crashed" in str(task_service.status_calls[-1]["last_action"])
    saved_run = run_store.get_run(run.id)
    assert saved_run is not None
    assert saved_run.status == AnalysisRunStatus.FAILED
    assert saved_run.error is not None
    assert saved_run.error.message == "engine crashed"
    runtime_task = runtime_store.get_task("task-6")
    assert runtime_task is not None
    assert runtime_task.status == "analyzing"
    assert runtime_task.analysis_run_id == run.id
    assert runtime_task.error is not None
    assert runtime_task.error.message == "engine crashed"
    assert runtime_task.progress.stage == AnalysisRunStatus.FAILED.value


def test_execute_search_dispatch_async_accepts_engine_result_instances_from_runner():
    task_service = _FakeResearchTaskService()
    run_store = InMemoryAnalysisRunStore()
    runtime_store = TaskRuntimeStore()

    def engine_runner(context: EngineContext):
        if context.engine_name == "query":
            return EngineResult(
                engine_name=context.engine_name,
                status="completed",
                success=True,
                summary="query complete",
                artifacts={"sources": ["reviews"]},
                metrics={"duration_seconds": 0.8},
            )
        return EngineResult(
            engine_name=context.engine_name,
            status="failed",
            success=False,
            summary="media failed",
            error=EngineExecutionError(
                code="media_failed",
                message="media failed",
                retryable=True,
            ),
        )

    service = AnalysisService(
        task_service,
        engine_runner=engine_runner,
        analysis_run_store=run_store,
        task_runtime_store=runtime_store,
    )
    run = run_store.create_run(
        research_task_id="task-engine-result",
        query="museum",
        engines=["query", "media"],
    )

    service.execute_search_dispatch_async(
        analysis_run_id=run.id,
        research_task_id="task-engine-result",
        query="museum",
        running_apps=["query", "media"],
        log_dir=Path("."),
        write_log=lambda *_args, **_kwargs: None,
    )

    saved_run = run_store.get_run(run.id)
    assert saved_run is not None
    assert saved_run.status == AnalysisRunStatus.PARTIAL
    assert saved_run.partial_results["query"]["engine_name"] == "query"
    assert saved_run.partial_results["query"]["artifacts"]["sources"] == ["reviews"]
    assert saved_run.partial_results["media"]["engine_name"] == "media"
    assert saved_run.partial_results["media"]["error"]["code"] == "media_failed"
    assert saved_run.metrics["success_count"] == 1
    assert saved_run.metrics["failure_count"] == 1


def test_finalize_analysis_run_counts_legacy_partial_results_via_engine_result_contract():
    task_service = _FakeResearchTaskService()
    run_store = InMemoryAnalysisRunStore()
    service = AnalysisService(
        task_service,
        engine_runner=lambda context: _successful_engine_result(context.engine_name),
        analysis_run_store=run_store,
    )
    run = run_store.create_run(
        research_task_id="task-legacy-results",
        query="legacy query",
        engines=["query", "insight"],
    )
    run.partial_results = {
        "query": "timeout",
        "insight": {
            "success": True,
            "status": "completed",
            "summary": "insight done",
        },
    }
    run = run_store.save_run(run)

    final_status = service._finalize_analysis_run(
        analysis_run_id=run.id,
        final_message="legacy partial results finalized",
    )

    saved_run = run_store.get_run(run.id)
    assert final_status == AnalysisRunStatus.PARTIAL
    assert saved_run is not None
    assert saved_run.status == AnalysisRunStatus.PARTIAL
    assert saved_run.metrics["success_count"] == 1
    assert saved_run.metrics["failure_count"] == 1