"""Integration tests for schema validation using real fixture files."""

import pytest

from basic_memory.schema.parser import parse_schema_note, parse_picoschema, SchemaDefinition
from basic_memory.schema.validator import validate_note
from basic_memory.schema.resolver import resolve_schema

from test_schema.helpers import (
    parse_frontmatter,
    parse_observations,
    parse_relations,
    VALID_DIR,
    WARNINGS_DIR,
    EDGE_CASES_DIR,
    SCHEMAS_DIR,
)


class TestValidNotesPassValidation:
    """Validate notes that should pass against the Person schema."""

    def test_paul_graham_passes(self, person_schema_frontmatter):
        schema = parse_schema_note(person_schema_frontmatter)
        filepath = VALID_DIR / "paul-graham.md"
        obs = parse_observations(filepath)
        rels = parse_relations(filepath)
        result = validate_note("paul-graham", schema, obs, rels)
        assert result.passed is True
        assert len(result.errors) == 0

    def test_paul_graham_name_present(self, person_schema_frontmatter):
        schema = parse_schema_note(person_schema_frontmatter)
        filepath = VALID_DIR / "paul-graham.md"
        obs = parse_observations(filepath)
        rels = parse_relations(filepath)
        result = validate_note("paul-graham", schema, obs, rels)
        name_result = next(r for r in result.field_results if r.field.name == "name")
        assert name_result.status == "present"
        assert "Paul Graham" in name_result.values

    def test_paul_graham_unmatched_observations(self, person_schema_frontmatter):
        """Extra observations should appear as unmatched, not warnings."""
        schema = parse_schema_note(person_schema_frontmatter)
        filepath = VALID_DIR / "paul-graham.md"
        obs = parse_observations(filepath)
        rels = parse_relations(filepath)
        result = validate_note("paul-graham", schema, obs, rels)
        assert "fact" in result.unmatched_observations

    def test_rich_hickey_passes(self, person_schema_frontmatter):
        schema = parse_schema_note(person_schema_frontmatter)
        filepath = VALID_DIR / "rich-hickey.md"
        obs = parse_observations(filepath)
        rels = parse_relations(filepath)
        result = validate_note("rich-hickey", schema, obs, rels)
        assert result.passed is True


class TestWarningNotes:
    """Notes that should produce warnings but still pass."""

    def test_missing_required_name_warns(self, person_schema_frontmatter):
        schema = parse_schema_note(person_schema_frontmatter)
        filepath = WARNINGS_DIR / "missing-required.md"
        obs = parse_observations(filepath)
        rels = parse_relations(filepath)
        result = validate_note("missing-required", schema, obs, rels)
        assert result.passed is True
        name_result = next(r for r in result.field_results if r.field.name == "name")
        assert name_result.status == "missing"
        assert any("name" in w for w in result.warnings)

    def test_wrong_enum_value_warns(self, book_schema_frontmatter):
        schema = parse_schema_note(book_schema_frontmatter)
        filepath = WARNINGS_DIR / "wrong-enum-value.md"
        obs = parse_observations(filepath)
        rels = parse_relations(filepath)
        result = validate_note("wrong-enum", schema, obs, rels)
        genre_result = next(r for r in result.field_results if r.field.name == "genre")
        assert genre_result.status == "enum_mismatch"


class TestInlineSchemaValidation:
    """Validate notes with inline schemas."""

    def test_standup_with_inline_schema(self):
        filepath = VALID_DIR / "standup-2024-01-15.md"
        frontmatter = parse_frontmatter(filepath)
        obs = parse_observations(filepath)
        rels = parse_relations(filepath)
        assert isinstance(frontmatter.get("schema"), dict)
        fields = parse_picoschema(frontmatter["schema"])
        schema = SchemaDefinition(
            entity=frontmatter.get("type", "unknown"),
            version=1,
            fields=fields,
            validation_mode="warn",
        )
        result = validate_note("standup", schema, obs, rels)
        assert result.passed is True


class TestEdgeCaseValidation:
    """Validation edge cases."""

    def test_empty_note_missing_all_fields(self, person_schema_frontmatter):
        schema = parse_schema_note(person_schema_frontmatter)
        filepath = EDGE_CASES_DIR / "empty-note.md"
        obs = parse_observations(filepath)
        rels = parse_relations(filepath)
        result = validate_note("empty-note", schema, obs, rels)
        assert all(r.status == "missing" for r in result.field_results)

    def test_unicode_fields_validate(self, person_schema_frontmatter):
        schema = parse_schema_note(person_schema_frontmatter)
        filepath = EDGE_CASES_DIR / "unicode-fields.md"
        obs = parse_observations(filepath)
        rels = parse_relations(filepath)
        result = validate_note("unicode", schema, obs, rels)
        name_result = next(r for r in result.field_results if r.field.name == "name")
        assert name_result.status == "present"

    def test_array_single_value_passes(self, meeting_schema_frontmatter):
        schema = parse_schema_note(meeting_schema_frontmatter)
        filepath = EDGE_CASES_DIR / "array-single.md"
        obs = parse_observations(filepath)
        rels = parse_relations(filepath)
        result = validate_note("array-single", schema, obs, rels)
        attendees = next(r for r in result.field_results if r.field.name == "attendees")
        assert attendees.status == "present"
        assert len(attendees.values) == 1


class TestResolverIntegration:
    """Test schema resolution priority with fixture files."""

    @pytest.mark.asyncio
    async def test_inline_schema_overrides_type(self):
        filepath = EDGE_CASES_DIR / "inline-and-type.md"
        frontmatter = parse_frontmatter(filepath)

        async def mock_search(query: str) -> list[dict]:
            if query == "Person":
                return [parse_frontmatter(SCHEMAS_DIR / "Person.md")]
            return []

        schema = await resolve_schema(frontmatter, mock_search)
        assert schema is not None
        field_names = {f.name for f in schema.fields}
        assert "topic" in field_names
        assert "name" not in field_names

    @pytest.mark.asyncio
    async def test_explicit_ref_overrides_type(self):
        filepath = EDGE_CASES_DIR / "explicit-overrides-type.md"
        frontmatter = parse_frontmatter(filepath)

        async def mock_search(query: str) -> list[dict]:
            if query == "Meeting":
                return [parse_frontmatter(SCHEMAS_DIR / "Meeting.md")]
            if query == "Person":
                return [parse_frontmatter(SCHEMAS_DIR / "Person.md")]
            return []

        schema = await resolve_schema(frontmatter, mock_search)
        assert schema is not None
        assert schema.entity == "Meeting"

    @pytest.mark.asyncio
    async def test_no_schema_returns_none(self):
        filepath = VALID_DIR / "no-schema-note.md"
        frontmatter = parse_frontmatter(filepath)

        async def mock_search(query: str) -> list[dict]:
            return []

        schema = await resolve_schema(frontmatter, mock_search)
        assert schema is None