"""Unit-Tests Node-Identität und Rollen (PLAN.md §3.6, §6.3, §10.1)."""

from __future__ import annotations

import uuid
from pathlib import Path

import pytest
from hms_domain import NodeIdentity, NodeRole


def _roles(*r: NodeRole) -> frozenset[NodeRole]:
    return frozenset(r)


# ---------- Persistenz (§3.6, §6.3) ----------


def test_load_or_create_persists_across_restart(tmp_path: Path) -> None:
    identity_dir = tmp_path / "userdata" / "identity"
    first = NodeIdentity.load_or_create(
        identity_dir, "Show Server A", _roles(NodeRole.RENDER_NODE, NodeRole.COORDINATOR)
    )
    second = NodeIdentity.load_or_create(
        identity_dir, "Show Server A", _roles(NodeRole.RENDER_NODE, NodeRole.COORDINATOR)
    )
    assert first.node_id == second.node_id  # persistente node_id (§3.6)
    uuid.UUID(first.node_id)  # gültige UUID


def test_identity_file_location_per_spec(tmp_path: Path) -> None:
    """node_id liegt unter userdata/identity/ (§9-Struktur)."""
    identity_dir = tmp_path / "userdata" / "identity"
    NodeIdentity.load_or_create(identity_dir, "N", _roles(NodeRole.RENDER_NODE))
    assert (identity_dir / "node_id").is_file()


def test_two_nodes_get_distinct_persistent_ids(tmp_path: Path) -> None:
    a = NodeIdentity.load_or_create(tmp_path / "a", "Node A", _roles(NodeRole.RENDER_NODE))
    b = NodeIdentity.load_or_create(tmp_path / "b", "Node B", _roles(NodeRole.RENDER_NODE))
    assert a.node_id != b.node_id  # doppelte node_id wäre Fehler (§6.3)


# ---------- Rollen (§6.3) ----------


@pytest.mark.parametrize(
    "roles",
    [
        _roles(NodeRole.RENDER_NODE),
        _roles(NodeRole.COORDINATOR),
        _roles(NodeRole.CONTROL_DESK),
        _roles(NodeRole.RENDER_NODE, NodeRole.COORDINATOR),
        _roles(NodeRole.CONTROL_DESK, NodeRole.COORDINATOR),
    ],
)
def test_valid_role_combinations_accepted(roles) -> None:
    identity = NodeIdentity.ephemeral("Test Node", roles)
    assert identity.roles == roles


@pytest.mark.parametrize(
    "roles",
    [
        frozenset(),  # keine Rolle
        _roles(NodeRole.RENDER_NODE, NodeRole.CONTROL_DESK),  # Desk + Renderer unplausibel
    ],
)
def test_invalid_role_combinations_rejected(roles) -> None:
    with pytest.raises(ValueError):
        NodeIdentity.ephemeral("Test Node", roles)


def test_role_properties() -> None:
    render_only = NodeIdentity.ephemeral("R", _roles(NodeRole.RENDER_NODE))
    coord_only = NodeIdentity.ephemeral("C", _roles(NodeRole.COORDINATOR))
    both = NodeIdentity.ephemeral("B", _roles(NodeRole.RENDER_NODE, NodeRole.COORDINATOR))
    assert render_only.renders_locally and not render_only.is_coordinator
    assert coord_only.is_coordinator and not coord_only.renders_locally
    assert both.is_coordinator and both.renders_locally  # §6.3: Coordinator auf Render-Node


def test_display_name_editable_without_identity_change(tmp_path: Path) -> None:
    """Umbenennung ändert die node_id nicht (§10.1: Name ist kein Identitätsteil
    für Parameterpfade)."""
    identity_dir = tmp_path / "identity"
    a = NodeIdentity.load_or_create(identity_dir, "Alter Name", _roles(NodeRole.RENDER_NODE))
    b = NodeIdentity.load_or_create(identity_dir, "Neuer Name", _roles(NodeRole.RENDER_NODE))
    assert a.node_id == b.node_id
    assert a.display_name != b.display_name


def test_ephemeral_distinct_ids() -> None:
    a = NodeIdentity.ephemeral("A", _roles(NodeRole.RENDER_NODE))
    b = NodeIdentity.ephemeral("B", _roles(NodeRole.RENDER_NODE))
    assert a.node_id != b.node_id  # Tests dürfen niemals dieselbe ID teilen