"""
多 worker 服务独立实例化（issue #11）单元测试

覆盖：
1. @service/@client 的 scope 元数据透传（顶层键，装饰期校验）
2. ServiceProvider 的 scope -> Provider 映射（request -> ContextLocalSingleton）
3. Application.run() 多 worker 模式下延迟引导（父进程跳过 apply_auto_configuration）
4. Application.bootstrap_worker() 环境变量重读 / 调度器门控 / fork 残留重置
5. server._worker_serve 与 bootstrap_worker 的桥接
6. lifespan 中 worker 启动/停止钩子的触发顺序
7. auto_discover 幂等守卫与 @on_worker_start/@on_worker_stop 的 AST 发现
"""

import asyncio
import os
import textwrap

import pytest
from fastapi.testclient import TestClient
from dependency_injector import providers as di_providers

import myboot.core.application as application_module
import myboot.core.server as server_module
from myboot.core.application import Application
from myboot.core.auto_configuration import AutoConfigurationManager
from myboot.core.decorators import (
    service,
    client,
    on_worker_start,
    on_worker_stop,
)
from myboot.core.di import DependencyContainer
from myboot.core.di.providers import ServiceProvider


# ---------------------------------------------------------------------------
# 公共 fixture
# ---------------------------------------------------------------------------

@pytest.fixture(autouse=True)
def _clean_worker_env():
    """每个测试前后清理 MYBOOT_* 环境变量

    _worker_serve / 测试本身会写入 MYBOOT_WORKER_ID 等变量，
    若不清理会污染后续 Application 构造。
    """
    saved = {k: v for k, v in os.environ.items() if k.startswith("MYBOOT_")}
    for key in saved:
        del os.environ[key]
    yield
    for key in [k for k in os.environ if k.startswith("MYBOOT_")]:
        del os.environ[key]
    os.environ.update(saved)


@pytest.fixture
def set_config():
    """临时修改全局配置，测试结束后恢复原值"""
    from myboot.core.config import get_settings

    settings = get_settings()
    changed = {}

    def _set(key, value):
        if key not in changed:
            changed[key] = settings.get(key)
        settings.set(key, value)

    yield _set

    for key, old in changed.items():
        settings.set(key, old)


# ---------------------------------------------------------------------------
# 1. scope 元数据透传
# ---------------------------------------------------------------------------

class TestScopeDecorators:
    def test_service_scope_defaults_to_singleton(self):
        @service()
        class AlphaService:
            pass

        assert AlphaService.__myboot_service__["scope"] == "singleton"

    def test_service_scope_stored_as_top_level_key(self):
        """scope 必须是顶层键（而非落入 kwargs），注册时才能读到"""

        @service(scope="request")
        class BetaService:
            pass

        meta = BetaService.__myboot_service__
        assert meta["scope"] == "request"
        assert "scope" not in meta["kwargs"]

    def test_service_invalid_scope_raises_at_decoration(self):
        with pytest.raises(ValueError, match="scope"):
            @service(scope="sigleton")  # 故意拼错
            class TypoService:
                pass

    def test_client_scope_defaults_to_singleton(self):
        @client()
        class AlphaClient:
            pass

        assert AlphaClient.__myboot_client__["scope"] == "singleton"

    def test_client_scope_stored_as_top_level_key(self):
        @client(scope="factory")
        class BetaClient:
            pass

        meta = BetaClient.__myboot_client__
        assert meta["scope"] == "factory"
        assert "scope" not in meta["kwargs"]

    def test_client_invalid_scope_raises_at_decoration(self):
        with pytest.raises(ValueError, match="scope"):
            @client(scope="prototype")
            class TypoClient:
                pass


# ---------------------------------------------------------------------------
# 2. Provider 映射
# ---------------------------------------------------------------------------

