<?php
if (strlen(session_id()) < 1) {
    session_start();
}
// ============================================================
// CONTROLADOR AJAX: atencion_formatos
// Descripción: Maneja operaciones CRUD de formatos múltiples
// Fecha: 2026-01-13
// ============================================================

require_once __DIR__ . "/../modelos/AtencionFormato.php";
require_once __DIR__ . "/../modelos/Resultado.php"; // Modelo para guardar datos reales en BD
require_once __DIR__ . "/../modelos/Resultado.php"; // Para métodos legacy (insertar_msp_XXX)

$atencionFormato = new AtencionFormato();
$resultadoModel = new Resultado();

// Recibir parámetros
$id_atencion_formato = isset($_POST["id_atencion_formato"]) ? limpiarCadena($_POST["id_atencion_formato"]) : "";
$idatencion = isset($_POST["idatencion"]) ? limpiarCadena($_POST["idatencion"]) : "";
$tipo_formato = isset($_POST["tipo_formato"]) ? limpiarCadena($_POST["tipo_formato"]) : "";
$datos_json = isset($_POST["datos_json"]) ? $_POST["datos_json"] : "{}";
$usuario_creacion = isset($_SESSION["idusuario"]) ? $_SESSION["idusuario"] : null;
$orden = isset($_POST["orden"]) ? limpiarCadena($_POST["orden"]) : 0;

// Asegurar que datos_json sea string
if (is_array($datos_json)) {
    $datos_json = json_encode($datos_json);
}

