<?php

namespace App\Controllers\View;

use App\Controllers\BaseController;
use App\Models\UserModel;
use App\Models\StudentModel;
use App\Models\ClassSectionModel;
use App\Models\StudentClassModel;
use App\Models\AuthorizedUserModel;
use App\Models\EmergencyContactModel;
use App\Models\ConfigurationModel;
use App\Models\StudentMedicalConditionModel;
use App\Models\StudentAllergyModel;
use \App\Models\EnrollmentModel;
use \App\Models\EventChargesModel;
use \App\Models\EventModel;
use CodeIgniter\Events\Events;
use App\Services\SchoolIdService;
use App\Services\FeeCalculationService;
use App\Services\PhoneFormatterService;
use InvalidArgumentException;
use DateTimeImmutable;
use DateTimeZone;
use Throwable;


use DateTime;
use Exception;
use CodeIgniter\Database\Exceptions\DatabaseException;


class ParentController extends BaseController
{
    protected $userModel;
    protected $studentModel;
    protected $db;
    protected $classSectionModel;
    protected $studentClassModel;
    protected $configModel;
    protected $lastDayOfRegistration;
    protected $withdrawalDeadline;
    protected $schoolYear;
    protected $semester;
    protected $dateAgeReference;
    protected $enrollmentModel;
    protected $maxChilds;
    protected $maxEmergency;
    protected $chargesModel;
    protected $eventModel;
    protected $eventController;
    protected $emergencyContactModel;
    protected $medicalConditionModel;
    protected $allergyModel;
    protected $authorizedUsersModel;
    protected $schoolStartDate;
    protected $ageDateRefernce;


    public function __construct()
    {
        $this->db = \Config\Database::connect();
        $this->userModel = new UserModel();
        $this->studentModel = new StudentModel();
        $this->classSectionModel = new ClassSectionModel();
        $this->studentClassModel = new StudentClassModel();
        $this->configModel = new ConfigurationModel();
        $this->enrollmentModel = new EnrollmentModel();
        $this->chargesModel = new EventChargesModel();
        $this->eventModel = new EventModel();
        $this->eventController = new \App\Controllers\View\InvoiceController();
        $this->emergencyContactModel =  new EmergencyContactModel();
        $this->medicalConditionModel = new StudentMedicalConditionModel();
        $this->allergyModel = new StudentAllergyModel();
        $this->authorizedUsersModel = new AuthorizedUserModel();

        $this->ageDateRefernce = $this->configModel->getConfig('date_age_reference');
        $this->lastDayOfRegistration = $this->configModel->getConfig('enrollment_deadline');
        $this->schoolStartDate = $this->configModel->getConfig('fall_semester_start');
        $this->withdrawalDeadline = $this->configModel->getConfig('refund_deadline');
        $this->schoolYear = $this->configModel->getConfig('school_year');
        $this->semester = $this->configModel->getConfig('semester');
        $this->dateAgeReference     = $this->configModel->getConfig('date_age_reference');
        $this->maxChilds       = (int) $this->configModel->getConfig('max_kids') ?? 0;
        $this->maxEmergency    = (int) $this->configModel->getConfig('max_emergency') ?? 0;

        helper(['url', 'form']);

        if (!session()->get('is_logged_in')) {
            return redirect()->to('/login');
        }

        // Add more role-specific checks if needed
        if (session()->get('role') !== 'parent') {
            return redirect()->to('/access_denied');
        }
    }

    public function index()
    {
        // Retrieve all parents from the database where role is parent
        $parents = $this->userModel->where('role', 'parent')->findAll();
        // Pass the parents to the view
        return view('administrator/parent', ['parents' => $parents]);
    }

    public function create()
    {
        // Show the form to create a new parent
        return view('administrator/create_parent');
    }

    public function store()
    {
        // Handle the form submission to create a new parent
        $data = [
            'firstname' => $this->request->getPost('firstname'),
            'lastname' => $this->request->getPost('lastname'),
            'email' => strtolower($this->request->getPost('email')),
            'password' => password_hash($this->request->getPost('password'), PASSWORD_DEFAULT),
            'role' => 'parent',
        ];
        $this->userModel->insert($data);
        return redirect()->to('/administrator/parent');
    }

    public function edit($id)
    {
        // Retrieve the parent details to edit
        $parent = $this->userModel->find($id);
        return view('administrator/edit_parent', ['parent' => $parent]);
    }

    public function update($id)
    {
        // Handle the form submission to update an existing parent
        $data = [
            'firstname' => $this->request->getPost('firstname'),
            'lastname' => $this->request->getPost('lastname'),
            'email' => strtolower($this->request->getPost('email')),
        ];
        if ($this->request->getPost('password')) {
            $data['password'] = password_hash($this->request->getPost('password'), PASSWORD_DEFAULT);
        }
        $this->userModel->update($id, $data);
        return redirect()->to('/administrator/parent');
    }

    public function destroy($id)
    {
        // Delete the parent
        $this->userModel->delete($id);
        return redirect()->to('/administrator/parent');
    }

    public function attendance()
    {
        try {
            // Get parent ID from session
            $parentId = session()->get('user_id');

            if (!$parentId) {
                return redirect()->back()->with('error', 'Parent session not found.');
            }

            // Get current school year from config
            $currentSchoolYear = $this->configModel->getConfig('school_year');

            // Get selected school year (no semester filter on parent view)
            $selectedYear = $this->request->getVar('school_year') ?? $currentSchoolYear;

            // Build query to retrieve attendance
            $builder = $this->db->table('attendance_data');
            $builder->select('students.firstname, students.lastname, attendance_data.date, attendance_data.status, attendance_data.reason');
            $builder->join('students', 'students.id = attendance_data.student_id');
            $builder->where('attendance_data.school_year', $selectedYear);
            // No semester filter so both semesters show for the selected year
            $builder->where('students.parent_id', $parentId);

            $query = $builder->get();
            $attendanceResults = $query->getResultArray();

            // Get list of available school years
            $schoolYears = $this->db->table('attendance_data')
                ->select('school_year')
                ->distinct()
                ->orderBy('school_year', 'DESC')
                ->get()
                ->getResultArray();

            // If no records found, set a flag to show message in the view
            if (empty($attendanceResults)) {
                return view('/parent/attendance', [
                    'attendance' => null,
                    'schoolYears' => $schoolYears,
                    'selectedYear' => $selectedYear,
                    'selectedSemester' => null,
                    //'error' => 'No attendance records found for the selected school year and semester.'
                ]);
            }

            // Return view with attendance results
            return view('/parent/attendance', [
                'attendance' => $attendanceResults,
                'schoolYears' => $schoolYears,
                'selectedYear' => $selectedYear,
                'selectedSemester' => null,
                'error' => null
            ]);
        } catch (Exception $e) {
            log_message('error', 'Failed to retrieve attendance data: ' . $e->getMessage());

            return view('/parent/attendance', [
                'attendance' => null,
                'schoolYears' => [],
                'selectedYear' => $selectedYear ?? null,
                'selectedSemester' => null,
                'error' => 'Failed to retrieve attendance data. Please try again later.'
            ]);
        }
    }
    public function viewPayments()
    {
        $parentId = session()->get('user_id');

        // Log the user ID for debugging
        log_message('info', 'Logged in user ID: ' . $parentId);

        if (!$parentId) {
            log_message('error', 'No user ID found in session.');
            return view('/parent/payment', ['invoices' => [], 'error' => 'No user ID found in session.']);
        }

        // Fetch invoices for the logged-in user based on parent IDs
        $builder = $this->db->table('invoices');
        $builder->select('*');
        $builder->groupStart()
            ->where('parent_id', $parentId)
            //->orWhere('secondparent_user_id', $userId)
            ->groupEnd();
        $query = $builder->get();
        $invoices = $query->getResultArray();

        // Log the query and results for debugging
        log_message('info', 'Query executed: ' . $builder->getCompiledSelect());
        log_message('info', 'invoices: ' . print_r($invoices, true));

        if (empty($invoices)) {
            log_message('info', 'No invoices found for user ID: ' . $parentId);
        } else {
            log_message('info', count($invoices) . ' payment(s) found for user ID: ' . $parentId);
        }

        // Pass the data to the view
        return view('/parent/payment', [
            'invoices' => $invoices
        ]);
    }

