from typing import Optional

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

from app.auth import get_current_admin_user
from app.database import get_session
from app.models import Underwriter
from app.schemas import UnderwriterCreate, UnderwriterUpdate, UnderwriterResponse
from app.user_models import User

router = APIRouter()


@router.get("/", response_model=list[UnderwriterResponse])
async def list_underwriters(
    active: Optional[bool] = Query(None, description="Filter by active status"),
    session: AsyncSession = Depends(get_session),
):
    query = select(Underwriter).order_by(Underwriter.display_order)
    if active is not None:
        query = query.where(Underwriter.active == active)
    result = await session.execute(query)
    return list(result.scalars().all())


@router.get("/{underwriter_id}", response_model=UnderwriterResponse)
async def get_underwriter(underwriter_id: int, session: AsyncSession = Depends(get_session)):
    result = await session.execute(select(Underwriter).where(Underwriter.id == underwriter_id))
    uw = result.scalar_one_or_none()
    if not uw:
        return {"error": "Underwriter not found"}
    return uw


@router.post("/", response_model=UnderwriterResponse, status_code=201)
async def create_underwriter(
    payload: UnderwriterCreate,
    session: AsyncSession = Depends(get_session),
    _: User = Depends(get_current_admin_user),
):
    uw = Underwriter(**payload.model_dump(), active=True)
    session.add(uw)
    await session.commit()
    await session.refresh(uw)
    return uw


@router.put("/{underwriter_id}", response_model=UnderwriterResponse)
async def update_underwriter(
    underwriter_id: int,
    payload: UnderwriterUpdate,
    session: AsyncSession = Depends(get_session),
    _: User = Depends(get_current_admin_user),
):
    result = await session.execute(select(Underwriter).where(Underwriter.id == underwriter_id))
    uw = result.scalar_one_or_none()
    if not uw:
        return {"error": "Underwriter not found"}
    for key, value in payload.model_dump(exclude_unset=True).items():
        setattr(uw, key, value)
    await session.commit()
    await session.refresh(uw)
    return uw


@router.delete("/{underwriter_id}", status_code=204)
async def delete_underwriter(
    underwriter_id: int,
    session: AsyncSession = Depends(get_session),
    _: User = Depends(get_current_admin_user),
):
    result = await session.execute(select(Underwriter).where(Underwriter.id == underwriter_id))
    uw = result.scalar_one_or_none()
    if not uw:
        return {"error": "Underwriter not found"}
    await session.delete(uw)
    await session.commit()