<?php

/**
 * Devoluciones.php - Manejo completo de devoluciones de productos
 * Sistema independiente de ventas
 */

// 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;
    }
}

// === REGISTRAR DEVOLUCIÓN ===
if ($tipo === 'registrarDevolucion') {
    error_log("=== REGISTRANDO DEVOLUCIÓN ===");

    // Obtener token del repartidor
    $authHeader = $_SERVER['HTTP_AUTHORIZATION'] ?? '';
    if (empty($authHeader)) {
        $headers = getallheaders();
        $authHeader = $headers['Authorization'] ?? '';
    }

    if (empty($authHeader)) {
        sendResponse(false, "Token de autenticación requerido");
    }

    $token = str_replace('Bearer ', '', $authHeader);

    // Verificar token y obtener repartidor_id
    require_once __DIR__ . '/../../modelos/Auth.php';
    $auth = new Auth($conn);
    $payload = $auth->verificarJWT($token);

    if (!$payload) {
        sendResponse(false, "Token inválido o expirado");
    }

    $repartidorId = $payload['repartidor_id'] ?? null;
    if (!$repartidorId) {
        sendResponse(false, "Token no válido para repartidor");
    }

    // Obtener parámetros
    $clienteId = isset($datapost['cliente_id']) ? (int)$datapost['cliente_id'] : 0;
    $visitaId = isset($datapost['visita_id']) ? (int)$datapost['visita_id'] : null;
    $ventaId = isset($datapost['venta_id']) ? (int)$datapost['venta_id'] : null;
    $productos = isset($datapost['productos']) ? $datapost['productos'] : [];
    $total = isset($datapost['total']) ? (float)$datapost['total'] : 0;
    $notas = isset($datapost['notas']) ? $datapost['notas'] : '';

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

    if (empty($productos)) {
        sendResponse(false, "Debe incluir al menos un producto para devolver");
    }

    try {
        error_log("Registrando devolución: Cliente ID=$clienteId, Total=$total, Productos=" . count($productos));

        // Iniciar transacción
        $conn->beginTransaction();

        // Crear registro de devolución
        $queryDevolucion = "INSERT INTO devoluciones (
                            repartidor_id,
                            cliente_id,
                            venta_id,
                            visita_id,
                            fecha_devolucion,
                            hora_devolucion,
                            subtotal,
                            impuestos,
                            total,
                            estado,
                            notas,
                            created_at
                        ) VALUES (
                            :repartidor_id,
                            :cliente_id,
                            :venta_id,
                            :visita_id,
                            CURDATE(),
                            CURTIME(),
                            :subtotal,
                            0,
                            :total,
                            'registrada',
                            :notas,
                            NOW()
                        )";

        $stmtDevolucion = $conn->prepare($queryDevolucion);
        $stmtDevolucion->bindParam(':repartidor_id', $repartidorId);
        $stmtDevolucion->bindParam(':cliente_id', $clienteId);
        $stmtDevolucion->bindParam(':venta_id', $ventaId);
        $stmtDevolucion->bindParam(':visita_id', $visitaId);
        $stmtDevolucion->bindParam(':subtotal', $total);
        $stmtDevolucion->bindParam(':total', $total);
        $stmtDevolucion->bindParam(':notas', $notas);
        $stmtDevolucion->execute();

        $devolucionId = $conn->lastInsertId();

        // Obtener el folio generado por el trigger
        $queryFolio = "SELECT folio FROM devoluciones WHERE id = :id";
        $stmtFolio = $conn->prepare($queryFolio);
        $stmtFolio->bindParam(':id', $devolucionId);
        $stmtFolio->execute();
        $folio = $stmtFolio->fetchColumn();

        error_log("Devolución creada con ID: $devolucionId, Folio: $folio");

        // Insertar detalles de devolución y actualizar inventario
        foreach ($productos as $producto) {
            $productoId = (int)$producto['producto_id'];
            $cantidad = (float)$producto['cantidad'];
            $precioUnitario = (float)$producto['precio_unitario'];
            $subtotal = (float)$producto['subtotal'];
            $motivo = isset($producto['motivo']) ? $producto['motivo'] : 'caducado';
            $descripcionMotivo = isset($producto['descripcion_motivo']) ? $producto['descripcion_motivo'] : '';

            // Validar motivo
            $motivosValidos = ['caducado', 'dañado', 'degustacion', 'finalizacion', 'promocion', 'otro'];
            if (!in_array($motivo, $motivosValidos)) {
                $motivo = 'caducado';
            }

            // Insertar detalle
            $queryDetalle = "INSERT INTO devoluciones_detalle (
                                devolucion_id,
                                producto_id,
                                cantidad,
                                precio_unitario,
                                subtotal,
                                motivo,
                                descripcion_motivo,
                                created_at
                            ) VALUES (
                                :devolucion_id,
                                :producto_id,
                                :cantidad,
                                :precio_unitario,
                                :subtotal,
                                :motivo,
                                :descripcion_motivo,
                                NOW()
                            )";

            $stmtDetalle = $conn->prepare($queryDetalle);
            $stmtDetalle->bindParam(':devolucion_id', $devolucionId);
            $stmtDetalle->bindParam(':producto_id', $productoId);
            $stmtDetalle->bindParam(':cantidad', $cantidad);
            $stmtDetalle->bindParam(':precio_unitario', $precioUnitario);
            $stmtDetalle->bindParam(':subtotal', $subtotal);
            $stmtDetalle->bindParam(':motivo', $motivo);
            $stmtDetalle->bindParam(':descripcion_motivo', $descripcionMotivo);
            $stmtDetalle->execute();

            // DEGUSTACIÓN: Restar del inventario NORMAL (como una venta sin cobro)
            // OTRAS DEVOLUCIONES: Sumar al inventario de devoluciones
            if ($motivo === 'degustacion') {
                error_log("Motivo: DEGUSTACIÓN - Restando del inventario NORMAL");

                // Restar del inventario NORMAL (como una salida/venta sin cobro)
                $queryInventarioNormal = "UPDATE inventarios_repartidor
                                         SET cantidad = cantidad - :cantidad,
                                             updated_at = NOW()
                                         WHERE repartidor_id = :repartidor_id
                                           AND producto_id = :producto_id";

                $stmtInventarioNormal = $conn->prepare($queryInventarioNormal);
                $stmtInventarioNormal->bindParam(':cantidad', $cantidad);
                $stmtInventarioNormal->bindParam(':repartidor_id', $repartidorId);
                $stmtInventarioNormal->bindParam(':producto_id', $productoId);
                $stmtInventarioNormal->execute();

                // Si el producto no existe en inventario normal, crear con cantidad negativa
                if ($stmtInventarioNormal->rowCount() === 0) {
                    error_log("Producto ID=$productoId no existe en inventario normal, creando con cantidad negativa");
                    $cantidadNegativa = -$cantidad;
                    $queryInsertInventarioNormal = "INSERT INTO inventarios_repartidor (
                                                        repartidor_id,
                                                        producto_id,
                                                        cantidad,
                                                        created_at,
                                                        updated_at
                                                     ) VALUES (
                                                        :repartidor_id,
                                                        :producto_id,
                                                        :cantidad_negativa,
                                                        NOW(),
                                                        NOW()
                                                     )";
                    $stmtInsertInventarioNormal = $conn->prepare($queryInsertInventarioNormal);
                    $stmtInsertInventarioNormal->bindParam(':repartidor_id', $repartidorId);
                    $stmtInsertInventarioNormal->bindParam(':producto_id', $productoId);
                    $stmtInsertInventarioNormal->bindParam(':cantidad_negativa', $cantidadNegativa);
                    $stmtInsertInventarioNormal->execute();
                }
            } else {
                // Para OTROS motivos: Sumar al inventario de DEVOLUCIONES
                error_log("Motivo: $motivo - Sumando al inventario de DEVOLUCIONES");

                $queryInventarioDev = "UPDATE inventarios_devoluciones_repartidor
                                       SET cantidad = cantidad + :cantidad,
                                           ultimo_motivo = :motivo,
                                           fecha_ultima_devolucion = NOW(),
                                           updated_at = NOW()
                                       WHERE repartidor_id = :repartidor_id
                                         AND producto_id = :producto_id";

                $stmtInventarioDev = $conn->prepare($queryInventarioDev);
                $stmtInventarioDev->bindParam(':cantidad', $cantidad);
                $stmtInventarioDev->bindParam(':motivo', $motivo);
                $stmtInventarioDev->bindParam(':repartidor_id', $repartidorId);
                $stmtInventarioDev->bindParam(':producto_id', $productoId);
                $stmtInventarioDev->execute();

                // Si el producto no existe en el inventario de devoluciones, crear registro
                if ($stmtInventarioDev->rowCount() === 0) {
                    error_log("Producto ID=$productoId no existe en inventario de devoluciones, creando registro");
                    $queryInsertInventarioDev = "INSERT INTO inventarios_devoluciones_repartidor (
                                                    repartidor_id,
                                                    producto_id,
                                                    cantidad,
                                                    ultimo_motivo,
                                                    fecha_ultima_devolucion,
                                                    created_at,
                                                    updated_at
                                                 ) VALUES (
                                                    :repartidor_id,
                                                    :producto_id,
                                                    :cantidad,
                                                    :motivo,
                                                    NOW(),
                                                    NOW(),
                                                    NOW()
                                                 )";
                    $stmtInsertInventarioDev = $conn->prepare($queryInsertInventarioDev);
                    $stmtInsertInventarioDev->bindParam(':repartidor_id', $repartidorId);
                    $stmtInsertInventarioDev->bindParam(':producto_id', $productoId);
                    $stmtInsertInventarioDev->bindParam(':cantidad', $cantidad);
                    $stmtInsertInventarioDev->bindParam(':motivo', $motivo);
                    $stmtInsertInventarioDev->execute();
                }
            }

            // Registrar movimiento de devolución en inventario
            $queryMovimiento = "INSERT INTO movimientos_inventario_repartidor (
                                   repartidor_id,
                                   producto_id,
                                   tipo_movimiento,
                                   cantidad,
                                   notas,
                                   created_at
                               ) VALUES (
                                   :repartidor_id,
                                   :producto_id,
                                   'devolucion',
                                   :cantidad,
                                   :notas,
                                   NOW()
                               )";

            $stmtMovimiento = $conn->prepare($queryMovimiento);
            $stmtMovimiento->bindParam(':repartidor_id', $repartidorId);
            $stmtMovimiento->bindParam(':producto_id', $productoId);
            $stmtMovimiento->bindParam(':cantidad', $cantidad);
            $notasMovimiento = "Devolución $folio - Cliente ID: $clienteId - Motivo: $motivo";
            $stmtMovimiento->bindParam(':notas', $notasMovimiento);
            $stmtMovimiento->execute();

            error_log("Producto ID=$productoId devuelto: Cantidad=$cantidad, Motivo=$motivo");
        }

        // Actualizar estado a 'procesada' después de actualizar inventario
        $queryUpdateEstado = "UPDATE devoluciones SET estado = 'procesada' WHERE id = :id";
        $stmtUpdateEstado = $conn->prepare($queryUpdateEstado);
        $stmtUpdateEstado->bindParam(':id', $devolucionId);
        $stmtUpdateEstado->execute();

        // Confirmar transacción
        $conn->commit();

        // Preparar respuesta
        $respuesta = [
            'devolucion_id' => $devolucionId,
            'folio' => $folio,
            'cliente_id' => $clienteId,
            'total' => $total,
            'productos_count' => count($productos),
            'estado' => 'procesada',
            'timestamp' => date('Y-m-d H:i:s')
        ];

        sendResponse(true, "Devolución registrada exitosamente", $respuesta);

    } catch (Exception $e) {
        // Revertir transacción en caso de error
        if ($conn->inTransaction()) {
            $conn->rollBack();
        }

        error_log("Error registrando devolución: " . $e->getMessage());
        error_log("Stack trace: " . $e->getTraceAsString());
        sendResponse(false, "Error registrando devolución: " . $e->getMessage());
    }
}