    public function enrollClasses()
    {
        try {
            // Log session data for debugging
            log_message('info', 'Session Data: ' . print_r(session()->get(), true));

            // Get deadlines and school year from config
            if (!$this->schoolYear) {
                log_message('error', 'Current school year not found in configuration.');
                return redirect()->back()->with('error', 'Configuration error: School year missing.');
            }

            // Get selected school year from request or fallback
            $selectedYear = $this->request->getGet('school_year') ?? $this->schoolYear;
            $isEditable = ($selectedYear === $this->schoolYear);

            // Get parent ID from session
            $parentId = session()->get('user_id');

            if (!$parentId) {
                log_message('error', 'User ID not found in session.');
                return redirect()->back()->with('error', 'User session error. Please log in again.');
            }

            // Verify user type is "parent" from the `users` table
            $userData = $this->db->table('users')
                ->select('user_type')
                ->where('id', $parentId)
                ->get()
                ->getRowArray();

            if (!$userData || $userData['user_type'] !== 'primary') {
                return redirect()->back()->with('error', 'Invalid user type. Only primary parents can enroll.');
            }

            // Fetch students with parent_id = current logged in user
            $students = $this->db->table('students')
                ->where('parent_id', $parentId)
                ->get()
                ->getResultArray();

            if (empty($students)) {
                log_message('error', 'No students found for Parent ID: ' . $parentId);
                return redirect()->to('/no-kids')->with('error', 'No students found. Please register your child first.');
            }

            // Map enrollment statuses
            $statusMap = [
                'admission under review' => 'admission under review',
                'payment pending' => 'payment pending',
                'enrolled' => 'enrolled',
                'withdraw under review' => 'withdraw under review',
                'refund pending' => 'refund pending',
                'withdrawn' => 'withdrawn',
                'denied' => 'denied',
                'waitlist' => 'waitlist' // ✅ Add this line
            ];


            // Attach enrollment and class section data to each student
            foreach ($students as &$student) {
                $studentId = $student['id'];

                // Get class section info (can be multiple sections like Grade + Arabic)
                $classSections = $this->studentClassModel->getClassSectionsByStudentId($studentId, $selectedYear, true);
                $student['class_section'] = !empty($classSections)
                    ? implode(', ', $classSections)
                    : 'Class not Assigned';
                $isArabicClass = !empty($classSections) && array_reduce(
                    $classSections,
                    static fn($carry, $name) => $carry || (is_string($name) && stripos($name, 'arabic') === 0),
                    false
                );

                // ✅ Get enrollment status AND admission status
                $enrollment = $this->db->table('enrollments')
                    ->select('enrollment_status, admission_status')
                    ->where('student_id', $studentId)
                    ->where('school_year', $selectedYear)
                    ->get()
                    ->getRowArray();

                // ✅ Apply admission status override logic
                if ($enrollment && isset($enrollment['admission_status'])) {
                    $student['admission_status'] = $enrollment['admission_status'];

                    if ($enrollment['admission_status'] === 'denied') {
                        // Force enrollment_status to denied if admission is denied
                        $student['enrollment_status'] = 'denied';
                    } else {
                        // Use enrollment_status from DB if admission is accepted/pending
                        $student['enrollment_status'] = $enrollment && isset($statusMap[$enrollment['enrollment_status']])
                            ? $statusMap[$enrollment['enrollment_status']]
                            : 'not enrolled';
                    }
                } else {
                    // No enrollment record found
                    $student['admission_status'] = null;
                    $student['enrollment_status'] = 'not enrolled';
                }

                // If assigned to Arabic class without an enrollment record, display as enrolled.
                if ($student['enrollment_status'] === 'not enrolled' && $isArabicClass) {
                    $student['enrollment_status'] = 'enrolled';
                }

                // ✅ Updated disable logic to include denied status
                $student['disable_enroll'] = in_array(
                    $student['enrollment_status'],
                    ['admission under review', 'payment pending', 'enrolled', 'withdraw under review', 'denied']
                );
            }

            // Fetch available school years
            $schoolYears = $this->db->table('enrollments')
                ->select('school_year')
                ->distinct()
                ->orderBy('school_year', 'DESC')
                ->get()
                ->getResultArray();

            if (empty($schoolYears)) {
                $schoolYears[] = ['school_year' => $this->schoolYear];
            }

            // Render view
            return view('/parent/enroll_classes', [
                'students' => $students,
                'schoolYears' => $schoolYears,
                'selectedYear' => $selectedYear,
                'isEditable' => $isEditable,
                'withdrawalDeadline' => $this->withdrawalDeadline,
                'lastDayOfRegistration' => $this->lastDayOfRegistration,
                'schoolStartDate' => $this->schoolStartDate
            ]);
        } catch (Exception $e) {
            log_message('error', 'An error occurred in enrollClasses: ' . $e->getMessage());
            return view('errors/html/error_500');
        }
    }

    public function noKids()
    {
        return view('/parent/no_kids_registred');
    }

