<?php

namespace App\Http\Controllers;

use App\Models\CierreTurno;
use App\Models\Diferencia;
use App\Models\Estacion;
use App\Models\Manguera;
use App\Models\PrecioDia;
use App\Models\RegistroSalida;
use App\Models\TipoCombustible;
use App\Models\Turno;
use App\Models\User;
use Carbon\Carbon;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;

class CierresTurnoController extends Controller
{
    public function index()
    {
        $items = CierreTurno::with(['usuario', 'turno'])->orderBy('id_cierre')->get();
        return view('cierres_turno.index', compact('items'));
    }

    public function create()
    {
        $usuarios = User::orderBy('id_usuario')->get();
        $turnos = Turno::orderBy('id_turno')->get();
        $items = PrecioDia::with('tipoCombustible')
            ->orderBy('fecha', 'desc')
            ->orderBy('id', 'desc')
            ->get();

        $idUsuario = auth()->id();
        $fecha = date('Y-m-d');
        $idTurno = request('id_turno');

        $totalVentasCalculado = 0.0;
        $ventasPorCombustible = [
            'diesel' => 0.0,
            'premium' => 0.0,
            'regular' => 0.0,
        ];

        if ($idUsuario && $idTurno) {
            $resumen = $this->calcularResumenVentasTurno((int)$idUsuario, (int)$idTurno, $fecha);
            $totalVentasCalculado = $resumen['total'];
            $ventasPorCombustible = $resumen['combustibles'];
        }

        return view('cierres_turno.create', compact('usuarios', 'turnos', 'items', 'totalVentasCalculado', 'ventasPorCombustible'));
    }

    public function cuadreCaja()
    {
        $usuarios = User::orderBy('id_usuario')->get();
        $turnos = Turno::orderBy('id_turno')->get();
        $tipos = TipoCombustible::orderBy('nombre')->get();
        $islas = Estacion::with(['caras.mangueras.tipoCombustible'])
            ->where('estado', 1)
            ->orderBy('id_estacion')
            ->get();

        if ($islas->isEmpty()) {
            $islas = collect([
                (object) [
                    'id_estacion' => 0,
                    'nombre' => 'Isla 1',
                    'caras' => collect([
                        (object) [
                            'id_cara' => 0,
                            'nombre' => 'Lado 1',
                            'mangueras' => Manguera::with('tipoCombustible')->orderBy('id_manguera')->get(),
                        ],
                    ]),
                ],
            ]);
        }

        $canEdit = true;
        $diferencias = collect();

        return view('cierres_turno.cuadre_caja', compact('usuarios', 'turnos', 'tipos', 'islas', 'canEdit', 'diferencias'));
    }

    public function listaCuadres()
    {
        $cuadres = DB::table('registros_salidas as rs')
            ->select(
                'rs.fecha_inicio',
                'rs.id_turno',
                'rs.id_usuario',
                DB::raw('MAX(rs.id_salida) as ultimo_registro'),
                't.turnos',
                'u.nombres',
                'u.apellidos',
                'u.usuario'
            )
            ->where('rs.observaciones', 'Cuadre de Caja')
            ->join('turnos as t', 't.id_turno', '=', 'rs.id_turno')
            ->join('usuarios as u', 'u.id_usuario', '=', 'rs.id_usuario')
            ->groupBy('rs.fecha_inicio', 'rs.id_turno', 'rs.id_usuario', 't.turnos', 'u.nombres', 'u.apellidos', 'u.usuario')
            ->orderByDesc('ultimo_registro')
            ->orderByDesc('rs.fecha_inicio')
            ->orderBy('t.turnos')
            ->get()
            ->map(function ($item) {
                return [
                    'fecha' => Carbon::parse($item->fecha_inicio)->format('Y-m-d'),
                    'turno' => $item->turnos ?? null,
                    'usuario' => trim(($item->nombres ?? '') . ' ' . ($item->apellidos ?? '') . ' ' . ($item->usuario ?? '')),
                    'id_turno' => (int) $item->id_turno,
                    'id_usuario' => (int) $item->id_usuario,
                ];
            });

        return view('cierres_turno.lista_cuadres', compact('cuadres'));
    }

