"""Tests for the reconciler's ``ref`` prop support."""

from __future__ import annotations

from typing import Any, Dict, List

from pythonnative.element import Element
from pythonnative.hooks import component, use_ref
from pythonnative.reconciler import Reconciler


class MockView:
    _next_id = 0

    def __init__(self, type_name: str, props: Dict[str, Any]) -> None:
        MockView._next_id += 1
        self.id = MockView._next_id
        self.type_name = type_name
        self.props = dict(props)
        self.children: List["MockView"] = []


class MockBackend:
    def __init__(self) -> None:
        self.last_create_props: Dict[str, Any] = {}
        self.last_update_changes: Dict[str, Any] = {}

    def create_view(self, type_name: str, props: Dict[str, Any]) -> MockView:
        # Track props the backend was asked to apply on create — ref
        # must NOT appear here; it's reconciler-owned.
        self.last_create_props = dict(props)
        return MockView(type_name, props)

    def update_view(self, view: MockView, type_name: str, changed: Dict[str, Any]) -> None:
        self.last_update_changes = dict(changed)
        view.props.update(changed)

    def add_child(self, parent: MockView, child: MockView, parent_type: str) -> None:
        parent.children.append(child)

    def remove_child(self, parent: MockView, child: MockView, parent_type: str) -> None:
        parent.children = [c for c in parent.children if c.id != child.id]

    def insert_child(self, parent: MockView, child: MockView, parent_type: str, index: int) -> None:
        parent.children.insert(index, child)


def test_ref_populated_on_mount() -> None:
    ref: Dict[str, Any] = {"current": None}
    el = Element("Text", {"text": "hi", "ref": ref}, [])
    backend = MockBackend()
    Reconciler(backend).mount(el)
    assert ref["current"] is not None
    assert isinstance(ref["current"], MockView)
    assert ref["current"].type_name == "Text"


def test_ref_not_passed_to_backend() -> None:
    ref: Dict[str, Any] = {"current": None}
    el = Element("Text", {"text": "hi", "ref": ref}, [])
    backend = MockBackend()
    Reconciler(backend).mount(el)
    assert "ref" not in backend.last_create_props


def test_ref_cleared_on_unmount() -> None:
    ref: Dict[str, Any] = {"current": None}
    el = Element("Text", {"text": "hi", "ref": ref}, [])
    backend = MockBackend()
    rec = Reconciler(backend)
    rec.mount(el)
    assert ref["current"] is not None

    # Replace with a different element type — destroys the old tree.
    rec.reconcile(Element("Button", {"title": "ok"}, []))
    assert ref["current"] is None


def test_ref_repointed_when_ref_dict_swapped() -> None:
    """Swapping the ref dict on update should populate the new and clear the old."""
    old_ref: Dict[str, Any] = {"current": None}
    new_ref: Dict[str, Any] = {"current": None}

    backend = MockBackend()
    rec = Reconciler(backend)
    rec.mount(Element("Text", {"text": "a", "ref": old_ref}, []))
    assert old_ref["current"] is not None
    first_view = old_ref["current"]

    rec.reconcile(Element("Text", {"text": "a", "ref": new_ref}, []))
    assert old_ref["current"] is None
    assert new_ref["current"] is first_view


def test_ref_ignored_when_not_a_dict() -> None:
    """Non-dict ``ref`` values are silently ignored — no crashes."""
    el = Element("Text", {"text": "hi", "ref": "not-a-dict"}, [])
    backend = MockBackend()
    Reconciler(backend).mount(el)


def test_ref_diff_does_not_trigger_native_update() -> None:
    """Changing only the ref dict identity should NOT call update_view."""
    backend = MockBackend()
    rec = Reconciler(backend)
    ref_a: Dict[str, Any] = {"current": None}
    ref_b: Dict[str, Any] = {"current": None}

    rec.mount(Element("Text", {"text": "x", "ref": ref_a}, []))
    backend.last_update_changes = {}

    rec.reconcile(Element("Text", {"text": "x", "ref": ref_b}, []))
    assert backend.last_update_changes == {}
    assert ref_a["current"] is None
    assert ref_b["current"] is not None


def test_use_ref_in_component_populated_after_mount() -> None:
    captured: Dict[str, Any] = {}

    @component
    def Comp() -> Element:
        ref = use_ref(None)
        captured["ref"] = ref
        return Element("Text", {"text": "hi", "ref": ref}, [])

    Reconciler(MockBackend()).mount(Comp())
    ref = captured["ref"]
    assert ref["current"] is not None
    assert isinstance(ref["current"], MockView)