sfp_api_laravel_diarista/app/Services/ProviderService.php

<?php

namespace App\Services;

use App\Enums\ApprovalStatusEnum;
use App\Enums\UserTypeEnum;
use App\Models\Address;
use App\Models\City;
use App\Models\Provider;
use App\Models\ProviderServicesType;
use App\Models\ProviderWorkingDay;
use App\Models\State;
use App\Models\User;
use App\Services\Pagarme\PagarmeRecipientService;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Http\UploadedFile;
use Illuminate\Pagination\LengthAwarePaginator;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

class ProviderService
{
    public function __construct(
        private readonly AuthService $authService,
        private readonly PagarmeRecipientService $pagarmeRecipientService,
        private readonly MediaService $mediaService,
        private readonly EmailService $emailService,
    ) {}

    public function getAll(): Collection
    {
        $providers = Provider::query()
            ->with(['user', 'profileMedia'])
            ->join('users', 'providers.user_id', '=', 'users.id')
            ->select('providers.*')
            ->orderBy('users.name', 'asc')
            ->get();

        return $providers;
    }

    public function findById(int $id): ?Provider
    {
        return Provider::with(['user', 'profileMedia', 'documentFrontMedia', 'documentBackMedia'])->find($id);
    }

    public function create(array $data): Provider
    {
        return DB::transaction(function () use ($data) {
            $provider = Provider::create($data);

            if (! empty($data['recipient_name']) && ! empty($data['recipient_default_bank_account'])) {
                $this->pagarmeRecipientService->createRecipientForProvider($provider, $data);
            }

            return $provider->fresh(['user', 'profileMedia']);
        });
    }

    public function update(int $id, array $data): ?Provider
    {
        $model = $this->findById($id);

        if (! $model) {
            return null;
        }

        $wasAccepted = $model->approval_status === ApprovalStatusEnum::ACCEPTED;

        if (isset($data['avatar']) && $data['avatar'] instanceof UploadedFile) {
            $media = $this->mediaService->replaceFile(
                newFile: $data['avatar'],
                folder: "provider/avatar/{$model->id}",
                source: 'provider',
                sourceId: $model->id,
                old: $model->profileMedia,
            );

            $data['profile_media_id'] = $media->id;

            unset($data['avatar']);
        }

        $model->update($data);

        $provider = $model->fresh(['user', 'profileMedia']);

        if (! $wasAccepted && $provider->approval_status === ApprovalStatusEnum::ACCEPTED) {
            $this->sendApprovedEmail($provider);
        }

        return $provider;
    }

    public function delete(int $id): bool
    {
        $model = $this->findById($id);

        if (! $model) {
            return false;
        }

        return $model->delete();
    }

    //

    public function getPaymentMethods(int $id): array
    {
        $provider = Provider::find($id);

        if (! $provider || empty($provider->recipient_default_bank_account)) {
            return [];
        }

        $bankAccount = $provider->recipient_default_bank_account;

        return [[
            'id'                              => $provider->id,
            'provider_id'                     => $provider->id,
            'account_type'                    => 'bank_account',
            'pix_key'                         => $bankAccount['pix_key']             ?? null,
            'bank_account_type'               => $bankAccount['type']                ?? null,
            'agency'                          => $bankAccount['branch_number']       ?? null,
            'account'                         => $bankAccount['account_number']      ?? null,
            'digit'                           => $bankAccount['account_check_digit'] ?? null,
            'recipient_default_bank_account'  => $bankAccount,
        ]];
    }

    public function getPending(int $page = 1, int $perPage = 10): LengthAwarePaginator
    {
        return Provider::query()
            ->where('approval_status', ApprovalStatusEnum::PENDING->value)
            ->with(['user', 'profileMedia'])
            ->orderBy('created_at', 'asc')
            ->paginate($perPage, ['*'], 'page', $page);
    }

    //

