File size: 22,417 Bytes
5f12c93
 
 
 
58e4c2a
5f12c93
 
9223feb
5f12c93
 
 
 
8defa71
5f12c93
 
 
 
f6c0922
f418863
 
f6c0922
 
 
 
 
5f12c93
82f306a
5f12c93
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9223feb
5f12c93
 
 
 
 
 
 
9223feb
5f12c93
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
9223feb
58e4c2a
 
 
 
5f12c93
 
58e4c2a
5f12c93
f6c0922
58e4c2a
f6c0922
 
 
 
 
 
 
 
 
 
 
 
 
 
5f12c93
 
 
 
 
9223feb
5f12c93
 
 
 
 
 
 
9223feb
5f12c93
 
 
 
 
 
9223feb
5f12c93
 
 
f6c0922
5f12c93
58e4c2a
 
 
 
5f12c93
 
 
58e4c2a
 
 
 
5f12c93
 
 
 
 
 
 
 
 
 
58e4c2a
5f12c93
 
f6c0922
5f12c93
 
 
 
 
 
 
2f4ab65
 
 
 
 
 
 
 
5f12c93
f6c0922
5f12c93
f6c0922
5f12c93
 
 
 
 
 
f6c0922
 
 
58e4c2a
5f12c93
 
 
 
 
244663c
f6c0922
 
 
 
 
 
 
 
 
 
 
 
 
 
5f12c93
 
 
f6c0922
 
5f12c93
58e4c2a
 
 
 
f418863
5f12c93
 
 
58e4c2a
 
 
 
5f12c93
 
 
 
 
 
 
 
 
8defa71
 
 
 
2f4ab65
 
 
5f12c93
9223feb
5f12c93
 
 
 
 
 
 
 
ea9df53
244663c
efe5cdf
5f12c93
f6c0922
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5f12c93
 
f6c0922
 
5f12c93
 
 
 
 
 
 
 
f418863
 
5f12c93
 
 
 
 
 
 
 
 
c03d875
5f12c93
 
c03d875
8defa71
 
 
 
 
2f4ab65
 
 
 
 
5f12c93
 
 
9223feb
8defa71
 
 
 
 
2f4ab65
5f12c93
c03d875
 
 
 
 
 
 
 
5f12c93
 
9223feb
5f12c93
 
 
 
 
 
 
 
ea9df53
244663c
efe5cdf
 
5f12c93
f6c0922
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5f12c93
 
 
8defa71
 
5f12c93
 
 
 
 
 
9f05894
 
 
 
efe5cdf
7f24904
f6c0922
5f12c93
 
8defa71
 
2f4ab65
 
 
 
 
5f12c93
 
0e75654
 
2f4ab65
 
0e75654
f6c0922
 
 
 
 
 
 
 
 
 
 
 
 
5f12c93
 
 
 
 
9223feb
5f12c93
 
 
 
 
 
f6c0922
5f12c93
 
244663c
 
f6c0922
 
 
 
 
 
 
 
 
 
 
 
 
244663c
5f12c93
 
9223feb
5f12c93
 
 
 
 
 
f6c0922
5f12c93
 
f6c0922
 
 
 
 
 
 
 
 
 
 
 
 
 
 
5f12c93
 
 
 
f485d1b
5f12c93
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
f6c0922
5f12c93
f6c0922
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
"""
Lógica de negocio para Solicitudes de Internación / Traslado.
"""
from __future__ import annotations
import logging
from datetime import datetime, timezone
from fastapi import HTTPException
from supabase import Client

from app.models.solicitud import Solicitud
from app.models.cama import Cama
from app.models.reserva import ReservaQuirofano
from app.schemas.solicitud import SolicitudHceWebhook, SolicitudResolucionRequest, AltaMedicaWebhook
from app.schemas.enums import EstadoCamaEnum, EstadoReservaEnum
from app.crud import solicitud as solicitud_crud
from app.crud import cama as cama_crud
from app.crud import reserva as reserva_crud
from app.crud import auditoria as auditoria_crud
from app.integrations import hce, monitoreo, facturacion
from app.services._common import validar_paciente_o_502
from app.schemas.enums import (
    EntidadAuditoriaEnum,
    TipoEventoAuditoriaEnum,
    OrigenAuditoriaEnum,
)

