Tul xxx Tul

Viewing: CajaDiariaController.php

<?php

namespace App\Http\Controllers;

use App\Models\CajaDiaria;
use App\Models\MovimientoCaja;
use App\Models\Venta;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\DB;
use Carbon\Carbon;

class CajaDiariaController extends Controller
{
    /**
     * Muestra la lista de cajas diarias
     */
    public function index(Request $request)
    {
        $query = CajaDiaria::query()->orderBy('fecha_apertura', 'desc');
        
        // Filtros
        if ($request->filled('fecha_desde')) {
            $query->whereDate('fecha_apertura', '>=', $request->fecha_desde);
        }
        
        if ($request->filled('fecha_hasta')) {
            $query->whereDate('fecha_apertura', '<=', $request->fecha_hasta);
        }
        
        if ($request->filled('estado')) {
            $query->where('estado', $request->estado);
        }
        
        $cajas = $query->paginate(15);
        
        return view('cajas.index', compact('cajas'));
    }

    /**
     * Muestra el formulario para abrir una nueva caja
     */
    public function create()
    {
        // Verificar si ya hay una caja abierta
        if (CajaDiaria::hayUnaAbierta()) {
            return redirect()->route('cajas.index')
                ->with('error', 'Ya existe una caja abierta. Debe cerrarla antes de abrir una nueva.');
        }
        
        return view('cajas.create');
    }

    /**
     * Almacena una nueva caja en la base de datos
     */
    public function store(Request $request)
    {
        // Validar datos
        $request->validate([
            'monto_apertura' => 'required|numeric|min:0',
            'turno' => 'required|in:mañana,tarde,noche',
            'nombre_cajero' => 'required|string|max:100',
            'observaciones' => 'nullable|string|max:500',
        ]);
        
        // Verificar si ya hay una caja abierta
        if (CajaDiaria::hayUnaAbierta()) {
            return redirect()->route('cajas.index')
                ->with('error', 'Ya existe una caja abierta. Debe cerrarla antes de abrir una nueva.');
        }
        
        // Crear la caja
        $caja = CajaDiaria::create([
            'fecha_apertura' => now(),
            'monto_apertura' => $request->monto_apertura,
            'turno' => $request->turno,
            'nombre_cajero' => $request->nombre_cajero,
            'observaciones' => $request->observaciones,
            'estado' => 'abierta',
            'created_by' => Auth::id(),
            'updated_by' => Auth::id(),
        ]);
        
        // Registrar el movimiento de apertura
        MovimientoCaja::create([
            'caja_id' => $caja->id,
            'fecha' => now(),
            'tipo' => 'ingreso',
            'concepto' => 'Apertura de caja - Turno ' . ucfirst($request->turno),
            'monto' => $request->monto_apertura,
            'metodo_pago' => 'efectivo',
            'observaciones' => 'Cajero: ' . $request->nombre_cajero,
            'created_by' => Auth::id(),
            'updated_by' => Auth::id(),
        ]);
        
        return redirect()->route('cajas.show', $caja)
            ->with('success', 'Caja del turno ' . ucfirst($request->turno) . ' abierta correctamente. Cajero: ' . $request->nombre_cajero);
    }

