strprfcrm/app/Services/NotificationService.php

<?php

namespace App\Services;

use App\Events\SendPersistentNotificationEvent;
use App\Helpers\DateHelper;
use App\Jobs\SendUserNotificationChannelJob;
use App\Models\ChatMessage;
use App\Models\NotificationDeliveryLog;
use App\Models\Order;
use App\Models\Reclamation;
use App\Models\Role;
use App\Models\Schedule;
use App\Models\User;
use App\Models\UserNotification;
use App\Models\UserNotificationSetting;
use App\Notifications\FireBaseNotification;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Str;

class NotificationService
{
    public function notifyChatMessage(ChatMessage $chatMessage, array $recipientIds = [], bool $forceBrowserNotification = false): void
    {
        $chatMessage->loadMissing([
            'user',
            'targetUser',
            'order.user',
            'order.brigadier',
            'reclamation.order',
            'reclamation.user',
            'reclamation.brigadier',
        ]);

        $type = $chatMessage->order_id ? UserNotification::TYPE_PLATFORM : UserNotification::TYPE_RECLAMATION;
        $sourceKey = $chatMessage->order_id ? 'platform' : 'reclamation';
        $title = $chatMessage->order_id ? 'Чат площадки' : 'Чат рекламации';

        [$message, $messageHtml, $payload] = $this->buildChatNotificationContent($chatMessage, $type);

        foreach ($this->chatRecipients($chatMessage, $recipientIds) as $user) {
            $settings = $this->settingsForUser($user->id);
            if (!$forceBrowserNotification && !$settings->isSectionEnabled('chat_settings')) {
                continue;
            }

            $channels = $settings->getChannelsForKey('chat_settings', $sourceKey);
            if (!$forceBrowserNotification && empty($channels)) {
                continue;
            }

            $notification = $this->createInAppNotification(
                $user,
                $type,
                UserNotification::EVENT_CHAT_MESSAGE,
                $title,
                $message,
                $messageHtml,
                $payload,
            );

            $this->dispatchDeliveryJobs($notification, [
                NotificationDeliveryLog::CHANNEL_BROWSER => $forceBrowserNotification || !empty($channels['browser']),
                NotificationDeliveryLog::CHANNEL_PUSH => !empty($channels['push']),
                NotificationDeliveryLog::CHANNEL_EMAIL => !empty($channels['email']),
            ]);
        }
    }

    public function notifyOrderCreated(Order $order, ?User $author = null): void
    {
        $statusName = $order->orderStatus?->name ?? (Order::STATUS_NAMES[$order->order_status_id] ?? '-');
        $authorSuffix = $author ? sprintf(' Изменил %s.', $author->name) : '';
        $authorSuffixHtml = $author ? sprintf(' Изменил %s.', e($author->name)) : '';

        $this->notifyOrderEvent(
            $order,
            UserNotification::EVENT_CREATED,
            'Площадки',
            sprintf('Добавлена новая площадка %s.', $order->object_address) . $authorSuffix,
            sprintf(
                'Добавлена новая площадка <a href="%s">%s</a>.',
                route('order.show', ['order' => $order->id, 'sync_year' => 1]),
                e($order->object_address)
            ) . $authorSuffixHtml,
            $statusName,
        );
    }

    public function notifyOrderStatusChanged(Order $order, ?User $author = null): void
    {
        $statusName = $order->orderStatus?->name ?? (Order::STATUS_NAMES[$order->order_status_id] ?? '-');
        $authorSuffix = $author ? sprintf(' Изменил %s.', $author->name) : '';
        $authorSuffixHtml = $author ? sprintf(' Изменил %s.', e($author->name)) : '';

        $this->notifyOrderEvent(
            $order,
            UserNotification::EVENT_STATUS_CHANGED,
            'Площадки',
            sprintf('Статус площадки %s изменен на %s.', $order->object_address, $statusName) . $authorSuffix,
            sprintf(
                'Статус площадки <a href="%s">%s</a> изменен на %s.',
                route('order.show', ['order' => $order->id, 'sync_year' => 1]),
                e($order->object_address),
                e($statusName)
            ) . $authorSuffixHtml,
            $statusName,
        );
    }

