import logging
import uuid

from fastapi import APIRouter, Depends, Response, status
from sqlalchemy.ext.asyncio import AsyncSession

from app.core.deps import get_db_session, get_current_user, require_study_member
from app.schemas.notification import GeneralNotificationFeed, GeneralNotificationRead, NotificationItem
from app.services import document_service, notification_service, project_reminder_service

router = APIRouter()
logger = logging.getLogger(__name__)


@router.get(
    "/notifications",
    response_model=list[NotificationItem],
    dependencies=[Depends(require_study_member())],
)
async def list_notifications(
    study_id: uuid.UUID,
    skip: int = 0,
    limit: int = 20,
    db: AsyncSession = Depends(get_db_session),
    current_user=Depends(get_current_user),
) -> list[NotificationItem]:
    return await document_service.list_distribution_notifications(
        db,
        study_id,
        current_user,
        skip=skip,
        limit=limit,
    )


@router.get(
    "/notifications/feed",
    response_model=GeneralNotificationFeed,
    dependencies=[Depends(require_study_member())],
)
async def list_general_notifications(
    study_id: uuid.UUID,
    limit: int = 10,
    db: AsyncSession = Depends(get_db_session),
    current_user=Depends(get_current_user),
) -> GeneralNotificationFeed:
    try:
        await project_reminder_service.sync_project_reminders(db, study_id, current_user)
    except Exception:
        await db.rollback()
        logger.warning("Failed to synchronize legacy project reminders", exc_info=True)
    return await notification_service.list_feed(
        db,
        study_id=study_id,
        recipient_id=current_user.id,
        limit=limit,
    )


@router.post(
    "/notifications/{notification_id}/read",
    response_model=GeneralNotificationRead,
    dependencies=[Depends(require_study_member())],
)
async def mark_general_notification_read(
    study_id: uuid.UUID,
    notification_id: uuid.UUID,
    db: AsyncSession = Depends(get_db_session),
    current_user=Depends(get_current_user),
) -> GeneralNotificationRead:
    return await notification_service.mark_read(
        db,
        study_id=study_id,
        recipient_id=current_user.id,
        notification_id=notification_id,
    )


@router.post(
    "/notifications/read-all",
    status_code=status.HTTP_204_NO_CONTENT,
    dependencies=[Depends(require_study_member())],
)
async def mark_all_general_notifications_read(
    study_id: uuid.UUID,
    db: AsyncSession = Depends(get_db_session),
    current_user=Depends(get_current_user),
) -> Response:
    await notification_service.mark_all_read(db, study_id=study_id, recipient_id=current_user.id)
    return Response(status_code=status.HTTP_204_NO_CONTENT)