from sqlalchemy import select, func
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.orm import selectinload

from app.db.models import Resource, User
from app.schemas.resource import ResourceCreate


async def create_resource(
    db: AsyncSession,
    class_id: int,
    uploader_id: int,
    data: ResourceCreate,
    file_url: str,
    file_type: str,
    file_size: int,
) -> Resource:
    resource = Resource(
        class_id=class_id,
        uploader_id=uploader_id,
        title=data.title,
        description=data.description,
        file_url=file_url,
        file_type=file_type,
        file_size=file_size,
        category=data.category,
    )
    db.add(resource)
    await db.commit()
    await db.refresh(resource)
    return resource


async def list_resources(
    db: AsyncSession, class_id: int, category: str | None = None, page: int = 1, page_size: int = 20
) -> tuple[list[Resource], int]:
    query = select(Resource).where(Resource.class_id == class_id)
    count_query = select(func.count(Resource.id)).where(Resource.class_id == class_id)

    if category:
        query = query.where(Resource.category == category)
        count_query = count_query.where(Resource.category == category)

    total_result = await db.execute(count_query)
    total = total_result.scalar() or 0

    result = await db.execute(
        query.options(selectinload(Resource.uploader))
        .order_by(Resource.created_at.desc())
        .offset((page - 1) * page_size)
        .limit(page_size)
    )
    resources = list(result.scalars().all())
    return resources, total


async def get_resource_by_id(db: AsyncSession, resource_id: int) -> Resource | None:
    result = await db.execute(
        select(Resource)
        .options(selectinload(Resource.uploader))
        .where(Resource.id == resource_id)
    )
    return result.scalar_one_or_none()


async def increment_download_count(db: AsyncSession, resource: Resource) -> Resource:
    resource.download_count += 1
    await db.commit()
    await db.refresh(resource)
    return resource


async def delete_resource(db: AsyncSession, resource: Resource):
    await db.delete(resource)
    await db.commit()