<?php

/**
 * CuentasPorCobrar.php - Gestión de cuentas por cobrar
 * Manejo de ventas a crédito y registro de pagos
 */

// Función para enviar respuesta JSON
if (!function_exists('sendResponse')) {
    function sendResponse($success, $message = '', $data = null)
    {
        echo json_encode([
            "success" => $success,
            "message" => $message,
            "data" => $data
        ]);
        exit;
    }
}

// === OBTENER VENTAS A CRÉDITO PENDIENTES ===
if ($tipo === 'getVentasCreditoPendientes') {
    error_log("=== OBTENIENDO VENTAS A CRÉDITO PENDIENTES ===");

    try {
        $clienteId = isset($datapost['cliente_id']) ? (int)$datapost['cliente_id'] : null;
        $repartidorId = isset($datapost['repartidor_id']) ? (int)$datapost['repartidor_id'] : null;
        $fechaDesde = isset($datapost['fecha_desde']) ? $datapost['fecha_desde'] : null;
        $fechaHasta = isset($datapost['fecha_hasta']) ? $datapost['fecha_hasta'] : null;
        $limite = isset($datapost['limite']) ? (int)$datapost['limite'] : 100;

        $query = "SELECT
                    v.id,
                    v.folio,
                    v.cliente_id,
                    v.repartidor_id,
                    v.fecha_venta,
                    v.hora_venta,
                    v.subtotal,
                    v.impuestos,
                    v.total,
                    v.forma_pago,
                    COALESCE(v.saldo_pendiente, v.total) as saldo_pendiente,
                    COALESCE(v.pagado, 0) as pagado,
                    c.nombre as cliente_nombre,
                    c.nombre_comercial as cliente_comercial,
                    c.telefono as cliente_telefono,
                    c.direccion as cliente_direccion,
                    r.nombre as repartidor_nombre,
                    COALESCE((SELECT SUM(monto) FROM pagos WHERE venta_id = v.id), 0) as total_pagado,
                    (SELECT COUNT(*) FROM pagos WHERE venta_id = v.id) as num_pagos
                  FROM ventas v
                  LEFT JOIN clientes c ON v.cliente_id = c.id
                  LEFT JOIN repartidores r ON v.repartidor_id = r.id
                  WHERE v.forma_pago = 'credito'
                  AND v.estado != 'anulada'
                  AND (v.pagado = 0 OR v.pagado IS NULL OR COALESCE(v.saldo_pendiente, v.total) > 0)";

        $params = [];

        if ($clienteId) {
            $query .= " AND v.cliente_id = :cliente_id";
            $params[':cliente_id'] = $clienteId;
        }

        if ($repartidorId) {
            $query .= " AND v.repartidor_id = :repartidor_id";
            $params[':repartidor_id'] = $repartidorId;
        }

        if ($fechaDesde) {
            $query .= " AND v.fecha_venta >= :fecha_desde";
            $params[':fecha_desde'] = $fechaDesde;
        }

        if ($fechaHasta) {
            $query .= " AND v.fecha_venta <= :fecha_hasta";
            $params[':fecha_hasta'] = $fechaHasta;
        }

        $query .= " ORDER BY v.fecha_venta DESC, v.id DESC LIMIT :limite";

        $stmt = $conn->prepare($query);

        foreach ($params as $key => $value) {
            $stmt->bindValue($key, $value);
        }
        $stmt->bindValue(':limite', $limite, PDO::PARAM_INT);

        $stmt->execute();
        $ventas = $stmt->fetchAll(PDO::FETCH_ASSOC);

        // Calcular totales
        $totalPendiente = 0;
        foreach ($ventas as &$venta) {
            $saldo = floatval($venta['total']) - floatval($venta['total_pagado']);
            $venta['saldo_pendiente'] = $saldo;
            $totalPendiente += $saldo;
        }

        sendResponse(true, "Ventas a crédito obtenidas", [
            'ventas' => $ventas,
            'total_pendiente' => $totalPendiente,
            'total_registros' => count($ventas)
        ]);

    } catch (Exception $e) {
        error_log("Error obteniendo ventas a crédito: " . $e->getMessage());
        sendResponse(false, "Error al obtener ventas: " . $e->getMessage());
    }
}

