"""Focused tests for the Agent Management read model."""

import unittest
from uuid import UUID

from app.agent_registry.service import AgentRegistryService
from app.identity import required_api_permission


SITE_ID = UUID("00000000-0000-4000-8000-000000001800")
ZONE_ID = UUID("00000000-0000-4000-8000-000000001801")


class FakeAgentRegistryRepository:
    def list_registry(self):
        return {
            "sites": [
                {
                    "id": SITE_ID,
                    "name": "Test Site",
                }
            ],
            "zones": [
                {
                    "id": ZONE_ID,
                    "site_id": SITE_ID,
                    "site_name": "Test Site",
                    "name": "Network A",
                    "description": None,
                    "is_enabled": True,
                    "assigned_agent_id": "agent-test",
                    "networks": ["10.50.0.0/24"],
                }
            ],
            "agents": [
                {
                    "agent_id": "agent-test",
                    "display_name": "Test Agent",
                    "site_id": SITE_ID,
                    "site_name": "Test Site",
                    "agent_zone_id": ZONE_ID,
                    "agent_zone_name": "Network A",
                    "agent_zone_enabled": True,
                    "hostname": "test-agent",
                    "version": "1.0.0-alpha",
                    "ip_address": "10.50.0.10",
                    "last_checkin_at": "2026-08-26T20:00:00+00:00",
                    "credential_state": "active",
                    "credential_created_at": "2026-08-26T19:00:00+00:00",
                    "credential_revoked_at": None,
                }
            ],
        }


class AgentRegistryServiceTests(unittest.TestCase):
    def test_projection_is_factual_and_zone_aware(self):
        data = AgentRegistryService(
            FakeAgentRegistryRepository()
        ).list_registry()

        self.assertEqual(len(data.agents), 1)
        self.assertEqual(len(data.sites), 1)
        self.assertEqual(len(data.zones), 1)

        agent = data.agents[0]
        self.assertEqual(agent.agent_id, "agent-test")
        self.assertEqual(agent.credential_state, "active")
        self.assertEqual(agent.routing_state, "assigned")
        self.assertEqual(
            data.zones[0].networks,
            ["10.50.0.0/24"],
        )

    def test_unassigned_and_disabled_routing_are_not_fabricated_online_states(self):
        repository = FakeAgentRegistryRepository()

        repository.list_registry = lambda: {
            "sites": [],
            "zones": [],
            "agents": [
                {
                    "agent_id": "legacy",
                    "display_name": None,
                    "site_id": None,
                    "site_name": "Legacy Site",
                    "agent_zone_id": None,
                    "agent_zone_name": None,
                    "agent_zone_enabled": None,
                    "hostname": None,
                    "version": None,
                    "ip_address": None,
                    "last_checkin_at": "2026-08-26T20:00:00+00:00",
                    "credential_state": "legacy",
                    "credential_created_at": None,
                    "credential_revoked_at": None,
                }
            ],
        }

        data = AgentRegistryService(repository).list_registry()

        self.assertEqual(
            data.agents[0].routing_state,
            "unassigned",
        )
        self.assertEqual(
            data.agents[0].credential_state,
            "legacy",
        )

    def test_api_permission_mapping_is_explicit(self):
        self.assertEqual(
            required_api_permission("GET", "/api/agents"),
            "agents.view",
        )


if __name__ == "__main__":
    unittest.main()