sfp_api_laravel_diarista/app/Services/Pagarme/PagarmePaymentService.php

<?php

namespace App\Services\Pagarme;

use App\Data\Pagarme\Customer\CustomerRequestData;
use App\Data\Pagarme\Customer\Parts\Request\AddressData;
use App\Data\Pagarme\Customer\Parts\Request\PhoneData;
use App\Data\Pagarme\Customer\Parts\Request\PhonesData;
use App\Data\Pagarme\Order\OrderRequestData;
use App\Data\Pagarme\Order\OrderResponseData;
use App\Data\Pagarme\Order\Parts\Request\CreditCardData;
use App\Data\Pagarme\Order\Parts\Request\ItemData;
use App\Data\Pagarme\Order\Parts\Request\PaymentData;
use App\Data\Pagarme\Order\Parts\Request\PixAdditionalInformationData;
use App\Data\Pagarme\Order\Parts\Request\PixData;
use App\Data\Pagarme\Order\Parts\Request\SplitData;
use App\Data\Pagarme\Order\Parts\Request\SplitOptionsData;
use App\Enums\PaymentSplitStatusEnum;
use App\Enums\PaymentStatusEnum;
use App\Models\Address;
use App\Models\Client;
use App\Models\Payment;
use App\Models\PaymentSplit;
use App\Models\Schedule;
use App\Services\Pagarme\Concerns\FormatsPagarmeData;
use App\Services\Pagarme\Concerns\SendsPagarmeRequests;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Str;

class PagarmePaymentService
{
    use FormatsPagarmeData;
    use SendsPagarmeRequests;

    public function __construct(
        private readonly PagarmeAnticipationService $anticipationService,
    ) {}

    public function calculatePaymentAmounts(float $serviceAmount, string $paymentMethod): array
    {
        if ($serviceAmount <= 0) {
            throw new \InvalidArgumentException('Valor do servico precisa ser maior que zero.');
        }

        if (! in_array($paymentMethod, ['credit_card', 'pix'], true)) {
            throw new \InvalidArgumentException('Forma de pagamento invalida.');
        }

        $platformFeeRate = $paymentMethod === 'credit_card'
            ? (float) config('services.pagarme.platform_credit_card_fee_rate', 0.11)
            : (float) config('services.pagarme.platform_pix_fee_rate', 0.11);

        $platformFee = round($serviceAmount * $platformFeeRate, 2);
        $grossAmount = round($serviceAmount + $platformFee, 2);

        if ($platformFee > 0 && empty(config('services.pagarme.platform_recipient_id'))) {
            throw new \InvalidArgumentException('PAGARME_PLATFORM_RECIPIENT_ID precisa estar configurado para receber a taxa da plataforma no split.');
        }

        return [
            'service_amount'      => round($serviceAmount, 2),
            'platform_fee_amount' => $platformFee,
            'gross_amount'        => $grossAmount,
        ];
    }

    public function platformFeeRates(): array
    {
        return [
            'pix'         => (float) config('services.pagarme.platform_pix_fee_rate', 0.11),
            'credit_card' => (float) config('services.pagarme.platform_credit_card_fee_rate', 0.11),
        ];
    }