// === REGISTRAR VENTA CON DEVOLUCIÓN (INTERCAMBIO) ===
if ($tipo === 'registrarVentaConDevolucion') {
    error_log("=== REGISTRANDO VENTA CON DEVOLUCIÓN (INTERCAMBIO) ===");

    // Obtener token del repartidor
    $authHeader = $_SERVER['HTTP_AUTHORIZATION'] ?? '';
    if (empty($authHeader)) {
        $headers = getallheaders();
        $authHeader = $headers['Authorization'] ?? '';
    }

    if (empty($authHeader)) {
        sendResponse(false, "Token de autenticación requerido");
    }

    $token = str_replace('Bearer ', '', $authHeader);

    // Verificar token y obtener repartidor_id
    require_once __DIR__ . '/../../modelos/Auth.php';
    $auth = new Auth($conn);
    $payload = $auth->verificarJWT($token);

    if (!$payload) {
        sendResponse(false, "Token inválido o expirado");
    }

    $repartidorId = $payload['repartidor_id'] ?? null;
    if (!$repartidorId) {
        sendResponse(false, "Token no válido para repartidor");
    }

    // Obtener parámetros
    $clienteId = isset($datapost['cliente_id']) ? (int)$datapost['cliente_id'] : 0;
    $visitaId = isset($datapost['visita_id']) ? (int)$datapost['visita_id'] : null;

    $productosVenta = isset($datapost['productos_venta']) ? $datapost['productos_venta'] : [];
    $productosDevolucion = isset($datapost['productos_devolucion']) ? $datapost['productos_devolucion'] : [];

    $totalVenta = isset($datapost['total_venta']) ? (float)$datapost['total_venta'] : 0;
    $totalDevolucion = isset($datapost['total_devolucion']) ? (float)$datapost['total_devolucion'] : 0;
    $totalNeto = isset($datapost['total_neto']) ? (float)$datapost['total_neto'] : 0;

    $formaPago = isset($datapost['forma_pago']) ? $datapost['forma_pago'] : 'efectivo';
    $notas = isset($datapost['notas']) ? $datapost['notas'] : '';

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

    if (empty($productosVenta) && empty($productosDevolucion)) {
        sendResponse(false, "Debe incluir productos de venta o devolución");
    }

    try {
        error_log("Registrando venta con devolución: Cliente ID=$clienteId, Venta=$totalVenta, Devolución=$totalDevolucion, Neto=$totalNeto");

        // Iniciar transacción
        $conn->beginTransaction();

        $ventaId = null;
        $devolucionId = null;

        // 1. REGISTRAR VENTA (si hay productos de venta)
        if (!empty($productosVenta)) {
            $queryVenta = "INSERT INTO ventas (
                            cliente_id,
                            repartidor_id,
                            visita_id,
                            fecha_venta,
                            hora_venta,
                            subtotal,
                            impuestos,
                            descuento,
                            total,
                            forma_pago,
                            estado,
                            notas,
                            created_at
                        ) VALUES (
                            :cliente_id,
                            :repartidor_id,
                            :visita_id,
                            CURDATE(),
                            CURTIME(),
                            :subtotal,
                            0,
                            0,
                            :total,
                            :forma_pago,
                            'completada',
                            :notas,
                            NOW()
                        )";

            $stmtVenta = $conn->prepare($queryVenta);
            $stmtVenta->bindParam(':cliente_id', $clienteId);
            $stmtVenta->bindParam(':repartidor_id', $repartidorId);
            $stmtVenta->bindParam(':visita_id', $visitaId);
            $stmtVenta->bindParam(':subtotal', $totalVenta);
            $stmtVenta->bindParam(':total', $totalVenta);
            $stmtVenta->bindParam(':forma_pago', $formaPago);
            $stmtVenta->bindParam(':notas', $notas);
            $stmtVenta->execute();

            $ventaId = $conn->lastInsertId();
            error_log("Venta creada con ID: $ventaId");

            // Insertar detalles de venta y actualizar inventario
            foreach ($productosVenta as $producto) {
                $productoId = (int)$producto['producto_id'];
                $cantidad = (float)$producto['cantidad'];
                $precioUnitario = (float)$producto['precio_unitario'];
                $subtotal = (float)$producto['subtotal'];

                // Insertar detalle
                $queryDetalle = "INSERT INTO ventas_detalle (
                                    venta_id,
                                    producto_id,
                                    cantidad,
                                    precio_unitario,
                                    descuento,
                                    subtotal,
                                    created_at
                                ) VALUES (
                                    :venta_id,
                                    :producto_id,
                                    :cantidad,
                                    :precio_unitario,
                                    0,
                                    :subtotal,
                                    NOW()
                                )";

                $stmtDetalle = $conn->prepare($queryDetalle);
                $stmtDetalle->bindParam(':venta_id', $ventaId);
                $stmtDetalle->bindParam(':producto_id', $productoId);
                $stmtDetalle->bindParam(':cantidad', $cantidad);
                $stmtDetalle->bindParam(':precio_unitario', $precioUnitario);
                $stmtDetalle->bindParam(':subtotal', $subtotal);
                $stmtDetalle->execute();

                // Actualizar inventario (restar)
                $queryInventarioRep = "UPDATE inventarios_repartidor
                                      SET cantidad = cantidad - :cantidad,
                                          updated_at = NOW()
                                      WHERE repartidor_id = :repartidor_id
                                        AND producto_id = :producto_id";

                $stmtInventarioRep = $conn->prepare($queryInventarioRep);
                $stmtInventarioRep->bindParam(':cantidad', $cantidad);
                $stmtInventarioRep->bindParam(':repartidor_id', $repartidorId);
                $stmtInventarioRep->bindParam(':producto_id', $productoId);
                $stmtInventarioRep->execute();

                if ($stmtInventarioRep->rowCount() === 0) {
                    $cantidadNegativa = -$cantidad;
                    $queryInsertInventario = "INSERT INTO inventarios_repartidor (
                                                repartidor_id,
                                                producto_id,
                                                cantidad,
                                                created_at,
                                                updated_at
                                            ) VALUES (
                                                :repartidor_id,
                                                :producto_id,
                                                :cantidad_negativa,
                                                NOW(),
                                                NOW()
                                            )";
                    $stmtInsertInventario = $conn->prepare($queryInsertInventario);
                    $stmtInsertInventario->bindParam(':repartidor_id', $repartidorId);
                    $stmtInsertInventario->bindParam(':producto_id', $productoId);
                    $stmtInsertInventario->bindParam(':cantidad_negativa', $cantidadNegativa);
                    $stmtInsertInventario->execute();
                }

                // Registrar movimiento de venta
                $queryMovimiento = "INSERT INTO movimientos_inventario_repartidor (
                                       repartidor_id,
                                       producto_id,
                                       tipo_movimiento,
                                       cantidad,
                                       venta_id,
                                       notas,
                                       created_at
                                   ) VALUES (
                                       :repartidor_id,
                                       :producto_id,
                                       'venta',
                                       :cantidad,
                                       :venta_id,
                                       :notas,
                                       NOW()
                                   )";

                $stmtMovimiento = $conn->prepare($queryMovimiento);
                $stmtMovimiento->bindParam(':repartidor_id', $repartidorId);
                $stmtMovimiento->bindParam(':producto_id', $productoId);
                $stmtMovimiento->bindParam(':cantidad', $cantidad);
                $stmtMovimiento->bindParam(':venta_id', $ventaId);
                $notasMovimiento = "Venta con intercambio - Cliente ID: $clienteId";
                $stmtMovimiento->bindParam(':notas', $notasMovimiento);
                $stmtMovimiento->execute();
            }
        }

        // 2. REGISTRAR DEVOLUCIÓN (si hay productos de devolución)
        if (!empty($productosDevolucion)) {
            $queryDevolucion = "INSERT INTO devoluciones (
                                repartidor_id,
                                cliente_id,
                                venta_id,
                                visita_id,
                                fecha_devolucion,
                                hora_devolucion,
                                subtotal,
                                impuestos,
                                total,
                                estado,
                                notas,
                                created_at
                            ) VALUES (
                                :repartidor_id,
                                :cliente_id,
                                :venta_id,
                                :visita_id,
                                CURDATE(),
                                CURTIME(),
                                :subtotal,
                                0,
                                :total,
                                'registrada',
                                :notas,
                                NOW()
                            )";

            $stmtDevolucion = $conn->prepare($queryDevolucion);
            $stmtDevolucion->bindParam(':repartidor_id', $repartidorId);
            $stmtDevolucion->bindParam(':cliente_id', $clienteId);
            $stmtDevolucion->bindParam(':venta_id', $ventaId);
            $stmtDevolucion->bindParam(':visita_id', $visitaId);
            $stmtDevolucion->bindParam(':subtotal', $totalDevolucion);
            $stmtDevolucion->bindParam(':total', $totalDevolucion);
            $stmtDevolucion->bindParam(':notas', $notas);
            $stmtDevolucion->execute();

            $devolucionId = $conn->lastInsertId();

            // Obtener folio
            $queryFolio = "SELECT folio FROM devoluciones WHERE id = :id";
            $stmtFolio = $conn->prepare($queryFolio);
            $stmtFolio->bindParam(':id', $devolucionId);
            $stmtFolio->execute();
            $folio = $stmtFolio->fetchColumn();

            error_log("Devolución creada con ID: $devolucionId, Folio: $folio");

            // Insertar detalles de devolución y actualizar inventario
            foreach ($productosDevolucion as $producto) {
                $productoId = (int)$producto['producto_id'];
                $cantidad = (float)$producto['cantidad'];
                $precioUnitario = (float)$producto['precio_unitario'];
                $subtotal = (float)$producto['subtotal'];
                $motivo = isset($producto['motivo']) ? $producto['motivo'] : 'caducado';
                $descripcionMotivo = isset($producto['descripcion_motivo']) ? $producto['descripcion_motivo'] : '';

                // Validar motivo
                $motivosValidos = ['caducado', 'dañado', 'degustacion', 'finalizacion', 'promocion', 'otro'];
                if (!in_array($motivo, $motivosValidos)) {
                    $motivo = 'caducado';
                }

                // Insertar detalle
                $queryDetalle = "INSERT INTO devoluciones_detalle (
                                    devolucion_id,
                                    producto_id,
                                    cantidad,
                                    precio_unitario,
                                    subtotal,
                                    motivo,
                                    descripcion_motivo,
                                    created_at
                                ) VALUES (
                                    :devolucion_id,
                                    :producto_id,
                                    :cantidad,
                                    :precio_unitario,
                                    :subtotal,
                                    :motivo,
                                    :descripcion_motivo,
                                    NOW()
                                )";

                $stmtDetalle = $conn->prepare($queryDetalle);
                $stmtDetalle->bindParam(':devolucion_id', $devolucionId);
                $stmtDetalle->bindParam(':producto_id', $productoId);
                $stmtDetalle->bindParam(':cantidad', $cantidad);
                $stmtDetalle->bindParam(':precio_unitario', $precioUnitario);
                $stmtDetalle->bindParam(':subtotal', $subtotal);
                $stmtDetalle->bindParam(':motivo', $motivo);
                $stmtDetalle->bindParam(':descripcion_motivo', $descripcionMotivo);
                $stmtDetalle->execute();

                // DEGUSTACIÓN: Restar del inventario NORMAL (como una venta sin cobro)
                // OTRAS DEVOLUCIONES: Sumar al inventario de devoluciones
                if ($motivo === 'degustacion') {
                    error_log("Motivo: DEGUSTACIÓN - Restando del inventario NORMAL (intercambio)");

                    // Restar del inventario NORMAL
                    $queryInventarioNormal = "UPDATE inventarios_repartidor
                                             SET cantidad = cantidad - :cantidad,
                                                 updated_at = NOW()
                                             WHERE repartidor_id = :repartidor_id
                                               AND producto_id = :producto_id";

                    $stmtInventarioNormal = $conn->prepare($queryInventarioNormal);
                    $stmtInventarioNormal->bindParam(':cantidad', $cantidad);
                    $stmtInventarioNormal->bindParam(':repartidor_id', $repartidorId);
                    $stmtInventarioNormal->bindParam(':producto_id', $productoId);
                    $stmtInventarioNormal->execute();

                    // Si no existe, crear con cantidad negativa
                    if ($stmtInventarioNormal->rowCount() === 0) {
                        $cantidadNegativa = -$cantidad;
                        $queryInsertInventarioNormal = "INSERT INTO inventarios_repartidor (
                                                            repartidor_id,
                                                            producto_id,
                                                            cantidad,
                                                            created_at,
                                                            updated_at
                                                         ) VALUES (
                                                            :repartidor_id,
                                                            :producto_id,
                                                            :cantidad_negativa,
                                                            NOW(),
                                                            NOW()
                                                         )";
                        $stmtInsertInventarioNormal = $conn->prepare($queryInsertInventarioNormal);
                        $stmtInsertInventarioNormal->bindParam(':repartidor_id', $repartidorId);
                        $stmtInsertInventarioNormal->bindParam(':producto_id', $productoId);
                        $stmtInsertInventarioNormal->bindParam(':cantidad_negativa', $cantidadNegativa);
                        $stmtInsertInventarioNormal->execute();
                    }
                } else {
                    // Para OTROS motivos: Sumar al inventario de DEVOLUCIONES
                    error_log("Motivo: $motivo - Sumando al inventario de DEVOLUCIONES (intercambio)");

                    $queryInventarioDev = "UPDATE inventarios_devoluciones_repartidor
                                           SET cantidad = cantidad + :cantidad,
                                               ultimo_motivo = :motivo,
                                               fecha_ultima_devolucion = NOW(),
                                               updated_at = NOW()
                                           WHERE repartidor_id = :repartidor_id
                                             AND producto_id = :producto_id";

                    $stmtInventarioDev = $conn->prepare($queryInventarioDev);
                    $stmtInventarioDev->bindParam(':cantidad', $cantidad);
                    $stmtInventarioDev->bindParam(':motivo', $motivo);
                    $stmtInventarioDev->bindParam(':repartidor_id', $repartidorId);
                    $stmtInventarioDev->bindParam(':producto_id', $productoId);
                    $stmtInventarioDev->execute();

                    if ($stmtInventarioDev->rowCount() === 0) {
                        $queryInsertInventarioDev = "INSERT INTO inventarios_devoluciones_repartidor (
                                                        repartidor_id,
                                                        producto_id,
                                                        cantidad,
                                                        ultimo_motivo,
                                                        fecha_ultima_devolucion,
                                                        created_at,
                                                        updated_at
                                                     ) VALUES (
                                                        :repartidor_id,
                                                        :producto_id,
                                                        :cantidad,
                                                        :motivo,
                                                        NOW(),
                                                        NOW(),
                                                        NOW()
                                                     )";
                        $stmtInsertInventarioDev = $conn->prepare($queryInsertInventarioDev);
                        $stmtInsertInventarioDev->bindParam(':repartidor_id', $repartidorId);
                        $stmtInsertInventarioDev->bindParam(':producto_id', $productoId);
                        $stmtInsertInventarioDev->bindParam(':cantidad', $cantidad);
                        $stmtInsertInventarioDev->bindParam(':motivo', $motivo);
                        $stmtInsertInventarioDev->execute();
                    }
                }

                // Registrar movimiento de devolución
                $queryMovimiento = "INSERT INTO movimientos_inventario_repartidor (
                                       repartidor_id,
                                       producto_id,
                                       tipo_movimiento,
                                       cantidad,
                                       notas,
                                       created_at
                                   ) VALUES (
                                       :repartidor_id,
                                       :producto_id,
                                       'devolucion',
                                       :cantidad,
                                       :notas,
                                       NOW()
                                   )";

                $stmtMovimiento = $conn->prepare($queryMovimiento);
                $stmtMovimiento->bindParam(':repartidor_id', $repartidorId);
                $stmtMovimiento->bindParam(':producto_id', $productoId);
                $stmtMovimiento->bindParam(':cantidad', $cantidad);
                $notasMovimiento = "Devolución $folio con intercambio - Cliente ID: $clienteId - Motivo: $motivo";
                $stmtMovimiento->bindParam(':notas', $notasMovimiento);
                $stmtMovimiento->execute();
            }

            // Actualizar estado de devolución
            $queryUpdateEstado = "UPDATE devoluciones SET estado = 'procesada' WHERE id = :id";
            $stmtUpdateEstado = $conn->prepare($queryUpdateEstado);
            $stmtUpdateEstado->bindParam(':id', $devolucionId);
            $stmtUpdateEstado->execute();
        }

        // 3. CREAR RELACIÓN ENTRE VENTA Y DEVOLUCIÓN (si ambas existen)
        if ($ventaId && $devolucionId) {
            $queryRelacion = "INSERT INTO ventas_devoluciones_relacion (
                                venta_id,
                                devolucion_id,
                                tipo_relacion,
                                monto_aplicado,
                                created_at
                            ) VALUES (
                                :venta_id,
                                :devolucion_id,
                                'intercambio',
                                :monto_aplicado,
                                NOW()
                            )";

            $stmtRelacion = $conn->prepare($queryRelacion);
            $stmtRelacion->bindParam(':venta_id', $ventaId);
            $stmtRelacion->bindParam(':devolucion_id', $devolucionId);
            $stmtRelacion->bindParam(':monto_aplicado', $totalDevolucion);
            $stmtRelacion->execute();

            error_log("Relación creada: Venta ID=$ventaId <-> Devolución ID=$devolucionId");
        }

        // Confirmar transacción
        $conn->commit();

        // Preparar respuesta
        $respuesta = [
            'venta_id' => $ventaId,
            'devolucion_id' => $devolucionId,
            'folio_devolucion' => $folio ?? null,
            'cliente_id' => $clienteId,
            'total_venta' => $totalVenta,
            'total_devolucion' => $totalDevolucion,
            'total_neto' => $totalNeto,
            'productos_venta_count' => count($productosVenta),
            'productos_devolucion_count' => count($productosDevolucion),
            'timestamp' => date('Y-m-d H:i:s')
        ];

        sendResponse(true, "Venta con devolución registrada exitosamente", $respuesta);

    } catch (Exception $e) {
        // Revertir transacción en caso de error
        if ($conn->inTransaction()) {
            $conn->rollBack();
        }

        error_log("Error registrando venta con devolución: " . $e->getMessage());
        error_log("Stack trace: " . $e->getTraceAsString());
        sendResponse(false, "Error registrando venta con devolución: " . $e->getMessage());
    }
}