    public function verCuadre(string $fecha, int $idTurno, int $idUsuario)
    {
        $usuarios = User::orderBy('id_usuario')->get();
        $turnos = Turno::orderBy('id_turno')->get();
        $tipos = TipoCombustible::orderBy('nombre')->get();
        $mediciones = RegistroSalida::where('observaciones', 'Cuadre de Caja')
            ->whereDate('fecha_inicio', $fecha)
            ->where('id_turno', $idTurno)
            ->where('id_usuario', $idUsuario)
            ->get()
            ->mapWithKeys(fn ($registro) => [ (int) $registro->id_manguera => (string) number_format((float) ($registro->saldo_final ?? 0), 3, '.', '') ])
            ->toArray();

        $islas = Estacion::with(['caras.mangueras.tipoCombustible'])
            ->where('estado', 1)
            ->orderBy('id_estacion')
            ->get();

        if ($islas->isEmpty()) {
            $islas = collect([
                (object) [
                    'id_estacion' => 0,
                    'nombre' => 'Isla 1',
                    'caras' => collect([
                        (object) [
                            'id_cara' => 0,
                            'nombre' => 'Lado 1',
                            'mangueras' => Manguera::with('tipoCombustible')->orderBy('id_manguera')->get(),
                        ],
                    ]),
                ],
            ]);
        }

        $cierre = CierreTurno::query()
            ->where('id_usuario', $idUsuario)
            ->where('id_turno', $idTurno)
            ->whereDate('fecha', $fecha)
            ->first();

        $resumen = $this->calcularResumenVentasTurno($idUsuario, $idTurno, $fecha);
        $totalVentasCalculado = $cierre->total_ventas ?? $resumen['total'] ?? 0;

        $diferencias = Diferencia::query()
            ->where('id_turno', $idTurno)
            ->where('id_usuario', $idUsuario)
            ->whereDate('created_at', $fecha)
            ->get();

        $canEdit = strtoupper((string) auth()->user()?->rol) === 'ADMIN';

        return view('cierres_turno.cuadre_caja', compact('usuarios', 'turnos', 'tipos', 'islas', 'fecha', 'idTurno', 'idUsuario', 'mediciones', 'canEdit', 'cierre', 'totalVentasCalculado', 'diferencias'));
    }