    public function processPayment(
        Payment  $payment,
        Schedule $schedule,
        string   $paymentMethod,
        ?string  $cardId  = null,
        array    $options = [],
    ): array {
        $grossAmount = (float) $payment->gross_amount;

        $items    = $this->buildOrderItems($schedule, $grossAmount);
        $customer = $this->buildCustomer($schedule, $options);
        $split    = $this->buildSplit($payment, $options);

        $pixOptions = config('services.pagarme.pix_disable_split')
            ? []
            : ['split' => $split];

        $orderOptions = array_merge(['split' => $split], $pixOptions);

        if ($paymentMethod === 'credit_card') {
            $creditCard = new CreditCardData(
                cardId:              $cardId,
                installments:        $payment->installments,
                statementDescriptor: Str::limit((string) config('app.name', 'SOFTPAR'), 13, ''),
                operationType:       'auth_and_capture',
            );

            $result = $this->createOrderWithCreditCard(
                payment:    $payment,
                items:      $items,
                customer:   $customer,
                creditCard: $creditCard,
                options:    $orderOptions,
            );

            $this->logCreditCardOrderResult($payment, $result, 'create_order');

            $orderStatus = OrderResponseData::fromArray($result)->paymentStatus();

            if (! in_array($orderStatus, [PaymentStatusEnum::PAID, PaymentStatusEnum::AUTHORIZED], true)) {
                return $result;
            }

            $anticipationLimits = $this->anticipationService->fetchAnticipationLimitsForPayment($payment);

            $this->anticipationService->createBulkAnticipation($payment, $anticipationLimits);

            return $result;
        }

        $pixData = new PixData(
            expiresIn: 1800,

            additionalInformation: [
                new PixAdditionalInformationData(
                    name:  'Agendamento',
                    value: (string) $schedule->id,
                ),
            ],
        );

        return $this->createOrderWithPix(
            payment:  $payment,
            items:    $items,
            customer: $customer,
            pix:      $pixData,
            options:  $pixOptions,
        );
    }

    public function createOrderWithCreditCard(
        Payment             $payment,
        array               $items,
        CustomerRequestData $customer,
        CreditCardData      $creditCard,
        array               $options = []
    ): array {
        return $this->createOrder(
            payment:  $payment,
            items:    $items,
            customer: $customer,

            paymentMethod: OrderRequestData::creditCardPaymentMethod(
                creditCard: $creditCard,
                split:      is_array($options['split'] ?? null) ? $options['split'] : null,
            ),

            options: $options,
        );
    }

    public function createOrderWithPix(
        Payment             $payment,
        array               $items,
        CustomerRequestData $customer,
        PixData             $pix,
        array               $options = []
    ): array {
        return $this->createOrder(
            payment:  $payment,
            items:    $items,
            customer: $customer,

            paymentMethod: OrderRequestData::pixPaymentMethod(
                pix:   $pix,
                split: is_array($options['split'] ?? null) ? $options['split'] : null,
            ),

            options: $options,
        );
    }

    public function createOrder(
        Payment             $payment,
        array               $items,
        CustomerRequestData $customer,
        PaymentData         $paymentMethod,
        array               $options = []
    ): array {
        $metadata = array_merge([
            'payment_id'  => (string) $payment->id,
            'schedule_id' => (string) $payment->schedule_id,
            'client_id'   => (string) $payment->client_id,
            'provider_id' => (string) $payment->provider_id,
        ], $options['metadata'] ?? []);

        $requestData = new OrderRequestData(
            code:       $payment->ensureGatewayCode(),
            items:      $items,
            payments:   [$paymentMethod],
            metadata:   $metadata,
            customer:   $customer,
            customerId: $options['customer_id'] ?? null,
            closed:     $options['closed']      ?? true,
            channel:    $options['channel']     ?? null,
        );

        $order = OrderResponseData::fromArray($this->pagarmeRequest(
            method:         'POST',
            path:           '/orders',
            payload:        $requestData,
            idempotencyKey: $this->idempotencyKey($payment),
            errorMessage:   'Erro ao criar pedido de pagamento no Pagar.me.',
        ));

        $order->requireId();

        $this->saveExternalCustomerId($payment, $order);

        return $order->toArray();
    }

    //

