strprfcrm/app/Http/Controllers/OrderController.php

<?php

namespace App\Http\Controllers;

use App\Http\Requests\CreteTtnRequest;
use App\Http\Requests\ExportScheduleRequest;
use App\Http\Requests\Order\StoreOrderRequest;
use App\Jobs\ExportOneOrderJob;
use App\Jobs\ExportOrdersJob;
use App\Jobs\ExportScheduleJob;
use App\Jobs\GenerateFilesPack;
use App\Jobs\GenerateHandoverPack;
use App\Jobs\GenerateInstallationPack;
use App\Jobs\GenerateTtnPack;
use App\Models\Dictionary\Area;
use App\Models\Dictionary\District;
use App\Models\Contractor;
use App\Models\File;
use App\Models\MafOrder;
use App\Models\ObjectType;
use App\Models\Order;
use App\Models\OrderStatus;
use App\Models\OrderView;
use App\Models\ProductSKU;
use App\Models\Schedule;
use App\Models\Ttn;
use App\Models\User;
use App\Services\ContractorSpecificationService;
use App\Services\FileService;
use App\Services\NotificationService;
use App\Services\OrderPaymentStatusService;
use Carbon\Carbon;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Str;
use Illuminate\Support\Facades\Storage;
use Symfony\Component\HttpFoundation\BinaryFileResponse;
use Throwable;
use ZipArchive;

class OrderController extends Controller
{
    protected array $data = [
        'active'    => 'orders',
        'title'     => 'Заказы',
        'id'        => 'orders',
        'header'    => [
            'id'                        => 'ID',
            'name'                      => 'Название',
            'user_name'                 => 'Менеджер',
            'district_name'             => 'Округ',
            'area_name'                 => 'Район',
            'object_address'            => 'Адрес объекта',
            'object_type_name'          => 'Тип объекта',
            'comment'                   => 'Комментарий',
            'products_total'            => 'Всего МАФ',
            'installation_date'         => 'Дата выхода на монтаж',
            'ready_date'                => 'Дата готовности площадки',
            'brigadier_name'            => 'Бригадир',
            'order_status_name'         => 'Статус',
            'tg_group_name'             => 'Имя группы в ТГ',
            'tg_group_link'             => 'Ссылка на группу в ТГ',
            'products_with_count'       => 'МАФы',
            'ready_to_mount'            => 'Все МАФы на складе',
        ],
        'searchFields' => [
            'name',
            'user_name',
            'district_name',
            'area_name',
            'object_type_name',
            'comment',
            'object_address',
            'installation_date',
            'tg_group_name',
            'tg_group_link',
        ],
    ];

    public function __construct()
    {
        $this->data['districts'] = District::query()->get()->pluck('name', 'id');
        $this->data['areas'] = Area::query()->get()->pluck('name', 'id');
        $this->data['objectTypes'] = ObjectType::query()->get()->pluck('name', 'id');
        $this->data['orderStatuses'] = OrderStatus::query()->orderBy('id')->get()->pluck('name', 'id');
        $this->data['brigadiers'] = User::query()
            ->withPermission('orders.scope.brigadier')
            ->get()
            ->pluck('name', 'id');
        $this->data['users'] = User::query()
            ->withAnyPermission(['orders.scope.manager', 'orders.scope.admin'])
            ->get()
            ->pluck('name', 'id');
    }