    public function storeCuadreCaja(Request $request)
    {
        $data = $request->validate([
            'id_usuario' => 'required|integer',
            'id_turno' => 'required|integer',
            'fecha' => 'required|date',
            'mediciones' => 'nullable|array',
            'total_ventas' => 'nullable|numeric',
            'efectivo' => 'nullable|numeric',
            'credito' => 'nullable|numeric',
            'visa' => 'nullable|numeric',
            'descuentos' => 'nullable|numeric',
            'diferencias' => 'nullable|array',
            'diferencias.*.id_tipo_combustible' => 'nullable|integer|exists:tipos_combustible,id_tipo_combustible',
            'diferencias.*.cantidad_galones' => 'nullable|numeric|min:0',
            'diferencias.*.precio' => 'nullable|numeric|min:0',
            'diferencias.*.total' => 'nullable|numeric|min:0',
            'diferencias.*.observacion' => 'nullable|string|max:1000',
        ]);

        $idUsuario = (int) $data['id_usuario'];
        $idTurno = (int) $data['id_turno'];
        $fecha = $data['fecha'];
        $mediciones = is_array($data['mediciones'] ?? null) ? $data['mediciones'] : [];

        $medicionesValidas = [];
        foreach ($mediciones as $idManguera => $valor) {
            if ($valor === null || $valor === '') {
                continue;
            }

            $monto = (float) $valor;
            if ($monto <= 0) {
                return back()->withErrors(['mediciones' => 'Todos los montos deben ser mayores a 0 soles.'])->withInput();
            }

            $medicionesValidas[(int) $idManguera] = $monto;
        }

        if ($medicionesValidas === []) {
            return back()->withErrors(['mediciones' => 'Debe ingresar al menos un monto mayor a 0 soles para guardar el cuadre.'])->withInput();
        }

        $turno = Turno::find($idTurno);
        if (!$turno) {
            return back()->withErrors(['id_turno' => 'El turno seleccionado no es válido.'])->withInput();
        }


        foreach ($medicionesValidas as $idManguera => $valor) {
            $idManguera = (int) $idManguera;
            if ($idManguera <= 0) {
                continue;
            }

            $manguera = Manguera::find($idManguera);
            if (!$manguera) {
                continue;
            }

            $ultimoRegistro = RegistroSalida::where('id_manguera', $idManguera)
                ->orderByDesc('id_salida')
                ->first();

            $saldoInicial = $ultimoRegistro ? (float)($ultimoRegistro->saldo_final ?? 0) : 0.0;
            $saldoFinal = (float) $valor;
            $precioGalon = $this->resolvePrecioGalonForManguera($idManguera, $idTurno, $fecha);
            $total = max(0.0, ($saldoFinal - $saldoInicial) * $precioGalon);

            RegistroSalida::create([
                'id_manguera' => $idManguera,
                'id_usuario' => $idUsuario,
                'id_turno' => $idTurno,
                'fecha_inicio' => $fecha . ' 00:00:00',
                'saldo_inicial' => round($saldoInicial, 3),
                'saldo_final' => round($saldoFinal, 3),
                'precio_galon' => round($precioGalon, 2),
                'total' => round($total, 2),
                'observaciones' => 'Cuadre de Caja',
            ]);
        }

        if (!empty($data['diferencias']) && is_array($data['diferencias'])) {
            $this->guardarDiferencias($idUsuario, $idTurno, $fecha, $data['diferencias']);
        }

        $hasClosingValues = collect(['total_ventas', 'efectivo', 'credito', 'visa', 'descuentos'])
            ->contains(fn ($field) => filled($request->input($field)));

        if ($hasClosingValues) {
            $resumen = $this->calcularResumenVentasTurno($idUsuario, $idTurno, $fecha);
            $submittedTotalVentas = $data['total_ventas'] ?? null;

            if (is_null($submittedTotalVentas) || $submittedTotalVentas === '') {
                $data['total_ventas'] = $resumen['total'];
            } else {
                $data['total_ventas'] = round((float) $submittedTotalVentas, 2);
            }

            $data['efectivo'] = round((float)($data['efectivo'] ?? 0), 2);
            $data['credito'] = round((float)($data['credito'] ?? 0), 2);
            $data['visa'] = round((float)($data['visa'] ?? 0), 2);
            $data['descuentos'] = round((float)($data['descuentos'] ?? 0), 2);

            $diferenciasQuery = Diferencia::query()->where('id_turno', $idTurno);
            if (!is_null($idUsuario)) {
                $diferenciasQuery->where('id_usuario', $idUsuario);
            }

            $totalDiferencias = (float) $diferenciasQuery->sum('total');
            $data['diferencia'] = (float) $data['total_ventas'] - (
                (float)($data['efectivo'] ?? 0)
                + (float)($data['credito'] ?? 0)
                + (float)($data['visa'] ?? 0)
                + (float)($data['descuentos'] ?? 0)
                + $totalDiferencias
            );

            $this->guardarCierreTurno($data);
        }

        return redirect()->route('cierres_turno.cuadre_caja.lista')->with('success', 'Cuadre de caja registrado.');
    }

    private function guardarCierreTurno(array $data): CierreTurno
    {
        $cierre = CierreTurno::query()
            ->where('id_usuario', (int) ($data['id_usuario'] ?? 0))
            ->where('id_turno', (int) ($data['id_turno'] ?? 0))
            ->whereDate('fecha', $data['fecha'] ?? null)
            ->first();

        if ($cierre) {
            $cierre->fill($data);
            $cierre->save();

            return $cierre;
        }

        return CierreTurno::create($data);
    }

