<?php

namespace App\Http\Controllers;

use App\Models\AjusteInventario;
use App\Models\Inventario;
use App\Models\MovimientoInventario;
use App\Models\Producto;
use App\Models\ProductoVariante;
use App\Models\Sucursal;
use App\Services\InventoryFlowService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Str;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Schema;
use Illuminate\Validation\ValidationException;
use Illuminate\View\View;

class InventarioController extends Controller
{
    public function __construct(private readonly InventoryFlowService $inventoryFlowService)
    {
    }

    public function index(Request $request): View
    {
        $empresaId = tenant_empresa_id();
        abort_if(! $empresaId, 403, 'No hay empresa activa.');

        $tenantSucursalId = tenant_sucursal_id();
        $search = trim((string) $request->query('q', ''));

        $this->ensureInventorySnapshots($empresaId);

        $inventarioQuery = Inventario::query()
            ->where('empresa_id', $empresaId)
            ->with(['producto.categoria', 'sucursal']);

        if ($tenantSucursalId) {
            $inventarioQuery->where(static function ($query) use ($tenantSucursalId): void {
                $query->whereNull('sucursal_id')
                    ->orWhere('sucursal_id', $tenantSucursalId);
            });
        } else {
            $inventarioQuery->whereNull('sucursal_id');
        }

        if ($search !== '') {
            $inventarioQuery->whereHas('producto', function ($query) use ($search): void {
                $query->where('nombre', 'like', '%'.$search.'%')
                    ->orWhere('sku', 'like', '%'.$search.'%')
                    ->orWhere('codigo_barras', 'like', '%'.$search.'%');
            });
        }

        $inventario = $inventarioQuery
            ->orderByDesc('updated_at')
            ->paginate(20)
            ->withQueryString();

        $productos = Producto::query()
            ->where('empresa_id', $empresaId)
            ->where('activo', 1)
            ->when($tenantSucursalId, static function ($query, int $sucursalId): void {
                $query->where(static function ($nested) use ($sucursalId): void {
                    $nested->whereNull('sucursal_id')
                        ->orWhere('sucursal_id', $sucursalId);
                });
            })
            ->orderBy('nombre')
            ->get();

        $movimientos = collect();
        if (has_permission('movimientos_inventario.ver')) {
            $movimientosQuery = MovimientoInventario::query()
                ->where('empresa_id', $empresaId)
                ->with(['producto']);

            if ($tenantSucursalId) {
                $movimientosQuery->where('sucursal_id', $tenantSucursalId);
            } else {
                $movimientosQuery->whereNull('sucursal_id');
            }

            $movimientos = $movimientosQuery
                ->orderByDesc('id')
                ->limit(30)
                ->get();
        }

        $inventoryStatsQuery = Inventario::query()
            ->where('empresa_id', $empresaId)
            ->with(['producto:id,nombre,sku,stock_minimo']);

        if ($tenantSucursalId) {
            $inventoryStatsQuery->where(static function ($query) use ($tenantSucursalId): void {
                $query->whereNull('sucursal_id')
                    ->orWhere('sucursal_id', $tenantSucursalId);
            });
        } else {
            $inventoryStatsQuery->whereNull('sucursal_id');
        }

        $inventoryStatsRows = $inventoryStatsQuery->get();

        $lowStockProducts = $inventoryStatsRows
            ->filter(static function (Inventario $row): bool {
                $stockActual = (float) $row->stock;
                $stockMinimo = (float) ($row->producto?->stock_minimo ?? 0);

                return $stockActual <= $stockMinimo;
            })
            ->map(static function (Inventario $row): array {
                $stockActual = (float) $row->stock;
                $stockMinimo = (float) ($row->producto?->stock_minimo ?? 0);

                return [
                    'id' => (int) ($row->producto?->id ?? $row->producto_id),
                    'nombre' => (string) ($row->producto?->nombre ?? 'Producto'),
                    'sku' => trim((string) ($row->producto?->sku ?? '')),
                    'stock_actual' => $stockActual,
                    'stock_minimo' => $stockMinimo,
                    'faltante' => max($stockMinimo - $stockActual, 0),
                    'costo_promedio' => (float) $row->costo_promedio,
                ];
            })
            ->values();

        $stockValue = $inventoryStatsRows->sum(
            static fn (Inventario $row): float => ((float) $row->stock) * ((float) $row->costo_promedio)
        );

        $branches = Sucursal::query()
            ->where('empresa_id', $empresaId)
            ->where('activa', 1)
            ->orderBy('nombre')
            ->get(['id', 'nombre']);

        $productVariantsMap = [];
        if (Schema::hasTable('producto_variantes')) {
            $productVariantsMap = ProductoVariante::query()
                ->where('empresa_id', $empresaId)
                ->whereIn('producto_id', $productos->pluck('id')->all())
                ->where('activo', 1)
                ->orderBy('nombre')
                ->get(['id', 'producto_id', 'nombre', 'cantidad', 'activo'])
                ->groupBy('producto_id')
                ->map(static function ($items): array {
                    return $items->map(static function (ProductoVariante $variant): array {
                        return [
                            'id' => (int) $variant->id,
                            'nombre' => (string) $variant->nombre,
                            'cantidad' => (int) ($variant->cantidad ?? 0),
                            'activo' => (int) ($variant->activo ? 1 : 0),
                        ];
                    })->values()->all();
                })
                ->all();
        }

        $movementsModal = $movimientos
            ->map(static function (MovimientoInventario $movement): array {
                return [
                    'id' => (int) $movement->id,
                    'created_at' => optional($movement->created_at)->format('Y-m-d H:i:s') ?: '',
                    'sucursal' => (string) ($movement->sucursal?->nombre ?? 'Sin sucursal'),
                    'producto' => (string) ($movement->producto?->nombre ?? ''),
                    'variante_nombre' => (string) ($movement->variante?->nombre ?? ''),
                    'tipo' => (string) $movement->tipo,
                    'referencia' => (string) ($movement->referencia ?? ''),
                    'cantidad' => number_format((float) $movement->cantidad, 2, '.', ''),
                ];
            })
            ->values();

        $transferMovementsQuery = MovimientoInventario::query()
            ->where('empresa_id', $empresaId)
            ->whereNotNull('referencia')
            ->where('referencia', 'like', 'TRS-%')
            ->with([
                'sucursal:id,nombre',
                'producto:id,nombre',
                'variante:id,nombre',
            ])
            ->orderByDesc('id')
            ->limit(250);

        if ($tenantSucursalId) {
            $transferMovementsQuery->where('sucursal_id', $tenantSucursalId);
        }

        $transferMovements = $transferMovementsQuery->get();
        $transferEntriesByKey = [];

        foreach ($transferMovements as $movement) {
            if ($movement->tipo !== 'entrada') {
                continue;
            }

            $key = implode('|', [
                (string) $movement->referencia,
                (string) $movement->producto_id,
                (string) ($movement->variante_id ?? 0),
            ]);

            if (! array_key_exists($key, $transferEntriesByKey)) {
                $transferEntriesByKey[$key] = $movement;
            }
        }

        $transferHistory = $transferMovements
            ->filter(static fn (MovimientoInventario $movement): bool => $movement->tipo === 'salida')
            ->map(static function (MovimientoInventario $movement) use ($transferEntriesByKey): array {
                $key = implode('|', [
                    (string) $movement->referencia,
                    (string) $movement->producto_id,
                    (string) ($movement->variante_id ?? 0),
                ]);
                /** @var MovimientoInventario|null $entryMovement */
                $entryMovement = $transferEntriesByKey[$key] ?? null;

                return [
                    'id' => (int) $movement->id,
                    'created_at' => optional($movement->created_at)->format('Y-m-d H:i:s') ?: '',
                    'referencia' => (string) ($movement->referencia ?? ''),
                    'producto' => (string) ($movement->producto?->nombre ?? ''),
                    'variante_nombre' => (string) ($movement->variante?->nombre ?? ''),
                    'sucursal_origen' => (string) ($movement->sucursal?->nombre ?? 'Sin sucursal'),
                    'sucursal_destino' => (string) ($entryMovement?->sucursal?->nombre ?? 'Sin sucursal'),
                    'cantidad' => number_format(abs((float) $movement->cantidad), 2, '.', ''),
                ];
            })
            ->take(60)
            ->values();

        $pendingAdjustments = collect();
        $adjustmentHistory = collect();
        if (Schema::hasTable('ajustes_inventario')) {
            $pendingAdjustmentsQuery = AjusteInventario::query()
                ->where('empresa_id', $empresaId)
                ->where('estado', 'pendiente')
                ->with([
                    'producto:id,nombre',
                    'variante:id,nombre',
                    'usuario:id,nombre',
                    'sucursal:id,nombre',
                ])
                ->orderByDesc('id')
                ->limit(80);

            if ($tenantSucursalId) {
                $pendingAdjustmentsQuery->where('sucursal_id', $tenantSucursalId);
            }

            $pendingAdjustments = $pendingAdjustmentsQuery
                ->get()
                ->map(static function (AjusteInventario $adjustment): array {
                    return [
                        'id' => (int) $adjustment->id,
                        'sucursal' => (string) ($adjustment->sucursal?->nombre ?? 'Sin sucursal'),
                        'producto' => (string) ($adjustment->producto?->nombre ?? ''),
                        'variante_nombre' => (string) ($adjustment->variante?->nombre ?? ''),
                        'stock_anterior' => number_format((float) $adjustment->stock_anterior, 2, '.', ''),
                        'stock_nuevo' => number_format((float) $adjustment->stock_nuevo, 2, '.', ''),
                        'motivo' => (string) ($adjustment->motivo ?? ''),
                    ];
                })
                ->values();

            $adjustmentHistoryQuery = AjusteInventario::query()
                ->where('empresa_id', $empresaId)
                ->whereIn('estado', ['aprobado', 'rechazado'])
                ->with([
                    'producto:id,nombre',
                    'variante:id,nombre',
                    'usuario:id,nombre',
                    'aprobadoPor:id,nombre',
                    'sucursal:id,nombre',
                ])
                ->orderByDesc('id')
                ->limit(120);

            if ($tenantSucursalId) {
                $adjustmentHistoryQuery->where('sucursal_id', $tenantSucursalId);
            }

            $adjustmentHistory = $adjustmentHistoryQuery
                ->get()
                ->map(static function (AjusteInventario $adjustment): array {
                    return [
                        'id' => (int) $adjustment->id,
                        'created_at' => optional($adjustment->created_at)->format('Y-m-d H:i:s') ?: '',
                        'sucursal' => (string) ($adjustment->sucursal?->nombre ?? 'Sin sucursal'),
                        'producto' => (string) ($adjustment->producto?->nombre ?? ''),
                        'variante_nombre' => (string) ($adjustment->variante?->nombre ?? ''),
                        'tipo_ajuste' => (string) ($adjustment->tipo_ajuste ?? 'correccion'),
                        'stock_anterior' => number_format((float) $adjustment->stock_anterior, 2, '.', ''),
                        'stock_nuevo' => number_format((float) $adjustment->stock_nuevo, 2, '.', ''),
                        'estado' => (string) ($adjustment->estado ?? 'pendiente'),
                        'solicitado_por' => (string) ($adjustment->usuario?->nombre ?? '-'),
                        'aprobado_por' => (string) ($adjustment->aprobadoPor?->nombre ?? '-'),
                        'observacion_aprobacion' => (string) ($adjustment->observacion_aprobacion ?? '-'),
                    ];
                })
                ->values();
        }

        return view('modules.inventario.index', [
            'inventario' => $inventario,
            'productos' => $productos,
            'movimientos' => $movimientos,
            'tenantSucursalId' => $tenantSucursalId,
            'search' => $search,
            'inventoryStats' => [
                'products_total' => $inventoryStatsRows->pluck('producto_id')->unique()->count(),
                'low_stock' => $lowStockProducts->pluck('id')->unique()->count(),
                'stock_value' => (float) $stockValue,
            ],
            'lowStockProducts' => $lowStockProducts,
            'branches' => $branches,
            'productVariantsMap' => $productVariantsMap,
            'movementsModal' => $movementsModal,
            'transferHistory' => $transferHistory,
            'pendingAdjustments' => $pendingAdjustments,
            'adjustmentHistory' => $adjustmentHistory,
            'userBranchId' => $tenantSucursalId ? (int) $tenantSucursalId : 0,
        ]);
    }