    public function notifyReclamationCreated(Reclamation $reclamation, ?User $author = null): void
    {
        $order = $reclamation->order;
        if (!$order) {
            return;
        }

        $authorSuffix = $author ? sprintf(' Изменил %s.', $author->name) : '';
        $authorSuffixHtml = $author ? sprintf(' Изменил %s.', e($author->name)) : '';

        $message = sprintf(
            'Добавлена новая рекламация по адресу %s #%d.',
            $order->object_address,
            $reclamation->id,
        ) . $authorSuffix;

        $messageHtml = sprintf(
            'Добавлена новая рекламация по адресу <a href="%s">%s</a> <a href="%s">#%d</a>.',
            route('order.show', ['order' => $order->id, 'sync_year' => 1]),
            e($order->object_address),
            route('reclamations.show', ['reclamation' => $reclamation->id]),
            $reclamation->id,
        ) . $authorSuffixHtml;

        $this->notifyReclamationEvent(
            $reclamation,
            UserNotification::EVENT_CREATED,
            'Рекламации',
            $message,
            $messageHtml,
            (int)$reclamation->status_id,
        );
    }

    public function notifyReclamationStatusChanged(Reclamation $reclamation, ?User $author = null): void
    {
        $order = $reclamation->order;
        if (!$order) {
            return;
        }

        $statusName = $reclamation->status?->name ?? (Reclamation::STATUS_NAMES[$reclamation->status_id] ?? '-');
        $authorSuffix = $author ? sprintf(' Изменил %s.', $author->name) : '';
        $authorSuffixHtml = $author ? sprintf(' Изменил %s.', e($author->name)) : '';

        $message = sprintf(
            'Статус рекламации %s #%d изменен на %s.',
            $order->object_address,
            $reclamation->id,
            $statusName,
        ) . $authorSuffix;

        $messageHtml = sprintf(
            'Статус рекламации по адресу <a href="%s">%s</a> <a href="%s">#%d</a> изменен на %s.',
            route('order.show', ['order' => $order->id, 'sync_year' => 1]),
            e($order->object_address),
            route('reclamations.show', ['reclamation' => $reclamation->id]),
            $reclamation->id,
            e($statusName),
        ) . $authorSuffixHtml;

        $this->notifyReclamationEvent(
            $reclamation,
            UserNotification::EVENT_STATUS_CHANGED,
            'Рекламации',
            $message,
            $messageHtml,
            (int)$reclamation->status_id,
        );
    }

    public function notifyScheduleAdded(Schedule $schedule, ?User $author = null): void
    {
        $sourceKey = $this->sourceToSettingKey((string)$schedule->source);
        if (!$sourceKey) {
            return;
        }

        $brigadierName = $schedule->brigadier?->name ?? '-';
        $date = DateHelper::getHumanDate((string)$schedule->installation_date, true);
        $authorSuffix = $author ? sprintf(' Изменил %s.', $author->name) : '';
        $authorSuffixHtml = $author ? sprintf(' Изменил %s.', e($author->name)) : '';

        if ((string)$schedule->source === 'Рекламации') {
            $reclamationId = $this->extractReclamationId((string)$schedule->address_code);

            $message = sprintf(
                'Рекламация №%s по адресу %s добавлена в график на %s, Бригадир %s.',
                $reclamationId ?? '—',
                $schedule->object_address,
                $date,
                $brigadierName,
            ) . $authorSuffix;

            $reclamationLink = $reclamationId
                ? route('reclamations.show', ['reclamation' => $reclamationId])
                : route('schedule.index');
            $orderLink = $schedule->order_id
                ? route('order.show', ['order' => $schedule->order_id, 'sync_year' => 1])
                : null;

            $addressHtml = $orderLink
                ? sprintf('<a href="%s">%s</a>', $orderLink, e($schedule->object_address))
                : e($schedule->object_address);

            $messageHtml = sprintf(
                '<a href="%s">Рекламация №%s</a> по адресу %s добавлена в график на %s, Бригадир %s.',
                $reclamationLink,
                $reclamationId ?? '—',
                $addressHtml,
                e($date),
                e($brigadierName),
            ) . $authorSuffixHtml;
        } else {
            $message = sprintf(
                '%s добавлено в график монтажей на %s, Бригадир %s.',
                $schedule->object_address,
                $date,
                $brigadierName,
            ) . $authorSuffix;

            $orderLink = $schedule->order_id
                ? route('order.show', ['order' => $schedule->order_id, 'sync_year' => 1])
                : route('schedule.index');

            $messageHtml = sprintf(
                '<a href="%s">%s</a> добавлено в график монтажей на %s, Бригадир %s.',
                $orderLink,
                e($schedule->object_address),
                e($date),
                e($brigadierName),
            ) . $authorSuffixHtml;
        }

        $users = $this->scheduleRecipients($schedule);
        foreach ($users as $user) {
            $settings = $this->settingsForUser($user->id);
            if (!$settings->isSectionEnabled('schedule_settings')) {
                continue;
            }

            $channels = $settings->getChannelsForKey('schedule_settings', $sourceKey);
            if (empty($channels)) {
                continue;
            }

            $notification = $this->createInAppNotification(
                $user,
                UserNotification::TYPE_SCHEDULE,
                UserNotification::EVENT_SCHEDULE_ADDED,
                'График монтажей',
                $message,
                $messageHtml,
                [
                    'schedule_id' => $schedule->id,
                    'source' => $schedule->source,
                ],
            );

            $this->dispatchDeliveryJobs($notification, [
                NotificationDeliveryLog::CHANNEL_BROWSER => !empty($channels['browser']),
                NotificationDeliveryLog::CHANNEL_PUSH => !empty($channels['push']),
                NotificationDeliveryLog::CHANNEL_EMAIL => !empty($channels['email']),
            ]);
        }
    }