class TestProviderScopes:
    class _Dummy:
        pass

    def test_singleton_scope_creates_singleton_provider(self):
        sp = ServiceProvider(self._Dummy, "dummy", scope="singleton")
        assert isinstance(sp.create_provider(), di_providers.Singleton)

    def test_request_scope_creates_context_local_singleton(self):
        sp = ServiceProvider(self._Dummy, "dummy", scope="request")
        assert isinstance(sp.create_provider(), di_providers.ContextLocalSingleton)

    def test_factory_scope_creates_factory_provider(self):
        sp = ServiceProvider(self._Dummy, "dummy", scope="factory")
        provider = sp.create_provider()
        assert isinstance(provider, di_providers.Factory)
        assert not isinstance(provider, di_providers.Singleton)

    def test_request_scope_instances_per_asyncio_task(self):
        """request 作用域：跨 asyncio 任务不同实例，同一任务内同一实例"""

        class ReqService:
            pass

        container = DependencyContainer()
        container.register_service(ReqService, "req_service", scope="request")
        container.build_container()

        async def resolve_twice():
            first = container.get_service("req_service")
            second = container.get_service("req_service")
            return first, second

        async def main():
            (a1, a2), (b1, b2) = await asyncio.gather(
                resolve_twice(), resolve_twice()
            )
            return a1, a2, b1, b2

        a1, a2, b1, b2 = asyncio.run(main())
        assert a1 is a2  # 同一任务（请求）内单例
        assert b1 is b2
        assert a1 is not b1  # 跨任务（请求）不同实例
        # request 作用域不进入单例缓存
        assert "req_service" not in container.service_instances

    def test_register_service_accepts_decorator_metadata_with_scope(self):
        """回归：装饰器元数据（含顶层 scope 键）作为 config 传入时
        不得与 register_service 的显式 scope 参数冲突"""

        @service(scope="request")
        class MetaService:
            pass

        meta = MetaService.__myboot_service__
        container = DependencyContainer()
        container.register_service(
            MetaService, meta["name"], scope=meta["scope"], config=meta
        )
        container.build_container()

        provider = container.service_providers[meta["name"]]
        assert provider.scope == "request"

    def test_factory_scope_not_cached_by_container(self):
        class FactService:
            pass

        container = DependencyContainer()
        container.register_service(FactService, "fact_service", scope="factory")
        container.build_container()

        first = container.get_service("fact_service")
        second = container.get_service("fact_service")
        assert first is not second
        assert "fact_service" not in container.service_instances


# ---------------------------------------------------------------------------
# 3. run() 延迟引导
# ---------------------------------------------------------------------------

class TestRunDefersBootstrap:
    def _run(self, monkeypatch, set_config, workers, app_path):
        calls = []
        monkeypatch.setattr(
            application_module, "auto_discover",
            lambda pkg: calls.append(("discover", pkg)),
        )
        monkeypatch.setattr(
            application_module, "apply_auto_configuration",
            lambda app: calls.append(("apply", app)),
        )

        app = Application(name="run-defer-test")
        monkeypatch.setattr(
            app.server_manager, "start_server",
            lambda **kwargs: calls.append(("serve", kwargs)),
        )
        # conf/config.yaml 中 server.workers=1 会覆盖 run() 入参，显式设置
        set_config("server.workers", workers)
        app.run(workers=workers, app_path=app_path)
        return app, calls

    def test_multi_worker_with_app_path_skips_apply(self, monkeypatch, set_config):
        app, calls = self._run(monkeypatch, set_config, workers=2, app_path="main:app")
        events = [name for name, _ in calls]
        assert "discover" in events  # 父进程仍做 AST 发现（预热缓存）
        assert "apply" not in events  # 实例化延迟到 worker 内
        assert "serve" in events
        serve_kwargs = dict(calls)["serve"]
        assert serve_kwargs["workers"] == 2
        assert serve_kwargs["app_path"] == "main:app"

    def test_single_worker_applies_in_parent(self, monkeypatch, set_config):
        app, calls = self._run(monkeypatch, set_config, workers=1, app_path=None)
        events = [name for name, _ in calls]
        assert "discover" in events
        assert "apply" in events

    def test_multi_worker_without_app_path_falls_back_to_parent_apply(
        self, monkeypatch, set_config
    ):
        """无 app_path 的回退路径（父进程自己 serve）保持原有引导行为"""
        app, calls = self._run(monkeypatch, set_config, workers=2, app_path=None)
        events = [name for name, _ in calls]
        assert "apply" in events