    public function register(array $data): array
    {
        try {
            DB::beginTransaction();

            $email = $data['email'] ?? null;
            $phone = $data['phone'] ?? null;
            $code  = $data['code']  ?? null;

            $user = User::query()
                ->where('type', UserTypeEnum::PROVIDER->value)
                ->where('code', $code)
                ->where(function ($query) use ($email, $phone) {
                    if (! empty($email)) {
                        $query->orWhere('email', $email);
                    }

                    if (! empty($phone)) {
                        $query->orWhere('phone', $phone);
                    }
                })
                ->latest('id')
                ->first();

            if (! $user) {
                throw new \Exception(__('messages.user_not_found_or_code_not_validated'));
            }

            $user->name = $data['name'];

            if (empty($user->email) && ! empty($email)) {
                $user->email = $email;
            }

            if (empty($user->phone) && ! empty($phone)) {
                $user->phone = $phone;
            }

            $user->save();

            $provider = Provider::withTrashed()->where('user_id', $user->id)->first();

            if (! $provider) {
                $provider = new Provider;

                $provider->user_id = $user->id;
            } elseif ($provider->trashed()) {
                $provider->restore();
            }

            $provider->rg              = $data['rg'] ?? null;
            $provider->document        = $this->sanitizeDigits($data['document'] ?? null);
            $provider->birth_date      = $data['birth_date']     ?? null;
            $provider->daily_price_8h  = $data['daily_price_8h'] ?? null;
            $provider->daily_price_6h  = $data['daily_price_6h'] ?? null;
            $provider->daily_price_4h  = $data['daily_price_4h'] ?? null;
            $provider->daily_price_2h  = $data['daily_price_2h'] ?? null;
            $provider->approval_status = ApprovalStatusEnum::PENDING->value;

            $provider->save();

            $provider->refresh();

            $provider->load('profileMedia', 'documentFrontMedia', 'documentBackMedia');

            $selfie = $this->mediaService->replaceFile(
                newFile: $data['selfie'],
                folder: "provider/avatar/{$provider->id}",
                source: 'provider',
                sourceId: $provider->id,
                old: $provider->profileMedia,
            );

            $provider->profile_media_id = $selfie->id;

            $front = $this->mediaService->replaceFile(
                newFile: $data['document_front'],
                folder: "provider/documentos/{$provider->id}",
                source: 'provider_document',
                sourceId: $provider->id,
                old: $provider->documentFrontMedia,
                filename: 'frente.'.$data['document_front']->getClientOriginalExtension(),
            );

            $provider->document_front_media_id = $front->id;

            $back = $this->mediaService->replaceFile(
                newFile: $data['document_back'],
                folder: "provider/documentos/{$provider->id}",
                source: 'provider_document',
                sourceId: $provider->id,
                old: $provider->documentBackMedia,
                filename: 'verso.'.$data['document_back']->getClientOriginalExtension(),
            );

            $provider->document_back_media_id = $back->id;

            $provider->save();

            $bankAccount = $data['recipient_default_bank_account'] ?? [];

            $hasBankData = ! empty($bankAccount['bank']) && ! empty($bankAccount['account_number']);

            if (! empty($data['recipient_name']) && $hasBankData && empty($provider->recipient_id)) {
                $this->pagarmeRecipientService->createRecipientForProvider($provider, $data);
            }

            Address::where('source', 'provider')->where('source_id', $provider->id)->delete();

            $this->createProviderAddress($provider->id, $data);

            ProviderServicesType::where('provider_id', $provider->id)->delete();

            $this->createProviderServicesTypes($provider->id, $data);

            ProviderWorkingDay::where('provider_id', $provider->id)->delete();

            $this->createProviderWorkingDays($provider->id, $data);

            if ((empty($user->email) && empty($user->phone)) || empty($user->code)) {
                throw new \Exception(__('messages.user_not_found_or_code_not_validated'));
            }

            $user->registration_complete = true;

            $user->validated_code = true;
            $user->code           = null;

            $user->save();

            $result = $this->authService->createAppSession($user);

            DB::commit();

            return $result;
        } catch (\Exception $e) {
            DB::rollBack();

            Log::error('Error registering provider: '.$e->getMessage(), [
                'data' => $data,
            ]);

            throw $e;
        }
    }

    public function updateBankAccount(int $id, array $bankAccountData): ?Provider
    {
        $provider = Provider::with(['user', 'addresses.city', 'addresses.state'])->find($id);

        if (! $provider) {
            return null;
        }

        $bankAccountData['holder_name']     = $bankAccountData['holder_name']     ?? $provider->user?->name;
        $bankAccountData['holder_document'] = $bankAccountData['holder_document'] ?? $provider->document;
        $bankAccountData['holder_type']     = $bankAccountData['holder_type']     ?? 'individual';

        if (empty($provider->recipient_id)) {
            $this->pagarmeRecipientService->createRecipientForProvider(
                $provider,
                $this->buildRecipientDataFromProvider($provider, $bankAccountData),
            );
        } else {
            $this->pagarmeRecipientService->updateDefaultBankAccount($provider, $bankAccountData);
        }

        return $provider->fresh(['user', 'profileMedia']);
    }

    //

    public function approve(int $id): Provider
    {
        [$provider, $wasAccepted] = DB::transaction(function () use ($id) {
            $provider = Provider::findOrFail($id);

            $wasAccepted = $provider->approval_status === ApprovalStatusEnum::ACCEPTED;

            $provider->update(['approval_status' => ApprovalStatusEnum::ACCEPTED->value]);

            return [$provider->fresh(['user', 'profileMedia']), $wasAccepted];
        });

        if (! $wasAccepted) {
            $this->sendApprovedEmail($provider);
        }

        return $provider;
    }

