from __future__ import annotations

import sys
from pathlib import Path
from types import SimpleNamespace
from types import ModuleType

import apps.web_api.runtime.search_dispatch as search_dispatch
from apps.web_api.runtime.process_registry import ProcessRuntimeRegistry, build_default_process_table
from apps.web_api.runtime.search_dispatch import SearchDispatchRuntime
from services.application.analysis import SearchRequestSubmission
from services.shared.models import EngineContext, EngineResult


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

    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.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 _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 test_dispatch_search_request_prefers_process_registry_runtime_state(monkeypatch):
    registry = ProcessRuntimeRegistry(build_default_process_table())
    registry.set_status("insight", "running")
    registry.set_status("query", "running")
    research_task_service = _FakeResearchTaskService()
    threads: list[_FakeThread] = []

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

    monkeypatch.setattr("apps.web_api.runtime.search_dispatch.threading.Thread", fake_thread)

    result = SearchDispatchRuntime().dispatch_search_request(
        research_task_id="task-1",
        query="museum research",
        process_registry=registry,
        check_app_status=lambda: None,
        research_task_service=research_task_service,
        log_dir=Path("."),
        write_log=lambda *_args, **_kwargs: None,
    )

    assert result["success"] is True
    assert result["accepted"] is True
    assert result["running_apps"] == ["insight", "query"]
    assert len(threads) == 1
    assert threads[0].started is True
    assert threads[0].kwargs["running_apps"] == ["insight", "query"]
    assert research_task_service.calls[-1]["analysis_status"] == "queued"


def test_dispatch_search_request_uses_registry_state_after_status_refresh(monkeypatch):
    registry = ProcessRuntimeRegistry(build_default_process_table())
    research_task_service = _FakeResearchTaskService()
    threads: list[_FakeThread] = []

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

    monkeypatch.setattr("apps.web_api.runtime.search_dispatch.threading.Thread", fake_thread)

    result = SearchDispatchRuntime().dispatch_search_request(
        research_task_id="task-2",
        query="forum sentiment",
        process_registry=registry,
        check_app_status=lambda: registry.set_status("media", "running"),
        research_task_service=research_task_service,
        log_dir=Path("."),
        write_log=lambda *_args, **_kwargs: None,
    )

    assert result["success"] is True
    assert result["running_apps"] == ["media"]
    assert len(threads) == 1
    assert threads[0].kwargs["running_apps"] == ["media"]


def test_dispatch_search_request_prefers_explicit_analysis_service():
    registry = ProcessRuntimeRegistry(build_default_process_table())
    captured: dict[str, object] = {}

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

    result = SearchDispatchRuntime().dispatch_search_request(
        research_task_id="task-3",
        query="runtime cleanup",
        process_registry=registry,
        check_app_status=lambda: None,
        research_task_service=_FakeResearchTaskService(),
        log_dir=Path("."),
        write_log=lambda *_args, **_kwargs: None,
        analysis_service=SimpleNamespace(dispatch_search_request=dispatch),
    )

    assert result == {"success": True, "accepted": True}
    assert captured["research_task_id"] == "task-3"
    assert captured["query"] == "runtime cleanup"
    assert captured["research_task_service"].__class__ is _FakeResearchTaskService
    assert captured["execution_context"].process_registry is registry


def test_dispatch_search_request_uses_execution_context_builder(monkeypatch):
    registry = ProcessRuntimeRegistry(build_default_process_table())
    captured: dict[str, object] = {}
    execution_context = SimpleNamespace(process_registry=registry)

    def build_execution_context(**kwargs):
        captured["builder_kwargs"] = kwargs
        return execution_context

    def dispatch(**kwargs):
        captured["dispatch_kwargs"] = kwargs
        return {"success": True, "accepted": True}

    monkeypatch.setattr(
        search_dispatch,
        "build_analysis_execution_context",
        build_execution_context,
    )

    result = SearchDispatchRuntime().dispatch_search_request(
        research_task_id="task-4",
        query="artifact flow",
        process_registry=registry,
        check_app_status=lambda: None,
        research_task_service=_FakeResearchTaskService(),
        log_dir=Path("."),
        write_log=lambda *_args, **_kwargs: None,
        analysis_service=SimpleNamespace(dispatch_search_request=dispatch),
    )

    assert result == {"success": True, "accepted": True}
    assert captured["builder_kwargs"] == {
        "process_registry": registry,
        "check_app_status": captured["builder_kwargs"]["check_app_status"],
        "log_dir": Path("."),
        "write_log": captured["builder_kwargs"]["write_log"],
    }
    assert callable(captured["builder_kwargs"]["check_app_status"])
    assert callable(captured["builder_kwargs"]["write_log"])
    assert captured["dispatch_kwargs"]["execution_context"] is execution_context