    /**
     * Muestra los detalles de una caja específica
     */
    public function show(CajaDiaria $caja)
    {
        // Cargar relaciones
        $caja->load(['movimientos', 'creadoPor', 'ventas']);
        
        // ===== VENTAS (tabla ventas) - Solo para mostrar desglose =====
        $ventasTotal = $caja->ventas()->sum('total');
        $ventasEfectivo = $caja->ventas()->where('metodo_pago', 'efectivo')->sum('total');
        $ventasTransferencia = $caja->ventas()->where('metodo_pago', 'transferencia')->sum('total');
        $ventasTarjeta = $caja->ventas()->where('metodo_pago', 'tarjeta')->sum('total');
        
        // ===== CALCULOS USANDO METODOS DEL MODELO (fuente única de verdad) =====
        $totalVentas = $caja->calcularTotalVentas();
        $totalGastos = $caja->calcularTotalGastos();
        $totalPagos = $caja->calcularTotalPagos();
        
        // Retiros y consignaciones
        $retiros = $caja->movimientos()->where('tipo', 'retiro')->get();
        $consignaciones = $caja->movimientos()->where('tipo', 'consignacion')->get();
        $totalRetiros = $retiros->sum('monto');
        $totalConsignaciones = $consignaciones->sum('monto');
        
        // ===== EFECTIVO EN CAJA (usando resumen por método de pago) =====
        // El resumen por método viene de movimientos_caja que es la fuente correcta
        $resumenPorMetodo = $caja->getResumenPorMetodoPago();
        
        // Extraer totales por método
        $totalEfectivoEntrada = $resumenPorMetodo->where('metodo_pago', 'efectivo')->sum('total');
        $totalTransferencias = $resumenPorMetodo->where('metodo_pago', 'transferencia')->sum('total');
        
        // Todo el efectivo que SALE de la caja física
        $totalEfectivoSalida = $totalGastos + $totalPagos + $totalRetiros + $totalConsignaciones;
        
        // SALDO DE EFECTIVO EN CAJA
        $saldoActual = $caja->monto_apertura + $totalEfectivoEntrada - $totalEfectivoSalida;
        
        // ===== DATOS PARA LA VISTA =====
        // Ingresos de compraventa separados
        $ingresosCompraventa = $caja->calcularIngresosCompraventa();
        $ventasSinCompraventa = $ventasTotal;
        
        // Anticipos de hotel (total de movimientos_caja)
        $anticiposHotel = $caja->calcularAnticiposHotel();
        
        // Detalle de anticipos - obtener IDs de movimientos de anticipos de esta caja
        $anticiposIds = $caja->movimientos()
            ->where('tipo', 'ingreso')
            ->whereIn('referencia_tipo', ['hotel_anticipo', 'hotel_anticipo_reserva'])
            ->pluck('referencia_id')
            ->toArray();
        
        // Obtener detalles de HotelAnticipo que corresponden a esta caja
        $anticiposHotelDetalle = \App\Models\HotelAnticipo::with(['ocupacion.habitacion', 'ocupacion.cliente'])
            ->whereIn('id', $anticiposIds)
            ->orderBy('created_at', 'desc')
            ->get();
        
        $anticiposHotelEfectivo = $anticiposHotelDetalle->where('metodo_pago', 'efectivo')->sum('monto');
        $anticiposHotelTransferencia = $anticiposHotelDetalle->where('metodo_pago', 'transferencia')->sum('monto');
        
        $anticiposReservasDetalle = $caja->movimientos()
            ->where('tipo', 'ingreso')
            ->where('referencia_tipo', 'hotel_anticipo_reserva')
            ->get();
        
        // Movimientos agrupados por tipo
        $ingresos = $caja->movimientos()->where('tipo', 'ingreso')->get();
        $gastos = $caja->movimientos()->where('tipo', 'gasto')->get();
        $pagos = $caja->movimientos()->where('tipo', 'pago')->get();
        
        // Ingresos de compraventa específicos
        $ingresosCompraventaDetalle = $caja->movimientos()
            ->where('tipo', 'ingreso')
            ->where('referencia_tipo', 'App\\Models\\Prestamo')
            ->get();
        
        // Resumen por método de pago
        $resumenPorMetodo = $caja->getResumenPorMetodoPago();
        
        // Resumen por banco (transferencias con banco especificado)
        $resumenPorBanco = $caja->getResumenPorBanco();
        
        // Transferencias separadas: anticipos vs ventas
        $transferenciasAnticipos = $caja->getTransferenciasAnticipos();
        $transferenciasVentas = $caja->getTransferenciasVentas();
        
        // Anticipos en efectivo (para mostrar en el cálculo)
        $anticiposEfectivo = $caja->getAnticiposEfectivo();
        
        // Saldo histórico de bancos (solo para administradores nivel 3-4)
        $saldoHistoricoBancos = null;
        $saldoPorBancoHistorico = null;
        if (auth()->user()->tieneNivelMinimo(3)) {
            $saldoHistoricoBancos = CajaDiaria::getSaldoHistoricoBancos();
            $saldoPorBancoHistorico = CajaDiaria::getSaldoPorBancoHistorico();
        }
        
        return view('cajas.show', compact(
            'caja', 'totalVentas', 'totalGastos', 'totalPagos', 'saldoActual', 
            'ingresos', 'gastos', 'pagos', 'retiros', 'consignaciones',
            'ingresosCompraventa', 'ventasSinCompraventa',
            'ingresosCompraventaDetalle', 'anticiposHotel', 'anticiposHotelDetalle', 'anticiposReservasDetalle',
            'resumenPorMetodo', 'resumenPorBanco', 'totalRetiros', 'totalConsignaciones',
            'ventasEfectivo', 'ventasTransferencia', 'ventasTarjeta',
            'anticiposHotelEfectivo', 'anticiposHotelTransferencia',
            'totalEfectivoEntrada', 'totalEfectivoSalida', 'totalTransferencias',
            'transferenciasAnticipos', 'transferenciasVentas', 'anticiposEfectivo',
            'saldoHistoricoBancos', 'saldoPorBancoHistorico'
        ));
    }

