strprfcrm/app/Http/Controllers/ReclamationController.php

<?php

namespace App\Http\Controllers;

use App\Http\Requests\CreateReclamationRequest;
use App\Http\Requests\StoreReclamationDetailsRequest;
use App\Http\Requests\StoreReclamationRequest;
use App\Http\Requests\StoreReclamationSparePartsRequest;
use App\Jobs\ExportReclamationsJob;
use App\Jobs\GenerateFilesPack;
use App\Jobs\GenerateReclamationPaymentPack;
use App\Jobs\GenerateReclamationPack;
use App\Models\File;
use App\Models\Order;
use App\Models\Reclamation;
use App\Models\ReclamationDetail;
use App\Models\ReclamationStatus;
use App\Models\ReclamationView;
use App\Models\Role;
use App\Models\User;
use App\Services\FileService;
use App\Services\NotificationService;
use App\Services\SparePartReservationService;
use Illuminate\Http\Request;
use Illuminate\Support\Carbon;
use Illuminate\Support\Facades\Storage;
use Throwable;

class ReclamationController extends Controller
{
    protected array $data = [
        'active' => 'reclamations',
        'title' => 'Рекламации',
        'id' => 'reclamations',
        'header' => [
            'id' => 'ID',
            'user_name' => 'Менеджер',
            'status_name' => 'Статус',
            'district_name' => 'Округ',
            'area_name' => 'Район',
            'object_address' => 'Адрес объекта',
            'maf_installation_year' => 'Год установки МАФ',
            'create_date' => 'Дата создания',
            'finish_date' => 'Дата завершения',
            'start_work_date' => 'Дата начала работ',
            'work_days' => 'Срок работ, дней',
            'brigadier_name' => 'Бригадир',
            'reason' => 'Причина',
            'guarantee' => 'Гарантии',
            'whats_done' => 'Что сделано',
            'comment' => 'Комментарий',
        ],
        'searchFields' => [
            'reason',
            'guarantee',
            'whats_done',
            'comment',
        ],
        'ranges' => [],
    ];

    public function __construct()
    {
        $this->data['users'] = User::query()->whereIn('role', [Role::MANAGER, Role::ADMIN])->get()->pluck('name', 'id');
        $this->data['statuses'] = ReclamationStatus::query()->get()->pluck('name', 'id');
    }

    public function index(Request $request)
    {
        session(['gp_reclamations' => $request->all()]);
        $nav = $this->resolveNavToken($request);
        $this->rememberNavigation($request, $nav);
        $model = new ReclamationView();
        // fill filters
        $this->createFilters($model, 'user_name', 'status_name');
        $this->createDateFilters($model, 'create_date', 'finish_date');

        $q = $model::query();

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

        if (hasRole(Role::BRIGADIER)) {
            $q->where('brigadier_id', auth()->id())
                ->whereIn('status_id', Reclamation::visibleStatusIdsForBrigadier());
        } elseif (hasRole(Role::WAREHOUSE_HEAD)) {
            $q->whereNotNull('brigadier_id')
                ->whereIn('status_id', Reclamation::visibleStatusIdsForBrigadier());
        }

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

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

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

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

        $model = new ReclamationView();
        $this->createFilters($model, 'user_name', 'status_name');
        $this->createDateFilters($model, 'create_date', 'finish_date');

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

        $reclamationIds = $q->pluck('id')->toArray();

        ExportReclamationsJob::dispatch($reclamationIds, $request->user()->id);

        return redirect()->route('reclamations.index', session('gp_reclamations'))
            ->with(['success' => 'Задача экспорта рекламаций создана!']);
    }