    /**
     * Display a listing of the resource.
     */
    public function index(Request $request)
    {
        session(['gp_orders' => $request->all()]);
        $nav = $this->startNavigationContext($request);
        $model = new OrderView;
        // fill filters
        $this->createFilters($model, 'user_name', 'district_name', 'area_name', 'object_type_name', 'brigadier_name', 'order_status_name', 'ready_to_mount');
        $this->createDateFilters($model, 'installation_date', 'ready_date');
        $this->data['ranges'] = [];

        $q = $model::query();

        $this->acceptFilters($q, $request);
        $this->acceptSearch($q, $request);
        $this->setSortAndOrderBy($model, $request);

        $this->applyOrderVisibilityScope($q, $request->user());

        $this->data['filtered_orders_count'] = (clone $q)->count();
        $this->data['filtered_products_total'] = (clone $q)->sum('products_total');

        $this->applyStableSorting($q);
        $this->data['orders'] = $q->paginate($this->data['per_page'])->withQueryString();

        foreach ($this->data['orders'] as $order) {
            Order::where('id', $order->id)->first()?->recalculateReadyToMount();
        }

        $this->data['statuses'] = OrderStatus::query()->orderBy('id')->get()->pluck('name', 'id');
        $this->data['nav'] = $nav;

        return view('orders.index', $this->data);
    }

    /**
     * Show the form for creating a new resource.
     */
    public function create(Request $request)
    {
        $nav = $this->startNavigationContext($request);
        $this->data['nav'] = $nav;
        $this->data['back_url'] = $this->navigationBackUrl(
            $request,
            $nav,
            route('order.index', session('gp_orders'))
        );
        return view('orders.edit', $this->data);
    }

    /**
     * Store a newly created resource in storage.
     */
    public function store(StoreOrderRequest $request, NotificationService $notificationService)
    {
        $data = $request->validated();

        $products = $request->validated('products');
        $quantities = $request->validated('quantity');

        unset($data['products']);

        if(isset($data['id'])) {
            $order = Order::query()->where('id', $data['id'])->first();
            $status = $order->order_status_id;
            $statusErrors = $this->validateMountStatusChange($order, $data['order_status_id'] ?? null);

            if ($statusErrors !== []) {
                return $this->mountStatusValidationFailed($request, $statusErrors);
            }

            $order->update($data);
            $order->refresh();
            if($order->order_status_id != $status) {
                $notificationService->notifyOrderStatusChanged($order, auth()->user());
            }
        } else {
            $data['order_status_id'] = Order::STATUS_NEW;
            $order = Order::query()->create($data);
            $tg_group_name = '/' . $order->district->shortname
                . ' ' . $order->object_address
                . ' (' . $order->area->name . ')'
                . ' - ' . $order->user->name;
            $order->update(['tg_group_name' => $tg_group_name]);
            $notificationService->notifyOrderCreated($order, auth()->user());
        }

        // меняем список товаров заказа только если статус новый
        if($products && $quantities && ($order->order_status_id == 1)) {
            $desiredCounts = [];
            foreach ($products as $key => $productId) {
                $quantity = (int)($quantities[$key] ?? 0);
                if ($quantity < 1) {
                    continue;
                }

                if (!isset($desiredCounts[$productId])) {
                    $desiredCounts[$productId] = 0;
                }
                $desiredCounts[$productId] += $quantity;
            }

            $attachedSkus = ProductSKU::query()
                ->where('order_id', $order->id)
                ->whereNotNull('maf_order_id')
                ->with('product:id,article')
                ->get();

            $attachedByProduct = [];
            foreach ($attachedSkus as $sku) {
                if (!isset($attachedByProduct[$sku->product_id])) {
                    $attachedByProduct[$sku->product_id] = 0;
                }
                $attachedByProduct[$sku->product_id]++;
            }

            $currentCounts = ProductSKU::query()
                ->where('order_id', $order->id)
                ->selectRaw('product_id, COUNT(*) as cnt')
                ->groupBy('product_id')
                ->pluck('cnt', 'product_id')
                ->map(fn ($count) => (int)$count)
                ->toArray();

            $errors = [];
            foreach ($attachedByProduct as $productId => $attachedCount) {
                $desiredCount = $desiredCounts[$productId] ?? 0;
                if ($desiredCount < $attachedCount) {
                    $article = $attachedSkus->firstWhere('product_id', $productId)?->product?->article ?? ('ID ' . $productId);
                    $errors[] = "Нельзя удалить привязанные МАФ {$article}: привязано {$attachedCount} шт.";
                }
            }

            // Если есть хотя бы один привязанный МАФ, запрещаем добавлять новые позиции/количество.
            if (!empty($attachedByProduct)) {
                foreach ($desiredCounts as $productId => $desiredCount) {
                    $currentCount = $currentCounts[$productId] ?? 0;
                    if ($desiredCount > $currentCount) {
                        $errors[] = 'Нельзя добавлять новые позиции МАФ, пока на площадке есть привязанные МАФ.';
                        break;
                    }
                }
            }

            if (!empty($errors)) {
                return redirect()->back()->withInput()->with(['danger' => $errors]);
            }

            // Удаляем только непривязанные SKU и пересоздаём их по новому списку.
            ProductSKU::query()
                ->where('order_id', $order->id)
                ->whereNull('maf_order_id')
                ->delete();

            foreach ($desiredCounts as $productId => $desiredCount) {
                $attachedCount = $attachedByProduct[$productId] ?? 0;
                $toCreate = $desiredCount - $attachedCount;

                for ($i = 0; $i < $toCreate; $i++) {
                    ProductSKU::query()->create([
                        'order_id' => $order->id,
                        'product_id' => $productId,
                        'status' => 'требуется'
                    ]);
                }
            }
        }

        $order->refresh();
        $order->autoChangeStatus();

        $nav = $this->resolveNavToken($request);

        return redirect()->route('order.show', $this->withNav(['order' => $order], $nav));
    }