// === OBTENER SALDO POR CLIENTE ===
if ($tipo === 'getSaldoPorCliente') {
    error_log("=== OBTENIENDO SALDO POR CLIENTE ===");

    try {
        $soloConSaldo = isset($datapost['solo_con_saldo']) ? (bool)$datapost['solo_con_saldo'] : true;

        $query = "SELECT
                    c.id as cliente_id,
                    c.codigo as cliente_codigo,
                    c.nombre as cliente_nombre,
                    c.nombre_comercial,
                    c.telefono,
                    c.direccion,
                    COUNT(DISTINCT v.id) as total_ventas_credito,
                    COALESCE(SUM(v.total), 0) as total_vendido,
                    COALESCE(SUM(
                        (SELECT COALESCE(SUM(p.monto), 0) FROM pagos p WHERE p.venta_id = v.id)
                    ), 0) as total_pagado,
                    COALESCE(SUM(v.total), 0) - COALESCE(SUM(
                        (SELECT COALESCE(SUM(p.monto), 0) FROM pagos p WHERE p.venta_id = v.id)
                    ), 0) as saldo_pendiente,
                    MIN(v.fecha_venta) as primera_venta,
                    MAX(v.fecha_venta) as ultima_venta
                  FROM clientes c
                  INNER JOIN ventas v ON c.id = v.cliente_id
                  WHERE v.forma_pago = 'credito'
                  AND v.estado != 'anulada'
                  GROUP BY c.id, c.codigo, c.nombre, c.nombre_comercial, c.telefono, c.direccion";

        if ($soloConSaldo) {
            $query .= " HAVING saldo_pendiente > 0";
        }

        $query .= " ORDER BY saldo_pendiente DESC";

        $stmt = $conn->prepare($query);
        $stmt->execute();
        $clientes = $stmt->fetchAll(PDO::FETCH_ASSOC);

        // Calcular total general
        $totalGeneral = 0;
        foreach ($clientes as $cliente) {
            $totalGeneral += floatval($cliente['saldo_pendiente']);
        }

        sendResponse(true, "Saldos por cliente obtenidos", [
            'clientes' => $clientes,
            'total_general' => $totalGeneral,
            'total_clientes' => count($clientes)
        ]);

    } catch (Exception $e) {
        error_log("Error obteniendo saldos: " . $e->getMessage());
        sendResponse(false, "Error al obtener saldos: " . $e->getMessage());
    }
}