    /**
     * Muestra el formulario para cerrar una caja
     */
    public function edit(CajaDiaria $caja)
    {
        // Verificar si la caja está abierta
        if (!$caja->estaAbierta()) {
            return redirect()->route('cajas.show', $caja)
                ->with('error', 'Esta caja ya está cerrada.');
        }
        
        // Calcular totales
        $totalVentas = $caja->calcularTotalVentas();
        $totalGastos = $caja->calcularTotalGastos();
        $totalPagos = $caja->calcularTotalPagos();
        
        // Calcular saldo teórico
        $saldoTeorico = $caja->monto_apertura + $totalVentas - $totalGastos - $totalPagos;
        
        return view('cajas.edit', compact('caja', 'totalVentas', 'totalGastos', 'totalPagos', 'saldoTeorico'));
    }

    /**
     * Cierra una caja
     */
    public function update(Request $request, CajaDiaria $caja)
    {
        // Validar datos
        $request->validate([
            'monto_cierre' => 'required|numeric|min:0',
            'observaciones' => 'nullable|string|max:500',
        ]);
        
        // Verificar si la caja está abierta
        if (!$caja->estaAbierta()) {
            return redirect()->route('cajas.show', $caja)
                ->with('error', 'Esta caja ya está cerrada.');
        }
        
        // Calcular totales
        $totalVentas = $caja->calcularTotalVentas();
        $totalGastos = $caja->calcularTotalGastos();
        $totalPagos = $caja->calcularTotalPagos();
        
        // Calcular saldo teórico y diferencia
        $saldoTeorico = $caja->monto_apertura + $totalVentas - $totalGastos - $totalPagos;
        $diferencia = $request->monto_cierre - $saldoTeorico;
        
        // Actualizar la caja
        $caja->update([
            'fecha_cierre' => now(),
            'monto_cierre' => $request->monto_cierre,
            'total_ventas' => $totalVentas,
            'total_gastos' => $totalGastos,
            'total_pagos' => $totalPagos,
            'diferencia' => $diferencia,
            'observaciones' => $request->observaciones,
            'estado' => 'cerrada',
            'updated_by' => Auth::id(),
        ]);
        
        return redirect()->route('cajas.show', $caja)
            ->with('success', 'Caja cerrada correctamente.');
    }

