from fastapi import APIRouter, Depends, HTTPException, Query
from fastapi import status as http_status
from sqlalchemy.orm import Session

from app.core.database import get_db
from app.core.masking import mask_configured
from app.core.security import ApiPrincipal, require_api_key
from app.modules.business.constants import BusinessField, BusinessResponseKey
from app.modules.business.registry import supported_domain_values
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 {BusinessResponseKey.DOMAINS: supported_domain_values()}


@router.get("/{domain}", response_model=DomainListRead)
def list_records(
    domain: str,
    limit: int = Query(default=50, ge=1, le=500),
    offset: int = Query(default=0, ge=0),
    status_filter: str | None = Query(default=None, alias=BusinessField.STATUS),
    db: Session = Depends(get_db),
) -> dict:
    try:
        total, items = BusinessService(db).list_records(domain, limit, offset, status_filter)
    except KeyError as exc:
        raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
    return {
        BusinessResponseKey.DOMAIN: domain,
        BusinessResponseKey.TOTAL: total,
        BusinessResponseKey.ITEMS: mask_configured(items),
    }


@router.get("/{domain}/{record_id}")
def get_record(
    domain: str,
    record_id: int,
    db: Session = Depends(get_db),
) -> dict:
    try:
        return {
            BusinessResponseKey.DOMAIN: domain,
            BusinessResponseKey.DATA: mask_configured(
                BusinessService(db).get_record(domain, record_id)
            ),
        }
    except KeyError as exc:
        raise HTTPException(status_code=http_status.HTTP_404_NOT_FOUND, 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=http_status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
    return {
        BusinessResponseKey.DOMAIN: domain,
        BusinessResponseKey.DATA: mask_configured(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=http_status.HTTP_404_NOT_FOUND, detail=str(exc)) from exc
    return {
        BusinessResponseKey.DOMAIN: domain,
        BusinessResponseKey.DATA: mask_configured(data),
    }