# ---------------------------------------------------------------------------
# 4. bootstrap_worker()
# ---------------------------------------------------------------------------

class TestBootstrapWorker:
    def test_reads_worker_env_and_disables_scheduler_for_non_primary(self):
        app = Application(name="bw-env-test", auto_configuration=False)
        # 构造时无环境变量：默认自认 primary（这正是被修复的 bug 场景）
        assert app.is_primary_worker is True

        os.environ["MYBOOT_WORKER_ID"] = "2"
        os.environ["MYBOOT_WORKER_COUNT"] = "3"
        os.environ["MYBOOT_IS_PRIMARY_WORKER"] = "0"

        old_scheduler = app.scheduler
        result = app.bootstrap_worker()

        assert app.worker_id == 2
        assert app.worker_count == 3
        assert app.is_primary_worker is False
        # 调度器被重建且按 primary 门控禁用
        assert app.scheduler is not old_scheduler
        assert app.scheduler.is_enabled() is False
        assert result is app.get_fastapi_app()

    def test_primary_worker_keeps_scheduler_enabled(self):
        app = Application(name="bw-primary-test", auto_configuration=False)
        os.environ["MYBOOT_WORKER_ID"] = "1"
        os.environ["MYBOOT_WORKER_COUNT"] = "3"
        os.environ["MYBOOT_IS_PRIMARY_WORKER"] = "1"

        app.bootstrap_worker()
        assert app.is_primary_worker is True
        assert app.scheduler.is_enabled() is True

    def test_scheduler_on_all_workers_overrides_primary_gate(self, set_config):
        set_config("scheduler.on_all_workers", True)
        app = Application(name="bw-allworkers-test", auto_configuration=False)
        os.environ["MYBOOT_WORKER_ID"] = "2"
        os.environ["MYBOOT_WORKER_COUNT"] = "2"
        os.environ["MYBOOT_IS_PRIMARY_WORKER"] = "0"

        app.bootstrap_worker()
        assert app.is_primary_worker is False
        assert app.scheduler.is_enabled() is True

    def test_defensive_reset_on_fork_inherited_state(self):
        """fork 子进程继承父进程已引导状态时：清空注册表并重建 FastAPI 应用"""
        app = Application(name="bw-reset-test", auto_configuration=False)

        class InheritedService:
            pass

        app.di_container = DependencyContainer()
        app.di_container.register_service(InheritedService, "inherited_service")
        app.services["inherited_service"] = InheritedService()
        app.clients["inherited_client"] = object()
        app.components["inherited_component"] = object()
        app._client_type_map = {InheritedService: "inherited_client"}
        app._component_type_map = {InheritedService: "inherited_component"}
        app.worker_start_hooks.append(lambda: None)
        app.worker_stop_hooks.append(lambda: None)
        old_fastapi_app = app._fastapi_app

        result = app.bootstrap_worker()

        assert app.services == {}
        assert app.clients == {}
        assert app.components == {}
        assert app._client_type_map == {}
        assert app._component_type_map == {}
        assert app.worker_start_hooks == []
        assert app.worker_stop_hooks == []
        assert not app.di_container.service_providers
        # FastAPI 应用被重建（丢弃绑定到 fork 前实例的路由）
        assert app._fastapi_app is not old_fastapi_app
        assert result is app._fastapi_app

    def test_clean_state_keeps_pristine_fastapi_app(self):
        """正常延迟引导路径：注册表为空时不触发重置，沿用原 FastAPI 实例"""
        app = Application(name="bw-clean-test", auto_configuration=False)
        old_fastapi_app = app._fastapi_app

        result = app.bootstrap_worker()
        assert app._fastapi_app is old_fastapi_app
        assert result is old_fastapi_app

    def test_runs_auto_configuration_inside_worker(self, monkeypatch):
        calls = []
        monkeypatch.setattr(
            application_module, "auto_discover",
            lambda pkg: calls.append(("discover", pkg)),
        )
        monkeypatch.setattr(
            application_module, "apply_auto_configuration",
            lambda app: calls.append(("apply", app)),
        )
        app = Application(name="bw-autoconf-test")
        app.bootstrap_worker()

        events = [name for name, _ in calls]
        assert "discover" in events
        assert "apply" in events

    def test_auto_configuration_disabled_skips_bootstrap_apply(self, monkeypatch):
        calls = []
        monkeypatch.setattr(
            application_module, "apply_auto_configuration",
            lambda app: calls.append("apply"),
        )
        app = Application(name="bw-noautoconf-test", auto_configuration=False)
        app.bootstrap_worker()
        assert calls == []