    private function validateMountStatusChange(Order $order, mixed $newStatusId): array
    {
        if ((int) $newStatusId !== Order::STATUS_IN_MOUNT) {
            return [];
        }

        return $order->getMountStatusErrors();
    }

    private function mountStatusValidationFailed(Request $request, array $errors)
    {
        if ($request->expectsJson() || $request->ajax()) {
            return response()->json([
                'message' => $errors[0],
                'errors' => $errors,
            ], 422);
        }

        return redirect()->back()->withInput()->with(['danger' => $errors]);
    }

    private function applyOrderVisibilityScope($query, ?User $user): void
    {
        $scope = $user?->visibilityScope('orders');

        match ($scope) {
            'admin', 'manager' => null,
            'brigadier' => $query
                ->where('brigadier_id', $user->id)
                ->whereIn('order_status_id', Order::visibleStatusIdsForBrigadier()),
            'warehouse_head' => $query
                ->whereNotNull('brigadier_id')
                ->whereNotNull('installation_date'),
            default => $query->whereRaw('1 = 0'),
        };
    }

    private function canViewOrderByVisibilityScope(Order $order, ?User $user): bool
    {
        return match ($user?->visibilityScope('orders')) {
            'admin', 'manager' => true,
            'brigadier' => (int)$order->brigadier_id === (int)$user->id
                && in_array((int)$order->order_status_id, Order::visibleStatusIdsForBrigadier(), true),
            'warehouse_head' => $order->brigadier_id !== null && $order->installation_date !== null,
            default => false,
        };
    }