// === OBTENER HISTORIAL DE DEVOLUCIONES ===
if ($tipo === 'getHistorialDevoluciones') {
    error_log("=== OBTENIENDO HISTORIAL DE DEVOLUCIONES ===");

    // Obtener token del repartidor
    $authHeader = $_SERVER['HTTP_AUTHORIZATION'] ?? '';
    if (empty($authHeader)) {
        $headers = getallheaders();
        $authHeader = $headers['Authorization'] ?? '';
    }

    if (empty($authHeader)) {
        sendResponse(false, "Token de autenticación requerido");
    }

    $token = str_replace('Bearer ', '', $authHeader);

    // Verificar token
    require_once __DIR__ . '/../../modelos/Auth.php';
    $auth = new Auth($conn);
    $payload = $auth->verificarJWT($token);

    if (!$payload) {
        sendResponse(false, "Token inválido o expirado");
    }

    $repartidorId = $payload['repartidor_id'] ?? null;
    if (!$repartidorId) {
        sendResponse(false, "Token no válido para repartidor");
    }

    // Obtener parámetros
    $fechaInicio = isset($datapost['fecha_inicio']) ? $datapost['fecha_inicio'] : null;
    $fechaFin = isset($datapost['fecha_fin']) ? $datapost['fecha_fin'] : null;
    $estado = isset($datapost['estado']) ? $datapost['estado'] : null;
    $clienteId = isset($datapost['cliente_id']) ? (int)$datapost['cliente_id'] : null;

    try {
        // Construir query directamente sin usar la vista para evitar problemas de cache
        $query = "SELECT
                    d.id,
                    d.folio,
                    d.fecha_devolucion,
                    d.hora_devolucion,
                    d.total,
                    d.estado,
                    d.repartidor_id,
                    r.nombre as repartidor_nombre,
                    d.cliente_id,
                    COALESCE(c.nombre_comercial, CONCAT(c.nombre, ' ', COALESCE(c.apellidos, ''))) as cliente_nombre,
                    (SELECT COUNT(*) FROM devoluciones_detalle WHERE devolucion_id = d.id) as productos_count,
                    (SELECT SUM(cantidad) FROM devoluciones_detalle WHERE devolucion_id = d.id) as total_productos
                  FROM devoluciones d
                  LEFT JOIN repartidores r ON d.repartidor_id = r.id
                  LEFT JOIN clientes c ON d.cliente_id = c.id
                  WHERE d.repartidor_id = :repartidor_id";

        if ($fechaInicio && $fechaFin) {
            $query .= " AND d.fecha_devolucion BETWEEN :fecha_inicio AND :fecha_fin";
        } elseif ($fechaInicio) {
            $query .= " AND d.fecha_devolucion >= :fecha_inicio";
        } elseif ($fechaFin) {
            $query .= " AND d.fecha_devolucion <= :fecha_fin";
        }

        if ($estado) {
            $query .= " AND d.estado = :estado";
        }

        if ($clienteId) {
            $query .= " AND d.cliente_id = :cliente_id";
        }

        $query .= " ORDER BY d.fecha_devolucion DESC, d.hora_devolucion DESC";

        $stmt = $conn->prepare($query);
        $stmt->bindParam(':repartidor_id', $repartidorId, PDO::PARAM_INT);

        if ($fechaInicio && $fechaFin) {
            $stmt->bindParam(':fecha_inicio', $fechaInicio);
            $stmt->bindParam(':fecha_fin', $fechaFin);
        } elseif ($fechaInicio) {
            $stmt->bindParam(':fecha_inicio', $fechaInicio);
        } elseif ($fechaFin) {
            $stmt->bindParam(':fecha_fin', $fechaFin);
        }

        if ($estado) {
            $stmt->bindParam(':estado', $estado);
        }

        if ($clienteId) {
            $stmt->bindParam(':cliente_id', $clienteId, PDO::PARAM_INT);
        }

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

        error_log("Devoluciones encontradas: " . count($devoluciones));

        // Obtener el detalle de productos para cada devolución
        foreach ($devoluciones as $key => $devolucion) {
            $queryProductos = "SELECT
                                dd.id,
                                dd.producto_id,
                                dd.cantidad,
                                dd.precio_unitario,
                                dd.subtotal,
                                dd.motivo,
                                dd.descripcion_motivo,
                                p.nombre as producto_nombre,
                                p.codigo as producto_codigo,
                                p.descripcion,
                                p.unidad_medida as unidad
                              FROM devoluciones_detalle dd
                              LEFT JOIN productos p ON dd.producto_id = p.id
                              WHERE dd.devolucion_id = :devolucion_id
                              ORDER BY dd.id";

            $stmtProductos = $conn->prepare($queryProductos);
            $stmtProductos->bindParam(':devolucion_id', $devolucion['id'], PDO::PARAM_INT);
            $stmtProductos->execute();
            $productos = $stmtProductos->fetchAll(PDO::FETCH_ASSOC);

            error_log("Devolución ID {$devolucion['id']}: " . count($productos) . " productos");

            $devoluciones[$key]['productos'] = $productos;
        }

        sendResponse(true, "Historial de devoluciones obtenido correctamente", $devoluciones);

    } catch (Exception $e) {
        error_log("Error obteniendo historial de devoluciones: " . $e->getMessage());
        sendResponse(false, "Error obteniendo historial de devoluciones: " . $e->getMessage());
    }
}

