import pytest
from uuid import uuid4
from unittest.mock import AsyncMock
try:
    from backend.src.application.use_cases.collection_use_cases import CollectionUseCases
    from backend.src.shared.exceptions import NotFoundError, ForbiddenError
    from backend.src.domain.repositories.collection_access_repository import ICollectionAccessRepository
except ImportError:
    from src.application.use_cases.collection_use_cases import CollectionUseCases
    from src.shared.exceptions import NotFoundError, ForbiddenError
    from src.domain.repositories.collection_access_repository import ICollectionAccessRepository


class TestCollectionUseCases:

    @pytest.fixture
    def collection_use_cases(self, mock_collection_repository, mock_user_repository):
        mock_access_repository = AsyncMock()
        mock_access_repository.get_by_user_and_collection = AsyncMock(return_value=None)
        mock_access_repository.create = AsyncMock()
        mock_access_repository.delete_by_user_and_collection = AsyncMock(return_value=True)
        mock_access_repository.list_by_user = AsyncMock(return_value=[])
        
        return CollectionUseCases(
            collection_repository=mock_collection_repository,
            access_repository=mock_access_repository,
            user_repository=mock_user_repository
        )

    @pytest.mark.asyncio
    async def test_create_collection_success(self, collection_use_cases, mock_user, 
                                            mock_collection_repository, mock_user_repository):
        owner_id = uuid4()
        mock_user_repository.get_by_id = AsyncMock(return_value=mock_user)
        mock_collection_repository.create = AsyncMock(return_value=mock_user)
        
        result = await collection_use_cases.create_collection(
            name="Тестовая коллекция",
            owner_id=owner_id,
            description="Описание",
            is_public=False
        )
        
        assert result is not None
        mock_user_repository.get_by_id.assert_called_once_with(owner_id)
        mock_collection_repository.create.assert_called_once()

    @pytest.mark.asyncio
    async def test_create_collection_user_not_found(self, collection_use_cases, mock_user_repository):
        owner_id = uuid4()
        mock_user_repository.get_by_id = AsyncMock(return_value=None)
        
        with pytest.raises(NotFoundError):
            await collection_use_cases.create_collection(
                name="Коллекция",
                owner_id=owner_id
            )

    @pytest.mark.asyncio
    async def test_get_collection_success(self, collection_use_cases, mock_collection, mock_collection_repository):
        collection_id = uuid4()
        mock_collection_repository.get_by_id = AsyncMock(return_value=mock_collection)
        
        result = await collection_use_cases.get_collection(collection_id)
        
        assert result == mock_collection
        mock_collection_repository.get_by_id.assert_called_once_with(collection_id)

    @pytest.mark.asyncio
    async def test_get_collection_not_found(self, collection_use_cases, mock_collection_repository):
        collection_id = uuid4()
        mock_collection_repository.get_by_id = AsyncMock(return_value=None)
        
        with pytest.raises(NotFoundError):
            await collection_use_cases.get_collection(collection_id)

    @pytest.mark.asyncio
    async def test_update_collection_success(self, collection_use_cases, mock_collection, mock_collection_repository):
        collection_id = uuid4()
        user_id = uuid4()
        mock_collection.owner_id = user_id
        mock_collection_repository.get_by_id = AsyncMock(return_value=mock_collection)
        mock_collection_repository.update = AsyncMock(return_value=mock_collection)
        
        result = await collection_use_cases.update_collection(
            collection_id=collection_id,
            user_id=user_id,
            name="Обновленное название"
        )
        
        assert result is not None
        assert mock_collection.name == "Обновленное название"

    @pytest.mark.asyncio
    async def test_update_collection_forbidden(self, collection_use_cases, mock_collection, mock_collection_repository):
        collection_id = uuid4()
        user_id = uuid4()
        owner_id = uuid4()
        mock_collection.owner_id = owner_id
        mock_collection_repository.get_by_id = AsyncMock(return_value=mock_collection)
        
        with pytest.raises(ForbiddenError):
            await collection_use_cases.update_collection(
                collection_id=collection_id,
                user_id=user_id,
                name="Название"
            )

    @pytest.mark.asyncio
    async def test_check_access_owner(self, collection_use_cases, mock_collection, mock_collection_repository):
        collection_id = uuid4()
        user_id = uuid4()
        mock_collection.owner_id = user_id
        mock_collection.is_public = False
        mock_collection_repository.get_by_id = AsyncMock(return_value=mock_collection)
        
        result = await collection_use_cases.check_access(collection_id, user_id)
        
        assert result is True

    @pytest.mark.asyncio
    async def test_check_access_public(self, collection_use_cases, mock_collection, mock_collection_repository):
        collection_id = uuid4()
        user_id = uuid4()
        owner_id = uuid4()
        mock_collection.owner_id = owner_id
        mock_collection.is_public = True
        mock_collection_repository.get_by_id = AsyncMock(return_value=mock_collection)
        
        result = await collection_use_cases.check_access(collection_id, user_id)
        
        assert result is True