    private function ensureInventorySnapshots(int $empresaId): void
    {
        $productos = Producto::query()
            ->where('empresa_id', $empresaId)
            ->get(['id', 'empresa_id', 'sucursal_id', 'stock_actual', 'precio_compra']);

        foreach ($productos as $producto) {
            Inventario::query()->firstOrCreate(
                [
                    'empresa_id' => $empresaId,
                    'producto_id' => (int) $producto->id,
                    'sucursal_id' => $producto->sucursal_id ? (int) $producto->sucursal_id : null,
                ],
                [
                    'stock' => (float) ($producto->stock_actual ?? 0),
                    'costo_promedio' => (float) ($producto->precio_compra ?? 0),
                ]
            );
        }
    }

    public function storeMovement(Request $request): RedirectResponse
    {
        $empresaId = tenant_empresa_id();
        abort_if(! $empresaId, 403, 'No hay empresa activa.');

        $tenantSucursalId = tenant_sucursal_id();
        $validated = $request->validate([
            'producto_id' => ['required', 'integer'],
            'tipo' => ['required', 'string', 'in:entrada,salida,ajuste'],
            'cantidad' => ['required', 'numeric', 'gt:0'],
            'costo_unitario' => ['nullable', 'numeric', 'min:0'],
            'referencia' => ['nullable', 'string', 'max:120'],
        ]);

        $producto = Producto::query()
            ->whereKey((int) $validated['producto_id'])
            ->where('empresa_id', $empresaId)
            ->first();

        if (! $producto) {
            throw ValidationException::withMessages([
                'producto_id' => 'El producto no pertenece a la empresa activa.',
            ]);
        }

        if (
            $tenantSucursalId
            && $producto->sucursal_id
            && (int) $producto->sucursal_id !== (int) $tenantSucursalId
        ) {
            throw ValidationException::withMessages([
                'producto_id' => 'El producto no pertenece a la sucursal activa.',
            ]);
        }

        if (! $tenantSucursalId && $producto->sucursal_id) {
            throw ValidationException::withMessages([
                'producto_id' => 'Selecciona una sucursal activa para ajustar este producto.',
            ]);
        }

        $tipo = (string) $validated['tipo'];
        $cantidad = (float) $validated['cantidad'];
        $costoUnitario = (float) ($validated['costo_unitario'] ?? 0);

        DB::transaction(function () use (
            $empresaId,
            $tenantSucursalId,
            $producto,
            $tipo,
            $cantidad,
            $costoUnitario,
            $validated
        ): void {
            $this->inventoryFlowService->applyMovement(
                empresaId: $empresaId,
                sucursalId: $tenantSucursalId,
                producto: $producto,
                tipo: $tipo,
                cantidad: $cantidad,
                costoUnitario: $costoUnitario,
                referencia: $validated['referencia'] ?? null
            );
        });

        return redirect()->route('inventario.index')
            ->with('status', 'Movimiento de inventario registrado correctamente.');
    }