// === OBTENER DETALLE DE DEVOLUCIÓN ===
if ($tipo === 'getDetalleDevolucion') {
    error_log("=== OBTENIENDO DETALLE DE DEVOLUCIÓN ===");

    // Obtener parámetros
    $devolucionId = isset($datapost['devolucion_id']) ? (int)$datapost['devolucion_id'] : 0;

    if ($devolucionId <= 0) {
        sendResponse(false, "ID de devolución requerido");
    }

    try {
        // Obtener información de la devolución
        $queryDevolucion = "SELECT
                            d.*,
                            COALESCE(c.nombre_comercial, CONCAT(c.nombre, ' ', COALESCE(c.apellidos, ''))) as cliente_nombre,
                            r.nombre as repartidor_nombre
                          FROM devoluciones d
                          LEFT JOIN clientes c ON d.cliente_id = c.id
                          LEFT JOIN repartidores r ON d.repartidor_id = r.id
                          WHERE d.id = :devolucion_id";

        $stmtDevolucion = $conn->prepare($queryDevolucion);
        $stmtDevolucion->bindParam(':devolucion_id', $devolucionId, PDO::PARAM_INT);
        $stmtDevolucion->execute();

        $devolucion = $stmtDevolucion->fetch(PDO::FETCH_ASSOC);

        if (!$devolucion) {
            sendResponse(false, "Devolución no encontrada");
        }

        // Obtener productos devueltos
        $queryProductos = "SELECT
                            dd.*,
                            p.nombre as producto_nombre,
                            p.codigo as producto_codigo,
                            p.descripcion,
                            p.unidad_medida as unidad
                          FROM devoluciones_detalle dd
                          LEFT JOIN productos p ON dd.producto_id = p.id
                          WHERE dd.devolucion_id = :devolucion_id
                          ORDER BY dd.id";

        $stmtProductos = $conn->prepare($queryProductos);
        $stmtProductos->bindParam(':devolucion_id', $devolucionId, PDO::PARAM_INT);
        $stmtProductos->execute();

        $productos = $stmtProductos->fetchAll(PDO::FETCH_ASSOC);

        // Agregar productos a la devolución
        $devolucion['productos'] = $productos;

        sendResponse(true, "Detalle de devolución obtenido correctamente", $devolucion);

    } catch (Exception $e) {
        error_log("Error obteniendo detalle de devolución: " . $e->getMessage());
        sendResponse(false, "Error obteniendo detalle de devolución: " . $e->getMessage());
    }
}