# ---------------------------------------------------------------------------
# 5. _worker_serve 桥接
# ---------------------------------------------------------------------------

class TestWorkerServe:
    @pytest.fixture
    def serve_recorder(self, monkeypatch):
        """mock hypercorn.asyncio.serve 与 setup_worker_logging"""
        import importlib

        import hypercorn.asyncio

        # 注意：myboot.core 包的 `from .logger import logger` 会用 loguru
        # 实例遮蔽包属性 myboot.core.logger，必须经 importlib 拿到真实模块
        logger_module = importlib.import_module("myboot.core.logger")

        served = {}

        async def fake_serve(app, config):
            served["app"] = app
            served["config"] = config

        monkeypatch.setattr(hypercorn.asyncio, "serve", fake_serve)
        monkeypatch.setattr(
            logger_module, "setup_worker_logging", lambda *a, **k: None
        )
        return served

    def test_myboot_app_served_via_bootstrap_worker(
        self, monkeypatch, serve_recorder
    ):
        resolved = object()
        monkeypatch.setattr(
            server_module, "_resolve_app_from_path", lambda path: resolved
        )

        bootstrapped_app = object()
        bootstrap_calls = []

        class FakeMybootApp:
            def bootstrap_worker(self):
                bootstrap_calls.append(True)
                return bootstrapped_app

        monkeypatch.setattr(application_module, "_current_app", FakeMybootApp())

        server_module._worker_serve("main:app", {}, 2, 3)

        # 桥接：serve 的是 bootstrap_worker() 的返回值，而非解析出的原对象
        assert bootstrap_calls == [True]
        assert serve_recorder["app"] is bootstrapped_app
        # 环境变量在引导前已设置
        assert os.environ["MYBOOT_WORKER_ID"] == "2"
        assert os.environ["MYBOOT_WORKER_COUNT"] == "3"
        assert os.environ["MYBOOT_IS_PRIMARY_WORKER"] == "0"

    def test_primary_worker_env_flag(self, monkeypatch, serve_recorder):
        monkeypatch.setattr(
            server_module, "_resolve_app_from_path", lambda path: object()
        )
        monkeypatch.setattr(application_module, "_current_app", None)

        server_module._worker_serve("main:app", {}, 1, 2)
        assert os.environ["MYBOOT_IS_PRIMARY_WORKER"] == "1"

    def test_plain_asgi_app_path_untouched(self, monkeypatch, serve_recorder):
        """非 myboot 应用（_current_app 为 None）：直接 serve 解析出的对象"""
        resolved = object()
        monkeypatch.setattr(
            server_module, "_resolve_app_from_path", lambda path: resolved
        )
        monkeypatch.setattr(application_module, "_current_app", None)

        server_module._worker_serve("asgi_module:app", {}, 2, 2)
        assert serve_recorder["app"] is resolved


# ---------------------------------------------------------------------------
# 6. worker 生命周期钩子
# ---------------------------------------------------------------------------