    /**
     * Muestra el formulario para registrar un nuevo movimiento
     */
    public function createMovimiento()
    {
        // Verificar si hay una caja abierta
        $caja = CajaDiaria::obtenerCajaAbierta();
        
        if (!$caja) {
            return redirect()->route('cajas.index')
                ->with('error', 'No hay ninguna caja abierta. Debe abrir una caja antes de registrar movimientos.');
        }
        
        return view('cajas.movimientos.create', compact('caja'));
    }

    /**
     * Almacena un nuevo movimiento en la base de datos
     */
    public function storeMovimiento(Request $request)
    {
        // Validar datos
        $request->validate([
            'tipo' => 'required|in:ingreso,gasto,pago,retiro,consignacion',
            'concepto' => 'required|string|max:255',
            'monto' => 'required|numeric|min:0.01',
            'metodo_pago' => 'required|string|max:50',
            'banco' => 'nullable|string|max:100',
            'numero_referencia' => 'nullable|string|max:100',
            'observaciones' => 'nullable|string|max:500',
        ]);
        
        // Verificar si hay una caja abierta
        $caja = CajaDiaria::obtenerCajaAbierta();
        
        if (!$caja) {
            return redirect()->route('cajas.index')
                ->with('error', 'No hay ninguna caja abierta. Debe abrir una caja antes de registrar movimientos.');
        }
        
        // Crear el movimiento
        $movimiento = MovimientoCaja::create([
            'caja_id' => $caja->id,
            'fecha' => now(),
            'tipo' => $request->tipo,
            'concepto' => $request->concepto,
            'monto' => $request->monto,
            'metodo_pago' => $request->metodo_pago,
            'banco' => $request->banco,
            'numero_referencia' => $request->numero_referencia,
            'observaciones' => $request->observaciones,
            'created_by' => Auth::id(),
            'updated_by' => Auth::id(),
        ]);
        
        return redirect()->route('cajas.show', $caja)
            ->with('success', 'Movimiento registrado correctamente.');
    }

    /**
     * Registrar un retiro de caja
     */
    public function storeRetiro(Request $request)
    {
        $request->validate([
            'monto' => 'required|numeric|min:0.01',
            'concepto' => 'required|string|max:255',
            'observaciones' => 'nullable|string|max:500',
        ]);
        
        $caja = CajaDiaria::obtenerCajaAbierta();
        
        if (!$caja) {
            if ($request->ajax()) {
                return response()->json(['success' => false, 'message' => 'No hay caja abierta'], 400);
            }
            return redirect()->route('cajas.index')->with('error', 'No hay ninguna caja abierta.');
        }
        
        $movimiento = MovimientoCaja::create([
            'caja_id' => $caja->id,
            'fecha' => now(),
            'tipo' => 'retiro',
            'concepto' => $request->concepto,
            'monto' => $request->monto,
            'metodo_pago' => 'efectivo',
            'observaciones' => $request->observaciones,
            'created_by' => Auth::id(),
            'updated_by' => Auth::id(),
        ]);
        
        if ($request->ajax()) {
            return response()->json([
                'success' => true,
                'message' => 'Retiro registrado correctamente',
                'movimiento' => $movimiento
            ]);
        }
        
        return redirect()->route('cajas.show', $caja)->with('success', 'Retiro registrado correctamente.');
    }