// === OBTENER DETALLE DE CUENTA DE UN CLIENTE ===
if ($tipo === 'getDetalleCuentaCliente') {
    error_log("=== OBTENIENDO DETALLE DE CUENTA DE CLIENTE ===");

    $clienteId = isset($datapost['cliente_id']) ? (int)$datapost['cliente_id'] : 0;

    if ($clienteId <= 0) {
        sendResponse(false, "ID de cliente requerido");
    }

    try {
        // Obtener información del cliente
        $queryCliente = "SELECT id, codigo, nombre, nombre_comercial, telefono, direccion
                         FROM clientes WHERE id = :cliente_id";
        $stmtCliente = $conn->prepare($queryCliente);
        $stmtCliente->bindParam(':cliente_id', $clienteId);
        $stmtCliente->execute();
        $cliente = $stmtCliente->fetch(PDO::FETCH_ASSOC);

        if (!$cliente) {
            sendResponse(false, "Cliente no encontrado");
        }

        // Obtener ventas a crédito del cliente
        $queryVentas = "SELECT
                          v.id,
                          v.folio,
                          v.fecha_venta,
                          v.hora_venta,
                          v.total,
                          v.estado,
                          r.nombre as repartidor_nombre,
                          COALESCE((SELECT SUM(monto) FROM pagos WHERE venta_id = v.id), 0) as total_pagado
                        FROM ventas v
                        LEFT JOIN repartidores r ON v.repartidor_id = r.id
                        WHERE v.cliente_id = :cliente_id
                        AND v.forma_pago = 'credito'
                        AND v.estado != 'anulada'
                        ORDER BY v.fecha_venta DESC";

        $stmtVentas = $conn->prepare($queryVentas);
        $stmtVentas->bindParam(':cliente_id', $clienteId);
        $stmtVentas->execute();
        $ventas = $stmtVentas->fetchAll(PDO::FETCH_ASSOC);

        // Calcular saldo de cada venta
        $totalVendido = 0;
        $totalPagado = 0;
        foreach ($ventas as &$venta) {
            $venta['saldo_pendiente'] = floatval($venta['total']) - floatval($venta['total_pagado']);
            $totalVendido += floatval($venta['total']);
            $totalPagado += floatval($venta['total_pagado']);
        }

        // Obtener historial de pagos
        $queryPagos = "SELECT
                         p.id,
                         p.venta_id,
                         p.monto,
                         p.fecha_pago,
                         p.forma_pago,
                         p.referencia,
                         p.notas,
                         v.folio as venta_folio
                       FROM pagos p
                       INNER JOIN ventas v ON p.venta_id = v.id
                       WHERE p.cliente_id = :cliente_id
                       ORDER BY p.fecha_pago DESC";

        $stmtPagos = $conn->prepare($queryPagos);
        $stmtPagos->bindParam(':cliente_id', $clienteId);
        $stmtPagos->execute();
        $pagos = $stmtPagos->fetchAll(PDO::FETCH_ASSOC);

        sendResponse(true, "Detalle de cuenta obtenido", [
            'cliente' => $cliente,
            'ventas' => $ventas,
            'pagos' => $pagos,
            'resumen' => [
                'total_vendido' => $totalVendido,
                'total_pagado' => $totalPagado,
                'saldo_pendiente' => $totalVendido - $totalPagado
            ]
        ]);

    } catch (Exception $e) {
        error_log("Error obteniendo detalle de cuenta: " . $e->getMessage());
        sendResponse(false, "Error al obtener detalle: " . $e->getMessage());
    }
}