    public function storeTransfer(Request $request): RedirectResponse
    {
        $empresaId = tenant_empresa_id();
        abort_if(! $empresaId, 403, 'No hay empresa activa.');

        $validated = $request->validate([
            '_inventory_modal' => ['nullable', 'string'],
            'producto_id' => ['required', 'integer'],
            'variante_id' => ['nullable', 'integer'],
            'sucursal_origen_id' => ['required', 'integer'],
            'sucursal_destino_id' => ['required', 'integer', 'different:sucursal_origen_id'],
            'cantidad' => ['required', 'numeric', 'gt:0'],
            'observacion' => ['nullable', 'string', 'max:255'],
        ]);

        $producto = Producto::query()
            ->whereKey((int) $validated['producto_id'])
            ->where('empresa_id', $empresaId)
            ->first();

        if (! $producto) {
            throw ValidationException::withMessages([
                'producto_id' => 'El producto no pertenece a la empresa activa.',
            ]);
        }

        $varianteId = isset($validated['variante_id']) && (int) $validated['variante_id'] > 0
            ? (int) $validated['variante_id']
            : null;

        if ($varianteId !== null) {
            $variante = ProductoVariante::query()
                ->whereKey($varianteId)
                ->where('empresa_id', $empresaId)
                ->where('producto_id', (int) $producto->id)
                ->where('activo', 1)
                ->first();

            if (! $variante) {
                throw ValidationException::withMessages([
                    'variante_id' => 'La variación seleccionada no es válida para este producto.',
                ]);
            }
        }

        $originBranch = Sucursal::query()
            ->whereKey((int) $validated['sucursal_origen_id'])
            ->where('empresa_id', $empresaId)
            ->where('activa', 1)
            ->first();

        $destinationBranch = Sucursal::query()
            ->whereKey((int) $validated['sucursal_destino_id'])
            ->where('empresa_id', $empresaId)
            ->where('activa', 1)
            ->first();

        if (! $originBranch || ! $destinationBranch) {
            throw ValidationException::withMessages([
                'sucursal_origen_id' => 'Las sucursales de traslado no son válidas.',
            ]);
        }

        $cantidad = (float) $validated['cantidad'];
        $referenciaBase = 'TRS-'.now()->format('YmdHis').'-'.strtoupper(Str::random(4));
        $referencia = trim($referenciaBase.' '.((string) ($validated['observacion'] ?? '')));

        DB::transaction(function () use ($empresaId, $originBranch, $destinationBranch, $producto, $cantidad, $referencia): void {
            $originInventory = Inventario::query()
                ->where('empresa_id', $empresaId)
                ->where('sucursal_id', (int) $originBranch->id)
                ->where('producto_id', (int) $producto->id)
                ->first();

            $costoUnitario = (float) ($originInventory?->costo_promedio ?? $producto->precio_compra ?? 0);

            $this->inventoryFlowService->applyMovement(
                empresaId: $empresaId,
                sucursalId: (int) $originBranch->id,
                producto: $producto,
                tipo: 'salida',
                cantidad: $cantidad,
                costoUnitario: $costoUnitario,
                referencia: $referencia
            );

            $this->inventoryFlowService->applyMovement(
                empresaId: $empresaId,
                sucursalId: (int) $destinationBranch->id,
                producto: $producto,
                tipo: 'entrada',
                cantidad: $cantidad,
                costoUnitario: $costoUnitario,
                referencia: $referencia
            );
        });

        return redirect()->route('inventario.index')
            ->with('status', 'Traslado registrado correctamente.');
    }