    /**
     * Display the specified resource.
     */
    public function show(Request $request, int $order)
    {
        $this->data['order'] = Order::query()
            ->withoutGlobalScope(\App\Models\Scopes\YearScope::class)
            ->with([
                'chatMessages.user',
                'chatMessages.targetUser',
                'chatMessages.notifiedUsers',
                'chatMessages.files',
            ])
            ->find($order);

        if ($request->boolean('sync_year') && $this->data['order']) {
            $previousYear = year();
            $targetYear = (int)$this->data['order']->year;

            if ($previousYear !== $targetYear) {
                session(['year' => $targetYear]);
                session()->flash('warning', "Год переключен: {$previousYear} → {$targetYear} (по году площадки).");
            }
        }

        if ($this->data['order'] && !$this->canViewOrderByVisibilityScope($this->data['order'], $request->user())) {
            abort(403);
        }

        $nav = $this->resolveNavToken($request);
        $this->rememberNavigation($request, $nav);
        $this->data['nav'] = $nav;
        $this->data['back_url'] = $this->navigationBackUrl(
            $request,
            $nav,
            route('order.index', session('gp_orders'))
        );
        $orderModel = $this->data['order'];
        $chatUsers = User::query()->orderBy('name')->get(['id', 'name', 'role']);
        $responsibleUserIds = User::query()
            ->withPermission('orders.scope.admin')
            ->pluck('id')
            ->map(static fn ($id) => (int) $id)
            ->all();
        $responsibleUserIds = array_values(array_unique(array_filter(array_merge($responsibleUserIds, [
            $orderModel?->user_id ? (int) $orderModel->user_id : null,
            $orderModel?->brigadier_id ? (int) $orderModel->brigadier_id : null,
        ]))));

        $this->data['chatUsers'] = $chatUsers->map(fn ($u) => [
            'id' => $u->id,
            'name' => $u->name,
            'role' => $u->role,
        ])->keyBy('id');
        $this->data['chatResponsibleUserIds'] = $responsibleUserIds;
        $this->data['chatManagerUserId'] = $orderModel?->user_id ? (int) $orderModel->user_id : null;
        $this->data['chatBrigadierUserId'] = $orderModel?->brigadier_id ? (int) $orderModel->brigadier_id : null;
        $this->data['contractors'] = Contractor::query()
            ->where('hidden', false)
            ->orderBy('name')
            ->pluck('name', 'id');
        return view('orders.show', $this->data);
    }

    /**
     * Show the form for editing the specified resource.
     */
    public function edit(Request $request, Order $order)
    {
        $this->data['order'] = $order;
        $nav = $this->resolveNavToken($request);
        $this->rememberNavigation($request, $nav);
        $this->data['nav'] = $nav;
        $this->data['back_url'] = $this->navigationBackUrl(
            $request,
            $nav,
            route('order.index', session('gp_orders'))
        );
        return view('orders.edit', $this->data);
    }

    /**
     * Привязка товаров к заказу
     * @param Order $order
     * @return RedirectResponse
     * @throws Throwable
     */
    public function getMafToOrder(Order $order)
    {
        $attached = 0;
        $missingByProduct = [];

        DB::transaction(function () use ($order, &$attached, &$missingByProduct) {
            foreach ($order->products_sku as $productSku) {
                // Уже привязан, пропускаем
                if ($productSku->maf_order_id) {
                    continue;
                }

                $mafOrder = MafOrder::query()
                    ->where('product_id', $productSku->product_id)
                    ->where('in_stock', '>', 0)
                    ->orderBy('created_at')
                    ->lockForUpdate()
                    ->first();

                if (!$mafOrder) {
                    $article = $productSku->product?->article ?? ('ID ' . $productSku->product_id);
                    if (!isset($missingByProduct[$productSku->product_id])) {
                        $missingByProduct[$productSku->product_id] = ['article' => $article, 'count' => 0];
                    }
                    $missingByProduct[$productSku->product_id]['count']++;
                    continue;
                }

                $productSku->update(['maf_order_id' => $mafOrder->id, 'status' => 'отгружен']);
                $mafOrder->decrement('in_stock');
                $attached++;
            }
        });

        $order->autoChangeStatus();

        $success = [];
        $danger = [];

        if ($attached > 0) {
            $success[] = "Привязано МАФ: {$attached}.";
        }

        foreach ($missingByProduct as $missing) {
            $danger[] = "Не удалось привязать {$missing['count']} шт. МАФ {$missing['article']}: нет остатка на складе.";
        }

        if ($attached === 0 && empty($danger)) {
            $danger[] = 'Нет МАФ для привязки: все МАФы на площадке уже привязаны.';
        }

        $flash = [];
        if (!empty($success)) {
            $flash['success'] = $success;
        }
        if (!empty($danger)) {
            $flash['danger'] = $danger;
        }

        return redirect()->route('order.show', $order)->with($flash);
    }