    public function enrollClassesHandler()
    {
        // Call enrollClasses() function at the start of this method
        $this->enrollClasses();
        $refundService = new FeeCalculationService();

        // Retrieve enrollment and withdrawal data from the POST request
        $enroll = $this->request->getPost('enroll'); // Selected students for enrollment
        $withdraw = $this->request->getPost('withdraw'); // Selected students for withdrawal
        $parentId = session()->get('user_id'); // Parent ID from session

        if ($this->lastDayOfRegistration && local_date(utc_now(), 'Y-m-d') > date('Y-m-d', strtotime($this->lastDayOfRegistration))) {
            if (!empty($enroll)) {
                return redirect()->back()->with('error', 'Enrollment deadline has passed. New enrollments are not allowed.');
            }
        }

        // Ensure there are students selected for either enrollment or withdrawal
        if (empty($enroll) && empty($withdraw)) {
            return redirect()->back()->with('error', 'No students selected for enrollment or withdrawal.');
        }

        // Handle enrollments
        $studentData = [];

        if (!empty($enroll)) {
            foreach ($enroll as $studentId) {
                // Get student full name (supports both string return or array with firstname/lastname)
                $studentInfo = $this->studentModel->getFullNameById($studentId);

                if (empty($studentName)) {
                    $studentName = "Student ID $studentId";
                    log_message('warning', "Name for student ID $studentId not found in students table.");
                }

                // Save student info into $studentData
                $studentData[$studentId] =  $studentInfo;   // raw return from getFullName()

                // Check if the student already has an enrollment record for the current school year and semester
                $existingEnrollment = $this->enrollmentModel
                    ->where('student_id', $studentId)
                    ->where('school_year', $this->schoolYear)
                    ->where('semester', $this->semester)
                    ->get()
                    ->getRowArray();

                $studentSchoolId = $this->studentModel->getStudentSchoolIdByStudentId($studentId);
                if (!$studentSchoolId) {
                    return redirect()->back()->with('error', "{$studentData[$studentId]['firstname']} {$studentData[$studentId]['lastname']}: Student school ID not found.");
                }
                if ($existingEnrollment) {
                    if ($existingEnrollment['is_withdrawn'] == 1) {
                        // Reactivate the enrollment if the student was previously withdrawn
                        $this->enrollmentModel->where('id', $existingEnrollment['id'])->update([
                            'is_withdrawn' => 0,
                            'withdrawal_date' => null,
                            'enrollment_status' => 'payment pending',
                            'updated_at' => utc_now()
                        ]);
                        log_message('info', "{$studentData[$studentId]['firstname']} {$studentData[$studentId]['lastname']} (ID $studentId) has been re-enrolled in enrollment ID {$existingEnrollment['id']}.");
                        // Apply promotion-based class placement for the upcoming year
                        $this->applyPromotionAssignment((int)$studentId, (string)$this->schoolYear);
                    } else {
                        log_message('info', "{$studentData[$studentId]['firstname']} {$studentData[$studentId]['lastname']} (ID $studentId) is already actively enrolled.");
                    }
                } else {
                    // If no enrollment record exists, insert a new enrollment record
                    $result = $this->enrollmentModel->insert([
                        'student_id'        => $studentId,
                        'parent_id'         => $parentId,
                        'school_year'       => $this->schoolYear,
                        'semester'          => $this->semester,
                        'enrollment_date'   => local_date(utc_now(), 'Y-m-d'),
                        'is_withdrawn'      => 0,
                        'enrollment_status' => 'admission under review',
                        'admission_status'  => 'pending',
                        'created_at'        => utc_now()
                    ]);

                    if (!$result) {
                        dd($this->enrollmentModel->errors());
                    } else {
                        log_message('info', "{$studentData[$studentId]['firstname']} {$studentData[$studentId]['lastname']} (ID $studentId) has been newly enrolled.");
                        // Apply promotion-based class placement for the upcoming year
                        $this->applyPromotionAssignment((int)$studentId, (string)$this->schoolYear);
                    }
                }
            }
        }

        // $studentData now holds info for all students processed

        // Handle withdrawals
        if (!empty($withdraw)) {
            foreach ($withdraw as $studentId) {
                $enrollment = $this->enrollmentModel
                    ->where('student_id', $studentId)
                    ->where('school_year', $this->schoolYear)
                    ->where('semester', $this->semester)
                    ->where('is_withdrawn', 0) // Only withdraw active enrollments
                    ->get()
                    ->getRowArray();

                if ($enrollment !== null) {
                    // Update enrollment as withdrawn
                    $this->enrollmentModel->where('id', $enrollment['id'])->update([
                        'withdrawal_date' => local_date(utc_now(), 'Y-m-d'),
                        'enrollment_status' => 'withdraw under review', // Withdrawal needs review
                        'updated_at' => utc_now()
                    ]);
                    log_message('info', "Student ID $studentId has been withdrawn from enrollment ID {$enrollment['id']}.");

                    // === Trigger refund process ===
                    // Find the related invoice (you may need to adjust this based on your DB structure)
                    $invoice = $this->db->table('invoices')
                        ->where('parent_id', $parentId)
                        ->where('school_year', $this->schoolYear)
                        ->orderBy('created_at', 'DESC')
                        ->get()
                        ->getRowArray();

                    if ($invoice !== null) {
                        $invoiceId = $invoice['id'];

                        $refundTable = $this->db->table('refunds');

                        $existingRefund = $refundTable
                            ->where('parent_id', $parentId)
                            ->where('invoice_id', $invoiceId)
                            ->where('school_year', $this->schoolYear)
                            ->get()
                            ->getRow();

                        if ($existingRefund) {
                            // Only update the fields that should change
                            $updateData = [
                                'reason'    => 'Withdrawal under review for student ID ' . $studentId,
                                'note'      => null,
                                'updated_by' => session()->get('user_id'), // optionally track updates
                                // Add other fields if *and only if* they must be changed
                            ];

                            $refundTable
                                ->where('id', $existingRefund->id)
                                ->update($updateData);

                            log_message('info', "Refund record updated for invoice ID {$invoiceId}, student ID {$studentId}.");
                        } else {
                            // Only set these once, for new entries
                            $insertData = [
                                'parent_id'     => $parentId,
                                'invoice_id'    => $invoiceId,
                                'requested_at'  => utc_now(),
                                'school_year'   => $this->schoolYear,
                                'status'        => 'Pending review',
                                'reason'        => 'Withdrawal under review for student ID ' . $studentId,
                                'request'       => 'new',
                                'semester'      => $this->semester,
                                'refund_paid_amount'   => 0.0,
                            ];

                            $refundTable->insert($insertData);

                            log_message('info', "Refund record created for invoice ID {$invoiceId}, student ID {$studentId}.");
                        }
                    } else {
                        log_message('error', "No invoice found for parent ID {$parentId}, student ID {$studentId}.");
                    }
                } else {
                    log_message('error', "No active enrollment found for student ID $studentId.");
                }
            }
        }

        $parentData = $this->userModel->getUserInfoById($parentId);
        $parentData['user_id'] = $parentId;
        // Redirect to the success page after processing enrollment and withdrawal
        if (!empty($withdraw)) {
            // Redirect to withdrawal success page if there are withdrawals //parent/enroll_classes
            return redirect()->to('/parent/enroll_classes');
        } else {
            // Redirect to enrollment success page if there are enrollments
            Events::trigger('admissionUnderReview', $parentData, $studentData);  //send notification for enrolled student
            return redirect()->to('/parent/enroll_classes');
        }
    }

    /**
     * If a promotion_queue record exists for this student and the given school year,
     * create/update student_class row accordingly (base section until distribution),
     * and mark the queue row as applied.
     */
    private function applyPromotionAssignment(int $studentId, string $year): void
    {
        try {
            $promo = new \App\Models\PromotionQueueModel();
            $classSectionModel = new \App\Models\ClassSectionModel();
            $studentClass = new \App\Models\StudentClassModel();

            $row = $promo->where('student_id', $studentId)
                ->where('school_year_to', $year)
                ->first();

            if (!$row) return; // nothing to do

            $targetSectionId = (int)($row['to_class_section_id'] ?? 0);
            if ($targetSectionId <= 0) {
                // Resolve base section for target class (e.g., '3')
                $base = $classSectionModel->getBaseSectionByClassId((int)$row['to_class_id']);
                if (!$base) {
                    log_message('warning', 'applyPromotionAssignment: base section not found for class_id=' . (int)$row['to_class_id']);
                    return;
                }
                $targetSectionId = (int)($base['class_section_id'] ?? 0);
            }

            if ($targetSectionId <= 0) return;

            // Upsert into student_class for the target school year
            $exists = $studentClass->where('student_id', $studentId)
                ->where('school_year', $year)
                ->first();

            $payload = [
                'student_id'       => $studentId,
                'class_section_id' => $targetSectionId,
                'school_year'      => $year,
                'updated_by'       => (int)(session()->get('user_id') ?? 0) ?: null,
                'updated_at'       => utc_now(),
            ];

            if ($exists) {
                $studentClass->update((int)$exists['id'], $payload);
            } else {
                $payload['created_at'] = utc_now();
                $studentClass->insert($payload);
            }

            // Mark promotion as applied
            $promo->update((int)$row['id'], [
                'status'     => 'applied',
                'updated_at' => utc_now(),
                'updated_by' => (int)(session()->get('user_id') ?? 0) ?: null,
            ]);
        } catch (\Throwable $e) {
            log_message('error', 'applyPromotionAssignment failed: ' . $e->getMessage());
        }
    }

    public function enrollFailure()
    {
        echo view('/parent/enroll_failure');
    }

    public function payment()
    {
        // Get the logged-in user's ID
        $userId = session()->get('user_id');

        // Fetch invoices records where the user is either the first or second parent
        $invoices = $this->db->table('invoices')
            ->select('invoices.*, registeredKids') // Assuming 'registeredKids' is a field
            ->where('parent_id', $userId)
            //->orWhere('secondparent_user_id', $userId)
            ->get()
            ->getResultArray();

        // Pass the invoices data to the view
        return view('/parent/payment', [
            'invoices' => $invoices
        ]);
    }

    public function paymentHandler()
    {
        $parentId = session()->get('user_id');

        // Update all students for this parent to mark tuition as paid
        $this->db->table('students')
            ->where('parent_id', $parentId)
            ->update(['tuition_paid' => 1]);

        // Clear the total tuition fee from the session
        session()->remove('total_tuition_fee');

        // Set success message in session
        session()->setFlashdata('success', 'Tuition fees paid successfully');

        return redirect()->to('/parent/payment_success');
    }

    public function messageParent()
    {
        return view('/parent/parent_message');
    }

    public function successMessage()
    {
        // Load the success message view
        return view('/parent/success_message');
    }

    public function addSecondParent()
    {
        return view('/parent/add_second_parent');
    }