    public function reject(int $id): Provider
    {
        return DB::transaction(function () use ($id) {
            $provider = Provider::findOrFail($id);

            $provider->update(['approval_status' => ApprovalStatusEnum::REJECTED->value]);

            return $provider->fresh(['user', 'profileMedia']);
        });
    }

    //

    private function buildRecipientDataFromProvider(Provider $provider, array $bankAccountData): array
    {
        $address = $provider->addresses->first();

        return [
            'recipient_name'                 => $provider->user?->name,
            'recipient_email'                => $provider->user?->email,
            'recipient_document'             => $provider->document,
            'recipient_type'                 => 'individual',
            'recipient_payment_mode'         => 'bank_transfer',
            'recipient_metadata'             => [],
            'recipient_default_bank_account' => $bankAccountData,
            'birth_date'                     => $provider->birth_date,
            'phone'                          => $provider->user?->phone,
            'address'                        => $address?->address,
            'number'                         => $address?->number,
            'city'                           => $address?->city?->name,
            'state'                          => $address?->state?->code,
            'zip_code'                       => $address?->zip_code,
        ];
    }

    private function createProviderAddress(int $providerId, array $data): void
    {
        $state = null;
        $city  = null;

        if (! empty($data['state'])) {
            $state = State::query()
                ->whereRaw('LOWER(code) = ?', [mb_strtolower($data['state'])])
                ->first();
        }

        if (! empty($data['city'])) {
            $cityQuery = City::query()
                ->whereRaw('LOWER(name) = ?', [mb_strtolower($data['city'])]);

            if ($state) {
                $cityQuery->where('state_id', $state->id);
            }

            $city = $cityQuery->first();
        }

        $address = new Address;

        $address->source    = 'provider';
        $address->source_id = $providerId;
        $address->zip_code  = $this->sanitizeDigits($data['zip_code'] ?? null);

        $address->address  = $data['address']  ?? null;
        $address->number   = $data['number']   ?? null;
        $address->district = $data['district'] ?? null;

        $address->has_complement = (bool) ($data['has_complement'] ?? false);

        $address->complement   = $data['complement']   ?? null;
        $address->nickname     = $data['nickname']     ?? null;
        $address->instructions = $data['instructions'] ?? null;
        $address->address_type = $data['address_type'] ?? 'home';

        $address->state_id = $state?->id;
        $address->city_id  = $city?->id;

        $address->latitude  = $data['latitude']  ?? null;
        $address->longitude = $data['longitude'] ?? null;

        $address->save();
    }

    private function createProviderServicesTypes(int $providerId, array $data): void
    {
        $serviceTypeIds = $data['services_types_ids'] ?? $data['service_types_ids'] ?? [];

        $uniqueIds = array_values(array_unique(array_map('intval', $serviceTypeIds)));

        foreach ($uniqueIds as $serviceTypeId) {
            ProviderServicesType::create([
                'provider_id'     => $providerId,
                'service_type_id' => $serviceTypeId,
            ]);
        }
    }

    private function createProviderWorkingDays(int $providerId, array $data): void
    {
        $workingDays = $data['working_days'] ?? [];

        $seen = [];

        foreach ($workingDays as $workingDay) {
            $day = (int) ($workingDay['day'] ?? -1);

            $period = $workingDay['period'] ?? null;

            if ($day < 0 || $day > 6 || ! in_array($period, ['morning', 'afternoon'], true)) {
                continue;
            }

            $uniqueKey = $day.'-'.$period;

            if (isset($seen[$uniqueKey])) {
                continue;
            }

            $seen[$uniqueKey] = true;

            ProviderWorkingDay::create([
                'provider_id' => $providerId,
                'day'         => $day,
                'period'      => $period,
            ]);
        }
    }

    //

    private function sanitizeDigits(?string $value): ?string
    {
        if ($value === null) {
            return null;
        }

        $digits = preg_replace('/\D+/', '', $value);

        return $digits === '' ? null : $digits;
    }

    private function sendApprovedEmail(Provider $provider): void
    {
        if (! empty($provider->user?->email)) {
            try {
                $this->emailService->sendProviderApproved(
                    email: $provider->user->email,
                    recipientName: $provider->user->name ?? '',
                    locale: $provider->user->language?->value,
                );
            } catch (\Throwable $exception) {
                Log::error('Provider approval email failed', [
                    'provider_id' => $provider->id,
                    'user_id'     => $provider->user?->id,
                    'email'       => $provider->user?->email,
                    'error'       => $exception->getMessage(),
                ]);
            }

            return;
        }

        Log::warning('Provider approval email skipped: provider user has no email', [
            'provider_id' => $provider->id,
            'user_id'     => $provider->user?->id,
        ]);
    }
}