from uuid import UUID

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

from app.database import get_postgres_session
from app.deps.domain_owner import require_domain_owner
from app.models import Account
from app.routers.auth import validate_password
from app.schemas import (
    OrgMemberCreate,
    OrgMemberListResponse,
    OrgMemberRead,
    OrgMemberRoleUpdate,
)
from app.services.org_members import (
    create_org_member,
    list_org_members,
    update_org_member_role,
)
from app.deps.org_manager import require_org_manager

router = APIRouter(prefix="/people", tags=["people"])


@router.get("", response_model=OrgMemberListResponse)
async def get_people(
    manager: Account = Depends(require_org_manager),
    session: AsyncSession = Depends(get_postgres_session),
) -> OrgMemberListResponse:
    items, counts = await list_org_members(session, manager.company_domain)
    return OrgMemberListResponse(items=items, counts=counts)


@router.post("", response_model=OrgMemberRead, status_code=status.HTTP_201_CREATED)
async def add_person(
    payload: OrgMemberCreate,
    manager: Account = Depends(require_org_manager),
    session: AsyncSession = Depends(get_postgres_session),
) -> OrgMemberRead:
    validate_password(payload.password)

    try:
        member = await create_org_member(
            session,
            manager=manager,
            payload=payload,
        )
        await session.commit()
        return member
    except ValueError as error:
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            detail=str(error),
        ) from error
    except IntegrityError as error:
        await session.rollback()
        raise HTTPException(
            status_code=status.HTTP_409_CONFLICT,
            detail="An account with those details already exists.",
        ) from error


@router.patch("/{member_id}/role", response_model=OrgMemberRead)
async def update_member_role(
    member_id: UUID,
    payload: OrgMemberRoleUpdate,
    owner: Account = Depends(require_domain_owner),
    session: AsyncSession = Depends(get_postgres_session),
) -> OrgMemberRead:
    try:
        member = await update_org_member_role(
            session,
            manager=owner,
            member_id=member_id,
            org_role=payload.org_role,
        )
        await session.commit()
        return member
    except ValueError as error:
        raise HTTPException(
            status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
            detail=str(error),
        ) from error