import uuid

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

from api.database import get_session
from api.models.domain import Domain
from api.models.extension_point import EPStatus, ExtensionPoint
from api.schemas.extension_point import EPCreate, EPRead, EPUpdate

router = APIRouter(prefix="/extension-points", tags=["extension-points"])


async def _resolve_domain_id(slug: str, session: AsyncSession) -> uuid.UUID:
    """Resolve a domain slug to its UUID, raising 422 if unknown."""
    row = await session.execute(
        select(Domain.id).where(Domain.slug == slug, Domain.status == "active")
    )
    domain_id = row.scalar_one_or_none()
    if domain_id is None:
        valid = [r[0] for r in (await session.execute(
            select(Domain.slug).where(Domain.status == "active")
        )).all()]
        raise HTTPException(
            status_code=422,
            detail=f"Unknown domain '{slug}'. Valid domains: {sorted(valid)}",
        )
    return domain_id


@router.get("/", response_model=list[EPRead])
async def list_eps(
    domain: str | None = None,
    status: EPStatus | None = None,
    ep_type: str | None = None,
    session: AsyncSession = Depends(get_session),
) -> list[ExtensionPoint]:
    q = select(ExtensionPoint)
    if domain:
        domain_id = await _resolve_domain_id(domain, session)
        q = q.where(ExtensionPoint.domain_id == domain_id)
    if status:
        q = q.where(ExtensionPoint.status == status)
    if ep_type:
        q = q.where(ExtensionPoint.ep_type == ep_type)
    q = q.order_by(ExtensionPoint.created_at)
    result = await session.execute(q)
    return list(result.scalars().all())


@router.post("/", response_model=EPRead, status_code=status.HTTP_201_CREATED)
async def create_ep(
    body: EPCreate,
    session: AsyncSession = Depends(get_session),
) -> ExtensionPoint:
    domain_id = await _resolve_domain_id(body.domain, session)
    data = body.model_dump(exclude={"domain"})
    data["domain_id"] = domain_id
    ep = ExtensionPoint(**data)
    session.add(ep)
    await session.commit()
    await session.refresh(ep)
    return ep


@router.get("/{ep_id}", response_model=EPRead)
async def get_ep(
    ep_id: uuid.UUID,
    session: AsyncSession = Depends(get_session),
) -> ExtensionPoint:
    ep = await session.get(ExtensionPoint, ep_id)
    if ep is None:
        raise HTTPException(status_code=404, detail="Extension point not found")
    return ep


@router.patch("/{ep_id}", response_model=EPRead)
async def update_ep(
    ep_id: uuid.UUID,
    body: EPUpdate,
    session: AsyncSession = Depends(get_session),
) -> ExtensionPoint:
    ep = await session.get(ExtensionPoint, ep_id)
    if ep is None:
        raise HTTPException(status_code=404, detail="Extension point not found")
    for field, value in body.model_dump(exclude_unset=True).items():
        setattr(ep, field, value)
    await session.commit()
    await session.refresh(ep)
    return ep


@router.delete("/{ep_id}", response_model=EPRead)
async def defer_ep(
    ep_id: uuid.UUID,
    session: AsyncSession = Depends(get_session),
) -> ExtensionPoint:
    ep = await session.get(ExtensionPoint, ep_id)
    if ep is None:
        raise HTTPException(status_code=404, detail="Extension point not found")
    ep.status = EPStatus.deferred
    await session.commit()
    await session.refresh(ep)
    return ep