"""
Test suite for FileDocumentRepository with async/await support.

This module contains comprehensive tests for all FileDocumentRepository methods
using mongomock-motor for in-memory MongoDB testing.
"""

import pytest
from datetime import datetime
from typing import Dict, Any

import pytest_asyncio
from bson import ObjectId
from pymongo.errors import DuplicateKeyError, PyMongoError
from mongomock_motor import AsyncMongoMockClient

from app.database.repositories.document_repository import FileDocumentRepository
from app.models.document import FileDocument, FileType


@pytest_asyncio.fixture
async def in_memory_repository():
  """Create an in-memory FileDocumentRepository for testing."""
  client = AsyncMongoMockClient()
  db = client.test_database
  repo = FileDocumentRepository(db)
  # repo.db = db
  # repo.collection = db.files
  await repo.initialize()
  return repo


@pytest.fixture
def sample_file_document():
  """Sample FileDocument data for testing."""
  return FileDocument(
    filename="test_document.pdf",
    filepath="/path/to/test_document.pdf",
    file_hash="a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456",
    file_type=FileType("pdf"),
    detected_at=datetime.now(),
  )


@pytest.fixture
def sample_update_data():
  """Sample update data for testing."""
  return {
      "metadata": {"tags": ["updated", "document"]},
      "file_type": FileType("txt"),
  }


@pytest.fixture
def multiple_sample_documents():
  """Multiple FileDocument objects for list/search testing."""
  base_time = datetime.now()
  return [
      FileDocument(
        filename="document1.pdf",
        filepath="/path/to/document1.pdf",
        file_hash="hash1" + "0" * 58,
        file_type=FileType("pdf"),
        detected_at=base_time,
      ),
      FileDocument(
        filename="similar_document.pdf",
        filepath="/path/to/similar_document.pdf",
        file_hash="hash2" + "0" * 58,
        file_type=FileType("pdf"),
        detected_at=base_time,
      ),
      FileDocument(
        filename="completely_different.txt",
        filepath="/path/to/completely_different.txt",
        file_hash="hash3" + "0" * 58,
        file_type=FileType("pdf"),
        detected_at=base_time,
      )
  ]


class TestFileDocumentRepositoryInitialization:
  """Tests for repository initialization."""
  
  @pytest.mark.asyncio
  async def test_i_can_initialize_repository(self):
    """Test repository initialization."""
    # Arrange
    client = AsyncMongoMockClient()
    db = client.test_database
    repo = FileDocumentRepository(db)
    await repo.initialize()
    
    # Act & Assert (should not raise any exception)
    assert repo.db is not None
    assert repo.collection is not None
    # TODO : check that the indexes are create


class TestFileDocumentRepositoryCreation:
  """Tests for file document creation functionality."""
  
  @pytest.mark.asyncio
  async def test_i_can_create_document(self, in_memory_repository, sample_file_document):
    """Test successful file document creation."""
    # Act
    created_doc = await in_memory_repository.create_document(sample_file_document)
    
    # Assert
    assert created_doc is not None
    assert created_doc.filename == sample_file_document.filename
    assert created_doc.filepath == sample_file_document.filepath
    assert created_doc.file_hash == sample_file_document.file_hash
    assert created_doc.file_type == sample_file_document.file_type
    assert created_doc.id is not None
    assert isinstance(created_doc.id, ObjectId)
  
  @pytest.mark.asyncio
  async def test_i_can_create_document_without_id(self, in_memory_repository, sample_file_document):
    """Test creating document with _id set to None (should be removed)."""
    # Arrange
    sample_file_document.id = None
    
    # Act
    created_doc = await in_memory_repository.create_document(sample_file_document)
    
    # Assert
    assert created_doc is not None
    assert created_doc.id is not None
    assert isinstance(created_doc.id, ObjectId)
  
  @pytest.mark.asyncio
  async def test_i_cannot_create_duplicate_document(self, in_memory_repository, sample_file_document):
    """Test that creating document with duplicate hash raises DuplicateKeyError."""
    # Arrange
    await in_memory_repository.create_document(sample_file_document)
    duplicate_doc = FileDocument(
      filename="different_name.pdf",
      filepath=sample_file_document.filepath,
      file_hash="different_hash" + "0" * 58,
      file_type=FileType("pdf"),
      detected_at=datetime.now()
    )
    
    # Act & Assert
    with pytest.raises(DuplicateKeyError) as exc_info:
      await in_memory_repository.create_document(duplicate_doc)
    
    assert "already exists" in str(exc_info.value)
  
  @pytest.mark.asyncio
  async def test_i_cannot_create_document_with_pymongo_error(self, in_memory_repository, sample_file_document, mocker):
    """Test handling of PyMongo errors during document creation."""
    # Arrange
    mocker.patch.object(in_memory_repository.collection, 'insert_one', side_effect=PyMongoError("Database error"))
    
    # Act & Assert
    with pytest.raises(ValueError) as exc_info:
      await in_memory_repository.create_document(sample_file_document)
    
    assert "Failed to create file document" in str(exc_info.value)