// === REGISTRAR PAGO ===
if ($tipo === 'registrarPago') {
    error_log("=== REGISTRANDO PAGO ===");

    $ventaId = isset($datapost['venta_id']) ? (int)$datapost['venta_id'] : 0;
    $monto = isset($datapost['monto']) ? floatval($datapost['monto']) : 0;
    $formaPago = isset($datapost['forma_pago']) ? $datapost['forma_pago'] : 'efectivo';
    $referencia = isset($datapost['referencia']) ? $datapost['referencia'] : null;
    $notas = isset($datapost['notas']) ? $datapost['notas'] : null;

    if ($ventaId <= 0) {
        sendResponse(false, "ID de venta requerido");
    }

    if ($monto <= 0) {
        sendResponse(false, "El monto debe ser mayor a cero");
    }

    try {
        // Verificar que la venta existe y es a crédito
        $queryVenta = "SELECT v.id, v.folio, v.total, v.cliente_id, v.forma_pago,
                              COALESCE((SELECT SUM(monto) FROM pagos WHERE venta_id = v.id), 0) as total_pagado
                       FROM ventas v
                       WHERE v.id = :venta_id AND v.estado != 'anulada'";
        $stmtVenta = $conn->prepare($queryVenta);
        $stmtVenta->bindParam(':venta_id', $ventaId);
        $stmtVenta->execute();
        $venta = $stmtVenta->fetch(PDO::FETCH_ASSOC);

        if (!$venta) {
            sendResponse(false, "Venta no encontrada");
        }

        if ($venta['forma_pago'] !== 'credito') {
            sendResponse(false, "Esta venta no es a crédito");
        }

        $saldoActual = floatval($venta['total']) - floatval($venta['total_pagado']);

        if ($monto > $saldoActual) {
            sendResponse(false, "El monto ($monto) excede el saldo pendiente ($saldoActual)");
        }

        $conn->beginTransaction();

        // Insertar pago
        $queryPago = "INSERT INTO pagos (
                        venta_id, cliente_id, monto, fecha_pago,
                        forma_pago, referencia, notas, created_at
                      ) VALUES (
                        :venta_id, :cliente_id, :monto, NOW(),
                        :forma_pago, :referencia, :notas, NOW()
                      )";

        $stmtPago = $conn->prepare($queryPago);
        $stmtPago->bindParam(':venta_id', $ventaId);
        $stmtPago->bindParam(':cliente_id', $venta['cliente_id']);
        $stmtPago->bindParam(':monto', $monto);
        $stmtPago->bindParam(':forma_pago', $formaPago);
        $stmtPago->bindParam(':referencia', $referencia);
        $stmtPago->bindParam(':notas', $notas);
        $stmtPago->execute();

        $pagoId = $conn->lastInsertId();

        // Actualizar saldo de la venta
        $nuevoSaldo = $saldoActual - $monto;
        $pagado = ($nuevoSaldo <= 0) ? 1 : 0;

        $queryUpdateVenta = "UPDATE ventas SET saldo_pendiente = :saldo, pagado = :pagado WHERE id = :venta_id";
        $stmtUpdate = $conn->prepare($queryUpdateVenta);
        $stmtUpdate->bindParam(':saldo', $nuevoSaldo);
        $stmtUpdate->bindParam(':pagado', $pagado);
        $stmtUpdate->bindParam(':venta_id', $ventaId);
        $stmtUpdate->execute();

        $conn->commit();

        error_log("Pago registrado: ID=$pagoId, Venta=$ventaId, Monto=$monto, Nuevo saldo=$nuevoSaldo");

        sendResponse(true, "Pago registrado exitosamente", [
            'pago_id' => $pagoId,
            'venta_folio' => $venta['folio'],
            'monto_pagado' => $monto,
            'saldo_anterior' => $saldoActual,
            'nuevo_saldo' => $nuevoSaldo,
            'venta_pagada' => ($pagado == 1)
        ]);

    } catch (Exception $e) {
        $conn->rollBack();
        error_log("Error registrando pago: " . $e->getMessage());
        sendResponse(false, "Error al registrar pago: " . $e->getMessage());
    }
}