    public function createUserFromParentOrAuthorizedUser($userData, $relationToStudent)
    {
        $schoolIdService = new SchoolIdService();

        // Step 1: Generate a secure token for email verification
        $token = bin2hex(random_bytes(48));

        // Step 2: Determine user type based on relationship
        $userType = in_array(strtolower($relationToStudent), ['wife', 'husband']) ? 'Secondary' : 'Tertiary';

        // Step 3: Validate incoming user data
        $validation = \Config\Services::validation();
        $validation->setRules([
            'firstname' => [
                'label' => 'First Name',
                'rules' => 'required|min_length[2]|max_length[100]|regex_match[/^[A-Za-z\s\-]+$/]',
                'errors' => [
                    'regex_match' => 'First name may only contain letters, spaces, and dashes.'
                ]
            ],
            'lastname' => [
                'label' => 'Last Name',
                'rules' => 'required|min_length[2]|max_length[100]|regex_match[/^[A-Za-z\s\-]+$/]',
                'errors' => [
                    'regex_match' => 'Last name may only contain letters, spaces, and dashes.'
                ]
            ],
            'email' => [
                'label' => 'Email Address',
                'rules' => 'required|valid_email|max_length[150]|is_unique[users.email]',
                'errors' => [
                    'is_unique' => 'This email is already registered.'
                ]
            ],
            'cellphone' => [
                'label' => 'Cell Phone',
                'rules' => 'required|regex_match[/^\d{10}$/]',
                'errors' => [
                    'regex_match' => 'Phone number must be exactly 10 digits.'
                ]
            ],
            'gender' => 'required|in_list[Male,Female]',
            'city' => 'required|max_length[100]',
            'state' => 'required|max_length[100]',
            'zip' => 'required|regex_match[/^\d{5}$/]',
        ]);

        if (!$validation->run($userData)) {
            log_message('error', 'User creation failed due to invalid data: ' . json_encode($validation->getErrors()));
            return false;
        }

        // Step 4: Prepare sanitized user data
        $userEntry = [
            'firstname' => ucfirst(strtolower($userData['firstname'])),
            'lastname' => ucfirst(strtolower($userData['lastname'])),
            'gender' => $userData['gender'],
            'cellphone' => $userData['cellphone'],
            'email' => strtolower($userData['email']),
            'address_street' => $userData['address_street'] ?? '',
            'apt' => $userData['apt'] ?? null,
            'city' => ucfirst(strtolower($userData['city'])),
            'state' => strtoupper($userData['state']),
            'zip' => $userData['zip'],
            'accept_school_policy' => $userData['accept_school_policy'] ?? 0,
            'token' => $token,
            'is_verified' => 0,
            'status' => 'Inactive',
            'user_type' => $userType,
            'semester' => $this->semester,
            'school_year' => $this->schoolYear,
            'school_id' => $schoolIdService->generateUserSchoolId(),
        ];

        try {
            // Step 5: Insert user into database
            if (!$this->userModel->insert($userEntry)) {
                log_message('error', 'Failed to insert user: ' . print_r($this->userModel->errors(), true));
                return false;
            }

            $userId = $this->userModel->getInsertID();

            // Step 6: Send activation email
            $this->sendActivationEmail($userData['email'], $token);

            log_message('info', "User with ID $userId created successfully and activation email sent.");
            return $userId;
        } catch (Exception $e) {
            log_message('error', 'Exception during user creation: ' . $e->getMessage());
            return false;
        }
    }

    private function sendActivationEmail($email, $token)
    {
        $emailController = new \App\Controllers\View\EmailController();

        $subject = 'Activate Your Account';
        $activationLink = site_url('/user/confirm/' . $token);
        $message = "Please click the following link to confirm your email and set your password: $activationLink";

        if ($emailController->sendEmail($email, $subject, $message)) {
            log_message('info', 'Activation email sent successfully to ' . $email);
        } else {
            log_message('error', 'Failed to send activation email to ' . $email);
        }
    }

    /**
     * Updates or inserts an authorized user record based on user ID and email.
     *
     * @param int   $userId  The ID of the parent/user who is authorizing access.
     * @param array $data    Contains 'email', 'name', and any other required fields.
     */
    protected function updateAuthorizedUsers($userId, $data)
    {
        $validation = \Config\Services::validation();

        // Step 1: Define validation rules for authorized user fields
        $validation->setRules([
            'email' => [
                'label' => 'Email',
                'rules' => 'required|valid_email|max_length[150]',
                'errors' => [
                    'required' => 'Email is required.',
                    'valid_email' => 'Please provide a valid email address.',
                    'max_length' => 'Email must be less than 150 characters.'
                ]
            ],
            'name' => [
                'label' => 'Name',
                'rules' => 'required|min_length[3]|max_length[100]|regex_match[/^[A-Za-z\s\-]+$/]',
                'errors' => [
                    'required' => 'Name is required.',
                    'regex_match' => 'Name can only contain letters, spaces, and dashes.',
                    'min_length' => 'Name must be at least 3 characters long.',
                    'max_length' => 'Name must be less than 100 characters.'
                ]
            ]
        ]);

        // Step 2: Run validation
        if (!$validation->run($data)) {
            log_message('error', 'Invalid authorized user data: ' . json_encode($validation->getErrors()));
            return; // Skip update/insert if validation fails
        }

        // Step 3: Check if an authorized user with same email/user ID exists
        $existingAuthorizedUser = $this->authorizedUsersModel
            ->where('user_id', $userId)
            ->where('email', $data['email'])
            ->first();

        if ($existingAuthorizedUser) {
            // Step 4: Update existing authorized user
            $this->authorizedUsersModel->update($existingAuthorizedUser['id'], $data);
        } else {
            // Step 5: Insert new authorized user with pending status
            $data['user_id'] = $userId;
            $data['status'] = 'Pending'; // default status for new records
            $this->authorizedUsersModel->insert($data);
        }
    }

    public function profile($id)
    {
        // Fetch the user's data based on the given ID
        $user = $this->userModel->find($id);

        // Check if user exists
        if (!$user) {
            return redirect()->to('/')->with('error', 'User not found');
        }

        // Load the profile view with the user's data
        return view('/profile', ['user' => $user]);
    }

    public function updateProfile($id)
    {
        $user = $this->userModel->find($id);

        // Step 1: Check if user exists
        if (!$user) {
            return redirect()->to('/')->with('error', 'User not found');
        }

        // Step 2: Define validation rules
        $validation = \Config\Services::validation();
        $validation->setRules([
            'firstname' => [
                'label' => 'First Name',
                'rules' => 'required|min_length[3]|max_length[100]|regex_match[/^[A-Za-z\s\-]+$/]',
                'errors' => [
                    'regex_match' => 'First name must only contain letters, spaces, and dashes.'
                ]
            ],
            'lastname' => [
                'label' => 'Last Name',
                'rules' => 'required|min_length[3]|max_length[100]|regex_match[/^[A-Za-z\s\-]+$/]',
                'errors' => [
                    'regex_match' => 'Last name must only contain letters, spaces, and dashes.'
                ]
            ],
            'cellphone' => [
                'label' => 'Cell Phone',
                'rules' => 'required|regex_match[/^\d{10}$/]',
                'errors' => [
                    'regex_match' => 'Cell phone must be exactly 10 digits.'
                ]
            ],
            'address_street' => [
                'label' => 'Street Address',
                'rules' => 'required|min_length[5]|max_length[255]'
            ],
            'city' => [
                'label' => 'City',
                'rules' => 'required|min_length[2]|max_length[100]'
            ],
            'state' => [
                'label' => 'State',
                'rules' => 'required|min_length[2]|max_length[100]'
            ],
            'zip' => [
                'label' => 'ZIP Code',
                'rules' => 'required|regex_match[/^\d{5}$/]',
                'errors' => [
                    'regex_match' => 'ZIP code must be exactly 5 digits.'
                ]
            ]
        ]);

        // Step 3: Validate input; reload view with error messages if validation fails
        if (!$this->validate($validation->getRules())) {
            return view('/profile', [
                'user' => $user,
                'validation' => $this->validator,
            ]);
        }

        // Step 4: Prepare cleaned and validated data for update
        $updatedData = [
            'firstname'      => ucfirst(strtolower($this->request->getPost('firstname'))),
            'lastname'       => ucfirst(strtolower($this->request->getPost('lastname'))),
            'cellphone'      => $this->request->getPost('cellphone'),
            'address_street' => $this->request->getPost('address_street'),
            'city'           => ucfirst(strtolower($this->request->getPost('city'))),
            'state'          => strtoupper($this->request->getPost('state')),
            'zip'            => $this->request->getPost('zip'),
        ];

        // Step 5: Update user profile in the database
        $this->userModel->update($id, $updatedData);

        // Step 6: Redirect with success message
        session()->setFlashdata('success', 'Profile updated successfully');
        return redirect()->to('/profile/' . $id);
    }

