from __future__ import annotations

import uuid

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

from cpv3.modules.transcription.models import Transcription
from cpv3.modules.transcription.schemas import TranscriptionCreate, TranscriptionUpdate


class TranscriptionRepository:
    """Repository for Transcription database operations."""

    def __init__(self, session: AsyncSession) -> None:
        self._session = session

    async def list_all(self) -> list[Transcription]:
        stmt: Select[tuple[Transcription]] = select(Transcription).where(
            Transcription.is_active.is_(True)
        )
        result = await self._session.execute(
            stmt.order_by(Transcription.created_at.desc())
        )
        return list(result.scalars().all())

    async def get_by_id(self, transcription_id: uuid.UUID) -> Transcription | None:
        result = await self._session.execute(
            select(Transcription)
            .where(Transcription.id == transcription_id)
            .where(Transcription.is_active.is_(True))
        )
        return result.scalar_one_or_none()

    async def get_by_artifact_id(self, artifact_id: uuid.UUID) -> Transcription | None:
        result = await self._session.execute(
            select(Transcription)
            .where(Transcription.artifact_id == artifact_id)
            .where(Transcription.is_active.is_(True))
        )
        return result.scalar_one_or_none()

    async def create(self, data: TranscriptionCreate) -> Transcription:
        transcription = Transcription(
            project_id=data.project_id,
            source_file_id=data.source_file_id,
            artifact_id=data.artifact_id,
            engine=data.engine,
            language=data.language,
            document=data.document,
            transcribe_options=data.transcribe_options,
        )

        self._session.add(transcription)
        await self._session.commit()
        await self._session.refresh(transcription)
        return transcription

    async def update(
        self, transcription: Transcription, data: TranscriptionUpdate
    ) -> Transcription:
        for key, value in data.model_dump(exclude_unset=True).items():
            if value is not None:
                setattr(transcription, key, value)

        await self._session.commit()
        await self._session.refresh(transcription)
        return transcription

    async def deactivate(self, transcription: Transcription) -> None:
        transcription.is_active = False
        await self._session.commit()