    private function guardarDiferencias(int $idUsuario, int $idTurno, string $fecha, array $rows): void
    {
        foreach ($rows as $row) {
            $idTipoCombustible = isset($row['id_tipo_combustible']) ? (int) $row['id_tipo_combustible'] : null;
            $cantidadGalones = isset($row['cantidad_galones']) ? (float) $row['cantidad_galones'] : null;
            $observacion = trim((string) ($row['observacion'] ?? ''));

            if (!$idTipoCombustible || $cantidadGalones === null || $cantidadGalones <= 0) {
                continue;
            }

            $precio = isset($row['precio']) && $row['precio'] !== ''
                ? (float) $row['precio']
                : $this->obtenerPrecioPorTurno($idTipoCombustible, $idTurno, $fecha);

            $total = isset($row['total']) && $row['total'] !== ''
                ? (float) $row['total']
                : round($cantidadGalones * $precio, 2);

            Diferencia::create([
                'id_usuario' => $idUsuario,
                'id_turno' => $idTurno,
                'id_tipo_combustible' => $idTipoCombustible,
                'cantidad_galones' => round($cantidadGalones, 3),
                'precio' => round($precio, 2),
                'total' => round($total, 2),
                'observacion' => $observacion ?: null,
                'estado' => 1,
                'created_at' => Carbon::parse($fecha)->setTime(now()->hour, now()->minute, now()->second),
                'updated_at' => Carbon::now(),
            ]);
        }
    }

    private function turnoOrden(?string $nombre): int
    {
        $texto = mb_strtolower(trim((string) $nombre));

        if (str_contains($texto, 'mañana') || str_contains($texto, 'manana')) {
            return 1;
        }

        if (str_contains($texto, 'tarde')) {
            return 2;
        }

        if (str_contains($texto, 'noche')) {
            return 3;
        }

        return 0;
    }

    public function store(Request $request)
    {
        $data = $request->validate([
            'id_usuario' => 'required|integer',
            'id_turno' => 'required|integer',
            'fecha' => 'required|date',
            'total_ventas' => 'nullable|numeric',

            'efectivo' => 'nullable|numeric',
            'credito' => 'nullable|numeric',
            'visa' => 'nullable|numeric',
            'descuentos' => 'nullable|numeric',
        ]);

        $idUsuario = (int)$data['id_usuario'];
        $idTurno = (int)$data['id_turno'];
        $fecha = $data['fecha'];

        $resumen = $this->calcularResumenVentasTurno($idUsuario, $idTurno, $fecha);
        $submittedTotalVentas = $data['total_ventas'] ?? null;

        if (is_null($submittedTotalVentas) || $submittedTotalVentas === '') {
            $data['total_ventas'] = $resumen['total'];
        } else {
            $data['total_ventas'] = round((float) $submittedTotalVentas, 2);
        }

        $data['efectivo'] = round((float)($data['efectivo'] ?? 0), 2);
        $data['credito'] = round((float)($data['credito'] ?? 0), 2);
        $data['visa'] = round((float)($data['visa'] ?? 0), 2);
        $data['descuentos'] = round((float)($data['descuentos'] ?? 0), 2);

        $efectivo = (float)($data['efectivo'] ?? 0);
        $credito = (float)($data['credito'] ?? 0);
        $visa = (float)($data['visa'] ?? 0);
        $descuentos = (float)($data['descuentos'] ?? 0);

        $diferenciasQuery = Diferencia::query()
            ->where('id_turno', $idTurno);

        if (!is_null($idUsuario)) {
            $diferenciasQuery->where('id_usuario', $idUsuario);
        }

        $totalDiferencias = (float) $diferenciasQuery->sum('total');

        $data['diferencia'] = (float)$data['total_ventas'] - ($efectivo + $credito + $visa + $descuentos + $totalDiferencias);

        $this->guardarCierreTurno($data);
        return redirect()->route('cierres_turno.index')->with('success', 'Cierre creado.');

    }

    public function edit(string $id)
    {
        $item = CierreTurno::findOrFail($id);
        $usuarios = User::orderBy('id_usuario')->get();
        $turnos = Turno::orderBy('id_turno')->get();
        return view('cierres_turno.edit', compact('item', 'usuarios', 'turnos'));
    }