class TestFileDocumentRepositoryFinding:
  """Tests for file document finding functionality."""
  
  @pytest.mark.asyncio
  async def test_i_can_find_document_by_valid_id(self, in_memory_repository, sample_file_document):
    """Test finding document by valid ObjectId."""
    # Arrange
    created_doc = await in_memory_repository.create_document(sample_file_document)
    
    # Act
    found_doc = await in_memory_repository.find_document_by_id(str(created_doc.id))
    
    # Assert
    assert found_doc is not None
    assert found_doc.id == created_doc.id
    assert found_doc.filename == created_doc.filename
    assert found_doc.file_hash == created_doc.file_hash
  
  @pytest.mark.asyncio
  async def test_i_cannot_find_document_with_invalid_id(self, in_memory_repository):
    """Test that invalid ObjectId returns None."""
    # Act
    found_doc = await in_memory_repository.find_document_by_id("invalid_id")
    
    # Assert
    assert found_doc is None
  
  @pytest.mark.asyncio
  async def test_i_cannot_find_document_by_nonexistent_id(self, in_memory_repository):
    """Test that nonexistent but valid ObjectId returns None."""
    # Arrange
    nonexistent_id = str(ObjectId())
    
    # Act
    found_doc = await in_memory_repository.find_document_by_id(nonexistent_id)
    
    # Assert
    assert found_doc is None
  
  @pytest.mark.asyncio
  async def test_i_can_find_document_by_hash(self, in_memory_repository, sample_file_document):
    """Test finding document by file hash."""
    # Arrange
    created_doc = await in_memory_repository.create_document(sample_file_document)
    
    # Act
    found_doc = await in_memory_repository.find_document_by_hash(sample_file_document.file_hash)
    
    # Assert
    assert found_doc is not None
    assert found_doc.file_hash == created_doc.file_hash
    assert found_doc.id == created_doc.id
  
  @pytest.mark.asyncio
  async def test_i_cannot_find_document_with_nonexistent_hash(self, in_memory_repository):
    """Test that nonexistent hash returns None."""
    # Act
    found_doc = await in_memory_repository.find_document_by_hash("nonexistent_hash")
    
    # Assert
    assert found_doc is None
  
  @pytest.mark.asyncio
  async def test_i_can_find_document_by_filepath(self, in_memory_repository, sample_file_document):
    """Test finding document by exact filepath."""
    # Arrange
    created_doc = await in_memory_repository.create_document(sample_file_document)
    
    # Act
    found_doc = await in_memory_repository.find_document_by_filepath(sample_file_document.filepath)
    
    # Assert
    assert found_doc is not None
    assert found_doc.filepath == created_doc.filepath
    assert found_doc.id == created_doc.id
  
  @pytest.mark.asyncio
  async def test_i_cannot_find_document_with_nonexistent_filepath(self, in_memory_repository):
    """Test that nonexistent filepath returns None."""
    # Act
    found_doc = await in_memory_repository.find_document_by_filepath("/nonexistent/path.pdf")
    
    # Assert
    assert found_doc is None