logger = logging.getLogger(__name__)

_ERR_NOT_FOUND = {"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Solicitud no encontrada"}


# ─── Helpers ───────────────────────────────────────────────────────────────

def _parse_solicitud_id(solicitud_id: str) -> int:
    try:
        return int(solicitud_id.split("-")[-1])
    except (ValueError, IndexError):
        raise HTTPException(
            status_code=400,
            detail={"codigo": "ERROR_VALIDACION", "mensaje": f"ID de solicitud inválido: {solicitud_id}"},
        )


def _get_solicitud_or_404(db: Client, solicitud_id: str) -> Solicitud:
    num_id = _parse_solicitud_id(solicitud_id)
    sol = solicitud_crud.get_by_id(db, num_id)
    if not sol:
        raise HTTPException(status_code=404, detail=_ERR_NOT_FOUND)
    return sol


def _get_cama_or_404(db: Client, cama_id: int) -> Cama:
    c = cama_crud.get_by_id(db, cama_id)
    if not c:
        raise HTTPException(
            status_code=404,
            detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": f"Cama {cama_id} no encontrada"},
        )
    return c


def _verificar_contraindicaciones(paciente_id: int, cama: Cama) -> None:
    contraindicaciones = hce.get_contraindicaciones(paciente_id)
    incompatibles = cama.contraindicaciones_incompatibles or []
    conflicto = set(contraindicaciones) & set(incompatibles)
    if conflicto:
        raise HTTPException(
            status_code=422,
            detail={
                "codigo": "CONTRAINDICACION_DETECTADA",
                "mensaje": "El paciente tiene contraindicaciones incompatibles con la cama",
            },
        )


# ─── Recibir solicitud desde HCE (M1) ─────────────────────────────────────

def recibir_solicitud(db: Client, data: SolicitudHceWebhook) -> Solicitud:
    logger.info(
        "Recibiendo solicitud HCE — solicitud_hce_id=%s tipo=%s paciente_id=%s",
        data.solicitud_hce_id, data.tipo, data.paciente_id,
    )
    existing = solicitud_crud.get_by_hce_id(db, data.solicitud_hce_id)
    if existing:
        logger.info("Solicitud duplicada (idempotente) — solicitud_hce_id=%s id=%s", data.solicitud_hce_id, existing.solicitud_id)
        return existing
    sol = solicitud_crud.create(db, data)
    logger.info("Solicitud creada — id=%s tipo=%s paciente_id=%s", sol.solicitud_id, sol.tipo, sol.paciente_id)
    auditoria_crud.registrar(
        db,
        entidad=EntidadAuditoriaEnum.SOLICITUD.value,
        entidad_id=sol.solicitud_id,
        cama_id=sol.cama_solicitada_id,
        evento=TipoEventoAuditoriaEnum.SOLICITUD_RECIBIDA.value,
        estado_nuevo=sol.estado,
        paciente_id=sol.paciente_id,
        origen=OrigenAuditoriaEnum.WEBHOOK.value,
        descripcion=f"Solicitud {sol.solicitud_id} ({sol.tipo}) recibida desde HCE",
        detalle={"solicitud_hce_id": sol.solicitud_hce_id, "tipo": sol.tipo},
        hospital_id=sol.hospital_id,
    )
    return sol


# ─── Listar / obtener solicitudes ──────────────────────────────────────────

def get_solicitudes(
    db: Client,
    estado: str | None = None,
    tipo: str | None = None,
    hospital_id: str | None = None,
) -> list[Solicitud]:
    return solicitud_crud.get_all(db, estado, tipo, hospital_id)


def get_solicitud(db: Client, solicitud_id: str) -> Solicitud:
    return _get_solicitud_or_404(db, solicitud_id)


