sfp_api_laravel_ginastica_cerebro/app/Services/StudentContractService.php

<?php

namespace App\Services;

use App\Models\StudentContract;
use App\Models\StudentContractInstallment;
use App\Models\StudentMedia;
use App\Models\Unit;
use Barryvdh\DomPDF\Facade\Pdf;
use Carbon\Carbon;
use Illuminate\Database\Eloquent\Collection;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Arr;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Illuminate\Validation\ValidationException;

class StudentContractService
{
    private const FILE_ATTRIBUTES = [
        'file_url',
        'file_type',
        'signed_file_url',
        'signed_file_type',
    ];

    private const VERSION_ATTRIBUTES = [
        'id',
        'version',
        'derived_from_contract_id',
        'created_by_user_id',
        'created_at',
        'updated_at',
        'deleted_at',
    ];

    public function getAll(int $unitId, ?int $studentId = null): Collection
    {
        return StudentContract::with([
            'student' => fn ($query) => $query
                ->withTrashed()
                ->with(['city', 'state']),
            'classPackageUnit',
            'createdBy',
        ])
            ->latestVersion()
            ->where('unit_id', $unitId)
            ->when($studentId, fn ($q) => $q->where('student_id', $studentId))
            ->orderBy('created_at', 'desc')
            ->get();
    }

    public function findById(int $id): ?StudentContract
    {
        $contract = StudentContract::with(['student', 'classPackageUnit', 'createdBy'])->find($id);

        if (! $contract) {
            return null;
        }

        $this->loadVersionHistory($contract);

        return $contract;
    }

    public function generateNextProtocol(): string
    {
        $nextNumber = $this->getMaxProtocolNumber() + 1;

        return str_pad((string) $nextNumber, 6, '0', STR_PAD_LEFT);
    }

    public function getMaxProtocolNumber(): int
    {
        $driver = DB::connection()->getDriverName();

        if ($driver === 'pgsql') {
            $max = StudentContract::withTrashed()
                ->whereNotNull('protocol')
                ->whereRaw("protocol ~ '^[0-9]+$'")
                ->selectRaw("COALESCE(MAX(CAST(protocol AS BIGINT)), 0) as max_protocol")
                ->value('max_protocol');

            return (int) $max;
        }

        if ($driver === 'mysql') {
            $max = StudentContract::withTrashed()
                ->whereNotNull('protocol')
                ->whereRaw("protocol REGEXP '^[0-9]+$'")
                ->selectRaw("COALESCE(MAX(CAST(protocol AS UNSIGNED)), 0) as max_protocol")
                ->value('max_protocol');

            return (int) $max;
        }

        $max = StudentContract::withTrashed()
            ->whereNotNull('protocol')
            ->get(['protocol'])
            ->filter(fn ($contract) => ctype_digit((string) $contract->protocol))
            ->map(fn ($contract) => (int) $contract->protocol)
            ->max();

        return (int) ($max ?? 0);
    }

    public function create(array $data): StudentContract
    {
        if (! empty($data['due_day'])) {
            $data['recurring_day'] = (int) $data['due_day'];
        }

        unset($data['due_day']);

        $unitId = $data['unit_id'] ?? null;
        $isAutomatic = true;

        if ($unitId) {
            $unit = $this->findUnit($unitId);
            if ($unit && $unit->automatic_protocol === false) {
                $isAutomatic = false;
            }
        }

        if ($isAutomatic) {
            $data['protocol'] = $this->generateNextProtocol();
        }

        $data['status'] = 'pending';
        $contract = StudentContract::create($data);

        $this->generateInstallments($contract);

        return $contract;
    }

    protected function findUnit(int $unitId): ?Unit
    {
        return Unit::find($unitId);
    }

    public function update(int $id, array $data, ?int $createdByUserId = null): ?StudentContract
    {
        if (! empty($data['due_day'])) {
            $data['recurring_day'] = (int) $data['due_day'];
        }

        unset($data['due_day']);

        return DB::transaction(function () use ($id, $data, $createdByUserId): ?StudentContract {
            $contract = StudentContract::query()->lockForUpdate()->find($id);

            if (! $contract) {
                return null;
            }

            $originalAttributes = $contract->getAttributes();

            $contract->fill($data);

            $dirty = Arr::except(
                $contract->getDirty(),

                array_merge(self::FILE_ATTRIBUTES, self::VERSION_ATTRIBUTES),
            );

            if ($dirty === []) {
                return $contract->refresh();
            }

            if ($contract->derivedVersions()->withTrashed()->lockForUpdate()->first()) {
                throw ValidationException::withMessages([
                    'contract' => __('validation.student_contract_old_version'),
                ]);
            }

            $submittedAttributes = array_keys($data);

            $copiedAttributes = Arr::except(
                $originalAttributes,
                array_merge(self::FILE_ATTRIBUTES, self::VERSION_ATTRIBUTES, $submittedAttributes),
            );

            $editedAttributes = Arr::only($contract->getAttributes(), $submittedAttributes);

            $newVersion = StudentContract::create(array_merge(
                $copiedAttributes,
                $editedAttributes,
                [
                    'version'                  => $contract->version + 1,
                    'derived_from_contract_id' => $contract->id,
                    'created_by_user_id'       => $createdByUserId,
                ],
            ));

            StudentContractInstallment::where('student_contract_id', $contract->id)
                ->update(['student_contract_id' => $newVersion->id]);

            return $newVersion->fresh();
        });
    }

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

