import uuid
from uuid import UUID

from ntr_text_fragmentation.models.linker_entity import LinkerEntity


class TestLink:
    """Набор тестов для проверки функциональности связей (линков) с использованием LinkerEntity."""

    def test_create_link(self):
        """Тест создания объекта LinkerEntity с параметрами связи."""
        link_id = uuid.uuid4()
        name = "Тестовая связь"
        text = "Это текст тестовой связи"
        in_search_text = "Текст для поиска связи"
        metadata = {"key": "value"}
        source_id = uuid.uuid4()
        target_id = uuid.uuid4()

        link = LinkerEntity(
            id=link_id,
            name=name,
            text=text,
            in_search_text=in_search_text,
            metadata=metadata,
            source_id=source_id,
            target_id=target_id,
            type="Link"
        )

        assert link.id == link_id
        assert link.name == name
        assert link.text == text
        assert link.in_search_text == in_search_text
        assert link.metadata == metadata
        assert link.source_id == source_id
        assert link.target_id == target_id
        assert link.type == "Link"
        assert link.number_in_relation is None
        assert link.is_link() is True
        
    def test_link_fixture(self, sample_link):
        """Тест использования фикстуры с предустановленными значениями."""
        assert sample_link.id == UUID('98765432-9876-5432-9876-543298765432')
        assert sample_link.name == "Тестовая связь"
        assert sample_link.text == "Текст тестовой связи"
        assert sample_link.in_search_text is None  # Значение по умолчанию
        assert sample_link.metadata == {"test_key": "test_value"}
        assert sample_link.source_id == UUID('12345678-1234-5678-1234-567812345678')
        assert sample_link.target_id == UUID('87654321-8765-4321-8765-432187654321')
        assert sample_link.type == "Link"
        assert sample_link.number_in_relation is None
        assert sample_link.is_link() is True

    def test_link_with_number_in_relation(self):
        """Тест создания объекта LinkerEntity с указанным номером в связи."""
        link_id = uuid.uuid4()
        name = "Тестовая связь"
        text = "Это текст тестовой связи"
        in_search_text = "Текст для поиска связи"
        metadata = {"key": "value"}
        source_id = uuid.uuid4()
        target_id = uuid.uuid4()
        number_in_relation = 1

        link = LinkerEntity(
            id=link_id,
            name=name,
            text=text,
            in_search_text=in_search_text,
            metadata=metadata,
            source_id=source_id,
            target_id=target_id,
            number_in_relation=number_in_relation,
            type="Link"
        )

        assert link.id == link_id
        assert link.name == name
        assert link.text == text
        assert link.in_search_text == in_search_text
        assert link.metadata == metadata
        assert link.source_id == source_id
        assert link.target_id == target_id
        assert link.type == "Link"
        assert link.number_in_relation == number_in_relation
        assert link.is_link() is True

    def test_link_to_string(self):
        """Тест метода __str__()."""
        # Без in_search_text
        link = LinkerEntity(
            id=uuid.uuid4(),
            name="Тестовая связь",
            text="Текст тестовой связи",
            metadata={},
            source_id=uuid.uuid4(),
            target_id=uuid.uuid4(),
            type="Link"
        )
        expected_string = "Тестовая связь: Текст тестовой связи"
        assert str(link) == expected_string
        
        # С in_search_text
        link_with_search_text = LinkerEntity(
            id=uuid.uuid4(),
            name="Тестовая связь",
            text="Текст тестовой связи",
            in_search_text="Специальный текст для поиска",
            metadata={},
            source_id=uuid.uuid4(),
            target_id=uuid.uuid4(),
            type="Link"
        )
        assert str(link_with_search_text) == "Специальный текст для поиска"
        
    def test_link_compare(self, sample_link):
        """Тест метода __eq__ для сравнения связей."""
        # Создаем копию с теми же основными атрибутами
        same_link = LinkerEntity(
            id=sample_link.id,
            name=sample_link.name,
            text=sample_link.text,
            in_search_text="Другой текст для поиска",  # Отличается от sample_link
            metadata={},                              # Отличается от sample_link
            source_id=sample_link.source_id,
            target_id=sample_link.target_id,
            type="Link"
        )
        
        # Должны быть равны по __eq__, так как метаданные и in_search_text не учитываются в сравнении
        assert sample_link == same_link
        
        # Создаем связь с другим ID
        different_id_link = LinkerEntity(
            id=uuid.uuid4(),
            name=sample_link.name,
            text=sample_link.text,
            metadata=sample_link.metadata,
            source_id=sample_link.source_id,
            target_id=sample_link.target_id,
            type="Link"
        )
        
        assert sample_link != different_id_link
        
    def test_invalid_link_creation(self):
        """Тест создания некорректной связи (без source_id или target_id)."""
        link_id = uuid.uuid4()
        
        # Пробуем создать связь только с source_id
        try:
            LinkerEntity(
                id=link_id,
                name="Некорректная связь",
                text="Текст некорректной связи",
                metadata={},
                source_id=uuid.uuid4()
            )
            assert False, "Создание связи только с source_id должно вызывать исключение"
        except ValueError:
            pass
            
        # Пробуем создать связь только с target_id
        try:
            LinkerEntity(
                id=link_id,
                name="Некорректная связь",
                text="Текст некорректной связи",
                metadata={},
                target_id=uuid.uuid4()
            )
            assert False, "Создание связи только с target_id должно вызывать исключение"
        except ValueError:
            pass
            
    def test_linker_entity_as_link(self):
        """Тест использования LinkerEntity как связи."""
        entity_id = uuid.uuid4()
        source_id = uuid.uuid4()
        target_id = uuid.uuid4()
        
        # Создаем LinkerEntity с source_id и target_id
        linking_entity = LinkerEntity(
            id=entity_id,
            name="Связывающая сущность",
            text="Текст связывающей сущности",
            metadata={},
            source_id=source_id,
            target_id=target_id
        )
        
        # Проверяем, что LinkerEntity может выступать как связь
        assert linking_entity.is_link() is True
        assert linking_entity.source_id == source_id
        assert linking_entity.target_id == target_id
        
        # Создаем обычную сущность
        regular_entity = LinkerEntity(
            id=uuid.uuid4(),
            name="Обычная сущность",
            text="Текст обычной сущности",
            metadata={}
        )
        
        # Проверяем, что обычная сущность не является связью
        assert regular_entity.is_link() is False