strprfcrm/app/Http/Controllers/ChatMessageController.php

<?php

namespace App\Http\Controllers;

use App\Models\ChatMessage;
use App\Models\Order;
use App\Models\Reclamation;
use App\Models\Role;
use App\Models\User;
use App\Services\FileService;
use App\Services\NotificationService;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Throwable;

class ChatMessageController extends Controller
{
    public function storeForOrder(
        Request $request,
        Order $order,
        FileService $fileService,
        NotificationService $notificationService,
    ): RedirectResponse {
        $this->ensureCanViewOrder($order);

        if ($this->isDeleteRequest($request)) {
            $chatMessage = $this->resolveMessageForDeletion($request);
            $this->ensureAdminCanDeleteMessage($chatMessage, $order, null);
            $this->deleteMessage($chatMessage);

            return redirect()->back()->with(['success' => 'Сообщение удалено.']);
        }

        return $this->storeMessage(
            $request,
            $fileService,
            $notificationService,
            $order,
            null,
            'chat/orders/' . $order->id,
        );
    }

    public function storeForReclamation(
        Request $request,
        Reclamation $reclamation,
        FileService $fileService,
        NotificationService $notificationService,
    ): RedirectResponse {
        $this->ensureCanViewReclamation($reclamation);

        if ($this->isDeleteRequest($request)) {
            $chatMessage = $this->resolveMessageForDeletion($request);
            $this->ensureAdminCanDeleteMessage($chatMessage, null, $reclamation);
            $this->deleteMessage($chatMessage);

            return redirect()->back()->with(['success' => 'Сообщение удалено.']);
        }

        return $this->storeMessage(
            $request,
            $fileService,
            $notificationService,
            null,
            $reclamation,
            'chat/reclamations/' . $reclamation->id,
        );
    }

    public function destroyForOrder(Order $order, ChatMessage $chatMessage): RedirectResponse
    {
        $this->ensureAdminCanDeleteMessage($chatMessage, $order, null);
        $this->deleteMessage($chatMessage);

        return redirect()->back()->with(['success' => 'Сообщение удалено.']);
    }

    public function destroyForReclamation(Reclamation $reclamation, ChatMessage $chatMessage): RedirectResponse
    {
        $this->ensureAdminCanDeleteMessage($chatMessage, null, $reclamation);
        $this->deleteMessage($chatMessage);

        return redirect()->back()->with(['success' => 'Сообщение удалено.']);
    }

    private function storeMessage(
        Request $request,
        FileService $fileService,
        NotificationService $notificationService,
        ?Order $order,
        ?Reclamation $reclamation,
        string $filePath,
    ): RedirectResponse {
        $isPrivileged = hasRole(Role::ADMIN . ',' . Role::MANAGER);
        $isBrigadier = hasRole(Role::BRIGADIER);

        $validated = $request->validate([
            'message' => 'nullable|string',
            'notification_type' => 'nullable|string|in:none,responsibles,all,user',
            'target_user_id' => 'nullable|integer|exists:users,id,deleted_at,NULL',
            'target_user_ids' => 'nullable|array',
            'target_user_ids.*' => 'integer|exists:users,id,deleted_at,NULL',
            'attachments' => 'nullable|array|max:5',
            'attachments.*' => 'file|max:10240',
        ]);

        $notificationType = $validated['notification_type'] ?? ChatMessage::NOTIFICATION_NONE;
        if ($isBrigadier) {
            $notificationType = ChatMessage::NOTIFICATION_RESPONSIBLES;
        } elseif (!$isPrivileged) {
            $notificationType = ChatMessage::NOTIFICATION_NONE;
        }

        $messageText = trim((string) ($validated['message'] ?? ''));
        $attachments = $request->file('attachments', []);

        if ($messageText === '' && empty($attachments)) {
            return redirect()->back()->with(['danger' => 'Нужно указать сообщение или добавить файл.']);
        }

        $recipientIds = [];
        $targetUserId = null;
        if ($isBrigadier) {
            $recipientIds = $this->chatBrigadierRecipientIds($order, $reclamation, (int) auth()->id());
        } elseif ($notificationType === ChatMessage::NOTIFICATION_USER) {
            $targetUserId = (int) ($validated['target_user_id'] ?? 0);
            if ($targetUserId < 1) {
                return redirect()->back()->with(['danger' => 'Нужно выбрать пользователя для уведомления.']);
            }

            $recipientIds = [$targetUserId];
        }

        if (in_array($notificationType, [
            ChatMessage::NOTIFICATION_RESPONSIBLES,
            ChatMessage::NOTIFICATION_ALL,
        ], true)) {
            $recipientIds = $this->resolveTargetUserIds(
                $notificationType,
                $validated['target_user_ids'] ?? [],
                $order,
                $reclamation,
                (int) auth()->id(),
            );

            if (empty($recipientIds)) {
                return redirect()->back()->with(['danger' => 'Нужно выбрать хотя бы одного получателя уведомления.']);
            }
        }

        if (!in_array($notificationType, [ChatMessage::NOTIFICATION_USER], true)) {
            $targetUserId = null;
        }

        try {
            $chatMessage = ChatMessage::query()->create([
                'order_id' => $order?->id,
                'reclamation_id' => $reclamation?->id,
                'user_id' => (int) auth()->id(),
                'target_user_id' => $targetUserId,
                'notification_type' => $notificationType,
                'message' => $messageText !== '' ? $messageText : null,
            ]);

            if (!empty($recipientIds)) {
                $chatMessage->notifiedUsers()->syncWithoutDetaching($recipientIds);
            }

            $files = [];
            foreach ($attachments as $attachment) {
                $files[] = $fileService->saveUploadedFile($filePath, $attachment);
            }

            if (!empty($files)) {
                $chatMessage->files()->syncWithoutDetaching(collect($files)->pluck('id')->all());
            }

            if ($notificationType !== ChatMessage::NOTIFICATION_NONE) {
                $notificationService->notifyChatMessage($chatMessage->fresh([
                    'user',
                    'targetUser',
                    'files',
                    'order.user',
                    'order.brigadier',
                    'reclamation.order',
                    'reclamation.user',
                    'reclamation.brigadier',
                ]), $recipientIds, $isBrigadier);
            }
        } catch (Throwable $exception) {
            report($exception);

            return redirect()->back()->with(['error' => 'Не удалось отправить сообщение в чат.']);
        }

        return redirect()->back()->with(['success' => 'Сообщение отправлено.']);
    }