    public function storeAdjustmentRequest(Request $request): RedirectResponse
    {
        $empresaId = tenant_empresa_id();
        abort_if(! $empresaId, 403, 'No hay empresa activa.');

        $validated = $request->validate([
            '_inventory_modal' => ['nullable', 'string'],
            'sucursal_id' => ['required', 'integer'],
            'producto_id' => ['required', 'integer'],
            'variante_id' => ['nullable', 'integer'],
            'stock_nuevo' => ['required', 'numeric', 'min:0'],
            'motivo' => ['required', 'string', 'max:255'],
        ]);

        $sucursal = Sucursal::query()
            ->whereKey((int) $validated['sucursal_id'])
            ->where('empresa_id', $empresaId)
            ->where('activa', 1)
            ->first();

        if (! $sucursal) {
            throw ValidationException::withMessages([
                'sucursal_id' => 'La sucursal seleccionada no es válida.',
            ]);
        }

        $producto = Producto::query()
            ->whereKey((int) $validated['producto_id'])
            ->where('empresa_id', $empresaId)
            ->first();

        if (! $producto) {
            throw ValidationException::withMessages([
                'producto_id' => 'El producto no pertenece a la empresa activa.',
            ]);
        }

        $varianteId = isset($validated['variante_id']) && (int) $validated['variante_id'] > 0
            ? (int) $validated['variante_id']
            : null;

        if ($varianteId !== null) {
            $variante = ProductoVariante::query()
                ->whereKey($varianteId)
                ->where('empresa_id', $empresaId)
                ->where('producto_id', (int) $producto->id)
                ->where('activo', 1)
                ->first();

            if (! $variante) {
                throw ValidationException::withMessages([
                    'variante_id' => 'La variación seleccionada no es válida para este producto.',
                ]);
            }
        }

        $inventory = Inventario::query()
            ->where('empresa_id', $empresaId)
            ->where('sucursal_id', (int) $sucursal->id)
            ->where('producto_id', (int) $producto->id)
            ->first();

        $stockAnterior = (float) ($inventory?->stock ?? 0);
        $stockNuevo = (float) $validated['stock_nuevo'];

        $tipoAjuste = 'correccion';
        if ($stockNuevo > $stockAnterior) {
            $tipoAjuste = 'incremento';
        } elseif ($stockNuevo < $stockAnterior) {
            $tipoAjuste = 'decremento';
        }

        AjusteInventario::query()->create([
            'empresa_id' => $empresaId,
            'sucursal_id' => (int) $sucursal->id,
            'producto_id' => (int) $producto->id,
            'variante_id' => $varianteId,
            'tipo_ajuste' => $tipoAjuste,
            'stock_anterior' => $stockAnterior,
            'stock_nuevo' => $stockNuevo,
            'motivo' => trim((string) $validated['motivo']),
            'usuario_id' => (int) auth()->id(),
            'estado' => 'pendiente',
        ]);

        return redirect()->route('inventario.index')
            ->with('status', 'Solicitud de ajuste enviada correctamente.');
    }

