"""Tests for the unified active lifecycle (is_active dispatch)."""

from __future__ import annotations

from pathlib import Path
from unittest.mock import patch

from wildpc_core import lifecycle
from wildpc_core.config import load_config


class TestIsActive:
    def test_service_uses_systemctl(self, wildpc_root: Path) -> None:
        config = load_config(wildpc_root)
        with patch.object(lifecycle, "_systemctl_active", return_value=True) as mock:
            assert lifecycle.is_active("test-svc", "service", config) is True
        mock.assert_called_once_with("wildpc-test-svc.service")

    def test_job_uses_timer(self, wildpc_root: Path) -> None:
        config = load_config(wildpc_root)
        with patch.object(lifecycle, "_systemctl_active", return_value=True) as mock:
            assert lifecycle.is_active("test-job", "job", config) is True
        mock.assert_called_once_with("wildpc-test-job-job.timer")

    def test_tool_checks_path(self, wildpc_root: Path) -> None:
        config = load_config(wildpc_root)
        # give the tool a source so the tool branch is reachable
        config.programs["test-tool"].source = "/tmp/test-tool"
        with patch.object(lifecycle, "_on_path", return_value=True) as mock:
            assert lifecycle.is_active("test-tool", "tool", config) is True
        mock.assert_called_once_with("test-tool")

    def test_unknown_is_inactive(self, wildpc_root: Path) -> None:
        config = load_config(wildpc_root)
        assert lifecycle.is_active("does-not-exist", "service", config) is False

    def test_path_deployment_checks_path(self, wildpc_root: Path) -> None:
        # A `manager: path` deployment (a tool) is active when on PATH.
        from wildpc_core.manifest import PathDeployment, ProgramSpec

        config = load_config(wildpc_root)
        config.programs["mytool"] = ProgramSpec(id="mytool", source="/tmp/mytool")
        config.tools["mytool"] = PathDeployment(manager="path", program="mytool")
        with patch.object(lifecycle, "_on_path", return_value=True) as mock:
            assert lifecycle.is_active("mytool", "tool", config) is True
        mock.assert_called_once_with("mytool")

    def test_remote_deployment_is_active(self, wildpc_root: Path) -> None:
        # A remote deployment has no local process; the manager is `none` → available.
        from wildpc_core.manifest import RemoteDeployment

        config = load_config(wildpc_root)
        config.references["ext"] = RemoteDeployment(
            manager="none", program="ext", base_url="http://x"
        )
        assert lifecycle.is_active("ext", "reference", config) is True

    def test_static_deployment_active_when_dist_built(
        self, wildpc_root: Path, tmp_path: Path
    ) -> None:
        # A static (caddy) deployment is active once its served dir exists.
        from wildpc_core.manifest import CaddyDeployment, ProgramSpec

        config = load_config(wildpc_root)
        repo = tmp_path / "fe"
        config.programs["fe"] = ProgramSpec(id="fe", source=str(repo))
        config.statics["fe"] = CaddyDeployment(
            manager="caddy", program="fe", root="dist"
        )
        # No dist yet → inactive (caddy manager checks the served dir)
        assert lifecycle.is_active("fe", "static", config) is False
        # Built dist → served in place → active
        (repo / "dist").mkdir(parents=True)
        assert lifecycle.is_active("fe", "static", config) is True