    public function isEmailUnique(string $email): bool
    {
        $tablesAndColumns = [
            'users'             => 'email',
            'emergency_contacts' => 'email',
        ];

        foreach ($tablesAndColumns as $table => $column) {
            // Skip duplicate table lookups with different columns
            $builder = $this->db->table($table);
            $builder->where($column, $email);
            $exists = $builder->countAllResults();

            if ($exists > 0) {
                return false; // Email already exists
            }
        }

        return true; // Email is unique
    }


    //form to save student and emergency contact data
    public function saveStudentRegistration()
    {
        log_message('debug', print_r($this->request->getPost(), true));

        $schoolIdService = new SchoolIdService();
        $parentId = session()->get('user_id');

        if (!$this->lastDayOfRegistration || !strtotime($this->lastDayOfRegistration)) {
            throw new \Exception('Invalid enrollment deadline date.');
        }

        if (strtolower($this->request->getMethod()) !== 'post') {
            return redirect()->back()->with('error', 'Invalid request method.');
        }

        try {
            // ✅ 1. Get existing data
            $data = $this->getRegistrationData($parentId);
            $existingKids = $data['existingKids'];
            $existingECs  = $data['emergencies'];
            $maxChilds    = $data['maxChilds'];
            $maxEmergency = $data['maxEmergency'];

            $existingKidsCount = count($existingKids);
            $existingECCount   = count($existingECs);

            $incomingFirstNames   = $this->request->getPost('studentFirstName') ?? [];
            $incomingLastNames    = $this->request->getPost('studentLastName') ?? [];
            $incomingDOBs         = $this->request->getPost('dob') ?? [];

            $newStudentCount = count(array_filter($incomingFirstNames));

            // ✅ 2. Duplicate student check against existing records
            foreach ($incomingFirstNames as $i => $firstName) {
                $lastName = trim($incomingLastNames[$i] ?? '');
                $dob      = trim($incomingDOBs[$i] ?? '');

                if (empty($firstName) || empty($lastName) || empty($dob)) continue;

                foreach ($existingKids as $kid) {
                    if (
                        strtolower($kid['firstname']) === strtolower($firstName) &&
                        strtolower($kid['lastname']) === strtolower($lastName) &&
                        $kid['dob'] === $dob
                    ) {
                        return redirect()->back()->withInput()->with('error', "Duplicate student detected: {$firstName} {$lastName} with DOB {$dob} already exists.");
                    }
                }
            }

            // ✅ 3. Duplicate student check within incoming data
            $seenStudents = [];
            foreach ($incomingFirstNames as $i => $firstName) {
                $lastName = trim($incomingLastNames[$i] ?? '');
                $dob      = trim($incomingDOBs[$i] ?? '');

                if (empty($firstName) || empty($lastName) || empty($dob)) continue;

                $key = strtolower($firstName . '|' . $lastName . '|' . $dob);
                if (isset($seenStudents[$key])) {
                    return redirect()->back()->withInput()->with('error', "Duplicate student entry in the form: {$firstName} {$lastName} with DOB {$dob}.");
                }
                $seenStudents[$key] = true;
            }

            // ✅ 4. Emergency contact validation
            $incomingECFirst  = $this->request->getPost('emergency_firstname') ?? [];
            $incomingECLast   = $this->request->getPost('emergency_lastname') ?? [];
            $incomingECPhones = $this->request->getPost('emergency_phone') ?? [];
            $incomingECEmails = $this->request->getPost('emergency_email') ?? [];

            $newECCount = count(array_filter($incomingECFirst));

            // Against existing
            foreach ($incomingECFirst as $i => $first) {
                $last  = trim($incomingECLast[$i] ?? '');
                $phone = preg_replace('/\D/', '', $incomingECPhones[$i] ?? '');
                $email = strtolower(trim($incomingECEmails[$i] ?? ''));

                if (empty($first) || empty($last)) continue;

                foreach ($existingECs as $contact) {
                    $existingPhone = preg_replace('/\D/', '', $contact['cellphone']);
                    $existingEmail = strtolower($contact['email']);

                    if (
                        strtolower($contact['emergency_contact_name']) === strtolower(trim($first . ' ' . $last)) ||
                        ($phone && $phone === $existingPhone) ||
                        ($email && $email === $existingEmail)
                    ) {
                        return redirect()->back()->withInput()->with('error', "Duplicate emergency contact: {$first} {$last} already exists.");
                    }
                }
            }

            // Within incoming data
            $seenContacts = [];
            foreach ($incomingECFirst as $i => $first) {
                $last  = trim($incomingECLast[$i] ?? '');
                $phone = preg_replace('/\D/', '', $incomingECPhones[$i] ?? '');
                $email = strtolower(trim($incomingECEmails[$i] ?? ''));

                if (empty($first) || empty($last)) continue;

                $key = strtolower($first . '|' . $last . '|' . $phone . '|' . $email);
                if (isset($seenContacts[$key])) {
                    return redirect()->back()->withInput()->with('error', "Duplicate emergency contact entry in the form: {$first} {$last}.");
                }
                $seenContacts[$key] = true;
            }

            // ✅ 5. Check limits
            if (($existingKidsCount + $newStudentCount) > $maxChilds) {
                return redirect()->back()->withInput()->with('error', "Student limit exceeded. You have $existingKidsCount and tried to add $newStudentCount (limit: $maxChilds).");
            }

            if (($existingECCount + $newECCount) > $maxEmergency) {
                return redirect()->back()->withInput()->with('error', "Emergency contact limit exceeded. You have $existingECCount and tried to add $newECCount (limit: $maxEmergency).");
            }

            // ✅ 6. Start transaction and save
            $this->db->transStart();

            $studentAdded = false;

            // Gather all POST data for last year flags
            $rawPost = $this->request->getPost();

            // Loop through students
            foreach ($incomingFirstNames as $idx => $firstName) {
                if (!empty($firstName)) {
                    // ✅ 7. Extract is_new flag (convert to boolean)
                    $lastYearKey = 'last_year_' . $idx;
                    $lastYearVal = strtolower(trim($rawPost[$lastYearKey] ?? ''));

                    $isNew = match ($lastYearVal) {
                        'yes' => false,  // was with us last year => not new
                        'no'  => true,   // was not with us => new student
                        default => null  // missing or invalid
                    };

                    if (!isset($isNew)) {
                        return redirect()->back()->withInput()->with('error', "Please select if student #" . ($idx + 1) . " was with us last year.");
                    }

                    // ✅ 8. Pass $isNew to the student save function
                    $result = $this->validateAndSaveOrUpdateStudent($idx, $parentId, $this->semester, $this->schoolYear, $schoolIdService, $isNew, null, null);

                    if ($result) {
                        $studentAdded = true;
                    }
                }
            }

            $hasEC = !empty($incomingECFirst[0]) || !empty(($this->request->getPost('emergency_lastname')[0] ?? ''));

            if ($hasEC) {
                $this->saveEmergencyContact($parentId, $this->semester, $this->schoolYear);
            }

            if (!$studentAdded && !$hasEC) {
                throw new \Exception('Please fill in at least a form before submitting.');
            }

            $this->db->transComplete();

            if ($this->db->transStatus() === false) {
                throw new \Exception('DB transaction failed.');
            }

            return redirect()->to(base_url('/parent/child_register'))->with('success', 'Registration successful!');
        } catch (\Throwable $e) {
            log_message('error', $e->getMessage());
            $this->db->transRollback();
            return redirect()->back()->withInput()->with('error', $e->getMessage());
        }
    }


