"""Repository pour les documents attachés."""

from sqlalchemy import select
from sqlalchemy.ext.asyncio import AsyncSession

from app.models.document import Document, DocumentType
from app.repositories.base import BaseRepository


class DocumentRepository(BaseRepository[Document]):
    """Repository pour les opérations sur les documents."""

    def __init__(self, db: AsyncSession) -> None:
        """Initialise le repository."""
        super().__init__(Document, db)

    async def get_by_item(self, item_id: int) -> list[Document]:
        """Récupère tous les documents d'un objet.

        Args:
            item_id: ID de l'objet

        Returns:
            Liste des documents
        """
        result = await self.db.execute(
            select(Document)
            .where(Document.item_id == item_id)
            .order_by(Document.type, Document.created_at)
        )
        return list(result.scalars().all())

    async def get_by_item_and_type(
        self, item_id: int, type: DocumentType
    ) -> list[Document]:
        """Récupère les documents d'un objet par type.

        Args:
            item_id: ID de l'objet
            type: Type de document

        Returns:
            Liste des documents
        """
        result = await self.db.execute(
            select(Document)
            .where(Document.item_id == item_id, Document.type == type)
            .order_by(Document.created_at)
        )
        return list(result.scalars().all())

    async def get_by_filename(self, filename: str) -> Document | None:
        """Récupère un document par son nom de fichier.

        Args:
            filename: Nom du fichier (UUID)

        Returns:
            Le document trouvé ou None
        """
        result = await self.db.execute(
            select(Document).where(Document.filename == filename)
        )
        return result.scalar_one_or_none()

    async def count_by_item(self, item_id: int) -> int:
        """Compte le nombre de documents d'un objet.

        Args:
            item_id: ID de l'objet

        Returns:
            Nombre de documents
        """
        from sqlalchemy import func

        result = await self.db.execute(
            select(func.count(Document.id)).where(Document.item_id == item_id)
        )
        return result.scalar_one()

    async def get_photos(self, item_id: int) -> list[Document]:
        """Récupère les photos d'un objet.

        Args:
            item_id: ID de l'objet

        Returns:
            Liste des photos
        """
        return await self.get_by_item_and_type(item_id, DocumentType.PHOTO)

    async def get_invoices(self, item_id: int) -> list[Document]:
        """Récupère les factures d'un objet.

        Args:
            item_id: ID de l'objet

        Returns:
            Liste des factures
        """
        return await self.get_by_item_and_type(item_id, DocumentType.INVOICE)

    async def get_manuals(self, item_id: int) -> list[Document]:
        """Récupère les notices d'un objet.

        Args:
            item_id: ID de l'objet

        Returns:
            Liste des notices
        """
        return await self.get_by_item_and_type(item_id, DocumentType.MANUAL)