# ─── Resolver solicitud ────────────────────────────────────────────────────

def resolver_solicitud(
    db: Client,
    solicitud_id: str,
    data: SolicitudResolucionRequest,
    resuelto_por: int,
    actor: dict | None = None,
) -> Solicitud:
    logger.info(
        "Resolviendo solicitud id=%s accion=%s resuelto_por=%s",
        solicitud_id, data.accion, resuelto_por,
    )
    sol = _get_solicitud_or_404(db, solicitud_id)

    if sol.estado != "PENDIENTE":
        logger.warning(
            "Solicitud id=%s no resoluble — estado_actual=%s accion_intentada=%s",
            solicitud_id, sol.estado, data.accion,
        )
        raise HTTPException(
            status_code=409,
            detail={
                "codigo": "SOLICITUD_YA_RESUELTA",
                "mensaje": "La solicitud ya fue resuelta",
                "detalle": f"La solicitud {solicitud_id} fue {sol.estado}",
            },
        )

    accion = data.accion.value
    logger.info("Solicitud id=%s en estado PENDIENTE — procesando accion=%s", solicitud_id, accion)

    if accion == "RECHAZAR":
        _rechazar(db, sol, data.motivo, resuelto_por, actor)
    elif accion in ("APROBAR", "APROBAR_CON_CAMBIO"):
        cama_id = data.cama_asignada_id if accion == "APROBAR_CON_CAMBIO" else sol.cama_solicitada_id
        if cama_id is None and sol.tipo == "INTERNACION":
            raise HTTPException(
                status_code=400,
                detail={"codigo": "ERROR_VALIDACION", "mensaje": "Se requiere cama_asignada_id"},
            )
        # M1 crea el episodio_id al crear la solicitud (no en el alta) — para INTERNACION
        # es la única fuente del dato que viaja a M7 en el cierre de facturación, así que
        # se exige acá en vez de dejar que el evento salga con idEpisodioExterno: null.
        if sol.episodio_id is None and sol.tipo == "INTERNACION":
            raise HTTPException(
                status_code=400,
                detail={"codigo": "ERROR_VALIDACION", "mensaje": "La solicitud no tiene episodio_id (requerido para INTERNACION)"},
            )
        if sol.tipo == "INTERNACION":
            _aprobar_internacion(db, sol, cama_id, data.motivo, resuelto_por, accion, actor)
        else:
            _aprobar_traslado(db, sol, cama_id, data.motivo, resuelto_por, accion, actor)
    else:
        raise HTTPException(status_code=400, detail={"codigo": "ERROR_VALIDACION", "mensaje": "Acción inválida"})

    return solicitud_crud.save(db, sol)


def _rechazar(
    db: Client, sol: Solicitud, motivo: str | None, resuelto_por: int, actor: dict | None = None
) -> None:
    logger.info("Rechazando solicitud id=%s motivo=%s", sol.solicitud_id, motivo)
    sol.estado = "RECHAZADA"
    sol.accion = "RECHAZAR"
    sol.motivo = motivo
    sol.resuelto_por = resuelto_por
    sol.timestamp_resolucion = datetime.now(timezone.utc)
    hce.notify_resultado_solicitud(sol.solicitud_hce_id, "RECHAZADA", motivo)
    auditoria_crud.registrar(
        db,
        entidad=EntidadAuditoriaEnum.SOLICITUD.value,
        entidad_id=sol.solicitud_id,
        cama_id=sol.cama_solicitada_id,
        evento=TipoEventoAuditoriaEnum.SOLICITUD_RECHAZADA.value,
        estado_anterior="PENDIENTE",
        estado_nuevo=sol.estado,
        paciente_id=sol.paciente_id,
        actor=actor,
        descripcion=f"Solicitud {sol.solicitud_id} rechazada",
        detalle={"motivo": motivo},
        hospital_id=sol.hospital_id,
    )