    public function applyGatewayResponseToPayment(Payment $payment, array $orderResponse): Payment
    {
        $order = OrderResponseData::fromArray($orderResponse);

        $newStatus = $order->paymentStatus();

        $failureCode    = null;
        $failureMessage = null;

        if ($newStatus === PaymentStatusEnum::FAILED) {
            $failureCode    = $order->failureCode();
            $failureMessage = $order->failureMessage();

            $this->logCreditCardOrderResult($payment, $orderResponse, 'webhook_failed');
        }

        $gatewayFeeCents = $order->lastTransaction()?->cost ?? 0;

        $gatewayFee = $gatewayFeeCents > 0 ? round($gatewayFeeCents / 100, 2) : 0;

        $payment->forceFill([
            'gateway_provider'            => 'pagarme',
            'gateway_entity_reference'    => $order->gatewayEntityReference(),
            'gateway_entity_label'        => $order->gatewayEntityLabel(),
            'gateway_operation_reference' => $order->gatewayOperationReference(),
            'gateway_operation_label'     => $order->gatewayOperationLabel(),
            'status'                      => $newStatus,
            'paid_at'                     => $order->paidAt(),
            'authorized_at'               => $order->authorizedAt(),
            'gateway_payload'             => $orderResponse,
            'gateway_fee_amount'          => $gatewayFee,
            'failure_code'                => $failureCode,
            'failure_message'             => $failureMessage,
        ])->save();

        $splitStatus = match ($newStatus) {
            PaymentStatusEnum::PAID       => PaymentSplitStatusEnum::TRANSFERRED,
            PaymentStatusEnum::FAILED     => PaymentSplitStatusEnum::FAILED,
            PaymentStatusEnum::CANCELLED  => PaymentSplitStatusEnum::CANCELLED,
            PaymentStatusEnum::AUTHORIZED => PaymentSplitStatusEnum::PROCESSING,
            default                       => PaymentSplitStatusEnum::PENDING,
        };

        PaymentSplit::query()
            ->where('payment_id', $payment->id)
            ->update(['status' => $splitStatus]);

        return $payment->fresh();
    }

    //

    private function buildCustomer(Schedule $schedule, array $options = []): CustomerRequestData
    {
        $client  = $schedule->client;
        $user    = $client->user()->first(['id', 'name', 'email', 'phone']);
        $address = Address::with(['city.state', 'state'])->find($schedule->address_id);

        foreach ([
            'nome'      => $user?->name,
            'email'     => $user?->email,
            'documento' => $client->document,
        ] as $field => $value) {
            if ($value === null || $value === '') {
                throw new \InvalidArgumentException("Cliente precisa ter {$field} para criar pedido no Pagar.me.");
            }
        }

        if (! $address) {
            throw new \InvalidArgumentException('Endereco do agendamento nao encontrado para criar pedido no Pagar.me.');
        }

        $document = $this->digits($client->document);

        $phone = $this->buildPhonePayload($user->phone)
            ?: $this->buildPhonePayload($options['phone'] ?? null);

        $state   = $address->state?->code ?? $address->city?->state?->code;
        $city    = $address->city?->name;
        $zipCode = $this->digits($address->zip_code);

        $line1 = implode(', ', array_filter([
            $address->number ?: 'S/N',
            $address->address,
            $address->district,
        ]));

        foreach ([
            'documento' => $document,
            'estado'    => $state,
            'cidade'    => $city,
            'cep'       => $zipCode,
            'endereco'  => $line1,
            'telefone'  => $phone,
        ] as $field => $value) {
            if ($value === null || $value === '' || $value === []) {
                throw new \InvalidArgumentException("Cliente precisa ter {$field} valido para criar pedido no Pagar.me.");
            }
        }

        $customerAddress = new AddressData(
            line1:   $line1,
            line2:   $address->complement ?: $address->instructions,
            zipCode: $zipCode,
            city:    $city,
            state:   $state,
            country: 'BR',
        );

        $customerPhones = null;

        if ($phone) {
            $customerPhones = new PhonesData(
                mobilePhone: new PhoneData(
                    countryCode: $phone['country_code'],
                    areaCode:    $phone['area_code'],
                    number:      $phone['number'],
                ),
            );
        }

        return new CustomerRequestData(
            name:         $user->name,
            email:        $user->email,
            document:     $document,
            type:         strlen($document) === 14 ? 'company' : 'individual',
            documentType: strlen($document) === 14 ? 'CNPJ' : 'CPF',
            code:         $client->ensureGatewayCode(),
            address:      $customerAddress,
            phones:       $customerPhones,
        );
    }

