<?php
session_start();
error_reporting(E_ALL); // Temporalmente activamos todos los errores para depuración
ini_set('display_errors', 0); // Evitamos mostrar errores en la respuesta JSON

// Asegurarnos que no haya salida antes del JSON
ob_start();

header('Content-Type: application/json');

require_once '../includes/config.php';
require_once '../includes/db.php';
require_once '../WhatsApp/index.php'; // Script centralizado de WhatsApp

// Definir constantes en el nivel superior
define('ESTADO_PENDIENTE', 'PENDIENTE');
define('ESTADO_PAGADO', 'PAGADO');

// Función para enviar respuesta JSON y terminar
function enviarRespuesta($success, $message) {
    ob_clean(); // Limpiar cualquier salida anterior
    echo json_encode([
        'success' => $success,
        'message' => $message
    ]);
    exit;
}

if (!isset($_SESSION['usuario_id'])) {
    enviarRespuesta(false, 'No autorizado');
}

try {
    // Crear conexión PDO con manejo de errores
    try {
        $pdo = new PDO(
            "mysql:host=" . DB_HOST . ";dbname=" . DB_NAME . ";charset=utf8",
            DB_USER,
            DB_PASS,
            [
                PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC
            ]
        );
    } catch (PDOException $e) {
        throw new Exception('Error de conexión a la base de datos: ' . $e->getMessage());
    }
    
    // Obtener configuración
    $stmt = $pdo->query("SELECT moneda, con_decimales, whatsapp, instance_id, api_token, nombre_comercio FROM configuracion LIMIT 1");
    $config = $stmt->fetch(PDO::FETCH_ASSOC);
    $moneda = $config['moneda'] ?? 'USD.00'; // Valor por defecto
    $decimales = (int)($config['con_decimales'] ?? 0);
    
    // Función helper para formatear montos según configuración
    function formatearMonto($monto, $decimales) {
        return number_format(
            $decimales ? $monto : round($monto),
            $decimales ? 2 : 0,
            '.',
            ','
        );
    }

    // Iniciar transacción
    try {
        $pdo->beginTransaction();
    } catch (PDOException $e) {
        throw new Exception('Error al iniciar transacción: ' . $e->getMessage());
    }

    // Validar datos del formulario
    $cliente_id = filter_input(INPUT_POST, 'cliente_id', FILTER_VALIDATE_INT) ?: 0;
    $monto_recibido = filter_input(INPUT_POST, 'monto_recibido', FILTER_VALIDATE_FLOAT) ?: 0;
    $metodo_pago = trim(htmlspecialchars($_POST['metodo_pago'] ?? ''));
    $fecha_pago = trim(htmlspecialchars($_POST['fecha_pago'] ?? date('Y-m-d H:i:s')));
    $observaciones = trim(htmlspecialchars($_POST['observaciones'] ?? ''));
    $cuotas = isset($_POST['cuotas']) ? json_decode($_POST['cuotas'], true) : [];

    // Validaciones básicas
    if ($cliente_id <= 0) {
        throw new Exception('Cliente no válido');
    }
    if ($monto_recibido <= 0) {
        throw new Exception('Monto recibido debe ser mayor a 0');
    }
    if (empty($cuotas)) {
        throw new Exception('No se seleccionaron cuotas para cobrar');
    }

    $monto_restante = $monto_recibido;

    // Obtener y ordenar las cuotas por fecha de vencimiento
    $cuotas_ordenadas = [];
    foreach ($cuotas as $cuota) {
        $stmt = $pdo->prepare("
            SELECT id, monto, numero_cuota, venta_id, fecha_vencimiento 
            FROM cuotas 
            WHERE id = ?
        ");
        $stmt->execute([$cuota['id']]);
        $detalle = $stmt->fetch(PDO::FETCH_ASSOC);
        $cuotas_ordenadas[] = $detalle;
    }

    // Ordenar cuotas por fecha de vencimiento
    usort($cuotas_ordenadas, function($a, $b) {
        return strtotime($a['fecha_vencimiento']) - strtotime($b['fecha_vencimiento']);
    });

    // Procesar cada cuota
    foreach ($cuotas_ordenadas as $cuota) {
        $monto_cuota = $cuota['monto'];
        
        if ($monto_restante <= 0) {
            break; // No hay más dinero para procesar
        }
        
        if ($monto_restante >= $monto_cuota) {
            // Pago total de la cuota
            $stmt = $pdo->prepare("
                UPDATE cuotas 
                SET estado = 'PAGADO',
                    fecha_pago = ?,
                    metodo_pago = ?
                WHERE id = ?
            ");
            
            $stmt->execute([
                $fecha_pago,
                $metodo_pago,
                $cuota['id']
            ]);
            
            $monto_restante -= $monto_cuota;
        } else {
            // Pago parcial
            // 1. Marcar la cuota original como pagada
            $stmt = $pdo->prepare("
                UPDATE cuotas 
                SET estado = 'PAGADO',
                    fecha_pago = ?,
                    metodo_pago = ?,
                    monto = ?
                WHERE id = ?
            ");
            
            $stmt->execute([
                $fecha_pago,
                $metodo_pago,
                $monto_restante,
                $cuota['id']
            ]);
            
            // 2. Crear nueva cuota con el saldo pendiente
            $stmt = $pdo->prepare("
                INSERT INTO cuotas (
                    venta_id, 
                    producto_id, 
                    numero_cuota, 
                    monto, 
                    fecha_vencimiento,
                    estado,
                    observaciones,
                    usuario_id,
                    cliente_id
                ) SELECT 
                    venta_id,
                    producto_id,
                    numero_cuota,
                    ?,              -- monto_pendiente
                    fecha_vencimiento,
                    'PENDIENTE',
                    observaciones,  -- Mantener la observación original
                    ?,              -- usuario_id
                    cliente_id      -- Seleccionar cliente_id de la cuota original
                FROM cuotas 
                WHERE id = ?
            ");

            $monto_pendiente = $monto_cuota - $monto_restante;
            $stmt->execute([
                $monto_pendiente,
                $_SESSION['usuario_id'],
                $cuota['id']
            ]);
            
            $monto_restante = 0; // Ya se usó todo el dinero disponible
            break;
        }

        // Agregar en procesar-cobro-multiple.php después de actualizar cuota
        $stmtInsertPago = $pdo->prepare("
            INSERT INTO pagos (
                venta_id,
                monto,
                tipo,
                numero_cuota, 
                fecha_pago,
                fecha_vencimiento,
                estado,
                usuario_id,
                producto_id        /* Agregamos producto_id nuevamente */
            ) VALUES (
                :venta_id,
                :monto,
                'CUOTA',
                :numero_cuota,
                :fecha_pago,
                :fecha_vencimiento, 
                'PENDIENTE',
                :usuario_id,
                :producto_id      /* Agregamos el placeholder */
            )
        ");

        $stmtInsertPago->execute([
            ':venta_id' => $cuota['venta_id'],
            ':monto' => $monto_cuota,
            ':numero_cuota' => $cuota['numero_cuota'],
            ':fecha_pago' => $fecha_pago,
            ':fecha_vencimiento' => $cuota['fecha_vencimiento'],
            ':usuario_id' => $_SESSION['usuario_id'],
            ':producto_id' => 0  /* Asignamos 0 como valor por defecto */
        ]);
    }

    // Modificar la consulta para obtener los datos del cliente
    $stmtCliente = $pdo->prepare("
        SELECT nombre, apellidos, tipo_documento, numero_documento
        FROM clientes 
        WHERE id_cliente = ?
    ");
    $stmtCliente->execute([$cliente_id]);
    $datosCliente = $stmtCliente->fetch(PDO::FETCH_ASSOC);

    // Obtener detalles de las cuotas pagadas
    $detallesCuotas = [];
    foreach ($cuotas_ordenadas as $cuota) {
        $detallesCuotas[] = "Cuota #{$cuota['numero_cuota']} - Venta #{$cuota['venta_id']}";
    }

    // Modificar el formato del mensaje
    $detalles_cobro = sprintf(
        'Cobro de cuota [%s] | Cliente: %s %s - %s %s | EFECTIVO RECIBIDO: %s %s | MÉTODO: %s',
        implode(', ', $detallesCuotas),
        $datosCliente['nombre'],
        $datosCliente['apellidos'],
        $datosCliente['tipo_documento'],
        $datosCliente['numero_documento'],
        $moneda,
        formatearMonto($monto_recibido, $decimales),
        $metodo_pago
    );

    $stmt = $pdo->prepare("
        INSERT INTO registro_actividad_usuario (
            id_usuario,
            tipo_accion,
            detalles_accion,
            direccion_ip,
            agente_usuario
        ) VALUES (?, ?, ?, ?, ?)
    ");

    $stmt->execute([
        $_SESSION['usuario_id'],
        'cobro_cuota',
        $detalles_cobro,
        $_SERVER['REMOTE_ADDR'] ?? '::1',
        $_SERVER['HTTP_USER_AGENT'] ?? 'Unknown'
    ]);

    $pdo->commit();

    // Después de esta línea: $pdo->commit();
    // Y antes de: enviarRespuesta(true, 'Cobro registrado exitosamente');

    try {
        // Solo intentar enviar WhatsApp si están configurados los datos necesarios
        if (!empty($config['instance_id']) && !empty($config['api_token'])) {
            // Obtener datos del cliente
            $stmtCliente = $pdo->prepare("SELECT nombre, apellidos, telefono_principal, telefono_secundario 
                                         FROM clientes WHERE id_cliente = ?");
            $stmtCliente->execute([$cliente_id]);
            $datosCliente = $stmtCliente->fetch();

            if ($datosCliente) {
                // Obtener detalles de las cuotas pagadas
                $detallesCuotas = "";
                foreach ($cuotas as $cuota) {
                    $stmt = $pdo->prepare("
                        SELECT c.numero_cuota, c.monto, c.venta_id, c.estado,
                               CASE 
                                   WHEN c.producto_id = 0 THEN 'Cuota Unificada'
                                   ELSE p.titulo 
                               END as producto,
                               (
                                   SELECT monto 
                                   FROM cuotas 
                                   WHERE venta_id = c.venta_id 
                                   AND numero_cuota = c.numero_cuota 
                                   AND estado = 'PENDIENTE'
                                   LIMIT 1
                               ) as saldo_pendiente
                        FROM cuotas c
                        LEFT JOIN productos p ON c.producto_id = p.id
                        WHERE c.id = ?
                    ");
                    $stmt->execute([$cuota['id']]);
                    $detalle = $stmt->fetch();
                    
                    $detallesCuotas .= "➤ Venta #{$detalle['venta_id']} - Cuota {$detalle['numero_cuota']}\n";
                    $detallesCuotas .= "   {$detalle['producto']}\n";
                    
                    // Agregar información sobre el tipo de pago y saldo
                    if ($detalle['saldo_pendiente'] > 0) {
                        $detallesCuotas .= "   💳 Pago Parcial\n";
                        $detallesCuotas .= "   💰 Saldo pendiente: {$moneda} " . formatearMonto($detalle['saldo_pendiente'], $decimales) . "\n";
                    } else {
                        $detallesCuotas .= "   ✅ Pago Total\n";
                    }
                    $detallesCuotas .= "\n";
                }

                $mensaje = "💰 *RECIBO DE PAGO*\n\n";
                $mensaje .= "*Cliente:* {$datosCliente['nombre']} {$datosCliente['apellidos']}\n\n";
                $mensaje .= "*DETALLE:*\n";
                $mensaje .= $detallesCuotas . "\n";

                // Calcular el monto total cobrado (restando el vuelto del monto recibido)
                $monto_total_cobrado = $monto_recibido - $monto_restante;
                $mensaje .= "*TOTAL COBRADO:* {$moneda} " . formatearMonto($monto_total_cobrado, $decimales) . "\n";
                $mensaje .= "*Método:* {$metodo_pago}\n";
                $mensaje .= "*Fecha:* " . date('d/m/Y H:i', strtotime($fecha_pago)) . "\n\n";

                if (!empty($observaciones)) {
                    $mensaje .= "*Obs:* {$observaciones}\n\n";
                }
                $mensaje .= "¡Gracias por su pago!\n\n";
                $mensaje .= "*{$config['nombre_comercio']}*";

                // Enviar al administrador
                if (!empty($config['whatsapp'])) {
                    enviarWhatsAppCentral($config['whatsapp'], "🔔 *Nuevo Pago Registrado*\n\n" . $mensaje, false);
                }

                // Enviar al cliente (números principal y secundario)
                foreach (['telefono_principal', 'telefono_secundario'] as $tipo_telefono) {
                    if (!empty($datosCliente[$tipo_telefono])) {
                        enviarWhatsAppCentral($datosCliente[$tipo_telefono], $mensaje, false);
                    }
                }
            }
        }
    } catch (Exception $e) {
        // Si falla el envío de WhatsApp, solo lo registramos pero no afectará el proceso de cobro
        error_log("Error al enviar WhatsApp: " . $e->getMessage());
    }

    // Continuar con la respuesta exitosa
    $mensaje_exito = 'Cobro registrado exitosamente';
    if ($monto_restante > 0) {
        $mensaje_exito .= sprintf('. El vuelto es %s %s', 
            formatearMonto($monto_restante, $decimales),
            $moneda
        );
    }
    enviarRespuesta(true, $mensaje_exito);

} catch (Exception $e) {
    error_log("Error en procesar-cobro-multiple.php: " . $e->getMessage());
    
    // Solo hacer rollback si hay una transacción activa
    if (isset($pdo) && $pdo->inTransaction()) {
        try {
            $pdo->rollBack();
        } catch (PDOException $rollbackError) {
            error_log("Error en rollback: " . $rollbackError->getMessage());
        }
    }
    
    enviarRespuesta(false, 'Error al procesar el cobro: ' . $e->getMessage());
}