from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session

from app.core.database import get_db
from app.core.security import ApiPrincipal, require_api_key
from app.modules.business.registry import DOMAIN_MODELS
from app.modules.business.schemas import DomainListRead, DomainRecordCreate, DomainRecordUpdate
from app.modules.business.service import BusinessService

router = APIRouter(dependencies=[Depends(require_api_key)])


@router.get("/domains")
def list_domains() -> dict[str, list[str]]:
    return {"domains": sorted(DOMAIN_MODELS)}


@router.get("/{domain}", response_model=DomainListRead)
def list_records(
    domain: str,
    limit: int = 50,
    offset: int = 0,
    status: str | None = None,
    db: Session = Depends(get_db),
) -> dict:
    try:
        total, items = BusinessService(db).list_records(domain, limit, offset, status)
    except KeyError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    return {"domain": domain, "total": total, "items": items}


@router.get("/{domain}/{record_id}")
def get_record(domain: str, record_id: int, db: Session = Depends(get_db)) -> dict:
    try:
        return {"domain": domain, "data": BusinessService(db).get_record(domain, record_id)}
    except KeyError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc


@router.post("/{domain}")
def create_record(
    domain: str,
    payload: DomainRecordCreate,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    try:
        data = BusinessService(db).create_record(
            domain,
            payload.data,
            principal.actor,
            payload.approval_ticket_id,
        )
    except KeyError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    return {"domain": domain, "data": data}


@router.patch("/{domain}/{record_id}")
def update_record(
    domain: str,
    record_id: int,
    payload: DomainRecordUpdate,
    db: Session = Depends(get_db),
    principal: ApiPrincipal = Depends(require_api_key),
) -> dict:
    try:
        data = BusinessService(db).update_record(
            domain,
            record_id,
            payload.data,
            actor=principal.actor,
            approval_ticket_id=payload.approval_ticket_id,
        )
    except KeyError as exc:
        raise HTTPException(status_code=404, detail=str(exc)) from exc
    return {"domain": domain, "data": data}