// === ELIMINAR PAGO ===
if ($tipo === 'eliminarPago') {
    error_log("=== ELIMINANDO PAGO ===");

    $pagoId = isset($datapost['pago_id']) ? (int)$datapost['pago_id'] : 0;

    if ($pagoId <= 0) {
        sendResponse(false, "ID de pago requerido");
    }

    try {
        // Obtener información del pago
        $queryPago = "SELECT * FROM pagos WHERE id = :pago_id";
        $stmtPago = $conn->prepare($queryPago);
        $stmtPago->bindParam(':pago_id', $pagoId);
        $stmtPago->execute();
        $pago = $stmtPago->fetch(PDO::FETCH_ASSOC);

        if (!$pago) {
            sendResponse(false, "Pago no encontrado");
        }

        $conn->beginTransaction();

        // Eliminar pago
        $queryDelete = "DELETE FROM pagos WHERE id = :pago_id";
        $stmtDelete = $conn->prepare($queryDelete);
        $stmtDelete->bindParam(':pago_id', $pagoId);
        $stmtDelete->execute();

        // Recalcular saldo de la venta
        $queryTotal = "SELECT COALESCE(SUM(monto), 0) as total_pagado FROM pagos WHERE venta_id = :venta_id";
        $stmtTotal = $conn->prepare($queryTotal);
        $stmtTotal->bindParam(':venta_id', $pago['venta_id']);
        $stmtTotal->execute();
        $totalPagado = $stmtTotal->fetch(PDO::FETCH_ASSOC)['total_pagado'];

        // Obtener total de la venta
        $queryVenta = "SELECT total FROM ventas WHERE id = :venta_id";
        $stmtVenta = $conn->prepare($queryVenta);
        $stmtVenta->bindParam(':venta_id', $pago['venta_id']);
        $stmtVenta->execute();
        $totalVenta = $stmtVenta->fetch(PDO::FETCH_ASSOC)['total'];

        $nuevoSaldo = floatval($totalVenta) - floatval($totalPagado);
        $pagado = ($nuevoSaldo <= 0) ? 1 : 0;

        // Actualizar venta
        $queryUpdateVenta = "UPDATE ventas SET saldo_pendiente = :saldo, pagado = :pagado WHERE id = :venta_id";
        $stmtUpdate = $conn->prepare($queryUpdateVenta);
        $stmtUpdate->bindParam(':saldo', $nuevoSaldo);
        $stmtUpdate->bindParam(':pagado', $pagado);
        $stmtUpdate->bindParam(':venta_id', $pago['venta_id']);
        $stmtUpdate->execute();

        $conn->commit();

        sendResponse(true, "Pago eliminado exitosamente", [
            'nuevo_saldo' => $nuevoSaldo
        ]);

    } catch (Exception $e) {
        $conn->rollBack();
        error_log("Error eliminando pago: " . $e->getMessage());
        sendResponse(false, "Error al eliminar pago: " . $e->getMessage());
    }
}

