"""Unit tests for KDL IR emission. Every assertion runs on a real KDL parse tree."""

from unittest import TestCase

import ckdl
from pydantic import BaseModel

from mizan_core.client.function import client
from mizan_core.ir import build_ir
from mizan_core.registry import clear_registry, register


class Prefs(BaseModel):
    live: bool = True


class Settings(BaseModel):
    meta: Prefs = Prefs()
    label: str = "plain"
    quoted: str = 'a "b" \\ c\nd\te'
    retries: int = 3
    ratio: float = 0.5
    enabled: bool = False
    tags: list[str] = []
    mapping: dict[str, str] = {}
    note: str | None = None
    who: str


def _struct_fields(document: ckdl.Document, type_name: str) -> dict[str, ckdl.Node]:
    """Field nodes of the named struct, keyed by field name."""
    for node in document.nodes:
        if node.name == "type" and node.args[0] == type_name:
            for child in node.children:
                if child.name == "struct":
                    return {field.args[0]: field for field in child.children}
    raise AssertionError(f"no struct type {type_name!r} in:\n{document}")


class EmptyDocumentTests(TestCase):
    """The IR of an empty registry."""

    def setUp(self):
        clear_registry()

    def tearDown(self):
        clear_registry()

    def test_empty_registry_emits_zero_bytes(self):
        """Nothing registered renders the empty document, not a blank line."""
        self.assertEqual(build_ir(), "")

    def test_empty_document_parses_to_zero_nodes(self):
        """The empty document is valid KDL carrying no nodes."""
        self.assertEqual(len(ckdl.parse(build_ir()).nodes), 0)


class FieldDefaultTests(TestCase):
    """Which Pydantic field defaults reach the document as KDL literals."""

    def setUp(self):
        clear_registry()

        @client
        def get_settings(request) -> Settings:
            return Settings(who="anyone")

        register(get_settings, "get_settings")
        self.fields = _struct_fields(
            ckdl.parse(build_ir()), "getSettingsOutput"
        )

    def tearDown(self):
        clear_registry()

    def test_scalar_defaults_survive_the_round_trip(self):
        """bool, int, float and str defaults parse back to the Python values."""
        self.assertEqual(self.fields["label"].properties["default"], "plain")
        self.assertEqual(self.fields["retries"].properties["default"], 3)
        self.assertEqual(self.fields["ratio"].properties["default"], 0.5)
        self.assertEqual(self.fields["enabled"].properties["default"], False)

    def test_string_default_escapes_round_trip(self):
        """Quotes, backslashes and control characters survive KDL escaping."""
        self.assertEqual(
            self.fields["quoted"].properties["default"], Settings.model_fields["quoted"].default
        )

    def test_model_valued_default_carries_no_literal(self):
        """A nested-model default has no KDL scalar form, so no `default` is emitted."""
        meta = self.fields["meta"]
        self.assertNotIn("default", meta.properties)
        self.assertIs(meta.properties["required"], False)

    def test_container_defaults_carry_no_literal(self):
        """List and dict defaults have no KDL scalar form either."""
        self.assertNotIn("default", self.fields["tags"].properties)
        self.assertNotIn("default", self.fields["mapping"].properties)

    def test_none_default_carries_no_literal(self):
        """`= None` leaves the optional shape to say the field may be absent."""
        self.assertNotIn("default", self.fields["note"].properties)

    def test_required_field_has_no_required_property(self):
        """A required field is the default, so the property is left off entirely."""
        self.assertNotIn("required", self.fields["who"].properties)
        self.assertNotIn("default", self.fields["who"].properties)