    private function ensureAdminCanDeleteMessage(
        ChatMessage $chatMessage,
        ?Order $order,
        ?Reclamation $reclamation,
    ): void {
        abort_unless(hasRole(Role::ADMIN), 403);

        if ($order && (int) $chatMessage->order_id !== (int) $order->id) {
            abort(404);
        }

        if ($reclamation && (int) $chatMessage->reclamation_id !== (int) $reclamation->id) {
            abort(404);
        }
    }

    private function deleteMessage(ChatMessage $chatMessage): void
    {
        DB::transaction(function () use ($chatMessage): void {
            $chatMessage->notifiedUsers()->detach();
            $chatMessage->files()->detach();
            $chatMessage->delete();
        });
    }

    private function isDeleteRequest(Request $request): bool
    {
        return $request->boolean('delete_message');
    }

    private function resolveMessageForDeletion(Request $request): ChatMessage
    {
        $validated = $request->validate([
            'chat_message_id' => 'required|integer|exists:chat_messages,id',
        ]);

        return ChatMessage::query()->findOrFail((int) $validated['chat_message_id']);
    }

    private function ensureCanViewOrder(Order $order): void
    {
        if (hasRole(Role::BRIGADIER)) {
            $canView = (int) $order->brigadier_id === (int) auth()->id()
                && in_array((int) $order->order_status_id, Order::visibleStatusIdsForBrigadier(), true);

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

    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 resolveTargetUserIds(
        string $notificationType,
        array $targetUserIds,
        ?Order $order,
        ?Reclamation $reclamation,
        int $senderId,
    ): array {
        $selectedIds = array_values(array_unique(array_map(static fn ($id) => (int) $id, $targetUserIds)));
        $allowedIds = match ($notificationType) {
            ChatMessage::NOTIFICATION_RESPONSIBLES => $this->chatResponsibleRecipientIds($order, $reclamation),
            ChatMessage::NOTIFICATION_ALL => User::query()->pluck('id')->map(static fn ($id) => (int) $id)->all(),
            default => [],
        };

        $selectedIds = array_values(array_intersect($selectedIds, $allowedIds));

        return array_values(array_diff($selectedIds, [$senderId]));
    }

    private function chatResponsibleRecipientIds(?Order $order, ?Reclamation $reclamation): array
    {
        $adminIds = User::query()
            ->where('role', Role::ADMIN)
            ->pluck('id')
            ->map(static fn ($id) => (int) $id)
            ->all();

        if ($order) {
            return array_values(array_unique(array_filter(array_merge($adminIds, [
                $order->user_id ? (int) $order->user_id : null,
                $order->brigadier_id ? (int) $order->brigadier_id : null,
            ]))));
        }

        if ($reclamation) {
            return array_values(array_unique(array_filter(array_merge($adminIds, [
                $reclamation->user_id ? (int) $reclamation->user_id : null,
                $reclamation->brigadier_id ? (int) $reclamation->brigadier_id : null,
            ]))));
        }

        return $adminIds;
    }

    private function chatBrigadierRecipientIds(?Order $order, ?Reclamation $reclamation, int $senderId): array
    {
        $adminIds = User::query()
            ->where('role', Role::ADMIN)
            ->pluck('id')
            ->map(static fn ($id) => (int) $id)
            ->all();

        $managerId = $order?->user_id ?: $reclamation?->user_id;

        return array_values(array_unique(array_diff(array_filter([
            ...$adminIds,
            $managerId ? (int) $managerId : null,
        ]), [$senderId])));
    }
}