    public function approveAdjustment(Request $request, AjusteInventario $ajuste): RedirectResponse
    {
        $empresaId = tenant_empresa_id();
        abort_if(! $empresaId, 403, 'No hay empresa activa.');
        abort_unless((int) $ajuste->empresa_id === (int) $empresaId, 403, 'No tienes acceso a este ajuste.');

        $tenantSucursalId = tenant_sucursal_id();
        if ($tenantSucursalId && (int) ($ajuste->sucursal_id ?? 0) !== (int) $tenantSucursalId) {
            abort(403, 'No tienes acceso a este ajuste.');
        }

        $validated = $request->validate([
            'observacion_aprobacion' => ['nullable', 'string', 'max:255'],
        ]);

        if ((string) $ajuste->estado !== 'pendiente') {
            return redirect()->route('inventario.index')
                ->with('error', 'La solicitud ya no está pendiente.');
        }

        $producto = Producto::query()
            ->whereKey((int) $ajuste->producto_id)
            ->where('empresa_id', $empresaId)
            ->first();

        if (! $producto) {
            return redirect()->route('inventario.index')
                ->with('error', 'No se encontró el producto del ajuste.');
        }

        DB::transaction(function () use ($empresaId, $ajuste, $producto, $validated): void {
            $inventory = Inventario::query()
                ->where('empresa_id', $empresaId)
                ->where('sucursal_id', $ajuste->sucursal_id)
                ->where('producto_id', (int) $producto->id)
                ->first();

            $costoUnitario = (float) ($inventory?->costo_promedio ?? $producto->precio_compra ?? 0);

            $this->inventoryFlowService->applyMovement(
                empresaId: $empresaId,
                sucursalId: $ajuste->sucursal_id ? (int) $ajuste->sucursal_id : null,
                producto: $producto,
                tipo: 'ajuste',
                cantidad: (float) $ajuste->stock_nuevo,
                costoUnitario: $costoUnitario,
                referencia: 'AJS#'.$ajuste->id
            );

            $ajuste->fill([
                'estado' => 'aprobado',
                'aprobado_por_id' => (int) auth()->id(),
                'observacion_aprobacion' => trim((string) ($validated['observacion_aprobacion'] ?? '')),
                'aprobado_at' => now(),
            ]);
            $ajuste->save();
        });

        return redirect()->route('inventario.index')
            ->with('status', 'Ajuste aprobado correctamente.');
    }

    public function rejectAdjustment(Request $request, AjusteInventario $ajuste): RedirectResponse
    {
        $empresaId = tenant_empresa_id();
        abort_if(! $empresaId, 403, 'No hay empresa activa.');
        abort_unless((int) $ajuste->empresa_id === (int) $empresaId, 403, 'No tienes acceso a este ajuste.');

        $tenantSucursalId = tenant_sucursal_id();
        if ($tenantSucursalId && (int) ($ajuste->sucursal_id ?? 0) !== (int) $tenantSucursalId) {
            abort(403, 'No tienes acceso a este ajuste.');
        }

        $validated = $request->validate([
            'observacion_rechazo' => ['required', 'string', 'max:255'],
        ]);

        if ((string) $ajuste->estado !== 'pendiente') {
            return redirect()->route('inventario.index')
                ->with('error', 'La solicitud ya no está pendiente.');
        }

        $ajuste->fill([
            'estado' => 'rechazado',
            'aprobado_por_id' => (int) auth()->id(),
            'observacion_aprobacion' => trim((string) $validated['observacion_rechazo']),
            'aprobado_at' => now(),
        ]);
        $ajuste->save();

        return redirect()->route('inventario.index')
            ->with('status', 'Ajuste rechazado correctamente.');
    }
}