    public function deliverChannel(int $userNotificationId, string $channel, int $attempt): void
    {
        $notification = UserNotification::query()->with('user')->find($userNotificationId);
        if (!$notification || !$notification->user) {
            return;
        }

        try {
            if ($channel === NotificationDeliveryLog::CHANNEL_BROWSER) {
                event(new SendPersistentNotificationEvent($notification->user_id, [
                    'id' => $notification->id,
                    'type' => $notification->type,
                    'title' => $notification->title,
                    'message' => $notification->message,
                    'message_html' => $notification->message_html,
                    'created_at' => $notification->created_at?->toDateTimeString(),
                ]));

                $this->createLog($notification, $channel, NotificationDeliveryLog::STATUS_SENT, $attempt, null);
                return;
            }

            if ($channel === NotificationDeliveryLog::CHANNEL_PUSH) {
                if (!$notification->user->token_fcm) {
                    $this->createLog($notification, $channel, NotificationDeliveryLog::STATUS_SKIPPED, $attempt, 'Отсутствует token_fcm');
                    return;
                }

                $notification->user->notify(new FireBaseNotification($notification->title, Str::limit(strip_tags($notification->message), 200)));
                $this->createLog($notification, $channel, NotificationDeliveryLog::STATUS_SENT, $attempt, null);
                return;
            }

            if ($channel === NotificationDeliveryLog::CHANNEL_EMAIL) {
                $email = $notification->user->notification_email;
                if (!$email || !filter_var($email, FILTER_VALIDATE_EMAIL)) {
                    $this->createLog($notification, $channel, NotificationDeliveryLog::STATUS_SKIPPED, $attempt, 'Отсутствует валидный notification_email');
                    return;
                }

                Mail::html($notification->message_html, function ($message) use ($email, $notification) {
                    $message->to($email)
                        ->subject($notification->title);
                });

                $this->createLog($notification, $channel, NotificationDeliveryLog::STATUS_SENT, $attempt, null);
                return;
            }

            $this->createLog($notification, $channel, NotificationDeliveryLog::STATUS_SKIPPED, $attempt, 'Неизвестный канал');
        } catch (\Throwable $exception) {
            $this->createLog($notification, $channel, NotificationDeliveryLog::STATUS_FAILED, $attempt, $exception->getMessage());
            throw $exception;
        }
    }

    public function markDeadLetter(int $userNotificationId, string $channel, int $attempt, ?string $error = null): void
    {
        $notification = UserNotification::query()->find($userNotificationId);
        if (!$notification) {
            return;
        }

        $this->createLog($notification, $channel, NotificationDeliveryLog::STATUS_DEAD_LETTER, $attempt, $error);
    }

    private function notifyOrderEvent(
        Order $order,
        string $event,
        string $title,
        string $message,
        string $messageHtml,
        string $statusName,
    ): void {
        $users = $this->orderRecipients($order);
        $statusId = (int) $order->order_status_id;

        foreach ($users as $user) {
            $settings = $this->settingsForUser($user->id);
            if (!$settings->isSectionEnabled('order_settings')) {
                continue;
            }

            $channels = $settings->getChannelsForKey('order_settings', $statusId);
            if (empty($channels)) {
                continue;
            }

            $notification = $this->createInAppNotification(
                $user,
                UserNotification::TYPE_PLATFORM,
                $event,
                $title,
                $message,
                $messageHtml,
                [
                    'order_id' => $order->id,
                    'status' => $statusName,
                ],
            );

            $this->dispatchDeliveryJobs($notification, [
                NotificationDeliveryLog::CHANNEL_BROWSER => !empty($channels['browser']),
                NotificationDeliveryLog::CHANNEL_PUSH => !empty($channels['push']),
                NotificationDeliveryLog::CHANNEL_EMAIL => !empty($channels['email']),
            ]);
        }
    }