def _aprobar_internacion(
    db: Client, sol: Solicitud, cama_id: int, motivo: str | None, resuelto_por: int,
    accion: str, actor: dict | None = None,
) -> None:
    logger.info(
        "Aprobando internación — solicitud_id=%s paciente_id=%s cama_id=%s",
        sol.solicitud_id, sol.paciente_id, cama_id,
    )
    validar_paciente_o_502(sol.paciente_id)

    cama = _get_cama_or_404(db, cama_id)
    if cama.estado != EstadoCamaEnum.DISPONIBLE.value:
        logger.warning(
            "Cama id=%s no disponible para internación — estado_actual=%s",
            cama_id, cama.estado,
        )
        raise HTTPException(
            status_code=409,
            detail={"codigo": "CAMA_NO_DISPONIBLE", "mensaje": f"La cama {cama_id} no está disponible"},
        )

    _verificar_contraindicaciones(sol.paciente_id, cama)

    cama.estado = EstadoCamaEnum.OCUPADA.value
    cama.paciente_id = sol.paciente_id
    # Datos del episodio en curso (ver app/models/cama.py) — necesarios más adelante
    # para el payload rico que pide M7 al cerrarse la internación (notify_cama_lista).
    cama.solicitud_hce_id = sol.solicitud_hce_id
    cama.fecha_ingreso = datetime.now(timezone.utc)
    # El episodio lo crea M1 al crear la solicitud (no en el alta) — se arrastra desde acá
    # hasta que la cama se libere (ver `cama_service.update_cama`).
    cama.episodio_id = sol.episodio_id
    cama.ultima_actualizacion = datetime.now(timezone.utc)
    cama_crud.save(db, cama)

    sol.estado = "APROBADA"
    sol.accion = accion
    sol.motivo = motivo
    sol.cama_asignada_id = cama_id
    sol.resuelto_por = resuelto_por
    sol.timestamp_resolucion = datetime.now(timezone.utc)

    hce.notify_movimiento(cama, sol.paciente_id, actor)
    hce.notify_resultado_solicitud(sol.solicitud_hce_id, "APROBADA")
    monitoreo.notify_alta(sol.paciente_id, cama_id)

    auditoria_crud.registrar(
        db,
        entidad=EntidadAuditoriaEnum.SOLICITUD.value,
        entidad_id=sol.solicitud_id,
        cama_id=cama_id,
        evento=TipoEventoAuditoriaEnum.SOLICITUD_APROBADA.value,
        estado_anterior="PENDIENTE",
        estado_nuevo=sol.estado,
        paciente_id=sol.paciente_id,
        actor=actor,
        descripcion=f"Solicitud {sol.solicitud_id} aprobada ({accion}) — internación",
        detalle={"accion": accion, "cama_asignada_id": cama_id},
        hospital_id=sol.hospital_id,
    )
    auditoria_crud.registrar(
        db,
        entidad=EntidadAuditoriaEnum.CAMA.value,
        entidad_id=cama_id,
        cama_id=cama_id,
        evento=TipoEventoAuditoriaEnum.CAMA_ASIGNADA.value,
        estado_anterior=EstadoCamaEnum.DISPONIBLE.value,
        estado_nuevo=cama.estado,
        paciente_id=sol.paciente_id,
        actor=actor,
        descripcion=f"Paciente {sol.paciente_id} ingresado a la cama {cama_id} (solicitud {sol.solicitud_id})",
        hospital_id=cama.hospital_id,
    )


