from __future__ import annotations

from services.application.crawler import (
    CrawlerOperationConflictError,
    CrawlerService,
    CrawlerValidationError,
)
from services.application.research import ResearchTaskNotFoundError
from services.shared.config.access import DatabaseRuntimeSettings
from services.shared.dto import CrawlerJobDTO, ResearchTaskDTO


class _FakeCrawlerJobQueryService:
    def __init__(self) -> None:
        self.jobs_calls = 0
        self.job_calls: list[str] = []

    def build_crawler_jobs_payload(self) -> dict[str, object]:
        self.jobs_calls += 1
        return {
            "current_job": {"id": "crawl-2"},
            "jobs": [{"id": "crawl-2"}],
        }

    def build_crawler_job_payload(self, job_id: str) -> dict[str, object]:
        self.job_calls.append(job_id)
        return {
            "job_id": job_id,
            "crawler_job": {"id": job_id, "status": "running"},
        }

    def get_crawler_job_dto(self, job_id: str):
        self.job_calls.append(job_id)
        if not job_id:
            return None
        return CrawlerJobDTO(
            id=job_id,
            research_task_id="task-1",
            platform="xiaohongshu",
            keywords=["museum"],
            status="running",
            last_action="crawler started",
        )


class _FakeLoginManager:
    def __init__(self) -> None:
        self.check_login_calls: list[dict[str, object]] = []
        self.start_login_calls: list[dict[str, object]] = []
        self.cancel_login_calls = 0

        self.check_login_result = (True, {"platform": "xiaohongshu", "logged_in": True})
        self.start_login_result = (True, "login started")
        self.cancel_login_result = (True, "login cancelled")

    def snapshot(self) -> dict[str, object]:
        return {"active_task": {"running": False}}

    def check_login(self, platform: str, headless: bool = True):
        self.check_login_calls.append({"platform": platform, "headless": headless})
        return self.check_login_result

    def start_login(
        self,
        *,
        platform: str,
        login_type: str,
        cookies: str = "",
        phone: str = "",
        headless: bool = True,
    ):
        self.start_login_calls.append(
            {
                "platform": platform,
                "login_type": login_type,
                "cookies": cookies,
                "phone": phone,
                "headless": headless,
            }
        )
        return self.start_login_result

    def cancel_login(self):
        self.cancel_login_calls += 1
        return self.cancel_login_result


class _FakeCrawlManager:
    def __init__(self) -> None:
        self.start_calls: list[dict[str, object]] = []
        self.stop_calls = 0
        self.start_result = (True, "crawler started")
        self.stop_result = (True, "crawler stopped")
        self.snapshot_payload = {"status": "running", "history_id": "crawl-2"}

    def snapshot(self) -> dict[str, object]:
        return dict(self.snapshot_payload)

    def start(self, payload: dict[str, object]):
        self.start_calls.append(dict(payload))
        return self.start_result

    def stop(self):
        self.stop_calls += 1
        return self.stop_result


class _FakeUiStateStore:
    def snapshot(self) -> dict[str, object]:
        return {"history": []}


class _FakeResearchTaskService:
    def __init__(self) -> None:
        self.status_calls: list[dict[str, object]] = []
        self.task_dtos = {
            "task-1": ResearchTaskDTO(
                id="task-1",
                title="Museum Task",
                status="ready",
                generated_query="Museum Task generated query",
                metadata={
                    "extras": {
                        "crawler_defaults": {
                            "keywords": ["Museum Task review", "Museum Task service"],
                            "crawler_type": "search",
                            "login_type": "qrcode",
                            "start_page": 3,
                            "max_notes": 50,
                            "max_comments": 12,
                            "enable_comments": True,
                            "enable_sub_comments": False,
                        },
                        "crawler_keywords_text": "Museum Task review\nMuseum Task service",
                    }
                },
            )
        }

    def get_task_dto(self, task_id: str) -> ResearchTaskDTO:
        try:
            return self.task_dtos[task_id]
        except KeyError as exc:
            raise ResearchTaskNotFoundError(f"missing task: {task_id}") from exc

    def set_task_status(
        self,
        task_id: str,
        *,
        status: str,
        last_action: str = "",
        generated_query: str = "",
        crawler_job_id: object = None,
    ):
        self.status_calls.append(
            {
                "task_id": task_id,
                "status": status,
                "last_action": last_action,
                "generated_query": generated_query,
                "crawler_job_id": crawler_job_id,
            }
        )
        return {"task_id": task_id}