        if (! $model) {
            return false;
        }

        if ($model->file_url) {
            Storage::delete($model->file_url);
        }

        if ($model->signed_file_url) {
            Storage::delete($model->signed_file_url);
        }

        return $model->delete();
    }

    //

    public function getFranchisorSummary(array $unitIds = []): array
    {
        $base = StudentContract::query()->latestVersion()
            ->when(! empty($unitIds), fn ($q) => $q->whereIn('unit_id', $unitIds));

        return [
            'active'    => (clone $base)->where('status', 'active')->count(),
            'frozen'    => (clone $base)->where('status', 'frozen')->count(),
            'cancelled' => (clone $base)->where('status', 'cancelled')->count(),
        ];
    }

    public function getFranchisorByStatus(string $status, array $unitIds = []): Collection
    {
        return StudentContract::with(['student', 'unit', 'createdBy'])->latestVersion()
            ->where('status', $status)
            ->when(! empty($unitIds), fn ($q) => $q->whereIn('unit_id', $unitIds))
            ->orderBy('created_at', 'desc')
            ->get();
    }

    public function getInstallments(int $contractId): Collection
    {
        return StudentContractInstallment::where('student_contract_id', $contractId)
            ->where('status', 'pending')
            ->orderBy('due_date')
            ->orderBy('installment_number')
            ->get();
    }

    //

    public function attachFile(int $id, UploadedFile $file, bool $signed = false): ?StudentContract
    {
        $model = StudentContract::find($id);

        if (! $model) {
            return null;
        }

        $path = $file->store('student-media');

        StudentMedia::create([
            'student_id'          => $model->student_id,
            'student_contract_id' => $model->id,
            'url'                 => $path,
            'file_type'           => $file->getMimeType(),
            'type'                => $signed ? 'signed_contract' : 'contract',
        ]);

        $urlAttribute = $signed ? 'signed_file_url' : 'file_url';

        $typeAttribute = $signed ? 'signed_file_type' : 'file_type';

        $model->update([
            $urlAttribute  => $path,
            $typeAttribute => $file->getMimeType(),
        ]);

        if ($signed && $model->status === 'pending') {
            $model->update(['status' => 'active']);
        }

        return $model->fresh();
    }

    public function generateFile(int $id): ?StudentContract
    {
        return DB::transaction(function () use ($id): ?StudentContract {
            $model = StudentContract::query()->lockForUpdate()->find($id);

            if (! $model || $model->file_url) {
                return $model?->fresh();
            }

            $model->load([
                'classPackageUnit.pavaoProposalUnit',
                'classPackageUnit.irrecusableProposalUnit',
                'student.city',
                'student.state',
                'student.responsibles.city',
                'student.responsibles.state',
                'unit.city',
                'unit.state',
            ]);

            $path = sprintf(
                'student-contracts/%d/contract-v%d.pdf',
                $model->id,
                $model->version,
            );

            $contents = Pdf::loadView('student-contracts.contract', [
                'contract' => $model,
            ])->setPaper('a4')->output();

            Storage::put($path, $contents);

            StudentMedia::create([
                'student_id'          => $model->student_id,
                'student_contract_id' => $model->id,
                'url'                 => $path,
                'file_type'           => 'application/pdf',
                'type'                => 'contract',
            ]);

            $model->update([
                'file_url'  => $path,
                'file_type' => 'application/pdf',
            ]);

            return $model->fresh();
        });
    }

    //

    public function cancel(int $id, ?int $createdByUserId = null): ?StudentContract
    {
        return $this->update($id, ['status' => 'cancelled'], $createdByUserId);
    }

    public function freeze(int $id, int $months = 0, ?int $createdByUserId = null): ?StudentContract
    {
        return DB::transaction(function () use ($id, $months, $createdByUserId): ?StudentContract {
            $contract = $this->update($id, ['status' => 'frozen'], $createdByUserId);

            if (! $contract) {
                return null;
            }

            if ($months > 0) {
                StudentContractInstallment::where('student_contract_id', $contract->id)
                    ->where('status', 'pending')
                    ->get()
                    ->each(function ($installment) use ($months) {
                        $newDate = Carbon::parse($installment->due_date)->addMonths($months);

                        $installment->update(['due_date' => $newDate->format('Y-m-d')]);
                    });
            }

            return $contract->fresh();
        });
    }

    public function reactivate(int $id, ?int $createdByUserId = null): ?StudentContract
    {
        return $this->update($id, ['status' => 'active'], $createdByUserId);
    }

    //

    // monta o array de datas para n parcelas
    // primeira parcela usa exatamente firstdate, data escolhida pelo usuario
    // segunda parcela em diante usa recurringday avancando mes a mes a partir do mes da primeira
    // exemplo: firstdate=25/05/2026, recurringday=5, count=3
    // resultado: [25/05/2026, 05/06/2026, 05/07/2026]

    private function buildInstallmentDates(string $firstDate, int $recurringDay, int $count): array
    {
        $dates = [];

        $first = Carbon::createFromFormat('Y-m-d', $firstDate);

        $dates[] = $first->copy();

        $baseMonth = $first->copy()->startOfMonth();

        for ($i = 1; $i < $count; $i++) {
            $next = $baseMonth->copy()->addMonths($i);

            $day = min($recurringDay, $next->daysInMonth);

            $next->setDay($day);

            $dates[] = $next;
        }

        return $dates;
    }

    /**
     * Cada bloco de valor do contrato (Matrícula, Pacote/Aulas, Materiais, Total
     * do Curso) gera seu próprio grupo de parcelas quando tem valor, quantidade
     * de parcelas e data de vencimento preenchidos. "Total do Curso" concentra
     * o que foi marcado como "incluso no valor do curso" na proposta; os
     * demais blocos só existem quando a modalidade escolhida marcou aquele
     * item como "permite parcelar" (parcela separada, fora do Total).
     */
    private const INSTALLMENT_BLOCKS = [
        ['value' => 'tax_register', 'installments' => 'installments', 'due_date' => 'enrollment_due_date', 'type' => 'enrollment', 'history' => 'REF. MATRÍCULA'],
        ['value' => 'package_value', 'installments' => 'package_installments', 'due_date' => 'package_due_date', 'type' => 'package', 'history' => 'REF. PACOTE'],
        ['value' => 'materials_value', 'installments' => 'materials_installments', 'due_date' => 'materials_due_date', 'type' => 'materials', 'history' => 'REF. MATERIAIS'],
        ['value' => 'total_value', 'installments' => 'total_installments', 'due_date' => 'total_due_date', 'type' => 'total', 'history' => 'REF. TOTAL DO CURSO'],
    ];

    private function generateInstallments(StudentContract $contract): void
    {
        $recurringDay = $contract->recurring_day ?? 1;

        $rows = [];

        $now = now();

        foreach (self::INSTALLMENT_BLOCKS as $block) {
            $value = $contract->{$block['value']};
            $installments = $contract->{$block['installments']};
            $dueDate = $contract->{$block['due_date']};

            if (! $value || ! $installments || ! $dueDate) continue;

            $installmentValue = round($value / $installments, 2);

            $dates = $this->buildInstallmentDates(
                $dueDate->format('Y-m-d'),
                $recurringDay,
                $installments,
            );

            foreach ($dates as $i => $date) {
                $rows[] = [
                    'student_contract_id' => $contract->id,
                    'unit_id'             => $contract->unit_id,
                    'student_id'          => $contract->student_id,
                    'type'                => $block['type'],
                    'history'             => $block['history'],
                    'installment_number'  => $i + 1,
                    'total_installments'  => $installments,
                    'value'               => $installmentValue,
                    'paid_value'          => 0,
                    'discount'            => 0,
                    'fine'                => 0,
                    'due_date'            => $date->format('Y-m-d'),
                    'status'              => 'pending',
                    'created_at'          => $now,
                    'updated_at'          => $now,
                ];
            }
        }

        if (! empty($rows)) {
            // As parcelas são registradas/calculadas normalmente. A cobrança no Asaas
            // da franquia será reintroduzida no módulo Franchisee (conta própria por unidade).

            StudentContractInstallment::insert($rows);
        }
    }

    private function loadVersionHistory(StudentContract $contract): void
    {
        $root = $contract;

        while ($root->derived_from_contract_id !== null) {
            $parent = StudentContract::with('createdBy')->find($root->derived_from_contract_id);

            if (! $parent) {
                break;
            }

            $root = $parent;
        }

        $history = new Collection;

        $current = StudentContract::with('createdBy')->find($root->id);

        while ($current) {
            $current->loadMissing('createdBy');
            $history->push($current);

            $current = $current->derivedVersions()->with('createdBy')->first();
        }

        $contract->setRelation('versionHistory', $history->sortByDesc('version')->values());
    }
}