    // Function to check if the parent has registered kids and redirect accordingly
    public function registerKidCheck()
    {
        $parentId = session()->get('user_id');

        if (!$parentId) {
            return redirect()->back()->with('error', 'Session expired. Please log in again.');
        }

        try {
            $data = $this->getRegistrationData($parentId);
        } catch (\RuntimeException $e) {
            return redirect()->back()->with('error', $e->getMessage());
        } catch (\Throwable $e) {
            log_message('error', "Failed to fetch registration data: " . $e->getMessage());
            return redirect()->back()->with('error', 'Failed to retrieve registration info.');
        }
        $data['lastDayOfRegistration'] = $this->lastDayOfRegistration;
        $data['registrationAgeDeadline'] = $this->dateAgeReference;
        return view('parent/register_student', $data);
    }

    private function getEnrollmentsByParent($parentId, $schoolYear)
    {
        return $this->enrollmentModel
            ->where('parent_id', $parentId)
            ->where('school_year', $schoolYear)
            ->orderBy('enrollment_date', 'DESC')
            ->findAll();
    }

    private function getRegistrationData(int $parentId): array
    {
        $enrollments     = $this->getEnrollmentsByParent($parentId, $this->schoolYear);

        $enrollmentMap = [];
        if (!empty($enrollments)) {
            foreach ($enrollments as $enroll) {
                $enrollmentMap[$enroll['student_id']] = $enroll;
            }
        }

        $user = $this->userModel->find($parentId);
        if (!$user || $user['user_type'] !== 'primary') {
            throw new \RuntimeException('Only primary parents are allowed to register children.');
        }

        $kids = $this->studentModel->where('parent_id', $parentId)->findAll();
        foreach ($kids as &$kid) {
            $kid['allergies'] = $this->allergyModel
                ->where('student_id', $kid['id'])
                ->findColumn('allergy') ?? [];

            $kid['medical_conditions'] = $this->medicalConditionModel
                ->where('student_id', $kid['id'])
                ->findColumn('condition_name') ?? [];

            $kid['enrollment'] = isset($enrollmentMap[$kid['id']]['id']) && !empty($enrollmentMap[$kid['id']]['id']) ? 1 : 0;
        }

        $emergencies = $this->emergencyContactModel->where('parent_id', $parentId)->findAll();

        return [
            'existingKids'   => $kids,
            'emergencies'    => $emergencies,
            'parent'         => $user,
            'maxChilds'      => $this->maxChilds,
            'maxEmergency'   => $this->maxEmergency,
            'enrollments'    => $enrollments,
        ];
    }

    private function validateAndSaveOrUpdateStudent($idx, $parentId, $semester, $schoolYear, $schoolIdService, $isNew = null, $studentId = null)
    {
        $firstName = $this->request->getPost('studentFirstName')[$idx] ?? null;
        $lastName  = $this->request->getPost('studentLastName')[$idx] ?? null;
        $dob       = $this->request->getPost('dob')[$idx] ?? null;
        $gender    = $this->request->getPost('gender')[$idx] ?? null;
        $grade     = $this->request->getPost('registration_grade')[$idx] ?? null;
        $conditions = $this->request->getPost('medical_conditions')[$idx] ?? [];
        $allergies  = $this->request->getPost('allergies')[$idx] ?? [];
        $photoRaw   = $this->request->getPost('photo_consent')[$idx] ?? '';

        if (!$firstName || !$lastName || !$dob || !$gender || !$grade) {
            return false;
        }

        // Normalize names: trim, collapse internal spaces, ucfirst each word
        $normalize = function (string $s): string {
            $s = trim($s);
            $s = preg_replace('/\s+/', ' ', $s);                 // collapse whitespace
            // Keep your existing formatName if you prefer; this is a safe default:
            return mb_convert_case($s, MB_CASE_TITLE, 'UTF-8');  // "ahmed ali" -> "Ahmed Ali"
        };

        $firstName = $normalize($firstName);
        $lastName  = $normalize($lastName);

        // Still do your stricter name validation if desired
        $this->validateNames($firstName);
        $this->validateNames($lastName);

        $dobObj = new \DateTime($dob);
        $objregistrationAgeDeadline = new \DateTime($this->ageDateRefernce);
        $age = $dobObj->diff($objregistrationAgeDeadline)->y;

        $validation = $this->validateDobAge($dob, $this->ageDateRefernce);
        if (!$validation['isValid']) {
            $displayDeadline = (new DateTime($this->ageDateRefernce))->format('m-d-Y');
            session()->setFlashdata(
                'error',
                "Student '{$firstName} {$lastName}' {$validation['message']}. Age at deadline would be: $displayDeadline."
            );
            return false;
        }

        $photoConsent = strtolower($photoRaw) === 'yes' ? 1 : 0;

        $studentData = [
            'firstname'            => $firstName,
            'lastname'             => $lastName,
            'age'                  => $age,
            'dob'                  => $dobObj->format('Y-m-d'),
            'gender'               => $gender,
            'registration_grade'   => $grade,
            'photo_consent'        => $photoConsent,
            'parent_id'            => (int) $parentId,
            'year_of_registration' => date('Y'),
            'school_year'          => $schoolYear,
            'semester'             => $semester,
        ];

        if (!is_null($isNew)) {
            $studentData['is_new'] = $isNew ? 1 : 0;
        }

        // ---------- DUPLICATE CHECK (case/space-insensitive) ----------
        // Using LOWER(TRIM(...)) bound safely; CI4 will bind the value.
        $fnKey = mb_strtolower(trim(preg_replace('/\s+/', ' ', $firstName)), 'UTF-8');
        $lnKey = mb_strtolower(trim(preg_replace('/\s+/', ' ', $lastName)), 'UTF-8');
        $dobStr = $dobObj->format('Y-m-d');

$existing = $this->studentModel
    ->where('school_year', $schoolYear)
    ->where('dob', $dobStr)
    ->where('firstname', $firstName)   // already normalized above
    ->where('lastname',  $lastName)    // already normalized above
    ->first();

        if (!$studentId && $existing) {
            session()->setFlashdata(
                'error',
                "Student '{$firstName} {$lastName}' with the same birthdate is already registered for $schoolYear."
            );
            return false;
        }


        // ---------- UPDATE OR INSERT ----------
        if ($studentId) {
            $this->studentModel->update($studentId, $studentData);
        } else {
            $studentData['registration_date'] = utc_now();
            $studentData['tuition_paid']      = 0;
            $studentData['school_id']         = $schoolIdService->generateStudentSchoolId();

            try {
                $studentId = $this->studentModel->insert($studentData, true);
            } catch (\CodeIgniter\Database\Exceptions\DatabaseException $e) {
                // If DB unique index (below) triggers 1062 duplicate-key, show a friendly message
                if (strpos($e->getMessage(), '1062') !== false) {
                    session()->setFlashdata('error', "Student '{$firstName} {$lastName}' with the same birthdate is already registered for $schoolYear.");
                    return false;
                }
                throw $e; // other DB errors bubble up
            }
        }

        // ---------- SAVE MEDICAL CONDITIONS ----------
        $this->medicalConditionModel->where('student_id', $studentId)->delete();
        foreach ((array) $conditions as $c) {
            $c = trim($c);
            if ($c !== '') {
                $this->medicalConditionModel->insert([
                    'student_id'     => $studentId,
                    'condition_name' => $c,
                ]);
            }
        }

        // ---------- SAVE ALLERGIES ----------
        $this->allergyModel->where('student_id', $studentId)->delete();
        foreach ((array) $allergies as $a) {
            $a = trim($a);
            if ($a !== '') {
                $this->allergyModel->insert([
                    'student_id' => $studentId,
                    'allergy'    => $a,
                ]);
            }
        }

        return true;
    }