    public function update(Request $request, string $id)
    {
        $item = CierreTurno::findOrFail($id);
        $data = $request->validate([
            'id_usuario' => 'required|integer',
            'id_turno' => 'required|integer',
            'fecha' => 'required|date',
            'total_ventas' => 'nullable|numeric',

            'efectivo' => 'nullable|numeric',
            'credito' => 'nullable|numeric',
            'visa' => 'nullable|numeric',
            'descuentos' => 'nullable|numeric',
        ]);

        $idUsuario = (int)$data['id_usuario'];
        $idTurno = (int)$data['id_turno'];
        $fecha = $data['fecha'];

        $resumen = $this->calcularResumenVentasTurno($idUsuario, $idTurno, $fecha);
        $submittedTotalVentas = $data['total_ventas'] ?? null;

        if (is_null($submittedTotalVentas) || $submittedTotalVentas === '') {
            $data['total_ventas'] = $resumen['total'];
        } else {
            $data['total_ventas'] = round((float) $submittedTotalVentas, 2);
        }

        $data['efectivo'] = round((float)($data['efectivo'] ?? 0), 2);
        $data['credito'] = round((float)($data['credito'] ?? 0), 2);
        $data['visa'] = round((float)($data['visa'] ?? 0), 2);
        $data['descuentos'] = round((float)($data['descuentos'] ?? 0), 2);

        $efectivo = (float)($data['efectivo'] ?? 0);
        $credito = (float)($data['credito'] ?? 0);
        $visa = (float)($data['visa'] ?? 0);
        $descuentos = (float)($data['descuentos'] ?? 0);

        $totalDiferencias = (float) Diferencia::query()
            ->where('id_usuario', $idUsuario)
            ->where('id_turno', $idTurno)
            ->sum('total');

        $data['diferencia'] = (float)$data['total_ventas'] - ($efectivo + $credito + $visa + $descuentos + $totalDiferencias);

        $item->update($data);
        return redirect()->route('cierres_turno.index')->with('success', 'Cierre actualizado.');

    }

    public function obtenerPrecio(Request $request)
    {
        $idTipoCombustible = (int) $request->input('id_tipo_combustible');
        $idTurno = (int) $request->input('id_turno');
        $fecha = $request->input('fecha') ?? date('Y-m-d');

        $precio = $this->obtenerPrecioPorTurno($idTipoCombustible, $idTurno, $fecha);

        return response()->json([
            'precio' => $precio,
            'formattedPrecio' => number_format($precio, 2, '.', ''),
        ]);
    }

    private function obtenerPrecioPorTurno(int $idTipoCombustible, int $idTurno, string $fecha): float
    {
        $precioDia = PrecioDia::where('tipo_combustible', $idTipoCombustible)
            ->whereDate('fecha', $fecha)
            ->orderByDesc('id')
            ->first();

        if (!$precioDia) {
            $precioDia = PrecioDia::where('tipo_combustible', $idTipoCombustible)
                ->whereDate('fecha', '<=', $fecha)
                ->orderByDesc('fecha')
                ->orderByDesc('id')
                ->first();
        }

        if (!$precioDia) {
            $tipoCombustible = TipoCombustible::find($idTipoCombustible);
            return (float) ($tipoCombustible?->precio ?? 0.0);
        }

        $turno = Turno::find($idTurno);
        $turnoNombre = mb_strtolower((string) ($turno?->turnos ?? $turno?->nombre ?? ''));

        if (str_contains($turnoNombre, 'mañ') || str_contains($turnoNombre, 'mana') || str_contains($turnoNombre, 'morning')) {
            return (float) ($precioDia->precio_turno_manana ?? 0);
        }

        if (str_contains($turnoNombre, 'tarde') || str_contains($turnoNombre, 'afternoon')) {
            return (float) ($precioDia->precio_turno_tarde ?? 0);
        }

        if (str_contains($turnoNombre, 'noche') || str_contains($turnoNombre, 'night')) {
            return (float) ($precioDia->precio_turno_noche ?? 0);
        }

        return (float) ($precioDia->precio_turno_manana ?? 0);
    }

