"""
Radiologist per-report commission ledger endpoints (superadmin tracking).
"""

from typing import Annotated
from uuid import UUID

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

from app.core.auth_deps import get_current_user, require_permission
from app.core.dependencies import get_db
from app.core.exceptions import ForbiddenException
from app.core.pagination import PaginationParams
from app.core.permissions import PermissionCode
from app.core.responses import PaginatedResponse, SuccessResponse
from app.models.user import User
from app.repositories.lab_repository import LabRepository
from app.schemas.referral import CommissionSettleRequest, RadiologistCommissionResponse
from app.services.radiologist_commission_service import RadiologistCommissionService

router = APIRouter(prefix="/radiologist-commissions", tags=["Radiologist Commissions"])
_service = RadiologistCommissionService()


async def _resolve_lab_id(
    db: AsyncSession,
    user: User,
    requested_lab_id: UUID | None,
) -> UUID:
    """Resolve and authorize the target branch lab_id."""
    if user.is_superadmin:
        if requested_lab_id:
            return requested_lab_id
        if user.lab_id:
            return user.lab_id
        return await LabRepository().get_default_lab_id(db)

    if not user.lab_id:
        return await LabRepository().get_default_lab_id(db)

    if requested_lab_id and requested_lab_id != user.lab_id:
        raise ForbiddenException("Access denied to another lab branch.")

    return user.lab_id


@router.get(
    "",
    response_model=PaginatedResponse[RadiologistCommissionResponse],
    status_code=status.HTTP_200_OK,
    summary="List radiologist commission ledger",
    description="Retrieve paginated per-report commissions for branch radiologists.",
    dependencies=[Depends(require_permission(PermissionCode.COMMISSION_READ))],
)
async def list_radiologist_commissions(
    db: Annotated[AsyncSession, Depends(get_db)],
    current_user: Annotated[User, Depends(get_current_user)],
    pagination: Annotated[PaginationParams, Depends()],
    lab_id: UUID | None = Query(None, description="Filter by lab branch ID"),
    radiologist_id: UUID | None = Query(None, description="Filter by radiologist user ID"),
    is_settled: bool | None = Query(None, description="Filter by settled payout status"),
) -> PaginatedResponse[RadiologistCommissionResponse]:
    target_lab_id = await _resolve_lab_id(db, current_user, lab_id)
    return await _service.list_commissions(
        db,
        lab_id=target_lab_id,
        radiologist_id=radiologist_id,
        is_settled=is_settled,
        page=pagination.page,
        limit=pagination.limit,
    )


@router.post(
    "/{entry_id}/settle",
    response_model=SuccessResponse[RadiologistCommissionResponse],
    status_code=status.HTTP_200_OK,
    summary="Settle radiologist commission entry",
    description="Disburse payout for an individual radiologist commission entry.",
    dependencies=[Depends(require_permission(PermissionCode.COMMISSION_WRITE))],
)
async def settle_radiologist_commission(
    entry_id: UUID,
    data: CommissionSettleRequest,
    db: Annotated[AsyncSession, Depends(get_db)],
    current_user: Annotated[User, Depends(get_current_user)],
    lab_id: UUID | None = Query(None, description="Lab branch ID"),
) -> SuccessResponse[RadiologistCommissionResponse]:
    target_lab_id = await _resolve_lab_id(db, current_user, lab_id)
    entry = await _service.settle_entry(db, entry_id, target_lab_id, notes=data.notes)
    return SuccessResponse(data=entry, message="Commission entry settled successfully.")