    /**
     * @param Order $order
     * @return RedirectResponse
     */
    public function destroy(Order $order)
    {
        Order::query()->where('id', $order->id)->delete();
        ProductSKU::query()->where('order_id', $order->id)->delete();
        return redirect()->route('order.index', session('gp_orders'));
    }

    public function revertMaf(Order $order)
    {
        $detached = 0;
        $notFoundMafOrders = 0;

        DB::transaction(function () use ($order, &$detached, &$notFoundMafOrders) {
            foreach ($order->products_sku as $maf) {
                if (!$maf->maf_order_id) {
                    continue;
                }

                $affectedRows = MafOrder::query()
                    ->where('id', $maf->maf_order_id)
                    ->lockForUpdate()
                    ->increment('in_stock');

                if (!$affectedRows) {
                    $notFoundMafOrders++;
                    continue;
                }

                $maf->update(['maf_order_id' => null, 'status' => 'требуется']);
                $detached++;
            }
        });

        $order->autoChangeStatus();

        $success = [];
        $danger = [];

        if ($detached > 0) {
            $success[] = "Отвязано МАФ: {$detached}.";
        }

        if ($notFoundMafOrders > 0) {
            $danger[] = "Не удалось отвязать {$notFoundMafOrders} шт. МАФ: связанный заказ МАФ не найден.";
        }

        if ($detached === 0 && empty($danger)) {
            $danger[] = 'Нет МАФ для отвязки: на площадке нет привязанных МАФ.';
        }

        $flash = [];
        if (!empty($success)) {
            $flash['success'] = $success;
        }
        if (!empty($danger)) {
            $flash['danger'] = $danger;
        }

        return redirect()->route('order.show', $order)->with($flash);
    }

    public function moveMaf(Request $request)
    {
        $data = $request->validate([
            'new_order_id' => 'required',
            'ids' => 'required|json',
        ]);

        $ids = json_decode($data['ids'], true);
        $updated = [];
        foreach ($ids as $mafId) {
            $maf = ProductSKU::query()
                ->where('id', $mafId)
                ->first();
            if($maf) {
                $comment = $maf->comment . "\n" . date('Y-m-d H:i') . ' Перенесено с площадки: ' . $maf->order->common_name;
                $maf->update(['order_id' => $data['new_order_id'], 'comment' => $comment]);
                $updated[] = $maf;
            }
        }
        return response()->json(['success' => true]);
    }

    public function search(Request $request): array
    {
        $ret = [];
        $s = $request->get('s');
        $currentOrderId = $request->integer('current_order_id');
        $searchFields = $this->data['searchFields'];
        $result = OrderView::query();
        if($s) {
            $result->where(function ($query) use ($searchFields, $s) {
                foreach ($searchFields as $searchField) {
                    $query->orWhere($searchField, 'LIKE', '%' . $s . '%');
                }
            });
        }

        if ($currentOrderId > 0) {
            $result->where('id', '!=', $currentOrderId);
        }

        $result->orderBy('object_address');
        foreach ($result->get() as $p) {
            $ret[$p->id] = $p->move_maf_name;
        }
        return $ret;
    }

    public function uploadPhoto(Request $request, Order $order, FileService $fileService)
    {
        $data = $request->validate([
            'photo' => 'required|array',
            'photo.*' => 'file|mimes:jpeg,jpg,png,webp',
        ]);

        try {
            $f = [];
            foreach ($data['photo'] as $photo) {
                $f[] = $fileService->saveUploadedFile('orders/' . $order->id . '/photo', $photo);
            }
            $order->photos()->syncWithoutDetaching($f);
        } catch (Throwable $e) {
            report($e);
            return redirect()->route('order.show', $order)
                ->with(['error' => 'Ошибка загрузки фотографий. Проверьте имя файла и повторите попытку.']);
        }

        return redirect()->route('order.show', $order)->with(['success' => 'Фотографии успешно загружены!']);
    }