    /**
     * Registrar una consignación bancaria
     */
    public function storeConsignacion(Request $request)
    {
        $request->validate([
            'monto' => 'required|numeric|min:0.01',
            'banco' => 'required|string|max:100',
            'numero_cuenta' => 'required|string|max:50',
            'numero_referencia' => 'required|string|max:100',
            'observaciones' => 'nullable|string|max:500',
        ]);
        
        $caja = CajaDiaria::obtenerCajaAbierta();
        
        if (!$caja) {
            if ($request->ajax()) {
                return response()->json(['success' => false, 'message' => 'No hay caja abierta'], 400);
            }
            return redirect()->route('cajas.index')->with('error', 'No hay ninguna caja abierta.');
        }
        
        $movimiento = MovimientoCaja::create([
            'caja_id' => $caja->id,
            'fecha' => now(),
            'tipo' => 'consignacion',
            'concepto' => 'Consignación a ' . $request->banco . ' - Cuenta: ' . $request->numero_cuenta,
            'monto' => $request->monto,
            'metodo_pago' => 'efectivo',
            'banco' => $request->banco,
            'numero_referencia' => $request->numero_referencia,
            'observaciones' => 'Cuenta: ' . $request->numero_cuenta . ($request->observaciones ? ' | ' . $request->observaciones : ''),
            'created_by' => Auth::id(),
            'updated_by' => Auth::id(),
        ]);
        
        if ($request->ajax()) {
            return response()->json([
                'success' => true,
                'message' => 'Consignación registrada correctamente',
                'movimiento' => $movimiento
            ]);
        }
        
        return redirect()->route('cajas.show', $caja)->with('success', 'Consignación registrada correctamente.');
    }

    /**
     * Genera un reporte de la caja
     */
    public function reporte(CajaDiaria $caja)
    {
        // Cargar relaciones
        $caja->load(['movimientos', 'creadoPor', 'ventas']);
        
        // Calcular totales
        $totalVentas = $caja->calcularTotalVentas();
        $totalGastos = $caja->calcularTotalGastos();
        $totalPagos = $caja->calcularTotalPagos();
        
        // Calcular saldo actual
        $saldoActual = $caja->monto_apertura + $totalVentas - $totalGastos - $totalPagos;
        
        // Obtener movimientos agrupados por tipo
        $ingresos = $caja->movimientos()->where('tipo', 'ingreso')->get();
        $gastos = $caja->movimientos()->where('tipo', 'gasto')->get();
        $pagos = $caja->movimientos()->where('tipo', 'pago')->get();
        
        return view('cajas.reporte', compact('caja', 'totalVentas', 'totalGastos', 'totalPagos', 'saldoActual', 'ingresos', 'gastos', 'pagos'));
    }

    /**
     * Muestra el estado actual de la caja
     */
    public function estadoActual()
    {
        // Verificar si hay una caja abierta
        $caja = CajaDiaria::obtenerCajaAbierta();
        
        if (!$caja) {
            return redirect()->route('cajas.index')
                ->with('error', 'No hay ninguna caja abierta actualmente.');
        }
        
        return redirect()->route('cajas.show', $caja);
    }

    /**
     * Reporte de productos vendidos
     */
    public function reporteProductos(CajaDiaria $caja)
    {
        $caja->load(['ventas.detalles.producto']);
        
        // Agrupar productos vendidos
        $productosVendidos = collect();
        foreach ($caja->ventas as $venta) {
            foreach ($venta->detalles as $detalle) {
                $key = $detalle->producto_id;
                if ($productosVendidos->has($key)) {
                    $item = $productosVendidos->get($key);
                    $item['cantidad'] += $detalle->cantidad;
                    $item['subtotal'] += $detalle->subtotal;
                    $productosVendidos->put($key, $item);
                } else {
                    $productosVendidos->put($key, [
                        'codigo' => $detalle->producto->codigo ?? '',
                        'nombre' => $detalle->producto->nombre ?? 'Producto eliminado',
                        'cantidad' => $detalle->cantidad,
                        'precio_unitario' => $detalle->precio_unitario,
                        'subtotal' => $detalle->subtotal,
                    ]);
                }
            }
        }
        
        $productosVendidos = $productosVendidos->sortByDesc('subtotal')->values();
        $totalProductos = $productosVendidos->sum('subtotal');
        
        $empresa = \App\Models\Empresa::first();
        
        return view('cajas.reportes.productos', compact('caja', 'productosVendidos', 'totalProductos', 'empresa'));
    }