    private function resolvePrecioGalonForManguera(int $idManguera, int $idTurno, string $fecha): float
    {
        $manguera = Manguera::find($idManguera);
        $turno = Turno::find($idTurno);

        if (!$manguera || !$turno) {
            return 0.0;
        }

        $turnoNombre = mb_strtolower($turno->turnos ?? $turno->nombre ?? '');
        $precioDia = PrecioDia::where('tipo_combustible', $manguera->id_tipo_combustible)
            ->whereDate('fecha', $fecha)
            ->orderByDesc('id')
            ->first();

        if (!$precioDia) {
            $precioDia = PrecioDia::where('tipo_combustible', $manguera->id_tipo_combustible)
                ->orderByDesc('fecha')
                ->orderByDesc('id')
                ->first();
        }

        if (!$precioDia) {
            return 0.0;
        }

        if (str_contains($turnoNombre, 'tarde')) {
            return (float) $precioDia->precio_turno_tarde;
        }

        if (str_contains($turnoNombre, 'noche')) {
            return (float) $precioDia->precio_turno_noche;
        }

        return (float) $precioDia->precio_turno_manana;
    }

    protected function calcularResumenVentasTurno(?int $idUsuario, int $idTurno, string $fecha): array
    {
        $combustibles = [
            'diesel' => 0.0,
            'premium' => 0.0,
            'regular' => 0.0,
        ];

        $total = 0.0;

        $query = RegistroSalida::with(['manguera.tipoCombustible', 'turno'])
            ->where('id_turno', $idTurno)
            ->whereDate('fecha_inicio', $fecha);

        if (!is_null($idUsuario)) {
            $query->where('id_usuario', $idUsuario);
        }

        $registros = $query
            ->orderByDesc('fecha_inicio')
            ->orderByDesc('id_salida')
            ->get();

        foreach ($registros as $registro) {
            $tipoNombre = strtolower((string)($registro->manguera?->tipoCombustible?->nombre ?? ''));
            $clave = null;

            if (str_contains($tipoNombre, 'diesel')) {
                $clave = 'diesel';
            } elseif (str_contains($tipoNombre, 'premium')) {
                $clave = 'premium';
            } elseif (str_contains($tipoNombre, 'regular')) {
                $clave = 'regular';
            }

            $saldoInicial = (float)($registro->saldo_inicial ?? 0);
            $saldoFinal = (float)($registro->saldo_final ?? 0);
            $galonesVendidos = $saldoFinal - $saldoInicial;

            if ($galonesVendidos < 0) {
                $galonesVendidos = 0;
            }

            $tipoId = $registro->manguera?->id_tipo_combustible;
            $precioTurno = 0.0;

            if ($tipoId) {
                $precioDia = PrecioDia::where('tipo_combustible', $tipoId)
                    ->whereDate('fecha', $fecha)
                    ->orderByDesc('id')
                    ->first();

                if (!$precioDia) {
                    $precioDia = PrecioDia::where('tipo_combustible', $tipoId)
                        ->whereDate('fecha', '<=', $fecha)
                        ->orderByDesc('fecha')
                        ->orderByDesc('id')
                        ->first();
                }

                $turnoNombre = strtolower((string)($registro->turno->turnos ?? $registro->turno->nombre ?? ''));

                if ($precioDia) {
                    if (str_contains($turnoNombre, 'mañ') || str_contains($turnoNombre, 'mana') || str_contains($turnoNombre, 'morning')) {
                        $precioTurno = (float)$precioDia->precio_turno_manana;
                    } elseif (str_contains($turnoNombre, 'tarde') || str_contains($turnoNombre, 'afternoon')) {
                        $precioTurno = (float)$precioDia->precio_turno_tarde;
                    } elseif (str_contains($turnoNombre, 'noche') || str_contains($turnoNombre, 'night')) {
                        $precioTurno = (float)$precioDia->precio_turno_noche;
                    }
                }
            }

            $monto = $galonesVendidos * $precioTurno;

            if ($clave !== null) {
                $combustibles[$clave] += $monto;
            }

            $total += $monto;
        }

        return [
            'total' => round($total, 2),
            'combustibles' => [
                'diesel' => round($combustibles['diesel'], 2),
                'premium' => round($combustibles['premium'], 2),
                'regular' => round($combustibles['regular'], 2),
            ],
        ];
    }