    public function deletePhoto(int $order, File $file, FileService $fileService)
    {
        $order = $this->findOrderWithoutYearScope($order);
        abort_unless($order->photos()->whereKey($file->id)->exists(), 404);

        $order->photos()->detach($file);
        $fileService->deleteFileWithThumbnail($file);
        $file->delete();
        return redirect()->route('order.show', $order);
    }

    public function deleteAllPhotos(int $order, FileService $fileService)
    {
        $order = $this->findOrderWithoutYearScope($order);
        $files = $order->photos;
        $order->photos()->detach();
        foreach ($files as $file) {
            $fileService->deleteFileWithThumbnail($file);
            $file->delete();
        }
        return redirect()->route('order.show', $order);
    }

    public function uploadDocument(Request $request, Order $order, FileService $fileService)
    {
        $data = $request->validate([
            'document.*' => 'file',
        ]);

        try {
            $f = [];
            $i = 0;
            foreach ($data['document'] as $document) {
                if ($i++ >= 5) break;
                $f[] = $fileService->saveUploadedFile('orders/' . $order->id . '/document', $document);
            }
            $order->documents()->syncWithoutDetaching($f);
        } catch (Throwable $e) {
            report($e);
            return redirect()->route('order.show', $order)
                ->with(['error' => 'Ошибка загрузки документов. Проверьте имя файла и повторите попытку.']);
        }

        return redirect()->route('order.show', $order)->with(['success' => 'Документы успешно загружены!']);
    }

    public function deleteDocument(int $order, File $file)
    {
        $order = $this->findOrderWithoutYearScope($order);
        abort_unless($order->documents()->whereKey($file->id)->exists(), 404);

        $order->documents()->detach($file);
        Storage::disk('public')->delete($file->path);
        $file->delete();
        return redirect()->route('order.show', $order);
    }

    public function deleteAllDocuments(int $order)
    {
        $order = $this->findOrderWithoutYearScope($order);
        $files = $order->documents;
        $order->documents()->detach();
        foreach ($files as $file) {
            Storage::disk('public')->delete($file->path);
            $file->delete();
        }
        return redirect()->route('order.show', $order);
    }

    public function uploadStatement(Request $request, Order $order, FileService $fileService)
    {
        $data = $request->validate([
            'statement.*' => 'file',
        ]);

        try {
            $f = [];
            $i = 0;
            foreach ($data['statement'] as $statement) {
                if ($i++ >= 5) break;
                $f[] = $fileService->saveUploadedFile('orders/' . $order->id . '/statement', $statement);
            }
            $order->statements()->syncWithoutDetaching($f);
        } catch (Throwable $e) {
            report($e);
            return redirect()->route('order.show', $order)
                ->with(['error' => 'Ошибка загрузки ведомостей. Проверьте имя файла и повторите попытку.']);
        }

        return redirect()->route('order.show', $order)->with(['success' => 'Ведомости успешно загружены!']);
    }

    public function deleteStatement(int $order, File $file)
    {
        $order = $this->findOrderWithoutYearScope($order);
        abort_unless($order->statements()->whereKey($file->id)->exists(), 404);

        $order->statements()->detach($file);
        Storage::disk('public')->delete($file->path);
        $file->delete();
        return redirect()->route('order.show', $order);
    }

    public function deleteAllStatements(int $order)
    {
        $order = $this->findOrderWithoutYearScope($order);
        $files = $order->statements;
        $order->statements()->detach();
        foreach ($files as $file) {
            Storage::disk('public')->delete($file->path);
            $file->delete();
        }
        return redirect()->route('order.show', $order);
    }

    private function findOrderWithoutYearScope(int $orderId): Order
    {
        return Order::query()
            ->withoutGlobalScope(\App\Models\Scopes\YearScope::class)
            ->findOrFail($orderId);
    }

    public function generateInstallationPack(Order $order)
    {
        $errors = $order->isAllMafConnected();
        if($errors) {
            return redirect()->route('order.show', $order)->with(['danger' => $errors]);
        }

        GenerateInstallationPack::dispatch($order, auth()->user()->id);
        return redirect()->route('order.show', $order)->with(['success' => 'Задача генерации документов создана!']);
    }