    /**
     * Validates if a date of birth falls within required age range by a deadline
     * 
     * @param string $dob Date of birth (YYYY-MM-DD format)
     * @param string $registrationAgeDeadline Deadline date (YYYY-MM-DD format)
     * @param int $minAge Minimum required age (default: 5)
     * @param int $maxAge Maximum allowed age (default: 18)
     * @return array ['isValid' => bool, 'message' => string]
     */
    function validateDobAge(string $dob, string $registrationAgeDeadline, int $minAge = 5, int $maxAge = 18): array
    {
        $response = ['isValid' => false, 'message' => '', 'age' => null];

        // -- Use a stable timezone for all comparisons (UTC is safest)
        $tz = new DateTimeZone('UTC');

        // 1) Empty?
        $dob = trim($dob);
        if ($dob === '') {
            $response['message'] = 'Date of birth is required';
            return $response;
        }

        // 2) Strict-parse DOB as a date-only at 00:00:00 (use leading "!" to zero unspecified fields)
        $birthDate = DateTimeImmutable::createFromFormat('!Y-m-d', $dob, $tz);
        $errs = DateTimeImmutable::getLastErrors();
        if ($birthDate === false || ($errs['warning_count'] ?? 0) > 0 || ($errs['error_count'] ?? 0) > 0) {
            $response['message'] = 'Invalid date format (Use YYYY-MM-DD)';
            return $response;
        }

        // 3) Parse deadline; if it's date-only, we set it to end-of-day to be inclusive
        try {
            $deadline = new DateTimeImmutable($registrationAgeDeadline, $tz);
        } catch (Throwable $e) {
            $deadline = new DateTimeImmutable('now', $tz);
        }
        // Inclusive of the deadline date
        $deadline = $deadline->setTime(23, 59, 59);

        // 4) Age at deadline (now that times are normalized)
        $ageAtDeadline = $birthDate->diff($deadline)->y;
        $response['age'] = $ageAtDeadline;

        // 5) Allowed birthdate window (inclusive)
        //    - Earliest birthdate = deadline - maxAge years  (exactly maxAge on deadline is OK)
        //    - Latest   birthdate = deadline - minAge years  (exactly minAge on deadline is OK)
        $minBirthDate = $deadline->modify("-{$maxAge} years")->setTime(0, 0, 0);   // earliest allowed
        $maxBirthDate = $deadline->modify("-{$minAge} years")->setTime(23, 59, 59); // latest allowed

        // 6) Validate
        $isValid = ($birthDate >= $minBirthDate) && ($birthDate <= $maxBirthDate);
        $response['isValid'] = $isValid;

        if (!$isValid) {
            $response['message'] = sprintf(
                'Must be %d-%d years old by %s. Current age would be: %d',
                $minAge,
                $maxAge,
                $deadline->format('m-d-Y'),
                $ageAtDeadline
            );
        }

        return $response;
    }


    private function validateNames($name)
    {
        if (!preg_match('/^[A-Za-z\s\-]{2,30}$/', $name)) {
            throw new InvalidArgumentException("Invalid name format: Only letters, spaces, or dashes (2–30 chars) allowed.");
        }
    }

    private function saveEmergencyContact($parentId, $semester, $schoolYear, $single = null, $id = null)
    {
        $phoneFormatter = new PhoneFormatterService(); // Load the formatter service

        // ✅ SINGLE CONTACT MODE
        if ($single !== null) {
            $firstName = $this->formatName($single['first_name'] ?? '');
            $lastName  = $this->formatName($single['last_name'] ?? '');
            $relation  = trim($single['relation'] ?? '');
            $phone     = $phoneFormatter->formatPhoneNumber($single['cellphone'] ?? '');
            $email     = strtolower(trim($single['email'] ?? ''));

            if ($firstName === '' && $lastName === '' && $phone === '(000)-000-0000' && $email === '' && $relation === '') {
                return;
            }

            $this->validateNames($firstName);
            $this->validateNames($lastName);

            if ($email && !filter_var($email, FILTER_VALIDATE_EMAIL)) {
                throw new \Exception('Invalid email format for emergency contact.');
            }

            $fullName = $firstName . ' ' . $lastName;

            $data = [
                'parent_id'              => $parentId,
                'emergency_contact_name' => $fullName,
                'cellphone'              => $phone,
                'email'                  => $email,
                'relation'               => $relation,
                'semester'               => $semester,
                'school_year'            => $schoolYear,
                'updated_at'             => utc_now(),
            ];

            if ($id !== null) {
                $duplicate = $this->emergencyContactModel
                    ->where('parent_id', $parentId)
                    ->where('emergency_contact_name', $fullName)
                    ->where('cellphone', $phone)
                    ->where('email', $email)
                    ->where('relation', $relation)
                    ->where('id !=', $id)
                    ->first();

                if ($duplicate) {
                    session()->setFlashdata('error', 'Another emergency contact with the same information already exists.');
                    return redirect()->back()->withInput();
                }

                $this->emergencyContactModel->update($id, $data);
            } else {
                $exists = $this->emergencyContactModel->where([
                    'parent_id'              => $parentId,
                    'emergency_contact_name' => $fullName,
                    'cellphone'              => $phone,
                    'email'                  => $email,
                    'relation'               => $relation,
                ])->first();

                if ($exists) {
                    session()->setFlashdata('error', 'This emergency contact is already registered.');
                    return redirect()->back()->withInput();
                }

                $this->emergencyContactModel->insert($data);
            }
        }

        // ✅ BULK MODE
        $firstNames = $this->request->getPost('emergency_firstname') ?? [];
        $lastNames  = $this->request->getPost('emergency_lastname') ?? [];
        $relations  = $this->request->getPost('emergency_relation') ?? [];
        $phones     = $this->request->getPost('emergency_phone') ?? [];
        $emails     = $this->request->getPost('emergency_email') ?? [];

        foreach ($firstNames as $idx => $first) {
            $firstName = $this->formatName($first ?? '');
            $lastName  = $this->formatName($lastNames[$idx] ?? '');
            $relation  = trim($relations[$idx]  ?? '');
            $phone     = $phoneFormatter->formatPhoneNumber($phones[$idx] ?? '');
            $email     = strtolower(trim($emails[$idx] ?? ''));

            if ($firstName === '' && $lastName === '' && $phone === '(000)-000-0000' && $email === '' && $relation === '') {
                continue;
            }

            if ($phone === '(000)-000-0000') {
                throw new \Exception('Invalid phone number.');
            }
            if ($email && !filter_var($email, FILTER_VALIDATE_EMAIL)) {
                throw new \Exception('Invalid email format for emergency contact.');
            }

            $fullName = $firstName . ' ' . $lastName;

            $exists = $this->emergencyContactModel->where([
                'parent_id'              => $parentId,
                'emergency_contact_name' => $fullName,
                'cellphone'              => $phone,
                'email'                  => $email,
                'relation'               => $relation,
            ])->first();

            if (!$exists) {
                $this->emergencyContactModel->insert([
                    'parent_id'              => $parentId,
                    'emergency_contact_name' => $fullName,
                    'cellphone'              => $phone,
                    'email'                  => $email,
                    'relation'               => $relation,
                    'semester'               => $semester,
                    'school_year'            => $schoolYear,
                ]);
            }
        }
    }

    public function editEmergencyContact($id = null)
    {
        if ($id === null) {
            $parentId = session()->get('user_id');
            $contacts = $this->emergencyContactModel->where('parent_id', $parentId)->findAll();
            return view('/parent/edit_emergency_contact', ['contacts' => $contacts]);
        }

        if (strtolower($this->request->getMethod()) === 'post') {
            $rules = [
                'emergency_first_name' => [
                    'label' => 'First Name',
                    'rules' => 'required|min_length[2]|max_length[50]|regex_match[/^[-A-Za-z ]+$/]',
                    'errors' => [
                        'regex_match' => 'First name may only contain letters, spaces, and dashes.'
                    ]
                ],
                'emergency_last_name' => [
                    'label' => 'Last Name',
                    'rules' => 'required|min_length[2]|max_length[50]|regex_match[/^[-A-Za-z ]+$/]',
                    'errors' => [
                        'regex_match' => 'Last name may only contain letters, spaces, and dashes.'
                    ]
                ],
                'cellphone' => [
                    'label' => 'Cell Phone',
                    'rules' => 'required|regex_match[/^\(?\d{3}\)?[-\s]?\d{3}[-\s]?\d{4}$/]',
                    'errors' => [
                        'regex_match' => 'Please enter a valid phone number (e.g., 123-456-7890 or (123) 456 7890).'
                    ]
                ],

                'relation' => [
                    'label' => 'Relation',
                    'rules' => 'required|min_length[3]|max_length[50]'
                ],
                'email' => [
                    'label' => 'Email',
                    'rules' => 'permit_empty|valid_email|max_length[150]'
                ]
            ];

            if (!$this->validate($rules)) {
                return redirect()->back()->withInput()->with('errors', $this->validator->getErrors());
            }

            $parentId = session()->get('user_id');
            $semester = session()->get('active_semester');
            $schoolYear = session()->get('active_school_year');

            $this->saveEmergencyContact($parentId, $semester, $schoolYear, [
                'first_name' => $this->request->getPost('emergency_first_name'),
                'last_name'  => $this->request->getPost('emergency_last_name'),
                'cellphone'  => $this->request->getPost('cellphone'),
                'email'      => $this->request->getPost('email'),
                'relation'   => $this->request->getPost('relation'),
            ], $id);

            return redirect()->to('/parent/child_register')
                ->with('message', 'Emergency contact updated successfully.');
        }
    }