class TestFileDocumentRepositoryFuzzySearch:
  """Tests for fuzzy search functionality by filename."""
  
  @pytest.mark.asyncio
  async def test_i_can_find_documents_by_exact_name(self, in_memory_repository, multiple_sample_documents):
    """Test finding documents with exact filename match."""
    # Arrange
    for doc in multiple_sample_documents:
      await in_memory_repository.create_document(doc)
    
    # Act
    found_docs = await in_memory_repository.find_document_by_name("document1.pdf")
    
    # Assert
    assert len(found_docs) == 1
    assert found_docs[0].filename == "document1.pdf"
  
  @pytest.mark.asyncio
  async def test_i_can_find_documents_by_fuzzy_name(self, in_memory_repository, multiple_sample_documents):
    """Test finding documents with fuzzy matching using default threshold."""
    # Arrange
    for doc in multiple_sample_documents:
      await in_memory_repository.create_document(doc)
    
    # Act
    found_docs = await in_memory_repository.find_document_by_name("document")
    
    # Assert
    assert len(found_docs) >= 2  # Should find document1.pdf and similar_document.pdf
    filenames = [doc.filename for doc in found_docs]
    assert "document1.pdf" in filenames
    assert "similar_document.pdf" in filenames
  
  @pytest.mark.asyncio
  async def test_i_cannot_find_documents_by_name_with_pymongo_error(self, in_memory_repository, mocker):
    """Test handling of PyMongo errors during name search."""
    # Arrange
    mocker.patch.object(in_memory_repository.collection, 'find', side_effect=PyMongoError("Database error"))
    
    # Act
    found_docs = await in_memory_repository.find_document_by_name("test")
    
    # Assert
    assert found_docs == []


class TestFileDocumentRepositoryListing:
  """Tests for document listing functionality."""
  
  @pytest.mark.asyncio
  async def test_i_can_list_documents_with_default_pagination(self, in_memory_repository, multiple_sample_documents):
    """Test listing documents with default pagination."""
    # Arrange
    for doc in multiple_sample_documents:
      await in_memory_repository.create_document(doc)
    
    # Act
    docs = await in_memory_repository.list_documents()
    
    # Assert
    assert len(docs) == len(multiple_sample_documents)
    assert all(isinstance(doc, FileDocument) for doc in docs)
  
  @pytest.mark.asyncio
  async def test_i_can_list_documents_with_custom_pagination(self, in_memory_repository, multiple_sample_documents):
    """Test listing documents with custom pagination."""
    # Arrange
    for doc in multiple_sample_documents:
      await in_memory_repository.create_document(doc)
    
    # Act
    docs_page1 = await in_memory_repository.list_documents(skip=0, limit=2)
    docs_page2 = await in_memory_repository.list_documents(skip=2, limit=2)
    
    # Assert
    assert len(docs_page1) == 2
    assert len(docs_page2) == 1  # Only 3 total documents
    
    # Ensure no overlap between pages
    page1_ids = [doc.id for doc in docs_page1]
    page2_ids = [doc.id for doc in docs_page2]
    assert len(set(page1_ids).intersection(set(page2_ids))) == 0
  
  @pytest.mark.asyncio
  async def test_i_can_list_documents_sorted_by_date(self, in_memory_repository, sample_file_document):
    """Test that documents are sorted by detected_at in descending order."""
    # Arrange
    from datetime import timedelta
    
    # Create documents with different timestamps
    doc1 = sample_file_document.model_copy()
    doc1.filename = "oldest.pdf"
    doc1.filepath = f"/path/to/{doc1.filename}"
    doc1.file_hash = "hash1" + "0" * 58
    doc1.detected_at = datetime.now() - timedelta(hours=2)
    
    doc2 = sample_file_document.model_copy()
    doc2.filename = "newest.pdf"
    doc2.filepath = f"/path/to/{doc2.filename}"
    doc2.file_hash = "hash2" + "0" * 58
    doc2.detected_at = datetime.now()
    
    await in_memory_repository.create_document(doc1)
    await in_memory_repository.create_document(doc2)
    
    # Act
    docs = await in_memory_repository.list_documents()
    
    # Assert
    assert len(docs) == 2
    assert docs[0].filename == "newest.pdf"  # Most recent first
    assert docs[1].filename == "oldest.pdf"
  
  @pytest.mark.asyncio
  async def test_i_can_list_empty_documents(self, in_memory_repository):
    """Test listing documents from empty collection."""
    # Act
    docs = await in_memory_repository.list_documents()
    
    # Assert
    assert docs == []
  
  @pytest.mark.asyncio
  async def test_i_cannot_list_documents_with_pymongo_error(self, in_memory_repository, mocker):
    """Test handling of PyMongo errors during document listing."""
    # Arrange
    mocker.patch.object(in_memory_repository.collection, 'find', side_effect=PyMongoError("Database error"))
    
    # Act
    docs = await in_memory_repository.list_documents()
    
    # Assert
    assert docs == []