    /**
     * Reporte de cuadre de caja completo
     */
    public function reporteCuadre(CajaDiaria $caja)
    {
        $caja->load(['movimientos', 'creadoPor', 'ventas']);
        
        $totalVentas = $caja->calcularTotalVentas();
        $totalGastos = $caja->calcularTotalGastos();
        $totalPagos = $caja->calcularTotalPagos();
        $ingresosCompraventa = $caja->calcularIngresosCompraventa();
        $anticiposHotel = $caja->calcularAnticiposHotel();
        $ventasSinCompraventa = $caja->ventas()->sum('total');
        
        $saldoActual = $caja->monto_apertura + $totalVentas - $totalGastos - $totalPagos;
        
        $ingresos = $caja->movimientos()->where('tipo', 'ingreso')->get();
        $gastos = $caja->movimientos()->where('tipo', 'gasto')->get();
        $pagos = $caja->movimientos()->where('tipo', 'pago')->get();
        
        $empresa = \App\Models\Empresa::first();
        
        return view('cajas.reportes.cuadre', compact(
            'caja', 'totalVentas', 'totalGastos', 'totalPagos', 'saldoActual',
            'ingresos', 'gastos', 'pagos', 'ingresosCompraventa', 'anticiposHotel',
            'ventasSinCompraventa', 'empresa'
        ));
    }

    /**
     * Reporte de anticipos de hotel
     */
    public function reporteAnticipos(CajaDiaria $caja)
    {
        $fechaCaja = $caja->fecha_apertura->toDateString();
        
        // Anticipos de check-in
        $anticiposHotelDetalle = \App\Models\HotelAnticipo::with(['ocupacion.habitacion', 'ocupacion.cliente'])
            ->whereDate('created_at', $fechaCaja)
            ->orderBy('created_at', 'desc')
            ->get();
        
        // Anticipos de reservas
        $anticiposReservasDetalle = $caja->movimientos()
            ->where('tipo', 'ingreso')
            ->where('referencia_tipo', 'hotel_anticipo_reserva')
            ->get();
        
        $totalAnticipos = $anticiposHotelDetalle->sum('monto') + $anticiposReservasDetalle->sum('monto');
        
        // Agrupar por método de pago (combinando ambos tipos)
        $todosAnticipos = collect();
        foreach ($anticiposHotelDetalle as $a) {
            $todosAnticipos->push(['metodo_pago' => $a->metodo_pago ?? 'efectivo', 'monto' => $a->monto, 'tipo' => 'checkin']);
        }
        foreach ($anticiposReservasDetalle as $a) {
            $todosAnticipos->push(['metodo_pago' => $a->metodo_pago ?? 'efectivo', 'monto' => $a->monto, 'tipo' => 'reserva']);
        }
        
        $anticiposPorMetodo = $todosAnticipos->groupBy('metodo_pago')->map(function($items) {
            return [
                'cantidad' => $items->count(),
                'total' => $items->sum('monto')
            ];
        });
        
        $empresa = \App\Models\Empresa::first();
        
        return view('cajas.reportes.anticipos', compact('caja', 'anticiposHotelDetalle', 'anticiposReservasDetalle', 'totalAnticipos', 'anticiposPorMetodo', 'empresa'));
    }