    public function editStudent($id)
    {
        $schoolIdService  = new \App\Services\SchoolIdService();

        if (strtolower($this->request->getMethod()) !== 'post') {
            return redirect()->back()->with('error', 'Invalid request.');
        }

        $rules = [
            'firstname' => [
                'label' => 'First Name',
                'rules' => 'required|min_length[2]|max_length[255]|regex_match[/^[A-Za-z\s\-]+$/]',
                'errors' => ['regex_match' => 'Only letters, spaces, and dashes allowed.']
            ],
            'lastname' => [
                'label' => 'Last Name',
                'rules' => 'required|min_length[2]|max_length[255]|regex_match[/^[A-Za-z\s\-]+$/]',
                'errors' => ['regex_match' => 'Only letters, spaces, and dashes allowed.']
            ],
            'dob'                => 'required|valid_date',
            'gender'             => 'required|in_list[Male,Female]',
            'photo_consent'      => 'required|in_list[0,1]',
            'registration_grade' => 'permit_empty|max_length[50]',
        ];

        // ✅ Validate first, keep scalar post data for proper error messages
        if (!$this->validate($rules)) {
            return redirect()->back()->withInput()->with('errors', $this->validator->getErrors());
        }

        $parentId   = session()->get('user_id');

        // Prepare formData only AFTER validation
        $formData = [
            'studentFirstName'     => [$this->request->getPost('firstname')],
            'studentLastName'      => [$this->request->getPost('lastname')],
            'dob'                  => [$this->request->getPost('dob')],
            'gender'               => [$this->request->getPost('gender')],
            'registration_grade'   => [$this->request->getPost('registration_grade')],
            'photo_consent'        => [$this->request->getPost('photo_consent')],
            'allergies'            => [explode(',', $this->request->getPost('allergies') ?? '')],
            'medical_conditions'   => [explode(',', $this->request->getPost('medical_conditions') ?? '')],
        ];

        // Inject temporarily only for update logic, not before validation
        $this->request->setGlobal('post', $formData);

        // Save/update
        $this->validateAndSaveOrUpdateStudent(0, $parentId, $this->semester, $this->schoolYear, $schoolIdService, $id, null, null);

        return redirect()->to('/parent/child_register')->with('success', 'Student updated!');
    }

    public function deleteStudent($id)
    {
        if (strtolower($this->request->getMethod()) !== 'post') {
            return redirect()->back()->with('error', 'Invalid request method.');
        }

        $parentId = session()->get('user_id');

        // Confirm student exists and belongs to the parent
        $student = $this->studentModel
            ->where('id', $id)
            ->where('parent_id', $parentId)
            ->first();

        if (!$student) {
            return redirect()->back()->with('error', 'Student not found or unauthorized.');
        }

        // Perform deletion
        if (!$this->studentModel->delete($id)) {
            return redirect()->back()->with('error', 'Failed to delete student.');
        }

        // ✅ Check if parent has any students left
        $remainingStudents = $this->studentModel
            ->where('parent_id', $parentId)
            ->countAllResults();

        if ($remainingStudents === 0) {

            // Delete all emergency contacts linked to this parent
            $this->emergencyContactModel->where('parent_id', $parentId)->delete();
        }

        return redirect()->to('/parent/child_register')->with('success', 'Student deleted successfully.');
    }


    private function formatName(string $name): string
    {
        $name = trim($name);
        $name = strtolower($name);
        $name = ucwords($name, ' ');
        $name = implode('-', array_map('ucfirst', explode('-', $name)));

        return $name;
    }


    public function addStudentForm()
    {
        $session = session();
        $count = $session->get('registeredStudentsCount') ?? 0;

        return view('partials/student_form', [
            'registeredStudentsCount' => $count
        ]);
    }

    private function calculateAge($dob)
    {
        try {
            $parts = explode('-', $this->schoolYear);
            $endYear = isset($parts[1]) ? trim($parts[1]) : date('Y');

            $registrationAgeDeadline = "$endYear-12-31";

            // Convert both dates into DateTime objects
            $deadlineObj = \DateTime::createFromFormat('Y-m-d', $registrationAgeDeadline);
            $dobObj = \DateTime::createFromFormat('Y-m-d', $dob);

            if (!$deadlineObj || !$dobObj) {
                throw new \Exception('Invalid date format for DOB or Enrollment_deadline.');
            }

            // For display or logging purposes (if needed)
            $deadlineForDisplay = $deadlineObj->format('Y-m-d');
            $dobForDisplay = $dobObj->format('Y-m-d');

            // Compare dates
            if ($dobObj > $deadlineObj) {
                log_message('debug', "DOB ($dobForDisplay) is after deadline ($deadlineForDisplay)");
                return -1;  // Invalid age case
            }

            // Calculate age
            $ageInterval = $dobObj->diff($deadlineObj);
            return $ageInterval->y;
        } catch (\Exception $e) {
            log_message('error', 'Invalid DOB or deadline in calculateAge(): ' . $e->getMessage());
            return -1;
        }
    }

    public function parentEventPage()
    {
        $schoolYear = session()->get('school_year');
        $semester = session()->get('semester');
        $parentId = session()->get('user_id');

        // Get active events
        $activeEvents = $this->eventModel->getActiveEvents($schoolYear, $semester);
        $activeEventCount = is_array($activeEvents) ? count($activeEvents) : 0;

        // Get charges (participation info)
        $chargesList = $this->chargesModel->getChargesWithEventInfo($parentId, $schoolYear);

        // Build a map: "studentId:eventId" => [ 'participation' => ..., 'date' => ... ]
        $charges = [];
        foreach ($chargesList as $charge) {
            $key = $charge['student_id'] . ':' . $charge['event_id'];
            $charges[$key] = [
                'participation' => $charge['participation'],
                'date' => $charge['updated_at'] ?? $charge['created_at'] // Use updated_at if available
            ];
        }

        // Get enrolled students
        $students = $this->enrollmentModel->getEnrolledStudents($parentId, $schoolYear);

        return view('parent/event_participation', [
            'activeEvents' => $activeEvents,
            'charges' => $charges,
            'yourStudents' => $students,
            'activeEventCount' => $activeEventCount,
        ]);
    }

    public function updateParticipation()
    {
        $participations = $this->request->getPost('participation'); // ['student_id:event_id' => 'yes'|'no']
        $parentId = session()->get('user_id');

        foreach ($participations as $key => $value) {
            [$studentId, $eventId] = explode(':', $key);

            $existing = $this->chargesModel->where([
                'parent_id' => $parentId,
                'student_id' => $studentId,
                'event_id' => $eventId,
            ])->first();

            if ($value === 'no') {
                if ($existing) {
                    $this->chargesModel->delete($existing['id']);
                }
                continue; // skip to next entry
            }

            // value is 'yes'
            if ($existing) {
                $this->chargesModel->update($existing['id'], ['participation' => $value]);
            } else {
                $event = $this->eventModel->getEvent($eventId, $this->schoolYear);

                $this->chargesModel->insert([
                    'parent_id'     => $parentId,
                    'student_id'    => $studentId,
                    'event_id'      => $eventId,
                    'participation' => $value,
                    'charged'       => $event['amount'],
                    'school_year'   => $this->schoolYear,
                    'semester'      => $this->semester,
                    'updated_by'    => $parentId
                ]);
            }
        }
        //recalculate the invoice
        $this->eventController->generateInvoice($parentId);

        return redirect()->back()->with('success', 'Participation updated');
    }
}