def _aprobar_traslado(
    db: Client, sol: Solicitud, cama_destino_id: int | None, motivo: str | None, resuelto_por: int,
    accion: str, actor: dict | None = None,
) -> None:
    dest_id = cama_destino_id or sol.cama_destino_solicitada_id
    if not dest_id:
        raise HTTPException(
            status_code=400,
            detail={"codigo": "ERROR_VALIDACION", "mensaje": "Se requiere cama destino"},
        )

    validar_paciente_o_502(sol.paciente_id)

    cama_destino = _get_cama_or_404(db, dest_id)
    if cama_destino.estado != EstadoCamaEnum.DISPONIBLE.value:
        raise HTTPException(
            status_code=409,
            detail={"codigo": "CAMA_NO_DISPONIBLE", "mensaje": f"La cama destino {dest_id} no está disponible"},
        )

    _verificar_contraindicaciones(sol.paciente_id, cama_destino)

    origen_en_codigo_rojo = False
    if sol.cama_origen_id:
        cama_origen = _get_cama_or_404(db, sol.cama_origen_id)
        origen_en_codigo_rojo = cama_origen.estado == EstadoCamaEnum.CODIGO_ROJO.value
        # El episodio (fecha de ingreso, id de la internación original) es continuo a
        # través de un traslado — se hereda de la cama origen, no de esta solicitud de
        # traslado, para no perder el dato real de cuándo empezó la internación.
        cama_destino.solicitud_hce_id = cama_origen.solicitud_hce_id
        cama_destino.fecha_ingreso = cama_origen.fecha_ingreso
        # El episodio es del paciente, no de la cama: se hereda igual que solicitud_hce_id/
        # fecha_ingreso. La cama origen lo pierde recién cuando se libere de verdad (ver
        # `cama_service.update_cama` — no acá, para no dejarla sin dato mientras está
        # EN_LIMPIEZA y todavía puede haber consultas en curso sobre ese episodio).
        cama_destino.episodio_id = cama_origen.episodio_id
        cama_origen.estado = EstadoCamaEnum.EN_LIMPIEZA.value
        cama_origen.ultimo_movimiento_tipo = "TRASLADO"
        cama_origen.ultima_actualizacion = datetime.now(timezone.utc)
        cama_crud.save(db, cama_origen)
    else:
        # Traslado sin cama origen registrada (caso atípico) — se trata como un ingreso
        # nuevo a los fines del episodio.
        cama_destino.solicitud_hce_id = sol.solicitud_hce_id
        cama_destino.fecha_ingreso = datetime.now(timezone.utc)
        cama_destino.episodio_id = sol.episodio_id

    # Si la cama origen estaba en CODIGO_ROJO (emergencia activa), el destino hereda ese
    # estado — el traslado no puede "resolver" una emergencia que sigue en curso. En
    # cualquier otro caso (origen OCUPADA, lo normal), el destino pasa a OCUPADA como
    # siempre. Sin esto, `procesar_alerta_resuelta` (M9) deja de encontrar la cama por
    # paciente_id+CODIGO_ROJO tras el traslado y devuelve 404 aunque la emergencia siga.
    cama_destino.estado = (
        EstadoCamaEnum.CODIGO_ROJO.value if origen_en_codigo_rojo else EstadoCamaEnum.OCUPADA.value
    )
    cama_destino.paciente_id = sol.paciente_id
    cama_destino.ultima_actualizacion = datetime.now(timezone.utc)
    cama_crud.save(db, cama_destino)

    sol.estado = "APROBADA"
    sol.accion = accion
    sol.motivo = motivo
    sol.cama_asignada_id = dest_id
    sol.resuelto_por = resuelto_por
    sol.timestamp_resolucion = datetime.now(timezone.utc)

    hce.notify_movimiento(cama_destino, sol.paciente_id, actor)
    hce.notify_resultado_solicitud(sol.solicitud_hce_id, "APROBADA")
    monitoreo.notify_baja(sol.paciente_id, sol.cama_origen_id)
    monitoreo.notify_alta(sol.paciente_id, dest_id)

    auditoria_crud.registrar(
        db,
        entidad=EntidadAuditoriaEnum.SOLICITUD.value,
        entidad_id=sol.solicitud_id,
        cama_id=dest_id,
        evento=TipoEventoAuditoriaEnum.SOLICITUD_APROBADA.value,
        estado_anterior="PENDIENTE",
        estado_nuevo=sol.estado,
        paciente_id=sol.paciente_id,
        actor=actor,
        descripcion=f"Solicitud {sol.solicitud_id} aprobada ({accion}) — traslado",
        detalle={"accion": accion, "cama_asignada_id": dest_id, "cama_origen_id": sol.cama_origen_id},
        hospital_id=sol.hospital_id,
    )
    auditoria_crud.registrar(
        db,
        entidad=EntidadAuditoriaEnum.CAMA.value,
        entidad_id=dest_id,
        cama_id=dest_id,
        evento=TipoEventoAuditoriaEnum.CAMA_TRASLADO.value,
        estado_anterior=EstadoCamaEnum.DISPONIBLE.value,
        estado_nuevo=cama_destino.estado,
        paciente_id=sol.paciente_id,
        actor=actor,
        descripcion=f"Paciente {sol.paciente_id} trasladado a la cama {dest_id} (solicitud {sol.solicitud_id})",
        detalle={"cama_origen_id": sol.cama_origen_id},
        hospital_id=cama_destino.hospital_id,
    )