    public function generateHandoverPack(Order $order)
    {
        if($errors = $order->canCreateHandover()) {
            return redirect()->route('order.show', $order)->with(['danger' => $errors]);
        }
        GenerateHandoverPack::dispatch($order, auth()->user()->id);
        return redirect()->route('order.show', $order)->with(['success' => 'Задача генерации документов создана!']);
    }

    public function generatePhotosPack(Order $order)
    {
        GenerateFilesPack::dispatch($order, $order->photos, auth()->user()->id, 'Фото');
        return redirect()->back()->with(['success' => 'Задача архивации создана!']);
    }

    public function createTtn(CreteTtnRequest $request)
    {
        $ttn = Ttn::query()->create([
            'year' => date('Y'),
            'ttn_number'    => Ttn::reserveNextTtnNumber(),
            'ttn_number_suffix' => 'И',
            'order_number'  => $request->order_number,
            'order_date'    => $request->order_date,
            'departure_date' => $request->departure_date,
            'order_sum'     => $request->order_sum,
            'skus'          => json_encode($request->skus),
        ]);
        GenerateTtnPack::dispatch($ttn, auth()->user()->id);
        return redirect()->back()->with(['success' => 'Задача формирования ТН создана!']);
    }

    public function createContractorSpecification(Request $request, int $order, ContractorSpecificationService $service): BinaryFileResponse|RedirectResponse
    {
        $validated = $request->validate([
            'contractor_id' => ['required', 'integer', 'exists:contractors,id'],
            'specification_number' => ['required', 'string', 'max:255'],
            'specification_date' => ['required', 'date'],
            'work_start_date' => ['nullable', 'date'],
            'work_end_date' => ['nullable', 'date'],
            'skus' => ['required', 'array', 'min:1'],
            'skus.*' => ['required', 'integer', 'exists:products_sku,id'],
        ]);

        $contractor = Contractor::query()
            ->where('hidden', false)
            ->findOrFail($validated['contractor_id']);

        $orderModel = Order::query()
            ->withoutGlobalScope(\App\Models\Scopes\YearScope::class)
            ->findOrFail($order);

        $path = $service->generate($orderModel, $contractor, $validated);
        $specificationDate = Carbon::parse($validated['specification_date'])->format('d.m.Y');

        return response()
            ->download($path, 'Спецификация №' . $validated['specification_number'] . ' от ' . $specificationDate . '.xlsx')
            ->deleteFileAfterSend();
    }

    public function addStatementToMafs(Request $request, int $order): RedirectResponse
    {
        abort_unless(
            $request->user()?->canUpdateField('maf', 'statement_number')
            && $request->user()?->canUpdateField('maf', 'statement_date'),
            403
        );

        $validated = $request->validate([
            'statement_number' => ['required', 'string', 'max:255'],
            'statement_date' => ['required', 'date'],
            'skus' => ['required', 'array', 'min:1'],
            'skus.*' => ['required', 'integer', 'exists:products_sku,id'],
        ]);

        $orderModel = Order::query()
            ->withoutGlobalScope(\App\Models\Scopes\YearScope::class)
            ->findOrFail($order);

        $updated = ProductSKU::query()
            ->withoutGlobalScope(\App\Models\Scopes\YearScope::class)
            ->where('order_id', $orderModel->id)
            ->whereIn('id', $validated['skus'])
            ->update([
                'statement_number' => $validated['statement_number'],
                'statement_date' => $validated['statement_date'],
            ]);

        if ($updated === 0) {
            return redirect()->back()->with(['danger' => 'Выбранные МАФ не найдены на этой площадке.']);
        }

        app(OrderPaymentStatusService::class)->markPaidIfAllMafsHavePaymentData($orderModel);

        return redirect()->back()->with(['success' => "Ведомость добавлена к МАФ: {$updated}."]);
    }