// === REGISTRAR PAGO A CUENTA (DISTRIBUIDO AUTOMÁTICAMENTE) ===
if ($tipo === 'registrarPagoCuenta') {
    error_log("=== REGISTRANDO PAGO A CUENTA ===");

    $clienteId = isset($datapost['cliente_id']) ? (int)$datapost['cliente_id'] : 0;
    $monto = isset($datapost['monto']) ? floatval($datapost['monto']) : 0;
    $formaPago = isset($datapost['forma_pago']) ? $datapost['forma_pago'] : 'efectivo';
    $referencia = isset($datapost['referencia']) ? $datapost['referencia'] : null;
    $notas = isset($datapost['notas']) ? $datapost['notas'] : null;

    if ($clienteId <= 0) {
        sendResponse(false, "ID de cliente requerido");
    }

    if ($monto <= 0) {
        sendResponse(false, "El monto debe ser mayor a cero");
    }

    try {
        // Obtener ventas pendientes del cliente ordenadas de la más vieja a la más nueva
        $queryVentas = "SELECT
                          v.id,
                          v.folio,
                          v.total,
                          COALESCE(v.saldo_pendiente, v.total - COALESCE((SELECT SUM(monto) FROM pagos WHERE venta_id = v.id), 0)) as saldo_pendiente
                        FROM ventas v
                        WHERE v.cliente_id = :cliente_id
                        AND v.forma_pago = 'credito'
                        AND v.estado != 'anulada'
                        AND (v.pagado = 0 OR v.pagado IS NULL)
                        HAVING saldo_pendiente > 0
                        ORDER BY v.fecha_venta ASC, v.id ASC";

        $stmtVentas = $conn->prepare($queryVentas);
        $stmtVentas->bindParam(':cliente_id', $clienteId);
        $stmtVentas->execute();
        $ventasPendientes = $stmtVentas->fetchAll(PDO::FETCH_ASSOC);

        if (empty($ventasPendientes)) {
            sendResponse(false, "Este cliente no tiene ventas pendientes de pago");
        }

        // Calcular saldo total del cliente
        $saldoTotalCliente = 0;
        foreach ($ventasPendientes as $venta) {
            $saldoTotalCliente += floatval($venta['saldo_pendiente']);
        }

        $conn->beginTransaction();

        $montoRestante = $monto;
        $pagosRealizados = [];
        $ventasCubiertas = 0;
        $ventasParciales = 0;

        // Distribuir el pago desde la venta más vieja a la más nueva
        foreach ($ventasPendientes as $venta) {
            if ($montoRestante <= 0) break;

            $saldoVenta = floatval($venta['saldo_pendiente']);
            $montoAplicar = min($montoRestante, $saldoVenta);

            // Insertar pago para esta venta
            $queryPago = "INSERT INTO pagos (
                            venta_id, cliente_id, monto, fecha_pago,
                            forma_pago, referencia, notas, created_at
                          ) VALUES (
                            :venta_id, :cliente_id, :monto, NOW(),
                            :forma_pago, :referencia, :notas, NOW()
                          )";

            $notaPago = $notas ? $notas . " (Pago a cuenta distribuido)" : "Pago a cuenta distribuido";

            $stmtPago = $conn->prepare($queryPago);
            $stmtPago->bindParam(':venta_id', $venta['id']);
            $stmtPago->bindParam(':cliente_id', $clienteId);
            $stmtPago->bindParam(':monto', $montoAplicar);
            $stmtPago->bindParam(':forma_pago', $formaPago);
            $stmtPago->bindParam(':referencia', $referencia);
            $stmtPago->bindParam(':notas', $notaPago);
            $stmtPago->execute();

            $pagoId = $conn->lastInsertId();

            // Actualizar saldo de la venta
            $nuevoSaldo = $saldoVenta - $montoAplicar;
            $pagado = ($nuevoSaldo <= 0) ? 1 : 0;

            $queryUpdateVenta = "UPDATE ventas SET saldo_pendiente = :saldo, pagado = :pagado WHERE id = :venta_id";
            $stmtUpdate = $conn->prepare($queryUpdateVenta);
            $stmtUpdate->bindParam(':saldo', $nuevoSaldo);
            $stmtUpdate->bindParam(':pagado', $pagado);
            $stmtUpdate->bindParam(':venta_id', $venta['id']);
            $stmtUpdate->execute();

            // Registrar detalle del pago
            $pagosRealizados[] = [
                'pago_id' => $pagoId,
                'venta_id' => $venta['id'],
                'folio' => $venta['folio'],
                'monto_aplicado' => $montoAplicar,
                'saldo_anterior' => $saldoVenta,
                'nuevo_saldo' => $nuevoSaldo,
                'cubierta' => ($pagado == 1)
            ];

            if ($pagado == 1) {
                $ventasCubiertas++;
            } else {
                $ventasParciales++;
            }

            $montoRestante -= $montoAplicar;

            error_log("Pago aplicado: Venta {$venta['folio']}, Monto: $montoAplicar, Nuevo saldo: $nuevoSaldo");
        }

        $conn->commit();

        // Calcular nuevo saldo total
        $nuevoSaldoTotal = $saldoTotalCliente - $monto;
        if ($nuevoSaldoTotal < 0) $nuevoSaldoTotal = 0;

        error_log("Pago a cuenta completado: Cliente $clienteId, Monto $monto, Ventas cubiertas: $ventasCubiertas");

        sendResponse(true, "Pago a cuenta registrado exitosamente", [
            'monto_pagado' => $monto,
            'saldo_anterior' => $saldoTotalCliente,
            'nuevo_saldo' => $nuevoSaldoTotal,
            'ventas_cubiertas' => $ventasCubiertas,
            'ventas_parciales' => $ventasParciales,
            'detalle_pagos' => $pagosRealizados
        ]);

    } catch (Exception $e) {
        $conn->rollBack();
        error_log("Error registrando pago a cuenta: " . $e->getMessage());
        sendResponse(false, "Error al registrar pago: " . $e->getMessage());
    }
}