# ─── Alta médica (desde HCE M1) ────────────────────────────────────────────

def procesar_alta_medica(db: Client, data: AltaMedicaWebhook) -> Cama:
    paciente_id = data.paciente_id
    cama = cama_crud.get_by_paciente(db, paciente_id, ["OCUPADA", "CODIGO_ROJO"])
    if not cama:
        raise HTTPException(
            status_code=404,
            detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "No se encontró cama asignada al paciente"},
        )
    # Notificación asincrónica (fire-and-forget, M6_DISEÑO.md §2): M6 informa a M9 que
    # el paciente sale de monitoreo, pero que M9 esté caído no debe revertir el alta.
    # La notificación real a M7 (CAMA_LISTA) ocurre más adelante, al completar la
    # limpieza (cama_service.py), también fire-and-forget.
    monitoreo.notify_baja(paciente_id, cama.id)

    estado_previo = cama.estado
    cama.estado = EstadoCamaEnum.EN_LIMPIEZA.value
    cama.ultimo_movimiento_tipo = "ALTA"
    cama.alta_tipo = data.tipo_alta.value
    cama.alta_timestamp = data.timestamp
    # episodio_id NO se toca acá: ya viene poblado desde la internación/traslado
    # (`_aprobar_internacion`/`_aprobar_traslado`), que es donde M1 lo provee de verdad (al
    # crear la solicitud). AltaMedicaWebhook nunca lo tuvo como fuente real — pisarlo acá
    # con un dato del webhook de alta hacía que el evento a M7 saliera con
    # idEpisodioExterno: null, porque notify_cama_lista se dispara con la cama ya pisada.
    cama.ultima_actualizacion = datetime.now(timezone.utc)
    cama_crud.save(db, cama)
    # Fire-and-forget: notificación a M7 para cerrar la internación del lado de
    # facturación. Se dispara aquí (alta médica) porque el cierre de facturación
    # ocurre con el alta del paciente, no con la limpieza de la cama. cama.episodio_id ya
    # trae el valor real (poblado más arriba en la cadena) — no se pisa en este webhook.
    facturacion.notify_cama_lista(cama, db)
    auditoria_crud.registrar(
        db,
        entidad=EntidadAuditoriaEnum.CAMA.value,
        entidad_id=cama.id,
        cama_id=cama.id,
        evento=TipoEventoAuditoriaEnum.CAMA_ALTA.value,
        estado_anterior=estado_previo,
        estado_nuevo=cama.estado,
        paciente_id=paciente_id,
        origen=OrigenAuditoriaEnum.WEBHOOK.value,
        descripcion=f"Alta médica del paciente {paciente_id}; cama {cama.numero} en limpieza",
        hospital_id=cama.hospital_id,
    )
    return cama


# ─── Alertas de emergencia (desde M9) ──────────────────────────────────────