    public function export(Request $request)
    {
        $request->validate([
            'withFilter' => 'nullable',
            'filters' => 'nullable|array',
            's' => 'nullable|string',
        ]);

        $orders = Order::query();

        if ($request->boolean('withFilter')) {
            $filterRequest = new Request(array_filter([
                'filters' => $request->input('filters', []),
                's' => $request->input('s'),
                'sortBy' => $request->input('sortBy'),
                'order' => $request->input('order'),
            ], static fn ($value) => $value !== null));

            $model = new OrderView;
            $this->createFilters($model, 'user_name', 'district_name', 'area_name', 'object_type_name', 'brigadier_name', 'order_status_name', 'ready_to_mount');
            $this->createDateFilters($model, 'installation_date', 'ready_date');
            $this->data['ranges'] = [];

            $q = $model::query();
            $this->acceptFilters($q, $filterRequest);
            $this->acceptSearch($q, $filterRequest);
            $this->setSortAndOrderBy($model, $filterRequest);

            $this->applyOrderVisibilityScope($q, $request->user());

            $this->applyStableSorting($q);
            $orderIds = $q->pluck('id');

            $orders = Order::query()
                ->whereIn('id', $orderIds)
                ->get()
                ->sortBy(static fn (Order $order) => $orderIds->search($order->id))
                ->values();
        } else {
            $this->applyOrderVisibilityScope($orders, $request->user());
            $orders = $orders->get();
        }

        ExportOrdersJob::dispatch($orders, $request->user()->id);
        return redirect()->route('order.index', session('gp_orders'))
            ->with(['success' => 'Задача выгрузки создана!']);
    }
    public function exportOne(Order $order, Request $request)
    {

        ExportOneOrderJob::dispatch($order, $request->user()->id);
        return redirect()->route('order.show', $order->id)
            ->with(['success' => 'Задача выгрузки создана!']);

    }

    public function downloadTechDocs(Order $order): BinaryFileResponse
    {
        $techDocsPath = public_path('images/tech-docs');
        $articles = $order->products_sku
            ->pluck('product.article')
            ->unique()
            ->filter()
            ->values();

        if ($articles->isEmpty()) {
            abort(404, 'Нет МАФов на площадке');
        }

        $tempFile = tempnam(sys_get_temp_dir(), 'tech_docs_');
        if ($tempFile === false) {
            abort(500, 'Не удалось создать временный файл архива');
        }

        $zip = new ZipArchive();
        $result = $zip->open($tempFile, ZipArchive::CREATE | ZipArchive::OVERWRITE);
        if ($result !== true) {
            @unlink($tempFile);
            abort(500, 'Не удалось создать архив документации');
        }

        $filesAdded = 0;
        foreach ($articles as $article) {
            $articlePath = $techDocsPath . '/' . $article;
            if (!is_dir($articlePath)) {
                continue;
            }

            $files = new \RecursiveIteratorIterator(
                new \RecursiveDirectoryIterator($articlePath, \RecursiveDirectoryIterator::SKIP_DOTS),
                \RecursiveIteratorIterator::LEAVES_ONLY
            );

            foreach ($files as $file) {
                if ($file->isFile()) {
                    $relativePath = $article . '/' . $file->getFilename();
                    $zip->addFile($file->getRealPath(), $relativePath);
                    $filesAdded++;
                }
            }
        }

        if (!$filesAdded) {
            $zip->addFromString('readme.txt', 'Нет документации для этих МАФ!');
        }

        $zip->close();

        // WebView clients are more reliable with ASCII attachment names.
        $archiveName = 'tech_docs_order_' . $order->id . '_' . Str::slug((string)$order->object_address) . '.zip';
        $archiveName = trim($archiveName, '._');
        if ($archiveName === '.zip' || $archiveName === 'zip' || $archiveName === '') {
            $archiveName = 'tech_docs_order_' . $order->id . '.zip';
        }

        return response()->download($tempFile, $archiveName, [
            'Content-Type' => 'application/zip',
        ])->deleteFileAfterSend(true);
    }

}