    private function notifyReclamationEvent(
        Reclamation $reclamation,
        string $event,
        string $title,
        string $message,
        string $messageHtml,
        int $statusId,
    ): void {
        $users = $this->reclamationRecipients($reclamation);

        foreach ($users as $user) {
            $settings = $this->settingsForUser($user->id);
            if (!$settings->isSectionEnabled('reclamation_settings')) {
                continue;
            }

            $channels = $settings->getChannelsForKey('reclamation_settings', $statusId);
            if (empty($channels)) {
                continue;
            }

            $notification = $this->createInAppNotification(
                $user,
                UserNotification::TYPE_RECLAMATION,
                $event,
                $title,
                $message,
                $messageHtml,
                [
                    'reclamation_id' => $reclamation->id,
                    'status_id' => $statusId,
                ],
            );

            $this->dispatchDeliveryJobs($notification, [
                NotificationDeliveryLog::CHANNEL_BROWSER => !empty($channels['browser']),
                NotificationDeliveryLog::CHANNEL_PUSH => !empty($channels['push']),
                NotificationDeliveryLog::CHANNEL_EMAIL => !empty($channels['email']),
            ]);
        }
    }

    private function dispatchDeliveryJobs(UserNotification $notification, array $channels): void
    {
        foreach ($channels as $channel => $enabled) {
            if (!$enabled) {
                continue;
            }

            SendUserNotificationChannelJob::dispatch($notification->id, $channel);
        }
    }

    private function createInAppNotification(
        User $user,
        string $type,
        string $event,
        string $title,
        string $message,
        string $messageHtml,
        array $payload,
    ): UserNotification {
        $notification = UserNotification::query()->create([
            'user_id' => $user->id,
            'type' => $type,
            'event' => $event,
            'title' => $title,
            'message' => $message,
            'message_html' => $messageHtml,
            'data' => $payload,
        ]);

        $this->createLog($notification, NotificationDeliveryLog::CHANNEL_IN_APP, NotificationDeliveryLog::STATUS_SENT, 1, null);

        return $notification;
    }

    private function createLog(
        UserNotification $notification,
        string $channel,
        string $status,
        int $attempt,
        ?string $error,
    ): void {
        NotificationDeliveryLog::query()->create([
            'user_notification_id' => $notification->id,
            'user_id' => $notification->user_id,
            'channel' => $channel,
            'status' => $status,
            'attempt' => $attempt,
            'message' => $notification->message,
            'error' => $error,
        ]);
    }

    private function settingsForUser(int $userId): UserNotificationSetting
    {
        return UserNotificationSetting::query()->firstOrCreate(
            ['user_id' => $userId],
            UserNotificationSetting::defaultsForUser($userId),
        );
    }

    private function orderRecipients(Order $order): Collection
    {
        $query = User::query()
            ->whereIn('role', [Role::ADMIN, Role::ASSISTANT_HEAD, Role::WAREHOUSE_HEAD]);

        if ($order->user_id) {
            $query->orWhere('id', $order->user_id);
        }

        return $query->distinct()->get();
    }

    private function reclamationRecipients(Reclamation $reclamation): Collection
    {
        $query = User::query()
            ->whereIn('role', [Role::ADMIN, Role::ASSISTANT_HEAD, Role::WAREHOUSE_HEAD]);

        $managerId = $reclamation->user_id;
        if ($managerId) {
            $query->orWhere('id', $managerId);
        }

        return $query->distinct()->get();
    }

    private function scheduleRecipients(Schedule $schedule): Collection
    {
        $query = User::query()
            ->whereIn('role', [Role::ADMIN, Role::ASSISTANT_HEAD, Role::WAREHOUSE_HEAD]);

        if ($schedule->brigadier_id) {
            $query->orWhere('id', $schedule->brigadier_id);
        }

        $managerId = null;
        if ((string)$schedule->source === 'Площадки' && $schedule->order_id) {
            $managerId = Order::query()
                ->withoutGlobalScope(\App\Models\Scopes\YearScope::class)
                ->where('id', $schedule->order_id)
                ->value('user_id');
        }

        if ((string)$schedule->source === 'Рекламации') {
            $reclamationId = $this->extractReclamationId((string)$schedule->address_code);
            if ($reclamationId) {
                $reclamation = Reclamation::query()
                    ->withoutGlobalScope(\App\Models\Scopes\YearScope::class)
                    ->with('order')
                    ->find($reclamationId);
                $managerId = $reclamation?->order?->user_id ?: $reclamation?->user_id;
            }
        }

        if ($managerId) {
            $query->orWhere('id', $managerId);
        }

        return $query->distinct()->get();
    }