class TestFileDocumentRepositoryUpdate:
  """Tests for document update functionality."""
  
  @pytest.mark.asyncio
  async def test_i_can_update_document_successfully(self, in_memory_repository, sample_file_document,
                                                    sample_update_data):
    """Test successful document update."""
    # Arrange
    created_doc = await in_memory_repository.create_document(sample_file_document)
    
    # Act
    updated_doc = await in_memory_repository.update_document(str(created_doc.id), sample_update_data)
    
    # Assert
    assert updated_doc is not None
    assert updated_doc.file_type == sample_update_data["file_type"]
    assert updated_doc.id == created_doc.id
    assert updated_doc.filename == created_doc.filename  # Unchanged fields remain
  
  @pytest.mark.asyncio
  async def test_i_can_update_document_with_partial_data(self, in_memory_repository, sample_file_document):
    """Test updating document with partial data."""
    # Arrange
    created_doc = await in_memory_repository.create_document(sample_file_document)
    partial_update = {"file_type": FileType("txt")}
    
    # Act
    updated_doc = await in_memory_repository.update_document(str(created_doc.id), partial_update)
    
    # Assert
    assert updated_doc is not None
    assert updated_doc.file_type == FileType("txt")
    assert updated_doc.filename == created_doc.filename  # Should remain unchanged
    assert updated_doc.filepath == created_doc.filepath  # Should remain unchanged
  
  @pytest.mark.asyncio
  async def test_i_can_update_document_filtering_none_values(self, in_memory_repository, sample_file_document):
    """Test that None values are filtered out from update data."""
    # Arrange
    created_doc = await in_memory_repository.create_document(sample_file_document)
    update_with_none = {"metadata": {"tags": ["updated", "document"]}, "file_type": None}
    
    # Act
    updated_doc = await in_memory_repository.update_document(str(created_doc.id), update_with_none)
    
    # Assert
    assert updated_doc is not None
    assert updated_doc.metadata == {"tags": ["updated", "document"]}
    assert updated_doc.file_type == created_doc.file_type  # Should remain unchanged (None filtered out)
  
  @pytest.mark.asyncio
  async def test_i_can_update_document_with_empty_data(self, in_memory_repository, sample_file_document):
    """Test updating document with empty data returns current document."""
    # Arrange
    created_doc = await in_memory_repository.create_document(sample_file_document)
    empty_update = {}
    
    # Act
    result = await in_memory_repository.update_document(str(created_doc.id), empty_update)
    
    # Assert
    assert result is not None
    assert result.filename == created_doc.filename
    assert result.file_hash == created_doc.file_hash
    assert result.metadata == created_doc.metadata
  
  @pytest.mark.asyncio
  async def test_i_cannot_update_document_with_invalid_id(self, in_memory_repository, sample_update_data):
    """Test that updating with invalid ID returns None."""
    # Act
    result = await in_memory_repository.update_document("invalid_id", sample_update_data)
    
    # Assert
    assert result is None
  
  @pytest.mark.asyncio
  async def test_i_cannot_update_nonexistent_document(self, in_memory_repository, sample_update_data):
    """Test that updating nonexistent document returns None."""
    # Arrange
    nonexistent_id = str(ObjectId())
    
    # Act
    result = await in_memory_repository.update_document(nonexistent_id, sample_update_data)
    
    # Assert
    assert result is None
  
  @pytest.mark.asyncio
  async def test_i_cannot_update_document_with_pymongo_error(self, in_memory_repository, sample_file_document,
                                                             sample_update_data, mocker):
    """Test handling of PyMongo errors during document update."""
    # Arrange
    created_doc = await in_memory_repository.create_document(sample_file_document)
    mocker.patch.object(in_memory_repository.collection, 'find_one_and_update',
                        side_effect=PyMongoError("Database error"))
    
    # Act
    result = await in_memory_repository.update_document(str(created_doc.id), sample_update_data)
    
    # Assert
    assert result is None