class TestWorkerHookDecorators:
    def test_bare_decorator_marks_function(self):
        @on_worker_start
        def hook():
            pass

        assert hook.__myboot_worker_hook__ == {"event": "start", "order": 0}

    def test_decorator_with_order(self):
        @on_worker_stop(order=5)
        def hook():
            pass

        assert hook.__myboot_worker_hook__ == {"event": "stop", "order": 5}

    def test_auto_register_worker_hooks_sorted_by_order(self):
        class FakeApp:
            def __init__(self):
                self.worker_start_hooks = []
                self.worker_stop_hooks = []

            def add_worker_start_hook(self, hook):
                self.worker_start_hooks.append(hook)

            def add_worker_stop_hook(self, hook):
                self.worker_stop_hooks.append(hook)

        @on_worker_start(order=2)
        def start_late():
            pass

        @on_worker_start(order=1)
        def start_early():
            pass

        @on_worker_stop
        def stop_hook():
            pass

        manager = AutoConfigurationManager(use_cache=False)
        manager.discovered_components["worker_hooks"] = [
            {"function": start_late, "module": "m", "type": "function_on_worker_start"},
            {"function": start_early, "module": "m", "type": "function_on_worker_start"},
            {"function": stop_hook, "module": "m", "type": "function_on_worker_stop"},
        ]

        fake_app = FakeApp()
        manager._auto_register_worker_hooks(fake_app)

        assert fake_app.worker_start_hooks == [start_early, start_late]
        assert fake_app.worker_stop_hooks == [stop_hook]


class TestWorkerHooksInLifespan:
    def test_hook_firing_order_in_lifespan(self):
        """startup -> worker_start(按 order) -> scheduler.start ...
        scheduler.stop -> worker_stop -> shutdown"""
        events = []

        class StubScheduler:
            def has_jobs(self):
                return True

            def start(self):
                events.append("scheduler_start")

            def is_running(self):
                return True

            def stop(self):
                events.append("scheduler_stop")

        app = Application(name="hooks-lifespan-test", auto_configuration=False)
        app.scheduler = StubScheduler()

        def startup_hook():
            events.append("startup")

        def worker_start_sync():
            events.append("worker_start_sync")

        async def worker_start_async():
            events.append("worker_start_async")

        async def worker_stop_async():
            events.append("worker_stop_async")

        def shutdown_hook():
            events.append("shutdown")

        app.add_startup_hook(startup_hook)
        app.add_worker_start_hook(worker_start_sync)
        app.add_worker_start_hook(worker_start_async)
        app.add_worker_stop_hook(worker_stop_async)
        app.add_shutdown_hook(shutdown_hook)

        with TestClient(app.get_fastapi_app()):
            assert events == [
                "startup",
                "worker_start_sync",
                "worker_start_async",
                "scheduler_start",
            ]

        assert events == [
            "startup",
            "worker_start_sync",
            "worker_start_async",
            "scheduler_start",
            "scheduler_stop",
            "worker_stop_async",
            "shutdown",
        ]


# ---------------------------------------------------------------------------
# 7. auto_discover 幂等 + worker 钩子 AST 发现
# ---------------------------------------------------------------------------

class TestAutoDiscover:
    def _make_package(self, tmp_path):
        pkg = tmp_path / "demo_pkg"
        pkg.mkdir()
        (pkg / "__init__.py").write_text("", encoding="utf-8")
        (pkg / "stuff.py").write_text(
            textwrap.dedent(
                """
                from myboot.core.decorators import (
                    service, on_worker_start, on_worker_stop
                )


                @service()
                class DemoService:
                    pass


                @on_worker_start
                def start_hook():
                    pass


                @on_worker_stop(order=1)
                def stop_hook():
                    pass
                """
            ),
            encoding="utf-8",
        )
        return pkg

    def test_auto_discover_is_idempotent(self, tmp_path):
        self._make_package(tmp_path)
        manager = AutoConfigurationManager(app_root=str(tmp_path), use_cache=False)

        manager.auto_discover("demo_pkg")
        assert len(manager._component_metadata["services"]) == 1
        assert len(manager._component_metadata["worker_hooks"]) == 2

        # 重复调用（fork 子进程场景）：不追加重复条目
        manager.auto_discover("demo_pkg")
        assert len(manager._component_metadata["services"]) == 1
        assert len(manager._component_metadata["worker_hooks"]) == 2

    def test_worker_hooks_discovered_via_ast(self, tmp_path):
        self._make_package(tmp_path)
        manager = AutoConfigurationManager(app_root=str(tmp_path), use_cache=False)
        manager.auto_discover("demo_pkg")

        hook_types = sorted(
            item["type"] for item in manager._component_metadata["worker_hooks"]
        )
        assert hook_types == [
            "function_on_worker_start",
            "function_on_worker_stop",
        ]