from fastapi import HTTPException, status
from sqlalchemy import desc, func, select

from app.db.session import AsyncSessionLocal
from app.models.upload import UploadRecord


async def create_upload_record(
    *,
    upload_id: str,
    original_filename: str,
    content_type: str,
    size_bytes: int,
    element_count: int,
    removed_elements_count: int,
    removed_attributes_count: int,
    normalized_elements_count: int,
    normalized_seats_count: int,
    normalized_groups_count: int,
    normalized_sectors_count: int,
    original_storage_path: str,
    sanitized_storage_path: str,
    normalized_storage_path: str,
    processing_status: str = "completed",
) -> None:
    async with AsyncSessionLocal() as session:
        row = UploadRecord(
            upload_id=upload_id,
            original_filename=original_filename,
            content_type=content_type,
            size_bytes=size_bytes,
            element_count=element_count,
            removed_elements_count=removed_elements_count,
            removed_attributes_count=removed_attributes_count,
            normalized_elements_count=normalized_elements_count,
            normalized_seats_count=normalized_seats_count,
            normalized_groups_count=normalized_groups_count,
            normalized_sectors_count=normalized_sectors_count,
            original_storage_path=original_storage_path,
            sanitized_storage_path=sanitized_storage_path,
            normalized_storage_path=normalized_storage_path,
            processing_status=processing_status,
        )
        session.add(row)
        await session.commit()


async def list_upload_records(limit: int = 50, offset: int = 0) -> list[UploadRecord]:
    async with AsyncSessionLocal() as session:
        result = await session.execute(
            select(UploadRecord)
            .order_by(desc(UploadRecord.created_at), desc(UploadRecord.id))
            .limit(limit)
            .offset(offset)
        )
        return list(result.scalars().all())


async def count_upload_records() -> int:
    async with AsyncSessionLocal() as session:
        result = await session.execute(select(func.count()).select_from(UploadRecord))
        value = result.scalar_one()
        return int(value)


async def get_upload_record_by_upload_id(upload_id: str) -> UploadRecord:
    async with AsyncSessionLocal() as session:
        result = await session.execute(
            select(UploadRecord).where(UploadRecord.upload_id == upload_id)
        )
        row = result.scalar_one_or_none()

        if row is None:
            raise HTTPException(
                status_code=status.HTTP_404_NOT_FOUND,
                detail="Upload not found",
            )

        return row