// === CANCELAR DEVOLUCIÓN ===
if ($tipo === 'cancelarDevolucion') {
    error_log("=== CANCELANDO DEVOLUCIÓN ===");

    // Obtener parámetros
    $devolucionId = isset($datapost['devolucion_id']) ? (int)$datapost['devolucion_id'] : 0;
    $motivo = isset($datapost['motivo_cancelacion']) ? $datapost['motivo_cancelacion'] : '';

    if ($devolucionId <= 0) {
        sendResponse(false, "ID de devolución requerido");
    }

    try {
        $conn->beginTransaction();

        // Obtener información de la devolución
        $queryDevolucion = "SELECT * FROM devoluciones WHERE id = :id AND estado != 'cancelada'";
        $stmtDevolucion = $conn->prepare($queryDevolucion);
        $stmtDevolucion->bindParam(':id', $devolucionId);
        $stmtDevolucion->execute();
        $devolucion = $stmtDevolucion->fetch(PDO::FETCH_ASSOC);

        if (!$devolucion) {
            sendResponse(false, "Devolución no encontrada o ya está cancelada");
        }

        // Si está procesada, revertir inventario
        if ($devolucion['estado'] === 'procesada') {
            // Obtener productos devueltos
            $queryProductos = "SELECT * FROM devoluciones_detalle WHERE devolucion_id = :id";
            $stmtProductos = $conn->prepare($queryProductos);
            $stmtProductos->bindParam(':id', $devolucionId);
            $stmtProductos->execute();
            $productos = $stmtProductos->fetchAll(PDO::FETCH_ASSOC);

            // Revertir inventario (restar lo que se había sumado)
            foreach ($productos as $producto) {
                $queryRevertir = "UPDATE inventarios_repartidor
                                 SET cantidad = cantidad - :cantidad,
                                     updated_at = NOW()
                                 WHERE repartidor_id = :repartidor_id
                                   AND producto_id = :producto_id";

                $stmtRevertir = $conn->prepare($queryRevertir);
                $stmtRevertir->bindParam(':cantidad', $producto['cantidad']);
                $stmtRevertir->bindParam(':repartidor_id', $devolucion['repartidor_id']);
                $stmtRevertir->bindParam(':producto_id', $producto['producto_id']);
                $stmtRevertir->execute();

                // Registrar movimiento de cancelación
                $queryMovimiento = "INSERT INTO movimientos_inventario_repartidor (
                                       repartidor_id,
                                       producto_id,
                                       tipo_movimiento,
                                       cantidad,
                                       notas,
                                       created_at
                                   ) VALUES (
                                       :repartidor_id,
                                       :producto_id,
                                       'ajuste',
                                       :cantidad_negativa,
                                       :notas,
                                       NOW()
                                   )";

                $stmtMovimiento = $conn->prepare($queryMovimiento);
                $cantidadNegativa = -$producto['cantidad'];
                $stmtMovimiento->bindParam(':repartidor_id', $devolucion['repartidor_id']);
                $stmtMovimiento->bindParam(':producto_id', $producto['producto_id']);
                $stmtMovimiento->bindParam(':cantidad_negativa', $cantidadNegativa);
                $notasMovimiento = "Cancelación de devolución {$devolucion['folio']} - Motivo: $motivo";
                $stmtMovimiento->bindParam(':notas', $notasMovimiento);
                $stmtMovimiento->execute();
            }
        }

        // Actualizar estado a cancelada
        $queryUpdate = "UPDATE devoluciones
                       SET estado = 'cancelada',
                           notas = CONCAT(COALESCE(notas, ''), ' | CANCELADA: ', :motivo),
                           updated_at = NOW()
                       WHERE id = :id";

        $stmtUpdate = $conn->prepare($queryUpdate);
        $stmtUpdate->bindParam(':motivo', $motivo);
        $stmtUpdate->bindParam(':id', $devolucionId);
        $stmtUpdate->execute();

        $conn->commit();

        sendResponse(true, "Devolución cancelada exitosamente");

    } catch (Exception $e) {
        if ($conn->inTransaction()) {
            $conn->rollBack();
        }
        error_log("Error cancelando devolución: " . $e->getMessage());
        sendResponse(false, "Error cancelando devolución: " . $e->getMessage());
    }
}