    /**
     * Reporte general agrupado
     */
    public function reporteGeneral(CajaDiaria $caja)
    {
        $caja->load(['movimientos', 'creadoPor', 'ventas.detalles.producto']);
        
        // Totales
        $totalVentas = $caja->calcularTotalVentas();
        $totalGastos = $caja->calcularTotalGastos();
        $totalPagos = $caja->calcularTotalPagos();
        $ingresosCompraventa = $caja->calcularIngresosCompraventa();
        $anticiposHotel = $caja->calcularAnticiposHotel();
        $ventasSinCompraventa = $caja->ventas()->sum('total');
        $saldoActual = $caja->monto_apertura + $totalVentas - $totalGastos - $totalPagos;
        
        // Ventas por método de pago
        $ventasPorMetodo = $caja->ventas->groupBy('metodo_pago')->map(function($items) {
            return [
                'cantidad' => $items->count(),
                'total' => $items->sum('total')
            ];
        });
        
        // Top 10 productos más vendidos
        $productosVendidos = collect();
        foreach ($caja->ventas as $venta) {
            foreach ($venta->detalles as $detalle) {
                $key = $detalle->producto_id;
                if ($productosVendidos->has($key)) {
                    $item = $productosVendidos->get($key);
                    $item['cantidad'] += $detalle->cantidad;
                    $item['subtotal'] += $detalle->subtotal;
                    $productosVendidos->put($key, $item);
                } else {
                    $productosVendidos->put($key, [
                        'nombre' => $detalle->producto->nombre ?? 'Producto eliminado',
                        'cantidad' => $detalle->cantidad,
                        'subtotal' => $detalle->subtotal,
                    ]);
                }
            }
        }
        $topProductos = $productosVendidos->sortByDesc('subtotal')->take(10)->values();
        
        // Anticipos del día
        $fechaCaja = $caja->fecha_apertura->toDateString();
        $anticiposDetalle = \App\Models\HotelAnticipo::whereDate('created_at', $fechaCaja)->get();
        
        // Movimientos agrupados
        $ingresos = $caja->movimientos()->where('tipo', 'ingreso')->get();
        $gastos = $caja->movimientos()->where('tipo', 'gasto')->get();
        $pagos = $caja->movimientos()->where('tipo', 'pago')->get();
        
        $empresa = \App\Models\Empresa::first();
        
        return view('cajas.reportes.general', compact(
            'caja', 'totalVentas', 'totalGastos', 'totalPagos', 'saldoActual',
            'ingresosCompraventa', 'anticiposHotel', 'ventasSinCompraventa',
            'ventasPorMetodo', 'topProductos', 'anticiposDetalle',
            'ingresos', 'gastos', 'pagos', 'empresa'
        ));
    }
    