    private function buildOrderItems(Schedule $schedule, float $grossAmount): array
    {
        $description = $schedule->customSchedule?->serviceType?->description
            ?? "Servico {$schedule->id}";

        return [new ItemData(
            code:        "schedule-{$schedule->id}",
            amount:      OrderRequestData::amountInCents($grossAmount),
            quantity:    1,
            description: $description,
        )];
    }

    private function logCreditCardOrderResult(Payment $payment, array $orderResponse, string $source): void
    {
        $order       = OrderResponseData::fromArray($orderResponse);
        $charge      = $order->firstCharge();
        $transaction = $order->lastTransaction();

        Log::channel('pagarme')->info('Pagar.me credit card order result', [
            'source'             => $source,
            'payment_id'         => $payment->id,
            'provider_id'        => $payment->provider_id,
            'order_id'           => $order->id,
            'order_status'       => $order->status,
            'charge_id'          => $charge?->id,
            'charge_status'      => $charge?->status,
            'transaction_id'     => $transaction?->id,
            'transaction_status' => $transaction?->status,
            'failure_code'       => $order->failureCode(),
            'failure_message'    => $order->failureMessage(),
            'acquirer_message'   => $transaction?->acquirerMessage,
            'gateway_response'   => $transaction?->gatewayResponse,
        ]);
    }

    private function buildPhonePayload(?string $phone): ?array
    {
        $digits = $this->digits($phone);

        if (strlen($digits) < 10) {
            return null;
        }

        if (str_starts_with($digits, '55')) {
            $digits = substr($digits, 2);
        }

        return [
            'country_code' => '55',
            'area_code'    => substr($digits, 0, 2),
            'number'       => substr($digits, 2),
        ];
    }

    private function roundMoneyUp(float $amount): float
    {
        return ceil($amount * 100) / 100;
    }

    private function buildSplit(Payment $payment, array $options): array
    {
        $transfers = PaymentSplit::query()
            ->where('payment_id', $payment->id)
            ->get();

        $split = OrderRequestData::splitFromTransfers($transfers);

        $platformRecipientId = config('services.pagarme.platform_recipient_id');

        if (empty($platformRecipientId)) {
            return $split;
        }

        $orderAmountCents = OrderRequestData::amountInCents((float) $payment->gross_amount);

        $providerTotalCents = array_sum(array_map(
            static fn (SplitData $s) => $s->amount,
            $split,
        ));

        $platformAmountCents = $orderAmountCents - $providerTotalCents;

        if ($platformAmountCents > 0) {
            $split[] = new SplitData(
                amount:      $platformAmountCents,
                recipientId: $platformRecipientId,
                type:        'flat',

                options: new SplitOptionsData(
                    chargeProcessingFee: true,
                    chargeRemainderFee:  true,
                    liable:              true,
                ),
            );
        }

        return $split;
    }

    // evita criacao duplicada de payment

    private function idempotencyKey(Payment $payment): string
    {
        if (! empty($payment->idempotency_key)) {
            return $payment->idempotency_key;
        }

        $key = 'order-'.(string) \Illuminate\Support\Str::uuid();

        $payment->forceFill(['idempotency_key' => $key])->save();

        return $key;
    }

    // salva o gateway_customer_id do Pagar.me no Client apos criacao de ordem

    private function saveExternalCustomerId(Payment $payment, OrderResponseData $order): void
    {
        $customerId   = $order->customer?->id;
        $customerCode = $order->customer?->code;

        if (! $customerId && ! $customerCode) {
            return;
        }

        $client = Client::find($payment->client_id);

        if (! $client) {
            return;
        }

        $updated = false;

        if (! $client->gateway_customer_id && $customerId) {
            $client->gateway_customer_id = $customerId;

            $updated = true;
        }

        if (! $client->gateway_customer_code && $customerCode) {
            $client->gateway_customer_code = $customerCode;

            $updated = true;
        }

        if ($updated) {
            $client->save();
        }
    }
}