class TestFileDocumentRepositoryDeletion:
  """Tests for document deletion functionality."""
  
  @pytest.mark.asyncio
  async def test_i_can_delete_existing_document(self, in_memory_repository, sample_file_document):
    """Test successful document deletion."""
    # Arrange
    created_doc = await in_memory_repository.create_document(sample_file_document)
    
    # Act
    deletion_result = await in_memory_repository.delete_document(str(created_doc.id))
    
    # Assert
    assert deletion_result is True
    
    # Verify document is actually deleted
    found_doc = await in_memory_repository.find_document_by_id(str(created_doc.id))
    assert found_doc is None
  
  @pytest.mark.asyncio
  async def test_i_cannot_delete_document_with_invalid_id(self, in_memory_repository):
    """Test that deleting with invalid ID returns False."""
    # Act
    result = await in_memory_repository.delete_document("invalid_id")
    
    # Assert
    assert result is False
  
  @pytest.mark.asyncio
  async def test_i_cannot_delete_nonexistent_document(self, in_memory_repository):
    """Test that deleting nonexistent document returns False."""
    # Arrange
    nonexistent_id = str(ObjectId())
    
    # Act
    result = await in_memory_repository.delete_document(nonexistent_id)
    
    # Assert
    assert result is False
  
  @pytest.mark.asyncio
  async def test_i_cannot_delete_document_with_pymongo_error(self, in_memory_repository, sample_file_document, mocker):
    """Test handling of PyMongo errors during document deletion."""
    # Arrange
    created_doc = await in_memory_repository.create_document(sample_file_document)
    mocker.patch.object(in_memory_repository.collection, 'delete_one', side_effect=PyMongoError("Database error"))
    
    # Act
    result = await in_memory_repository.delete_document(str(created_doc.id))
    
    # Assert
    assert result is False


class TestFileDocumentRepositoryUtilities:
  """Tests for utility methods."""
  
  @pytest.mark.asyncio
  async def test_i_can_count_documents(self, in_memory_repository, sample_file_document):
    """Test counting documents."""
    # Arrange
    initial_count = await in_memory_repository.count_documents()
    await in_memory_repository.create_document(sample_file_document)
    
    # Act
    final_count = await in_memory_repository.count_documents()
    
    # Assert
    assert final_count == initial_count + 1
  
  @pytest.mark.asyncio
  async def test_i_can_count_zero_documents(self, in_memory_repository):
    """Test counting documents in empty collection."""
    # Act
    count = await in_memory_repository.count_documents()
    
    # Assert
    assert count == 0