switch ($_GET["op"]) {
    case 'guardar':
        // Verificar si ya existe este tipo de formato para esta atención
        $existe = $atencionFormato->existeFormato($idatencion, $tipo_formato);

        if ($existe && empty($id_atencion_formato)) {
            // Si existe y no se especificó ID, actualizar el existente
            $rspta = $atencionFormato->editar($existe, $datos_json);
            echo $rspta ? "Formato actualizado correctamente" : "No se pudo actualizar el formato";
        } elseif (!empty($id_atencion_formato)) {
            // Editar formato existente
            $rspta = $atencionFormato->editar($id_atencion_formato, $datos_json);
            echo $rspta ? "Formato actualizado correctamente" : "No se pudo actualizar el formato";
        } else {
            // Insertar nuevo formato
            $id_nuevo = $atencionFormato->insertar($idatencion, $tipo_formato, $datos_json, $usuario_creacion, $orden);
            echo $id_nuevo > 0 ? "Formato guardado correctamente" : "No se pudo guardar el formato";
        }
        break;

    case 'guardar_lote':
        // Habilitar reporte de errores temporalmente para debugging
        // ini_set('display_errors', 1);
        // ini_set('display_startup_errors', 1);
        // error_reporting(E_ALL);

        $idatencion = isset($_POST["idatencion"]) ? limpiarCadena($_POST["idatencion"]) : "";
        $formatos_json = isset($_POST["formatos"]) ? $_POST["formatos"] : "[]";

        $formatos = json_decode($formatos_json, true);

        if (empty($idatencion) || empty($formatos)) {
            echo json_encode(array("success" => false, "message" => "Datos incompletos o vacíos."));
            exit;
        }

        // --- HANDLER DE ERRORES FATALES GLOBAL (DEBUGGING EXTREMO) ---
        register_shutdown_function(function () {
            $error = error_get_last();
            if ($error !== NULL && in_array($error['type'], [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR])) {
                // Limpiar cualquier salida previa corrupta
                if (ob_get_length())
                    ob_clean();

                $msg = "ERROR FATAL DEL SERVIDOR: " . $error['message'] . " en archivo " . $error['file'] . " línea " . $error['line'];
                // Intentar responder con JSON válido
                header('Content-Type: application/json');
                echo json_encode(array(
                    "success" => false,
                    "message" => $msg
                ));
            }
        });
        // -------------------------------------------------------------

        $usuario_creacion = isset($_SESSION["idusuario"]) ? $_SESSION["idusuario"] : null;
        $rutas_generadas = array();
        $errores = array();

        require_once __DIR__ . "/../reportes/generar_pdf_msp.php"; // Wrapper de PDFs

        try {
            foreach ($formatos as $f) {
                $tipo = $f['tipo_formato'];
                $id_formato = isset($f['id_atencion_formato']) ? $f['id_atencion_formato'] : "";
                $datos_raw = $f['datos_json'];
                $datos_array = json_decode($datos_raw, true); // Array para uso interno PHP

                // 1. GUARDAR EN TABLA atencion_formatos (Backup/Estandarización)
                $id_formato_guardado = 0;

                $existe = $atencionFormato->existeFormato($idatencion, $tipo);
                if ($existe) {
                    $atencionFormato->editar($existe, $datos_raw); // Actualizamos JSON
                    $id_formato_guardado = $existe;
                } else {
                    $id_formato_guardado = $atencionFormato->insertar($idatencion, $tipo, $datos_raw, $usuario_creacion);
                }

                // 2. GUARDAR DATOS ESPECÍFICOS EN TABLAS REALES (Integridad Médica)


                // MAPEAR DATOS: El JS envía {medicamento: [], cantidad: []} directamente
                $datos_mapeados = [];
                if (is_array($datos_array)) {
                    // Si es un objeto asociativo (nuevo formato de pestañas), lo tomamos directamente
                    if (!isset($datos_array[0]['name'])) {
                        $datos_mapeados = $datos_array;
                    }
                    // Si es el formato viejo (array de objetos {name, value}), lo mapeamos
                    else {
                        foreach ($datos_array as $item) {
                            if (isset($item['name'])) {
                                $k = $item['name'];
                                $v = $item['value'];
                                if (substr($k, -2) === '[]') {
                                    $keyClean = substr($k, 0, -2);
                                    $datos_mapeados[$keyClean][] = $v;
                                } else {
                                    $datos_mapeados[$k] = $v;
                                }
                            }
                        }
                    }
                }

                // --- PASO CRÍTICO: Asegurar existencia de registro en 'resultado' ---
                // Necesario para vincular diagnósticos, recetas e historial.
                $sqlCheckResGlobal = "SELECT idresultado FROM resultado WHERE idatencion = '$idatencion' ORDER BY idresultado DESC LIMIT 1";
                $resResGlobal = ejecutarConsultaSimpleFila($sqlCheckResGlobal);
                $idresultado_master = 0;

                if (!$resResGlobal) {
                    $sqlCreateResGlobal = "INSERT INTO resultado (idatencion, estado, fecha, hora, tipo_formato) 
                                         VALUES ('$idatencion', 'Atendido', CURDATE(), CURTIME(), '$tipo')";
                    $idresultado_master = ejecutarConsulta_retornarID($sqlCreateResGlobal);
                } else {
                    $idresultado_master = $resResGlobal['idresultado'];
                }

                // --- GUARDADO ESPECÍFICO SEGÚN TIPO ---
                if ($tipo == 'MSP_002') {
                    $resultadoModel->insertar_msp_002($idatencion, $datos_mapeados);
                }

                // --- LÓGICA GLOBAL DE DIAGNÓSTICOS CIE-10 ---
                // Si vienen diagnósticos en el JSON, sincronizarlos con la tabla detalle_diagnostico
                if (isset($datos_mapeados['codigos_cie10']) && is_array($datos_mapeados['codigos_cie10']) && count($datos_mapeados['codigos_cie10']) > 0) {
                    
                    $idresultado = $idresultado_master;

                    if ($idresultado > 0) {
                        // PASO 2: Limpiar y Guardar Diagnósticos
                        $sqlDeleteDiag = "DELETE FROM detalle_diagnostico WHERE idresultado = '$idresultado'";
                        ejecutarConsulta($sqlDeleteDiag);

                        $codigos = $datos_mapeados['codigos_cie10'];
                        $tipos = isset($datos_mapeados['tipos_cie10']) ? $datos_mapeados['tipos_cie10'] : [];
                        $enfermedades = isset($datos_mapeados['enfermedades_cie10']) ? $datos_mapeados['enfermedades_cie10'] : [];

                        for ($i = 0; $i < count($codigos); $i++) {
                            $codigo = limpiarCadena($codigos[$i]);
                            $tipo_diag = isset($tipos[$i]) ? limpiarCadena($tipos[$i]) : 'PRESUNTIVO';

                            // Buscar iddiagnostico por código
                            $sqlGetDiag = "SELECT iddiagnostico FROM diagnostico WHERE codigo = '$codigo' LIMIT 1";
                            $resDiagId = ejecutarConsultaSimpleFila($sqlGetDiag);

                            if ($resDiagId && isset($resDiagId['iddiagnostico'])) {
                                $iddiagnostico = $resDiagId['iddiagnostico'];
                                $sqlInsertDiag = "INSERT INTO detalle_diagnostico (idresultado, iddiagnostico, tipo) 
                                                 VALUES ('$idresultado', '$iddiagnostico', '$tipo_diag')";
                                ejecutarConsulta($sqlInsertDiag);
                            }
                        }
                    }
                }


                if ($tipo == 'RECETA') {
                    // VALIDACIÓN CRÍTICA: Verificar que existan diagnósticos CIE-10
                    // PASO 1: Verificar si existe resultado para esta atención
                    $sqlCheckResultado = "SELECT idresultado FROM resultado WHERE idatencion = '$idatencion' ORDER BY idresultado DESC LIMIT 1";
                    $resResultado = ejecutarConsultaSimpleFila($sqlCheckResultado);

                    if (!$resResultado) {
                        error_log("ADVERTENCIA: No existe resultado para atención #$idatencion, creando registro básico");

                        $sqlCreateResultado = "INSERT INTO resultado (
                            idatencion, motivo_consulta, tiempo_enfermedad, antecedentes,
                            examen_fisico, tratamiento, signnose_de_alarma, Indicaciones_no_farmacologicas,
                            proxima_cita, estado, plan, fecha, hora, vigencia, tipo_formato
                        ) VALUES (
                            '$idatencion', '', '', '', '', '', '', '', '', 'Atendido', '', CURDATE(), CURTIME(), '', 'RECETA'
                        )";

                        $idresultadonew = ejecutarConsulta_retornarID($sqlCreateResultado);

                        if (!$idresultadonew) {
                            throw new Exception("ERROR: No se pudo crear el registro de resultado para la atención. Verifique la base de datos.");
                        }

                        error_log("Resultado creado con ID: $idresultadonew para atención #$idatencion");
                    }

                    // PASO 2: Ahora sí verificar que existan diagnósticos
                    $sqlCheckDiag = "SELECT COUNT(*) as total FROM detalle_diagnostico dd 
                                     INNER JOIN resultado r ON dd.idresultado = r.idresultado 
                                     WHERE r.idatencion = '$idatencion'";
                    $resDiag = ejecutarConsultaSimpleFila($sqlCheckDiag);

                    // PASO 3: Validación final (Verificar si existen diagnósticos tras el guardado global)
                    if (!$resDiag || $resDiag['total'] == 0) {
                        throw new Exception("ERROR: No se puede generar receta sin diagnósticos CIE-10. Por favor agregue al menos un diagnóstico en el Plan de Atención antes de generar la receta.");
                    }

                    // Guardar en tabla receta usando el modelo
                    // Guardar en tabla receta usando el modelo (DESACTIVADO POR MIGRACIÓN A JSON - 2026-01-19)
                    // Se desactiva para evitar duplicidad y desincronización. La fuente única es atencion_formatos.
                    /*
                    $resultadoModel->guardarSoloRecetas2(
                        $idatencion,
                        $datos_mapeados['medicamento'] ?? [],
                        $datos_mapeados['concentracion'] ?? [],
                        $datos_mapeados['presentacion'] ?? [],
                        $datos_mapeados['dosis'] ?? [],
                        $datos_mapeados['duracion'] ?? [],
                        $datos_mapeados['cantidad'] ?? [],
                        $datos_mapeados['via_administracion'] ?? [],
                        $datos_mapeados['posologia'] ?? []
                    );
                    */

                    // Guardar también campos de texto en resultado si existen
                    if (isset($datos_mapeados['tratamiento']) || isset($datos_mapeados['signnose_de_alarma']) || isset($datos_mapeados['Indicaciones_no_farmacologicas'])) {
                        $sqlUpdateResultado = "UPDATE resultado SET ";
                        $updates = [];
                        if (isset($datos_mapeados['tratamiento'])) {
                            $tratamiento = limpiarCadena($datos_mapeados['tratamiento']);
                            $updates[] = "tratamiento = '$tratamiento'";
                        }
                        if (isset($datos_mapeados['signnose_de_alarma'])) {
                            $signos = limpiarCadena($datos_mapeados['signnose_de_alarma']);
                            $updates[] = "signnose_de_alarma = '$signos'";
                        }
                        if (isset($datos_mapeados['Indicaciones_no_farmacologicas'])) {
                            $indicaciones = limpiarCadena($datos_mapeados['Indicaciones_no_farmacologicas']);
                            $updates[] = "Indicaciones_no_farmacologicas = '$indicaciones'";
                        }
                        if (isset($datos_mapeados['vigencia'])) {
                            $vigencia = limpiarCadena($datos_mapeados['vigencia']);
                            $updates[] = "vigencia = '$vigencia'";
                        }

                        if (!empty($updates)) {
                            $sqlUpdateResultado .= implode(', ', $updates) . " WHERE idatencion = '$idatencion'";
                            ejecutarConsulta($sqlUpdateResultado);
                        }
                    }
                }
                // FORMATOS MSP
                elseif ($tipo == 'MSP_006' && method_exists($resultadoModel, 'insertar_msp_006')) {
                    $resultadoModel->insertar_msp_006($idatencion, $datos_mapeados);
                } elseif ($tipo == 'MSP_008' && method_exists($resultadoModel, 'insertar_msp_008')) {
                    $resultadoModel->insertar_msp_008($idatencion, $datos_mapeados);
                } elseif ($tipo == 'MSP_003' && method_exists($resultadoModel, 'insertar_msp_003')) {
                    $resultadoModel->insertar_msp_003($idatencion, $datos_mapeados);
                } elseif ($tipo == 'MSP_012' && method_exists($resultadoModel, 'insertar_msp_012')) {
                    $resultadoModel->insertar_msp_012($idatencion, $datos_mapeados);
                } elseif ($tipo == 'MSP_002' && method_exists($resultadoModel, 'insertar_msp_002')) {
                    $resultadoModel->insertar_msp_002($idatencion, $datos_mapeados);
                } elseif ($tipo == 'DERIVACION_INTERNA') {
                    $medicos = $datos_mapeados['medicos_destino'] ?? [];
                    $motivo = limpiarCadena($datos_mapeados['motivo_derivacion'] ?? '');
                    $prioridad = limpiarCadena($datos_mapeados['prioridad'] ?? 'media');

                    // Asegurar que el idmedico_origen no sea nulo (usar sesión o fallback)
                    $idmedico_remitente = (isset($_SESSION["idusuario"])) ? $_SESSION["idusuario"] : $usuario_creacion;

                    // Obtener idpaciente
                    $idpaciente = 0;
                    $atRow = ejecutarConsultaSimpleFila("SELECT idpersona FROM atencion WHERE idatencion='$idatencion'");
                    if ($atRow) $idpaciente = $atRow['idpersona'];

                    if (is_array($medicos) && $idmedico_remitente > 0) {
                        foreach ($medicos as $idm) {
                            $idm_clean = limpiarCadena($idm);
                            if ($idm_clean == $idmedico_remitente) continue; // No auto-derivarse

                            $sqlDer = "INSERT INTO derivacion_interna (idatencion_origen, idpaciente, idmedico_origen, idmedico_destino, motivo, prioridad, estado)
                                       VALUES ('$idatencion', '$idpaciente', '$idmedico_remitente', '$idm_clean', '$motivo', '$prioridad', 'pendiente')";
                            ejecutarConsulta($sqlDer);
                        }
                    }
                }

                // 3. GENERAR PDF Y ACTUALIZAR RUTA
                try {
                    $ruta_pdf = generarPDFMspWrapper($idatencion, $tipo, $id_formato_guardado, $datos_raw);

                    if ($ruta_pdf) {
                        $atencionFormato->actualizarRutaPDF($id_formato_guardado, $ruta_pdf);
                        $rutas_generadas[] = $ruta_pdf;
                        error_log("PDF generado exitosamente para formato $tipo: $ruta_pdf");
                        
                        // 3.1. REGISTRAR EN DOCUMENTO_MEDICO PARA PERSISTENCIA (FIX PÉRDIDA DE DOCUMENTOS)
                        // CRÍTICO: Crear respaldo en tabla centralizada (excepto RECETA que se registra al firmar)
                        if ($tipo != 'RECETA') {
                            $atencionRow = ejecutarConsultaSimpleFila("SELECT idpersona FROM atencion WHERE idatencion='$idatencion'");
                            if ($atencionRow) {
                                $idpersona = $atencionRow['idpersona'];
                                $tipoDoc = strtolower($tipo);
                                
                                // FIX: Obtener idempleado de sesión si $usuario_creacion es NULL
                                $idempleado_final = $usuario_creacion;
                                if (!$idempleado_final && isset($_SESSION['idusuario'])) {
                                    $idempleado_final = $_SESSION['idusuario'];
                                }
                                if (!$idempleado_final && isset($_SESSION['idempleado'])) {
                                    $idempleado_final = $_SESSION['idempleado'];
                                }
                                // Si aún es NULL, usar 0 como fallback
                                if (!$idempleado_final) {
                                    $idempleado_final = 0;
                                    error_log("⚠️ ADVERTENCIA: idempleado es NULL para atención #$idatencion, usando 0 como fallback");
                                }
                                
                                // Verificar si ya existe documento de este tipo para esta atención
                                $docCheck = ejecutarConsultaSimpleFila("SELECT iddocumento FROM documento_medico WHERE idatencion='$idatencion' AND tipo='$tipoDoc'");
                                
                                if ($docCheck) {
                                    // Actualizar existente
                                    $iddoc = $docCheck['iddocumento'];
                                    $sqlUpdateDoc = "UPDATE documento_medico SET ruta_pdf='$ruta_pdf', fecha_emision=NOW() WHERE iddocumento='$iddoc'";
                                    if (ejecutarConsulta($sqlUpdateDoc)) {
                                        error_log("✅ Formato $tipo actualizado en documento_medico (respaldo) - Atención #$idatencion");
                                    }
                                } else {
                                    // Insertar nuevo
                                    $sqlInsertDoc = "INSERT INTO documento_medico (idatencion, idpersona, tipo, contenido, ruta_pdf, fecha_emision, idempleado, estado) 
                                                    VALUES ('$idatencion', '$idpersona', '$tipoDoc', 'Formato MSP', '$ruta_pdf', NOW(), '$idempleado_final', 'emitido')";
                                    if (ejecutarConsulta($sqlInsertDoc)) {
                                        error_log("✅ Formato $tipo registrado en documento_medico (respaldo) - Atención #$idatencion");
                                    } else {
                                        error_log("❌ ERROR al registrar formato $tipo en documento_medico - Atención #$idatencion");
                                    }
                                }
                            }
                        }
                    } // Cierre de if ($ruta_pdf)
                } catch (Exception $ePdf) {
                    $errores[] = $ePdf->getMessage(); 
                    error_log("❌ EXCEPCIÓN en generación de PDF ($tipo): " . $ePdf->getMessage());
                }
            } // Cierre de foreach ($formatos as $f)

            // PASO FINAL: ACTUALIZAR ESTADO DE LA ATENCIÓN A 'Atendido'
            // Esto asegura que desaparezca de la lista de pendientes una vez guardado y finalizado (botón Finalizar y Firmar)
            $sqlUpdateEstado = "UPDATE atencion SET estado='Atendido' WHERE idatencion='$idatencion'";
            ejecutarConsulta($sqlUpdateEstado);

            if (count($rutas_generadas) > 0 || count($errores) === 0) {
                // BLINDAJE: Transformar rutas absolutas/relativas a proxy seguro
                $rutas_proxy = array_map(function ($r) {
                    return $r ? "../reportes/ver_documento.php?f=" . basename($r) : null;
                }, array_filter($rutas_generadas));

                $mensaje = "Operación completada.";
                if (count($errores) > 0) {
                    $mensaje .= " Advertencias: " . implode("; ", $errores);
                    echo json_encode(array("success" => true, "message" => $mensaje, "archivos" => $rutas_proxy, "errores" => $errores));
                } else {
                    echo json_encode(array("success" => true, "message" => "Formatos guardados y Atención Finalizada.", "archivos" => $rutas_proxy));
                }
            } else {
                echo json_encode(array("success" => false, "message" => "Error al generar PDFs: " . implode("; ", $errores), "archivos" => [], "errores" => $errores));
            }
        } catch (Exception $e) {
            if (ob_get_length()) ob_clean();
            echo json_encode(array("success" => false, "message" => "Excepción del servidor: " . $e->getMessage()));
        }
        break;

    case 'listar':
        $rspta = $atencionFormato->listar($idatencion);
        $data = array();

        while ($reg = $rspta->fetch_object()) {
            $data[] = array(
                "id_atencion_formato" => $reg->id_atencion_formato,
                "idatencion" => $reg->idatencion,
                "tipo_formato" => $reg->tipo_formato,
                "datos_json" => $reg->datos_json,
                "fecha_creacion" => $reg->fecha_creacion,
                "fecha_modificacion" => $reg->fecha_modificacion,
                "orden" => $reg->orden,
                "estado" => $reg->estado,
                // CAMBIO: Usar proxy universal para garantizar visualizacion
                "ruta_pdf" => "../reportes/ver_documento.php?f=" . basename($reg->ruta_pdf)
            );
        }

        echo json_encode($data);
        break;

    case 'obtener':
        $rspta = $atencionFormato->obtener($id_atencion_formato);
        echo json_encode($rspta);
        break;

    case 'eliminar':
        $rspta = $atencionFormato->eliminar($id_atencion_formato);
        echo $rspta ? "Formato eliminado correctamente" : "No se pudo eliminar el formato";
        break;

    case 'contar':
        $total = $atencionFormato->contar($idatencion);
        echo json_encode(array("total" => $total));
        break;

    case 'actualizar_orden':
        $nuevo_orden = isset($_POST["nuevo_orden"]) ? limpiarCadena($_POST["nuevo_orden"]) : 0;
        $rspta = $atencionFormato->actualizarOrden($id_atencion_formato, $nuevo_orden);
        echo $rspta ? "Orden actualizado" : "No se pudo actualizar el orden";
        break;

    case 'subir_firma_paciente':
        if (!file_exists('../files/firmas_pacientes/')) {
            mkdir('../files/firmas_pacientes/', 0777, true);
        }

        if (isset($_FILES['foto_firma_paciente']) && $_FILES['foto_firma_paciente']['error'] == 0) {
            $ext = explode(".", $_FILES["foto_firma_paciente"]["name"]);
            $nombre_archivo = "firma_pac_" . $_POST['idatencion'] . "_" . time() . "." . end($ext);
            $ruta_destino = "../files/firmas_pacientes/" . $nombre_archivo;

            if (move_uploaded_file($_FILES["foto_firma_paciente"]["tmp_name"], $ruta_destino)) {
                echo json_encode(["success" => true, "ruta" => "files/firmas_pacientes/" . $nombre_archivo]);
            } else {
                echo json_encode(["success" => false, "message" => "Error al mover el archivo"]);
            }
        } else {
            echo json_encode(["success" => false, "message" => "No se subió ningún archivo o hubo un error"]);
        }
        break;

    default:
        echo json_encode(array("error" => "Operación no válida"));
        break;
}