// === OBTENER RESUMEN DE CUENTAS POR COBRAR ===
if ($tipo === 'getResumenCuentasPorCobrar') {
    error_log("=== OBTENIENDO RESUMEN DE CUENTAS POR COBRAR ===");

    try {
        // Total general pendiente
        $queryTotal = "SELECT
                         COUNT(DISTINCT v.id) as total_ventas,
                         COUNT(DISTINCT v.cliente_id) as total_clientes,
                         COALESCE(SUM(v.total), 0) as total_vendido,
                         COALESCE(SUM((SELECT COALESCE(SUM(p.monto), 0) FROM pagos p WHERE p.venta_id = v.id)), 0) as total_cobrado
                       FROM ventas v
                       WHERE v.forma_pago = 'credito'
                       AND v.estado != 'anulada'";

        $stmt = $conn->prepare($queryTotal);
        $stmt->execute();
        $totales = $stmt->fetch(PDO::FETCH_ASSOC);

        $totalPendiente = floatval($totales['total_vendido']) - floatval($totales['total_cobrado']);

        // Ventas por antigüedad
        $queryAntiguedad = "SELECT
                             CASE
                               WHEN DATEDIFF(CURDATE(), v.fecha_venta) <= 7 THEN '0-7 días'
                               WHEN DATEDIFF(CURDATE(), v.fecha_venta) <= 15 THEN '8-15 días'
                               WHEN DATEDIFF(CURDATE(), v.fecha_venta) <= 30 THEN '16-30 días'
                               WHEN DATEDIFF(CURDATE(), v.fecha_venta) <= 60 THEN '31-60 días'
                               ELSE 'Más de 60 días'
                             END as rango,
                             COUNT(*) as cantidad,
                             SUM(v.total - COALESCE((SELECT SUM(p.monto) FROM pagos p WHERE p.venta_id = v.id), 0)) as monto
                           FROM ventas v
                           WHERE v.forma_pago = 'credito'
                           AND v.estado != 'anulada'
                           AND (v.pagado = 0 OR v.pagado IS NULL)
                           GROUP BY rango
                           ORDER BY FIELD(rango, '0-7 días', '8-15 días', '16-30 días', '31-60 días', 'Más de 60 días')";

        $stmtAntiguedad = $conn->prepare($queryAntiguedad);
        $stmtAntiguedad->execute();
        $antiguedad = $stmtAntiguedad->fetchAll(PDO::FETCH_ASSOC);

        // Top 5 clientes con mayor saldo
        $queryTopClientes = "SELECT
                               c.id,
                               c.nombre_comercial,
                               c.nombre,
                               SUM(v.total - COALESCE((SELECT SUM(p.monto) FROM pagos p WHERE p.venta_id = v.id), 0)) as saldo
                             FROM clientes c
                             INNER JOIN ventas v ON c.id = v.cliente_id
                             WHERE v.forma_pago = 'credito'
                             AND v.estado != 'anulada'
                             GROUP BY c.id, c.nombre_comercial, c.nombre
                             HAVING saldo > 0
                             ORDER BY saldo DESC
                             LIMIT 5";

        $stmtTop = $conn->prepare($queryTopClientes);
        $stmtTop->execute();
        $topClientes = $stmtTop->fetchAll(PDO::FETCH_ASSOC);

        sendResponse(true, "Resumen obtenido", [
            'total_ventas_credito' => (int)$totales['total_ventas'],
            'total_clientes' => (int)$totales['total_clientes'],
            'total_vendido' => floatval($totales['total_vendido']),
            'total_cobrado' => floatval($totales['total_cobrado']),
            'total_pendiente' => $totalPendiente,
            'por_antiguedad' => $antiguedad,
            'top_clientes' => $topClientes
        ]);

    } catch (Exception $e) {
        error_log("Error obteniendo resumen: " . $e->getMessage());
        sendResponse(false, "Error al obtener resumen: " . $e->getMessage());
    }
}