def procesar_alerta_emergencia(db: Client, paciente_id: int) -> Cama:
    cama = cama_crud.get_by_paciente(db, paciente_id, ["OCUPADA"])
    if not cama:
        raise HTTPException(
            status_code=404,
            detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "Paciente sin cama asignada"},
        )
    estado_previo = cama.estado
    cama.estado = EstadoCamaEnum.CODIGO_ROJO.value
    cama.ultima_actualizacion = datetime.now(timezone.utc)
    cama_crud.save(db, cama)
    hce.notify_evento_episodio(0, "CODIGO_ROJO", f"Alerta de emergencia detectada para paciente {paciente_id}")
    auditoria_crud.registrar(
        db,
        entidad=EntidadAuditoriaEnum.CAMA.value,
        entidad_id=cama.id,
        cama_id=cama.id,
        evento=TipoEventoAuditoriaEnum.CAMA_CODIGO_ROJO.value,
        estado_anterior=estado_previo,
        estado_nuevo=cama.estado,
        paciente_id=paciente_id,
        origen=OrigenAuditoriaEnum.WEBHOOK.value,
        descripcion=f"Alerta de emergencia: cama {cama.numero} en CODIGO_ROJO",
        hospital_id=cama.hospital_id,
    )
    return cama


def procesar_alerta_resuelta(db: Client, paciente_id: int) -> Cama:
    cama = cama_crud.get_by_paciente(db, paciente_id, ["CODIGO_ROJO"])
    if not cama:
        raise HTTPException(
            status_code=404,
            detail={"codigo": "RECURSO_NO_ENCONTRADO", "mensaje": "No se encontró cama en CODIGO_ROJO para el paciente"},
        )
    estado_previo = cama.estado
    cama.estado = EstadoCamaEnum.OCUPADA.value
    cama.ultima_actualizacion = datetime.now(timezone.utc)
    cama = cama_crud.save(db, cama)
    auditoria_crud.registrar(
        db,
        entidad=EntidadAuditoriaEnum.CAMA.value,
        entidad_id=cama.id,
        cama_id=cama.id,
        evento=TipoEventoAuditoriaEnum.CAMA_ALERTA_RESUELTA.value,
        estado_anterior=estado_previo,
        estado_nuevo=cama.estado,
        paciente_id=paciente_id,
        origen=OrigenAuditoriaEnum.WEBHOOK.value,
        descripcion=f"Alerta resuelta: cama {cama.numero} vuelve a OCUPADA",
        hospital_id=cama.hospital_id,
    )
    return cama


# ─── Cancelar reserva por turno (desde M2) ─────────────────────────────────

def cancelar_reserva_por_turno(db: Client, turno_id: int, motivo: str) -> ReservaQuirofano:
    reserva = reserva_crud.get_by_turno(db, turno_id)
    if not reserva:
        raise HTTPException(
            status_code=404,
            detail={
                "codigo": "RESERVA_NO_ENCONTRADA",
                "mensaje": f"No existe reserva activa para el turno {turno_id}",
            },
        )
    if reserva.estado == EstadoReservaEnum.CANCELADA.value:
        return reserva
    if reserva.estado in (EstadoReservaEnum.EN_CURSO.value, EstadoReservaEnum.COMPLETADA.value):
        raise HTTPException(
            status_code=409,
            detail={
                "codigo": "RESERVA_NO_CANCELABLE",
                "mensaje": "La reserva no puede cancelarse en su estado actual",
                "detalle": f"Estado: {reserva.estado}",
            },
        )
    estado_previo = reserva.estado
    reserva.estado = EstadoReservaEnum.CANCELADA.value
    reserva = reserva_crud.save(db, reserva)
    auditoria_crud.registrar(
        db,
        entidad=EntidadAuditoriaEnum.RESERVA_QUIROFANO.value,
        entidad_id=reserva.id,
        cama_id=reserva.cama_id,
        evento=TipoEventoAuditoriaEnum.RESERVA_CANCELADA.value,
        estado_anterior=estado_previo,
        estado_nuevo=reserva.estado,
        paciente_id=reserva.paciente_id,
        origen=OrigenAuditoriaEnum.WEBHOOK.value,
        descripcion=f"Reserva {reserva.id} cancelada por turno {turno_id}",
        detalle={"turno_id": turno_id, "motivo": motivo},
    )
    return reserva