def _build_service():
    query_service = _FakeCrawlerJobQueryService()
    login_manager = _FakeLoginManager()
    crawl_manager = _FakeCrawlManager()
    ui_state_store = _FakeUiStateStore()
    research_task_service = _FakeResearchTaskService()
    reload_calls: list[str] = []

    service = CrawlerService(
        crawl_manager=crawl_manager,
        login_manager=login_manager,
        ui_state_store=ui_state_store,
        crawler_query_service=query_service,
        valid_platforms=["xiaohongshu", "dianping"],
        valid_login_types=["qrcode", "phone"],
        reload_settings_callable=lambda: reload_calls.append("reloaded"),
        database_runtime_settings_getter=lambda: DatabaseRuntimeSettings(
            dialect="postgresql",
            host="db",
            port="5432",
            user="bettafish",
            password="bettafish",
            name="bettafish",
            charset="utf8mb4",
        ),
        research_task_service=research_task_service,
    )
    return service, query_service, login_manager, crawl_manager, research_task_service, reload_calls


def test_build_crawler_state_payload_includes_snapshots_and_job_view():
    service, query_service, _login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    payload = service.build_crawler_state_payload()

    assert payload == {
        "crawler": {"status": "running", "history_id": "crawl-2"},
        "login": {"active_task": {"running": False}},
        "storage": {"history": []},
        "crawler_jobs": {
            "current_job": {"id": "crawl-2"},
            "jobs": [{"id": "crawl-2"}],
        },
    }
    assert query_service.jobs_calls == 1


def test_build_crawler_jobs_payload_delegates_to_query_service():
    service, query_service, _login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    payload = service.build_crawler_jobs_payload()

    assert payload == {
        "current_job": {"id": "crawl-2"},
        "jobs": [{"id": "crawl-2"}],
    }
    assert query_service.jobs_calls == 1


def test_build_crawler_job_payload_delegates_to_query_service():
    service, query_service, _login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    payload = service.build_crawler_job_payload("crawl-7")

    assert payload == {
        "job_id": "crawl-7",
        "crawler_job": {"id": "crawl-7", "status": "running"},
    }
    assert query_service.job_calls == ["crawl-7"]


def test_get_default_save_option_uses_database_runtime_settings_boundary():
    service, _query_service, _login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    assert service.get_default_save_option() == "postgres"


def test_check_login_returns_platform_state_payload():
    service, _query_service, login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    payload = service.check_login(platform="xiaohongshu")

    assert payload == {"platform_state": {"platform": "xiaohongshu", "logged_in": True}}
    assert login_manager.check_login_calls == [{"platform": "xiaohongshu", "headless": True}]


def test_check_login_raises_validation_error_for_invalid_platform():
    service, _query_service, _login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    try:
        service.check_login(platform="")
        assert False, "expected CrawlerValidationError"
    except CrawlerValidationError as exc:
        assert str(exc) == "Please choose a valid platform."


def test_check_login_raises_conflict_error_when_manager_rejects_request():
    service, _query_service, login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()
    login_manager.check_login_result = (False, {"message": "login state is unavailable"})

    try:
        service.check_login(platform="xiaohongshu")
        assert False, "expected CrawlerOperationConflictError"
    except CrawlerOperationConflictError as exc:
        assert str(exc) == "login state is unavailable"


