<?php

namespace App\Http\Controllers\Api;

use App\Models\AdditionalCharge;
use App\Models\ClassSection;
use App\Models\Configuration;
use App\Models\DiscountUsage;
use App\Models\Enrollment;
use App\Models\EventCharges;
use App\Models\Invoice;
use App\Models\ManualPayment;
use App\Models\PaymentError;
use App\Models\Payment;
use App\Models\StudentClass;
use App\Models\Student;
use App\Models\TeacherClass;
use App\Models\User;
use Illuminate\Http\JsonResponse;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Storage;
use Symfony\Component\HttpFoundation\Response;

class PaymentController extends BaseApiController
{
    protected Payment $payment;
    protected Configuration $config;
    protected ManualPayment $manualPayment;
    protected EventCharges $eventCharges;
    protected User $user;
    protected Enrollment $enrollment;
    protected Student $student;
    protected StudentClass $studentClass;
    protected PaymentError $paymentError;
    protected TeacherClass $teacherClass;
    protected DiscountUsage $discountUsage;
    protected AdditionalCharge $additionalCharge;
    protected ClassSection $classSection;
    protected Invoice $invoice;
    protected string $schoolYear;
    protected string $semester;
    protected ?string $installmentDate;

    public function __construct()
    {
        parent::__construct();
        $this->payment = model(Payment::class);
        $this->config = model(Configuration::class);
        $this->manualPayment = model(ManualPayment::class);
        $this->eventCharges = model(EventCharges::class);
        $this->user = model(User::class);
        $this->enrollment = model(Enrollment::class);
        $this->student = model(Student::class);
        $this->studentClass = model(StudentClass::class);
        $this->paymentError = model(PaymentError::class);
        $this->teacherClass = model(TeacherClass::class);
        $this->discountUsage = model(DiscountUsage::class);
        $this->additionalCharge = model(AdditionalCharge::class);
        $this->classSection = model(ClassSection::class);
        $this->invoice = model(Invoice::class);

        $this->schoolYear = (string) ($this->config->getConfig('school_year') ?? '');
        $this->semester = (string) ($this->config->getConfig('semester') ?? '');
        $this->installmentDate = $this->config->getConfig('installment_date');
    }

    /**
     * GET /api/v1/payments
     * List payments with optional filters
     */
    public function index(): JsonResponse
    {
        $page = max(1, (int) ($this->request->getGet('page') ?? 1));
        $perPage = min(100, max(1, (int) ($this->request->getGet('per_page') ?? 20)));
        $parentId = $this->request->getGet('parent_id');
        $status = $this->request->getGet('status');

        $query = $this->payment->newQuery();

        if ($parentId) {
            $query->where('parent_id', $parentId);
        }

        if ($status) {
            $query->where('status', $status);
        }

        $result = $this->paginate($query, $page, $perPage);

        return $this->success($result, 'Payments retrieved successfully');
    }

    /**
     * GET /api/v1/payments/{id}
     * Get a single payment
     */
    public function show($id = null): JsonResponse
    {
        $payment = $this->payment->find($id);
        if (!$payment) {
            return $this->error('Payment not found', Response::HTTP_NOT_FOUND);
        }

        return $this->success($payment, 'Payment retrieved successfully');
    }

    /**
     * GET /api/v1/payments/parent/{id}
     * Get payments by parent ID
     */
    public function getByParent($id = null): JsonResponse
    {
        $payments = $this->payment->newQuery()
            ->select('payments.*', 'invoices.invoice_number')
            ->leftJoin('invoices', 'invoices.id', '=', 'payments.invoice_id')
            ->where('payments.parent_id', $id)
            ->orderBy('payments.payment_date', 'DESC')
            ->get()
            ->toArray();

        // Get parent name
        $parent = $this->user->select('firstname', 'lastname')->find($id);
        $parentName = trim(($parent['firstname'] ?? '') . ' ' . ($parent['lastname'] ?? ''));

        return $this->success([
            'payments' => $payments,
            'parent_id' => (int) $id,
            'parent_name' => $parentName,
        ], 'Payments retrieved successfully');
    }