// === OBTENER INVENTARIO DE DEVOLUCIONES ===
if ($tipo === 'getInventarioDevoluciones') {
    error_log("=== OBTENIENDO INVENTARIO DE DEVOLUCIONES ===");

    $repartidorId = null;

    // Intentar obtener repartidor_id del body primero (para llamadas desde admin web)
    if (isset($datapost['repartidor_id'])) {
        $repartidorId = (int)$datapost['repartidor_id'];
        error_log("Repartidor ID desde body: $repartidorId");
    } else {
        // Si no viene en el body, intentar obtener del token JWT (para llamadas desde app móvil)
        $authHeader = $_SERVER['HTTP_AUTHORIZATION'] ?? '';
        if (empty($authHeader)) {
            $headers = getallheaders();
            $authHeader = $headers['Authorization'] ?? '';
        }

        if (empty($authHeader)) {
            sendResponse(false, "Token de autenticación o repartidor_id requerido");
        }

        $token = str_replace('Bearer ', '', $authHeader);

        // Verificar token y obtener repartidor_id
        require_once __DIR__ . '/../../modelos/Auth.php';
        $auth = new Auth($conn);
        $payload = $auth->verificarJWT($token);

        if (!$payload) {
            sendResponse(false, "Token inválido o expirado");
        }

        $repartidorId = $payload['repartidor_id'] ?? null;
        if (!$repartidorId) {
            sendResponse(false, "Token no válido para repartidor");
        }
    }

    if (!$repartidorId) {
        sendResponse(false, "ID de repartidor no proporcionado");
    }

    try {
        // Obtener inventario de devoluciones del repartidor
        $query = "SELECT
                    id.id,
                    id.repartidor_id,
                    id.producto_id,
                    id.cantidad,
                    id.ultimo_motivo,
                    id.tipo_origen,
                    id.fecha_ultima_devolucion,
                    id.created_at,
                    id.updated_at,
                    p.codigo,
                    p.nombre,
                    p.descripcion,
                    p.precio,
                    p.unidad_medida,
                    p.imagen_url,
                    c.nombre as categoria_nombre
                  FROM inventarios_devoluciones_repartidor id
                  INNER JOIN productos p ON id.producto_id = p.id
                  LEFT JOIN categorias_productos c ON p.categoria_id = c.id
                  WHERE id.repartidor_id = :repartidor_id
                  ORDER BY
                    CASE
                        WHEN id.cantidad > 0 THEN 0
                        ELSE 1
                    END,
                    id.fecha_ultima_devolucion DESC,
                    p.nombre ASC";

        $stmt = $conn->prepare($query);
        $stmt->bindParam(':repartidor_id', $repartidorId, PDO::PARAM_INT);
        $stmt->execute();

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

        error_log("Inventario de devoluciones obtenido: " . count($inventarioDevoluciones) . " productos");

        // Calcular estadísticas
        $totalProductos = count($inventarioDevoluciones);
        $totalUnidades = 0;
        $valorTotal = 0;

        foreach ($inventarioDevoluciones as $item) {
            $totalUnidades += floatval($item['cantidad']);
            $valorTotal += floatval($item['cantidad']) * floatval($item['precio']);
        }

        $estadisticas = [
            'total_productos' => $totalProductos,
            'total_unidades' => $totalUnidades,
            'valor_total' => $valorTotal
        ];

        $respuesta = [
            'inventario' => $inventarioDevoluciones,
            'estadisticas' => $estadisticas
        ];

        sendResponse(true, "Inventario de devoluciones obtenido correctamente", $respuesta);

    } catch (Exception $e) {
        error_log("Error obteniendo inventario de devoluciones: " . $e->getMessage());
        sendResponse(false, "Error obteniendo inventario de devoluciones: " . $e->getMessage());
    }
}