def test_start_login_returns_message_payload():
    service, _query_service, login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    payload = service.start_login(
        platform="xiaohongshu",
        login_type="qrcode",
        cookies="cookie=1",
        phone="13800138000",
    )

    assert payload == {"message": "login started"}
    assert login_manager.start_login_calls == [
        {
            "platform": "xiaohongshu",
            "login_type": "qrcode",
            "cookies": "cookie=1",
            "phone": "13800138000",
            "headless": True,
        }
    ]


def test_start_login_raises_validation_error_for_invalid_login_type():
    service, _query_service, _login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    try:
        service.start_login(platform="xiaohongshu", login_type="invalid-type")
        assert False, "expected CrawlerValidationError"
    except CrawlerValidationError as exc:
        assert str(exc) == "Please choose a valid login type."


def test_start_login_raises_conflict_error_when_manager_rejects_request():
    service, _query_service, login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()
    login_manager.start_login_result = (False, "login task already exists")

    try:
        service.start_login(platform="xiaohongshu", login_type="qrcode")
        assert False, "expected CrawlerOperationConflictError"
    except CrawlerOperationConflictError as exc:
        assert str(exc) == "login task already exists"


def test_start_crawler_uses_metadata_extras_without_legacy_payload_fallback():
    service, _query_service, _login_manager, crawl_manager, research_task_service, reload_calls = _build_service()
    research_task_service.task_dtos["task-1"].legacy_payload = {}

    payload = service.start_crawler(
        {
            "research_task_id": "task-1",
            "platform": "xiaohongshu",
        }
    )

    assert payload == {"message": "crawler started", "job_id": "crawl-2"}
    assert reload_calls == ["reloaded"]
    assert crawl_manager.start_calls == [
        {
            "research_task_id": "task-1",
            "platform": "xiaohongshu",
            "keywords": "Museum Task review\nMuseum Task service",
            "crawler_type": "search",
            "login_type": "qrcode",
            "start_page": 3,
            "max_notes": 50,
            "max_comments": 12,
            "enable_comments": True,
            "enable_sub_comments": False,
        }
    ]


def test_cancel_login_returns_message_payload():
    service, _query_service, login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    payload = service.cancel_login()

    assert payload == {"message": "login cancelled"}
    assert login_manager.cancel_login_calls == 1


def test_cancel_login_raises_conflict_error_when_manager_rejects_request():
    service, _query_service, login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()
    login_manager.cancel_login_result = (False, "login task is not running")

    try:
        service.cancel_login()
        assert False, "expected CrawlerOperationConflictError"
    except CrawlerOperationConflictError as exc:
        assert str(exc) == "login task is not running"


def test_start_crawler_returns_message_payload_and_reloads_settings():
    service, _query_service, _login_manager, crawl_manager, research_task_service, reload_calls = _build_service()

    payload = service.start_crawler({"platform": "xiaohongshu", "keywords": ["museum"]})

    assert payload == {"message": "crawler started", "job_id": "crawl-2"}
    assert crawl_manager.start_calls == [{"platform": "xiaohongshu", "keywords": "museum"}]
    assert reload_calls == ["reloaded"]
    assert research_task_service.status_calls == []


def test_start_crawler_links_job_back_to_research_task_when_task_id_is_present():
    service, _query_service, _login_manager, crawl_manager, research_task_service, reload_calls = _build_service()

    payload = service.start_crawler({"platform": "xiaohongshu", "research_task_id": "task-1"})

    assert payload == {"message": "crawler started", "job_id": "crawl-2"}
    assert crawl_manager.start_calls == [
        {
            "platform": "xiaohongshu",
            "research_task_id": "task-1",
            "keywords": "Museum Task review\nMuseum Task service",
            "crawler_type": "search",
            "login_type": "qrcode",
            "start_page": 3,
            "max_notes": 50,
            "max_comments": 12,
            "enable_comments": True,
            "enable_sub_comments": False,
        }
    ]
    assert reload_calls == ["reloaded"]
    assert research_task_service.status_calls == [
        {
            "task_id": "task-1",
            "status": "crawling",
            "last_action": "crawler started",
            "generated_query": "Museum Task generated query",
            "crawler_job_id": "crawl-2",
        }
    ]