def test_resolve_search_query_uses_default_analysis_service_builder(monkeypatch):
    captured: dict[str, object] = {}

    def resolve_search_query(**service_kwargs):
        captured["service_kwargs"] = service_kwargs
        return "task-5", "resolved query"

    def build_analysis_service(**kwargs):
        captured["builder_kwargs"] = kwargs
        return SimpleNamespace(resolve_search_query=resolve_search_query)

    monkeypatch.setattr(search_dispatch, "build_analysis_service", build_analysis_service)

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

    assert (task_id, query) == ("task-5", "resolved query")
    assert captured["builder_kwargs"]["research_task_service"] == "task-service"
    assert captured["service_kwargs"] == {
        "payload": {"research_task_id": "task-5"},
        "research_task_service": "task-service",
    }


def test_build_search_dispatch_runtime_returns_runtime_with_bound_service():
    analysis_service = SimpleNamespace()

    runtime = search_dispatch.build_search_dispatch_runtime(
        analysis_service=analysis_service,
    )

    assert isinstance(runtime, SearchDispatchRuntime)
    assert runtime._analysis_service is analysis_service


def test_build_search_request_submitter_binds_execution_context_and_dispatch(monkeypatch):
    registry = ProcessRuntimeRegistry(build_default_process_table())
    captured: dict[str, object] = {}
    execution_context = SimpleNamespace(process_registry=registry)

    def build_execution_context(**kwargs):
        captured["builder_kwargs"] = kwargs
        return execution_context

    def resolve_search_query(**kwargs):
        captured["resolve_kwargs"] = kwargs
        return "task-6", "bound query"

    def dispatch_search_request(**kwargs):
        captured.setdefault("dispatch_calls", []).append(kwargs)
        return {"success": True, "accepted": True}

    def submit_search_request(**kwargs):
        captured["submit_kwargs"] = kwargs
        return SearchRequestSubmission(
            payload=kwargs["dispatch_search_request"](
                research_task_id="task-6",
                query="bound query",
            ),
            kind="accepted",
        )

    monkeypatch.setattr(
        search_dispatch,
        "build_analysis_execution_context",
        build_execution_context,
    )

    submitter = search_dispatch.build_search_request_submitter(
        research_task_service="task-service",
        resolve_search_query=resolve_search_query,
        dispatch_search_request=dispatch_search_request,
        check_app_status=lambda: None,
        log_dir=Path("."),
        write_log=lambda *_args, **_kwargs: None,
        process_registry=registry,
        analysis_service=SimpleNamespace(submit_search_request=submit_search_request),
    )

    payload, status_code = submitter(payload={"research_task_id": "task-6"})

    assert status_code == 200
    assert payload == {"success": True, "accepted": True}
    assert captured["builder_kwargs"] == {
        "process_registry": registry,
        "check_app_status": captured["builder_kwargs"]["check_app_status"],
        "log_dir": Path("."),
        "write_log": captured["builder_kwargs"]["write_log"],
    }
    assert callable(captured["builder_kwargs"]["check_app_status"])
    assert callable(captured["builder_kwargs"]["write_log"])
    assert captured["submit_kwargs"]["payload"] == {"research_task_id": "task-6"}
    assert captured["submit_kwargs"]["execution_context"] is execution_context
    assert captured["submit_kwargs"]["research_task_service"] == "task-service"
    assert captured["submit_kwargs"]["resolve_search_query"] is resolve_search_query
    assert callable(captured["submit_kwargs"]["dispatch_search_request"])
    assert captured["dispatch_calls"] == [
        {
            "research_task_id": "task-6",
            "query": "bound query",
            "execution_context": execution_context,
            "research_task_service": "task-service",
        }
    ]