// === RETIRAR INVENTARIO DE DEVOLUCIONES ===
if ($tipo === 'retirarInventarioDevoluciones') {
    error_log("=== RETIRAR INVENTARIO DE DEVOLUCIONES ===");

    $repartidorId = isset($datapost['repartidor_id']) ? (int)$datapost['repartidor_id'] : 0;
    $productos = isset($datapost['productos']) ? $datapost['productos'] : [];
    $accion = isset($datapost['accion']) ? $datapost['accion'] : 'descarte'; // descarte, devolver_almacen, otro
    $notas = isset($datapost['notas']) ? $datapost['notas'] : '';

    if ($repartidorId <= 0) {
        sendResponse(false, "ID de repartidor inválido");
    }

    if (empty($productos) || !is_array($productos)) {
        sendResponse(false, "Debe especificar al menos un producto");
    }

    try {
        $conn->beginTransaction();

        $productosRetirados = [];
        $totalRetirado = 0;

        foreach ($productos as $producto) {
            $productoId = (int)$producto['producto_id'];
            $cantidad = (float)$producto['cantidad'];

            if ($productoId <= 0 || $cantidad <= 0) {
                continue;
            }

            // Verificar que existe en inventario de devoluciones
            $queryVerificar = "SELECT cantidad FROM inventarios_devoluciones_repartidor
                              WHERE repartidor_id = :repartidor_id
                                AND producto_id = :producto_id";
            $stmtVerificar = $conn->prepare($queryVerificar);
            $stmtVerificar->bindParam(':repartidor_id', $repartidorId);
            $stmtVerificar->bindParam(':producto_id', $productoId);
            $stmtVerificar->execute();
            $inventario = $stmtVerificar->fetch(PDO::FETCH_ASSOC);

            if (!$inventario) {
                error_log("Producto ID=$productoId no existe en inventario de devoluciones del repartidor");
                continue;
            }

            $cantidadActual = (float)$inventario['cantidad'];

            // No permitir retirar más de lo que hay
            if ($cantidad > $cantidadActual) {
                $cantidad = $cantidadActual;
            }

            // Restar del inventario de devoluciones (puede quedar en 0)
            $queryRetirar = "UPDATE inventarios_devoluciones_repartidor
                            SET cantidad = cantidad - :cantidad,
                                updated_at = NOW()
                            WHERE repartidor_id = :repartidor_id
                              AND producto_id = :producto_id";
            $stmtRetirar = $conn->prepare($queryRetirar);
            $stmtRetirar->bindParam(':cantidad', $cantidad);
            $stmtRetirar->bindParam(':repartidor_id', $repartidorId);
            $stmtRetirar->bindParam(':producto_id', $productoId);
            $stmtRetirar->execute();

            // Si la acción es devolver_almacen, sumar al stock del almacén principal
            if ($accion === 'devolver_almacen') {
                // Obtener stock actual antes de actualizar
                $queryStockActual = "SELECT stock_actual FROM productos WHERE id = :producto_id";
                $stmtStockActual = $conn->prepare($queryStockActual);
                $stmtStockActual->bindParam(':producto_id', $productoId);
                $stmtStockActual->execute();
                $stockAnterior = (float)$stmtStockActual->fetchColumn();

                // Actualizar stock del almacén
                $queryDevolverAlmacen = "UPDATE productos
                                        SET stock_actual = stock_actual + :cantidad,
                                            updated_at = NOW()
                                        WHERE id = :producto_id";
                $stmtDevolverAlmacen = $conn->prepare($queryDevolverAlmacen);
                $stmtDevolverAlmacen->bindParam(':cantidad', $cantidad);
                $stmtDevolverAlmacen->bindParam(':producto_id', $productoId);
                $stmtDevolverAlmacen->execute();

                $stockNuevo = $stockAnterior + $cantidad;

                // Registrar movimiento en movimientos_stock del almacén
                // motivo_id 10 = "Devolución de repartidor" (entrada)
                $motivoId = 10;
                $motivoTexto = "Devolución desde repartidor ID: $repartidorId";
                if (!empty($notas)) {
                    $motivoTexto .= " - $notas";
                }

                $queryMovStock = "INSERT INTO movimientos_stock (
                                    producto_id,
                                    tipo_movimiento,
                                    cantidad,
                                    stock_anterior,
                                    stock_nuevo,
                                    motivo,
                                    motivo_id,
                                    created_at
                                ) VALUES (
                                    :producto_id,
                                    'entrada',
                                    :cantidad,
                                    :stock_anterior,
                                    :stock_nuevo,
                                    :motivo,
                                    :motivo_id,
                                    NOW()
                                )";
                $stmtMovStock = $conn->prepare($queryMovStock);
                $stmtMovStock->bindParam(':producto_id', $productoId);
                $stmtMovStock->bindParam(':cantidad', $cantidad);
                $stmtMovStock->bindParam(':stock_anterior', $stockAnterior);
                $stmtMovStock->bindParam(':stock_nuevo', $stockNuevo);
                $stmtMovStock->bindParam(':motivo', $motivoTexto);
                $stmtMovStock->bindParam(':motivo_id', $motivoId);
                $stmtMovStock->execute();

                error_log("Devuelto al almacén: Producto ID=$productoId, Cantidad=$cantidad, Stock: $stockAnterior -> $stockNuevo");
            }

            // Registrar movimiento
            $tipoMovimiento = 'retiro_devolucion';
            $notasMovimiento = "Retiro de inventario de devoluciones - Acción: $accion";
            if (!empty($notas)) {
                $notasMovimiento .= " - $notas";
            }

            $queryMovimiento = "INSERT INTO movimientos_inventario_repartidor (
                                   repartidor_id,
                                   producto_id,
                                   tipo_movimiento,
                                   cantidad,
                                   notas,
                                   created_at
                               ) VALUES (
                                   :repartidor_id,
                                   :producto_id,
                                   :tipo_movimiento,
                                   :cantidad,
                                   :notas,
                                   NOW()
                               )";
            $stmtMovimiento = $conn->prepare($queryMovimiento);
            $cantidadNegativa = -$cantidad; // Negativo porque es una salida
            $stmtMovimiento->bindParam(':repartidor_id', $repartidorId);
            $stmtMovimiento->bindParam(':producto_id', $productoId);
            $stmtMovimiento->bindParam(':tipo_movimiento', $tipoMovimiento);
            $stmtMovimiento->bindParam(':cantidad', $cantidadNegativa);
            $stmtMovimiento->bindParam(':notas', $notasMovimiento);
            $stmtMovimiento->execute();

            $productosRetirados[] = [
                'producto_id' => $productoId,
                'cantidad' => $cantidad
            ];
            $totalRetirado += $cantidad;

            error_log("Retirado del inventario de devoluciones: Producto ID=$productoId, Cantidad=$cantidad");
        }

        $conn->commit();

        $respuesta = [
            'productos_retirados' => $productosRetirados,
            'total_productos' => count($productosRetirados),
            'total_unidades' => $totalRetirado,
            'accion' => $accion
        ];

        sendResponse(true, "Inventario de devoluciones retirado correctamente", $respuesta);

    } catch (Exception $e) {
        if ($conn->inTransaction()) {
            $conn->rollBack();
        }
        error_log("Error retirando inventario de devoluciones: " . $e->getMessage());
        sendResponse(false, "Error retirando inventario de devoluciones: " . $e->getMessage());
    }
}
