from __future__ import annotations

import uuid

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

from cpv3.modules.files.models import File
from cpv3.modules.files.schemas import FileCreate, FileUpdate
from cpv3.modules.users.models import User


class FileRepository:
    """Repository for File database operations."""

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

    async def list_all(self, *, requester: User) -> list[File]:
        stmt: Select[tuple[File]] = select(File).where(File.is_deleted.is_(False))
        if not requester.is_staff:
            stmt = stmt.where(File.owner_id == requester.id)

        result = await self._session.execute(stmt.order_by(File.created_at.desc()))
        return list(result.scalars().all())

    async def get_by_id(self, file_id: uuid.UUID) -> File | None:
        result = await self._session.execute(select(File).where(File.id == file_id))
        file = result.scalar_one_or_none()
        if file is None:
            return None
        if file.is_deleted:
            return None
        return file

    async def create(self, *, requester: User, data: FileCreate) -> File:
        file = File(
            owner_id=requester.id,
            project_id=data.project_id,
            original_filename=data.original_filename,
            path=data.path,
            storage_backend=data.storage_backend,
            mime_type=data.mime_type,
            size_bytes=data.size_bytes,
            checksum=data.checksum,
            file_format=data.file_format,
            is_uploaded=data.is_uploaded,
        )

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

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

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

    async def mark_deleted(self, file: File) -> None:
        file.is_deleted = True
        await self._session.commit()