"""Tests for basic_memory.schema.resolver -- schema resolution order."""

from unittest.mock import AsyncMock

import pytest

from basic_memory.schema.parser import SchemaDefinition
from basic_memory.schema.resolver import resolve_schema


@pytest.fixture
def mock_search_fn():
    """A mock search function that returns empty by default."""
    return AsyncMock(return_value=[])


# --- Inline schema (priority 1) ---


class TestInlineSchema:
    @pytest.mark.asyncio
    async def test_inline_schema_parsed_directly(self, mock_search_fn):
        frontmatter = {
            "type": "Meeting",
            "schema": {
                "date": "string",
                "attendees?(array)": "string",
            },
        }
        result = await resolve_schema(frontmatter, mock_search_fn)

        assert result is not None
        assert isinstance(result, SchemaDefinition)
        assert result.entity == "Meeting"
        assert len(result.fields) == 2
        # Inline schema should NOT call search at all
        mock_search_fn.assert_not_called()

    @pytest.mark.asyncio
    async def test_inline_schema_uses_type_for_entity(self, mock_search_fn):
        frontmatter = {
            "type": "CustomType",
            "schema": {"field": "string"},
        }
        result = await resolve_schema(frontmatter, mock_search_fn)
        assert result.entity == "CustomType"

    @pytest.mark.asyncio
    async def test_inline_schema_defaults_entity_to_unknown(self, mock_search_fn):
        frontmatter = {
            "schema": {"field": "string"},
        }
        result = await resolve_schema(frontmatter, mock_search_fn)
        assert result.entity == "unknown"

    @pytest.mark.asyncio
    async def test_inline_schema_respects_validation_mode(self, mock_search_fn):
        frontmatter = {
            "type": "Test",
            "schema": {"name": "string"},
            "settings": {"validation": "strict"},
        }
        result = await resolve_schema(frontmatter, mock_search_fn)
        assert result.validation_mode == "strict"


# --- Explicit reference (priority 2) ---


class TestExplicitReference:
    @pytest.mark.asyncio
    async def test_explicit_ref_calls_search(self, mock_search_fn):
        schema_note_frontmatter = {
            "entity": "Person",
            "schema": {"name": "string"},
        }
        mock_search_fn.return_value = [schema_note_frontmatter]

        frontmatter = {"schema": "Person"}
        result = await resolve_schema(frontmatter, mock_search_fn)

        assert result is not None
        assert result.entity == "Person"
        mock_search_fn.assert_called_once_with("Person")

    @pytest.mark.asyncio
    async def test_explicit_ref_not_found_falls_through(self, mock_search_fn):
        """If explicit ref search returns nothing, fall through to implicit by type."""
        mock_search_fn.return_value = []

        frontmatter = {"schema": "NonExistent", "type": "Person"}
        await resolve_schema(frontmatter, mock_search_fn)

        # Search called twice: once for explicit ref "NonExistent", once for type "Person"
        assert mock_search_fn.call_count == 2

    @pytest.mark.asyncio
    async def test_explicit_ref_not_found_no_type_returns_none(self, mock_search_fn):
        frontmatter = {"schema": "NonExistent"}
        result = await resolve_schema(frontmatter, mock_search_fn)
        assert result is None


# --- Implicit by type (priority 3) ---


class TestImplicitByType:
    @pytest.mark.asyncio
    async def test_implicit_type_lookup(self, mock_search_fn):
        schema_note_frontmatter = {
            "entity": "Book",
            "schema": {"title": "string"},
        }
        mock_search_fn.return_value = [schema_note_frontmatter]

        frontmatter = {"type": "Book"}
        result = await resolve_schema(frontmatter, mock_search_fn)

        assert result is not None
        assert result.entity == "Book"
        mock_search_fn.assert_called_once_with("Book")

    @pytest.mark.asyncio
    async def test_implicit_type_not_found(self, mock_search_fn):
        frontmatter = {"type": "UnknownType"}
        result = await resolve_schema(frontmatter, mock_search_fn)
        assert result is None


# --- No schema (priority 4) ---


class TestNoSchema:
    @pytest.mark.asyncio
    async def test_no_schema_no_type(self, mock_search_fn):
        result = await resolve_schema({}, mock_search_fn)
        assert result is None
        mock_search_fn.assert_not_called()

    @pytest.mark.asyncio
    async def test_empty_frontmatter(self, mock_search_fn):
        result = await resolve_schema({}, mock_search_fn)
        assert result is None


# --- Priority order ---


class TestResolutionPriority:
    @pytest.mark.asyncio
    async def test_inline_beats_type(self, mock_search_fn):
        """Inline schema should win over implicit type lookup."""
        frontmatter = {
            "type": "Person",
            "schema": {"custom_field": "string"},
        }
        result = await resolve_schema(frontmatter, mock_search_fn)

        # Inline schema parsed, search never called
        assert result is not None
        assert result.fields[0].name == "custom_field"
        mock_search_fn.assert_not_called()