    /**
     * Reporte de conciliación histórica (Solo nivel 3+)
     */
    public function conciliacionHistorica(Request $request)
    {
        // Solo nivel 3+ puede ver este reporte
        if (!auth()->user()->tieneNivelMinimo(3)) {
            return redirect()->route('cajas.index')
                ->with('error', 'No tiene permisos para ver este reporte.');
        }
        
        $empresa = \App\Models\Empresa::first();
        
        // Filtros de fecha
        $fechaInicio = $request->fecha_inicio ? Carbon::parse($request->fecha_inicio) : Carbon::now()->startOfMonth();
        $fechaFin = $request->fecha_fin ? Carbon::parse($request->fecha_fin) : Carbon::now();
        
        // Total ventas históricas
        $totalVentasHistorico = Venta::whereBetween('created_at', [$fechaInicio->startOfDay(), $fechaFin->endOfDay()])
            ->sum('total');
        
        // Ventas por método de pago
        $ventasPorMetodo = Venta::whereBetween('created_at', [$fechaInicio->startOfDay(), $fechaFin->endOfDay()])
            ->selectRaw('metodo_pago, SUM(total) as total, COUNT(*) as cantidad')
            ->groupBy('metodo_pago')
            ->get();
        
        // Total consignaciones históricas
        $totalConsignaciones = MovimientoCaja::where('tipo', 'consignacion')
            ->whereBetween('created_at', [$fechaInicio->startOfDay(), $fechaFin->endOfDay()])
            ->sum('monto');
        
        // Consignaciones por banco
        $consignacionesPorBanco = MovimientoCaja::where('tipo', 'consignacion')
            ->whereBetween('created_at', [$fechaInicio->startOfDay(), $fechaFin->endOfDay()])
            ->selectRaw('banco, SUM(monto) as total, COUNT(*) as cantidad')
            ->groupBy('banco')
            ->get();
        
        // Total transferencias recibidas (anticipos + ventas)
        $totalTransferenciasAnticipos = MovimientoCaja::where('tipo', 'ingreso')
            ->where('metodo_pago', 'transferencia')
            ->whereIn('referencia_tipo', ['hotel_anticipo', 'hotel_anticipo_reserva'])
            ->whereBetween('created_at', [$fechaInicio->startOfDay(), $fechaFin->endOfDay()])
            ->sum('monto');
        
        $totalTransferenciasVentas = Venta::where('metodo_pago', 'transferencia')
            ->whereBetween('created_at', [$fechaInicio->startOfDay(), $fechaFin->endOfDay()])
            ->sum('total');
        
        // Total retiros
        $totalRetiros = MovimientoCaja::where('tipo', 'retiro')
            ->whereBetween('created_at', [$fechaInicio->startOfDay(), $fechaFin->endOfDay()])
            ->sum('monto');
        
        // Total gastos y pagos
        $totalGastos = MovimientoCaja::where('tipo', 'gasto')
            ->whereBetween('created_at', [$fechaInicio->startOfDay(), $fechaFin->endOfDay()])
            ->sum('monto');
        
        $totalPagos = MovimientoCaja::where('tipo', 'pago')
            ->whereBetween('created_at', [$fechaInicio->startOfDay(), $fechaFin->endOfDay()])
            ->sum('monto');
        
        // Cajas del período
        $cajas = CajaDiaria::whereBetween('fecha_apertura', [$fechaInicio->startOfDay(), $fechaFin->endOfDay()])
            ->with('creadoPor')
            ->orderBy('fecha_apertura', 'desc')
            ->get();
        
        // Resumen de cajas
        $cajasAbiertas = $cajas->where('estado', 'abierta')->count();
        $cajasCerradas = $cajas->where('estado', 'cerrada')->count();
        $totalDiferencias = $cajas->sum('diferencia');
        
        // Cálculos de conciliación
        $totalEnBancos = $totalConsignaciones + $totalTransferenciasAnticipos + $totalTransferenciasVentas;
        $totalEfectivoEntradas = $totalVentasHistorico - $totalTransferenciasVentas;
        $totalEfectivoSalidas = $totalGastos + $totalPagos + $totalRetiros + $totalConsignaciones;
        $efectivoNeto = $totalEfectivoEntradas - $totalEfectivoSalidas;
        
        // Si se solicita PDF
        if ($request->has('pdf')) {
            $pdf = \Barryvdh\DomPDF\Facade\Pdf::loadView('cajas.reportes.conciliacion_pdf', compact(
                'empresa', 'fechaInicio', 'fechaFin',
                'totalVentasHistorico', 'ventasPorMetodo',
                'totalConsignaciones', 'consignacionesPorBanco',
                'totalTransferenciasAnticipos', 'totalTransferenciasVentas',
                'totalRetiros', 'totalGastos', 'totalPagos',
                'cajas', 'cajasAbiertas', 'cajasCerradas', 'totalDiferencias',
                'totalEnBancos', 'totalEfectivoEntradas', 'totalEfectivoSalidas', 'efectivoNeto'
            ));
            
            $pdf->setPaper('letter', 'portrait');
            
            return $pdf->stream('conciliacion_' . $fechaInicio->format('Y-m-d') . '_' . $fechaFin->format('Y-m-d') . '.pdf');
        }
        
        return view('cajas.reportes.conciliacion', compact(
            'empresa', 'fechaInicio', 'fechaFin',
            'totalVentasHistorico', 'ventasPorMetodo',
            'totalConsignaciones', 'consignacionesPorBanco',
            'totalTransferenciasAnticipos', 'totalTransferenciasVentas',
            'totalRetiros', 'totalGastos', 'totalPagos',
            'cajas', 'cajasAbiertas', 'cajasCerradas', 'totalDiferencias',
            'totalEnBancos', 'totalEfectivoEntradas', 'totalEfectivoSalidas', 'efectivoNeto'
        ));
    }
}
User / IP	: 216.73.216.146
Host / Server	: 45.84.207.204 / aircan.me
System	: Linux lt-bnk-web1726.main-hosting.eu 5.14.0-611.36.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Tue Mar 3 11:23:52 EST 2026 x86_64