    public function resumenVentas(Request $request)
    {
        $idUsuarioRaw = $request->query('id_usuario');
        $idUsuario = (is_null($idUsuarioRaw) || $idUsuarioRaw === '') ? null : (int) $idUsuarioRaw;
        $idTurno = (int) $request->query('id_turno');
        $fecha = (string) $request->query('fecha', date('Y-m-d'));
        $medicionesRaw = $request->query('mediciones');

        if (!$idTurno) {
            return response()->json([
                'total' => 0,
                'total_diferencias' => 0,
                'combustibles' => [
                    'diesel' => 0,
                    'premium' => 0,
                    'regular' => 0,
                ],
            ]);
        }

        $mediciones = [];
        if (is_string($medicionesRaw) && $medicionesRaw !== '') {
            $decoded = json_decode($medicionesRaw, true);
            if (is_array($decoded)) {
                foreach ($decoded as $idManguera => $valor) {
                    if ($valor === null || $valor === '') {
                        continue;
                    }

                    $monto = (float) $valor;
                    if ($monto >= 0) {
                        $mediciones[(int) $idManguera] = $monto;
                    }
                }
            }
        }

        $resumen = $mediciones !== []
            ? $this->calcularResumenVentasDesdeMediciones($idUsuario, $idTurno, $fecha, $mediciones)
            : $this->calcularResumenVentasTurno($idUsuario, $idTurno, $fecha);

        $diferenciasQuery = Diferencia::query()
            ->where('id_turno', $idTurno);

        if (!is_null($idUsuario)) {
            $diferenciasQuery->where('id_usuario', $idUsuario);
        }

        $totalDiferencias = (float) $diferenciasQuery->sum('total');

        return response()->json([
            'total' => $resumen['total'],
            'total_diferencias' => round($totalDiferencias, 2),
            'combustibles' => $resumen['combustibles'],
        ]);
    }

    private function calcularResumenVentasDesdeMediciones(?int $idUsuario, int $idTurno, string $fecha, array $mediciones): array
    {
        $combustibles = [
            'diesel' => 0.0,
            'premium' => 0.0,
            'regular' => 0.0,
        ];

        $total = 0.0;

        foreach ($mediciones as $idManguera => $saldoFinal) {
            $manguera = Manguera::find($idManguera);
            if (!$manguera) {
                continue;
            }

            $ultimoRegistro = RegistroSalida::where('id_manguera', $idManguera)
                ->orderByDesc('id_salida')
                ->first();

            $saldoInicial = $ultimoRegistro ? (float) ($ultimoRegistro->saldo_final ?? 0) : 0.0;
            $galonesVendidos = max(0.0, (float) $saldoFinal - $saldoInicial);
            $precioTurno = $this->resolvePrecioGalonForManguera($idManguera, $idTurno, $fecha);
            $monto = $galonesVendidos * $precioTurno;

            $tipoNombre = strtolower((string) ($manguera->tipoCombustible->nombre ?? ''));
            if (str_contains($tipoNombre, 'diesel')) {
                $combustibles['diesel'] += $monto;
            } elseif (str_contains($tipoNombre, 'premium')) {
                $combustibles['premium'] += $monto;
            } elseif (str_contains($tipoNombre, 'regular')) {
                $combustibles['regular'] += $monto;
            }

            $total += $monto;
        }

        return [
            'total' => round($total, 2),
            'combustibles' => [
                'diesel' => round($combustibles['diesel'], 2),
                'premium' => round($combustibles['premium'], 2),
                'regular' => round($combustibles['regular'], 2),
            ],
        ];
    }

    public function destroy(string $id)
    {
        $item = CierreTurno::findOrFail($id);
        $item->delete();
        return redirect()->route('cierres_turno.index')->with('success', 'Cierre eliminado.');
    }
}