def test_start_crawler_keeps_explicit_payload_over_research_task_defaults():
    service, _query_service, _login_manager, crawl_manager, research_task_service, _reload_calls = _build_service()

    service.start_crawler(
        {
            "platform": "xiaohongshu",
            "research_task_id": "task-1",
            "keywords": "custom keyword",
            "login_type": "phone",
            "start_page": 8,
            "max_notes": 5,
            "max_comments": 6,
            "enable_comments": False,
            "enable_sub_comments": True,
        }
    )

    assert crawl_manager.start_calls == [
        {
            "platform": "xiaohongshu",
            "research_task_id": "task-1",
            "keywords": "custom keyword",
            "crawler_type": "search",
            "login_type": "phone",
            "start_page": 8,
            "max_notes": 5,
            "max_comments": 6,
            "enable_comments": False,
            "enable_sub_comments": True,
        }
    ]
    assert research_task_service.status_calls[0]["generated_query"] == "Museum Task generated query"


def test_start_crawler_rejects_unknown_research_task_id():
    service, _query_service, _login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    try:
        service.start_crawler({"platform": "xiaohongshu", "research_task_id": "missing"})
        assert False, "expected CrawlerValidationError"
    except CrawlerValidationError as exc:
        assert str(exc) == "Research task not found."


def test_start_crawler_raises_validation_error_for_invalid_platform():
    service, _query_service, _login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    try:
        service.start_crawler({"platform": ""})
        assert False, "expected CrawlerValidationError"
    except CrawlerValidationError as exc:
        assert str(exc) == "Please choose a valid platform."


def test_start_crawler_raises_conflict_error_when_manager_rejects_request():
    service, _query_service, _login_manager, crawl_manager, _research_task_service, reload_calls = _build_service()
    crawl_manager.start_result = (False, "crawler is already running")

    try:
        service.start_crawler({"platform": "xiaohongshu"})
        assert False, "expected CrawlerOperationConflictError"
    except CrawlerOperationConflictError as exc:
        assert str(exc) == "crawler is already running"

    assert reload_calls == ["reloaded"]


def test_stop_crawler_returns_message_payload():
    service, _query_service, _login_manager, crawl_manager, _research_task_service, _reload_calls = _build_service()

    payload = service.stop_crawler()

    assert payload == {"message": "crawler stopped"}
    assert crawl_manager.stop_calls == 1


def test_stop_crawler_raises_conflict_error_when_manager_rejects_request():
    service, _query_service, _login_manager, crawl_manager, _research_task_service, _reload_calls = _build_service()
    crawl_manager.stop_result = (False, "crawler is not running")

    try:
        service.stop_crawler()
        assert False, "expected CrawlerOperationConflictError"
    except CrawlerOperationConflictError as exc:
        assert str(exc) == "crawler is not running"


def test_build_task_crawler_resource_payload_returns_empty_resource_without_linked_job():
    service, _query_service, _login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    payload = service.build_task_crawler_resource_payload(
        research_task_id="task-1",
        crawler_job_id=None,
        task=ResearchTaskDTO(id="task-1", status="draft", last_action="draft task"),
    )

    assert payload["task_id"] == "task-1"
    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_build_task_crawler_resource_payload_returns_linked_job_when_available():
    service, _query_service, _login_manager, _crawl_manager, _research_task_service, _reload_calls = _build_service()

    payload = service.build_task_crawler_resource_payload(
        research_task_id="task-1",
        crawler_job_id="crawl-7",
        task=ResearchTaskDTO(id="task-1", status="crawling"),
    )

    assert payload["task_id"] == "task-1"
    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"]["status"] == "running"
    assert payload["crawler"]["history"]["linked_job_available"] is True