    public function create(CreateReclamationRequest $request, Order $order, NotificationService $notificationService)
    {
        $nav = $this->resolveNavToken($request);
        $reclamation = Reclamation::query()->create([
            'order_id' => $order->id,
            'user_id' => $request->user()->id,
            'status_id' => Reclamation::STATUS_NEW,
            'create_date' => Carbon::now(),
            'finish_date' => Carbon::now()->addDays(30),
        ]);
        $skus = $request->validated('skus');
        $reclamation->skus()->attach($skus);
        $notificationService->notifyReclamationCreated($reclamation->fresh(['order', 'status']), auth()->user());
        return redirect()->route('reclamations.show', $this->withNav(['reclamation' => $reclamation], $nav));
    }

    public function show(Request $request, Reclamation $reclamation)
    {
        $this->ensureCanViewReclamation($reclamation);

        $this->data['brigadiers'] = User::query()->where('role', Role::BRIGADIER)->get()->pluck('name', 'id');
        $this->data['reclamation'] = $reclamation->load([
            'order',
            'chatMessages.user',
            'chatMessages.targetUser',
            'chatMessages.notifiedUsers',
            'chatMessages.files',
        ]);
        $chatUsers = User::query()->orderBy('name')->get(['id', 'name', 'role']);
        $responsibleUserIds = User::query()
            ->where('role', Role::ADMIN)
            ->pluck('id')
            ->map(static fn ($id) => (int) $id)
            ->all();
        $responsibleUserIds = array_values(array_unique(array_filter(array_merge($responsibleUserIds, [
            $reclamation->user_id ? (int) $reclamation->user_id : null,
            $reclamation->brigadier_id ? (int) $reclamation->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'] = $reclamation->user_id ? (int) $reclamation->user_id : null;
        $this->data['chatBrigadierUserId'] = $reclamation->brigadier_id ? (int) $reclamation->brigadier_id : null;
        $nav = $this->resolveNavToken($request);
        $this->rememberNavigation($request, $nav);
        $this->data['nav'] = $nav;
        $this->data['back_url'] = $this->navigationBackUrl(
            $request,
            $nav,
            route('reclamations.index', session('gp_reclamations'))
        );
        return view('reclamations.edit', $this->data);
    }

    public function update(StoreReclamationRequest $request, Reclamation $reclamation, NotificationService $notificationService)
    {
        $data = $request->validated();
        $oldStatusId = $reclamation->status_id;
        $reclamation->update($data);

        if ((int) $oldStatusId !== (int) $reclamation->status_id) {
            $notificationService->notifyReclamationStatusChanged($reclamation->fresh(['order', 'status']), auth()->user());
        }

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

        if ($request->ajax()) {
            return response()->noContent();
        }

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

    public function updateStatus(Request $request, Reclamation $reclamation, NotificationService $notificationService)
    {
        if (!hasRole('admin,manager')) {
            abort(403);
        }

        $validated = $request->validate([
            'status_id' => 'required|exists:reclamation_statuses,id',
        ]);

        $reclamation->update(['status_id' => $validated['status_id']]);
        $notificationService->notifyReclamationStatusChanged($reclamation->fresh(['order', 'status']), auth()->user());

        return response()->noContent();
    }

    public function delete(Reclamation $reclamation)
    {
        $reclamation->delete();
        return redirect()->route('reclamations.index');
    }

    public function uploadPhotoBefore(Request $request, Reclamation $reclamation, FileService $fileService)
    {
        $this->ensureHasRole([Role::ADMIN, Role::MANAGER]);
        $this->ensureCanViewReclamation($reclamation);

        $data = $request->validate([
            'photo.*' => 'mimes:jpeg,jpg,png,webp|max:8192',
        ]);

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

        return $this->redirectToReclamationShow($request, $reclamation)
            ->with(['success' => 'Фотографии проблемы успешно загружены!']);
    }

    public function uploadPhotoAfter(Request $request, Reclamation $reclamation, FileService $fileService)
    {
        $this->ensureCanViewReclamation($reclamation);

        $data = $request->validate([
            'photo.*' => 'mimes:jpeg,jpg,png,webp|max:8192',
        ]);

        try {
            $f = [];
            foreach ($data['photo'] as $photo) {
                $f[] = $fileService->saveUploadedFile('reclamations/' . $reclamation->id . '/photo_after', $photo);
            }
            $reclamation->photos_after()->syncWithoutDetaching($f);
        } catch (Throwable $e) {
            report($e);
            return $this->redirectToReclamationShow($request, $reclamation)
                ->with(['error' => 'Ошибка загрузки фотографий после устранения. Проверьте имя файла и повторите попытку.']);
        }

        return $this->redirectToReclamationShow($request, $reclamation)
            ->with(['success' => 'Фотографии после устранения успешно загружены!']);
    }

    public function deletePhotoBefore(Request $request, Reclamation $reclamation, File $file, FileService $fileService)
    {
        $this->ensureHasRole([Role::ADMIN, Role::MANAGER]);
        $this->ensureCanViewReclamation($reclamation);

        $reclamation->photos_before()->detach($file);
        Storage::disk('public')->delete($file->path);
        $file->delete();
        return $this->redirectToReclamationShow($request, $reclamation);
    }

    public function deletePhotoAfter(Request $request, Reclamation $reclamation, File $file, FileService $fileService)
    {
        $this->ensureHasRole([Role::ADMIN, Role::MANAGER]);
        $this->ensureCanViewReclamation($reclamation);

        $reclamation->photos_after()->detach($file);
        Storage::disk('public')->delete($file->path);
        $file->delete();
        return $this->redirectToReclamationShow($request, $reclamation);
    }

    public function uploadDocument(Request $request, Reclamation $reclamation, FileService $fileService)
    {
        $this->ensureHasRole([Role::ADMIN, Role::MANAGER]);
        $this->ensureCanViewReclamation($reclamation);

        $data = $request->validate([
            'document.*' => 'file',
        ]);

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

        return $this->redirectToReclamationShow($request, $reclamation)
            ->with(['success' => 'Документы рекламации успешно загружены!']);
    }

    public function deleteDocument(Request $request, Reclamation $reclamation, File $file)
    {
        $this->ensureHasRole([Role::ADMIN, Role::MANAGER]);
        $this->ensureCanViewReclamation($reclamation);

        $reclamation->documents()->detach($file);
        Storage::disk('public')->delete($file->path);
        $file->delete();
        return $this->redirectToReclamationShow($request, $reclamation);
    }

    public function uploadAct(Request $request, Reclamation $reclamation, FileService $fileService)
    {
        $this->ensureHasRole([Role::ADMIN, Role::MANAGER, Role::BRIGADIER, Role::WAREHOUSE_HEAD]);
        $this->ensureCanViewReclamation($reclamation);

        $data = $request->validate([
            'acts.*' => 'file',
        ]);

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

        return $this->redirectToReclamationShow($request, $reclamation)
            ->with(['success' => 'Акты успешно загружены!']);
    }

    public function deleteAct(Request $request, Reclamation $reclamation, File $file)
    {
        $this->ensureHasRole([Role::ADMIN, Role::MANAGER]);
        $this->ensureCanViewReclamation($reclamation);

        $reclamation->acts()->detach($file);
        Storage::disk('public')->delete($file->path);
        $file->delete();
        return $this->redirectToReclamationShow($request, $reclamation);
    }

    public function updateDetails(StoreReclamationDetailsRequest $request, Reclamation $reclamation)
    {
        $names = $request->validated('name');
        $quantity = $request->validated('quantity');
        $withDocuments = $request->validated('with_documents');

        $reservationService = app(SparePartReservationService::class);

        foreach ($names as $key => $name) {
            if (!$name) continue;

            if ((int)$quantity[$key] >= 1) {
                // Проверяем, является ли это запчастью
                $sparePart = \App\Models\SparePart::where('article', $name)->first();

                if ($sparePart) {
                    // Резервирование вместо прямого списания
                    $withDocs = isset($withDocuments[$key]) && $withDocuments[$key];
                    $qty = (int)$quantity[$key];

                    // Получаем текущее количество в pivot
                    $currentPivot = $reclamation->spareParts()->find($sparePart->id);
                    $currentQty = $currentPivot?->pivot->quantity ?? 0;
                    $diff = $qty - $currentQty;

                    if ($diff > 0) {
                        // Нужно зарезервировать дополнительное количество
                        $result = $reservationService->reserve(
                            $sparePart->id,
                            $diff,
                            $withDocs,
                            $reclamation->id
                        );

                        // Обновляем pivot с учётом результата
                        $reclamation->spareParts()->syncWithoutDetaching([
                            $sparePart->id => [
                                'quantity' => $qty,
                                'with_documents' => $withDocs,
                                'status' => $result->isFullyReserved() ? 'reserved' : 'pending',
                                'reserved_qty' => $currentQty + $result->reserved,
                            ]
                        ]);
                    } elseif ($diff < 0) {
                        // Уменьшение — отменяем часть резерва
                        $reservationService->adjustReservation(
                            $reclamation->id,
                            $sparePart->id,
                            $withDocs,
                            $qty
                        );

                        $reclamation->spareParts()->syncWithoutDetaching([
                            $sparePart->id => [
                                'quantity' => $qty,
                                'with_documents' => $withDocs,
                                'reserved_qty' => $qty,
                            ]
                        ]);
                    } else {
                        // Количество не изменилось, возможно изменился with_documents
                        $reclamation->spareParts()->syncWithoutDetaching([
                            $sparePart->id => [
                                'quantity' => $qty,
                                'with_documents' => $withDocs,
                            ]
                        ]);
                    }
                } else {
                    // Обычная деталь
                    ReclamationDetail::query()->updateOrCreate(
                        ['reclamation_id' => $reclamation->id, 'name' => $name],
                        ['quantity' => $quantity[$key]]
                    );
                }
            } else {
                // Удаление
                // Проверяем, является ли это запчастью — отменяем резервы
                $sparePartToRemove = \App\Models\SparePart::where('article', $name)->first();
                if ($sparePartToRemove) {
                    // Отменяем все резервы для этой запчасти в рекламации
                    $reservationService->cancelForReclamation(
                        $reclamation->id,
                        $sparePartToRemove->id
                    );
                    // Удаляем связь
                    $reclamation->spareParts()->detach($sparePartToRemove->id);
                } else {
                    // Обычная деталь
                    ReclamationDetail::query()
                        ->where('reclamation_id', $reclamation->id)
                        ->where('name', $name)
                        ->delete();
                }
            }
        }

        return $this->redirectToReclamationShow($request, $reclamation);
    }

    public function updateSpareParts(StoreReclamationSparePartsRequest $request, Reclamation $reclamation)
    {
        $rows = $request->validated('rows') ?? [];

        $reservationService = app(SparePartReservationService::class);

        // Получаем текущие привязки для сравнения
        $currentSpareParts = $reclamation->spareParts->keyBy('id');

        // Определяем какие запчасти были удалены
        $newSparePartIds = collect($rows)->pluck('spare_part_id')->filter()->toArray();
        $removedIds = $currentSpareParts->keys()->diff($newSparePartIds);

        // Отменяем резервы для удалённых запчастей
        foreach ($removedIds as $removedId) {
            $current = $currentSpareParts->get($removedId);
            if ($current) {
                $reservationService->cancelForReclamation(
                    $reclamation->id,
                    $removedId,
                    $current->pivot->with_documents
                );
            }
        }

        // Собираем новые привязки
        $newSpareParts = [];

        foreach ($rows as $row) {
            $sparePartId = $row['spare_part_id'] ?? null;
            if (empty($sparePartId)) continue;

            $quantity = (int)($row['quantity'] ?? 0);
            if ($quantity < 1) continue;

            $withDocs = !empty($row['with_documents']) && $row['with_documents'] != '0';

            // Проверяем, изменилось ли количество
            $currentQty = $currentSpareParts->get($sparePartId)?->pivot->quantity ?? 0;
            $currentReserved = $currentSpareParts->get($sparePartId)?->pivot->reserved_qty ?? 0;
            $diff = $quantity - $currentQty;

            $status = 'pending';
            $reservedQty = $currentReserved;

            if ($diff > 0) {
                // Нужно зарезервировать дополнительное количество
                $result = $reservationService->reserve(
                    $sparePartId,
                    $diff,
                    $withDocs,
                    $reclamation->id
                );

                $reservedQty = $currentReserved + $result->reserved;
                $status = $reservedQty >= $quantity ? 'reserved' : 'pending';
            } elseif ($diff < 0) {
                // Уменьшение — отменяем часть резерва
                $reservationService->adjustReservation(
                    $reclamation->id,
                    $sparePartId,
                    $withDocs,
                    $quantity
                );

                $reservedQty = $quantity;
                $status = 'reserved';
            } else {
                // Количество не изменилось
                $status = $currentReserved >= $quantity ? 'reserved' : 'pending';
            }

            $newSpareParts[$sparePartId] = [
                'quantity' => $quantity,
                'with_documents' => $withDocs,
                'status' => $status,
                'reserved_qty' => $reservedQty,
            ];
        }

        // Синхронизируем (заменяем все старые привязки новыми)
        $reclamation->spareParts()->sync($newSpareParts);

        return $this->redirectToReclamationShow($request, $reclamation);
    }

    public function generateReclamationPack(Request $request, Reclamation $reclamation)
    {
        GenerateReclamationPack::dispatch($reclamation, auth()->user()->id);
        return $this->redirectToReclamationShow($request, $reclamation)
            ->with(['success' => 'Задача генерации документов создана!']);
    }

    public function generateReclamationPaymentPack(Request $request, Reclamation $reclamation)
    {
        GenerateReclamationPaymentPack::dispatch($reclamation, auth()->user()->id);
        return $this->redirectToReclamationShow($request, $reclamation)
            ->with(['success' => 'Задача генерации пакета документов на оплату создана!']);
    }

    public function generatePhotosBeforePack(Request $request, Reclamation $reclamation)
    {
        GenerateFilesPack::dispatch($reclamation, $reclamation->photos_before, auth()->user()->id, 'Фото проблемы');
        return $this->redirectToReclamationShow($request, $reclamation)
            ->with(['success' => 'Задача архивации создана!']);
    }

    public function generatePhotosAfterPack(Request $request, Reclamation $reclamation)
    {
        GenerateFilesPack::dispatch($reclamation, $reclamation->photos_after, auth()->user()->id, 'Фото после');
        return $this->redirectToReclamationShow($request, $reclamation)
            ->with(['success' => 'Задача архивации создана!']);
    }

    private function ensureCanViewReclamation(Reclamation $reclamation): void
    {
        if (hasRole(Role::BRIGADIER)) {
            $canView = (int)$reclamation->brigadier_id === (int)auth()->id()
                && in_array((int)$reclamation->status_id, Reclamation::visibleStatusIdsForBrigadier(), true);

            if (!$canView) {
                abort(403);
            }
        }

        if (hasRole(Role::WAREHOUSE_HEAD)) {
            $canView = $reclamation->brigadier_id !== null
                && in_array((int)$reclamation->status_id, Reclamation::visibleStatusIdsForBrigadier(), true);

            if (!$canView) {
                abort(403);
            }
        }
    }

    private function ensureHasRole(array $roles): void
    {
        if (!count(array_intersect($roles, Role::effectiveRoles((string)auth()->user()?->role)))) {
            abort(403);
        }
    }

    private function redirectToReclamationShow(Request $request, Reclamation $reclamation)
    {
        $nav = $this->resolveNavToken($request);

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

}