    private function extractReclamationId(string $addressCode): ?int
    {
        if (preg_match('/^РЕКЛ-(\d+)$/u', $addressCode, $matches)) {
            return (int)$matches[1];
        }

        return null;
    }

    private function sourceToSettingKey(string $source): ?string
    {
        return match ($source) {
            'Площадки' => 'platform',
            'Рекламации' => 'reclamation',
            default => null,
        };
    }

    private function chatRecipients(ChatMessage $chatMessage, array $recipientIds = []): Collection
    {
        $recipientIds = array_values(array_unique(array_map(static fn ($id) => (int) $id, $recipientIds)));
        $recipientIds = array_values(array_diff($recipientIds, [(int) $chatMessage->user_id]));

        if (!empty($recipientIds)) {
            return User::query()
                ->whereIn('id', $recipientIds)
                ->get();
        }

        if ($chatMessage->notification_type === ChatMessage::NOTIFICATION_USER) {
            if (!$chatMessage->target_user_id || (int) $chatMessage->target_user_id === (int) $chatMessage->user_id) {
                return new Collection();
            }

            return User::query()
                ->where('id', $chatMessage->target_user_id)
                ->get();
        }

        if (!in_array($chatMessage->notification_type, [
            ChatMessage::NOTIFICATION_ALL,
            ChatMessage::NOTIFICATION_RESPONSIBLES,
        ], true)) {
            return new Collection();
        }

        $recipientIds = [];

        if ($chatMessage->order) {
            $recipientIds = $chatMessage->notification_type === ChatMessage::NOTIFICATION_ALL
                ? $this->allChatRecipientIds()
                : $this->chatResponsibleRecipientIdsForOrder($chatMessage->order);
        }

        if ($chatMessage->reclamation) {
            $recipientIds = $chatMessage->notification_type === ChatMessage::NOTIFICATION_ALL
                ? $this->allChatRecipientIds()
                : $this->chatResponsibleRecipientIdsForReclamation($chatMessage->reclamation);
        }

        $recipientIds = array_values(array_unique(array_filter($recipientIds)));
        $recipientIds = array_values(array_diff($recipientIds, [(int) $chatMessage->user_id]));

        if (empty($recipientIds)) {
            return new Collection();
        }

        return User::query()
            ->whereIn('id', $recipientIds)
            ->get();
    }

    private function allChatRecipientIds(): array
    {
        return User::query()
            ->pluck('id')
            ->map(static fn ($id) => (int) $id)
            ->all();
    }

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

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

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

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

    private function buildChatNotificationContent(ChatMessage $chatMessage, string $type): array
    {
        $senderName = $chatMessage->user?->name ?? 'Пользователь';
        $text = trim((string) $chatMessage->message);
        $text = $text !== '' ? Str::limit($text, 200) : 'Вложение';

        if ($type === UserNotification::TYPE_PLATFORM) {
            $order = $chatMessage->order;
            $address = $order?->object_address ?? '-';
            $orderUrl = $order ? route('order.show', ['order' => $order->id, 'sync_year' => 1]) : route('order.index');

            $message = sprintf('Новое сообщение в чате площадки %s от %s: %s', $address, $senderName, $text);
            $messageHtml = sprintf(
                'Новое сообщение в <a href="%s">чате площадки %s</a> от %s: %s',
                $orderUrl,
                e($address),
                e($senderName),
                e($text)
            );

            return [$message, $messageHtml, [
                'chat_message_id' => $chatMessage->id,
                'order_id' => $order?->id,
            ]];
        }

        $reclamation = $chatMessage->reclamation;
        $address = $reclamation?->order?->object_address ?? '-';
        $reclamationUrl = $reclamation
            ? route('reclamations.show', ['reclamation' => $reclamation->id, 'sync_year' => 1])
            : route('reclamations.index');

        $reclamationNumber = $reclamation?->id ? ('#' . $reclamation->id) : '#-';

        $message = sprintf('Новое сообщение в чате рекламации %s по адресу %s от %s: %s', $reclamationNumber, $address, $senderName, $text);
        $messageHtml = sprintf(
            'Новое сообщение в <a href="%s">чате рекламации %s</a> по адресу %s от %s: %s',
            $reclamationUrl,
            e($reclamationNumber),
            e($address),
            e($senderName),
            e($text)
        );

        return [$message, $messageHtml, [
            'chat_message_id' => $chatMessage->id,
            'reclamation_id' => $reclamation?->id,
        ]];
    }
}