def test_map_search_submission_to_http_response_preserves_existing_status_mapping():
    accepted_payload, accepted_status = search_dispatch._map_search_submission_to_http_response(
        SearchRequestSubmission(
            payload={"success": True, "accepted": True},
            kind="accepted",
        )
    )
    empty_payload, empty_status = search_dispatch._map_search_submission_to_http_response(
        SearchRequestSubmission(
            payload={"success": False, "message": "empty"},
            kind="empty_query",
        )
    )
    rejected_payload, rejected_status = search_dispatch._map_search_submission_to_http_response(
        SearchRequestSubmission(
            payload={"success": False, "message": "rejected"},
            kind="rejected",
        )
    )

    assert accepted_status == 200
    assert accepted_payload == {"success": True, "accepted": True}
    assert empty_status == 200
    assert empty_payload == {"success": False, "message": "empty"}
    assert rejected_status == 400
    assert rejected_payload == {"success": False, "message": "rejected"}


def test_build_query_agent_uses_runtime_settings_helper(monkeypatch):
    captured: dict[str, object] = {}

    monkeypatch.setattr(
        search_dispatch,
        "get_settings",
        lambda: SimpleNamespace(
            QUERY_ENGINE_API_KEY="query-key",
            QUERY_ENGINE_BASE_URL="https://query.example.com",
            QUERY_ENGINE_MODEL_NAME="query-model",
            SEARCH_TOOL_TYPE="TavilyAPI",
            ANSPIRE_API_KEY="anspire-key",
            BOCHA_WEB_SEARCH_API_KEY="bocha-key",
            TAVILY_API_KEY="tavily-key",
        ),
    )

    class _FakeSettings:
        def __init__(self, **kwargs):
            captured["kwargs"] = kwargs

    class _FakeAgent:
        def __init__(self, config):
            self.config = config

    monkeypatch.setattr("services.engines.query.Settings", _FakeSettings)
    monkeypatch.setattr("services.engines.query.DeepSearchAgent", _FakeAgent)

    agent = search_dispatch.build_query_agent()

    assert captured["kwargs"] == {
        "QUERY_ENGINE_API_KEY": "query-key",
        "QUERY_ENGINE_BASE_URL": "https://query.example.com",
        "QUERY_ENGINE_MODEL_NAME": "query-model",
        "SEARCH_TOOL_TYPE": "TavilyAPI",
        "ANSPIRE_API_KEY": "anspire-key",
        "BOCHA_WEB_SEARCH_API_KEY": "bocha-key",
        "TAVILY_API_KEY": "tavily-key",
        "OUTPUT_DIR": str(search_dispatch.QUERY_REPORTS_DIR),
    }
    assert isinstance(agent, _FakeAgent)