    /**
     * POST /api/v1/payments
     * Create a new payment plan
     */
    public function store(): JsonResponse
    {
        $data = $this->payloadData();
        if (empty($data)) {
            return $this->error('Invalid request data', Response::HTTP_BAD_REQUEST);
        }

        $rules = [
            'parent_id' => 'required|integer',
            'total_amount' => 'required|numeric',
            'number_of_installments' => 'nullable|integer',
            'payment_date' => 'required|date',
            'payment_type' => 'nullable|string',
            'semester' => 'nullable|string',
            'school_year' => 'nullable|string',
        ];

        $errors = $this->validateRequest($data, $rules);
        if (!empty($errors)) {
            return $this->respondValidationError($errors);
        }

        $paymentData = [
            'parent_id' => $data['parent_id'],
            'total_amount' => $data['total_amount'],
            'number_of_installments' => $data['number_of_installments'] ?? 1,
            'paid_amount' => 0,
            'balance_amount' => $data['total_amount'],
            'payment_date' => $data['payment_date'],
            'payment_type' => $data['payment_type'] ?? 'installment',
            'status' => 'Pending',
            'semester' => $data['semester'] ?? $this->semester,
            'school_year' => $data['school_year'] ?? $this->schoolYear,
        ];

        try {
            $payment = $this->payment->create($paymentData);
            return $this->success($payment->toArray(), 'Payment plan created successfully', Response::HTTP_CREATED);
        } catch (\Throwable $e) {
            log_message('error', 'Payment creation error: ' . $e->getMessage());
            return $this->respondError('Failed to create payment plan', Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * PATCH /api/v1/payments/{id}
     * Update a payment
     */
    public function update($id = null): JsonResponse
    {
        $payment = $this->payment->find($id);
        if (!$payment) {
            return $this->error('Payment not found', Response::HTTP_NOT_FOUND);
        }

        $user = $this->getCurrentUser();
        if (!$user) {
            return $this->respondError('Authentication required', Response::HTTP_UNAUTHORIZED);
        }

        $data = $this->payloadData();
        if (empty($data)) {
            return $this->error('Invalid request data', Response::HTTP_BAD_REQUEST);
        }

        $allowedFields = ['paid_amount', 'balance', 'status', 'payment_method', 'payment_date', 'check_number'];
        $updateData = [];
        foreach ($allowedFields as $field) {
            if (array_key_exists($field, $data)) {
                $updateData[$field] = $data[$field];
            }
        }

        if (empty($updateData)) {
            return $this->error('No valid fields to update', Response::HTTP_BAD_REQUEST);
        }

        $updateData['updated_by'] = $user->id;

        try {
            $this->payment->update($id, $updateData);
            $updatedPayment = $this->payment->find($id);
            return $this->success($updatedPayment, 'Payment updated successfully');
        } catch (\Throwable $e) {
            log_message('error', 'Payment update error: ' . $e->getMessage());
            return $this->respondError('Failed to update payment', Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * DELETE /api/v1/payments/{id}
     * Delete a payment
     */
    public function destroy($id = null): JsonResponse
    {
        $row = $this->payment->find($id);
        if (!$row) {
            return $this->error('Payment not found', Response::HTTP_NOT_FOUND);
        }

        try {
            $this->payment->delete($id);
            return $this->success(null, 'Payment deleted successfully');
        } catch (\Throwable $e) {
            log_message('error', 'Payment delete error: ' . $e->getMessage());
            return $this->respondError('Failed to delete payment', Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * POST /api/v1/payments/{id}/update-balance
     * Update balance after payment
     */
    public function updateBalance($paymentId): JsonResponse
    {
        $data = $this->payloadData();
        $amountPaid = (float) ($data['paid_amount'] ?? 0);

        if ($amountPaid <= 0) {
            return $this->respondError('Invalid amount', Response::HTTP_BAD_REQUEST);
        }

        if ($this->payment->updateBalance($paymentId, $amountPaid)) {
            return $this->success(['status' => 'success'], 'Balance updated successfully');
        } else {
            return $this->error('Payment not found', Response::HTTP_NOT_FOUND);
        }
    }

    /**
     * GET /api/v1/payments/enrolled-students/{parentId}
     * Get enrolled students for a parent
     */
    public function getEnrolledStudents($parentId): JsonResponse
    {
        $enrollments = $this->enrollment->getEnrolledStudents((int) $parentId, $this->schoolYear);
        $students = [];

        foreach ($enrollments as $row) {
            $students[] = [
                'id' => $row['id'],
                'firstname' => $row['firstname'],
                'lastname' => $row['lastname'],
                'grade' => $this->studentClass->getStudentGrade($row['id']) ?? 'N/A',
            ];
        }

        return $this->success($students, 'Enrolled students retrieved successfully');
    }

    /**
     * GET /api/v1/payments/manual-pay-search
     * Search for parent and get payment data
     */
    public function manualPaySearch(): JsonResponse
    {
        $searchTerm = trim((string) $this->request->getGet('search_term'));

        $installmentDateRaw = (string) ($this->installmentDate ?? '');
        $installmentEndYmd = '';
        if ($installmentDateRaw) {
            $ts = strtotime($installmentDateRaw);
            if ($ts !== false) {
                $installmentEndYmd = date('Y-m-d', $ts);
            }
        }

        $parentData = null;
        $students = [];
        $payments = [];
        $invoices = [];

        if ($searchTerm !== '') {
            $searchClean = preg_replace('/\D/', '', $searchTerm);
            $searchFormatted = $this->formatPhone($searchClean);

            $parent = DB::table('users')
                ->where(function ($query) use ($searchTerm, $searchClean, $searchFormatted) {
                    $query->where('email', $searchTerm);
                    if (!empty($searchClean) && strlen($searchClean) === 10) {
                        $formattedPhone = substr($searchClean, 0, 3) . '-' . substr($searchClean, 3, 3) . '-' . substr($searchClean, 6, 4);
                        $query->orWhere('cellphone', $formattedPhone);
                    }
                    if (!empty($searchClean)) {
                        $query->orWhereRaw("REPLACE(REPLACE(REPLACE(REPLACE(cellphone, '(', ''), ')', ''), '-', ''), ' ', '') = ?", [$searchClean]);
                    }
                    if (!empty($searchFormatted)) {
                        $query->orWhere('cellphone', $searchFormatted);
                    }
                })
                ->first();

            if ($parent) {
                $parentArray = (array) $parent;
                unset($parentArray['password']);
                $parentData = $parentArray;
                $parentId = (int) $parent['id'];

                // Students
                $students = $this->student
                    ->where('parent_id', $parentId)
                    ->findAll();

                // Payments (paginated)
                $payments = $this->payment
                    ->where('parent_id', $parentId)
                    ->orderBy('payment_date', 'DESC')
                    ->paginate(10);

                // Invoices
                $rawInvoices = $this->invoice
                    ->where('parent_id', $parentId)
                    ->orderBy('issue_date', 'DESC')
                    ->findAll();

                // Calculate invoice balances
                $invoiceIds = array_values(array_unique(array_map(static fn($r) => (int)($r['id'] ?? 0), $rawInvoices)));
                $paidByInvoice = [];
                $discountByInvoice = [];
                $refundByInvoice = [];

                if (!empty($invoiceIds)) {
                    $paidRows = DB::table('payments')
                        ->select('invoice_id', DB::raw('COALESCE(SUM(paid_amount),0) AS total_paid'))
                        ->whereIn('invoice_id', $invoiceIds)
                        ->groupBy('invoice_id')
                        ->get();

                    foreach ($paidRows as $r) {
                        $iid = (int)($r->invoice_id ?? 0);
                        $paidByInvoice[$iid] = (float)($r->total_paid ?? 0);
                    }

                    $discRows = DB::table('discount_usages')
                        ->select('invoice_id', DB::raw('COALESCE(SUM(discount_amount),0) AS total_disc'))
                        ->whereIn('invoice_id', $invoiceIds)
                        ->groupBy('invoice_id')
                        ->get();

                    foreach ($discRows as $dr) {
                        $iid = (int)($dr->invoice_id ?? 0);
                        $discountByInvoice[$iid] = (float)($dr->total_disc ?? 0);
                    }

                    $refRows = DB::table('refunds')
                        ->select('invoice_id', DB::raw('COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid'))
                        ->whereIn('invoice_id', $invoiceIds)
                        ->whereIn('status', ['Partial', 'Paid'])
                        ->groupBy('invoice_id')
                        ->get();

                    foreach ($refRows as $rr) {
                        $iid = (int)($rr->invoice_id ?? 0);
                        $refundByInvoice[$iid] = (float)($rr->total_refund_paid ?? 0);
                    }
                }

                // Normalize invoices
                $invoices = array_map(function (array $inv) use ($installmentEndYmd, $paidByInvoice, $discountByInvoice, $refundByInvoice) {
                    $inv['total_amount'] = isset($inv['total_amount']) ? (float) $inv['total_amount'] : 0.0;
                    $iid = (int)($inv['id'] ?? 0);
                    $actualPaid = isset($paidByInvoice[$iid]) ? (float)$paidByInvoice[$iid] : null;
                    $inv['paid_amount'] = is_numeric($actualPaid)
                        ? (float)$actualPaid
                        : (isset($inv['paid_amount']) ? (float)$inv['paid_amount'] : 0.0);
                    $inv['discount'] = isset($discountByInvoice[$iid]) ? (float)$discountByInvoice[$iid] : (float)($inv['discount'] ?? 0.0);
                    $inv['refund_paid'] = isset($refundByInvoice[$iid]) ? (float)$refundByInvoice[$iid] : 0.0;
                    $inv['balance'] = max(0.0, (float)$inv['total_amount'] - (float)$inv['paid_amount'] - (float)$inv['discount'] - (float)$inv['refund_paid']);
                    $inv['due_ymd'] = $installmentEndYmd;

                    $issueYmd = '';
                    foreach (['issue_date', 'start_date', 'created_at'] as $k) {
                        if (!empty($inv[$k])) {
                            $its = strtotime($inv[$k]);
                            if ($its !== false) {
                                $issueYmd = date('Y-m-d', $its);
                                break;
                            }
                        }
                    }
                    $inv['issue_ymd'] = $issueYmd;

                    return $inv;
                }, $rawInvoices);
            }
        }

        return $this->success([
            'parent' => $parentData,
            'students' => $students,
            'payments' => $payments,
            'invoices' => $invoices,
            'search_term' => $searchTerm,
            'today_ymd' => date('Y-m-d'),
            'installment_end_ymd' => $installmentEndYmd,
        ], 'Manual pay search completed');
    }

    /**
     * POST /api/v1/payments/manual-pay-update
     * Update manual payment
     */
    public function manualPayUpdate(): JsonResponse
    {
        $data = $this->payloadData();
        $invoiceId = (int) ($data['invoice_id'] ?? 0);
        $amount = (float) ($data['amount'] ?? 0);
        $paymentMethod = strtolower(trim((string) ($data['payment_method'] ?? '')));
        $checkNumber = trim((string) ($data['check_number'] ?? ''));
        $paymentDateStr = $data['payment_date'] ?? null;
        $paymentDate = $paymentDateStr ? date('Y-m-d H:i:s', strtotime($paymentDateStr)) : utc_now();

        // Validation
        if (!$invoiceId || !$amount || !$paymentMethod) {
            return $this->respondError('Missing required fields (invoice, amount, or method).', Response::HTTP_BAD_REQUEST);
        }

        $allowedMethods = ['cash', 'check', 'card'];
        if (!in_array($paymentMethod, $allowedMethods, true)) {
            return $this->respondError('Invalid payment method.', Response::HTTP_BAD_REQUEST);
        }

        if ($paymentMethod === 'check' && $checkNumber === '') {
            return $this->respondError('Check number is required for check payments.', Response::HTTP_BAD_REQUEST);
        }

        if ($amount <= 0) {
            return $this->respondError('Invalid amount: ' . number_format($amount, 2), Response::HTTP_BAD_REQUEST);
        }

        $invoice = $this->invoice->find($invoiceId);
        if (!$invoice) {
            return $this->respondError('Invoice not found.', Response::HTTP_NOT_FOUND);
        }

        // Snapshot pre-payment balance
        $initialPreBalance = $this->getCurrentInvoiceBalance($invoiceId);

        // Card must equal full balance
        if ($paymentMethod === 'card' && (float)round($amount, 2) !== (float)round($initialPreBalance, 2)) {
            return $this->respondError(
                'Debit/Credit Card payments must equal the full remaining balance (' . number_format($initialPreBalance, 2) . ').',
                Response::HTTP_BAD_REQUEST
            );
        }

        // Handle file upload
        $checkFile = null;
        if ($this->laravelRequest->hasFile('payment_file')) {
            $paymentFile = $this->laravelRequest->file('payment_file');
            if ($paymentFile->isValid()) {
                $okTypes = ['image/jpeg', 'image/png', 'application/pdf'];
                $okExts = ['jpg', 'jpeg', 'png', 'pdf'];
                $mime = $paymentFile->getMimeType();
                $ext = strtolower($paymentFile->getClientExtension());

                if (!in_array($mime, $okTypes, true) || !in_array($ext, $okExts, true)) {
                    return $this->respondError('Unsupported file type. Use JPG, PNG, or PDF.', Response::HTTP_BAD_REQUEST);
                }

                if ($paymentFile->getSize() > 5 * 1024 * 1024) {
                    return $this->respondError('File too large. Max 5MB.', Response::HTTP_BAD_REQUEST);
                }

                $subdir = ($paymentMethod === 'check') ? 'checks' : (($paymentMethod === 'card') ? 'cards' : 'misc');
                $fileName = $paymentFile->store('payments/' . $subdir, 'public');
                $checkFile = basename($fileName);
            }
        }

        DB::beginTransaction();
        try {
            // Lock invoice
            $row = DB::selectOne('SELECT id, parent_id, total_amount, school_year FROM invoices WHERE id = ? FOR UPDATE', [$invoiceId]);
            if (!$row) {
                DB::rollBack();
                return $this->respondError('Invoice not found.', Response::HTTP_NOT_FOUND);
            }

            $parentId = (int)($row->parent_id ?? 0);
            $invYear = (string)($row->school_year ?? $this->schoolYear);

            // Recalculate invoice
            $this->recalculateInvoice($invoiceId, $invYear);

            // Get current balance
            $currentBalance = $this->getCurrentInvoiceBalance($invoiceId);

            if ($amount > $currentBalance + 0.00001) {
                DB::rollBack();
                return $this->respondError(
                    'Entered amount (' . number_format($amount, 2) . ') exceeds remaining balance (' . number_format($currentBalance, 2) . ').',
                    Response::HTTP_BAD_REQUEST
                );
            }

            if ($paymentMethod === 'card' && (float)round($amount, 2) !== (float)round($currentBalance, 2)) {
                DB::rollBack();
                return $this->respondError(
                    'Debit/Credit Card payments must equal the full remaining balance (' . number_format($currentBalance, 2) . ').',
                    Response::HTTP_BAD_REQUEST
                );
            }

            // Installment sequence
            $paidCount = $this->getSuccessfulPaymentCount($invoiceId);
            $installmentSeq = $paidCount + 1;

            // Generate transaction ID
            $transactionId = 'INV-' . $invoiceId . '-' . str_replace('.', '', (string)microtime(true));

            // Process payment
            $ok = $this->processPayment(
                $invoiceId,
                $amount,
                $paymentMethod,
                $checkFile,
                $transactionId,
                $paymentDate,
                $this->schoolYear,
                $this->semester,
                $checkNumber,
                $installmentSeq
            );

            if (!$ok) {
                DB::rollBack();
                return $this->respondError('Failed to record payment.', Response::HTTP_INTERNAL_SERVER_ERROR);
            }

            // Recalculate invoice
            $this->recalculateInvoice($invoiceId, $this->schoolYear);

            // Post-payment balance
            $postBalance = (float)round($initialPreBalance - $amount, 2);
            if ($postBalance < 0) $postBalance = 0.0;

            // Update enrollment status if paid
            $enrollmentUpdated = $this->updateEnrollmentStatusIfPaid($invoiceId);
            if ($enrollmentUpdated != 0) {
                $studentIds = $this->student->getStudentIdsByParentId($parentId);
                [$eventDataEnroll, $studentDataEnroll] = $this->buildStudentEnrolledEventData($parentId, $studentIds);
                Event::dispatch('studentEnrolled', [$eventDataEnroll, $studentDataEnroll]);
            }

            // Calculate discounts
            $invoiceDiscount = 0.0;
            $rowDisc = DB::table('discount_usages')
                ->select(DB::raw('COALESCE(SUM(discount_amount),0) AS sum_disc'))
                ->where('invoice_id', $invoiceId)
                ->first();
            if ($rowDisc) {
                $invoiceDiscount = (float)$rowDisc->sum_disc;
            }

            $parentYearDiscountTotal = 0.0;
            $rowParentDisc = DB::table('discount_usages')
                ->select(DB::raw('COALESCE(SUM(discount_amount),0) AS sum_disc'))
                ->where('parent_id', $parentId)
                ->where('school_year', $this->schoolYear)
                ->first();
            if ($rowParentDisc) {
                $parentYearDiscountTotal = (float)$rowParentDisc->sum_disc;
            }

            DB::commit();

            // Build event data
            [$eventData, $studentData] = $this->buildPaymentEventData(
                $invoiceId,
                $transactionId,
                $amount,
                $paymentMethod,
                $paymentDate,
                $checkNumber,
                $installmentSeq,
                $initialPreBalance,
                $postBalance,
                $invoiceDiscount,
                $parentYearDiscountTotal
            );

            Event::dispatch('paymentReceived', [$eventData, $studentData]);

            return $this->success([
                'transaction_id' => $transactionId,
                'installment_seq' => $installmentSeq,
                'post_balance' => $postBalance,
            ], 'Payment recorded successfully (Installment #' . $installmentSeq . '). Transaction ID: ' . $transactionId);
        } catch (\Throwable $e) {
            DB::rollBack();
            log_message('error', '[manualPayUpdate] ' . $e->getMessage());
            return $this->respondError('Unexpected error while recording payment.', Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * POST /api/v1/payments/manual-pay-edit
     * Edit a manual payment
     */
    public function manualPayEdit(): JsonResponse
    {
        $data = $this->payloadData();
        $paymentId = (int) ($data['payment_id'] ?? 0);
        $paidAmount = (float) ($data['paid_amount'] ?? 0);
        $paymentMethod = $data['payment_method'] ?? '';
        $checkNumber = $data['check_number'] ?? '';

        if (!$paymentId || !$paidAmount || !$paymentMethod) {
            return $this->respondError('Missing required fields.', Response::HTTP_BAD_REQUEST);
        }

        $payment = $this->payment->find($paymentId);
        if (!$payment) {
            return $this->respondError('Original payment not found.', Response::HTTP_NOT_FOUND);
        }

        $invoice = $this->invoice->find($payment['invoice_id']);
        if (!$invoice) {
            return $this->respondError('Linked invoice not found.', Response::HTTP_NOT_FOUND);
        }

        $checkFile = $payment['check_file'] ?? null;

        // Handle file upload
        if (in_array(strtolower($paymentMethod), ['check', 'card']) && $this->laravelRequest->hasFile('payment_file')) {
            $paymentFile = $this->laravelRequest->file('payment_file');
            if ($paymentFile->isValid()) {
                $subdir = (strtolower($paymentMethod) === 'check') ? 'checks' : 'cards';
                $fileName = $paymentFile->store('payments/' . $subdir, 'public');
                $checkFile = basename($fileName);
            }
        }

        if ($paidAmount <= 0) {
            return $this->respondError(
                'Invalid amount entered: ' . number_format($paidAmount, 2) . '. Amount must be greater than zero.',
                Response::HTTP_BAD_REQUEST
            );
        }

        // Recalculate invoice
        $this->recalculateInvoice($payment['invoice_id'], $this->schoolYear);

        // Get current balance excluding this payment
        $currentBalance = $this->getCurrentInvoiceBalanceExcludingPayment($payment['invoice_id'], $paymentId);

        if ($paidAmount > $currentBalance) {
            return $this->respondError(
                'Entered amount (' . number_format($paidAmount, 2) . ') exceeds remaining balance (' . number_format($currentBalance, 2) . ').',
                Response::HTTP_BAD_REQUEST
            );
        }

        // Update payment
        $updateData = [
            'paid_amount' => $paidAmount,
            'payment_method' => strtolower($paymentMethod),
            'check_file' => $checkFile,
            'updated_by' => $this->getCurrentUserId(),
        ];

        if (strtolower($paymentMethod) === 'check') {
            $updateData['check_number'] = $checkNumber;
        } else {
            $updateData['check_number'] = null;
        }

        $this->payment->update($paymentId, $updateData);

        // Recalculate invoice
        $this->recalculateInvoice($payment['invoice_id'], $this->schoolYear);

        return $this->success(null, 'Payment updated successfully');
    }

    /**
     * GET /api/v1/payments/event-charges
     * Get event charges
     */
    public function eventChargesShow(): JsonResponse
    {
        $schoolYear = $this->request->getGet('school_year') ?? $this->schoolYear;
        $semester = $this->request->getGet('semester') ?? $this->semester;

        $charges = $this->eventCharges->newQuery()
            ->select('event_charges.*', 'users.firstname AS parent_firstname', 'users.lastname AS parent_lastname', 'students.firstname AS student_firstname', 'students.lastname AS student_lastname')
            ->leftJoin('users', 'users.id', '=', 'event_charges.parent_id')
            ->leftJoin('students', 'students.id', '=', 'event_charges.student_id')
            ->where('event_charges.school_year', $schoolYear)
            ->where('event_charges.semester', $semester)
            ->orderBy('event_charges.created_at', 'DESC')
            ->get()
            ->toArray();

        $parents = $this->user->getParents();

        return $this->success([
            'charges' => $charges,
            'parents' => $parents,
            'school_year' => $schoolYear,
            'semester' => $semester,
        ], 'Event charges retrieved successfully');
    }

    /**
     * POST /api/v1/payments/event-charges
     * Update event charges
     */
    public function eventChargesUpdate(): JsonResponse
    {
        $data = $this->payloadData();
        $studentIds = $data['student_ids'] ?? [];
        $userId = $this->getCurrentUserId() ?? 0;

        $commonData = [
            'parent_id' => $data['parent_id'],
            'event_name' => $data['event_name'],
            'description' => $data['description'] ?? null,
            'amount' => $data['amount'],
            'semester' => $data['semester'] ?? $this->semester,
            'school_year' => $data['school_year'] ?? $this->schoolYear,
            'charged' => 0,
            'updated_by' => $userId,
        ];

        $success = false;
        $created = [];

        if (!empty($studentIds)) {
            foreach ($studentIds as $studentId) {
                $chargeData = array_merge($commonData, ['student_id' => $studentId]);
                $created[] = $this->eventCharges->create($chargeData);
                $success = true;
            }
        } elseif (isset($data['student_id'])) {
            $chargeData = array_merge($commonData, ['student_id' => $data['student_id']]);
            $created[] = $this->eventCharges->create($chargeData);
            $success = true;
        }

        if (!$success) {
            return $this->respondError('No student selected. Please select at least one.', Response::HTTP_BAD_REQUEST);
        }

        return $this->success($created, 'Event charge(s) added successfully', Response::HTTP_CREATED);
    }

    /**
     * GET /api/v1/payments/redirect-page
     * Get payment redirect page data
     */
    public function redirectPage(): JsonResponse
    {
        $modeCheck = $this->config->getConfig('paypal_mode');
        $parentId = $this->getCurrentUserId();

        $parent = DB::table('users')
            ->select('firstname', 'lastname', 'school_id')
            ->where('id', $parentId)
            ->first();

        $parentName = isset($parent->firstname, $parent->lastname)
            ? $parent->firstname . ' ' . $parent->lastname
            : 'Parent';

        $schoolId = $parent->school_id ?? null;

        $latestInvoice = $this->invoice->where('parent_id', $parentId)
            ->orderBy('created_at', 'DESC')
            ->select('total_amount')
            ->first();

        $totalAmount = $latestInvoice['total_amount'] ?? 0;

        return $this->success([
            'parent_name' => $parentName,
            'total_amount' => $totalAmount,
            'school_id' => $schoolId,
            'mode_check' => $modeCheck,
        ], 'Payment redirect data retrieved');
    }

    /**
     * GET /api/v1/payments/check-file/{filename}
     * Serve check file
     */
    public function serveCheckFile($filename, $mode = 'download'): \Symfony\Component\HttpFoundation\StreamedResponse|JsonResponse
    {
        $filename = basename($filename);
        $roots = [
            storage_path('app/public/uploads/checks/' . $filename),
            storage_path('app/public/uploads/cards/' . $filename),
            storage_path('app/public/uploads/misc/' . $filename),
            storage_path('app/public/uploads/' . $filename),
        ];

        $path = null;
        foreach ($roots as $candidate) {
            if (is_file($candidate)) {
                $path = $candidate;
                break;
            }
        }

        if (!$path) {
            return $this->respondError('Payment file not found: ' . $filename, Response::HTTP_NOT_FOUND);
        }

        if ($mode === 'inline') {
            return response()->file($path, [
                'Content-Type' => mime_content_type($path),
                'Content-Disposition' => 'inline; filename="' . $filename . '"',
            ]);
        }

        return response()->download($path, $filename);
    }

    // Private helper methods

    private function formatPhone($input): string
    {
        $digits = preg_replace('/\D/', '', $input);
        if (strlen($digits) !== 10) {
            return $input;
        }
        return sprintf('(%s)-%s-%s', substr($digits, 0, 3), substr($digits, 3, 3), substr($digits, 6, 4));
    }

    private function getCurrentInvoiceBalance(int $invoiceId): float
    {
        $invoice = $this->invoice->find($invoiceId);
        if (!$invoice) return 0.0;

        $totalPaid = (float) DB::table('payments')
            ->where('invoice_id', $invoiceId)
            ->whereNotIn('status', ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'])
            ->sum('paid_amount');

        $totalDisc = (float) DB::table('discount_usages')
            ->where('invoice_id', $invoiceId)
            ->sum('discount_amount');

        $totalRefundPaid = (float) DB::table('refunds')
            ->where('invoice_id', $invoiceId)
            ->whereIn('status', ['Partial', 'Paid'])
            ->sum('refund_paid_amount');

        $total = (float)($invoice['total_amount'] ?? 0);
        return max(0.0, round($total - $totalPaid - $totalDisc - $totalRefundPaid, 2));
    }

    private function getCurrentInvoiceBalanceExcludingPayment(int $invoiceId, int $excludePaymentId): float
    {
        $invoice = $this->invoice->find($invoiceId);
        if (!$invoice) return 0.0;

        $totalPaid = (float) DB::table('payments')
            ->where('invoice_id', $invoiceId)
            ->where('id', '!=', $excludePaymentId)
            ->whereNotIn('status', ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'])
            ->sum('paid_amount');

        $totalDisc = (float) DB::table('discount_usages')
            ->where('invoice_id', $invoiceId)
            ->sum('discount_amount');

        $totalRefundPaid = (float) DB::table('refunds')
            ->where('invoice_id', $invoiceId)
            ->whereIn('status', ['Partial', 'Paid'])
            ->sum('refund_paid_amount');

        $total = (float)($invoice['total_amount'] ?? 0);
        return max(0.0, round($total - $totalPaid - $totalDisc - $totalRefundPaid, 2));
    }

    private function getSuccessfulPaymentCount(int $invoiceId): int
    {
        return DB::table('payments')
            ->where('invoice_id', $invoiceId)
            ->where('paid_amount', '>', 0)
            ->whereNotIn('status', ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'])
            ->count();
    }

    private function processPayment(
        $invoiceId,
        $amount,
        $paymentMethod,
        $checkFile = null,
        $transactionId = null,
        $paymentDate = null,
        $schoolYear = null,
        $semester = null,
        $checkNumber = null,
        ?int $installmentSeq = null
    ): bool {
        $invoice = $this->invoice->find($invoiceId);
        if (!$invoice) {
            return false;
        }

        $transactionId = $transactionId ?? 'INV-' . $invoiceId . '-' . time();
        $paymentDate = $paymentDate ?? utc_now();

        if ($installmentSeq === null || $installmentSeq < 1) {
            $installmentSeq = $this->getSuccessfulPaymentCount($invoiceId) + 1;
        }

        $newPaid = (float) $invoice['paid_amount'] + (float) $amount;
        $newBalance = (float) $invoice['balance'] - (float) $amount;

        if ($newBalance == $invoice['total_amount']) {
            $paymentStatus = 'Unpaid';
        } elseif ($newBalance > 0 && $newBalance < $invoice['total_amount']) {
            $paymentStatus = 'Partially Paid';
        } elseif ($newBalance <= 0.00001) {
            $paymentStatus = 'Paid';
        } else {
            $paymentStatus = $invoice['status'];
        }

        $invoiceUpdateData = [
            'paid_amount' => $newPaid,
            'balance' => $newBalance,
            'status' => $paymentStatus,
            'updated_by' => $this->getCurrentUserId(),
        ];

        if (!$this->invoice->update($invoiceId, $invoiceUpdateData)) {
            return false;
        }

        $paymentData = [
            'parent_id' => $invoice['parent_id'],
            'invoice_id' => $invoiceId,
            'total_amount' => $invoice['total_amount'],
            'paid_amount' => $amount,
            'balance' => $newBalance,
            'number_of_installments' => $installmentSeq,
            'transaction_id' => $transactionId,
            'payment_method' => strtolower($paymentMethod),
            'payment_date' => $paymentDate,
            'status' => $paymentStatus,
            'check_file' => $checkFile,
            'check_number' => (strtolower($paymentMethod) === 'check') ? $checkNumber : null,
            'updated_by' => $this->getCurrentUserId(),
            'school_year' => $schoolYear ?? $this->schoolYear,
            'semester' => $semester ?? $this->semester,
        ];

        return $this->payment->insert($paymentData) !== false;
    }

    private function recalculateInvoice($invoiceId, $schoolYear): void
    {
        $invoice = $this->invoice->find($invoiceId);
        if (!$invoice) return;

        $parentId = (int)($invoice['parent_id'] ?? 0);
        if ($parentId <= 0) return;

        // Get enrollments
        $enrollments = $this->enrollment
            ->where('parent_id', $parentId)
            ->where('school_year', $schoolYear)
            ->findAll();

        $registered = [];
        $withdrawn = [];

        foreach ($enrollments as $e) {
            $row = [
                'student_id' => (int)($e['student_id'] ?? 0),
                'class_section_id' => $e['class_section_id'] ?? null,
                'enrollment_status' => (string)($e['enrollment_status'] ?? ''),
            ];

            if (in_array($row['enrollment_status'], ['enrolled', 'payment pending'], true)) {
                $registered[] = $row;
            } elseif (in_array($row['enrollment_status'], ['withdrawn', 'refund pending', 'withdraw under review'], true)) {
                $withdrawn[] = $row;
            }
        }

        // Refund window check
        $refundDeadline = (string)($this->config->getConfig('refund_deadline') ?? '');
        $refundAllowed = true;

        try {
            $tzName = (string) (config('app.timezone', 'UTC'));
            $tz = new \DateTimeZone($tzName);
            $today = new \DateTimeImmutable('today', $tz);
            $deadline = new \DateTimeImmutable($refundDeadline, $tz);
            $refundAllowed = $today <= $deadline;
        } catch (\Throwable $e) {
            $refundAllowed = true;
        }

        $tuitionStudents = $registered;
        if (!$refundAllowed) {
            $tuitionStudents = array_merge($tuitionStudents, $withdrawn);
        }

        // Grade threshold and fees
        $gradeFee = (int)($this->config->getConfig('grade_fee') ?? 9);
        $firstStudentFee = (float)($this->config->getConfig('first_student_fee') ?? 350);
        $secondStudentFee = (float)($this->config->getConfig('second_student_fee') ?? 200);
        $youthFee = (float)($this->config->getConfig('youth_fee') ?? 180);

        // Normalize grades
        foreach ($tuitionStudents as &$s) {
            $name = null;
            if (!empty($s['class_section_id'])) {
                $name = $this->classSection->getClassSectionNameBySectionId($s['class_section_id']);
            }
            $s['grade_name'] = is_string($name) ? strtoupper(trim($name)) : 'N/A';
        }
        unset($s);

        // Count regular vs youth
        $regularCount = 0;
        $youthCount = 0;
        foreach ($tuitionStudents as $s) {
            $lvl = $this->parseGradeLevel($s['grade_name']);
            if ($lvl > $gradeFee) $youthCount++; else $regularCount++;
        }

        $tuitionSubtotal = 0.0;
        $tuitionSubtotal += $youthCount * $youthFee;
        if ($regularCount >= 2) {
            $tuitionSubtotal += $firstStudentFee + ($regularCount - 1) * $secondStudentFee;
        } elseif ($regularCount === 1) {
            $tuitionSubtotal += $firstStudentFee;
        }

        // Event charges
        $eventSubtotal = 0.0;
        try {
            $events = $this->eventCharges->getChargesWithEventInfo($parentId, $schoolYear) ?? [];
            foreach ($events as $ev) {
                $eventSubtotal += (float)($ev['charged'] ?? 0.0);
            }
        } catch (\Throwable $e) {
        }

        // Additional charges
        $additionalSubtotal = 0.0;
        try {
            $rows = $this->additionalCharge
                ->select('charge_type', 'amount')
                ->where('invoice_id', $invoiceId)
                ->where('status', 'applied')
                ->findAll();

            foreach ($rows as $r) {
                $amt = (float)($r['amount'] ?? 0);
                $typ = strtolower((string)($r['charge_type'] ?? 'add'));
                if ($typ === 'deduct') $amt = -abs($amt); else $amt = abs($amt);
                $additionalSubtotal += $amt;
            }
        } catch (\Throwable $e) {
        }

        $newTotal = round($tuitionSubtotal + $eventSubtotal + $additionalSubtotal, 2);

        // Payments / Discounts / Refunds
        $payments = $this->payment
            ->where('invoice_id', $invoiceId)
            ->where('school_year', $schoolYear)
            ->findAll();

        $totalPaid = 0.0;
        foreach ($payments as $p) {
            $totalPaid += (float)($p['paid_amount'] ?? 0);
        }

        $discRow = DB::table('discount_usages')
            ->select(DB::raw('COALESCE(SUM(discount_amount),0) AS total_disc'))
            ->where('invoice_id', $invoiceId)
            ->first();

        $totalDisc = (float)($discRow->total_disc ?? 0);

        $refundRow = DB::table('refunds')
            ->select(DB::raw('COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid'))
            ->where('invoice_id', $invoiceId)
            ->whereIn('status', ['Partial', 'Paid'])
            ->first();

        $totalRefundPaid = (float)($refundRow->total_refund_paid ?? 0);

        $newBalance = max(0.0, $newTotal - $totalDisc - $totalPaid - $totalRefundPaid);
        $newStatus = ($newBalance <= 0.00001) ? 'Paid' : (($totalPaid > 0) ? 'Partially Paid' : 'Unpaid');

        $this->invoice->update($invoiceId, [
            'total_amount' => $newTotal,
            'paid_amount' => $totalPaid,
            'balance' => $newBalance,
            'status' => $newStatus,
        ]);
    }

    private function parseGradeLevel($grade): int
    {
        if (is_numeric($grade)) return (int)$grade;
        if (!is_string($grade)) return 999;

        $g = strtoupper(trim((string)$grade));
        $g = preg_replace('/\s+/', ' ', $g);
        $g = str_replace(['.', '_', '-'], ['', '', ' '], $g);

        $kg = ['K', 'KG', 'K G', 'KINDER', 'KINDERGARTEN'];
        if (in_array($g, $kg, true)) return 1;

        $pk = ['PK', 'P K', 'PREK', 'PRE K', 'PRE KINDER', 'PREKINDER'];
        if (in_array($g, $pk, true)) return -1;

        if (preg_match('/^Y(?:OUTH)?\s*(\d+)?$/', $g, $m)) {
            $n = isset($m[1]) && $m[1] !== '' ? max(1, (int)$m[1]) : 1;
            $gradeFee = (int)($this->config->getConfig('grade_fee') ?? 9);
            return $gradeFee + $n;
        }

        if (preg_match('/^(?:GR?ADE\s*)?(\d{1,2})\s*([A-Z]*)$/', $g, $m)) {
            return (int)$m[1];
        }

        return 999;
    }

    private function updateEnrollmentStatusIfPaid(int $invoiceId): int
    {
        $invoice = $this->invoice->find($invoiceId);
        if (!$invoice) {
            log_message('warning', 'Invoice not found: {id}', ['id' => $invoiceId]);
            return 0;
        }

        $total = (float) ($invoice['total_amount'] ?? 0);
        $currentBal = $this->getCurrentInvoiceBalance($invoiceId);

        if (!($total > 0 && $currentBal < $total)) {
            log_message('info', 'No payment yet (or still full balance). Skipping enrollment update. Invoice #{id}', ['id' => $invoiceId]);
            return 0;
        }

        $parentId = (int) ($invoice['parent_id'] ?? 0);
        $schoolYear = (string) $this->schoolYear;
        $semester = isset($this->semester) && $this->semester !== '' ? (string)$this->semester : null;

        if ($parentId <= 0 || $schoolYear === '') {
            log_message('warning', 'updateEnrollmentStatusIfPaid: missing parent_id/school_year for invoice #{id}', ['id' => $invoiceId]);
            return 0;
        }

        $toUpdateIds = DB::table('enrollments')
            ->select('id')
            ->where('parent_id', $parentId)
            ->where('school_year', $schoolYear)
            ->where(function ($query) {
                $query->where('enrollment_status', 'payment pending')
                    ->orWhere('enrollment_status', 'Payment pending')
                    ->orWhere('enrollment_status', 'Payment Pending')
                    ->orWhere('enrollment_status', 'PAYMENT PENDING')
                    ->orWhereRaw("LOWER(TRIM(REPLACE(enrollment_status, CHAR(160), ' '))) = 'payment pending'");
            })
            ->when($semester !== null, function ($query) use ($semester) {
                $query->where('semester', $semester);
            })
            ->pluck('id')
            ->toArray();

        if (empty($toUpdateIds)) {
            log_message('info', 'No enrollments matched pending status for parent {p}, year {y}, sem {s}.', [
                'p' => $parentId,
                'y' => $schoolYear,
                's' => $semester ?? 'ALL'
            ]);
            return 0;
        }

        DB::beginTransaction();
        try {
            $affected = DB::table('enrollments')
                ->whereIn('id', $toUpdateIds)
                ->update([
                    'enrollment_status' => 'enrolled',
                    'enrollment_date' => date('Y-m-d'),
                ]);

            DB::commit();

            log_message('info', 'Enrollment status -> enrolled for {n} row(s). parent={p}, year={y}, sem={s}, ids=[{ids}]', [
                'n' => $affected,
                'p' => $parentId,
                'y' => $schoolYear,
                's' => $semester ?? 'ALL',
                'ids' => implode(',', $toUpdateIds),
            ]);

            return $affected;
        } catch (\Throwable $e) {
            DB::rollBack();
            log_message('error', 'updateEnrollmentStatusIfPaid error: ' . $e->getMessage());
            return 0;
        }
    }

    private function buildStudentEnrolledEventData(
        int $parentId,
        array $studentIds,
        ?string $schoolYear = null,
        ?string $semester = null,
        ?string $portalLink = null
    ): array {
        $schoolYear = $schoolYear ?? $this->schoolYear;
        $semester = $semester ?? $this->semester;
        $portalLink = $portalLink ?? url('/login');

        $parent = DB::table('users')
            ->select('id', 'firstname', 'lastname', 'email')
            ->where('id', $parentId)
            ->first();

        if (!$parent) {
            throw new \RuntimeException("Parent user #{$parentId} not found");
        }

        $ids = array_values(array_unique(array_map('intval', $studentIds)));
        if (empty($ids)) {
            $ids = array_map(
                fn($r) => (int)$r->id,
                DB::table('students')
                    ->select('id')
                    ->where('parent_id', $parentId)
                    ->get()
                    ->toArray()
            );
        }

        if (empty($ids)) {
            return [[
                'user_id' => (int) $parent->id,
                'email' => $parent->email ?? null,
                'firstname' => $parent->firstname ?? '',
                'lastname' => $parent->lastname ?? '',
                'school_year' => $schoolYear,
            ], []];
        }

        $rows = DB::table('students as s')
            ->select([
                's.id AS student_id',
                's.firstname AS s_firstname',
                's.lastname AS s_lastname',
                's.registration_grade',
                'sc.class_section_id',
                'cs.class_section_name',
                'tu.firstname AS t_firstname',
                'tu.lastname AS t_lastname'
            ])
            ->leftJoin('student_class as sc', function ($join) use ($schoolYear, $semester) {
                $join->on('sc.student_id', '=', 's.id')
                    ->where('sc.school_year', '=', $schoolYear)
                    ->where('sc.semester', '=', $semester);
            })
            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'sc.class_section_id')
            ->leftJoin('teacher_class as tc', function ($join) use ($schoolYear, $semester) {
                $join->on('tc.class_section_id', '=', 'sc.class_section_id')
                    ->where('tc.position', '=', 'main')
                    ->where('tc.school_year', '=', $schoolYear)
                    ->where('tc.semester', '=', $semester);
            })
            ->leftJoin('users as tu', 'tu.id', '=', 'tc.teacher_id')
            ->where('s.parent_id', $parentId)
            ->whereIn('s.id', $ids)
            ->orderBy('sc.updated_at', 'DESC')
            ->get()
            ->toArray();

        if (!$rows) {
            $rows = DB::table('students as s')
                ->select('s.id AS student_id', 's.firstname AS s_firstname', 's.lastname AS s_lastname', 's.registration_grade')
                ->whereIn('s.id', $ids)
                ->where('s.parent_id', $parentId)
                ->get()
                ->toArray();
        }

        $studentdata = [];
        $seen = [];

        foreach ($rows as $r) {
            $sid = (int) ($r->student_id ?? 0);
            if ($sid <= 0 || isset($seen[$sid])) continue;

            $seen[$sid] = true;

            $teacherFull = trim(
                trim((string)($r->t_firstname ?? '')) . ' ' .
                    trim((string)($r->t_lastname ?? ''))
            );

            if ($teacherFull === '') {
                $teacherFull = null;
            }

            $studentdata[] = [
                'id' => $sid,
                'student_id' => $sid,
                'firstname' => (string)($r->s_firstname ?? ''),
                'lastname' => (string)($r->s_lastname ?? ''),
                'name' => trim(((string)($r->s_firstname ?? '')) . ' ' . ((string)($r->s_lastname ?? ''))),
                'registration_grade' => (string)($r->registration_grade ?? ''),
                'class_section_id' => isset($r->class_section_id) ? (int)$r->class_section_id : null,
                'class_section_name' => $r->class_section_name ?? null,
                'teacher_name' => $teacherFull,
                'start_date' => '',
                'portal_link' => $portalLink,
            ];
        }

        $data = [
            'user_id' => (int) $parent->id,
            'email' => $parent->email ?? null,
            'firstname' => $parent->firstname ?? '',
            'lastname' => $parent->lastname ?? '',
            'school_year' => $schoolYear,
            'semester' => $semester,
            'portal_link' => $portalLink,
        ];

        return [$data, $studentdata];
    }

    private function buildPaymentEventData(
        int $invoiceId,
        string $transactionId,
        float $amount,
        string $paymentMethod,
        string $paymentDate,
        ?string $checkNumber,
        int $installmentSeq,
        float $preBalance,
        float $postBalance,
        ?float $invoiceDiscount = null,
        ?float $parentYearDiscountTotal = null
    ): array {
        $invoice = $this->invoice->find($invoiceId) ?: [];
        $parentId = (int) ($invoice['parent_id'] ?? 0);

        $parent = $parentId
            ? DB::table('users')->select('id', 'firstname', 'lastname', 'email')->where('id', $parentId)->first()
            : null;

        $eventData = [
            'invoice_id' => $invoiceId,
            'invoice_number' => $invoice['invoice_number'] ?? null,
            'transaction_id' => $transactionId,
            'transactionId' => $transactionId,
            'amount' => (float) $amount,
            'payment_method' => $paymentMethod,
            'method' => $paymentMethod,
            'payment_date' => $paymentDate,
            'check_number' => $checkNumber ?: null,
            'installment_seq' => (int) $installmentSeq,
            'pre_balance' => (float) $preBalance,
            'post_balance' => (float) $postBalance,
            'invoice_total' => (float) ($invoice['total_amount'] ?? 0),
            'user_id' => (int) ($parent->id ?? $parentId),
            'email' => $parent->email ?? null,
            'firstname' => $parent->firstname ?? null,
            'lastname' => $parent->lastname ?? null,
            'school_year' => $this->schoolYear,
            'semester' => $this->semester,
        ];

        if ($invoiceDiscount !== null) {
            $eventData['invoice_discount'] = (float) $invoiceDiscount;
        }

        if ($parentYearDiscountTotal !== null) {
            $eventData['parent_year_discount_total'] = (float) $parentYearDiscountTotal;
        }

        $students = [];
        if ($parentId) {
            $studentRows = DB::table('students')
                ->select('id', 'firstname', 'lastname')
                ->where('parent_id', $parentId)
                ->orderBy('lastname', 'ASC')
                ->get();

            foreach ($studentRows as $r) {
                $students[] = [
                    'id' => (int) $r->id,
                    'firstname' => (string) ($r->firstname ?? ''),
                    'lastname' => (string) ($r->lastname ?? ''),
                    'name' => trim(($r->firstname ?? '') . ' ' . ($r->lastname ?? '')),
                ];
            }
        }

        return [$eventData, $students];
    }
}