def test_build_insight_agent_uses_runtime_database_settings(monkeypatch):
    captured: dict[str, object] = {}

    monkeypatch.setattr(
        search_dispatch,
        "get_settings",
        lambda: SimpleNamespace(
            INSIGHT_ENGINE_API_KEY="insight-key",
            INSIGHT_ENGINE_BASE_URL="https://insight.example.com",
            INSIGHT_ENGINE_MODEL_NAME="insight-model",
        ),
    )
    monkeypatch.setattr(
        search_dispatch,
        "get_database_runtime_settings",
        lambda: SimpleNamespace(
            host="db.internal",
            user="crawler_user",
            password="crawler_pwd",
            name="crawler_db",
            port="15432",
            charset="utf8mb4",
            dialect="postgresql",
        ),
    )

    class _FakeSettings:
        def __init__(self, **kwargs):
            captured["kwargs"] = kwargs

    class _FakeAgent:
        def __init__(self, config):
            self.config = config

    fake_module = ModuleType("services.engines.insight")
    fake_module.Settings = _FakeSettings
    fake_module.DeepSearchAgent = _FakeAgent
    monkeypatch.setitem(sys.modules, "services.engines.insight", fake_module)

    agent = search_dispatch.build_insight_agent()

    assert captured["kwargs"] == {
        "INSIGHT_ENGINE_API_KEY": "insight-key",
        "INSIGHT_ENGINE_BASE_URL": "https://insight.example.com",
        "INSIGHT_ENGINE_MODEL_NAME": "insight-model",
        "DB_HOST": "db.internal",
        "DB_USER": "crawler_user",
        "DB_PASSWORD": "crawler_pwd",
        "DB_NAME": "crawler_db",
        "DB_PORT": "15432",
        "DB_CHARSET": "utf8mb4",
        "DB_DIALECT": "postgresql",
        "OUTPUT_DIR": str(search_dispatch.INSIGHT_REPORTS_DIR),
    }
    assert isinstance(agent, _FakeAgent)


def test_run_local_engine_research_returns_canonical_engine_payload(monkeypatch):
    class _FakeAgent:
        def research(self, query, save_report=True):
            assert query == "museum research"
            assert save_report is True
            return "final report body"

        def get_progress_summary(self):
            return {"completed_steps": 4, "total_steps": 4}

    monkeypatch.setattr(
        search_dispatch,
        "LOCAL_ENGINE_BUILDERS",
        {"query_local": lambda: _FakeAgent()},
    )

    result = search_dispatch.run_local_engine_research(
        EngineContext(
            engine_name="query",
            research_task_id="task-7",
            query="museum research",
        ),
        engine_registry=SimpleNamespace(
            contains=lambda app_name: app_name == "query",
            get_local_runner=lambda _app_name: "query_local",
        ),
    )

    assert result.engine_name == "query"
    assert result.success is True
    assert result.status == "completed"
    assert result.summary == "research completed"
    assert result.artifacts["report_preview"] == "final report body"
    assert result.metrics == {"completed_steps": 4, "total_steps": 4}


def test_run_local_engine_research_returns_standard_error_payload(monkeypatch):
    class _FakeAgent:
        def research(self, _query, save_report=True):
            assert save_report is True
            raise RuntimeError("engine exploded")

    monkeypatch.setattr(
        search_dispatch,
        "LOCAL_ENGINE_BUILDERS",
        {"query_local": lambda: _FakeAgent()},
    )

    result = search_dispatch.run_local_engine_research(
        EngineContext(
            engine_name="query",
            research_task_id="task-8",
            query="museum research",
        ),
        engine_registry=SimpleNamespace(
            contains=lambda app_name: app_name == "query",
            get_local_runner=lambda _app_name: "query_local",
        ),
    )

    assert result.engine_name == "query"
    assert result.success is False
    assert result.status == "failed"
    assert result.summary == "engine exploded"
    assert result.error is not None
    assert result.error.code == "engine_execution_failed"
    assert result.error.details["engine_name"] == "query"


def test_build_analysis_service_wraps_engine_context_for_local_runner(monkeypatch):
    captured: dict[str, object] = {}

    def fake_local_runner(context, *, engine_registry=None):
        captured["context"] = context
        captured["engine_registry"] = engine_registry
        return EngineResult(
            engine_name=context.engine_name,
            status="completed",
            success=True,
            summary="ok",
        )

    monkeypatch.setattr(search_dispatch, "run_local_engine_research", fake_local_runner)

    service = search_dispatch.build_analysis_service(
        research_task_service=_FakeResearchTaskService(),
        engine_registry="engine-registry",
    )

    context = EngineContext(
        engine_name="media",
        research_task_id="task-ctx",
        query="museum review",
        trace_id="trace-ctx",
        metadata={"source": "unit-test"},
    )
    result = service._engine_runner(context)

    assert result.engine_name == "media"
    assert result.success is True
    assert captured["context"] is context
    assert captured["engine_registry"] == "engine-registry"