From d76c871cb720e2dcd9850f35c2f724897fee2b18 Mon Sep 17 00:00:00 2001
From: root <melabidi@alrahmaisgl.org>
Date: Mon, 9 Mar 2026 02:52:13 -0400
Subject: [PATCH] add controllers, servoices

---
 app/Config/Services.php                       |    2 +-
 app/Http/Controllers/Api/Api.zip              |  Bin 240011 -> 0 bytes
 .../AttendanceTrackingController.php          |    2 +-
 .../Api/Auth/RegisterController.php           |   64 +
 .../Api/ClassPrep/ClassPrepController.php     |   53 +
 .../ClassPreparationController.php            |   60 +
 .../Communication/CommunicationController.php |  178 ++
 .../CompetitionScoresController.php           |  212 ++
 .../Api/Discounts/DiscountController.php      |  107 +
 .../Api/Email/BroadcastEmailController.php    |  184 ++
 .../Api/Expenses/ExpenseController.php        |  180 ++
 .../ExtraCharges/ExtraChargesController.php   |  143 ++
 .../Api/Finance/FinancialController.php       |  218 ++
 .../Api/Finance/InvoiceController.php         |  125 +
 .../Api/Finance/PaymentController.php         |   58 +
 .../Finance/PaymentEventChargesController.php |   46 +
 .../Api/Finance/PaymentManualController.php   |   81 +
 .../Finance/PaymentNotificationController.php |   41 +
 .../Finance/PaymentTransactionController.php  |   51 +
 .../Api/Finance/PaypalPaymentController.php   |   52 +
 .../Finance/PaypalTransactionsController.php  |   71 +
 .../Api/Finance/ReimbursementController.php   |  391 +++
 .../Api/Grading/GradingController.php         |  281 +++
 .../Grading/HomeworkTrackingController.php    |   45 +
 .../Api/Incidents/IncidentController.php      |  151 ++
 .../Api/Reports/FilesController.php           |  105 +
 .../Api/Scores/FinalController.php            |   67 +
 .../Api/Scores/HomeworkController.php         |   85 +
 .../Api/Scores/MidtermController.php          |   67 +
 .../Api/Scores/ParticipationController.php    |   70 +
 .../Api/Scores/ProjectController.php          |   86 +
 .../Controllers/Api/Scores/QuizController.php |   85 +
 .../Api/Scores/ScoreCommentController.php     |   88 +
 .../Api/Scores/ScoreController.php            |   66 +
 .../Api/Scores/ScorePredictorController.php   |   35 +
 .../Api/System/SemesterRangeController.php    |   80 +
 app/Http/Controllers/Api/UserController.php   |  102 +
 app/Http/Controllers/old/ApiClient.php        |  107 +
 .../old/BroadcastEmailController.php          |  256 --
 .../Controllers/old/ClassPrepController.php   |  307 ---
 .../old/ClassPreparationController.php        |  616 -----
 .../old/CommunicationController.php           |  172 --
 .../old/CompetitionScoresController.php       |  441 ----
 .../Controllers/old/DiscountController.php    |  906 -------
 app/Http/Controllers/old/EmailService.php     |   96 +
 .../Controllers/old/ExpenseController.php     |  348 ---
 .../old/ExtraChargesController.php            |  588 -----
 .../Controllers/old/FeeCalculationService.php |  183 ++
 app/Http/Controllers/old/FilesController.php  |  304 ---
 app/Http/Controllers/old/FinalController.php  |  159 --
 .../Controllers/old/FinancialController.php   | 1349 ----------
 app/Http/Controllers/old/FlagController.php   |  568 -----
 .../Controllers/old/GradingController.php     | 2237 -----------------
 .../Controllers/old/HomeworkController.php    |  656 -----
 .../old/HomeworkTrackingController.php        |  289 ---
 .../Controllers/old/InvoiceController.php     | 1701 -------------
 .../Controllers/old/MidtermController.php     |  364 ---
 app/Http/Controllers/old/NavbarService.php    |   66 +
 .../Controllers/old/NotificationService.php   |   39 +
 .../old/ParticipationController.php           |  355 ---
 .../Controllers/old/PaymentController.php     | 1775 -------------
 .../old/PaymentNotificationController.php     |  365 ---
 .../old/PaymentTransactionController.php      |   84 -
 .../old/PaypalTransactionsController.php      |   99 -
 .../Controllers/old/PhoneFormatterService.php |   31 +
 .../Controllers/old/ProjectController.php     |  540 ----
 app/Http/Controllers/old/QuizController.php   |  577 -----
 .../Controllers/old/RegisterController.php    |  360 ---
 app/Http/Controllers/old/RoleService.php      |   21 +
 app/Http/Controllers/old/SchoolIdService.php  |   74 +
 .../old/ScoreCommentController.php            |  550 ----
 app/Http/Controllers/old/ScoreController.php  | 1438 -----------
 app/Http/Controllers/old/ScorePredictor.php   |  260 --
 app/Http/Controllers/old/TimeService.php      |  222 ++
 app/Http/Controllers/old/UserController.php   |  874 -------
 app/Http/Requests/ApiFormRequest.php          |   23 +
 app/Http/Requests/Auth/RegisterRequest.php    |   44 +
 .../Discounts/ApplyDiscountVoucherRequest.php |   23 +
 .../Discounts/StoreDiscountVoucherRequest.php |   29 +
 .../UpdateDiscountVoucherRequest.php          |   29 +
 .../Requests/Expenses/StoreExpenseRequest.php |   28 +
 .../Expenses/UpdateExpenseRequest.php         |   27 +
 .../Expenses/UpdateExpenseStatusRequest.php   |   21 +
 .../ExtraCharges/StoreExtraChargeRequest.php  |   28 +
 .../ExtraCharges/UpdateExtraChargeRequest.php |   24 +
 app/Http/Requests/Files/FileNameRequest.php   |   27 +
 .../Finance/FinancialReportRequest.php        |   22 +
 .../Finance/FinancialSummaryRequest.php       |    7 +
 .../Finance/FinancialUnpaidParentsRequest.php |   20 +
 .../Grading/BelowSixtyEmailRequest.php        |   22 +
 .../Grading/BelowSixtyListRequest.php         |   21 +
 .../Grading/BelowSixtyMeetingRequest.php      |   22 +
 .../Grading/BelowSixtyMeetingSaveRequest.php  |   25 +
 .../Grading/BelowSixtySendRequest.php         |   24 +
 .../Grading/BelowSixtyStatusRequest.php       |   24 +
 .../Grading/GradingLockAllRequest.php         |   21 +
 .../Requests/Grading/GradingLockRequest.php   |   22 +
 .../Grading/GradingOverviewRequest.php        |   22 +
 .../Grading/GradingRefreshRequest.php         |   22 +
 .../Grading/GradingScoreShowRequest.php       |   21 +
 .../Grading/GradingScoreUpdateRequest.php     |   29 +
 .../Grading/HomeworkTrackingRequest.php       |   22 +
 .../Grading/PlacementBatchRequest.php         |   22 +
 .../Grading/PlacementBatchUpdateRequest.php   |   21 +
 .../Grading/PlacementLevelRequest.php         |   22 +
 .../Grading/PlacementLevelsRequest.php        |   22 +
 .../Requests/Grading/PlacementRequest.php     |   23 +
 .../Incidents/IncidentCancelRequest.php       |   21 +
 .../Incidents/IncidentCloseRequest.php        |   21 +
 .../Incidents/IncidentListRequest.php         |   21 +
 .../Incidents/IncidentStateRequest.php        |   20 +
 .../Incidents/IncidentStoreRequest.php        |   53 +
 .../Invoices/InvoiceGenerateRequest.php       |   21 +
 .../Invoices/InvoiceManagementRequest.php     |   20 +
 .../Invoices/InvoiceParentRequest.php         |   20 +
 .../Invoices/InvoiceStatusRequest.php         |   20 +
 .../Payments/PaymentByParentRequest.php       |   15 +
 .../Payments/PaymentCreateRequest.php         |   23 +
 .../PaymentEventChargesListRequest.php        |   21 +
 .../PaymentEventChargesStoreRequest.php       |   28 +
 .../Payments/PaymentManualEditRequest.php     |   23 +
 .../Payments/PaymentManualSearchRequest.php   |   21 +
 .../Payments/PaymentManualSuggestRequest.php  |   20 +
 .../Payments/PaymentManualUpdateRequest.php   |   27 +
 .../PaymentNotificationListRequest.php        |   22 +
 .../PaymentNotificationSendRequest.php        |   23 +
 .../PaymentTransactionCreateRequest.php       |   30 +
 .../PaymentTransactionStatusRequest.php       |   20 +
 .../Payments/PaymentUpdateBalanceRequest.php  |   15 +
 .../Payments/PaypalExecuteRequest.php         |   21 +
 .../PaypalTransactionsListRequest.php         |   21 +
 .../ReimbursementBatchAdminFileRequest.php    |   22 +
 .../ReimbursementBatchAssignmentRequest.php   |   24 +
 .../ReimbursementBatchCreateRequest.php       |   20 +
 .../ReimbursementBatchEmailRequest.php        |   26 +
 .../ReimbursementBatchLockRequest.php         |   20 +
 .../ReimbursementExportBatchRequest.php       |   20 +
 .../ReimbursementExportRequest.php            |   24 +
 .../ReimbursementIndexRequest.php             |   23 +
 .../ReimbursementMarkDonationRequest.php      |   20 +
 .../ReimbursementProcessRequest.php           |   28 +
 .../ReimbursementStoreRequest.php             |   28 +
 .../ReimbursementUnderProcessingRequest.php   |   18 +
 .../ReimbursementUpdateRequest.php            |   26 +
 .../Requests/Scores/ScoreAddColumnRequest.php |   22 +
 .../Requests/Scores/ScoreClassRequest.php     |   22 +
 .../Scores/ScoreCommentListRequest.php        |   22 +
 .../Scores/ScoreCommentSaveRequest.php        |   24 +
 .../Scores/ScoreCommentUpdateRequest.php      |   24 +
 app/Http/Requests/Scores/ScoreLockRequest.php |   23 +
 .../Requests/Scores/ScoreOverviewRequest.php  |   22 +
 .../Requests/Scores/ScorePredictorRequest.php |   21 +
 .../Requests/Scores/ScoreStudentRequest.php   |   20 +
 .../Requests/Scores/ScoreUpdateRequest.php    |   24 +
 .../Semesters/SchoolYearRangeRequest.php      |   20 +
 .../Semesters/SemesterNormalizeRequest.php    |   20 +
 .../Semesters/SemesterRangeRequest.php        |   21 +
 .../Semesters/SemesterResolveRequest.php      |   20 +
 .../Requests/Users/LoginActivityRequest.php   |   21 +
 app/Http/Requests/Users/UserListRequest.php   |   22 +
 app/Http/Requests/Users/UserStoreRequest.php  |   45 +
 app/Http/Requests/Users/UserUpdateRequest.php |   45 +
 app/Http/Resources/Auth/RegisterResource.php  |   22 +
 .../Discounts/DiscountParentResource.php      |   20 +
 .../Discounts/DiscountVoucherResource.php     |   26 +
 .../Resources/Expenses/ExpenseResource.php    |   34 +
 .../Expenses/ExpenseStaffResource.php         |   17 +
 .../ExtraChargeInvoiceOptionResource.php      |   20 +
 .../ExtraChargeParentOptionResource.php       |   16 +
 .../ExtraCharges/ExtraChargeResource.php      |   31 +
 app/Http/Resources/Files/FileMetaResource.php |   21 +
 .../Finance/FinancialDiscountResource.php     |   18 +
 .../FinancialExpenseSummaryResource.php       |   17 +
 .../Finance/FinancialInvoiceResource.php      |   28 +
 .../Finance/FinancialPaymentResource.php      |   17 +
 .../Finance/FinancialRefundResource.php       |   18 +
 .../FinancialReimbursementSummaryResource.php |   17 +
 .../Finance/FinancialReportResource.php       |   27 +
 .../Finance/FinancialSummaryResource.php      |   29 +
 .../Finance/FinancialUnpaidParentResource.php |   28 +
 .../Grading/BelowSixtyStudentResource.php     |   31 +
 .../Grading/GradingScoreResource.php          |   14 +
 .../HomeworkTrackingTeacherResource.php       |   20 +
 .../IncidentAnalysisStudentResource.php       |   24 +
 .../Incidents/IncidentGradeResource.php       |   17 +
 .../Resources/Incidents/IncidentResource.php  |   36 +
 .../IncidentStudentOptionResource.php         |   17 +
 .../InvoiceManagementParentResource.php       |   24 +
 .../Resources/Invoices/InvoiceResource.php    |   31 +
 .../PaymentNotificationLogResource.php        |   32 +
 .../Resources/Payments/PaymentResource.php    |   30 +
 .../Payments/PaymentTransactionResource.php   |   26 +
 .../Payments/PaypalTransactionResource.php    |   26 +
 .../ReimbursementBatchResource.php            |   23 +
 .../ReimbursementExpenseResource.php          |   36 +
 .../ReimbursementRecipientResource.php        |   24 +
 .../Reimbursements/ReimbursementResource.php  |   30 +
 ...imbursementUnderProcessingItemResource.php |   28 +
 .../Resources/Scores/ScoreCommentResource.php |   20 +
 .../Scores/ScorePredictorStudentResource.php  |   30 +
 .../Resources/Scores/ScoreStudentResource.php |   21 +
 .../Semesters/SemesterRangeResource.php       |   17 +
 .../Semesters/SemesterResolveResource.php     |   17 +
 .../Resources/Users/LoginActivityResource.php |   21 +
 .../Resources/Users/UserWithRolesResource.php |   20 +
 app/Interfaces/ScoreCalculatorInterface.php   |   11 +
 app/Models/CurrentIncident.php                |   40 +
 app/Models/{Flag.php => Incident.php}         |   14 +-
 app/Models/PaymentTransaction.php             |    4 +-
 .../AdministratorEnrollmentStatusService.php  |    6 +-
 .../Assignment/AssignmentContextService.php   |   28 +
 .../AssignmentDataLoaderService.php           |   46 +
 .../Assignment/AssignmentMetaService.php      |   38 +
 .../Assignment/AssignmentSectionService.php   |   27 +
 app/Services/Assignment/AssignmentService.php |  128 +-
 .../AttendanceTrackingService.php             |  175 +-
 app/Services/AttendanceTrackingService.php    |    9 -
 .../Auth/RegistrationCaptchaService.php       |   36 +
 .../Auth/RegistrationFormatterService.php     |   84 +
 app/Services/Auth/RegistrationService.php     |  159 ++
 .../BroadcastEmailComposerService.php         |   45 +
 .../BroadcastEmailDispatchService.php         |   81 +
 .../BroadcastEmailImageService.php            |   51 +
 .../BroadcastEmailRecipientService.php        |   36 +
 .../BroadcastEmailSenderOptionsService.php    |   33 +
 app/Services/ClassPrep/ClassRosterService.php |   42 +
 .../ClassPrep/StickerCountService.php         |  161 ++
 .../ClassPreparationAdjustmentService.php     |   32 +
 .../ClassPreparationCalculatorService.php     |  126 +
 .../ClassPreparationContextService.php        |   44 +
 .../ClassPreparationInventoryService.php      |   54 +
 .../ClassPreparationLogService.php            |   41 +
 .../ClassPreparationRosterService.php         |   40 +
 .../ClassPreparationService.php               |  121 +
 .../CommunicationFamilyService.php            |   59 +
 .../Communication/CommunicationLogService.php |   18 +
 .../CommunicationPreviewService.php           |   84 +
 .../CommunicationSendService.php              |   97 +
 .../CommunicationStudentService.php           |   53 +
 .../CommunicationTemplateService.php          |   57 +
 .../CompetitionScoresContextService.php       |   73 +
 .../CompetitionScoresQueryService.php         |  118 +
 .../CompetitionScoresRosterService.php        |   67 +
 .../CompetitionScoresSaveService.php          |   63 +
 .../Discounts/DiscountApplyService.php        |  294 +++
 .../Discounts/DiscountContextService.php      |   18 +
 .../Discounts/DiscountInvoiceService.php      |  394 +++
 .../Discounts/DiscountParentService.php       |   27 +
 .../Discounts/DiscountVoucherService.php      |   48 +
 app/Services/EmailService.php                 |   63 +
 .../Expenses/ExpenseContextService.php        |   18 +
 app/Services/Expenses/ExpenseQueryService.php |   41 +
 .../Expenses/ExpenseReceiptService.php        |   22 +
 .../Expenses/ExpenseRetailorService.php       |   34 +
 app/Services/Expenses/ExpenseStaffService.php |   46 +
 .../Expenses/ExpenseStatusService.php         |   19 +
 app/Services/Expenses/ExpenseWriteService.php |   41 +
 .../ExtraChargesChargeService.php             |  235 ++
 .../ExtraChargesContextService.php            |   18 +
 .../ExtraChargesInvoiceService.php            |   75 +
 .../ExtraCharges/ExtraChargesListService.php  |   23 +
 .../ExtraCharges/ExtraChargesMetaService.php  |   66 +
 .../ExtraChargesParentService.php             |   48 +
 .../Files/ExamDraftDownloadNameService.php    |   45 +
 app/Services/Files/FileServeService.php       |  112 +
 .../Finance/FinancialChartService.php         |   90 +
 .../FinancialDonationRecipientService.php     |   16 +
 .../Finance/FinancialPaymentService.php       |  119 +
 .../Finance/FinancialPdfReportService.php     |   62 +
 .../Finance/FinancialReportService.php        |  104 +
 .../Finance/FinancialSchoolYearService.php    |   28 +
 .../Finance/FinancialSummaryService.php       |  479 ++++
 .../Finance/FinancialUnpaidParentsService.php |  247 ++
 .../Grading/GradingBelowSixtyService.php      |  403 +++
 app/Services/Grading/GradingLockService.php   |  118 +
 .../Grading/GradingOverviewService.php        |  439 ++++
 .../Grading/GradingPlacementService.php       |  372 +++
 .../Grading/GradingRefreshService.php         |  111 +
 app/Services/Grading/GradingScoreService.php  |  189 ++
 .../HomeworkTrackingCalendarService.php       |   86 +
 .../Grading/HomeworkTrackingService.php       |  219 ++
 .../Incidents/CurrentIncidentService.php      |  233 ++
 .../Incidents/IncidentAnalysisService.php     |   92 +
 .../Incidents/IncidentHistoryService.php      |   61 +
 .../Incidents/IncidentLookupService.php       |   86 +
 .../Invoices/InvoiceConfigService.php         |   63 +
 .../Invoices/InvoiceGenerationService.php     |  264 ++
 app/Services/Invoices/InvoiceGradeService.php |   83 +
 .../Invoices/InvoiceManagementService.php     |  146 ++
 .../Invoices/InvoicePaymentService.php        |   82 +
 app/Services/Invoices/InvoicePdfService.php   |  445 ++++
 .../Invoices/InvoiceTuitionService.php        |   77 +
 .../Payments/PaymentBalanceService.php        |   13 +
 .../PaymentEnrollmentEventService.php         |  131 +
 .../Payments/PaymentEventChargesService.php   |   98 +
 .../Payments/PaymentLookupService.php         |   19 +
 .../Payments/PaymentManualService.php         |  649 +++++
 .../PaymentNotificationDispatchService.php    |   39 +
 .../Payments/PaymentNotificationService.php   |  396 +++
 app/Services/Payments/PaymentPlanService.php  |   39 +
 .../Payments/PaymentTransactionService.php    |   37 +
 .../Payments/PaypalPaymentService.php         |  123 +
 .../Payments/PaypalTransactionsService.php    |   42 +
 app/Services/PhoneFormatterService.php        |   22 +
 .../ReimbursementBatchAssignmentService.php   |  121 +
 .../ReimbursementBatchService.php             |  154 ++
 .../ReimbursementContextService.php           |   18 +
 .../ReimbursementCrudService.php              |   97 +
 .../ReimbursementDonationService.php          |   53 +
 .../ReimbursementEmailService.php             |  358 +++
 .../ReimbursementExportService.php            |  233 ++
 .../ReimbursementFileService.php              |  119 +
 .../ReimbursementLookupService.php            |   23 +
 .../ReimbursementQueryService.php             |  498 ++++
 .../ReimbursementRecipientService.php         |   93 +
 app/Services/SchoolIdService.php              |   69 +
 app/Services/Scores/AttendanceCalculator.php  |  146 ++
 app/Services/Scores/ExamScoreService.php      |  129 +
 app/Services/Scores/HomeworkCalculator.php    |   19 +
 app/Services/Scores/HomeworkScoreService.php  |  226 ++
 .../Scores/ParticipationScoreService.php      |  146 ++
 app/Services/Scores/ProjectCalculator.php     |   19 +
 app/Services/Scores/ProjectScoreService.php   |  223 ++
 app/Services/Scores/QuizCalculator.php        |   38 +
 app/Services/Scores/QuizScoreService.php      |  220 ++
 app/Services/Scores/ScoreCommentService.php   |  340 +++
 app/Services/Scores/ScoreDashboardService.php |  243 ++
 .../Scores/ScorePredictorDataService.php      |  105 +
 .../Scores/ScorePredictorRiskService.php      |  143 ++
 app/Services/Scores/ScorePredictorService.php |   41 +
 app/Services/Scores/ScoreTermService.php      |   70 +
 app/Services/Scores/SemesterScoreService.php  |  227 ++
 app/Services/SemesterRangeService.php         |  113 +
 .../Semesters/SemesterConfigService.php       |   41 +
 app/Services/Users/LoginActivityService.php   |   45 +
 app/Services/Users/UserEventService.php       |   31 +
 app/Services/Users/UserListService.php        |  161 ++
 app/Services/Users/UserManagementService.php  |  293 +++
 app/Support/SqliteCompat.php                  |    1 +
 composer.json                                 |    1 +
 composer.lock                                 |   65 +-
 config/sanctum.php                            |   84 +
 ...3_204035_create_current_incident_table.php |   51 +
 ...26_02_23_204036_create_incident_table.php} |   14 +-
 ...900056_create_communication_logs_table.php |   53 +
 ...12_create_personal_access_tokens_table.php |   33 +
 ...026_03_09_064908_create_sessions_table.php |   31 +
 routes/api.php                                |  283 ++-
 school_api                                    |  Bin 0 -> 622592 bytes
 storage/testing/files/cached.pdf              |    1 +
 storage/testing/files/sample.exe              |    1 +
 storage/testing/files/sample.pdf              |    1 +
 .../AttendanceTrackingControllerTest.php      |    4 +-
 .../Api/V1/Auth/RegisterControllerTest.php    |   71 +
 .../Api/V1/Auth/RegisterPayloadDebugTest.php  |   40 +
 .../BroadcastEmailControllerTest.php          |  134 +
 .../V1/ClassPrep/ClassPrepControllerTest.php  |  203 ++
 .../ClassPreparationControllerTest.php        |  134 +
 .../CommunicationControllerTest.php           |  186 ++
 .../CompetitionScoresControllerTest.php       |  178 ++
 .../V1/Discounts/DiscountControllerTest.php   |  198 ++
 .../Api/V1/Expenses/ExpenseControllerTest.php |  236 ++
 .../ExtraChargesControllerTest.php            |  261 ++
 .../V1/Finance/FinancialControllerTest.php    |  193 ++
 .../Api/V1/Finance/InvoiceControllerTest.php  |  166 ++
 .../Api/V1/Finance/PaymentControllerTest.php  |  153 ++
 .../PaymentEventChargesControllerTest.php     |  108 +
 .../Finance/PaymentManualControllerTest.php   |  132 +
 .../PaymentNotificationControllerTest.php     |  141 ++
 .../PaymentTransactionControllerTest.php      |  136 +
 .../PaypalTransactionsControllerTest.php      |   98 +
 .../Finance/ReimbursementControllerTest.php   |  185 ++
 .../Api/V1/Grading/GradingControllerTest.php  |  129 +
 .../HomeworkTrackingControllerTest.php        |   79 +
 .../V1/Incidents/IncidentControllerTest.php   |  158 ++
 .../Api/V1/Reports/FilesControllerTest.php    |  100 +
 .../Api/V1/Scores/FinalControllerTest.php     |   91 +
 .../Api/V1/Scores/HomeworkControllerTest.php  |   92 +
 .../Api/V1/Scores/MidtermControllerTest.php   |   91 +
 .../V1/Scores/ParticipationControllerTest.php |  104 +
 .../Api/V1/Scores/ProjectControllerTest.php   |   92 +
 .../Api/V1/Scores/QuizControllerTest.php      |   92 +
 .../V1/Scores/ScoreCommentControllerTest.php  |  111 +
 .../Api/V1/Scores/ScoreControllerTest.php     |  117 +
 .../Scores/ScorePredictorControllerTest.php   |  108 +
 .../V1/System/SemesterRangeControllerTest.php |   74 +
 .../Api/V1/Users/UserControllerTest.php       |  153 ++
 .../AdminNotificationSubjectServiceTest.php   |  144 +-
 .../AdminNotificationUserServiceTest.php      |   75 +
 .../AdminPrintRecipientServiceTest.php        |  138 +-
 .../AdministratorAbsenceServiceTest.php       |   36 +
 .../AdministratorDashboardServiceTest.php     |   27 +
 ...dministratorEnrollmentEventServiceTest.php |   23 +
 ...dministratorEnrollmentQueryServiceTest.php |  264 +-
 ...ministratorEnrollmentRefundServiceTest.php |   34 +
 .../AdministratorEnrollmentServiceTest.php    |   29 +
 ...ministratorEnrollmentStatusServiceTest.php |  227 +-
 .../AdministratorMetricsServiceTest.php       |   32 +
 .../AdministratorNotificationServiceTest.php  |   31 +
 .../AdministratorSharedServiceTest.php        |   21 +
 ...inistratorTeacherSubmissionServiceTest.php |   27 +
 .../AdministratorUserSearchServiceTest.php    |   22 +
 ...acherSubmissionNotificationServiceTest.php |  159 +-
 .../TeacherSubmissionReportServiceTest.php    |  327 +--
 .../TeacherSubmissionSupportServiceTest.php   |  125 +-
 .../AssignmentContextServiceTest.php          |   27 +
 .../AssignmentDataLoaderServiceTest.php       |  118 +
 .../Assignment/AssignmentMetaServiceTest.php  |   43 +
 .../AssignmentSectionServiceTest.php          |   31 +
 .../AttendancePolicyServiceTest.php           |   55 +-
 .../Attendance/AttendanceQueryServiceTest.php |  111 +
 .../AttendanceRecordSyncServiceTest.php       |  262 +-
 .../AttendanceSemesterRangeServiceTest.php    |   29 +
 .../Attendance/AttendanceServiceTest.php      |  128 +
 .../Attendance/StaffAttendanceServiceTest.php |   90 +
 .../StudentAttendanceWriterServiceTest.php    |  343 +--
 ...TeacherAttendanceSubmissionServiceTest.php |  556 +---
 .../AttendanceCaseQueryServiceTest.php        |   40 +-
 ...endanceCommunicationSupportServiceTest.php |   90 +-
 .../AttendanceEmailComposerServiceTest.php    |  129 +-
 .../AttendanceNotificationLogServiceTest.php  |   59 +-
 ...endanceNotificationWorkflowServiceTest.php |  132 +-
 .../AttendanceParentLookupServiceTest.php     |  114 +-
 .../AttendancePendingViolationServiceTest.php |   58 +-
 .../AttendanceTrackingServiceTest.php         |  133 +-
 ...nceViolationStudentResolverServiceTest.php |   87 +-
 .../ViolationRuleEngineServiceTest.php        |  108 +-
 .../Auth/RegistrationCaptchaServiceTest.php   |   33 +
 .../Auth/RegistrationFormatterServiceTest.php |   70 +
 .../Services/Auth/RegistrationServiceTest.php |  150 ++
 .../BroadcastEmailComposerServiceTest.php     |   30 +
 .../BroadcastEmailRecipientServiceTest.php    |   93 +
 ...BroadcastEmailSenderOptionsServiceTest.php |   23 +
 .../ClassPrep/ClassRosterServiceTest.php      |   71 +
 .../ClassPrep/StickerCountServiceTest.php     |  165 ++
 .../ClassPreparationAdjustmentServiceTest.php |   30 +
 .../ClassPreparationCalculatorServiceTest.php |   59 +
 .../ClassPreparationContextServiceTest.php    |   28 +
 .../ClassPreparationInventoryServiceTest.php  |   48 +
 .../ClassPreparationLogServiceTest.php        |   36 +
 .../ClassPreparationRosterServiceTest.php     |   84 +
 .../ClassPreparationServiceTest.php           |   93 +
 .../CommunicationTemplateServiceTest.php      |   31 +
 .../CompetitionScoresSaveServiceTest.php      |   46 +
 .../Discounts/DiscountApplyServiceTest.php    |   38 +
 .../Expenses/ExpenseReceiptServiceTest.php    |   26 +
 .../Expenses/ExpenseStaffServiceTest.php      |   75 +
 .../ExtraChargesMetaServiceTest.php           |   61 +
 .../ExamDraftDownloadNameServiceTest.php      |   43 +
 .../Services/Files/FileServeServiceTest.php   |   69 +
 .../Finance/FinancialChartServiceTest.php     |   31 +
 .../Finance/FinancialPaymentServiceTest.php   |   94 +
 .../Finance/FinancialPdfReportServiceTest.php |   37 +
 .../Finance/FinancialReportServiceTest.php    |  126 +
 .../FinancialSchoolYearServiceTest.php        |   50 +
 .../Finance/FinancialSummaryServiceTest.php   |  165 ++
 .../FinancialUnpaidParentsServiceTest.php     |  110 +
 .../Grading/GradingBelowSixtyServiceTest.php  |   55 +
 .../Grading/GradingLockServiceTest.php        |   69 +
 .../Grading/HomeworkTrackingServiceTest.php   |   81 +
 .../Incidents/IncidentAnalysisServiceTest.php |   62 +
 .../Incidents/IncidentHistoryServiceTest.php  |   66 +
 .../Incidents/IncidentLookupServiceTest.php   |   79 +
 .../Invoices/InvoiceConfigServiceTest.php     |   38 +
 .../Invoices/InvoiceGenerationServiceTest.php |   92 +
 .../Invoices/InvoiceGradeServiceTest.php      |   37 +
 .../Invoices/InvoiceManagementServiceTest.php |  107 +
 .../Invoices/InvoicePaymentServiceTest.php    |   63 +
 .../Invoices/InvoicePdfServiceTest.php        |   91 +
 .../Invoices/InvoiceTuitionServiceTest.php    |   60 +
 .../Payments/PaymentBalanceServiceTest.php    |   40 +
 .../PaymentEnrollmentEventServiceTest.php     |   53 +
 .../PaymentEventChargesServiceTest.php        |   82 +
 .../Payments/PaymentLookupServiceTest.php     |   50 +
 .../Payments/PaymentManualServiceTest.php     |   61 +
 ...PaymentNotificationDispatchServiceTest.php |   40 +
 .../PaymentNotificationServiceTest.php        |  134 +
 .../Payments/PaymentPlanServiceTest.php       |   70 +
 .../PaymentTransactionServiceTest.php         |   67 +
 .../Payments/PaypalPaymentServiceTest.php     |   45 +
 .../PaypalTransactionsServiceTest.php         |   46 +
 ...eimbursementBatchAssignmentServiceTest.php |   83 +
 .../ReimbursementBatchServiceTest.php         |   30 +
 .../ReimbursementDonationServiceTest.php      |   77 +
 .../ReimbursementRecipientServiceTest.php     |   79 +
 .../Services/Scores/ExamScoreServiceTest.php  |  106 +
 .../Scores/HomeworkScoreServiceTest.php       |   81 +
 .../Scores/ParticipationScoreServiceTest.php  |   98 +
 .../Scores/ProjectScoreServiceTest.php        |  114 +
 .../Services/Scores/QuizScoreServiceTest.php  |  114 +
 .../Scores/ScoreCommentServiceTest.php        |   80 +
 .../Scores/ScoreDashboardServiceTest.php      |  110 +
 .../Scores/ScorePredictorServiceTest.php      |   77 +
 .../Services/Scores/ScoreTermServiceTest.php  |   38 +
 .../Scores/SemesterScoreServiceTest.php       |  107 +
 .../Semesters/SemesterConfigServiceTest.php   |   27 +
 .../Semesters/SemesterRangeServiceTest.php    |   46 +
 .../Users/LoginActivityServiceTest.php        |   45 +
 .../Services/Users/UserEventServiceTest.php   |   52 +
 .../Services/Users/UserListServiceTest.php    |   73 +
 .../Users/UserManagementServiceTest.php       |  153 ++
 501 files changed, 34439 insertions(+), 21843 deletions(-)
 delete mode 100644 app/Http/Controllers/Api/Api.zip
 create mode 100644 app/Http/Controllers/Api/Auth/RegisterController.php
 create mode 100644 app/Http/Controllers/Api/ClassPrep/ClassPrepController.php
 create mode 100644 app/Http/Controllers/Api/ClassPreparation/ClassPreparationController.php
 create mode 100644 app/Http/Controllers/Api/Communication/CommunicationController.php
 create mode 100644 app/Http/Controllers/Api/CompetitionScores/CompetitionScoresController.php
 create mode 100644 app/Http/Controllers/Api/Discounts/DiscountController.php
 create mode 100644 app/Http/Controllers/Api/Email/BroadcastEmailController.php
 create mode 100644 app/Http/Controllers/Api/Expenses/ExpenseController.php
 create mode 100644 app/Http/Controllers/Api/ExtraCharges/ExtraChargesController.php
 create mode 100644 app/Http/Controllers/Api/Finance/FinancialController.php
 create mode 100644 app/Http/Controllers/Api/Finance/InvoiceController.php
 create mode 100644 app/Http/Controllers/Api/Finance/PaymentController.php
 create mode 100644 app/Http/Controllers/Api/Finance/PaymentEventChargesController.php
 create mode 100644 app/Http/Controllers/Api/Finance/PaymentManualController.php
 create mode 100644 app/Http/Controllers/Api/Finance/PaymentNotificationController.php
 create mode 100644 app/Http/Controllers/Api/Finance/PaymentTransactionController.php
 create mode 100644 app/Http/Controllers/Api/Finance/PaypalPaymentController.php
 create mode 100644 app/Http/Controllers/Api/Finance/PaypalTransactionsController.php
 create mode 100644 app/Http/Controllers/Api/Finance/ReimbursementController.php
 create mode 100644 app/Http/Controllers/Api/Grading/GradingController.php
 create mode 100644 app/Http/Controllers/Api/Grading/HomeworkTrackingController.php
 create mode 100644 app/Http/Controllers/Api/Incidents/IncidentController.php
 create mode 100644 app/Http/Controllers/Api/Reports/FilesController.php
 create mode 100644 app/Http/Controllers/Api/Scores/FinalController.php
 create mode 100644 app/Http/Controllers/Api/Scores/HomeworkController.php
 create mode 100644 app/Http/Controllers/Api/Scores/MidtermController.php
 create mode 100644 app/Http/Controllers/Api/Scores/ParticipationController.php
 create mode 100644 app/Http/Controllers/Api/Scores/ProjectController.php
 create mode 100644 app/Http/Controllers/Api/Scores/QuizController.php
 create mode 100644 app/Http/Controllers/Api/Scores/ScoreCommentController.php
 create mode 100644 app/Http/Controllers/Api/Scores/ScoreController.php
 create mode 100644 app/Http/Controllers/Api/Scores/ScorePredictorController.php
 create mode 100644 app/Http/Controllers/Api/System/SemesterRangeController.php
 create mode 100644 app/Http/Controllers/Api/UserController.php
 create mode 100644 app/Http/Controllers/old/ApiClient.php
 delete mode 100644 app/Http/Controllers/old/BroadcastEmailController.php
 delete mode 100644 app/Http/Controllers/old/ClassPrepController.php
 delete mode 100644 app/Http/Controllers/old/ClassPreparationController.php
 delete mode 100644 app/Http/Controllers/old/CommunicationController.php
 delete mode 100644 app/Http/Controllers/old/CompetitionScoresController.php
 delete mode 100644 app/Http/Controllers/old/DiscountController.php
 create mode 100644 app/Http/Controllers/old/EmailService.php
 delete mode 100644 app/Http/Controllers/old/ExpenseController.php
 delete mode 100644 app/Http/Controllers/old/ExtraChargesController.php
 create mode 100644 app/Http/Controllers/old/FeeCalculationService.php
 delete mode 100644 app/Http/Controllers/old/FilesController.php
 delete mode 100644 app/Http/Controllers/old/FinalController.php
 delete mode 100644 app/Http/Controllers/old/FinancialController.php
 delete mode 100644 app/Http/Controllers/old/FlagController.php
 delete mode 100644 app/Http/Controllers/old/GradingController.php
 delete mode 100644 app/Http/Controllers/old/HomeworkController.php
 delete mode 100644 app/Http/Controllers/old/HomeworkTrackingController.php
 delete mode 100644 app/Http/Controllers/old/InvoiceController.php
 delete mode 100644 app/Http/Controllers/old/MidtermController.php
 create mode 100644 app/Http/Controllers/old/NavbarService.php
 create mode 100644 app/Http/Controllers/old/NotificationService.php
 delete mode 100644 app/Http/Controllers/old/ParticipationController.php
 delete mode 100644 app/Http/Controllers/old/PaymentController.php
 delete mode 100644 app/Http/Controllers/old/PaymentNotificationController.php
 delete mode 100644 app/Http/Controllers/old/PaymentTransactionController.php
 delete mode 100644 app/Http/Controllers/old/PaypalTransactionsController.php
 create mode 100644 app/Http/Controllers/old/PhoneFormatterService.php
 delete mode 100644 app/Http/Controllers/old/ProjectController.php
 delete mode 100644 app/Http/Controllers/old/QuizController.php
 delete mode 100644 app/Http/Controllers/old/RegisterController.php
 create mode 100644 app/Http/Controllers/old/RoleService.php
 create mode 100644 app/Http/Controllers/old/SchoolIdService.php
 delete mode 100644 app/Http/Controllers/old/ScoreCommentController.php
 delete mode 100644 app/Http/Controllers/old/ScoreController.php
 delete mode 100644 app/Http/Controllers/old/ScorePredictor.php
 create mode 100644 app/Http/Controllers/old/TimeService.php
 delete mode 100644 app/Http/Controllers/old/UserController.php
 create mode 100644 app/Http/Requests/Auth/RegisterRequest.php
 create mode 100644 app/Http/Requests/Discounts/ApplyDiscountVoucherRequest.php
 create mode 100644 app/Http/Requests/Discounts/StoreDiscountVoucherRequest.php
 create mode 100644 app/Http/Requests/Discounts/UpdateDiscountVoucherRequest.php
 create mode 100644 app/Http/Requests/Expenses/StoreExpenseRequest.php
 create mode 100644 app/Http/Requests/Expenses/UpdateExpenseRequest.php
 create mode 100644 app/Http/Requests/Expenses/UpdateExpenseStatusRequest.php
 create mode 100644 app/Http/Requests/ExtraCharges/StoreExtraChargeRequest.php
 create mode 100644 app/Http/Requests/ExtraCharges/UpdateExtraChargeRequest.php
 create mode 100644 app/Http/Requests/Files/FileNameRequest.php
 create mode 100644 app/Http/Requests/Finance/FinancialReportRequest.php
 create mode 100644 app/Http/Requests/Finance/FinancialSummaryRequest.php
 create mode 100644 app/Http/Requests/Finance/FinancialUnpaidParentsRequest.php
 create mode 100644 app/Http/Requests/Grading/BelowSixtyEmailRequest.php
 create mode 100644 app/Http/Requests/Grading/BelowSixtyListRequest.php
 create mode 100644 app/Http/Requests/Grading/BelowSixtyMeetingRequest.php
 create mode 100644 app/Http/Requests/Grading/BelowSixtyMeetingSaveRequest.php
 create mode 100644 app/Http/Requests/Grading/BelowSixtySendRequest.php
 create mode 100644 app/Http/Requests/Grading/BelowSixtyStatusRequest.php
 create mode 100644 app/Http/Requests/Grading/GradingLockAllRequest.php
 create mode 100644 app/Http/Requests/Grading/GradingLockRequest.php
 create mode 100644 app/Http/Requests/Grading/GradingOverviewRequest.php
 create mode 100644 app/Http/Requests/Grading/GradingRefreshRequest.php
 create mode 100644 app/Http/Requests/Grading/GradingScoreShowRequest.php
 create mode 100644 app/Http/Requests/Grading/GradingScoreUpdateRequest.php
 create mode 100644 app/Http/Requests/Grading/HomeworkTrackingRequest.php
 create mode 100644 app/Http/Requests/Grading/PlacementBatchRequest.php
 create mode 100644 app/Http/Requests/Grading/PlacementBatchUpdateRequest.php
 create mode 100644 app/Http/Requests/Grading/PlacementLevelRequest.php
 create mode 100644 app/Http/Requests/Grading/PlacementLevelsRequest.php
 create mode 100644 app/Http/Requests/Grading/PlacementRequest.php
 create mode 100644 app/Http/Requests/Incidents/IncidentCancelRequest.php
 create mode 100644 app/Http/Requests/Incidents/IncidentCloseRequest.php
 create mode 100644 app/Http/Requests/Incidents/IncidentListRequest.php
 create mode 100644 app/Http/Requests/Incidents/IncidentStateRequest.php
 create mode 100644 app/Http/Requests/Incidents/IncidentStoreRequest.php
 create mode 100644 app/Http/Requests/Invoices/InvoiceGenerateRequest.php
 create mode 100644 app/Http/Requests/Invoices/InvoiceManagementRequest.php
 create mode 100644 app/Http/Requests/Invoices/InvoiceParentRequest.php
 create mode 100644 app/Http/Requests/Invoices/InvoiceStatusRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentByParentRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentCreateRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentEventChargesListRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentEventChargesStoreRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentManualEditRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentManualSearchRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentManualSuggestRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentManualUpdateRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentNotificationListRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentNotificationSendRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentTransactionCreateRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentTransactionStatusRequest.php
 create mode 100644 app/Http/Requests/Payments/PaymentUpdateBalanceRequest.php
 create mode 100644 app/Http/Requests/Payments/PaypalExecuteRequest.php
 create mode 100644 app/Http/Requests/Payments/PaypalTransactionsListRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementBatchAdminFileRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementBatchAssignmentRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementBatchCreateRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementBatchEmailRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementBatchLockRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementExportBatchRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementExportRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementIndexRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementMarkDonationRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementProcessRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementStoreRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementUnderProcessingRequest.php
 create mode 100644 app/Http/Requests/Reimbursements/ReimbursementUpdateRequest.php
 create mode 100644 app/Http/Requests/Scores/ScoreAddColumnRequest.php
 create mode 100644 app/Http/Requests/Scores/ScoreClassRequest.php
 create mode 100644 app/Http/Requests/Scores/ScoreCommentListRequest.php
 create mode 100644 app/Http/Requests/Scores/ScoreCommentSaveRequest.php
 create mode 100644 app/Http/Requests/Scores/ScoreCommentUpdateRequest.php
 create mode 100644 app/Http/Requests/Scores/ScoreLockRequest.php
 create mode 100644 app/Http/Requests/Scores/ScoreOverviewRequest.php
 create mode 100644 app/Http/Requests/Scores/ScorePredictorRequest.php
 create mode 100644 app/Http/Requests/Scores/ScoreStudentRequest.php
 create mode 100644 app/Http/Requests/Scores/ScoreUpdateRequest.php
 create mode 100644 app/Http/Requests/Semesters/SchoolYearRangeRequest.php
 create mode 100644 app/Http/Requests/Semesters/SemesterNormalizeRequest.php
 create mode 100644 app/Http/Requests/Semesters/SemesterRangeRequest.php
 create mode 100644 app/Http/Requests/Semesters/SemesterResolveRequest.php
 create mode 100644 app/Http/Requests/Users/LoginActivityRequest.php
 create mode 100644 app/Http/Requests/Users/UserListRequest.php
 create mode 100644 app/Http/Requests/Users/UserStoreRequest.php
 create mode 100644 app/Http/Requests/Users/UserUpdateRequest.php
 create mode 100644 app/Http/Resources/Auth/RegisterResource.php
 create mode 100644 app/Http/Resources/Discounts/DiscountParentResource.php
 create mode 100644 app/Http/Resources/Discounts/DiscountVoucherResource.php
 create mode 100644 app/Http/Resources/Expenses/ExpenseResource.php
 create mode 100644 app/Http/Resources/Expenses/ExpenseStaffResource.php
 create mode 100644 app/Http/Resources/ExtraCharges/ExtraChargeInvoiceOptionResource.php
 create mode 100644 app/Http/Resources/ExtraCharges/ExtraChargeParentOptionResource.php
 create mode 100644 app/Http/Resources/ExtraCharges/ExtraChargeResource.php
 create mode 100644 app/Http/Resources/Files/FileMetaResource.php
 create mode 100644 app/Http/Resources/Finance/FinancialDiscountResource.php
 create mode 100644 app/Http/Resources/Finance/FinancialExpenseSummaryResource.php
 create mode 100644 app/Http/Resources/Finance/FinancialInvoiceResource.php
 create mode 100644 app/Http/Resources/Finance/FinancialPaymentResource.php
 create mode 100644 app/Http/Resources/Finance/FinancialRefundResource.php
 create mode 100644 app/Http/Resources/Finance/FinancialReimbursementSummaryResource.php
 create mode 100644 app/Http/Resources/Finance/FinancialReportResource.php
 create mode 100644 app/Http/Resources/Finance/FinancialSummaryResource.php
 create mode 100644 app/Http/Resources/Finance/FinancialUnpaidParentResource.php
 create mode 100644 app/Http/Resources/Grading/BelowSixtyStudentResource.php
 create mode 100644 app/Http/Resources/Grading/GradingScoreResource.php
 create mode 100644 app/Http/Resources/Grading/HomeworkTrackingTeacherResource.php
 create mode 100644 app/Http/Resources/Incidents/IncidentAnalysisStudentResource.php
 create mode 100644 app/Http/Resources/Incidents/IncidentGradeResource.php
 create mode 100644 app/Http/Resources/Incidents/IncidentResource.php
 create mode 100644 app/Http/Resources/Incidents/IncidentStudentOptionResource.php
 create mode 100644 app/Http/Resources/Invoices/InvoiceManagementParentResource.php
 create mode 100644 app/Http/Resources/Invoices/InvoiceResource.php
 create mode 100644 app/Http/Resources/Payments/PaymentNotificationLogResource.php
 create mode 100644 app/Http/Resources/Payments/PaymentResource.php
 create mode 100644 app/Http/Resources/Payments/PaymentTransactionResource.php
 create mode 100644 app/Http/Resources/Payments/PaypalTransactionResource.php
 create mode 100644 app/Http/Resources/Reimbursements/ReimbursementBatchResource.php
 create mode 100644 app/Http/Resources/Reimbursements/ReimbursementExpenseResource.php
 create mode 100644 app/Http/Resources/Reimbursements/ReimbursementRecipientResource.php
 create mode 100644 app/Http/Resources/Reimbursements/ReimbursementResource.php
 create mode 100644 app/Http/Resources/Reimbursements/ReimbursementUnderProcessingItemResource.php
 create mode 100644 app/Http/Resources/Scores/ScoreCommentResource.php
 create mode 100644 app/Http/Resources/Scores/ScorePredictorStudentResource.php
 create mode 100644 app/Http/Resources/Scores/ScoreStudentResource.php
 create mode 100644 app/Http/Resources/Semesters/SemesterRangeResource.php
 create mode 100644 app/Http/Resources/Semesters/SemesterResolveResource.php
 create mode 100644 app/Http/Resources/Users/LoginActivityResource.php
 create mode 100644 app/Http/Resources/Users/UserWithRolesResource.php
 create mode 100644 app/Interfaces/ScoreCalculatorInterface.php
 create mode 100644 app/Models/CurrentIncident.php
 rename app/Models/{Flag.php => Incident.php} (86%)
 create mode 100644 app/Services/Assignment/AssignmentContextService.php
 create mode 100644 app/Services/Assignment/AssignmentDataLoaderService.php
 create mode 100644 app/Services/Assignment/AssignmentMetaService.php
 create mode 100644 app/Services/Assignment/AssignmentSectionService.php
 delete mode 100644 app/Services/AttendanceTrackingService.php
 create mode 100644 app/Services/Auth/RegistrationCaptchaService.php
 create mode 100644 app/Services/Auth/RegistrationFormatterService.php
 create mode 100644 app/Services/Auth/RegistrationService.php
 create mode 100644 app/Services/BroadcastEmail/BroadcastEmailComposerService.php
 create mode 100644 app/Services/BroadcastEmail/BroadcastEmailDispatchService.php
 create mode 100644 app/Services/BroadcastEmail/BroadcastEmailImageService.php
 create mode 100644 app/Services/BroadcastEmail/BroadcastEmailRecipientService.php
 create mode 100644 app/Services/BroadcastEmail/BroadcastEmailSenderOptionsService.php
 create mode 100644 app/Services/ClassPrep/ClassRosterService.php
 create mode 100644 app/Services/ClassPrep/StickerCountService.php
 create mode 100644 app/Services/ClassPreparation/ClassPreparationAdjustmentService.php
 create mode 100644 app/Services/ClassPreparation/ClassPreparationCalculatorService.php
 create mode 100644 app/Services/ClassPreparation/ClassPreparationContextService.php
 create mode 100644 app/Services/ClassPreparation/ClassPreparationInventoryService.php
 create mode 100644 app/Services/ClassPreparation/ClassPreparationLogService.php
 create mode 100644 app/Services/ClassPreparation/ClassPreparationRosterService.php
 create mode 100644 app/Services/ClassPreparation/ClassPreparationService.php
 create mode 100644 app/Services/Communication/CommunicationFamilyService.php
 create mode 100644 app/Services/Communication/CommunicationLogService.php
 create mode 100644 app/Services/Communication/CommunicationPreviewService.php
 create mode 100644 app/Services/Communication/CommunicationSendService.php
 create mode 100644 app/Services/Communication/CommunicationStudentService.php
 create mode 100644 app/Services/Communication/CommunicationTemplateService.php
 create mode 100644 app/Services/CompetitionScores/CompetitionScoresContextService.php
 create mode 100644 app/Services/CompetitionScores/CompetitionScoresQueryService.php
 create mode 100644 app/Services/CompetitionScores/CompetitionScoresRosterService.php
 create mode 100644 app/Services/CompetitionScores/CompetitionScoresSaveService.php
 create mode 100644 app/Services/Discounts/DiscountApplyService.php
 create mode 100644 app/Services/Discounts/DiscountContextService.php
 create mode 100644 app/Services/Discounts/DiscountInvoiceService.php
 create mode 100644 app/Services/Discounts/DiscountParentService.php
 create mode 100644 app/Services/Discounts/DiscountVoucherService.php
 create mode 100644 app/Services/EmailService.php
 create mode 100644 app/Services/Expenses/ExpenseContextService.php
 create mode 100644 app/Services/Expenses/ExpenseQueryService.php
 create mode 100644 app/Services/Expenses/ExpenseReceiptService.php
 create mode 100644 app/Services/Expenses/ExpenseRetailorService.php
 create mode 100644 app/Services/Expenses/ExpenseStaffService.php
 create mode 100644 app/Services/Expenses/ExpenseStatusService.php
 create mode 100644 app/Services/Expenses/ExpenseWriteService.php
 create mode 100644 app/Services/ExtraCharges/ExtraChargesChargeService.php
 create mode 100644 app/Services/ExtraCharges/ExtraChargesContextService.php
 create mode 100644 app/Services/ExtraCharges/ExtraChargesInvoiceService.php
 create mode 100644 app/Services/ExtraCharges/ExtraChargesListService.php
 create mode 100644 app/Services/ExtraCharges/ExtraChargesMetaService.php
 create mode 100644 app/Services/ExtraCharges/ExtraChargesParentService.php
 create mode 100644 app/Services/Files/ExamDraftDownloadNameService.php
 create mode 100644 app/Services/Files/FileServeService.php
 create mode 100644 app/Services/Finance/FinancialChartService.php
 create mode 100644 app/Services/Finance/FinancialDonationRecipientService.php
 create mode 100644 app/Services/Finance/FinancialPaymentService.php
 create mode 100644 app/Services/Finance/FinancialPdfReportService.php
 create mode 100644 app/Services/Finance/FinancialReportService.php
 create mode 100644 app/Services/Finance/FinancialSchoolYearService.php
 create mode 100644 app/Services/Finance/FinancialSummaryService.php
 create mode 100644 app/Services/Finance/FinancialUnpaidParentsService.php
 create mode 100644 app/Services/Grading/GradingBelowSixtyService.php
 create mode 100644 app/Services/Grading/GradingLockService.php
 create mode 100644 app/Services/Grading/GradingOverviewService.php
 create mode 100644 app/Services/Grading/GradingPlacementService.php
 create mode 100644 app/Services/Grading/GradingRefreshService.php
 create mode 100644 app/Services/Grading/GradingScoreService.php
 create mode 100644 app/Services/Grading/HomeworkTrackingCalendarService.php
 create mode 100644 app/Services/Grading/HomeworkTrackingService.php
 create mode 100644 app/Services/Incidents/CurrentIncidentService.php
 create mode 100644 app/Services/Incidents/IncidentAnalysisService.php
 create mode 100644 app/Services/Incidents/IncidentHistoryService.php
 create mode 100644 app/Services/Incidents/IncidentLookupService.php
 create mode 100644 app/Services/Invoices/InvoiceConfigService.php
 create mode 100644 app/Services/Invoices/InvoiceGenerationService.php
 create mode 100644 app/Services/Invoices/InvoiceGradeService.php
 create mode 100644 app/Services/Invoices/InvoiceManagementService.php
 create mode 100644 app/Services/Invoices/InvoicePaymentService.php
 create mode 100644 app/Services/Invoices/InvoicePdfService.php
 create mode 100644 app/Services/Invoices/InvoiceTuitionService.php
 create mode 100644 app/Services/Payments/PaymentBalanceService.php
 create mode 100644 app/Services/Payments/PaymentEnrollmentEventService.php
 create mode 100644 app/Services/Payments/PaymentEventChargesService.php
 create mode 100644 app/Services/Payments/PaymentLookupService.php
 create mode 100644 app/Services/Payments/PaymentManualService.php
 create mode 100644 app/Services/Payments/PaymentNotificationDispatchService.php
 create mode 100644 app/Services/Payments/PaymentNotificationService.php
 create mode 100644 app/Services/Payments/PaymentPlanService.php
 create mode 100644 app/Services/Payments/PaymentTransactionService.php
 create mode 100644 app/Services/Payments/PaypalPaymentService.php
 create mode 100644 app/Services/Payments/PaypalTransactionsService.php
 create mode 100644 app/Services/PhoneFormatterService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementBatchAssignmentService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementBatchService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementContextService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementCrudService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementDonationService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementEmailService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementExportService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementFileService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementLookupService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementQueryService.php
 create mode 100644 app/Services/Reimbursements/ReimbursementRecipientService.php
 create mode 100644 app/Services/SchoolIdService.php
 create mode 100644 app/Services/Scores/AttendanceCalculator.php
 create mode 100644 app/Services/Scores/ExamScoreService.php
 create mode 100644 app/Services/Scores/HomeworkCalculator.php
 create mode 100644 app/Services/Scores/HomeworkScoreService.php
 create mode 100644 app/Services/Scores/ParticipationScoreService.php
 create mode 100644 app/Services/Scores/ProjectCalculator.php
 create mode 100644 app/Services/Scores/ProjectScoreService.php
 create mode 100644 app/Services/Scores/QuizCalculator.php
 create mode 100644 app/Services/Scores/QuizScoreService.php
 create mode 100644 app/Services/Scores/ScoreCommentService.php
 create mode 100644 app/Services/Scores/ScoreDashboardService.php
 create mode 100644 app/Services/Scores/ScorePredictorDataService.php
 create mode 100644 app/Services/Scores/ScorePredictorRiskService.php
 create mode 100644 app/Services/Scores/ScorePredictorService.php
 create mode 100644 app/Services/Scores/ScoreTermService.php
 create mode 100644 app/Services/Scores/SemesterScoreService.php
 create mode 100644 app/Services/SemesterRangeService.php
 create mode 100644 app/Services/Semesters/SemesterConfigService.php
 create mode 100644 app/Services/Users/LoginActivityService.php
 create mode 100644 app/Services/Users/UserEventService.php
 create mode 100644 app/Services/Users/UserListService.php
 create mode 100644 app/Services/Users/UserManagementService.php
 create mode 100644 config/sanctum.php
 create mode 100644 database/migrations/2026_02_23_204035_create_current_incident_table.php
 rename database/migrations/{2026_02_23_204036_create_flag_table.php => 2026_02_23_204036_create_incident_table.php} (67%)
 create mode 100644 database/migrations/2026_02_23_900056_create_communication_logs_table.php
 create mode 100644 database/migrations/2026_03_09_050312_create_personal_access_tokens_table.php
 create mode 100644 database/migrations/2026_03_09_064908_create_sessions_table.php
 create mode 100644 school_api
 create mode 100644 storage/testing/files/cached.pdf
 create mode 100644 storage/testing/files/sample.exe
 create mode 100644 storage/testing/files/sample.pdf
 create mode 100644 tests/Feature/Api/V1/Auth/RegisterControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Auth/RegisterPayloadDebugTest.php
 create mode 100644 tests/Feature/Api/V1/BroadcastEmail/BroadcastEmailControllerTest.php
 create mode 100644 tests/Feature/Api/V1/ClassPrep/ClassPrepControllerTest.php
 create mode 100644 tests/Feature/Api/V1/ClassPreparation/ClassPreparationControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Communication/CommunicationControllerTest.php
 create mode 100644 tests/Feature/Api/V1/CompetitionScores/CompetitionScoresControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Discounts/DiscountControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Expenses/ExpenseControllerTest.php
 create mode 100644 tests/Feature/Api/V1/ExtraCharges/ExtraChargesControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Finance/FinancialControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Finance/InvoiceControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Finance/PaymentControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Finance/PaymentEventChargesControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Finance/PaymentManualControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Finance/PaymentNotificationControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Finance/PaymentTransactionControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Finance/PaypalTransactionsControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Finance/ReimbursementControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Grading/GradingControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Grading/HomeworkTrackingControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Incidents/IncidentControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Reports/FilesControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Scores/FinalControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Scores/HomeworkControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Scores/MidtermControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Scores/ParticipationControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Scores/ProjectControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Scores/QuizControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Scores/ScoreCommentControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Scores/ScoreControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Scores/ScorePredictorControllerTest.php
 create mode 100644 tests/Feature/Api/V1/System/SemesterRangeControllerTest.php
 create mode 100644 tests/Feature/Api/V1/Users/UserControllerTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdminNotificationUserServiceTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdministratorAbsenceServiceTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdministratorDashboardServiceTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdministratorEnrollmentEventServiceTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdministratorEnrollmentRefundServiceTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdministratorEnrollmentServiceTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdministratorMetricsServiceTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdministratorNotificationServiceTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdministratorSharedServiceTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdministratorTeacherSubmissionServiceTest.php
 create mode 100644 tests/Unit/Services/Administrator/AdministratorUserSearchServiceTest.php
 create mode 100644 tests/Unit/Services/Assignment/AssignmentContextServiceTest.php
 create mode 100644 tests/Unit/Services/Assignment/AssignmentDataLoaderServiceTest.php
 create mode 100644 tests/Unit/Services/Assignment/AssignmentMetaServiceTest.php
 create mode 100644 tests/Unit/Services/Assignment/AssignmentSectionServiceTest.php
 create mode 100644 tests/Unit/Services/Attendance/AttendanceQueryServiceTest.php
 create mode 100644 tests/Unit/Services/Attendance/AttendanceSemesterRangeServiceTest.php
 create mode 100644 tests/Unit/Services/Attendance/AttendanceServiceTest.php
 create mode 100644 tests/Unit/Services/Attendance/StaffAttendanceServiceTest.php
 create mode 100644 tests/Unit/Services/Auth/RegistrationCaptchaServiceTest.php
 create mode 100644 tests/Unit/Services/Auth/RegistrationFormatterServiceTest.php
 create mode 100644 tests/Unit/Services/Auth/RegistrationServiceTest.php
 create mode 100644 tests/Unit/Services/BroadcastEmail/BroadcastEmailComposerServiceTest.php
 create mode 100644 tests/Unit/Services/BroadcastEmail/BroadcastEmailRecipientServiceTest.php
 create mode 100644 tests/Unit/Services/BroadcastEmail/BroadcastEmailSenderOptionsServiceTest.php
 create mode 100644 tests/Unit/Services/ClassPrep/ClassRosterServiceTest.php
 create mode 100644 tests/Unit/Services/ClassPrep/StickerCountServiceTest.php
 create mode 100644 tests/Unit/Services/ClassPreparation/ClassPreparationAdjustmentServiceTest.php
 create mode 100644 tests/Unit/Services/ClassPreparation/ClassPreparationCalculatorServiceTest.php
 create mode 100644 tests/Unit/Services/ClassPreparation/ClassPreparationContextServiceTest.php
 create mode 100644 tests/Unit/Services/ClassPreparation/ClassPreparationInventoryServiceTest.php
 create mode 100644 tests/Unit/Services/ClassPreparation/ClassPreparationLogServiceTest.php
 create mode 100644 tests/Unit/Services/ClassPreparation/ClassPreparationRosterServiceTest.php
 create mode 100644 tests/Unit/Services/ClassPreparation/ClassPreparationServiceTest.php
 create mode 100644 tests/Unit/Services/Communication/CommunicationTemplateServiceTest.php
 create mode 100644 tests/Unit/Services/CompetitionScores/CompetitionScoresSaveServiceTest.php
 create mode 100644 tests/Unit/Services/Discounts/DiscountApplyServiceTest.php
 create mode 100644 tests/Unit/Services/Expenses/ExpenseReceiptServiceTest.php
 create mode 100644 tests/Unit/Services/Expenses/ExpenseStaffServiceTest.php
 create mode 100644 tests/Unit/Services/ExtraCharges/ExtraChargesMetaServiceTest.php
 create mode 100644 tests/Unit/Services/Files/ExamDraftDownloadNameServiceTest.php
 create mode 100644 tests/Unit/Services/Files/FileServeServiceTest.php
 create mode 100644 tests/Unit/Services/Finance/FinancialChartServiceTest.php
 create mode 100644 tests/Unit/Services/Finance/FinancialPaymentServiceTest.php
 create mode 100644 tests/Unit/Services/Finance/FinancialPdfReportServiceTest.php
 create mode 100644 tests/Unit/Services/Finance/FinancialReportServiceTest.php
 create mode 100644 tests/Unit/Services/Finance/FinancialSchoolYearServiceTest.php
 create mode 100644 tests/Unit/Services/Finance/FinancialSummaryServiceTest.php
 create mode 100644 tests/Unit/Services/Finance/FinancialUnpaidParentsServiceTest.php
 create mode 100644 tests/Unit/Services/Grading/GradingBelowSixtyServiceTest.php
 create mode 100644 tests/Unit/Services/Grading/GradingLockServiceTest.php
 create mode 100644 tests/Unit/Services/Grading/HomeworkTrackingServiceTest.php
 create mode 100644 tests/Unit/Services/Incidents/IncidentAnalysisServiceTest.php
 create mode 100644 tests/Unit/Services/Incidents/IncidentHistoryServiceTest.php
 create mode 100644 tests/Unit/Services/Incidents/IncidentLookupServiceTest.php
 create mode 100644 tests/Unit/Services/Invoices/InvoiceConfigServiceTest.php
 create mode 100644 tests/Unit/Services/Invoices/InvoiceGenerationServiceTest.php
 create mode 100644 tests/Unit/Services/Invoices/InvoiceGradeServiceTest.php
 create mode 100644 tests/Unit/Services/Invoices/InvoiceManagementServiceTest.php
 create mode 100644 tests/Unit/Services/Invoices/InvoicePaymentServiceTest.php
 create mode 100644 tests/Unit/Services/Invoices/InvoicePdfServiceTest.php
 create mode 100644 tests/Unit/Services/Invoices/InvoiceTuitionServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaymentBalanceServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaymentEnrollmentEventServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaymentEventChargesServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaymentLookupServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaymentManualServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaymentNotificationDispatchServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaymentNotificationServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaymentPlanServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaymentTransactionServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaypalPaymentServiceTest.php
 create mode 100644 tests/Unit/Services/Payments/PaypalTransactionsServiceTest.php
 create mode 100644 tests/Unit/Services/Reimbursements/ReimbursementBatchAssignmentServiceTest.php
 create mode 100644 tests/Unit/Services/Reimbursements/ReimbursementBatchServiceTest.php
 create mode 100644 tests/Unit/Services/Reimbursements/ReimbursementDonationServiceTest.php
 create mode 100644 tests/Unit/Services/Reimbursements/ReimbursementRecipientServiceTest.php
 create mode 100644 tests/Unit/Services/Scores/ExamScoreServiceTest.php
 create mode 100644 tests/Unit/Services/Scores/HomeworkScoreServiceTest.php
 create mode 100644 tests/Unit/Services/Scores/ParticipationScoreServiceTest.php
 create mode 100644 tests/Unit/Services/Scores/ProjectScoreServiceTest.php
 create mode 100644 tests/Unit/Services/Scores/QuizScoreServiceTest.php
 create mode 100644 tests/Unit/Services/Scores/ScoreCommentServiceTest.php
 create mode 100644 tests/Unit/Services/Scores/ScoreDashboardServiceTest.php
 create mode 100644 tests/Unit/Services/Scores/ScorePredictorServiceTest.php
 create mode 100644 tests/Unit/Services/Scores/ScoreTermServiceTest.php
 create mode 100644 tests/Unit/Services/Scores/SemesterScoreServiceTest.php
 create mode 100644 tests/Unit/Services/Semesters/SemesterConfigServiceTest.php
 create mode 100644 tests/Unit/Services/Semesters/SemesterRangeServiceTest.php
 create mode 100644 tests/Unit/Services/Users/LoginActivityServiceTest.php
 create mode 100644 tests/Unit/Services/Users/UserEventServiceTest.php
 create mode 100644 tests/Unit/Services/Users/UserListServiceTest.php
 create mode 100644 tests/Unit/Services/Users/UserManagementServiceTest.php

diff --git a/app/Config/Services.php b/app/Config/Services.php
index f98dc979..668e31bd 100755
--- a/app/Config/Services.php
+++ b/app/Config/Services.php
@@ -3,7 +3,7 @@
 namespace Config;
 
 use App\Services\EmailService;
-use App\Services\SemesterScoreService;
+use App\Services\Scores\SemesterScoreService;
 
 class Services
 {
diff --git a/app/Http/Controllers/Api/Api.zip b/app/Http/Controllers/Api/Api.zip
deleted file mode 100644
index fbcb139079f3e5f6587d4df163537ba7fddda706..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 240011
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%0Dl%_}Ufd11PV{}HgK3%wqYSJ+
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

diff --git a/app/Http/Controllers/Api/AttendanceTracking/AttendanceTrackingController.php b/app/Http/Controllers/Api/AttendanceTracking/AttendanceTrackingController.php
index 7348d6ea..bdb79f31 100644
--- a/app/Http/Controllers/Api/AttendanceTracking/AttendanceTrackingController.php
+++ b/app/Http/Controllers/Api/AttendanceTracking/AttendanceTrackingController.php
@@ -8,7 +8,7 @@ use App\Http\Requests\AttendanceTracking\ParentsInfoRequest;
 use App\Http\Requests\AttendanceTracking\RecordAttendanceTrackingRequest;
 use App\Http\Requests\AttendanceTracking\SaveAttendanceNotificationNoteRequest;
 use App\Http\Requests\AttendanceTracking\SendAttendanceManualEmailRequest;
-use App\Services\AttendanceTrackingService;
+use App\Services\AttendanceTracking\AttendanceTrackingService;
 use Illuminate\Http\JsonResponse;
 use Illuminate\Http\Request;
 
diff --git a/app/Http/Controllers/Api/Auth/RegisterController.php b/app/Http/Controllers/Api/Auth/RegisterController.php
new file mode 100644
index 00000000..5ec3221e
--- /dev/null
+++ b/app/Http/Controllers/Api/Auth/RegisterController.php
@@ -0,0 +1,64 @@
+<?php
+
+namespace App\Http\Controllers\Api\Auth;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Auth\RegisterRequest;
+use App\Http\Resources\Auth\RegisterResource;
+use App\Services\Auth\RegistrationCaptchaService;
+use App\Services\Auth\RegistrationService;
+use Illuminate\Http\JsonResponse;
+
+class RegisterController extends BaseApiController
+{
+    public function __construct(
+        private RegistrationService $service,
+        private RegistrationCaptchaService $captchaService
+    ) {
+        parent::__construct();
+    }
+
+    public function captcha(): JsonResponse
+    {
+        $captcha = $this->captchaService->generate();
+
+        return response()->json([
+            'ok' => true,
+            'captcha' => $captcha,
+        ]);
+    }
+
+    public function store(RegisterRequest $request): JsonResponse
+    {
+        if (app()->runningUnitTests() && $request->header('X-Debug-Request') === '1') {
+            return response()->json([
+                'ok' => true,
+                'debug' => [
+                    'content_type' => $request->header('Content-Type'),
+                    'content_length' => strlen((string) $request->getContent()),
+                    'request_all' => $request->all(),
+                    'json_all' => $request->json()->all(),
+                    'payload_data' => $this->payloadData(),
+                ],
+            ]);
+        }
+
+        $result = $this->service->register($request->validated());
+
+        if (empty($result['ok'])) {
+            $code = $result['code'] ?? 'registration_failed';
+            $status = $code === 'pending_activation' || $code === 'email_exists' ? 409 : 422;
+
+            return response()->json([
+                'ok' => false,
+                'message' => $result['message'] ?? 'Registration failed.',
+                'code' => $code,
+            ], $status);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'registration' => new RegisterResource($result),
+        ], 201);
+    }
+}
diff --git a/app/Http/Controllers/Api/ClassPrep/ClassPrepController.php b/app/Http/Controllers/Api/ClassPrep/ClassPrepController.php
new file mode 100644
index 00000000..003c13a6
--- /dev/null
+++ b/app/Http/Controllers/Api/ClassPrep/ClassPrepController.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace App\Http\Controllers\Api\ClassPrep;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Services\ClassPrep\ClassRosterService;
+use App\Services\ClassPrep\StickerCountService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class ClassPrepController extends BaseApiController
+{
+    private StickerCountService $stickerCounts;
+    private ClassRosterService $roster;
+
+    public function __construct(StickerCountService $stickerCounts, ClassRosterService $roster)
+    {
+        parent::__construct();
+        $this->stickerCounts = $stickerCounts;
+        $this->roster = $roster;
+    }
+
+    public function stickerCounts(Request $request): JsonResponse
+    {
+        $schoolYear = (string) ($request->query('school_year') ?? '');
+        $semester = (string) ($request->query('semester') ?? '');
+        $classSectionId = $request->query('class_section_id') ?? $request->query('class_id');
+        $classSectionId = is_numeric($classSectionId) ? (int) $classSectionId : null;
+
+        if ($classSectionId !== null && $classSectionId > 0) {
+            $payload = $this->stickerCounts->listForClass($schoolYear, $semester, $classSectionId);
+        } else {
+            $payload = $this->stickerCounts->listAll($schoolYear, $semester);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'data' => $payload,
+        ]);
+    }
+
+    public function studentsByClass(Request $request, int $classSectionId): JsonResponse
+    {
+        $schoolYear = (string) ($request->query('school_year') ?? '');
+
+        $students = $this->roster->listStudentsByClass($classSectionId, $schoolYear !== '' ? $schoolYear : null);
+
+        return response()->json([
+            'ok' => true,
+            'students' => $students,
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/ClassPreparation/ClassPreparationController.php b/app/Http/Controllers/Api/ClassPreparation/ClassPreparationController.php
new file mode 100644
index 00000000..584ff75d
--- /dev/null
+++ b/app/Http/Controllers/Api/ClassPreparation/ClassPreparationController.php
@@ -0,0 +1,60 @@
+<?php
+
+namespace App\Http\Controllers\Api\ClassPreparation;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Services\ClassPreparation\ClassPreparationService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class ClassPreparationController extends BaseApiController
+{
+    private ClassPreparationService $service;
+
+    public function __construct(ClassPreparationService $service)
+    {
+        parent::__construct();
+        $this->service = $service;
+    }
+
+    public function index(Request $request): JsonResponse
+    {
+        $schoolYear = (string) ($request->query('school_year') ?? '');
+        $semester = (string) ($request->query('semester') ?? '');
+
+        $payload = $this->service->listPrep(
+            $schoolYear !== '' ? $schoolYear : null,
+            $semester !== '' ? $semester : null
+        );
+
+        return response()->json([
+            'ok' => true,
+            'schoolYear' => $payload['schoolYear'],
+            'semester' => $payload['semester'],
+            'results' => $payload['results'],
+            'totals' => $payload['totals'],
+            'shortages' => $payload['shortages'],
+        ]);
+    }
+
+    public function markPrinted(Request $request): JsonResponse
+    {
+        $schoolYear = (string) ($request->input('school_year') ?? '');
+        $semester = (string) ($request->input('semester') ?? '');
+        $ids = $request->input('class_section_ids', []);
+
+        if ($schoolYear === '' || !is_array($ids)) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'school_year and class_section_ids are required.',
+            ], 422);
+        }
+
+        $count = $this->service->markPrinted($schoolYear, $semester, $ids);
+
+        return response()->json([
+            'ok' => true,
+            'updated' => $count,
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Communication/CommunicationController.php b/app/Http/Controllers/Api/Communication/CommunicationController.php
new file mode 100644
index 00000000..74300f85
--- /dev/null
+++ b/app/Http/Controllers/Api/Communication/CommunicationController.php
@@ -0,0 +1,178 @@
+<?php
+
+namespace App\Http\Controllers\Api\Communication;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Services\Communication\CommunicationFamilyService;
+use App\Services\Communication\CommunicationPreviewService;
+use App\Services\Communication\CommunicationSendService;
+use App\Services\Communication\CommunicationStudentService;
+use App\Services\Communication\CommunicationTemplateService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class CommunicationController extends BaseApiController
+{
+    private CommunicationStudentService $students;
+    private CommunicationTemplateService $templates;
+    private CommunicationFamilyService $families;
+    private CommunicationPreviewService $previewService;
+    private CommunicationSendService $sendService;
+
+    public function __construct(
+        CommunicationStudentService $students,
+        CommunicationTemplateService $templates,
+        CommunicationFamilyService $families,
+        CommunicationPreviewService $previewService,
+        CommunicationSendService $sendService
+    ) {
+        parent::__construct();
+        $this->students = $students;
+        $this->templates = $templates;
+        $this->families = $families;
+        $this->previewService = $previewService;
+        $this->sendService = $sendService;
+    }
+
+    public function options(): JsonResponse
+    {
+        return response()->json([
+            'ok' => true,
+            'students' => $this->students->listStudents(),
+            'templates' => $this->templates->listActiveTemplates(),
+        ]);
+    }
+
+    public function families(int $studentId): JsonResponse
+    {
+        return response()->json([
+            'ok' => true,
+            'data' => $this->families->familiesForStudent($studentId),
+        ]);
+    }
+
+    public function guardians(int $familyId): JsonResponse
+    {
+        return response()->json([
+            'ok' => true,
+            'data' => $this->families->guardiansForFamily($familyId),
+        ]);
+    }
+
+    public function preview(Request $request): JsonResponse
+    {
+        $templateKey = (string) $request->input('template_key', '');
+        $studentId = (int) $request->input('student_id', 0);
+        $familyId = (int) $request->input('family_id', 0);
+        $vars = $this->normalizeArray($request->input('vars', []));
+
+        if ($templateKey === '' || $studentId <= 0 || $familyId <= 0) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'template_key, student_id, and family_id are required.',
+            ], 422);
+        }
+
+        $teacherName = $this->resolveTeacherName();
+        $result = $this->previewService->buildPreview($templateKey, $studentId, $familyId, $vars, $teacherName);
+
+        if (!$result['ok']) {
+            return response()->json([
+                'ok' => false,
+                'message' => $result['message'] ?? 'Preview failed.',
+            ], $result['status'] ?? 400);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'subject' => $result['subject'],
+            'html' => $result['html'],
+        ]);
+    }
+
+    public function send(Request $request): JsonResponse
+    {
+        $studentId = (int) $request->input('student_id', 0);
+        $familyId = (int) $request->input('family_id', 0);
+        $templateKey = (string) $request->input('template_key', '');
+        $subject = (string) $request->input('subject', '');
+        $body = (string) $request->input('body', '');
+        $recipients = $this->normalizeArray($request->input('recipients', []));
+        $cc = $this->normalizeArray($request->input('cc', []));
+        $bcc = $this->normalizeArray($request->input('bcc', []));
+
+        if ($studentId <= 0 || $familyId <= 0 || $templateKey === '' || $subject === '' || $body === '') {
+            return response()->json([
+                'ok' => false,
+                'message' => 'student_id, family_id, template_key, subject, and body are required.',
+            ], 422);
+        }
+
+        if (empty($recipients)) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'At least one recipient is required.',
+            ], 422);
+        }
+
+        $student = $this->students->getStudentBasic($studentId);
+        if (!$student) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'Student not found.',
+            ], 404);
+        }
+
+        $result = $this->sendService->send([
+            'student_id' => $studentId,
+            'family_id' => $familyId,
+            'template_key' => $templateKey,
+            'subject' => $subject,
+            'body' => $body,
+            'recipients' => $recipients,
+            'cc' => $cc,
+            'bcc' => $bcc,
+            'student_name' => trim(($student['firstname'] ?? '') . ' ' . ($student['lastname'] ?? '')),
+            'sent_by' => (int) (auth()->id() ?? 0),
+        ]);
+
+        if (!$result['ok']) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'Failed to send email.',
+                'error' => $result['error'],
+            ], 500);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'message' => 'Email sent successfully.',
+        ]);
+    }
+
+    private function normalizeArray($value): array
+    {
+        if (is_array($value)) {
+            return $value;
+        }
+
+        if (is_string($value) && $value !== '') {
+            $decoded = json_decode($value, true);
+            if (is_array($decoded)) {
+                return $decoded;
+            }
+        }
+
+        return [];
+    }
+
+    private function resolveTeacherName(): string
+    {
+        $user = auth()->user();
+        if ($user) {
+            $name = trim(($user->firstname ?? '') . ' ' . ($user->lastname ?? ''));
+            return $name !== '' ? $name : 'Teacher';
+        }
+        return 'Teacher';
+    }
+}
diff --git a/app/Http/Controllers/Api/CompetitionScores/CompetitionScoresController.php b/app/Http/Controllers/Api/CompetitionScores/CompetitionScoresController.php
new file mode 100644
index 00000000..52b96100
--- /dev/null
+++ b/app/Http/Controllers/Api/CompetitionScores/CompetitionScoresController.php
@@ -0,0 +1,212 @@
+<?php
+
+namespace App\Http\Controllers\Api\CompetitionScores;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Models\Competition;
+use App\Services\CompetitionScores\CompetitionScoresContextService;
+use App\Services\CompetitionScores\CompetitionScoresQueryService;
+use App\Services\CompetitionScores\CompetitionScoresRosterService;
+use App\Services\CompetitionScores\CompetitionScoresSaveService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class CompetitionScoresController extends BaseApiController
+{
+    private CompetitionScoresContextService $contextService;
+    private CompetitionScoresQueryService $queryService;
+    private CompetitionScoresRosterService $rosterService;
+    private CompetitionScoresSaveService $saveService;
+
+    public function __construct(
+        CompetitionScoresContextService $contextService,
+        CompetitionScoresQueryService $queryService,
+        CompetitionScoresRosterService $rosterService,
+        CompetitionScoresSaveService $saveService
+    ) {
+        parent::__construct();
+        $this->contextService = $contextService;
+        $this->queryService = $queryService;
+        $this->rosterService = $rosterService;
+        $this->saveService = $saveService;
+    }
+
+    public function index(Request $request): JsonResponse
+    {
+        $userId = (int) (auth()->id() ?? 0);
+        [$assignments, $schoolYear, $semester] = $this->contextService->getTeacherContext($userId);
+
+        $activeClassId = $this->contextService->resolveActiveClassId(
+            $assignments,
+            (int) $request->query('class_section_id', 0)
+        );
+        $activeClassName = $this->contextService->getActiveClassName($assignments, $activeClassId);
+
+        if (empty($assignments) || $activeClassId <= 0) {
+            return response()->json([
+                'ok' => true,
+                'competitions' => [],
+                'activeClassId' => $activeClassId,
+                'activeClassName' => $activeClassName,
+                'questionCounts' => [],
+                'scoreCounts' => [],
+                'studentTotal' => 0,
+                'sectionMap' => $this->contextService->getClassSectionMap(),
+                'schoolYear' => $schoolYear,
+                'semester' => $semester,
+                'hasClasses' => false,
+            ]);
+        }
+
+        $competitions = $this->queryService->getCompetitionsForClass($activeClassId, $schoolYear, $semester);
+        $competitionIds = array_values(array_filter(array_map(static function ($row) {
+            return (int) ($row['id'] ?? 0);
+        }, $competitions)));
+
+        return response()->json([
+            'ok' => true,
+            'competitions' => $competitions,
+            'activeClassId' => $activeClassId,
+            'activeClassName' => $activeClassName,
+            'questionCounts' => $this->queryService->getQuestionCounts($competitionIds, $activeClassId),
+            'scoreCounts' => $this->queryService->getScoreCounts($competitionIds, $activeClassId),
+            'studentTotal' => $this->rosterService->getClassStudentCount($activeClassId, $schoolYear),
+            'sectionMap' => $this->contextService->getClassSectionMap(),
+            'schoolYear' => $schoolYear,
+            'semester' => $semester,
+            'hasClasses' => true,
+        ]);
+    }
+
+    public function edit(Request $request, int $id): JsonResponse
+    {
+        $userId = (int) (auth()->id() ?? 0);
+        [$assignments, $schoolYear, $semester] = $this->contextService->getTeacherContext($userId);
+        $allowedClassIds = $this->contextService->getAllowedClassIds($assignments);
+
+        if (empty($allowedClassIds)) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'No class assignments found for your account.',
+            ], 403);
+        }
+
+        $competition = Competition::query()->find($id);
+        if (!$competition) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'Competition not found.',
+            ], 404);
+        }
+
+        $isLocked = (bool) $competition->is_locked;
+        $lockedClassId = (int) ($competition->class_section_id ?? 0);
+        $requestedClassId = (int) $request->query('class_section_id', 0);
+        $activeClassId = $this->contextService->resolveActiveClassId($assignments, $requestedClassId);
+        $classSectionId = $lockedClassId > 0 ? $lockedClassId : $activeClassId;
+
+        if ($classSectionId <= 0) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'Select a class section before entering scores.',
+            ], 422);
+        }
+
+        if (!in_array($classSectionId, $allowedClassIds, true)) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'You are not assigned to that class.',
+            ], 403);
+        }
+
+        $competitionArray = $competition->toArray();
+        $students = $this->rosterService->getStudentsForCompetition($competitionArray, $classSectionId);
+        $scoreMap = $this->saveService->getScoreMap($id, $classSectionId);
+        $questionCount = $this->queryService->getQuestionCountForCompetition($id, $classSectionId);
+        $classStudentCount = $this->rosterService->getClassStudentCount(
+            $classSectionId,
+            $competitionArray['school_year'] ?? $schoolYear
+        );
+
+        return response()->json([
+            'ok' => true,
+            'competition' => $competitionArray,
+            'students' => $students,
+            'scoreMap' => $scoreMap,
+            'classSectionId' => $classSectionId,
+            'classSectionName' => $this->contextService->getActiveClassName($assignments, $classSectionId),
+            'classStudentCount' => $classStudentCount,
+            'questionCount' => $questionCount,
+            'classSelectionLocked' => $lockedClassId > 0,
+            'isLocked' => $isLocked,
+            'schoolYear' => $schoolYear,
+            'semester' => $semester,
+        ]);
+    }
+
+    public function save(Request $request, int $id): JsonResponse
+    {
+        $userId = (int) (auth()->id() ?? 0);
+        [$assignments] = $this->contextService->getTeacherContext($userId);
+        $allowedClassIds = $this->contextService->getAllowedClassIds($assignments);
+
+        if (empty($allowedClassIds)) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'No class assignments found for your account.',
+            ], 403);
+        }
+
+        $competition = Competition::query()->find($id);
+        if (!$competition) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'Competition not found.',
+            ], 404);
+        }
+
+        if ((bool) $competition->is_locked) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'Competition is locked. You cannot update scores.',
+            ], 423);
+        }
+
+        $lockedClassId = (int) ($competition->class_section_id ?? 0);
+        $classSectionId = $lockedClassId > 0 ? $lockedClassId : (int) $request->input('class_section_id', 0);
+
+        if ($classSectionId <= 0) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'Select a class section before saving scores.',
+            ], 422);
+        }
+
+        if (!in_array($classSectionId, $allowedClassIds, true)) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'You are not assigned to that class.',
+            ], 403);
+        }
+
+        $scores = $request->input('scores', []);
+        $scores = is_array($scores) ? $scores : [];
+        [$cleanScores, $invalidScores] = $this->saveService->filterScores($scores);
+
+        if (!empty($invalidScores)) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'Scores must be whole numbers (no decimals).',
+                'invalidScores' => $invalidScores,
+            ], 422);
+        }
+
+        $this->saveService->saveScores($id, $classSectionId, $cleanScores);
+
+        return response()->json([
+            'ok' => true,
+            'message' => 'Scores saved.',
+            'savedCount' => count($cleanScores),
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Discounts/DiscountController.php b/app/Http/Controllers/Api/Discounts/DiscountController.php
new file mode 100644
index 00000000..d7885a8d
--- /dev/null
+++ b/app/Http/Controllers/Api/Discounts/DiscountController.php
@@ -0,0 +1,107 @@
+<?php
+
+namespace App\Http\Controllers\Api\Discounts;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Discounts\ApplyDiscountVoucherRequest;
+use App\Http\Requests\Discounts\StoreDiscountVoucherRequest;
+use App\Http\Requests\Discounts\UpdateDiscountVoucherRequest;
+use App\Http\Resources\Discounts\DiscountParentResource;
+use App\Http\Resources\Discounts\DiscountVoucherResource;
+use App\Services\Discounts\DiscountApplyService;
+use App\Services\Discounts\DiscountContextService;
+use App\Services\Discounts\DiscountParentService;
+use App\Services\Discounts\DiscountVoucherService;
+use Illuminate\Http\JsonResponse;
+
+class DiscountController extends BaseApiController
+{
+    private DiscountContextService $context;
+    private DiscountVoucherService $voucherService;
+    private DiscountParentService $parentService;
+    private DiscountApplyService $applyService;
+
+    public function __construct(
+        DiscountContextService $context,
+        DiscountVoucherService $voucherService,
+        DiscountParentService $parentService,
+        DiscountApplyService $applyService
+    ) {
+        parent::__construct();
+        $this->context = $context;
+        $this->voucherService = $voucherService;
+        $this->parentService = $parentService;
+        $this->applyService = $applyService;
+    }
+
+    public function options(): JsonResponse
+    {
+        $schoolYear = $this->context->getSchoolYear();
+        $vouchers = $this->voucherService->listActive();
+        $parents = $this->parentService->listParentsWithDiscounts($schoolYear);
+
+        return response()->json([
+            'ok' => true,
+            'vouchers' => DiscountVoucherResource::collection($vouchers),
+            'parents' => DiscountParentResource::collection($parents),
+            'schoolYear' => $schoolYear,
+        ]);
+    }
+
+    public function apply(ApplyDiscountVoucherRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->applyService->applyVoucher(
+            (int) $payload['voucher_id'],
+            $payload['parent_ids'],
+            (bool) ($payload['allow_additional'] ?? false),
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json($result, $result['ok'] ? 200 : 422);
+    }
+
+    public function listVouchers(): JsonResponse
+    {
+        $vouchers = $this->voucherService->listAll();
+        return response()->json([
+            'ok' => true,
+            'vouchers' => DiscountVoucherResource::collection($vouchers),
+        ]);
+    }
+
+    public function storeVoucher(StoreDiscountVoucherRequest $request): JsonResponse
+    {
+        $voucher = $this->voucherService->create($request->validated());
+        return response()->json([
+            'ok' => true,
+            'voucher' => new DiscountVoucherResource($voucher),
+        ], 201);
+    }
+
+    public function updateVoucher(UpdateDiscountVoucherRequest $request, int $id): JsonResponse
+    {
+        $voucher = $this->voucherService->update($id, $request->validated());
+        return response()->json([
+            'ok' => true,
+            'voucher' => new DiscountVoucherResource($voucher),
+        ]);
+    }
+
+    public function showVoucher(int $id): JsonResponse
+    {
+        $voucher = $this->voucherService->find($id);
+        return response()->json([
+            'ok' => true,
+            'voucher' => new DiscountVoucherResource($voucher),
+        ]);
+    }
+
+    public function deleteVoucher(int $id): JsonResponse
+    {
+        $this->voucherService->delete($id);
+        return response()->json([
+            'ok' => true,
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Email/BroadcastEmailController.php b/app/Http/Controllers/Api/Email/BroadcastEmailController.php
new file mode 100644
index 00000000..16fd3d93
--- /dev/null
+++ b/app/Http/Controllers/Api/Email/BroadcastEmailController.php
@@ -0,0 +1,184 @@
+<?php
+
+namespace App\Http\Controllers\Api\Email;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Services\BroadcastEmail\BroadcastEmailComposerService;
+use App\Services\BroadcastEmail\BroadcastEmailDispatchService;
+use App\Services\BroadcastEmail\BroadcastEmailImageService;
+use App\Services\BroadcastEmail\BroadcastEmailRecipientService;
+use App\Services\BroadcastEmail\BroadcastEmailSenderOptionsService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class BroadcastEmailController extends BaseApiController
+{
+    private BroadcastEmailSenderOptionsService $senderOptions;
+    private BroadcastEmailRecipientService $recipients;
+    private BroadcastEmailComposerService $composer;
+    private BroadcastEmailDispatchService $dispatch;
+    private BroadcastEmailImageService $imageService;
+
+    public function __construct(
+        BroadcastEmailSenderOptionsService $senderOptions,
+        BroadcastEmailRecipientService $recipients,
+        BroadcastEmailComposerService $composer,
+        BroadcastEmailDispatchService $dispatch,
+        BroadcastEmailImageService $imageService
+    ) {
+        parent::__construct();
+        $this->senderOptions = $senderOptions;
+        $this->recipients = $recipients;
+        $this->composer = $composer;
+        $this->dispatch = $dispatch;
+        $this->imageService = $imageService;
+    }
+
+    public function options(): JsonResponse
+    {
+        return response()->json([
+            'ok' => true,
+            'parents' => $this->recipients->parentsWithEmails(),
+            'fromOptions' => $this->senderOptions->listOptions(),
+        ]);
+    }
+
+    public function send(Request $request): JsonResponse
+    {
+        $mode = (string) ($request->input('mode') ?? 'standard');
+        $subject = trim((string) ($request->input('subject') ?? ''));
+        $fromKey = trim((string) ($request->input('from_key') ?? 'general'));
+        $body = (string) ($request->input('body_html') ?? '');
+        $wrapLayout = (bool) $request->boolean('wrap_layout');
+        $preheader = (string) ($request->input('preheader') ?? '');
+        $ctaText = (string) ($request->input('cta_text') ?? '');
+        $ctaUrl = (string) ($request->input('cta_url') ?? '');
+        $testEmail = trim((string) ($request->input('test_email') ?? ''));
+        $isTestOnly = (bool) $request->boolean('send_test_only');
+
+        $body = $this->composer->sanitizeHtml($body);
+
+        if ($subject === '' || $body === '') {
+            return response()->json([
+                'ok' => false,
+                'message' => 'Subject and Body are required.',
+            ], 422);
+        }
+
+        $personalize = $mode === 'personalized';
+
+        if ($isTestOnly) {
+            if ($testEmail === '') {
+                return response()->json([
+                    'ok' => false,
+                    'message' => 'Provide a test email address.',
+                ], 422);
+            }
+
+            $result = $this->dispatch->sendTest([
+                'wrap_layout' => $wrapLayout,
+                'subject' => $subject,
+                'body_html' => $body,
+                'recipient_name' => 'Parent',
+                'preheader' => $preheader,
+                'cta_text' => $ctaText,
+                'cta_url' => $ctaUrl,
+                'personalize' => $personalize,
+                'test_email' => $testEmail,
+                'from_key' => $fromKey,
+            ]);
+
+            return response()->json($result, $result['ok'] ? 200 : 500);
+        }
+
+        $rawIds = $request->input('parent_ids', []);
+        $ids = $this->normalizeIds($rawIds);
+
+        if (empty($ids)) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'Please select at least one parent.',
+            ], 422);
+        }
+
+        $recipients = $this->recipients->recipientsByIds($ids);
+
+        if (empty($recipients)) {
+            return response()->json([
+                'ok' => false,
+                'message' => 'No valid parent emails found.',
+            ], 422);
+        }
+
+        $stats = $this->dispatch->sendBroadcast([
+            'wrap_layout' => $wrapLayout,
+            'subject' => $subject,
+            'body_html' => $body,
+            'preheader' => $preheader,
+            'cta_text' => $ctaText,
+            'cta_url' => $ctaUrl,
+            'personalize' => $personalize,
+            'from_key' => $fromKey,
+            'mode' => $mode,
+        ], $recipients);
+
+        $message = sprintf(
+            'Broadcast finished. Mode: %s. Sent: %d/%d. Failures: %d.',
+            $stats['mode'],
+            $stats['sent'],
+            $stats['attempted'],
+            $stats['failed']
+        );
+
+        return response()->json([
+            'ok' => $stats['failed'] === 0,
+            'stats' => $stats,
+            'message' => $message,
+        ]);
+    }
+
+    public function uploadImage(Request $request): JsonResponse
+    {
+        $file = $request->file('image');
+        if (!$file || !$file->isValid()) {
+            return response()->json([
+                'success' => false,
+                'error' => 'No image uploaded',
+            ], 400);
+        }
+
+        $result = $this->imageService->store($file);
+        if (!$result['ok']) {
+            return response()->json([
+                'success' => false,
+                'error' => $result['error'] ?? 'Upload failed',
+            ], $result['status'] ?? 400);
+        }
+
+        $newHash = function_exists('csrf_hash') ? csrf_hash() : csrf_token();
+
+        return response()->json([
+            'success' => true,
+            'url' => $result['url'],
+            'csrf_hash' => $newHash,
+        ])->header('X-CSRF-HASH', (string) $newHash);
+    }
+
+    private function normalizeIds($rawIds): array
+    {
+        $ids = [];
+        $raw = is_array($rawIds) ? $rawIds : [$rawIds];
+
+        foreach ($raw as $value) {
+            if (is_string($value) && strpos($value, ',') !== false) {
+                foreach (explode(',', $value) as $piece) {
+                    $ids[] = (int) $piece;
+                }
+                continue;
+            }
+            $ids[] = (int) $value;
+        }
+
+        return array_values(array_unique(array_filter($ids)));
+    }
+}
diff --git a/app/Http/Controllers/Api/Expenses/ExpenseController.php b/app/Http/Controllers/Api/Expenses/ExpenseController.php
new file mode 100644
index 00000000..726f5cb7
--- /dev/null
+++ b/app/Http/Controllers/Api/Expenses/ExpenseController.php
@@ -0,0 +1,180 @@
+<?php
+
+namespace App\Http\Controllers\Api\Expenses;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Expenses\StoreExpenseRequest;
+use App\Http\Requests\Expenses\UpdateExpenseRequest;
+use App\Http\Requests\Expenses\UpdateExpenseStatusRequest;
+use App\Http\Resources\Expenses\ExpenseResource;
+use App\Http\Resources\Expenses\ExpenseStaffResource;
+use App\Models\Expense;
+use App\Services\Expenses\ExpenseContextService;
+use App\Services\Expenses\ExpenseQueryService;
+use App\Services\Expenses\ExpenseReceiptService;
+use App\Services\Expenses\ExpenseRetailorService;
+use App\Services\Expenses\ExpenseStaffService;
+use App\Services\Expenses\ExpenseStatusService;
+use App\Services\Expenses\ExpenseWriteService;
+use Illuminate\Http\JsonResponse;
+
+class ExpenseController extends BaseApiController
+{
+    public function __construct(
+        private ExpenseContextService $context,
+        private ExpenseRetailorService $retailors,
+        private ExpenseStaffService $staff,
+        private ExpenseQueryService $queryService,
+        private ExpenseReceiptService $receiptService,
+        private ExpenseWriteService $writeService,
+        private ExpenseStatusService $statusService
+    ) {
+        parent::__construct();
+    }
+
+    public function options(): JsonResponse
+    {
+        $schoolYear = $this->context->getSchoolYear();
+        $semester = $this->context->getSemester();
+
+        return response()->json([
+            'ok' => true,
+            'schoolYear' => $schoolYear,
+            'semester' => $semester,
+            'retailors' => $this->retailors->listRetailors(),
+            'staff' => ExpenseStaffResource::collection($this->staff->listStaffUsers()),
+        ]);
+    }
+
+    public function index(): JsonResponse
+    {
+        $rows = $this->queryService->listAll();
+        $rows = array_map(function ($row) {
+            $row['receipt_url'] = $this->receiptService->receiptUrl($row['receipt_path'] ?? null);
+            return $row;
+        }, $rows);
+
+        return response()->json([
+            'ok' => true,
+            'expenses' => ExpenseResource::collection($rows),
+        ]);
+    }
+
+    public function show(int $id): JsonResponse
+    {
+        $row = $this->queryService->findById($id);
+        if (!$row) {
+            return response()->json(['ok' => false, 'message' => 'Expense not found.'], 404);
+        }
+
+        $row['receipt_url'] = $this->receiptService->receiptUrl($row['receipt_path'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'expense' => new ExpenseResource($row),
+        ]);
+    }
+
+    public function store(StoreExpenseRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $userId = (int) (auth()->id() ?? 0);
+
+        $receiptName = null;
+        if ($request->hasFile('receipt')) {
+            $receiptName = $this->receiptService->storeReceipt($request->file('receipt'));
+        }
+
+        $isDonation = $payload['category'] === 'Donation';
+
+        $expense = $this->writeService->store([
+            'category' => $payload['category'],
+            'amount' => $payload['amount'],
+            'receipt_path' => $receiptName,
+            'description' => $payload['description'] ?? null,
+            'retailor' => $payload['retailor'] ?? null,
+            'date_of_purchase' => $payload['date_of_purchase'],
+            'purchased_by' => (int) $payload['purchased_by'],
+            'added_by' => $userId,
+            'status' => $isDonation ? 'approved' : 'pending',
+            'status_reason' => $isDonation ? 'Marked as Donation (non-reimbursable).' : null,
+            'approved_by' => $isDonation ? $userId : null,
+            'school_year' => $payload['school_year'] ?? null,
+            'semester' => $payload['semester'] ?? null,
+        ]);
+
+        return response()->json([
+            'ok' => true,
+            'expense' => new ExpenseResource($expense->toArray()),
+        ], 201);
+    }
+
+    public function update(UpdateExpenseRequest $request, int $id): JsonResponse
+    {
+        $expense = Expense::query()->find($id);
+        if (!$expense) {
+            return response()->json(['ok' => false, 'message' => 'Expense not found.'], 404);
+        }
+
+        $payload = $request->validated();
+        $userId = (int) (auth()->id() ?? 0);
+
+        $receiptName = $expense->receipt_path;
+        if ($request->hasFile('receipt')) {
+            $receiptName = $this->receiptService->storeReceipt($request->file('receipt'));
+        }
+        if (!empty($payload['remove_receipt'])) {
+            $receiptName = null;
+        }
+
+        $category = $payload['category'];
+        $isDonation = $category === 'Donation';
+
+        $updateData = [
+            'category' => $category,
+            'amount' => $payload['amount'],
+            'description' => $payload['description'] ?? null,
+            'retailor' => $payload['retailor'] ?? null,
+            'date_of_purchase' => $payload['date_of_purchase'],
+            'purchased_by' => (int) $payload['purchased_by'],
+            'receipt_path' => $receiptName,
+            'updated_by' => $userId,
+        ];
+
+        if ($isDonation) {
+            $updateData['status'] = 'approved';
+            $updateData['status_reason'] = 'Marked as Donation (non-reimbursable).';
+            $updateData['approved_by'] = $userId ?: null;
+            $updateData['reimbursement_id'] = null;
+        } elseif (($expense->category ?? '') === 'Donation') {
+            $updateData['status_reason'] = null;
+            $updateData['approved_by'] = $expense->approved_by;
+            $updateData['status'] = $expense->status ?? 'pending';
+        }
+
+        $updated = $this->writeService->update($expense, $updateData);
+
+        return response()->json([
+            'ok' => true,
+            'expense' => new ExpenseResource($updated->toArray()),
+        ]);
+    }
+
+    public function updateStatus(UpdateExpenseStatusRequest $request, int $id): JsonResponse
+    {
+        $expense = Expense::query()->find($id);
+        if (!$expense) {
+            return response()->json(['ok' => false, 'message' => 'Expense not found.'], 404);
+        }
+
+        $payload = $request->validated();
+        $userId = (int) (auth()->id() ?? 0);
+
+        $updated = $this->statusService->updateStatus($expense, $payload['status'], $payload['reason'] ?? '', $userId);
+
+        return response()->json([
+            'ok' => true,
+            'expense' => new ExpenseResource($updated->toArray()),
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/ExtraCharges/ExtraChargesController.php b/app/Http/Controllers/Api/ExtraCharges/ExtraChargesController.php
new file mode 100644
index 00000000..a9126454
--- /dev/null
+++ b/app/Http/Controllers/Api/ExtraCharges/ExtraChargesController.php
@@ -0,0 +1,143 @@
+<?php
+
+namespace App\Http\Controllers\Api\ExtraCharges;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\ExtraCharges\StoreExtraChargeRequest;
+use App\Http\Requests\ExtraCharges\UpdateExtraChargeRequest;
+use App\Http\Resources\ExtraCharges\ExtraChargeInvoiceOptionResource;
+use App\Http\Resources\ExtraCharges\ExtraChargeParentOptionResource;
+use App\Http\Resources\ExtraCharges\ExtraChargeResource;
+use App\Models\AdditionalCharge;
+use App\Services\ExtraCharges\ExtraChargesChargeService;
+use App\Services\ExtraCharges\ExtraChargesContextService;
+use App\Services\ExtraCharges\ExtraChargesInvoiceService;
+use App\Services\ExtraCharges\ExtraChargesListService;
+use App\Services\ExtraCharges\ExtraChargesMetaService;
+use App\Services\ExtraCharges\ExtraChargesParentService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class ExtraChargesController extends BaseApiController
+{
+    public function __construct(
+        private ExtraChargesContextService $context,
+        private ExtraChargesMetaService $meta,
+        private ExtraChargesParentService $parents,
+        private ExtraChargesInvoiceService $invoices,
+        private ExtraChargesListService $listService,
+        private ExtraChargesChargeService $chargeService
+    ) {
+        parent::__construct();
+    }
+
+    public function list(Request $request): JsonResponse
+    {
+        $year = (string) ($request->query('school_year') ?? $this->context->getSchoolYear());
+        $sem = (string) ($request->query('semester') ?? $this->context->getSemester());
+        $status = $request->query('status') ?: null;
+        $q = trim((string) ($request->query('q') ?? '')) ?: null;
+        $per = (int) ($request->query('per_page') ?? 50);
+
+        [$rows, $meta] = $this->listService->listForTerm($year, $sem, $status, $q, $per);
+
+        return response()->json([
+            'ok' => true,
+            'school_year' => $year,
+            'semester' => $sem,
+            'rows' => ExtraChargeResource::collection($rows),
+            'pager' => $meta,
+        ]);
+    }
+
+    public function options(Request $request): JsonResponse
+    {
+        $q = trim((string) ($request->query('q') ?? ''));
+        $parentOptions = $this->parents->searchParents($q);
+
+        return response()->json([
+            'ok' => true,
+            'schoolYear' => $this->context->getSchoolYear(),
+            'semester' => $this->context->getSemester(),
+            'schoolYears' => $this->meta->getSchoolYears($this->context->getSchoolYear()),
+            'parents' => ExtraChargeParentOptionResource::collection($parentOptions),
+        ]);
+    }
+
+    public function parentOptions(Request $request): JsonResponse
+    {
+        $q = trim((string) ($request->query('q') ?? ''));
+        $parentOptions = $this->parents->searchParents($q);
+
+        return response()->json([
+            'results' => ExtraChargeParentOptionResource::collection($parentOptions),
+        ]);
+    }
+
+    public function invoicesForParent(Request $request): JsonResponse
+    {
+        $parentId = (int) ($request->query('parent_id') ?? 0);
+        $schoolYear = (string) ($request->query('school_year') ?? $this->context->getSchoolYear());
+        $rows = $this->invoices->listInvoicesForParent($parentId, $schoolYear);
+
+        return response()->json([
+            'results' => ExtraChargeInvoiceOptionResource::collection($rows),
+        ]);
+    }
+
+    public function store(StoreExtraChargeRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $payload['created_by'] = (int) (auth()->id() ?? 0);
+
+        $result = $this->chargeService->createCharge($payload);
+
+        return response()->json($result, $result['ok'] ? 201 : 422);
+    }
+
+    public function update(UpdateExtraChargeRequest $request, int $id): JsonResponse
+    {
+        $charge = AdditionalCharge::query()->find($id);
+        if (!$charge) {
+            return response()->json(['ok' => false, 'error' => 'Charge not found'], 404);
+        }
+
+        $payload = $request->validated();
+        $payload['updated_by'] = (int) (auth()->id() ?? 0);
+
+        $ok = $this->chargeService->updateCharge($charge, $payload);
+
+        return response()->json([
+            'ok' => $ok,
+            'id' => $id,
+        ], $ok ? 200 : 422);
+    }
+
+    public function void(int $id): JsonResponse
+    {
+        $charge = AdditionalCharge::query()->find($id);
+        if (!$charge) {
+            return response()->json(['ok' => false, 'error' => 'Charge not found'], 404);
+        }
+
+        $ok = $this->chargeService->voidCharge($charge);
+
+        return response()->json([
+            'ok' => $ok,
+        ], $ok ? 200 : 422);
+    }
+
+    public function reverse(int $id): JsonResponse
+    {
+        $charge = AdditionalCharge::query()->find($id);
+        if (!$charge) {
+            return response()->json(['ok' => false, 'error' => 'Charge not found'], 404);
+        }
+
+        $ok = $this->chargeService->reverseCharge($charge);
+
+        return response()->json([
+            'ok' => $ok,
+        ], $ok ? 200 : 422);
+    }
+}
diff --git a/app/Http/Controllers/Api/Finance/FinancialController.php b/app/Http/Controllers/Api/Finance/FinancialController.php
new file mode 100644
index 00000000..45d84525
--- /dev/null
+++ b/app/Http/Controllers/Api/Finance/FinancialController.php
@@ -0,0 +1,218 @@
+<?php
+
+namespace App\Http\Controllers\Api\Finance;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Finance\FinancialReportRequest;
+use App\Http\Requests\Finance\FinancialSummaryRequest;
+use App\Http\Requests\Finance\FinancialUnpaidParentsRequest;
+use App\Http\Resources\Finance\FinancialReportResource;
+use App\Http\Resources\Finance\FinancialSummaryResource;
+use App\Http\Resources\Finance\FinancialUnpaidParentResource;
+use App\Services\Finance\FinancialPdfReportService;
+use App\Services\Finance\FinancialReportService;
+use App\Services\Finance\FinancialSchoolYearService;
+use App\Services\Finance\FinancialSummaryService;
+use App\Services\Finance\FinancialUnpaidParentsService;
+use Illuminate\Http\JsonResponse;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+
+class FinancialController extends BaseApiController
+{
+    public function __construct(
+        private FinancialReportService $reportService,
+        private FinancialSummaryService $summaryService,
+        private FinancialUnpaidParentsService $unpaidParentsService,
+        private FinancialSchoolYearService $schoolYears,
+        private FinancialPdfReportService $pdfService
+    ) {
+        parent::__construct();
+    }
+
+    public function report(FinancialReportRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $report = $this->reportService->getReport(
+            $payload['date_from'] ?? null,
+            $payload['date_to'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        return response()->json([
+            'ok' => true,
+            'report' => new FinancialReportResource($report),
+        ]);
+    }
+
+    public function summary(FinancialSummaryRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $summary = $this->summaryService->getSummary(
+            $payload['date_from'] ?? null,
+            $payload['date_to'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        $schoolYears = $this->schoolYears->listYears($summary['schoolYear'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'summary' => new FinancialSummaryResource($summary),
+            'schoolYears' => $schoolYears,
+        ]);
+    }
+
+    public function unpaidParents(FinancialUnpaidParentsRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->unpaidParentsService->getUnpaidParents($payload['school_year'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'schoolYear' => $data['schoolYear'] ?? null,
+            'schoolYears' => $data['schoolYears'] ?? [],
+            'results' => FinancialUnpaidParentResource::collection($data['results'] ?? []),
+        ]);
+    }
+
+    public function downloadCsv(FinancialReportRequest $request): StreamedResponse
+    {
+        $payload = $request->validated();
+        $report = $this->reportService->getReport(
+            $payload['date_from'] ?? null,
+            $payload['date_to'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        $paymentsMap = [];
+        foreach ($report['payments'] as $payment) {
+            $invoiceId = (int) ($payment['invoice_id'] ?? 0);
+            $paymentsMap[$invoiceId] = (float) ($payment['paid_amount'] ?? 0);
+        }
+
+        $refundsMap = [];
+        foreach ($report['refunds'] as $refund) {
+            $invoiceId = (int) ($refund['invoice_id'] ?? 0);
+            $refundsMap[$invoiceId] = (float) ($refund['total_refunded'] ?? 0);
+        }
+
+        $discountsMap = [];
+        foreach ($report['discounts'] as $discount) {
+            $invoiceId = (int) ($discount['invoice_id'] ?? 0);
+            $discountsMap[$invoiceId] = (float) ($discount['discount_amount'] ?? 0);
+        }
+
+        $breakdown = $report['paymentBreakdown'] ?? [];
+
+        $filename = 'financial_report_' . date('Ymd_His') . '.csv';
+
+        return response()->streamDownload(function () use ($report, $paymentsMap, $refundsMap, $discountsMap, $breakdown) {
+            $out = fopen('php://output', 'w');
+
+            fputcsv($out, ['Invoice #', 'Parent', 'School Year', 'Total', 'Paid', 'Cash', 'Credit', 'Check', 'Balance', 'Refund', 'Discount', 'Status']);
+            $sumTotal = 0.0;
+            $sumPaid = 0.0;
+            $sumCash = 0.0;
+            $sumCredit = 0.0;
+            $sumCheck = 0.0;
+            $sumBalance = 0.0;
+            $sumRefund = 0.0;
+            $sumDiscount = 0.0;
+
+            foreach ($report['invoices'] as $inv) {
+                $invoiceId = (int) ($inv['id'] ?? 0);
+                $paid = (float) ($paymentsMap[$invoiceId] ?? 0);
+                $bd = $breakdown[$invoiceId] ?? [];
+                $cash = (float) ($bd['cash'] ?? 0);
+                $credit = (float) ($bd['credit'] ?? 0);
+                $check = (float) ($bd['check'] ?? 0);
+                $refunded = (float) ($refundsMap[$invoiceId] ?? 0);
+                $discount = (float) ($discountsMap[$invoiceId] ?? 0);
+                $total = (float) ($inv['total_amount'] ?? 0);
+                $balance = $total - $paid - $discount - $refunded;
+                if ($balance < 0) {
+                    $balance = 0.0;
+                }
+                $status = $balance === 0.0 ? 'Paid' : 'Unpaid';
+
+                fputcsv($out, [
+                    $inv['invoice_number'] ?? '',
+                    $inv['parent_name'] ?? '',
+                    $inv['school_year'] ?? '',
+                    $total,
+                    $paid,
+                    $cash,
+                    $credit,
+                    $check,
+                    $balance,
+                    $refunded,
+                    $discount,
+                    $status,
+                ]);
+
+                $sumTotal += $total;
+                $sumPaid += $paid;
+                $sumCash += $cash;
+                $sumCredit += $credit;
+                $sumCheck += $check;
+                $sumBalance += $balance;
+                $sumRefund += $refunded;
+                $sumDiscount += $discount;
+            }
+
+            fputcsv($out, [
+                'TOTALS',
+                '',
+                '',
+                $sumTotal,
+                $sumPaid,
+                $sumCash,
+                $sumCredit,
+                $sumCheck,
+                $sumBalance,
+                $sumRefund,
+                $sumDiscount,
+                '',
+            ]);
+
+            fputcsv($out, []);
+            fputcsv($out, ['Expenses Summary']);
+            fputcsv($out, ['Category', 'Total Amount']);
+            foreach ($report['expenses'] as $exp) {
+                fputcsv($out, [
+                    $exp['category'] ?? '',
+                    $exp['total_amount'] ?? 0,
+                ]);
+            }
+
+            fputcsv($out, []);
+            fputcsv($out, ['Reimbursements Summary']);
+            fputcsv($out, ['Status', 'Total Amount']);
+            foreach ($report['reimbursements'] as $row) {
+                fputcsv($out, [
+                    $row['status'] ?? '',
+                    $row['total_amount'] ?? 0,
+                ]);
+            }
+
+            fclose($out);
+        }, $filename, ['Content-Type' => 'text/csv']);
+    }
+
+    public function downloadPdf(FinancialReportRequest $request): StreamedResponse
+    {
+        $payload = $request->validated();
+        $summary = $this->summaryService->getSummary(
+            $payload['date_from'] ?? null,
+            $payload['date_to'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        $pdfBytes = $this->pdfService->buildPdf($summary);
+        $schoolYear = $summary['schoolYear'] ?? 'report';
+
+        return response()->streamDownload(function () use ($pdfBytes) {
+            echo $pdfBytes;
+        }, 'Financial_Report_' . $schoolYear . '.pdf', ['Content-Type' => 'application/pdf']);
+    }
+}
diff --git a/app/Http/Controllers/Api/Finance/InvoiceController.php b/app/Http/Controllers/Api/Finance/InvoiceController.php
new file mode 100644
index 00000000..944187af
--- /dev/null
+++ b/app/Http/Controllers/Api/Finance/InvoiceController.php
@@ -0,0 +1,125 @@
+<?php
+
+namespace App\Http\Controllers\Api\Finance;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Invoices\InvoiceGenerateRequest;
+use App\Http\Requests\Invoices\InvoiceManagementRequest;
+use App\Http\Requests\Invoices\InvoiceParentRequest;
+use App\Http\Requests\Invoices\InvoiceStatusRequest;
+use App\Http\Resources\Invoices\InvoiceManagementParentResource;
+use App\Http\Resources\Invoices\InvoiceResource;
+use App\Models\Invoice;
+use App\Services\Invoices\InvoiceGenerationService;
+use App\Services\Invoices\InvoiceManagementService;
+use App\Services\Invoices\InvoicePaymentService;
+use App\Services\Invoices\InvoicePdfService;
+use Illuminate\Http\JsonResponse;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+
+class InvoiceController extends BaseApiController
+{
+    public function __construct(
+        private InvoiceManagementService $management,
+        private InvoiceGenerationService $generation,
+        private InvoicePaymentService $paymentService,
+        private InvoicePdfService $pdfService
+    ) {
+        parent::__construct();
+    }
+
+    public function management(InvoiceManagementRequest $request): JsonResponse
+    {
+        $schoolYear = $request->validated()['school_year'] ?? null;
+        $schoolYear = $schoolYear ?: $request->input('schoolYear');
+        $schoolYear = $schoolYear ?: $request->input('year');
+
+        $data = $this->management->getManagementData($schoolYear);
+
+        return response()->json([
+            'ok' => true,
+            'schoolYear' => $data['schoolYear'],
+            'schoolYears' => $data['schoolYears'],
+            'invoices' => InvoiceManagementParentResource::collection($data['invoices']),
+        ]);
+    }
+
+    public function generate(InvoiceGenerateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->generation->generateInvoice((int) $payload['parent_id'], $payload['school_year'] ?? null);
+
+        if (empty($result['ok'])) {
+            return response()->json(['ok' => false, 'message' => $result['message'] ?? 'Unable to generate invoice.'], 422);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'updated' => $result['updated'] ?? false,
+            'updated_ids' => $result['updated_ids'] ?? [],
+            'insert_id' => $result['insert_id'] ?? null,
+        ]);
+    }
+
+    public function byParent(InvoiceParentRequest $request, int $parentId): JsonResponse
+    {
+        $schoolYear = $request->validated()['school_year'] ?? null;
+        $invoices = Invoice::getInvoicesByParentId($parentId, $schoolYear);
+
+        return response()->json([
+            'ok' => true,
+            'invoices' => InvoiceResource::collection($invoices),
+        ]);
+    }
+
+    public function parentPayment(InvoiceParentRequest $request): JsonResponse
+    {
+        $parentId = (int) (auth()->id() ?? 0);
+        if ($parentId <= 0) {
+            return response()->json(['ok' => false, 'message' => 'Unauthorized.'], 401);
+        }
+
+        $schoolYear = $request->validated()['school_year'] ?? null;
+        $data = $this->paymentService->getParentInvoiceSummary($parentId, $schoolYear);
+
+        return response()->json([
+            'ok' => true,
+            'invoices' => InvoiceResource::collection($data['invoices']),
+            'schoolYears' => $data['schoolYears'],
+            'selectedYear' => $data['selectedYear'],
+            'currentSchoolYear' => $data['currentSchoolYear'],
+            'dueDate' => $data['dueDate'],
+        ]);
+    }
+
+    public function updateStatus(InvoiceStatusRequest $request, int $invoiceId): JsonResponse
+    {
+        $status = $request->validated()['status'];
+        $updated = Invoice::updateInvoiceStatus($invoiceId, $status);
+
+        if (!$updated) {
+            return response()->json(['ok' => false, 'message' => 'Invoice not found.'], 404);
+        }
+
+        return response()->json(['ok' => true, 'status' => $status]);
+    }
+
+    public function unpaid(): JsonResponse
+    {
+        $rows = Invoice::getUnpaidInvoices();
+
+        return response()->json([
+            'ok' => true,
+            'invoices' => InvoiceResource::collection($rows),
+        ]);
+    }
+
+    public function pdf(int $invoiceId): StreamedResponse
+    {
+        $pdfBytes = $this->pdfService->buildPdf($invoiceId);
+
+        return response()->streamDownload(function () use ($pdfBytes) {
+            echo $pdfBytes;
+        }, 'invoice_' . $invoiceId . '.pdf', ['Content-Type' => 'application/pdf']);
+    }
+}
diff --git a/app/Http/Controllers/Api/Finance/PaymentController.php b/app/Http/Controllers/Api/Finance/PaymentController.php
new file mode 100644
index 00000000..8b044593
--- /dev/null
+++ b/app/Http/Controllers/Api/Finance/PaymentController.php
@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Http\Controllers\Api\Finance;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Payments\PaymentByParentRequest;
+use App\Http\Requests\Payments\PaymentCreateRequest;
+use App\Http\Requests\Payments\PaymentUpdateBalanceRequest;
+use App\Http\Resources\Payments\PaymentResource;
+use App\Services\Payments\PaymentBalanceService;
+use App\Services\Payments\PaymentLookupService;
+use App\Services\Payments\PaymentPlanService;
+use Illuminate\Http\JsonResponse;
+
+class PaymentController extends BaseApiController
+{
+    public function __construct(
+        private PaymentPlanService $planService,
+        private PaymentLookupService $lookupService,
+        private PaymentBalanceService $balanceService
+    ) {
+        parent::__construct();
+    }
+
+    public function store(PaymentCreateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $payment = $this->planService->createPlan($payload);
+
+        return response()->json([
+            'ok' => true,
+            'payment' => new PaymentResource($payment),
+        ], 201);
+    }
+
+    public function byParent(PaymentByParentRequest $request, int $parentId): JsonResponse
+    {
+        $payload = $request->validated();
+        $payments = $this->lookupService->getByParent($parentId, $payload['school_year'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'payments' => PaymentResource::collection($payments),
+        ]);
+    }
+
+    public function updateBalance(PaymentUpdateBalanceRequest $request, int $paymentId): JsonResponse
+    {
+        $payload = $request->validated();
+        $updated = $this->balanceService->updateBalance($paymentId, (float) $payload['paid_amount']);
+
+        if (!$updated) {
+            return response()->json(['ok' => false, 'message' => 'Payment not found.'], 404);
+        }
+
+        return response()->json(['ok' => true]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Finance/PaymentEventChargesController.php b/app/Http/Controllers/Api/Finance/PaymentEventChargesController.php
new file mode 100644
index 00000000..fa6dafd9
--- /dev/null
+++ b/app/Http/Controllers/Api/Finance/PaymentEventChargesController.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Http\Controllers\Api\Finance;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Payments\PaymentEventChargesListRequest;
+use App\Http\Requests\Payments\PaymentEventChargesStoreRequest;
+use App\Services\Payments\PaymentEventChargesService;
+use Illuminate\Http\JsonResponse;
+
+class PaymentEventChargesController extends BaseApiController
+{
+    public function __construct(private PaymentEventChargesService $service)
+    {
+        parent::__construct();
+    }
+
+    public function index(PaymentEventChargesListRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->listCharges($payload['school_year'] ?? null, $payload['semester'] ?? null);
+
+        return response()->json(['ok' => true] + $data);
+    }
+
+    public function store(PaymentEventChargesStoreRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $userId = (int) (auth()->id() ?? 0);
+
+        $count = $this->service->addCharges($payload, $userId);
+        if ($count === 0) {
+            return response()->json(['ok' => false, 'message' => 'No student selected.'], 422);
+        }
+
+        return response()->json(['ok' => true, 'inserted' => $count]);
+    }
+
+    public function enrolledStudents(PaymentEventChargesListRequest $request, int $parentId): JsonResponse
+    {
+        $payload = $request->validated();
+        $students = $this->service->getEnrolledStudents($parentId, $payload['school_year'] ?? null);
+
+        return response()->json(['ok' => true, 'students' => $students]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Finance/PaymentManualController.php b/app/Http/Controllers/Api/Finance/PaymentManualController.php
new file mode 100644
index 00000000..5cd5f466
--- /dev/null
+++ b/app/Http/Controllers/Api/Finance/PaymentManualController.php
@@ -0,0 +1,81 @@
+<?php
+
+namespace App\Http\Controllers\Api\Finance;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Payments\PaymentManualEditRequest;
+use App\Http\Requests\Payments\PaymentManualSearchRequest;
+use App\Http\Requests\Payments\PaymentManualSuggestRequest;
+use App\Http\Requests\Payments\PaymentManualUpdateRequest;
+use App\Services\Payments\PaymentManualService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+
+class PaymentManualController extends BaseApiController
+{
+    public function __construct(private PaymentManualService $service)
+    {
+        parent::__construct();
+    }
+
+    public function search(PaymentManualSearchRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->search(
+            (string) ($payload['search_term'] ?? ''),
+            $payload['school_year'] ?? null
+        );
+
+        return response()->json(['ok' => true] + $data);
+    }
+
+    public function suggest(PaymentManualSuggestRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $items = $this->service->suggest((string) ($payload['q'] ?? ''));
+
+        return response()->json(['ok' => true, 'items' => $items]);
+    }
+
+    public function record(PaymentManualUpdateRequest $request, int $invoiceId): JsonResponse
+    {
+        $payload = $request->validated();
+
+        $result = $this->service->recordPayment(
+            $invoiceId,
+            (float) $payload['amount'],
+            (string) $payload['payment_method'],
+            $payload['payment_date'] ?? null,
+            $payload['check_number'] ?? null,
+            $payload['payment_type'] ?? null,
+            $request->file('payment_file'),
+            $payload['school_year'] ?? null,
+            $payload['semester'] ?? null,
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true] + $result);
+    }
+
+    public function edit(PaymentManualEditRequest $request, int $paymentId): JsonResponse
+    {
+        $payload = $request->validated();
+
+        $this->service->editPayment(
+            $paymentId,
+            (float) $payload['paid_amount'],
+            (string) $payload['payment_method'],
+            $payload['check_number'] ?? null,
+            $request->file('payment_file'),
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function file(Request $request, string $filename)
+    {
+        $mode = (string) ($request->query('mode') ?? 'download');
+        return $this->service->serveCheckFile($filename, $mode);
+    }
+}
diff --git a/app/Http/Controllers/Api/Finance/PaymentNotificationController.php b/app/Http/Controllers/Api/Finance/PaymentNotificationController.php
new file mode 100644
index 00000000..206f97dc
--- /dev/null
+++ b/app/Http/Controllers/Api/Finance/PaymentNotificationController.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Http\Controllers\Api\Finance;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Payments\PaymentNotificationListRequest;
+use App\Http\Requests\Payments\PaymentNotificationSendRequest;
+use App\Http\Resources\Payments\PaymentNotificationLogResource;
+use App\Services\Payments\PaymentNotificationService;
+use Illuminate\Http\JsonResponse;
+
+class PaymentNotificationController extends BaseApiController
+{
+    public function __construct(private PaymentNotificationService $service)
+    {
+        parent::__construct();
+    }
+
+    public function index(PaymentNotificationListRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $logs = $this->service->listLogs(
+            $payload['from'] ?? null,
+            $payload['to'] ?? null,
+            $payload['type'] ?? null
+        );
+
+        return response()->json([
+            'ok' => true,
+            'logs' => PaymentNotificationLogResource::collection($logs),
+        ]);
+    }
+
+    public function send(PaymentNotificationSendRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->service->send($payload);
+
+        return response()->json(['ok' => true] + $result);
+    }
+}
diff --git a/app/Http/Controllers/Api/Finance/PaymentTransactionController.php b/app/Http/Controllers/Api/Finance/PaymentTransactionController.php
new file mode 100644
index 00000000..80954c58
--- /dev/null
+++ b/app/Http/Controllers/Api/Finance/PaymentTransactionController.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Http\Controllers\Api\Finance;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Payments\PaymentTransactionCreateRequest;
+use App\Http\Requests\Payments\PaymentTransactionStatusRequest;
+use App\Http\Resources\Payments\PaymentTransactionResource;
+use App\Services\Payments\PaymentTransactionService;
+use Illuminate\Http\JsonResponse;
+
+class PaymentTransactionController extends BaseApiController
+{
+    public function __construct(private PaymentTransactionService $service)
+    {
+        parent::__construct();
+    }
+
+    public function store(PaymentTransactionCreateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $transaction = $this->service->create($payload);
+
+        return response()->json([
+            'ok' => true,
+            'transaction' => new PaymentTransactionResource($transaction->toArray()),
+        ], 201);
+    }
+
+    public function byPayment(int $paymentId): JsonResponse
+    {
+        $transactions = $this->service->getByPayment($paymentId);
+
+        return response()->json([
+            'ok' => true,
+            'transactions' => PaymentTransactionResource::collection($transactions),
+        ]);
+    }
+
+    public function updateStatus(PaymentTransactionStatusRequest $request, string $transactionId): JsonResponse
+    {
+        $payload = $request->validated();
+        $updated = $this->service->updateStatus($transactionId, $payload['status']);
+
+        if (!$updated) {
+            return response()->json(['ok' => false, 'message' => 'Transaction not found.'], 404);
+        }
+
+        return response()->json(['ok' => true]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Finance/PaypalPaymentController.php b/app/Http/Controllers/Api/Finance/PaypalPaymentController.php
new file mode 100644
index 00000000..cfaf9530
--- /dev/null
+++ b/app/Http/Controllers/Api/Finance/PaypalPaymentController.php
@@ -0,0 +1,52 @@
+<?php
+
+namespace App\Http\Controllers\Api\Finance;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Payments\PaypalExecuteRequest;
+use App\Services\Payments\PaypalPaymentService;
+use Illuminate\Http\JsonResponse;
+
+class PaypalPaymentController extends BaseApiController
+{
+    public function __construct(private PaypalPaymentService $service)
+    {
+        parent::__construct();
+    }
+
+    public function redirect(): JsonResponse
+    {
+        return response()->json([
+            'ok' => true,
+            'redirect_url' => $this->service->getRedirectUrl(),
+        ]);
+    }
+
+    public function create(int $paymentId): JsonResponse
+    {
+        $result = $this->service->createPayment($paymentId);
+
+        return response()->json(['ok' => true] + $result);
+    }
+
+    public function execute(PaypalExecuteRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $this->service->executePayment(
+            (string) $payload['payer_id'],
+            $payload['paypal_payment_id'] ?? null
+        );
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function cancel(): JsonResponse
+    {
+        $this->service->cancelPayment();
+
+        return response()->json([
+            'ok' => true,
+            'message' => 'Payment was canceled.',
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Finance/PaypalTransactionsController.php b/app/Http/Controllers/Api/Finance/PaypalTransactionsController.php
new file mode 100644
index 00000000..46764bbf
--- /dev/null
+++ b/app/Http/Controllers/Api/Finance/PaypalTransactionsController.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace App\Http\Controllers\Api\Finance;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Payments\PaypalTransactionsListRequest;
+use App\Http\Resources\Payments\PaypalTransactionResource;
+use App\Services\Payments\PaypalTransactionsService;
+use Illuminate\Http\JsonResponse;
+use Symfony\Component\HttpFoundation\StreamedResponse;
+
+class PaypalTransactionsController extends BaseApiController
+{
+    public function __construct(private PaypalTransactionsService $service)
+    {
+        parent::__construct();
+    }
+
+    public function index(PaypalTransactionsListRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $perPage = (int) ($payload['per_page'] ?? 10);
+        $rows = $this->service->list($payload['q'] ?? null, $perPage);
+
+        return response()->json([
+            'ok' => true,
+            'transactions' => PaypalTransactionResource::collection($rows->items()),
+            'pagination' => [
+                'current_page' => $rows->currentPage(),
+                'per_page' => $rows->perPage(),
+                'total' => $rows->total(),
+                'last_page' => $rows->lastPage(),
+            ],
+        ]);
+    }
+
+    public function downloadCsv(PaypalTransactionsListRequest $request): StreamedResponse
+    {
+        $payload = $request->validated();
+        $rows = $this->service->listAll($payload['q'] ?? null);
+
+        $filename = 'paypal_transactions_' . date('Ymd_His') . '.csv';
+
+        return response()->streamDownload(function () use ($rows) {
+            $out = fopen('php://output', 'w');
+            fputcsv($out, [
+                'ID', 'Transaction ID', 'Order ID', 'Parent School ID',
+                'Email', 'Amount', 'Net Amount', 'Currency',
+                'Status', 'Event Type', 'Created At',
+            ]);
+
+            foreach ($rows as $row) {
+                fputcsv($out, [
+                    $row['id'] ?? null,
+                    $row['transaction_id'] ?? null,
+                    $row['order_id'] ?? null,
+                    $row['parent_school_id'] ?? null,
+                    $row['payer_email'] ?? null,
+                    $row['amount'] ?? null,
+                    $row['net_amount'] ?? null,
+                    $row['currency'] ?? null,
+                    $row['status'] ?? null,
+                    $row['event_type'] ?? null,
+                    $row['created_at'] ?? null,
+                ]);
+            }
+
+            fclose($out);
+        }, $filename, ['Content-Type' => 'text/csv']);
+    }
+}
diff --git a/app/Http/Controllers/Api/Finance/ReimbursementController.php b/app/Http/Controllers/Api/Finance/ReimbursementController.php
new file mode 100644
index 00000000..4a173cb6
--- /dev/null
+++ b/app/Http/Controllers/Api/Finance/ReimbursementController.php
@@ -0,0 +1,391 @@
+<?php
+
+namespace App\Http\Controllers\Api\Finance;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Files\FileNameRequest;
+use App\Http\Requests\Reimbursements\ReimbursementBatchAdminFileRequest;
+use App\Http\Requests\Reimbursements\ReimbursementBatchAssignmentRequest;
+use App\Http\Requests\Reimbursements\ReimbursementBatchCreateRequest;
+use App\Http\Requests\Reimbursements\ReimbursementBatchEmailRequest;
+use App\Http\Requests\Reimbursements\ReimbursementBatchLockRequest;
+use App\Http\Requests\Reimbursements\ReimbursementExportBatchRequest;
+use App\Http\Requests\Reimbursements\ReimbursementExportRequest;
+use App\Http\Requests\Reimbursements\ReimbursementIndexRequest;
+use App\Http\Requests\Reimbursements\ReimbursementMarkDonationRequest;
+use App\Http\Requests\Reimbursements\ReimbursementProcessRequest;
+use App\Http\Requests\Reimbursements\ReimbursementStoreRequest;
+use App\Http\Requests\Reimbursements\ReimbursementUnderProcessingRequest;
+use App\Http\Requests\Reimbursements\ReimbursementUpdateRequest;
+use App\Http\Resources\Reimbursements\ReimbursementBatchResource;
+use App\Http\Resources\Reimbursements\ReimbursementExpenseResource;
+use App\Http\Resources\Reimbursements\ReimbursementRecipientResource;
+use App\Http\Resources\Reimbursements\ReimbursementResource;
+use App\Http\Resources\Reimbursements\ReimbursementUnderProcessingItemResource;
+use App\Models\Reimbursement;
+use App\Models\ReimbursementBatch;
+use App\Services\Files\FileServeService;
+use App\Services\Reimbursements\ReimbursementBatchAssignmentService;
+use App\Services\Reimbursements\ReimbursementBatchService;
+use App\Services\Reimbursements\ReimbursementContextService;
+use App\Services\Reimbursements\ReimbursementCrudService;
+use App\Services\Reimbursements\ReimbursementDonationService;
+use App\Services\Reimbursements\ReimbursementEmailService;
+use App\Services\Reimbursements\ReimbursementExportService;
+use App\Services\Reimbursements\ReimbursementFileService;
+use App\Services\Reimbursements\ReimbursementQueryService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use RuntimeException;
+
+class ReimbursementController extends BaseApiController
+{
+    public function __construct(
+        private ReimbursementContextService $context,
+        private ReimbursementQueryService $queryService,
+        private ReimbursementDonationService $donationService,
+        private ReimbursementBatchService $batchService,
+        private ReimbursementBatchAssignmentService $assignmentService,
+        private ReimbursementFileService $fileService,
+        private ReimbursementExportService $exportService,
+        private ReimbursementEmailService $emailService,
+        private ReimbursementCrudService $crudService,
+        private FileServeService $fileServeService
+    ) {
+        parent::__construct();
+    }
+
+    public function underProcessing(ReimbursementUnderProcessingRequest $request): JsonResponse
+    {
+        $data = $this->queryService->underProcessing();
+
+        return response()->json([
+            'ok' => true,
+            'pendingItems' => ReimbursementUnderProcessingItemResource::collection($data['pendingItems'] ?? []),
+            'existingBatches' => ReimbursementBatchResource::collection($data['existingBatches'] ?? []),
+            'adminUsers' => ReimbursementRecipientResource::collection($data['adminUsers'] ?? []),
+            'itemsPayload' => ReimbursementUnderProcessingItemResource::collection($data['itemsPayload'] ?? []),
+        ]);
+    }
+
+    public function markDonation(ReimbursementMarkDonationRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $userId = (int) (auth()->id() ?? 0);
+
+        try {
+            $this->donationService->markDonation((int) $payload['expense_id'], $userId);
+        } catch (RuntimeException $e) {
+            $message = $e->getMessage();
+            $status = str_contains($message, 'not found') ? 404 : (str_contains($message, 'already') ? 409 : 422);
+            return response()->json(['ok' => false, 'message' => $message], $status);
+        } catch (\Throwable $e) {
+            return response()->json(['ok' => false, 'message' => 'Unable to mark donation right now.'], 500);
+        }
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function createBatch(ReimbursementBatchCreateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $userId = (int) (auth()->id() ?? 0);
+        $schoolYear = $this->context->getSchoolYear();
+        $semester = $this->context->getSemester();
+
+        $batch = $this->batchService->createBatch($payload['title'] ?? null, $userId, $schoolYear, $semester);
+
+        return response()->json([
+            'ok' => true,
+            'batch' => $batch,
+        ], 201);
+    }
+
+    public function updateBatchAssignment(ReimbursementBatchAssignmentRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+
+        $batchId = (int) ($payload['batch_id'] ?? 0);
+        $batchNumber = $payload['batch_number'] ?? null;
+        if ($batchId <= 0 && $batchNumber !== null && trim((string) $batchNumber) !== '') {
+            $batchId = (int) $batchNumber;
+        }
+
+        $adminIdRaw = $payload['admin_id'] ?? null;
+        $adminId = ($adminIdRaw === '' || $adminIdRaw === null) ? null : (int) $adminIdRaw;
+        $reimbursementId = !empty($payload['reimbursement_id']) ? (int) $payload['reimbursement_id'] : null;
+
+        try {
+            $result = $this->assignmentService->updateAssignment(
+                (int) $payload['expense_id'],
+                $batchId,
+                $adminId,
+                $reimbursementId,
+                $this->context->getSchoolYear(),
+                $this->context->getSemester()
+            );
+        } catch (RuntimeException $e) {
+            return response()->json(['ok' => false, 'message' => $e->getMessage()], 422);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'assignment' => $result,
+        ]);
+    }
+
+    public function lockBatch(ReimbursementBatchLockRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $userId = (int) (auth()->id() ?? 0);
+
+        try {
+            $this->batchService->lockBatch(
+                (int) $payload['batch_id'],
+                $userId,
+                $this->context->getSchoolYear(),
+                $this->context->getSemester()
+            );
+        } catch (RuntimeException $e) {
+            $message = $e->getMessage();
+            $status = str_contains($message, 'check file') ? 409 : 404;
+            return response()->json(['ok' => false, 'message' => $message], $status);
+        } catch (\Throwable $e) {
+            return response()->json(['ok' => false, 'message' => 'Unable to lock batch right now.'], 500);
+        }
+
+        return response()->json(['ok' => true, 'status' => 'closed']);
+    }
+
+    public function uploadBatchAdminFile(ReimbursementBatchAdminFileRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $batchId = (int) $payload['batch_id'];
+        $adminId = (int) $payload['admin_id'];
+
+        $batch = ReimbursementBatch::query()->find($batchId);
+        if (!$batch) {
+            return response()->json(['ok' => false, 'message' => 'Batch not found.'], 404);
+        }
+        if (strtolower((string) ($batch->status ?? '')) !== ReimbursementBatch::STATUS_OPEN) {
+            return response()->json(['ok' => false, 'message' => 'Cannot upload files for a locked batch.'], 409);
+        }
+
+        try {
+            $file = $this->fileService->storeAdminFile($batchId, $adminId, $request->file('check_file'), (int) (auth()->id() ?? 0));
+        } catch (\Throwable $e) {
+            return response()->json(['ok' => false, 'message' => 'Unable to store the uploaded file.'], 500);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'file' => $file,
+        ]);
+    }
+
+    public function serveAdminCheckFile(FileNameRequest $request, string $name, string $mode = 'inline'): Response|JsonResponse
+    {
+        $allowedExtensions = ['jpg', 'jpeg', 'png', 'webp', 'gif', 'pdf'];
+        $meta = $this->fileServeService->meta(storage_path('uploads/reimbursements'), $name, $allowedExtensions, null);
+        $disposition = strtolower(trim($mode)) === 'download' ? 'attachment' : 'inline';
+
+        return response(file_get_contents($meta['path']), 200, [
+            'Content-Type' => $meta['mime'],
+            'Content-Disposition' => $disposition . '; filename="' . $meta['download_name'] . '"',
+            'Content-Length' => (string) $meta['size'],
+            'ETag' => $meta['etag'],
+            'Last-Modified' => $meta['last_modified'],
+        ]);
+    }
+
+    public function index(ReimbursementIndexRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $filters = [
+            'school_year' => $payload['school_year'] ?? null,
+            'semester' => $payload['semester'] ?? null,
+            'status' => $payload['status'] ?? null,
+            'user_id' => $payload['user_id'] ?? null,
+        ];
+
+        $data = $this->queryService->index($filters);
+
+        return response()->json([
+            'ok' => true,
+            'expenses' => ReimbursementExpenseResource::collection($data['expenses'] ?? []),
+            'users' => ReimbursementRecipientResource::collection($data['users'] ?? []),
+            'schoolYears' => $data['schoolYears'] ?? [],
+            'batchSummaries' => $data['batchSummaries'] ?? [],
+            'batchDetails' => $data['batchDetails'] ?? [],
+            'batchAttachments' => $data['batchAttachments'] ?? [],
+            'donationBatch' => $data['donationBatch'] ?? null,
+            'donationDetails' => $data['donationDetails'] ?? null,
+        ]);
+    }
+
+    public function sendBatchEmail(ReimbursementBatchEmailRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $receiptIds = $payload['receipts'] ?? [];
+        $checkIds = $payload['checks'] ?? [];
+
+        try {
+            $ok = $this->emailService->sendBatchEmail(
+                (int) $payload['batch_id'],
+                $payload['recipient_email'],
+                (string) ($payload['message'] ?? ''),
+                $receiptIds,
+                $checkIds
+            );
+        } catch (RuntimeException $e) {
+            return response()->json(['ok' => false, 'message' => $e->getMessage()], 404);
+        }
+
+        if (!$ok) {
+            return response()->json(['ok' => false, 'message' => 'Failed to send email. Please try again.'], 500);
+        }
+
+        return response()->json(['ok' => true, 'message' => 'Email sent successfully.']);
+    }
+
+    public function export(ReimbursementExportRequest $request): Response
+    {
+        $payload = $request->validated();
+        $type = $payload['type'] ?? 'processed';
+
+        if ($type === 'under_processing') {
+            $csv = $this->exportService->buildUnderProcessingCsv();
+        } else {
+            $csv = $this->exportService->buildProcessedCsv($payload);
+        }
+
+        return response()->streamDownload(function () use ($csv) {
+            $out = fopen('php://output', 'w');
+            fprintf($out, chr(0xEF) . chr(0xBB) . chr(0xBF));
+            foreach ($csv['rows'] as $row) {
+                fputcsv($out, $row);
+            }
+            fclose($out);
+        }, $csv['filename'], [
+            'Content-Type' => 'text/csv; charset=UTF-8',
+        ]);
+    }
+
+    public function exportBatch(ReimbursementExportBatchRequest $request): Response
+    {
+        $payload = $request->validated();
+        $csv = $this->exportService->buildBatchCsv((int) $payload['batch_id']);
+
+        return response()->streamDownload(function () use ($csv) {
+            $out = fopen('php://output', 'w');
+            fprintf($out, chr(0xEF) . chr(0xBB) . chr(0xBF));
+            foreach ($csv['rows'] as $row) {
+                fputcsv($out, $row);
+            }
+            fclose($out);
+        }, $csv['filename'], [
+            'Content-Type' => 'text/csv; charset=UTF-8',
+        ]);
+    }
+
+    public function store(ReimbursementStoreRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $userId = (int) (auth()->id() ?? 0);
+        $receiptName = null;
+
+        if ($request->hasFile('receipt')) {
+            $receiptName = $this->fileService->storeReceipt($request->file('receipt'));
+        }
+
+        try {
+            $reimb = $this->crudService->store(
+                $payload,
+                $userId,
+                $this->context->getSchoolYear(),
+                $this->context->getSemester(),
+                $receiptName
+            );
+        } catch (RuntimeException $e) {
+            return response()->json(['ok' => false, 'message' => $e->getMessage()], 422);
+        }
+
+        $data = $reimb->toArray();
+        $data['receipt_url'] = $this->fileService->receiptUrl($reimb->receipt_path ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'reimbursement' => new ReimbursementResource($data),
+        ], 201);
+    }
+
+    public function process(ReimbursementProcessRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $userId = (int) (auth()->id() ?? 0);
+        $receiptName = null;
+
+        if ($request->hasFile('receipt')) {
+            $receiptName = $this->fileService->storeReceipt($request->file('receipt'));
+        }
+
+        try {
+            $reimb = $this->crudService->process(
+                $payload,
+                $userId,
+                $this->context->getSchoolYear(),
+                $this->context->getSemester(),
+                $receiptName
+            );
+        } catch (RuntimeException $e) {
+            return response()->json(['ok' => false, 'message' => $e->getMessage()], 422);
+        }
+
+        $data = $reimb->toArray();
+        $data['receipt_url'] = $this->fileService->receiptUrl($reimb->receipt_path ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'reimbursement' => new ReimbursementResource($data),
+        ], 201);
+    }
+
+    public function reimbursedExpenses(): JsonResponse
+    {
+        $expenses = $this->queryService->reimbursedExpenses();
+
+        return response()->json([
+            'ok' => true,
+            'expenses' => $expenses,
+        ]);
+    }
+
+    public function update(ReimbursementUpdateRequest $request, int $id): JsonResponse
+    {
+        $reimb = Reimbursement::query()->find($id);
+        if (!$reimb) {
+            return response()->json(['ok' => false, 'message' => 'Reimbursement not found.'], 404);
+        }
+
+        $payload = $request->validated();
+        $userId = (int) (auth()->id() ?? 0);
+
+        $receiptName = $reimb->receipt_path;
+        if ($request->hasFile('receipt')) {
+            $receiptName = $this->fileService->storeReceipt($request->file('receipt'));
+        }
+        if (!empty($payload['remove_receipt'])) {
+            $receiptName = null;
+        }
+
+        $updated = $this->crudService->update($reimb, $payload, $userId, $receiptName);
+        $data = $updated->toArray();
+        $data['receipt_url'] = $this->fileService->receiptUrl($updated->receipt_path ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'reimbursement' => new ReimbursementResource($data),
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Grading/GradingController.php b/app/Http/Controllers/Api/Grading/GradingController.php
new file mode 100644
index 00000000..11516b36
--- /dev/null
+++ b/app/Http/Controllers/Api/Grading/GradingController.php
@@ -0,0 +1,281 @@
+<?php
+
+namespace App\Http\Controllers\Api\Grading;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Grading\BelowSixtyEmailRequest;
+use App\Http\Requests\Grading\BelowSixtyMeetingRequest;
+use App\Http\Requests\Grading\BelowSixtyMeetingSaveRequest;
+use App\Http\Requests\Grading\BelowSixtySendRequest;
+use App\Http\Requests\Grading\BelowSixtyStatusRequest;
+use App\Http\Requests\Grading\BelowSixtyListRequest;
+use App\Http\Requests\Grading\GradingLockAllRequest;
+use App\Http\Requests\Grading\GradingLockRequest;
+use App\Http\Requests\Grading\GradingOverviewRequest;
+use App\Http\Requests\Grading\GradingRefreshRequest;
+use App\Http\Requests\Grading\GradingScoreShowRequest;
+use App\Http\Requests\Grading\GradingScoreUpdateRequest;
+use App\Http\Requests\Grading\PlacementBatchRequest;
+use App\Http\Requests\Grading\PlacementBatchUpdateRequest;
+use App\Http\Requests\Grading\PlacementLevelsRequest;
+use App\Http\Requests\Grading\PlacementLevelRequest;
+use App\Http\Requests\Grading\PlacementRequest;
+use App\Http\Resources\Grading\BelowSixtyStudentResource;
+use App\Http\Resources\Grading\GradingScoreResource;
+use App\Services\Grading\GradingBelowSixtyService;
+use App\Services\Grading\GradingLockService;
+use App\Services\Grading\GradingOverviewService;
+use App\Services\Grading\GradingPlacementService;
+use App\Services\Grading\GradingRefreshService;
+use App\Services\Grading\GradingScoreService;
+use Illuminate\Http\JsonResponse;
+
+class GradingController extends BaseApiController
+{
+    public function __construct(
+        private GradingOverviewService $overviewService,
+        private GradingScoreService $scoreService,
+        private GradingLockService $lockService,
+        private GradingRefreshService $refreshService,
+        private GradingPlacementService $placementService,
+        private GradingBelowSixtyService $belowSixtyService
+    ) {
+        parent::__construct();
+    }
+
+    public function overview(GradingOverviewRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->overviewService->overview(
+            isset($payload['class_id']) ? (int) $payload['class_id'] : null,
+            $payload['semester'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        return response()->json(['ok' => true] + $data);
+    }
+
+    public function show(GradingScoreShowRequest $request, string $type, int $classSectionId, int $studentId): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->scoreService->show(
+            $type,
+            $classSectionId,
+            $studentId,
+            (string) $payload['semester'],
+            (string) $payload['school_year']
+        );
+
+        return response()->json([
+            'ok' => true,
+            'student' => $data['student'],
+            'scores' => GradingScoreResource::collection($data['scores']),
+            'type' => $data['type'],
+            'class_section_id' => $data['class_section_id'],
+            'semester' => $data['semester'],
+            'scores_locked' => $data['scores_locked'],
+        ]);
+    }
+
+    public function update(GradingScoreUpdateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $this->scoreService->update($payload, (int) (auth()->id() ?? 0));
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function toggleLock(GradingLockRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $locked = $this->lockService->toggle(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true, 'locked' => $locked]);
+    }
+
+    public function lockAll(GradingLockAllRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $count = $this->lockService->lockAll(
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true, 'locked_count' => $count]);
+    }
+
+    public function refresh(GradingRefreshRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $this->refreshService->refreshSemesterScores(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year']
+        );
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function placement(PlacementRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->placementService->placementContext(
+            isset($payload['class_section_id']) ? (int) $payload['class_section_id'] : null,
+            (string) $payload['school_year'],
+            $payload['placement_test'] ?? null,
+            $payload['open'] ?? null
+        );
+
+        return response()->json(['ok' => true] + $data);
+    }
+
+    public function updatePlacementLevel(PlacementLevelRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $this->placementService->updatePlacementLevel(
+            (int) $payload['student_id'],
+            (string) $payload['school_year'],
+            $payload['placement_level'] ?? null,
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function updatePlacementLevels(PlacementLevelsRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $this->placementService->updatePlacementLevels(
+            (int) $payload['class_section_id'],
+            (string) $payload['school_year'],
+            $payload['placement_level'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function createPlacementBatch(PlacementBatchRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $batchId = $this->placementService->createPlacementBatch(
+            (string) $payload['school_year'],
+            (string) $payload['placement_test'],
+            $payload['placement_level'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true, 'batch_id' => $batchId]);
+    }
+
+    public function showPlacementBatch(int $batchId): JsonResponse
+    {
+        $data = $this->placementService->getPlacementBatch($batchId);
+
+        return response()->json(['ok' => true] + $data);
+    }
+
+    public function updatePlacementBatch(PlacementBatchUpdateRequest $request, int $batchId): JsonResponse
+    {
+        $payload = $request->validated();
+        $this->placementService->updatePlacementBatch(
+            $batchId,
+            (string) $payload['school_year'],
+            $payload['placement_level'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function belowSixty(BelowSixtyListRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $rows = $this->belowSixtyService->listRows(
+            (string) $payload['school_year'],
+            (string) $payload['semester']
+        );
+
+        return response()->json([
+            'ok' => true,
+            'rows' => BelowSixtyStudentResource::collection($rows),
+            'semester' => $payload['semester'],
+            'school_year' => $payload['school_year'],
+        ]);
+    }
+
+    public function belowSixtyEmail(BelowSixtyEmailRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->belowSixtyService->emailContext(
+            (int) $payload['student_id'],
+            (string) $payload['school_year'],
+            (string) $payload['semester']
+        );
+
+        return response()->json(['ok' => true] + $data);
+    }
+
+    public function sendBelowSixtyEmail(BelowSixtySendRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->belowSixtyService->emailContext(
+            (int) $payload['student_id'],
+            (string) $payload['school_year'],
+            (string) $payload['semester']
+        );
+
+        $subject = trim((string) ($payload['subject'] ?? ''));
+        if ($subject !== '') {
+            $data['subject'] = $subject;
+        }
+        if (isset($payload['html']) && trim((string) $payload['html']) !== '') {
+            $data['html'] = (string) $payload['html'];
+        }
+
+        $this->belowSixtyService->sendEmail($data);
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function updateBelowSixtyStatus(BelowSixtyStatusRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $this->belowSixtyService->updateStatus(
+            (int) $payload['student_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            (string) $payload['status'],
+            (string) ($payload['note'] ?? ''),
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function belowSixtyMeeting(BelowSixtyMeetingRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->belowSixtyService->meetingContext(
+            (int) $payload['student_id'],
+            (string) $payload['school_year'],
+            (string) $payload['semester']
+        );
+
+        return response()->json(['ok' => true] + $data);
+    }
+
+    public function saveBelowSixtyMeeting(BelowSixtyMeetingSaveRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $this->belowSixtyService->saveMeeting($payload, (int) (auth()->id() ?? 0));
+
+        return response()->json(['ok' => true]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Grading/HomeworkTrackingController.php b/app/Http/Controllers/Api/Grading/HomeworkTrackingController.php
new file mode 100644
index 00000000..17f873e6
--- /dev/null
+++ b/app/Http/Controllers/Api/Grading/HomeworkTrackingController.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Http\Controllers\Api\Grading;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Grading\HomeworkTrackingRequest;
+use App\Http\Resources\Grading\HomeworkTrackingTeacherResource;
+use App\Services\Grading\HomeworkTrackingService;
+use Illuminate\Http\JsonResponse;
+
+class HomeworkTrackingController extends BaseApiController
+{
+    public function __construct(private HomeworkTrackingService $service)
+    {
+        parent::__construct();
+    }
+
+    public function index(HomeworkTrackingRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->report(
+            $payload['semester'] ?? null,
+            $payload['school_year'] ?? null,
+            isset($payload['page']) ? (int) $payload['page'] : 1
+        );
+
+        return response()->json([
+            'ok' => true,
+            'semester' => $data['semester'],
+            'school_year' => $data['school_year'],
+            'sundays' => $data['sundays'],
+            'event_days' => $data['event_days'],
+            'date_to_index' => $data['date_to_index'],
+            'teachers' => HomeworkTrackingTeacherResource::collection($data['teachers']),
+            'has_homework' => $data['has_homework'],
+            'hw_entered_at' => $data['hw_entered_at'],
+            'has_homework_by_date' => $data['has_homework_by_date'],
+            'hw_entered_at_by_date' => $data['hw_entered_at_by_date'],
+            'page' => $data['page'],
+            'total_pages' => $data['total_pages'],
+            'per_page' => $data['per_page'],
+            'total_rows' => $data['total_rows'],
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Incidents/IncidentController.php b/app/Http/Controllers/Api/Incidents/IncidentController.php
new file mode 100644
index 00000000..1d30d344
--- /dev/null
+++ b/app/Http/Controllers/Api/Incidents/IncidentController.php
@@ -0,0 +1,151 @@
+<?php
+
+namespace App\Http\Controllers\Api\Incidents;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Incidents\IncidentCancelRequest;
+use App\Http\Requests\Incidents\IncidentCloseRequest;
+use App\Http\Requests\Incidents\IncidentListRequest;
+use App\Http\Requests\Incidents\IncidentStateRequest;
+use App\Http\Requests\Incidents\IncidentStoreRequest;
+use App\Http\Resources\Incidents\IncidentAnalysisStudentResource;
+use App\Http\Resources\Incidents\IncidentGradeResource;
+use App\Http\Resources\Incidents\IncidentResource;
+use App\Http\Resources\Incidents\IncidentStudentOptionResource;
+use App\Services\Incidents\CurrentIncidentService;
+use App\Services\Incidents\IncidentAnalysisService;
+use App\Services\Incidents\IncidentHistoryService;
+use Illuminate\Http\JsonResponse;
+
+class IncidentController extends BaseApiController
+{
+    public function __construct(
+        private CurrentIncidentService $currentService,
+        private IncidentHistoryService $historyService,
+        private IncidentAnalysisService $analysisService
+    ) {
+        parent::__construct();
+    }
+
+    public function current(): JsonResponse
+    {
+        $data = $this->currentService->listCurrent();
+
+        return response()->json([
+            'ok' => true,
+            'incidents' => IncidentResource::collection($data['incidents']),
+            'grades' => IncidentGradeResource::collection($data['grades']),
+        ]);
+    }
+
+    public function history(IncidentListRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $incidents = $this->historyService->history($payload['school_year'] ?? null, $payload['semester'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'incidents' => IncidentResource::collection($incidents),
+        ]);
+    }
+
+    public function processed(IncidentListRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $incidents = $this->historyService->processed($payload['school_year'] ?? null, $payload['semester'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'incidents' => IncidentResource::collection($incidents),
+        ]);
+    }
+
+    public function analysis(IncidentListRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $students = $this->analysisService->analyze($payload['school_year'] ?? null, $payload['semester'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'students' => IncidentAnalysisStudentResource::collection($students),
+            'school_year' => $payload['school_year'] ?? null,
+            'semester' => $payload['semester'] ?? null,
+        ]);
+    }
+
+    public function studentsByGrade(int $gradeId): JsonResponse
+    {
+        $students = $this->currentService->studentsByGrade($gradeId);
+
+        return response()->json([
+            'ok' => true,
+            'students' => IncidentStudentOptionResource::collection($students),
+        ]);
+    }
+
+    public function store(IncidentStoreRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->currentService->addIncident($payload, (int) (auth()->id() ?? 0));
+
+        if (empty($result['ok'])) {
+            return response()->json(['ok' => false, 'message' => $result['message'] ?? 'Failed to add incident.'], 422);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'created' => $result['created'],
+            'incident_id' => $result['incident_id'],
+        ]);
+    }
+
+    public function updateState(IncidentStateRequest $request, int $incidentId): JsonResponse
+    {
+        $payload = $request->validated();
+        $updated = $this->currentService->updateState($incidentId, (string) $payload['incident_state']);
+
+        return response()->json([
+            'ok' => $updated,
+        ]);
+    }
+
+    public function close(IncidentCloseRequest $request, int $incidentId): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->currentService->closeIncident(
+            $incidentId,
+            (string) $payload['state_description'],
+            $payload['action_taken'] ?? null,
+            (int) (auth()->id() ?? 0)
+        );
+
+        if (empty($result['ok'])) {
+            return response()->json(['ok' => false, 'message' => $result['message'] ?? 'Failed to close incident.'], 422);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'incident_id' => $result['incident_id'],
+        ]);
+    }
+
+    public function cancel(IncidentCancelRequest $request, int $incidentId): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->currentService->cancelIncident(
+            $incidentId,
+            $payload['state_description'] ?? null,
+            $payload['action_taken'] ?? null,
+            (int) (auth()->id() ?? 0)
+        );
+
+        if (empty($result['ok'])) {
+            return response()->json(['ok' => false, 'message' => $result['message'] ?? 'Failed to cancel incident.'], 422);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'incident_id' => $result['incident_id'],
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Reports/FilesController.php b/app/Http/Controllers/Api/Reports/FilesController.php
new file mode 100644
index 00000000..29ec1197
--- /dev/null
+++ b/app/Http/Controllers/Api/Reports/FilesController.php
@@ -0,0 +1,105 @@
+<?php
+
+namespace App\Http\Controllers\Api\Reports;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Files\FileNameRequest;
+use App\Http\Resources\Files\FileMetaResource;
+use App\Services\Files\ExamDraftDownloadNameService;
+use App\Services\Files\FileServeService;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Http\Response;
+
+class FilesController extends BaseApiController
+{
+    public function __construct(
+        private FileServeService $fileService,
+        private ExamDraftDownloadNameService $draftNameService
+    ) {
+        parent::__construct();
+    }
+
+    public function receipt(FileNameRequest $request, string $name): Response|JsonResponse
+    {
+        return $this->serveFile(
+            $request,
+            storage_path('uploads/receipts'),
+            $name,
+            ['jpg', 'jpeg', 'png', 'webp', 'gif', 'pdf'],
+            null,
+            false
+        );
+    }
+
+    public function reimb(FileNameRequest $request, string $name): Response|JsonResponse
+    {
+        return $this->serveFile(
+            $request,
+            storage_path('uploads/reimbursements'),
+            $name,
+            ['jpg', 'jpeg', 'png', 'webp', 'gif', 'pdf'],
+            null,
+            true
+        );
+    }
+
+    public function earlyDismissalSignature(FileNameRequest $request, string $name): Response|JsonResponse
+    {
+        return $this->serveFile(
+            $request,
+            storage_path('uploads/early_dismissal_signatures'),
+            $name,
+            ['jpg', 'jpeg', 'png', 'webp', 'gif', 'pdf'],
+            null,
+            true
+        );
+    }
+
+    public function examDraftTeacher(FileNameRequest $request, string $name): Response|JsonResponse
+    {
+        $downloadName = $this->draftNameService->build($name, 'drafts');
+
+        return $this->serveFile(
+            $request,
+            storage_path('uploads/exams/drafts'),
+            $name,
+            ['doc', 'docx', 'pdf'],
+            $downloadName,
+            true
+        );
+    }
+
+    public function examDraftFinal(FileNameRequest $request, string $name): Response|JsonResponse
+    {
+        $downloadName = $this->draftNameService->build($name, 'finals');
+
+        return $this->serveFile(
+            $request,
+            storage_path('uploads/exams/finals'),
+            $name,
+            ['doc', 'docx', 'pdf'],
+            $downloadName,
+            true
+        );
+    }
+
+    private function serveFile(
+        FileNameRequest $request,
+        string $baseDir,
+        string $name,
+        array $allowedExtensions,
+        ?string $downloadName,
+        bool $nosniff
+    ): Response|JsonResponse {
+        if ($request->boolean('meta')) {
+            $meta = $this->fileService->meta($baseDir, $name, $allowedExtensions, $downloadName);
+
+            return response()->json([
+                'ok' => true,
+                'file' => new FileMetaResource($meta),
+            ]);
+        }
+
+        return $this->fileService->serveInline($baseDir, $name, $allowedExtensions, $request, $downloadName, $nosniff);
+    }
+}
diff --git a/app/Http/Controllers/Api/Scores/FinalController.php b/app/Http/Controllers/Api/Scores/FinalController.php
new file mode 100644
index 00000000..7ba0f37b
--- /dev/null
+++ b/app/Http/Controllers/Api/Scores/FinalController.php
@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Http\Controllers\Api\Scores;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Scores\ScoreClassRequest;
+use App\Http\Requests\Scores\ScoreUpdateRequest;
+use App\Http\Resources\Scores\ScoreStudentResource;
+use App\Models\Student;
+use App\Services\Scores\ExamScoreService;
+use App\Services\Scores\SemesterScoreService;
+use Illuminate\Http\JsonResponse;
+
+class FinalController extends BaseApiController
+{
+    public function __construct(
+        private ExamScoreService $service,
+        private SemesterScoreService $semesterScoreService
+    ) {
+        parent::__construct();
+    }
+
+    public function index(ScoreClassRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->list('final_exam', (int) $payload['class_section_id'], $payload['semester'] ?? null, $payload['school_year'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'students' => ScoreStudentResource::collection($data['students']),
+            'semester' => $data['semester'],
+            'school_year' => $data['schoolYear'],
+            'scores_locked' => $data['scoresLocked'],
+            'missing_ok_map' => $data['missingOkMap'],
+        ]);
+    }
+
+    public function update(ScoreUpdateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $count = $this->service->update(
+            'final_exam',
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            $payload['scores'],
+            $payload['missing_ok'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        $this->refreshSemesterScores((int) $payload['class_section_id'], (string) $payload['semester'], (string) $payload['school_year']);
+
+        return response()->json(['ok' => true, 'updated' => $count]);
+    }
+
+    private function refreshSemesterScores(int $classSectionId, string $semester, string $schoolYear): void
+    {
+        $studentInfo = Student::getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear, (int) (auth()->id() ?? 0));
+        if (empty($studentInfo)) {
+            return;
+        }
+        try {
+            $this->semesterScoreService->updateScoresForStudents($studentInfo, $semester, $schoolYear);
+        } catch (\Throwable $e) {
+        }
+    }
+}
diff --git a/app/Http/Controllers/Api/Scores/HomeworkController.php b/app/Http/Controllers/Api/Scores/HomeworkController.php
new file mode 100644
index 00000000..a78ab68f
--- /dev/null
+++ b/app/Http/Controllers/Api/Scores/HomeworkController.php
@@ -0,0 +1,85 @@
+<?php
+
+namespace App\Http\Controllers\Api\Scores;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Scores\ScoreAddColumnRequest;
+use App\Http\Requests\Scores\ScoreClassRequest;
+use App\Http\Requests\Scores\ScoreUpdateRequest;
+use App\Http\Resources\Scores\ScoreStudentResource;
+use App\Models\Student;
+use App\Services\Scores\HomeworkScoreService;
+use App\Services\Scores\SemesterScoreService;
+use Illuminate\Http\JsonResponse;
+
+class HomeworkController extends BaseApiController
+{
+    public function __construct(
+        private HomeworkScoreService $service,
+        private SemesterScoreService $semesterScoreService
+    ) {
+        parent::__construct();
+    }
+
+    public function index(ScoreClassRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->list(
+            (int) $payload['class_section_id'],
+            $payload['semester'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        return response()->json([
+            'ok' => true,
+            'students' => ScoreStudentResource::collection($data['students']),
+            'headers' => $data['headers'],
+            'semester' => $data['semester'],
+            'school_year' => $data['schoolYear'],
+            'scores_locked' => $data['scoresLocked'],
+            'missing_ok_map' => $data['missingOkMap'],
+        ]);
+    }
+
+    public function update(ScoreUpdateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $count = $this->service->update(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            $payload['scores'],
+            $payload['missing_ok'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        $this->refreshSemesterScores((int) $payload['class_section_id'], (string) $payload['semester'], (string) $payload['school_year']);
+
+        return response()->json(['ok' => true, 'updated' => $count]);
+    }
+
+    public function addColumn(ScoreAddColumnRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $nextIndex = $this->service->addColumn(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true, 'homework_index' => $nextIndex]);
+    }
+
+    private function refreshSemesterScores(int $classSectionId, string $semester, string $schoolYear): void
+    {
+        $studentInfo = Student::getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear, (int) (auth()->id() ?? 0));
+        if (empty($studentInfo)) {
+            return;
+        }
+        try {
+            $this->semesterScoreService->updateScoresForStudents($studentInfo, $semester, $schoolYear);
+        } catch (\Throwable $e) {
+        }
+    }
+}
diff --git a/app/Http/Controllers/Api/Scores/MidtermController.php b/app/Http/Controllers/Api/Scores/MidtermController.php
new file mode 100644
index 00000000..25e8d335
--- /dev/null
+++ b/app/Http/Controllers/Api/Scores/MidtermController.php
@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Http\Controllers\Api\Scores;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Scores\ScoreClassRequest;
+use App\Http\Requests\Scores\ScoreUpdateRequest;
+use App\Http\Resources\Scores\ScoreStudentResource;
+use App\Models\Student;
+use App\Services\Scores\ExamScoreService;
+use App\Services\Scores\SemesterScoreService;
+use Illuminate\Http\JsonResponse;
+
+class MidtermController extends BaseApiController
+{
+    public function __construct(
+        private ExamScoreService $service,
+        private SemesterScoreService $semesterScoreService
+    ) {
+        parent::__construct();
+    }
+
+    public function index(ScoreClassRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->list('midterm_exam', (int) $payload['class_section_id'], $payload['semester'] ?? null, $payload['school_year'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'students' => ScoreStudentResource::collection($data['students']),
+            'semester' => $data['semester'],
+            'school_year' => $data['schoolYear'],
+            'scores_locked' => $data['scoresLocked'],
+            'missing_ok_map' => $data['missingOkMap'],
+        ]);
+    }
+
+    public function update(ScoreUpdateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $count = $this->service->update(
+            'midterm_exam',
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            $payload['scores'],
+            $payload['missing_ok'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        $this->refreshSemesterScores((int) $payload['class_section_id'], (string) $payload['semester'], (string) $payload['school_year']);
+
+        return response()->json(['ok' => true, 'updated' => $count]);
+    }
+
+    private function refreshSemesterScores(int $classSectionId, string $semester, string $schoolYear): void
+    {
+        $studentInfo = Student::getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear, (int) (auth()->id() ?? 0));
+        if (empty($studentInfo)) {
+            return;
+        }
+        try {
+            $this->semesterScoreService->updateScoresForStudents($studentInfo, $semester, $schoolYear);
+        } catch (\Throwable $e) {
+        }
+    }
+}
diff --git a/app/Http/Controllers/Api/Scores/ParticipationController.php b/app/Http/Controllers/Api/Scores/ParticipationController.php
new file mode 100644
index 00000000..62a468b9
--- /dev/null
+++ b/app/Http/Controllers/Api/Scores/ParticipationController.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Http\Controllers\Api\Scores;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Scores\ScoreClassRequest;
+use App\Http\Requests\Scores\ScoreUpdateRequest;
+use App\Http\Resources\Scores\ScoreStudentResource;
+use App\Models\Student;
+use App\Services\Scores\ParticipationScoreService;
+use App\Services\Scores\SemesterScoreService;
+use Illuminate\Http\JsonResponse;
+
+class ParticipationController extends BaseApiController
+{
+    public function __construct(
+        private ParticipationScoreService $service,
+        private SemesterScoreService $semesterScoreService
+    ) {
+        parent::__construct();
+    }
+
+    public function index(ScoreClassRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->list(
+            (int) $payload['class_section_id'],
+            $payload['semester'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        return response()->json([
+            'ok' => true,
+            'students' => ScoreStudentResource::collection($data['students']),
+            'semester' => $data['semester'],
+            'school_year' => $data['schoolYear'],
+            'scores_locked' => $data['scoresLocked'],
+            'missing_ok_map' => $data['missingOkMap'],
+        ]);
+    }
+
+    public function update(ScoreUpdateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $count = $this->service->update(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            $payload['scores'],
+            $payload['missing_ok'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        $this->refreshSemesterScores((int) $payload['class_section_id'], (string) $payload['semester'], (string) $payload['school_year']);
+
+        return response()->json(['ok' => true, 'updated' => $count]);
+    }
+
+    private function refreshSemesterScores(int $classSectionId, string $semester, string $schoolYear): void
+    {
+        $studentInfo = Student::getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear, (int) (auth()->id() ?? 0));
+        if (empty($studentInfo)) {
+            return;
+        }
+        try {
+            $this->semesterScoreService->updateScoresForStudents($studentInfo, $semester, $schoolYear);
+        } catch (\Throwable $e) {
+        }
+    }
+}
diff --git a/app/Http/Controllers/Api/Scores/ProjectController.php b/app/Http/Controllers/Api/Scores/ProjectController.php
new file mode 100644
index 00000000..4116cd2e
--- /dev/null
+++ b/app/Http/Controllers/Api/Scores/ProjectController.php
@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Http\Controllers\Api\Scores;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Scores\ScoreAddColumnRequest;
+use App\Http\Requests\Scores\ScoreClassRequest;
+use App\Http\Requests\Scores\ScoreUpdateRequest;
+use App\Http\Resources\Scores\ScoreStudentResource;
+use App\Models\Student;
+use App\Services\Scores\ProjectScoreService;
+use App\Services\Scores\SemesterScoreService;
+use Illuminate\Http\JsonResponse;
+
+class ProjectController extends BaseApiController
+{
+    public function __construct(
+        private ProjectScoreService $service,
+        private SemesterScoreService $semesterScoreService
+    ) {
+        parent::__construct();
+    }
+
+    public function index(ScoreClassRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->list(
+            (int) $payload['class_section_id'],
+            $payload['semester'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        return response()->json([
+            'ok' => true,
+            'students' => ScoreStudentResource::collection($data['students']),
+            'headers' => $data['headers'],
+            'semester' => $data['semester'],
+            'school_year' => $data['schoolYear'],
+            'scores_locked' => $data['scoresLocked'],
+            'missing_ok_map' => $data['missingOkMap'],
+        ]);
+    }
+
+    public function update(ScoreUpdateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $count = $this->service->update(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            $payload['scores'],
+            $payload['missing_ok'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        $this->refreshSemesterScores((int) $payload['class_section_id'], (string) $payload['semester'], (string) $payload['school_year']);
+
+        return response()->json(['ok' => true, 'updated' => $count]);
+    }
+
+    public function addColumn(ScoreAddColumnRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $nextIndex = $this->service->addColumn(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true, 'project_index' => $nextIndex]);
+    }
+
+    private function refreshSemesterScores(int $classSectionId, string $semester, string $schoolYear): void
+    {
+        $studentInfo = Student::getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear, (int) (auth()->id() ?? 0));
+        if (empty($studentInfo)) {
+            return;
+        }
+        try {
+            $this->semesterScoreService->updateScoresForStudents($studentInfo, $semester, $schoolYear);
+        } catch (\Throwable $e) {
+            // swallow errors to keep API response stable
+        }
+    }
+}
diff --git a/app/Http/Controllers/Api/Scores/QuizController.php b/app/Http/Controllers/Api/Scores/QuizController.php
new file mode 100644
index 00000000..1eeed557
--- /dev/null
+++ b/app/Http/Controllers/Api/Scores/QuizController.php
@@ -0,0 +1,85 @@
+<?php
+
+namespace App\Http\Controllers\Api\Scores;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Scores\ScoreAddColumnRequest;
+use App\Http\Requests\Scores\ScoreClassRequest;
+use App\Http\Requests\Scores\ScoreUpdateRequest;
+use App\Http\Resources\Scores\ScoreStudentResource;
+use App\Models\Student;
+use App\Services\Scores\QuizScoreService;
+use App\Services\Scores\SemesterScoreService;
+use Illuminate\Http\JsonResponse;
+
+class QuizController extends BaseApiController
+{
+    public function __construct(
+        private QuizScoreService $service,
+        private SemesterScoreService $semesterScoreService
+    ) {
+        parent::__construct();
+    }
+
+    public function index(ScoreClassRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->list(
+            (int) $payload['class_section_id'],
+            $payload['semester'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        return response()->json([
+            'ok' => true,
+            'students' => ScoreStudentResource::collection($data['students']),
+            'headers' => $data['headers'],
+            'semester' => $data['semester'],
+            'school_year' => $data['schoolYear'],
+            'scores_locked' => $data['scoresLocked'],
+            'missing_ok_map' => $data['missingOkMap'],
+        ]);
+    }
+
+    public function update(ScoreUpdateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $count = $this->service->update(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            $payload['scores'],
+            $payload['missing_ok'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        $this->refreshSemesterScores((int) $payload['class_section_id'], (string) $payload['semester'], (string) $payload['school_year']);
+
+        return response()->json(['ok' => true, 'updated' => $count]);
+    }
+
+    public function addColumn(ScoreAddColumnRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $nextIndex = $this->service->addColumn(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true, 'quiz_index' => $nextIndex]);
+    }
+
+    private function refreshSemesterScores(int $classSectionId, string $semester, string $schoolYear): void
+    {
+        $studentInfo = Student::getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear, (int) (auth()->id() ?? 0));
+        if (empty($studentInfo)) {
+            return;
+        }
+        try {
+            $this->semesterScoreService->updateScoresForStudents($studentInfo, $semester, $schoolYear);
+        } catch (\Throwable $e) {
+        }
+    }
+}
diff --git a/app/Http/Controllers/Api/Scores/ScoreCommentController.php b/app/Http/Controllers/Api/Scores/ScoreCommentController.php
new file mode 100644
index 00000000..b362381c
--- /dev/null
+++ b/app/Http/Controllers/Api/Scores/ScoreCommentController.php
@@ -0,0 +1,88 @@
+<?php
+
+namespace App\Http\Controllers\Api\Scores;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Scores\ScoreCommentListRequest;
+use App\Http\Requests\Scores\ScoreCommentSaveRequest;
+use App\Http\Requests\Scores\ScoreCommentUpdateRequest;
+use App\Http\Resources\Scores\ScoreCommentResource;
+use App\Services\Scores\ScoreCommentService;
+use Illuminate\Http\JsonResponse;
+
+class ScoreCommentController extends BaseApiController
+{
+    public function __construct(private ScoreCommentService $service)
+    {
+        parent::__construct();
+    }
+
+    public function index(ScoreCommentListRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->list(
+            $payload['class_section_id'] ?? null,
+            $payload['semester'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        $studentRows = [];
+        foreach ($data['students'] as $student) {
+            $studentId = (int) ($student['student_id'] ?? 0);
+            $studentRows[] = [
+                'student_id' => $studentId,
+                'firstname' => $student['firstname'] ?? null,
+                'lastname' => $student['lastname'] ?? null,
+                'school_id' => $student['school_id'] ?? null,
+                'comments' => $data['comments'][$studentId] ?? [],
+            ];
+        }
+
+        return response()->json([
+            'ok' => true,
+            'students' => ScoreCommentResource::collection($studentRows),
+            'semester' => $data['semester'],
+            'school_year' => $data['schoolYear'],
+            'class_section_id' => $data['classSectionId'],
+            'scores_locked' => $data['scoresLocked'],
+        ]);
+    }
+
+    public function store(ScoreCommentSaveRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->service->save(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            $payload['comments'],
+            $payload['missing_ok'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        if (!empty($result['errors'])) {
+            return response()->json(['ok' => false, 'errors' => $result['errors']], 422);
+        }
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function update(ScoreCommentUpdateRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->service->update(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            $payload['comments'] ?? [],
+            $payload['reviews'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        if (!empty($result['errors'])) {
+            return response()->json(['ok' => false, 'errors' => $result['errors']], 422);
+        }
+
+        return response()->json(['ok' => true]);
+    }
+}
diff --git a/app/Http/Controllers/Api/Scores/ScoreController.php b/app/Http/Controllers/Api/Scores/ScoreController.php
new file mode 100644
index 00000000..d801db54
--- /dev/null
+++ b/app/Http/Controllers/Api/Scores/ScoreController.php
@@ -0,0 +1,66 @@
+<?php
+
+namespace App\Http\Controllers\Api\Scores;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Scores\ScoreLockRequest;
+use App\Http\Requests\Scores\ScoreOverviewRequest;
+use App\Http\Requests\Scores\ScoreStudentRequest;
+use App\Http\Resources\Scores\ScoreStudentResource;
+use App\Services\Scores\ScoreDashboardService;
+use Illuminate\Http\JsonResponse;
+
+class ScoreController extends BaseApiController
+{
+    public function __construct(private ScoreDashboardService $service)
+    {
+        parent::__construct();
+    }
+
+    public function overview(ScoreOverviewRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $teacherId = (int) (auth()->id() ?? 0);
+
+        $data = $this->service->overview(
+            $teacherId,
+            isset($payload['class_section_id']) ? (int) $payload['class_section_id'] : null,
+            $payload['semester'] ?? null,
+            $payload['school_year'] ?? null
+        );
+
+        return response()->json([
+            'ok' => true,
+            'students' => ScoreStudentResource::collection($data['students'] ?? []),
+            'class_section_id' => $data['class_section_id'] ?? null,
+            'class_section_name' => $data['class_section_name'] ?? null,
+            'semester' => $data['semester'] ?? null,
+            'school_year' => $data['school_year'] ?? null,
+            'scores_locked' => $data['scoresLocked'] ?? false,
+        ]);
+    }
+
+    public function lock(ScoreLockRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $this->service->submitScoresLock(
+            (int) $payload['class_section_id'],
+            (string) $payload['semester'],
+            (string) $payload['school_year'],
+            $payload['missing_ok'] ?? [],
+            (int) (auth()->id() ?? 0)
+        );
+
+        return response()->json(['ok' => true]);
+    }
+
+    public function studentScores(ScoreStudentRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $parentId = (int) (auth()->id() ?? 0);
+
+        $data = $this->service->viewStudentScores($parentId, (string) $payload['school_year']);
+
+        return response()->json(['ok' => true] + $data);
+    }
+}
diff --git a/app/Http/Controllers/Api/Scores/ScorePredictorController.php b/app/Http/Controllers/Api/Scores/ScorePredictorController.php
new file mode 100644
index 00000000..1f69533e
--- /dev/null
+++ b/app/Http/Controllers/Api/Scores/ScorePredictorController.php
@@ -0,0 +1,35 @@
+<?php
+
+namespace App\Http\Controllers\Api\Scores;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Scores\ScorePredictorRequest;
+use App\Http\Resources\Scores\ScorePredictorStudentResource;
+use App\Services\Scores\ScorePredictorService;
+use Illuminate\Http\JsonResponse;
+
+class ScorePredictorController extends BaseApiController
+{
+    public function __construct(private ScorePredictorService $service)
+    {
+        parent::__construct();
+    }
+
+    public function index(ScorePredictorRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $data = $this->service->report(
+            $payload['school_year'] ?? null,
+            isset($payload['class_section_id']) ? (int) $payload['class_section_id'] : null
+        );
+
+        return response()->json([
+            'ok' => true,
+            'students' => ScorePredictorStudentResource::collection($data['students'] ?? []),
+            'school_year' => $data['school_year'] ?? null,
+            'class_sections' => $data['class_sections'] ?? [],
+            'selected_class_section_id' => $data['selected_class_section_id'] ?? null,
+            'semester' => $data['semester'] ?? null,
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/System/SemesterRangeController.php b/app/Http/Controllers/Api/System/SemesterRangeController.php
new file mode 100644
index 00000000..eca196d3
--- /dev/null
+++ b/app/Http/Controllers/Api/System/SemesterRangeController.php
@@ -0,0 +1,80 @@
+<?php
+
+namespace App\Http\Controllers\Api\System;
+
+use App\Http\Controllers\Api\BaseApiController;
+use App\Http\Requests\Semesters\SchoolYearRangeRequest;
+use App\Http\Requests\Semesters\SemesterNormalizeRequest;
+use App\Http\Requests\Semesters\SemesterRangeRequest;
+use App\Http\Requests\Semesters\SemesterResolveRequest;
+use App\Http\Resources\Semesters\SemesterRangeResource;
+use App\Http\Resources\Semesters\SemesterResolveResource;
+use App\Services\SemesterRangeService;
+use Illuminate\Http\JsonResponse;
+
+class SemesterRangeController extends BaseApiController
+{
+    public function __construct(private SemesterRangeService $service)
+    {
+        parent::__construct();
+    }
+
+    public function schoolYearRange(SchoolYearRangeRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        [$start, $end] = $this->service->getSchoolYearRange($payload['school_year']);
+
+        return response()->json([
+            'ok' => true,
+            'school_year' => $payload['school_year'],
+            'range' => new SemesterRangeResource([
+                'start_date' => $start,
+                'end_date' => $end,
+            ]),
+        ]);
+    }
+
+    public function semesterRange(SemesterRangeRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $range = $this->service->getSemesterRange($payload['school_year'], $payload['semester']);
+
+        if ($range === null) {
+            return response()->json(['ok' => false, 'message' => 'Invalid semester range.'], 422);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'school_year' => $payload['school_year'],
+            'semester' => $this->service->normalizeSemester($payload['semester']),
+            'range' => new SemesterRangeResource([
+                'start_date' => $range[0],
+                'end_date' => $range[1],
+            ]),
+        ]);
+    }
+
+    public function normalize(SemesterNormalizeRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+
+        return response()->json([
+            'ok' => true,
+            'normalized' => $this->service->normalizeSemester($payload['semester']),
+        ]);
+    }
+
+    public function resolve(SemesterResolveRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $semester = $this->service->getSemesterForDate($payload['date'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'resolution' => new SemesterResolveResource([
+                'date' => $payload['date'] ?? null,
+                'semester' => $semester,
+            ]),
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/Api/UserController.php b/app/Http/Controllers/Api/UserController.php
new file mode 100644
index 00000000..8ccd2c6c
--- /dev/null
+++ b/app/Http/Controllers/Api/UserController.php
@@ -0,0 +1,102 @@
+<?php
+
+namespace App\Http\Controllers\Api;
+
+use App\Http\Requests\Users\LoginActivityRequest;
+use App\Http\Requests\Users\UserListRequest;
+use App\Http\Requests\Users\UserStoreRequest;
+use App\Http\Requests\Users\UserUpdateRequest;
+use App\Http\Resources\Users\LoginActivityResource;
+use App\Http\Resources\Users\UserWithRolesResource;
+use App\Services\Users\LoginActivityService;
+use App\Services\Users\UserListService;
+use App\Services\Users\UserManagementService;
+use Illuminate\Http\JsonResponse;
+
+class UserController extends BaseApiController
+{
+    public function __construct(
+        private UserListService $listService,
+        private UserManagementService $managementService,
+        private LoginActivityService $loginActivityService
+    ) {
+        parent::__construct();
+    }
+
+    public function index(UserListRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $users = $this->listService->list($payload['sort'] ?? null, $payload['order'] ?? null);
+
+        return response()->json([
+            'ok' => true,
+            'users' => UserWithRolesResource::collection($users),
+        ]);
+    }
+
+    public function store(UserStoreRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->managementService->create($payload, (int) (auth()->id() ?? 0));
+
+        if (empty($result['ok'])) {
+            return response()->json([
+                'ok' => false,
+                'message' => $result['message'] ?? 'Failed to create user.',
+            ], 422);
+        }
+
+        return response()->json([
+            'ok' => true,
+            'user_id' => $result['user']->id ?? null,
+        ], 201);
+    }
+
+    public function update(UserUpdateRequest $request, int $userId): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->managementService->update($userId, $payload);
+
+        if (empty($result['ok'])) {
+            return response()->json([
+                'ok' => false,
+                'message' => $result['message'] ?? 'Failed to update user.',
+            ], 422);
+        }
+
+        return response()->json([
+            'ok' => true,
+        ]);
+    }
+
+    public function destroy(int $userId): JsonResponse
+    {
+        $result = $this->managementService->delete($userId);
+
+        if (empty($result['ok'])) {
+            return response()->json([
+                'ok' => false,
+                'message' => $result['message'] ?? 'Failed to delete user.',
+            ], 404);
+        }
+
+        return response()->json([
+            'ok' => true,
+        ]);
+    }
+
+    public function loginActivity(LoginActivityRequest $request): JsonResponse
+    {
+        $payload = $request->validated();
+        $result = $this->loginActivityService->list(
+            (int) ($payload['per_page'] ?? 25),
+            (int) ($payload['page'] ?? 1)
+        );
+
+        return response()->json([
+            'ok' => true,
+            'activities' => LoginActivityResource::collection($result['activities']),
+            'pagination' => $result['pagination'],
+        ]);
+    }
+}
diff --git a/app/Http/Controllers/old/ApiClient.php b/app/Http/Controllers/old/ApiClient.php
new file mode 100644
index 00000000..8dc3ae8a
--- /dev/null
+++ b/app/Http/Controllers/old/ApiClient.php
@@ -0,0 +1,107 @@
+<?php
+
+namespace App\Services;
+
+use CodeIgniter\HTTP\CURLRequest;
+use Config\Api as ApiConfig;
+
+class ApiClient
+{
+    protected CURLRequest $http;
+    protected ApiConfig $config;
+
+    public function __construct(CURLRequest $http, ApiConfig $config)
+    {
+        $this->http = $http;
+        $this->config = $config;
+    }
+
+    public function get(string $uri, array $query = [], array $headers = []): array
+    {
+        return $this->request('get', $uri, [
+            'headers' => $this->mergeHeaders($headers),
+            'query'   => $query,
+        ]);
+    }
+
+    public function post(string $uri, array $data = [], array $headers = []): array
+    {
+        return $this->request('post', $uri, [
+            'headers' => $this->mergeHeaders($headers, ['Content-Type' => 'application/json']),
+            'json'    => $data,
+        ]);
+    }
+
+    public function put(string $uri, array $data = [], array $headers = []): array
+    {
+        return $this->request('put', $uri, [
+            'headers' => $this->mergeHeaders($headers, ['Content-Type' => 'application/json']),
+            'json'    => $data,
+        ]);
+    }
+
+    public function delete(string $uri, array $data = [], array $headers = []): array
+    {
+        return $this->request('delete', $uri, [
+            'headers' => $this->mergeHeaders($headers, ['Content-Type' => 'application/json']),
+            'json'    => $data,
+        ]);
+    }
+
+    /**
+     * Low-level access for uncommon HTTP methods or options
+     */
+    public function request(string $method, string $uri, array $options = []): array
+    {
+        $url = $this->fullUrl($uri);
+        $options['timeout'] = $options['timeout'] ?? $this->config->timeout;
+
+        $response = $this->http->request(strtoupper($method), $url, $options);
+
+        $status = $response->getStatusCode();
+        $body   = (string) $response->getBody();
+
+        $decoded = null;
+        if ($this->isJson($body)) {
+            $decoded = json_decode($body, true);
+        }
+
+        return [
+            'ok'        => $status >= 200 && $status < 300,
+            'status'    => $status,
+            'headers'   => $response->getHeaderLine('Content-Type'),
+            'data'      => $decoded,
+            'raw'       => $decoded === null ? $body : null,
+        ];
+    }
+
+    protected function fullUrl(string $uri): string
+    {
+        if (preg_match('#^https?://#i', $uri)) {
+            return $uri;
+        }
+
+        $base = rtrim($this->config->baseURL ?? '', '/');
+        if ($base === '') {
+            return '/' . ltrim($uri, '/');
+        }
+        return $base . '/' . ltrim($uri, '/');
+    }
+
+    protected function mergeHeaders(array $override = [], array $extra = []): array
+    {
+        $base = $this->config->defaultHeaders ?? [];
+        return array_filter(array_merge($base, $extra, $override), static function ($v) {
+            return $v !== null && $v !== '';
+        });
+    }
+
+    protected function isJson(string $string): bool
+    {
+        json_decode($string);
+        return json_last_error() === JSON_ERROR_NONE;
+    }
+}
+
+?>
+
diff --git a/app/Http/Controllers/old/BroadcastEmailController.php b/app/Http/Controllers/old/BroadcastEmailController.php
deleted file mode 100644
index bdeab9d7..00000000
--- a/app/Http/Controllers/old/BroadcastEmailController.php
+++ /dev/null
@@ -1,256 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Controllers\BaseController;
-use App\Models\UserModel;
-use App\Services\EmailService;
-
-class BroadcastEmailController extends BaseController
-{
-    protected UserModel $userModel;
-    protected EmailService $mailer;
-
-    public function __construct()
-    {
-        $this->userModel = new UserModel();
-        $this->mailer    = new EmailService(); // use your existing mailer unmodified
-    }
-
-    public function index()
-    {
-        helper(['form']);
-
-        // Parents via your role-based function
-        $parents = $this->userModel->getParents();
-        $parents = array_values(array_filter($parents, static fn($p) => !empty($p['email'])));
-
-        // Sender list from MAIL_SENDERS directly (no change to EmailService)
-        $fromOptions = $this->senderOptionsFromEnv();
-
-        return view('administrator/broadcast_email', [
-            'parents'     => $parents,
-            'fromOptions' => $fromOptions, // [['key'=>'general','label'=>'Al Rahma Office <office@...>'], ...]
-        ]);
-    }
-
-    public function send()
-    {
-        helper(['form']);
-
-        if (strtolower($this->request->getMethod()) !== 'post') {
-            return redirect()->to(site_url('admin/broadcast-email'));
-        }
-
-        $isTestOnly = $this->request->getPost('send_test_only') !== null;
-
-        $mode      = (string) $this->request->getPost('mode'); // 'personalized' | 'standard'
-        $subject   = trim((string) $this->request->getPost('subject'));
-        $fromKey   = trim((string) $this->request->getPost('from_key') ?: 'general');
-        $body      = (string) $this->request->getPost('body_html');
-        $body      = $this->sanitizeEmailHtml($body);
-
-
-        // Layout options
-        $wrapLayout = (bool) $this->request->getPost('wrap_layout');
-        $preheader  = (string) ($this->request->getPost('preheader') ?? '');
-        $ctaText    = (string) ($this->request->getPost('cta_text') ?? '');
-        $ctaUrl     = (string) ($this->request->getPost('cta_url') ?? '');
-
-        $testEmail  = trim((string) $this->request->getPost('test_email'));
-
-        if ($subject === '' || $body === '') {
-            return redirect()->back()->withInput()->with('error', 'Subject and Body are required.');
-        }
-
-        $isPersonalized = ($mode === 'personalized');
-
-        // --- TEST ONLY ---
-        if ($isTestOnly) {
-            if ($testEmail === '') {
-                return redirect()->back()->withInput()->with('error', 'Provide a test email address.');
-            }
-
-            $recipientName = 'Parent';
-            $html = $this->composeEmailHtml(
-                $wrapLayout,
-                $subject,
-                $body,
-                $recipientName,
-                $preheader,
-                $ctaText,
-                $ctaUrl,
-                $isPersonalized
-            );
-
-            $ok = $this->mailer->send($testEmail, '[TEST] ' . $subject, $html, $fromKey);
-            return redirect()->back()->with(
-                $ok ? 'message' : 'error',
-                $ok ? "Test email sent to {$testEmail}." : "Test email failed (mailer->send() returned false). Check logs."
-            );
-        }
-
-        // --- BROADCAST ---
-        $rawIds = (array) ($this->request->getPost('parent_ids') ?? []);
-        $ids    = [];
-        foreach ($rawIds as $v) {
-            if (is_string($v) && strpos($v, ',') !== false) {
-                $ids = array_merge($ids, array_map('intval', explode(',', $v)));
-            } else {
-                $ids[] = (int) $v;
-            }
-        }
-        $ids = array_values(array_unique(array_filter($ids)));
-
-        if (empty($ids)) {
-            return redirect()->back()->withInput()->with('error', 'Please select at least one parent.');
-        }
-
-        $rows = model(\App\Models\UserModel::class)
-            ->select('users.id, users.email, CONCAT(users.firstname, " ", users.lastname) AS name')
-            ->whereIn('users.id', $ids)
-            ->where('users.email IS NOT NULL AND users.email != ""')
-            ->findAll();
-
-        if (empty($rows)) {
-            return redirect()->back()->withInput()->with('error', 'No valid parent emails found.');
-        }
-
-        $stats = ['attempted' => 0, 'sent' => 0, 'failed' => 0, 'mode' => $mode];
-
-        foreach ($rows as $r) {
-            $stats['attempted']++;
-            $recipientName = $r['name'] ?: 'Parent';
-
-            $html = $this->composeEmailHtml(
-                $wrapLayout,
-                $subject,
-                $body,
-                $recipientName,
-                $preheader,
-                $ctaText,
-                $ctaUrl,
-                $isPersonalized
-            );
-
-            $ok = $this->mailer->send($r['email'], $subject, $html, $fromKey);
-            $ok ? $stats['sent']++ : $stats['failed']++;
-        }
-
-        $msg = "Broadcast finished. Mode: {$stats['mode']}. Sent: {$stats['sent']}/{$stats['attempted']}. Failures: {$stats['failed']}.";
-        return redirect()->to(site_url('admin/broadcast-email'))
-            ->with($stats['failed'] > 0 ? 'error' : 'message', $msg);
-    }
-
-
-    /**
-     * Build HTML: optionally wrap $body inside your view('layout/email_layout', ...).
-     */
-    private function composeEmailHtml(
-        bool $wrap,
-        string $subject,
-        string $body,
-        string $recipientName,
-        string $preheader = '',
-        string $ctaText = '',
-        string $ctaUrl = '',
-        bool $doPersonalize = true
-    ): string {
-        $content = $doPersonalize ? str_replace('{{name}}', $recipientName, $body) : $body;
-
-        if (!$wrap) {
-            return $content; // raw body
-        }
-
-        // Render a CHILD view that defines the section your layout expects
-        return view('emails/broadcast_wrapper', [
-            'subject'   => $subject,
-            'content'   => $content,
-            // pass more if you later wire them in your layout
-            'preheader' => $preheader,
-            'cta_text'  => $ctaText,
-            'cta_url'   => $ctaUrl,
-        ]);
-    }
-
-
-    private function sanitizeEmailHtml(string $html): string
-    {
-        // Remove <script> and <iframe> blocks (cheap and effective for admin inputs)
-        $html = preg_replace('#<(script|iframe)[^>]*>.*?</\1>#is', '', $html);
-        // Optionally strip on* event handlers (onclick, etc.)
-        $html = preg_replace('/\son\w+="[^"]*"/i', '', $html);
-        $html = preg_replace("/\son\w+='[^']*'/i", '', $html);
-        return $html;
-    }
-
-
-
-    /**
-     * Read MAIL_SENDERS from .env so we don’t need changes in EmailService.
-     * Returns [['key' => 'general', 'label' => 'Al Rahma Office <office@...>'], ...]
-     */
-    private function senderOptionsFromEnv(): array
-    {
-        $json = env('MAIL_SENDERS', '{}');
-        $arr  = json_decode($json, true);
-        if (!is_array($arr) || empty($arr)) {
-            // Fallback to SMTP_USER as a single "general" option
-            $smtpUser = getenv('SMTP_USER') ?: '';
-            $name     = 'Al Rahma Sunday School';
-            return [['key' => 'general', 'label' => $name . ($smtpUser ? " <{$smtpUser}>" : '')]];
-        }
-
-        $out = [];
-        foreach ($arr as $key => $info) {
-            $nm = $info['name']  ?? 'Sender';
-            $em = $info['email'] ?? '';
-            $out[] = ['key' => (string)$key, 'label' => trim($nm . ($em ? " <{$em}>" : ''))];
-        }
-        return $out;
-    }
-
-public function uploadImage()
-{
-    if (strtolower($this->request->getMethod()) !== 'post') {
-        return $this->response->setStatusCode(405)->setJSON(['success' => false, 'error' => 'Method not allowed']);
-    }
-
-    $file = $this->request->getFile('image');
-    if (!$file || !$file->isValid()) {
-        return $this->response->setStatusCode(400)->setJSON(['success' => false, 'error' => 'No image uploaded']);
-    }
-
-    $mime = strtolower((string) $file->getMimeType());
-    $allowed = ['image/jpeg' => 'jpg', 'image/png' => 'png', 'image/gif' => 'gif', 'image/webp' => 'webp'];
-    if (!isset($allowed[$mime])) {
-        return $this->response->setStatusCode(415)->setJSON(['success' => false, 'error' => 'Unsupported image type']);
-    }
-    if ($file->getSize() > 5 * 1024 * 1024) {
-        return $this->response->setStatusCode(413)->setJSON(['success' => false, 'error' => 'Image too large (max 5MB)']);
-    }
-
-    $targetDir = rtrim(FCPATH, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . 'uploads' . DIRECTORY_SEPARATOR . 'email';
-    if (!is_dir($targetDir)) {
-        @mkdir($targetDir, 0755, true);
-    }
-
-    $ext     = $allowed[$mime];
-    $newName = uniqid('em_', true) . '.' . $ext;
-    $file->move($targetDir, $newName, true);
-
-    helper('url');
-    $url = base_url('uploads/email/' . $newName);
-
-    // 👈 send the rotated token back both in JSON and a response header
-    $newHash = function_exists('csrf_hash') ? csrf_hash() : null;
-    return $this->response
-        ->setHeader('X-CSRF-HASH', (string) $newHash)
-        ->setJSON([
-            'success'   => true,
-            'url'       => $url,
-            'csrf_hash' => $newHash,
-        ]);
-}
-
-}
diff --git a/app/Http/Controllers/old/ClassPrepController.php b/app/Http/Controllers/old/ClassPrepController.php
deleted file mode 100644
index d8377773..00000000
--- a/app/Http/Controllers/old/ClassPrepController.php
+++ /dev/null
@@ -1,307 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-class ClassPrepController extends PrintablesBaseController
-{
-    // Compute per-student sticker counts for entire schoolYear (optionally semester).
-    protected function computeStickerCountsAll(\CodeIgniter\Database\BaseConnection $db, string $schoolYear, ?string $semester = null): array
-    {
-        return $this->computeStickerCounts($schoolYear, null, $semester);
-    }
-
-    // Compute per-student sticker counts for one class section.
-    protected function computeStickerCountsForClass(\CodeIgniter\Database\BaseConnection $db, string $schoolYear, int $classSectionId, ?string $semester = null): array
-    {
-        return $this->computeStickerCounts($schoolYear, $classSectionId, $semester);
-    }
-
-    protected function computeStickerCounts(
-        string $schoolYear,
-        ?int $classSectionId,
-        ?string $semester
-    ): array {
-        $specialMap   = ['KG' => 1, '1-A' => 3, '1-B' => 4, '2-A' => 5, '2-B' => 5, '9' => 2];
-        $isUpperBlock = static fn(string $g) => (bool) preg_match('/^(3|4|5|6|7|8)(-[AB])?$/', trim($g));
-        $isGrade5     = static fn(string $g) => (bool) preg_match('/^5(\-|$)/', trim($g));
-
-        $b = $this->db->table('student_class sc')
-            ->select('sc.student_id, s.firstname, s.lastname, s.is_new, cs.class_section_name AS grade_label')
-            ->join('students s', 's.id = sc.student_id', 'inner')
-            ->join('classSection cs', 'cs.class_section_id = sc.class_section_id', 'inner')
-            ->join('classes c', 'c.id = cs.class_id', 'inner')
-            ->where('sc.school_year', $schoolYear);
-
-        if (!empty($classSectionId)) {
-            $b->where('sc.class_section_id', $classSectionId);
-        }
-
-        $rows = $b->get()->getResultArray();
-
-        // Exclude Youth and KG (case-insensitive; also ignore variants like youth-*, KG-*)
-        $rows = array_values(array_filter($rows, static function ($r) {
-            $g = trim((string) $r['grade_label']);
-            return $g !== ''
-                && !preg_match('/^youth(?:\b|-)/i', $g)
-                && !preg_match('/^kg(?:\b|-)/i', $g);
-        }));
-
-        $students = [];
-        $total    = 0;
-
-        foreach ($rows as $r) {
-            $g     = trim((string) $r['grade_label']);
-            $isNew = ((int) $r['is_new']) === 1;
-
-            // Primary-only rules
-            if (array_key_exists($g, $specialMap)) {
-                $p = $specialMap[$g];
-            } elseif ($isUpperBlock($g)) {
-                $p = $isNew ? 4 : ($isGrade5($g) ? 3 : 2);
-            } else {
-                $p = 4;
-            }
-
-            $total += $p;
-
-            $students[] = [
-                'student_id'    => (int) $r['student_id'],
-                'firstname'     => trim($r['firstname']),
-                'lastname'      => trim($r['lastname']),
-                'grade_label'   => $g,
-                'primary_count' => $p,
-            ];
-        }
-
-        return [
-            'students' => $students,
-            'totals'   => [
-                'stickers' => $total,
-                'students' => count($students),
-            ],
-        ];
-    }
-
-    /**
-     * Compute sticker counts per student (no file I/O).
-     *
-     * @param BaseConnection $db
-     * @param string         $schoolYear e.g. "2025-2026"
-     * @param string|null    $semester   e.g. "Fall" (optional filter)
-     * @return array{
-     *   students: array<int, array{
-     *     student_id:int,
-     *     firstname:string,
-     *     lastname:string,
-     *     grade_label:string,
-     *     primary_count:int,
-     *     secondary_count:int
-     *   }>,
-     *   totals: array{primary:int, secondary:int, students:int}
-     * }
-     */
-    private function getStickerCountsPerStudent(string $schoolYear, ?string $semester = null): array
-    {
-        // --- Sticker rules helpers ----------------------------------------------
-        $specialMap = [
-            'KG' => 1,
-            '1-A' => 3,
-            '1-B' => 4,
-            '2-A' => 5,
-            '2-B' => 5,
-            '9'   => 2,
-        ];
-        $isUpperBlock = static function (string $g): bool {
-            // 3-A, 3-B, 4-A, 4-B, 5-A, 5-B, 6, 7, 8 (also allow plain 3/4/5/6/7/8)
-            return (bool) preg_match('/^(3|4|5|6|7|8)(-[AB])?$/', trim($g));
-        };
-        $isGrade5 = static function (string $g): bool {
-            // "5" OR "5-A"/"5-B"
-            return (bool) preg_match('/^5(\-|$)/', trim($g));
-        };
-
-        // --- Pull roster: student_class -> classSection -> classes -> students ---
-        $builder = $this->db->table('student_class sc')
-            ->select([
-                'sc.student_id',
-                's.firstname',
-                's.lastname',
-                's.is_new',
-                'cs.class_section_name AS grade_label',
-            ])
-            ->join('students s', 's.id = sc.student_id')
-            ->join('classSection cs', 'cs.class_section_id = sc.class_section_id')
-            ->join('classes c', 'c.id = cs.class_id')
-            ->where('sc.school_year', $schoolYear);
-
-
-        $rows = $builder->get()->getResultArray();
-
-        // Filter out Youth (any case; includes youth-*), and empty labels
-        $rows = array_values(array_filter($rows, static function ($r) {
-            $g = trim((string) $r['grade_label']);
-            return $g !== '' && strcasecmp($g, 'youth') !== 0 && strncasecmp($g, 'youth-', 6) !== 0;
-        }));
-
-        $out = [];
-        $totalPrimary = 0;
-        $totalSecondary = 0;
-
-        foreach ($rows as $r) {
-            $first = trim((string) $r['firstname']);
-            $last  = trim((string) $r['lastname']);
-            $grade = trim((string) $r['grade_label']);
-            $isNew = ((int) $r['is_new']) === 1;
-
-            $primary = 0;
-            $secondary = 0;
-
-            // 1) Special fixed grades
-            if (array_key_exists($grade, $specialMap)) {
-                $primary = (int) $specialMap[$grade];
-                $secondary = 0;
-            }
-            // 2) Upper block 3..8
-            elseif ($isUpperBlock($grade)) {
-                if ($isNew) {
-                    $primary = 4;
-                    $secondary = 0;
-                } else {
-                    $primary = $isGrade5($grade) ? 3 : 2;
-                    $secondary = max(0, 4 - $primary);
-                }
-            }
-            // 3) Fallback for other non-Youth labels (e.g., "1", "2", "10", "11")
-            else {
-                $primary = 4;
-                $secondary = 0;
-            }
-
-            $totalPrimary  += $primary;
-            $totalSecondary += $secondary;
-
-            $out[] = [
-                'student_id'     => (int) $r['student_id'],
-                'firstname'      => $first,
-                'lastname'       => $last,
-                'grade_label'    => $grade,
-                'primary_count'  => $primary,
-                'secondary_count' => $secondary,
-            ];
-        }
-
-        return [
-            'students' => $out,
-            'totals' => [
-                'primary'  => $totalPrimary,
-                'secondary' => $totalSecondary,
-                'students' => count($out),
-            ],
-        ];
-    }
-
-    protected function getStickerCountsPerStudentForClass(
-        string $schoolYear,
-        int $classSectionId,
-        ?string $semester = null
-    ): array {
-        // Reuse exact helpers/rules from getStickerCountsPerStudent()
-        $specialMap = [
-            '1-A' => 3,
-            '1-B' => 4,
-            '2-A' => 5,
-            '2-B' => 5,
-            '9' => 2,
-        ];
-        $isUpperBlock = static fn($g) => (bool) preg_match('/^(3|4|5|6|7|8)(-[AB])?$/', trim($g));
-        $isGrade5     = static fn($g) => (bool) preg_match('/^5(\-|$)/', trim($g));
-
-        $b = $this->db->table('student_class sc')
-            ->select('sc.student_id, s.firstname, s.lastname, s.is_new, cs.class_section_name AS grade_label')
-            ->join('students s', 's.id = sc.student_id')
-            ->join('classSection cs', 'cs.class_section_id = sc.class_section_id')
-            ->join('classes c', 'c.id = cs.class_id')
-            ->where('sc.school_year', $schoolYear)
-            ->where('sc.class_section_id', $classSectionId);
-
-
-        $rows = $b->get()->getResultArray();
-
-        $rows = array_values(array_filter($rows, static function ($r) {
-            $g = trim((string) $r['grade_label']);
-            return $g !== '' && strcasecmp($g, 'youth') !== 0 && strncasecmp($g, 'youth-', 6) !== 0;
-        }));
-
-        $out = [];
-        $tp = 0;
-        $ts = 0;
-        foreach ($rows as $r) {
-            $g = trim((string) $r['grade_label']);
-            $isNew = ((int) $r['is_new']) === 1;
-            $p = 0;
-            $s = 0;
-
-            if (isset($specialMap[$g])) {
-                $p = $specialMap[$g];
-            } elseif ($isUpperBlock($g)) {
-                if ($isNew) {
-                    $p = 4;
-                } else {
-                    $p = $isGrade5($g) ? 3 : 2;
-                    $s = max(0, 4 - $p);
-                }
-            } else {
-                $p = 4;
-            }
-
-            $tp += $p;
-            $ts += $s;
-
-            $out[] = [
-                'student_id'      => (int) $r['student_id'],
-                'firstname'       => trim($r['firstname']),
-                'lastname'        => trim($r['lastname']),
-                'grade_label'     => $g,
-                'primary_count'   => $p,
-                'secondary_count' => $s,
-            ];
-        }
-
-        return ['students' => $out, 'totals' => ['primary' => $tp, 'secondary' => $ts, 'students' => count($out)]];
-    }
-
-    public function previewStickerCounts()
-    {
-        // Optional: allow class_id filter; if present, preview only that class
-        $classId = (int) ($this->request->getGet('class_id') ?? 0);
-
-        if ($classId > 0) {
-            // same join as getStickerCountsPerStudent but add class filter
-            $result = $this->getStickerCountsPerStudentForClass($this->schoolYear, $classId, $this->semester);
-        } else {
-            // whole school year
-            $result = $this->getStickerCountsPerStudent($this->schoolYear, $this->semester);
-        }
-
-        return $this->response->setJSON([
-            'status' => 'ok',
-            'data'   => $result
-        ]);
-    }
-
-    public function studentsByClass(int $classSectionId)
-    {
-        $rows = $this->studentModel
-            ->select('students.id, students.firstname, students.lastname, students.gender, cs.class_section_name AS registration_grade')
-            ->join('student_class sc', 'sc.student_id = students.id', 'inner')
-            ->join('classSection cs', 'cs.class_section_id = sc.class_section_id', 'inner')
-            ->where('sc.school_year', $this->schoolYear)
-            ->where('sc.class_section_id', $classSectionId)
-            ->groupBy('students.id, students.firstname, students.lastname, students.gender, cs.class_section_name')
-            ->orderBy('students.firstname', 'ASC')
-            ->orderBy('students.lastname', 'ASC')
-            ->findAll(1000);
-
-        return $this->response->setJSON($rows);
-    }
-}
diff --git a/app/Http/Controllers/old/ClassPreparationController.php b/app/Http/Controllers/old/ClassPreparationController.php
deleted file mode 100644
index db9456e5..00000000
--- a/app/Http/Controllers/old/ClassPreparationController.php
+++ /dev/null
@@ -1,616 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Controllers\BaseController;
-use App\Models\StudentClassModel;
-use App\Models\ClassPreparationLogModel;
-use App\Models\ConfigurationModel;
-use App\Models\ClassSectionModel;
-use App\Models\ClassPrepAdjustmentModel;
-use App\Models\UserModel;
-
-class ClassPreparationController extends BaseController
-{
-    protected $studentClassModel;
-    protected $prepLogModel;
-    protected $classSectionModel;
-    protected $configModel;
-    protected $userModel;
-    protected $db;
-    protected $schoolYear;
-    protected $semester;
-    protected $adjustmentModel;
-    /** cache for roster presence per term */
-    private array $rosterPresenceCache = [];
-    // Inside ClassPreparationController (class scope, not inside a method)
-    private array $allowedPrepCategories = [
-        'Grade Box',
-        'Large Table',
-        'Regular Chair',
-        'Small Chair',
-        'Small Table',
-        'Teacher Chair',
-        'Trash Bin',
-        'White Board',
-    ];
-
-
-    public function __construct()
-    {
-        $this->studentClassModel = new StudentClassModel();
-        $this->prepLogModel      = new ClassPreparationLogModel();
-        $this->classSectionModel = new ClassSectionModel();
-        $this->configModel = new ConfigurationModel();
-        $this->adjustmentModel = new ClassPrepAdjustmentModel();
-
-        $this->userModel = new UserModel();
-        $this->db = \Config\Database::connect();
-
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester = $this->configModel->getConfig('semester');
-    }
-
-    public function index()
-    {
-        $schoolYear = (string)($this->request->getGet('school_year') ?? $this->schoolYear);
-        $semParam   = $this->request->getGet('semester');
-        $semester   = (is_string($semParam) && $semParam !== '') ? (string)$semParam : (string)$this->semester;
-        $allowed    = $this->allowedPrepCategories;
-        $limitToSemester = $this->hasRosterForSemester($schoolYear, $semester);
-
-        // 1) Get student count per class-section (distinct students, correct semester)
-        $scQ = $this->db->table('student_class sc')
-            ->select('sc.class_section_id, COUNT(DISTINCT sc.student_id) AS student_count', false)
-            ->join('students s', 's.id = sc.student_id', 'inner')
-            ->where('s.is_active', 1)
-            ->where('sc.school_year', $schoolYear);
-        if ($limitToSemester && $semester !== '') {
-            $scQ->where('sc.semester', $semester);
-        }
-        $classSections = $scQ->groupBy('sc.class_section_id')->get()->getResultArray();
-
-        // 2) Inventory availability — prefer good_qty when present, else condition='good' quantity.
-        $inventoryMap = $this->buildInventoryAvailability($schoolYear, $semester, $limitToSemester, $allowed);
-
-        // Seed totals with allowed categories for stable ordering
-        $requiredTotals = array_fill_keys($allowed, 0);
-        $prepResults    = [];
-
-        // 3) Build prep per section (once!)
-        foreach ($classSections as $section) {
-            $classSectionId = $section['class_section_id'];
-            $studentCount   = (int)$section['student_count'];
-            $classLevel     = $this->getClassLevelBySection($classSectionId);
-            $className      = $this->classSectionModel->getClassSectionNameBySectionId($classSectionId);
-
-            // Calculate required items (whitelist inside)
-            $baseItems = $this->calculatePrepItems($studentCount, $classLevel, $classSectionId);
-
-            // --- Apply adjustments (only Small/Large Table), clamp >= 0 ---
-            $rawAdjustments = $this->adjustmentModel
-                ->where('class_section_id', $classSectionId)
-                ->where('school_year', $schoolYear)
-                ->where('adjustable', 1)
-                ->findAll();
-
-            $adjMap = ['Large Table' => 0, 'Small Table' => 0];
-
-            foreach ($rawAdjustments as $a) {
-                $item  = $a['item_name'];
-                $delta = (int)$a['adjustment'];
-
-                if (array_key_exists($item, $adjMap)) {
-                    $adjMap[$item] = $delta;
-                }
-
-                if (isset($baseItems[$item])) {
-                    $baseItems[$item] = max(0, (int)$baseItems[$item] + $delta);
-                } elseif (in_array($item, $allowed, true)) {
-                    $baseItems[$item] = max(0, $delta);
-                }
-            }
-
-            // 4) Accumulate global totals (allowed only)
-            foreach ($allowed as $cat) {
-                $requiredTotals[$cat] += (int)($baseItems[$cat] ?? 0);
-            }
-
-            // 5) Compare with last snapshot; do not save here — only on print or explicit API
-            $oldSnap = $this->prepLogModel
-                ->where('class_section_id', $classSectionId)
-                ->where('school_year', $schoolYear)
-                ->orderBy('created_at', 'DESC')
-                ->first();
-
-            $oldPrep    = $oldSnap ? json_decode($oldSnap['prep_data'], true) : [];
-            $hasChanged = $this->hasPrepChanged($baseItems, $oldPrep);
-
-            // 6) Push exactly ONCE
-            $prepResults[] = [
-                'class_section'    => $className,
-                'class_section_id' => $classSectionId,
-                'student_count'    => $studentCount,
-                'class_level'      => $classLevel,
-                'prep_items'       => $baseItems,
-                'needs_print'      => $hasChanged,
-                'last_printed_at'  => $oldSnap['created_at'] ?? null,
-                'adjustments'      => $adjMap,
-            ];
-        }
-
-        // 7) Shortages (compare totals vs inventory)
-        $shortages = [];
-        foreach ($requiredTotals as $item => $reqQty) {
-            $have = (int)($inventoryMap[$item] ?? 0);
-            if ($have < (int)$reqQty) {
-                $shortages[$item] = (int)$reqQty - $have;
-            }
-        }
-
-        return view('class_prep/list', [
-            'prepResults' => $prepResults,
-            'schoolYear'  => $schoolYear,
-            'semester'    => $semester,
-            'shortages'   => $shortages,
-            'totalNeeded' => $requiredTotals,
-            'available'   => $inventoryMap,
-            // For temporary debugging, you can pass these too:
-            // 'joinGood' => $joinGood, 'nameGood' => $nameGood, 'joinCond' => $joinCond, 'nameCond' => $nameCond,
-        ]);
-    }
-
-    private function getTeacherCountForSection(string $classSectionId, ?string $schoolYear = null): int
-    {
-        $schoolYear = $schoolYear ?? $this->schoolYear;
-
-        // positions: 'main' and 'ta' (per your new schema)
-        $row = $this->db->table('teacher_class')
-            ->select('COUNT(*) AS cnt')
-            ->where('class_section_id', $classSectionId)
-            ->whereIn('position', ['main', 'ta'])
-            ->where('school_year', $schoolYear)
-            ->get()->getRowArray();
-
-        return (int)($row['cnt'] ?? 0);
-    }
-
-    private function calculatePrepItems(int $students, int $classLevel, string $classSectionId): array
-    {
-        // 1) Stable keys: your whitelist, all zero to start
-        $allowed = $this->allowedPrepCategories;
-        $items   = array_fill_keys($allowed, 0);
-
-        // 2) Fetch only the classroom categories you care about (optionally with grade bounds)
-        $categories = $this->db->table('inventory_categories')
-            ->select('name, grade_min, grade_max')
-            ->where('type', 'classroom')
-            ->whereIn('name', $allowed)
-            ->orderBy('name')
-            ->get()
-            ->getResultArray();
-
-        // 3) Rules
-        $isLowerGrades = in_array($classLevel, [1, 2], true);
-        $teacherCount  = $this->getTeacherCountForSection($classSectionId, $this->schoolYear);
-
-        foreach ($categories as $cat) {
-            $name     = $cat['name'];      // e.g., 'Small Table'
-            $gradeMin = $cat['grade_min']; // may be null
-            $gradeMax = $cat['grade_max']; // may be null
-
-            // Respect optional bounds
-            if ($gradeMin !== null && $classLevel < (int)$gradeMin) {
-                $items[$name] = 0;
-                continue;
-            }
-            if ($gradeMax !== null && $classLevel > (int)$gradeMax) {
-                $items[$name] = 0;
-                continue;
-            }
-
-            $qty = 0;
-            switch (strtolower($name)) {
-                case 'small table':
-                    $qty = $isLowerGrades ? (int)ceil($students / 3) : 0;
-                    break;
-                case 'large table':
-                    $qty = $isLowerGrades ? 0 : (int)ceil($students / 4);
-                    break;
-                case 'small chair':
-                    $qty = $isLowerGrades ? $students : 0;
-                    break;
-                case 'regular chair':
-                    $qty = $isLowerGrades ? 0 : $students;
-                    break;
-                case 'teacher chair':
-                    $qty = (int)$teacherCount;
-                    break;
-                case 'trash bin':
-                case 'white board':
-                case 'grade box':
-                    $qty = 1;
-                    break;
-                default:
-                    $qty = 0;
-            }
-
-            // Only set for allowed keys (guards against unexpected DB rows)
-            if (array_key_exists($name, $items)) {
-                $items[$name] = $qty;
-            }
-        }
-
-        return $items;
-    }
-
-
-    public function saveAdjustment()
-    {
-        $data = $this->request->getPost();
-        $sectionId = $data['class_section_id'];
-        $schoolYear = $data['school_year'];
-        $adjustments = $data['adjustments'] ?? [];
-
-        foreach ($adjustments as $itemName => $adjustment) {
-            $row = $this->adjustmentModel
-                ->where('class_section_id', $sectionId)
-                ->where('school_year', $schoolYear)
-                ->where('item_name', $itemName)
-                ->first();
-
-            if ($row) {
-                // Update
-                $this->adjustmentModel->update($row['id'], ['adjustment' => (int)$adjustment, 'adjustable' => 1]);
-            } else {
-                // Insert
-                $this->adjustmentModel->insert([
-                    'class_section_id' => $sectionId,
-                    'item_name'        => $itemName,
-                    'adjustment'       => (int)$adjustment,
-                    'school_year'      => $schoolYear,
-                    'adjustable'       => 1,
-                ]);
-            }
-        }
-
-        return redirect()->to(site_url('class-prep?school_year=' . urlencode($schoolYear)))
-            ->with('success', 'Adjustments saved successfully.');
-    }
-
-
-
-    /* ---------- helpers ---------- */
-
-    private function hasPrepChanged(array $new, array $old): bool
-    {
-        ksort($new);
-        ksort($old);
-
-        return json_encode($new) !== json_encode($old);
-    }
-
-    public function print($classSectionId, $schoolYear)
-    {
-        $semParam = $this->request->getGet('semester');
-        $semester = (is_string($semParam) && $semParam !== '') ? (string) $semParam : (string) $this->semester;
-        $limitToSemester = $this->hasRosterForSemester((string) $schoolYear, $semester);
-
-        // Friendly label (if you have this helper)
-        $className = $this->classSectionModel->getClassSectionNameBySectionId($classSectionId) ?? $classSectionId;
-
-        // Distinct student count for this term
-        $studentQ = $this->db->table('student_class sc')
-            ->select('COUNT(DISTINCT sc.student_id) AS cnt', false)
-            ->join('students s', 's.id = sc.student_id', 'inner')
-            ->where('s.is_active', 1)
-            ->where('sc.class_section_id', $classSectionId)
-            ->where('sc.school_year', $schoolYear);
-        if ($limitToSemester && $semester !== '') {
-            $studentQ->where('sc.semester', $semester);
-        }
-        $studentRow = $studentQ->get()->getRowArray();
-        $studentCount = (int)($studentRow['cnt'] ?? 0);
-
-        // Live calc + adjustments
-        $classLevel = $this->getClassLevelBySection((string)$classSectionId);
-        $items      = $this->calculatePrepItems($studentCount, $classLevel, (string)$classSectionId);
-
-        $rawAdjustments = $this->adjustmentModel
-            ->where('class_section_id', $classSectionId)
-            ->where('school_year', $schoolYear)
-            ->where('adjustable', 1)
-            ->findAll();
-        foreach ($rawAdjustments as $a) {
-            $item  = $a['item_name'];
-            $delta = (int)$a['adjustment'];
-            if (isset($items[$item])) $items[$item] = max(0, (int)$items[$item] + $delta);
-        }
-
-        // Record a snapshot at print time as the new baseline
-        $this->prepLogModel->insert([
-            'class_section_id' => (string)$classSectionId,
-            'class_section'    => $className,
-            'school_year'      => $schoolYear,
-            'prep_data'        => json_encode($items),
-            'created_at'       => utc_now(),
-        ]);
-
-        // Return PRINT view (HTML) that auto-opens the print dialog
-        return view('class_prep/print', [
-            'classSectionId' => $classSectionId,
-            'classSection'   => $className,
-            'schoolYear'     => $schoolYear,
-            'prepItems'      => $items,
-        ]);
-    }
-
-    /**
-     * API: Return class prep data and change flags for all sections in a year.
-     * GET: school_year
-     * Response: { ok, schoolYear, results:[{ class_section_id, class_section, student_count, class_level, prep_items, needs_print, last_printed_at }], totals, shortages }
-     */
-    public function apiList()
-    {
-        $schoolYear = (string)($this->request->getGet('school_year') ?? $this->schoolYear);
-        $semParam   = $this->request->getGet('semester');
-        $semester   = (is_string($semParam) && $semParam !== '') ? (string)$semParam : (string)$this->semester;
-        $allowed    = $this->allowedPrepCategories;
-        $limitToSemester = $this->hasRosterForSemester($schoolYear, $semester);
-
-        // Student counts
-        $scQ = $this->db->table('student_class sc')
-            ->select('sc.class_section_id, COUNT(DISTINCT sc.student_id) AS student_count', false)
-            ->join('students s', 's.id = sc.student_id', 'inner')
-            ->where('s.is_active', 1)
-            ->where('sc.school_year', $schoolYear);
-        if ($limitToSemester && $semester !== '') {
-            $scQ->where('sc.semester', $semester);
-        }
-        $classSections = $scQ->groupBy('sc.class_section_id')->get()->getResultArray();
-
-        // Build inventory availability maps
-        $inventoryMap = $this->buildInventoryAvailability($schoolYear, $semester, $limitToSemester, $allowed);
-
-        $requiredTotals = array_fill_keys($allowed, 0);
-        $results = [];
-
-        foreach ($classSections as $row) {
-            $classSectionId = (string)$row['class_section_id'];
-            $studentCount   = (int)$row['student_count'];
-            $classLevel     = $this->getClassLevelBySection($classSectionId);
-            $className      = $this->classSectionModel->getClassSectionNameBySectionId($classSectionId);
-
-            $baseItems = $this->calculatePrepItems($studentCount, $classLevel, $classSectionId);
-            $rawAdjustments = $this->adjustmentModel
-                ->where('class_section_id', $classSectionId)
-                ->where('school_year', $schoolYear)
-                ->where('adjustable', 1)
-                ->findAll();
-            $adjMap = ['Large Table' => 0, 'Small Table' => 0];
-            foreach ($rawAdjustments as $a) {
-                $item  = $a['item_name'];
-                $delta = (int)$a['adjustment'];
-                if (array_key_exists($item, $adjMap)) $adjMap[$item] = $delta;
-                if (isset($baseItems[$item])) $baseItems[$item] = max(0, (int)$baseItems[$item] + $delta);
-            }
-
-            foreach ($allowed as $cat) {
-                $requiredTotals[$cat] += (int)($baseItems[$cat] ?? 0);
-            }
-
-            $oldSnap = $this->prepLogModel
-                ->where('class_section_id', $classSectionId)
-                ->where('school_year', $schoolYear)
-                ->orderBy('created_at', 'DESC')
-                ->first();
-            $oldPrep    = $oldSnap ? json_decode($oldSnap['prep_data'], true) : [];
-            $hasChanged = $this->hasPrepChanged($baseItems, $oldPrep);
-
-            $results[] = [
-                'class_section'    => $className,
-                'class_section_id' => $classSectionId,
-                'student_count'    => $studentCount,
-                'class_level'      => $classLevel,
-                'prep_items'       => $baseItems,
-                'needs_print'      => $hasChanged,
-                'last_printed_at'  => $oldSnap['created_at'] ?? null,
-                'adjustments'      => $adjMap,
-            ];
-        }
-
-        // Shortages
-        $shortages = [];
-        foreach ($requiredTotals as $item => $reqQty) {
-            $have = (int)($inventoryMap[$item] ?? 0);
-            if ($have < (int)$reqQty) $shortages[$item] = (int)$reqQty - $have;
-        }
-
-        return $this->response->setJSON([
-            'ok'          => true,
-            'schoolYear'  => $schoolYear,
-            'results'     => $results,
-            'totals'      => $requiredTotals,
-            'shortages'   => $shortages,
-            'csrf_token'  => csrf_token(),
-            'csrf_hash'   => csrf_hash(),
-        ]);
-    }
-
-    /**
-     * API: Mark selected classes as printed (save baseline snapshot).
-     * POST: school_year, class_section_ids[]
-     */
-    public function apiMarkPrinted()
-    {
-        $schoolYear = (string)($this->request->getPost('school_year') ?? $this->schoolYear);
-        $semParam   = $this->request->getPost('semester');
-        $semester   = (is_string($semParam) && $semParam !== '') ? (string)$semParam : (string)$this->semester;
-        $limitToSemester = $this->hasRosterForSemester($schoolYear, $semester);
-        $ids = $this->request->getPost('class_section_ids') ?? [];
-        if (!is_array($ids)) $ids = $ids ? [$ids] : [];
-        $ids = array_values(array_unique(array_filter(array_map('strval', $ids))));
-
-        $now = utc_now();
-        $count = 0;
-        foreach ($ids as $classSectionId) {
-            $studentQ = $this->db->table('student_class sc')
-                ->select('COUNT(DISTINCT sc.student_id) AS cnt', false)
-                ->join('students s', 's.id = sc.student_id', 'inner')
-                ->where('s.is_active', 1)
-                ->where('sc.class_section_id', $classSectionId)
-                ->where('sc.school_year', $schoolYear);
-            if ($limitToSemester && $semester !== '') {
-                $studentQ->where('sc.semester', $semester);
-            }
-            $studentRow = $studentQ->get()->getRowArray();
-            $studentCount = (int)($studentRow['cnt'] ?? 0);
-            $classLevel   = $this->getClassLevelBySection((string)$classSectionId);
-            $className    = $this->classSectionModel->getClassSectionNameBySectionId($classSectionId) ?? $classSectionId;
-
-            $items = $this->calculatePrepItems($studentCount, $classLevel, (string)$classSectionId);
-
-            $rawAdjustments = $this->adjustmentModel
-                ->where('class_section_id', $classSectionId)
-                ->where('school_year', $schoolYear)
-                ->where('adjustable', 1)
-                ->findAll();
-            foreach ($rawAdjustments as $a) {
-                $item  = $a['item_name'];
-                $delta = (int)$a['adjustment'];
-                if (isset($items[$item])) $items[$item] = max(0, (int)$items[$item] + $delta);
-            }
-
-            try {
-                $this->prepLogModel->insert([
-                    'class_section_id' => (string)$classSectionId,
-                    'class_section'    => $className,
-                    'school_year'      => $schoolYear,
-                    'prep_data'        => json_encode($items),
-                    'created_at'       => $now,
-                ]);
-                $count++;
-            } catch (\Throwable $e) {
-                // ignore and continue
-            }
-        }
-
-        return $this->response->setJSON([
-            'ok'         => true,
-            'updated'    => $count,
-            'csrf_token' => csrf_token(),
-            'csrf_hash'  => csrf_hash(),
-        ]);
-    }
-
-
-    private function getClassLevelBySection(string $classSectionId): int
-    {
-        // Prefer the human-readable section name for grade parsing.
-        $sectionName = $this->classSectionModel->getClassSectionNameBySectionId($classSectionId);
-        $label = $sectionName !== null && $sectionName !== '' ? (string) $sectionName : $classSectionId;
-
-        // If it's clearly Kindergarten (KG/K)
-        if (preg_match('/^(kg|k)(\b|[^a-z0-9])/i', $label)) {
-            return 1; // treat Kindergarten as lower grade
-        }
-
-        // Remove non-digits, then infer by leading digit
-        $numValue = (int) preg_replace('/\D/', '', $label);
-
-        if ($numValue > 0 && $numValue < 30) {
-            $firstDigit = (int) substr((string) $numValue, 0, 1);
-            return $firstDigit === 1 ? 1 : ($firstDigit === 2 ? 2 : 3);
-        }
-
-        // Default to upper grades (3+)
-        return 3;
-    }
-
-    /**
-     * Returns true if student_class has any rows for the given school year.
-     * The semester argument is ignored because assignments are tracked per year.
-     */
-    private function hasRosterForTerm(string $schoolYear, string $semester): bool
-    {
-        $year = trim((string)$schoolYear);
-        if ($year === '') {
-            return false;
-        }
-
-        if (array_key_exists($year, $this->rosterPresenceCache)) {
-            return $this->rosterPresenceCache[$year];
-        }
-
-        $cnt = $this->db->table('student_class')
-            ->where('school_year', $year)
-            ->countAllResults();
-
-        $this->rosterPresenceCache[$year] = $cnt > 0;
-        return $this->rosterPresenceCache[$year];
-    }
-
-    private function hasRosterForSemester(string $schoolYear, string $semester): bool
-    {
-        $year = trim((string)$schoolYear);
-        $sem  = trim((string)$semester);
-        if ($year === '' || $sem === '') {
-            return false;
-        }
-
-        $key = sprintf('sem:%s:%s', $year, $sem);
-        if (array_key_exists($key, $this->rosterPresenceCache)) {
-            return $this->rosterPresenceCache[$key];
-        }
-
-        $cnt = $this->db->table('student_class')
-            ->where('school_year', $year)
-            ->where('semester', $sem)
-            ->countAllResults();
-
-        $this->rosterPresenceCache[$key] = $cnt > 0;
-        return $this->rosterPresenceCache[$key];
-    }
-
-    private function buildInventoryAvailability(string $schoolYear, string $semester, bool $limitToSemester, array $allowed): array
-    {
-        $inventoryMap = array_fill_keys($allowed, 0);
-
-        $joinRows = $this->db->table('inventory_items ii')
-            ->select('ic.name AS item_name, COALESCE(SUM(CASE WHEN ii.good_qty IS NOT NULL THEN ii.good_qty WHEN ii.`condition`="good" THEN ii.quantity ELSE 0 END),0) AS available')
-            ->join('inventory_categories ic', 'ic.id = ii.category_id', 'left')
-            ->where('ii.type', 'classroom')
-            ->where('ii.school_year', $schoolYear)
-            ->whereIn('ic.name', $allowed);
-        if ($limitToSemester && $semester !== '') {
-            $joinRows->where('ii.semester', $semester);
-        }
-        $joinRows = $joinRows->groupBy('ic.name')->get()->getResultArray();
-
-        foreach ($joinRows as $r) {
-            $name = (string)($r['item_name'] ?? '');
-            if ($name !== '' && isset($inventoryMap[$name])) {
-                $inventoryMap[$name] = max($inventoryMap[$name], (int)($r['available'] ?? 0));
-            }
-        }
-
-        $nameRows = $this->db->table('inventory_items')
-            ->select('name AS item_name, COALESCE(SUM(CASE WHEN good_qty IS NOT NULL THEN good_qty WHEN `condition`="good" THEN quantity ELSE 0 END),0) AS available')
-            ->where('type', 'classroom')
-            ->where('school_year', $schoolYear)
-            ->whereIn('name', $allowed);
-        if ($limitToSemester && $semester !== '') {
-            $nameRows->where('semester', $semester);
-        }
-        $nameRows = $nameRows->groupBy('name')->get()->getResultArray();
-
-        foreach ($nameRows as $r) {
-            $name = (string)($r['item_name'] ?? '');
-            if ($name !== '' && isset($inventoryMap[$name])) {
-                $inventoryMap[$name] = max($inventoryMap[$name], (int)($r['available'] ?? 0));
-            }
-        }
-
-        return $inventoryMap;
-    }
-}
diff --git a/app/Http/Controllers/old/CommunicationController.php b/app/Http/Controllers/old/CommunicationController.php
deleted file mode 100644
index 991200d9..00000000
--- a/app/Http/Controllers/old/CommunicationController.php
+++ /dev/null
@@ -1,172 +0,0 @@
-<?php 
-namespace App\Controllers\View;
-
-use App\Controllers\BaseController;
-use App\Models\StudentModel;
-use App\Models\FamilyModel;
-use App\Models\FamilyStudentModel;
-use App\Models\FamilyGuardianModel;
-use App\Models\FamilyCommPrefModel; // optional
-use App\Models\EmailTemplateModel;
-use App\Models\CommunicationLogModel;
-
-class CommunicationController extends BaseController
-{
-    protected StudentModel $studentModel;
-    protected FamilyModel $familyModel;
-    protected FamilyStudentModel $fsModel;
-    protected FamilyGuardianModel $fgModel;
-    protected ?FamilyCommPrefModel $fcpModel = null;
-    protected EmailTemplateModel $templateModel;
-    protected CommunicationLogModel $logModel;
-
-    public function __construct()
-    {
-        $this->studentModel  = new StudentModel();
-        $this->familyModel   = new FamilyModel();
-        $this->fsModel       = new FamilyStudentModel();
-        $this->fgModel       = new FamilyGuardianModel();
-        if (class_exists(FamilyCommPrefModel::class)) {
-            $this->fcpModel = new FamilyCommPrefModel();
-        }
-        $this->templateModel = new EmailTemplateModel();
-        $this->logModel      = new CommunicationLogModel();
-    }
-
-    public function index()
-    {
-        $students  = $this->studentModel->orderBy('lastname, firstname', 'asc')->findAll();
-        $templates = $this->templateModel->getActiveTemplates();
-        return view('communications/index', compact('students','templates'));
-    }
-
-    // AJAX: families for a student
-    public function families(int $studentId)
-    {
-        if (!$this->request->isAJAX()) return $this->response->setStatusCode(400)->setJSON(['error' => 'Bad request']);
-        $families = $this->fsModel->getFamiliesForStudent($studentId);
-        return $this->response->setJSON(['data' => $families]);
-    }
-
-    // AJAX: guardians for a family
-    public function guardians(int $familyId)
-    {
-        if (!$this->request->isAJAX()) return $this->response->setStatusCode(400)->setJSON(['error' => 'Bad request']);
-        $db = \Config\Database::connect();
-        $rows = $db->query("SELECT u.id as user_id, u.firstname, u.lastname, u.email, fg.relation, fg.is_primary, fg.receive_emails, fg.receive_sms\n                             FROM family_guardians fg\n                             JOIN users u ON u.id = fg.user_id\n                             WHERE fg.family_id = ?", [$familyId])->getResultArray();
-        return $this->response->setJSON(['data' => $rows]);
-    }
-
-    public function preview()
-    {
-        if (!$this->request->isAJAX()) return $this->response->setStatusCode(400)->setJSON(['error' => 'Bad request']);
-
-        $templateKey = (string) $this->request->getPost('template_key');
-        $studentId   = (int) $this->request->getPost('student_id');
-        $familyId    = (int) $this->request->getPost('family_id');
-        $varsPost    = $this->request->getPost('vars');
-        $vars        = is_array($varsPost) ? $varsPost : json_decode((string)$varsPost, true) ?? [];
-
-        $template = $this->templateModel->findByKey($templateKey);
-        if (!$template) return $this->response->setStatusCode(404)->setJSON(['error' => 'Template not found']);
-
-        $student = $this->studentModel->getStudentBasic($studentId);
-        if (!$student) return $this->response->setStatusCode(404)->setJSON(['error' => 'Student not found']);
-
-        // Build salutation from guardians in the chosen family
-        $db = \Config\Database::connect();
-        $gs = $db->query("SELECT u.firstname, u.lastname\n                           FROM family_guardians fg\n                           JOIN users u ON u.id = fg.user_id\n                           WHERE fg.family_id = ? AND fg.receive_emails = 1\n                           ORDER BY fg.is_primary DESC, u.lastname, u.firstname", [$familyId])->getResultArray();
-        $sal = 'Parent/Guardian';
-        if ($gs) {
-            $names = array_map(fn($r)=> trim(($r['firstname']??'').' '.($r['lastname']??'')), $gs);
-            $sal = implode(' & ', $names);
-        }
-
-        $autoVars = [
-            'student_fullname' => trim(($student['firstname'] ?? '').' '.($student['lastname'] ?? '')),
-            'student_grade'    => $student['grade'] ?? '',
-            'parent_salutation'=> $sal,
-            'date'             => local_date(utc_now(), 'Y-m-d'),
-            'school_name'      => 'Al Rahma Sunday School',
-            'teacher_name'     => (string)(session('display_name') ?? 'Teacher'),
-        ];
-        $all = array_merge($autoVars, $vars);
-
-        $subject = $this->renderTwig($template['subject'], $all);
-        $body    = nl2br($this->renderTwig($template['body'], $all));
-
-        return $this->response->setJSON(['subject' => $subject, 'html' => $body]);
-    }
-
-    public function send()
-    {
-        $rules = [
-            'student_id'   => 'required|integer',
-            'family_id'    => 'required|integer',
-            'template_key' => 'required|string',
-            'subject'      => 'required|string',
-            'body'         => 'required|string',
-            'recipients'   => 'required|string' // JSON array
-        ];
-        if (!$this->validate($rules)) {
-            return redirect()->back()->with('error', 'Invalid form submission.');
-        }
-
-        $studentId   = (int) $this->request->getPost('student_id');
-        $familyId    = (int) $this->request->getPost('family_id');
-        $templateKey = (string) $this->request->getPost('template_key');
-        $subject     = (string) $this->request->getPost('subject');
-        $bodyHtml    = (string) $this->request->getPost('body');
-        $recipients  = json_decode((string)$this->request->getPost('recipients'), true) ?? [];
-        $cc          = json_decode((string)($this->request->getPost('cc') ?? '[]'), true) ?? [];
-        $bcc         = json_decode((string)($this->request->getPost('bcc') ?? '[]'), true) ?? [];
-
-        $student = $this->studentModel->getStudentBasic($studentId);
-        if (!$student) return redirect()->back()->with('error', 'Student not found');
-
-        // Send email (PHPMailer via service('mailer'))
-        $sendOk = false; $error = null;
-        try {
-            $mailer = service('mailer');
-            foreach (array_unique($recipients) as $to) { if ($to) $mailer->addAddress($to); }
-            foreach (array_unique($cc) as $c) { if ($c) $mailer->addCC($c); }
-            foreach (array_unique($bcc) as $b){ if ($b) $mailer->addBCC($b); }
-            $mailer->Subject = $subject;
-            $mailer->isHTML(true);
-            $mailer->Body = $bodyHtml;
-            $mailer->AltBody = strip_tags($bodyHtml);
-            $sendOk = $mailer->send();
-        } catch (\Throwable $t) {
-            $error = $t->getMessage();
-        }
-
-        // Log
-        $this->logModel->insert([
-            'student_id'   => $studentId,
-            'family_id'    => $familyId,
-            'student_name' => trim(($student['firstname'] ?? '').' '.($student['lastname'] ?? '')),
-            'template_key' => $templateKey,
-            'subject'      => $subject,
-            'body'         => $bodyHtml,
-            'recipients'   => json_encode(array_values($recipients)),
-            'cc'           => json_encode(array_values($cc)),
-            'bcc'          => json_encode(array_values($bcc)),
-            'status'       => $sendOk ? 'sent' : 'failed',
-            'error_message'=> $error,
-            'sent_by'      => (int)(session('user_id') ?? 0),
-            'metadata'     => null,
-        ]);
-
-        return $sendOk
-            ? redirect()->to('/communications')->with('success', 'Email sent successfully.')
-            : redirect()->back()->with('error', 'Failed to send email: '.($error ?? 'Unknown error'));
-    }
-
-    private function renderTwig(string $template, array $vars): string
-    {
-        return preg_replace_callback('/\{\{\s*([a-zA-Z0-9_\.]+)\s*\}\}/', function($m) use ($vars) {
-            $key = $m[1];
-            return htmlspecialchars((string)($vars[$key] ?? ''), ENT_QUOTES, 'UTF-8');
-        }, $template);
-    }
-}
diff --git a/app/Http/Controllers/old/CompetitionScoresController.php b/app/Http/Controllers/old/CompetitionScoresController.php
deleted file mode 100644
index 29fd114e..00000000
--- a/app/Http/Controllers/old/CompetitionScoresController.php
+++ /dev/null
@@ -1,441 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Controllers\BaseController;
-use App\Models\ClassSectionModel;
-use App\Models\CompetitionClassWinnerModel;
-use App\Models\CompetitionModel;
-use App\Models\CompetitionScoreModel;
-use App\Models\ConfigurationModel;
-use App\Models\TeacherClassModel;
-
-class CompetitionScoresController extends BaseController
-{
-    protected $db;
-    protected TeacherClassModel $teacherClassModel;
-    protected ConfigurationModel $configModel;
-    protected ClassSectionModel $classSectionModel;
-    protected CompetitionClassWinnerModel $classWinnerModel;
-    protected string $classStudentTable;
-    protected bool $hasQuestionCount = false;
-    protected bool $hasClassWinnerTable = false;
-
-    public function __construct()
-    {
-        $this->db = \Config\Database::connect();
-        $this->teacherClassModel = new TeacherClassModel();
-        $this->configModel = new ConfigurationModel();
-        $this->classSectionModel = new ClassSectionModel();
-        $this->classWinnerModel = new CompetitionClassWinnerModel();
-
-        if ($this->db->tableExists('class_student')) {
-            $this->classStudentTable = 'class_student';
-        } elseif ($this->db->tableExists('student_class')) {
-            $this->classStudentTable = 'student_class';
-        } else {
-            $this->classStudentTable = '';
-        }
-
-        $this->hasClassWinnerTable = $this->db->tableExists('competition_class_winners');
-        $this->hasQuestionCount = $this->hasClassWinnerTable
-            && $this->db->fieldExists('question_count', 'competition_class_winners');
-    }
-
-    public function index()
-    {
-        [$assignments, $schoolYear, $semester] = $this->getTeacherContext();
-        $activeClassId = $this->resolveActiveClassId($assignments);
-        $activeClassName = $this->getActiveClassName($assignments, $activeClassId);
-
-        if (empty($assignments) || $activeClassId <= 0) {
-            return view('teacher/competition_scores/index', [
-                'competitions'    => [],
-                'activeClassId'   => $activeClassId,
-                'activeClassName' => $activeClassName,
-                'questionCounts'  => [],
-                'scoreCounts'     => [],
-                'studentTotal'    => 0,
-                'sectionMap'      => $this->getClassSectionMap(),
-                'schoolYear'      => $schoolYear,
-                'semester'        => $semester,
-                'hasClasses'      => false,
-            ]);
-        }
-
-        $competitions = $this->getCompetitionsForClass($activeClassId, $schoolYear, $semester);
-        $competitionIds = array_values(array_filter(array_map(static function ($row) {
-            return (int) ($row['id'] ?? 0);
-        }, $competitions)));
-
-        $questionCounts = $this->getQuestionCounts($competitionIds, $activeClassId);
-        $scoreCounts = $this->getScoreCounts($competitionIds, $activeClassId);
-        $studentTotal = $this->getClassStudentCount($activeClassId, $schoolYear);
-
-        return view('teacher/competition_scores/index', [
-            'competitions'    => $competitions,
-            'activeClassId'   => $activeClassId,
-            'activeClassName' => $activeClassName,
-            'questionCounts'  => $questionCounts,
-            'scoreCounts'     => $scoreCounts,
-            'studentTotal'    => $studentTotal,
-            'sectionMap'      => $this->getClassSectionMap(),
-            'schoolYear'      => $schoolYear,
-            'semester'        => $semester,
-            'hasClasses'      => true,
-        ]);
-    }
-
-    public function edit($id)
-    {
-        [$assignments, $schoolYear, $semester] = $this->getTeacherContext();
-        $allowedClassIds = $this->getAllowedClassIds($assignments);
-        if (empty($allowedClassIds)) {
-            return redirect()->to('/teacher/competition-scores')
-                ->with('error', 'No class assignments found for your account.');
-        }
-
-        $competitionModel = new CompetitionModel();
-        $scoreModel = new CompetitionScoreModel();
-        $competition = $competitionModel->find($id);
-        if (!$competition) {
-            return redirect()->to('/teacher/competition-scores')
-                ->with('error', 'Competition not found.');
-        }
-        $isLocked = !empty($competition['is_locked']);
-
-        $activeClassId = $this->resolveActiveClassId($assignments);
-        $lockedClassId = (int) ($competition['class_section_id'] ?? 0);
-        $classSectionId = $lockedClassId > 0 ? $lockedClassId : $activeClassId;
-        if ($classSectionId <= 0) {
-            return redirect()->to('/teacher/competition-scores')
-                ->with('error', 'Select a class section before entering scores.');
-        }
-        if (!in_array($classSectionId, $allowedClassIds, true)) {
-            return redirect()->to('/teacher/competition-scores')
-                ->with('error', 'You are not assigned to that class.');
-        }
-
-        $students = $this->getStudentsForCompetition($competition, $classSectionId);
-        $existingScores = $scoreModel
-            ->where('competition_id', $id)
-            ->where('class_section_id', $classSectionId)
-            ->findAll();
-
-        $scoreMap = [];
-        foreach ($existingScores as $row) {
-            $scoreMap[$row['student_id']] = $row['score'];
-        }
-
-        $questionCount = null;
-        if ($this->hasQuestionCount && $this->hasClassWinnerTable) {
-            $row = $this->classWinnerModel
-                ->select('question_count')
-                ->where('competition_id', $id)
-                ->where('class_section_id', $classSectionId)
-                ->first();
-            if ($row && $row['question_count'] !== null) {
-                $questionCount = (int) $row['question_count'];
-            }
-        }
-
-        $classStudentCount = $this->getClassStudentCount(
-            $classSectionId,
-            $competition['school_year'] ?? $schoolYear
-        );
-
-        $activeClassName = $this->getActiveClassName($assignments, $classSectionId);
-
-        return view('teacher/competition_scores/scores', [
-            'competition'       => $competition,
-            'students'          => $students,
-            'scoreMap'          => $scoreMap,
-            'classSectionId'    => $classSectionId,
-            'classSectionName'  => $activeClassName,
-            'classStudentCount' => $classStudentCount,
-            'questionCount'     => $questionCount,
-            'classSelectionLocked' => $lockedClassId > 0,
-            'isLocked'          => $isLocked,
-        ]);
-    }
-
-    public function save($id)
-    {
-        [$assignments] = $this->getTeacherContext();
-        $allowedClassIds = $this->getAllowedClassIds($assignments);
-        if (empty($allowedClassIds)) {
-            return redirect()->to('/teacher/competition-scores')
-                ->with('error', 'No class assignments found for your account.');
-        }
-
-        $competitionModel = new CompetitionModel();
-        $scoreModel = new CompetitionScoreModel();
-        $competition = $competitionModel->find($id);
-        if (!$competition) {
-            return redirect()->to('/teacher/competition-scores')
-                ->with('error', 'Competition not found.');
-        }
-        if (!empty($competition['is_locked'])) {
-            return redirect()->to("/teacher/competition-scores/{$id}")
-                ->with('error', 'Competition is locked. You cannot update scores.');
-        }
-
-        $lockedClassId = (int) ($competition['class_section_id'] ?? 0);
-        $classSectionId = $lockedClassId > 0
-            ? $lockedClassId
-            : (int) $this->request->getPost('class_section_id');
-        if ($classSectionId <= 0) {
-            return redirect()->to('/teacher/competition-scores')
-                ->with('error', 'Select a class section before saving scores.');
-        }
-        if (!in_array($classSectionId, $allowedClassIds, true)) {
-            return redirect()->to('/teacher/competition-scores')
-                ->with('error', 'You are not assigned to that class.');
-        }
-
-        $scores = (array) $this->request->getPost('scores');
-        $cleanScores = [];
-        $invalidScores = [];
-
-        foreach ($scores as $studentId => $scoreValue) {
-            $scoreValue = trim((string) $scoreValue);
-            if ($scoreValue === '') {
-                continue;
-            }
-            if (!preg_match('/^\d+$/', $scoreValue)) {
-                $invalidScores[] = $studentId;
-                continue;
-            }
-            $cleanScores[(int) $studentId] = (int) $scoreValue;
-        }
-
-        if (!empty($invalidScores)) {
-            return redirect()->to("/teacher/competition-scores/{$id}")
-                ->with('error', 'Scores must be whole numbers (no decimals).');
-        }
-
-        foreach ($cleanScores as $studentId => $scoreValue) {
-            $existing = $scoreModel
-                ->where('competition_id', $id)
-                ->where('student_id', (int) $studentId)
-                ->where('class_section_id', $classSectionId)
-                ->first();
-
-            if ($existing) {
-                $scoreModel->update($existing['id'], [
-                    'score'            => $scoreValue,
-                    'class_section_id' => $classSectionId,
-                ]);
-            } else {
-                $scoreModel->insert([
-                    'competition_id'   => (int) $id,
-                    'student_id'       => (int) $studentId,
-                    'class_section_id' => $classSectionId,
-                    'score'            => $scoreValue,
-                ]);
-            }
-        }
-
-        return redirect()->to("/teacher/competition-scores/{$id}")
-            ->with('success', 'Scores saved.');
-    }
-
-    private function getTeacherContext(): array
-    {
-        $userId = (int) (session()->get('user_id') ?? 0);
-        $schoolYear = (string) ($this->configModel->getConfig('school_year') ?? '');
-        $semester = (string) ($this->configModel->getConfig('semester') ?? '');
-        $assignments = $this->teacherClassModel->getClassAssignmentsByUserId(
-            $userId,
-            $schoolYear,
-            $semester
-        );
-
-        return [$assignments, $schoolYear, $semester];
-    }
-
-    private function getAllowedClassIds(array $assignments): array
-    {
-        $ids = array_map(static function ($row) {
-            return (int) ($row['class_section_id'] ?? 0);
-        }, $assignments);
-
-        $ids = array_values(array_filter(array_unique($ids)));
-        return $ids;
-    }
-
-    private function resolveActiveClassId(array $assignments): int
-    {
-        $allowed = $this->getAllowedClassIds($assignments);
-        $active = (int) (session()->get('class_section_id') ?? 0);
-        if ($active > 0 && in_array($active, $allowed, true)) {
-            return $active;
-        }
-
-        $active = $allowed[0] ?? 0;
-        if ($active > 0) {
-            session()->set('class_section_id', $active);
-        }
-
-        return (int) $active;
-    }
-
-    private function getActiveClassName(array $assignments, int $classSectionId): ?string
-    {
-        if ($classSectionId <= 0) {
-            return null;
-        }
-
-        foreach ($assignments as $row) {
-            if ((int) ($row['class_section_id'] ?? 0) === $classSectionId) {
-                return $row['class_section_name'] ?? null;
-            }
-        }
-
-        $row = $this->classSectionModel
-            ->select('class_section_name')
-            ->where('class_section_id', $classSectionId)
-            ->first();
-
-        return $row['class_section_name'] ?? null;
-    }
-
-    private function getCompetitionsForClass(int $classSectionId, string $schoolYear, string $semester): array
-    {
-        $competitionModel = new CompetitionModel();
-        $builder = $competitionModel->orderBy('id', 'DESC');
-
-        if ($classSectionId > 0) {
-            $builder->groupStart()
-                ->where('class_section_id', $classSectionId)
-                ->orWhere('class_section_id', 0)
-                ->orWhere('class_section_id IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        if ($schoolYear !== '') {
-            $builder->groupStart()
-                ->where('school_year', $schoolYear)
-                ->orWhere('school_year', '')
-                ->orWhere('school_year IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        if ($semester !== '') {
-            $builder->groupStart()
-                ->where('semester', $semester)
-                ->orWhere('semester', '')
-                ->orWhere('semester IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        return $builder->findAll();
-    }
-
-    private function getQuestionCounts(array $competitionIds, int $classSectionId): array
-    {
-        if (!$this->hasQuestionCount || !$this->hasClassWinnerTable || empty($competitionIds)) {
-            return [];
-        }
-
-        $rows = $this->classWinnerModel
-            ->select('competition_id, question_count')
-            ->where('class_section_id', $classSectionId)
-            ->whereIn('competition_id', $competitionIds)
-            ->findAll();
-
-        $out = [];
-        foreach ($rows as $row) {
-            $compId = (int) ($row['competition_id'] ?? 0);
-            if ($compId > 0 && $row['question_count'] !== null) {
-                $out[$compId] = (int) $row['question_count'];
-            }
-        }
-
-        return $out;
-    }
-
-    private function getScoreCounts(array $competitionIds, int $classSectionId): array
-    {
-        if (empty($competitionIds)) {
-            return [];
-        }
-
-        $rows = $this->db->table('competition_scores')
-            ->select('competition_id, COUNT(*) AS total')
-            ->where('class_section_id', $classSectionId)
-            ->whereIn('competition_id', $competitionIds)
-            ->groupBy('competition_id')
-            ->get()
-            ->getResultArray();
-
-        $out = [];
-        foreach ($rows as $row) {
-            $compId = (int) ($row['competition_id'] ?? 0);
-            if ($compId > 0) {
-                $out[$compId] = (int) ($row['total'] ?? 0);
-            }
-        }
-
-        return $out;
-    }
-
-    private function getClassStudentCount(int $classSectionId, ?string $schoolYear): int
-    {
-        if ($classSectionId <= 0 || $this->classStudentTable === '') {
-            return 0;
-        }
-
-        $builder = $this->db->table($this->classStudentTable)
-            ->select('COUNT(*) AS total')
-            ->where('class_section_id', $classSectionId);
-
-        if ($schoolYear && $this->db->fieldExists('school_year', $this->classStudentTable)) {
-            $builder->where('school_year', $schoolYear);
-        }
-
-        $row = $builder->get()->getRowArray();
-        return (int) ($row['total'] ?? 0);
-    }
-
-    private function getStudentsForCompetition(array $competition, int $classSectionId): array
-    {
-        if ($classSectionId <= 0 || $this->classStudentTable === '') {
-            return [];
-        }
-
-        $builder = $this->db->table('students s')
-            ->select('s.id, s.school_id, s.firstname, s.lastname')
-            ->join($this->classStudentTable . ' cs', 'cs.student_id = s.id', 'inner')
-            ->where('cs.class_section_id', $classSectionId);
-
-        $hasSchoolYear = $this->db->fieldExists('school_year', $this->classStudentTable);
-        if ($hasSchoolYear && !empty($competition['school_year'])) {
-            $builder->where('cs.school_year', $competition['school_year']);
-        }
-
-        $builder->distinct();
-        $builder->orderBy('s.lastname', 'ASC')
-            ->orderBy('s.firstname', 'ASC');
-
-        return $builder->get()->getResultArray();
-    }
-
-    private function getClassSectionMap(): array
-    {
-        $sections = $this->classSectionModel
-            ->select('class_section_id, class_section_name')
-            ->orderBy('class_section_name', 'ASC')
-            ->findAll();
-
-        $map = [];
-        foreach ($sections as $section) {
-            $id = (int) ($section['class_section_id'] ?? 0);
-            if ($id > 0) {
-                $map[$id] = $section['class_section_name'] ?? (string) $id;
-            }
-        }
-
-        return $map;
-    }
-}
diff --git a/app/Http/Controllers/old/DiscountController.php b/app/Http/Controllers/old/DiscountController.php
deleted file mode 100644
index 85fbf27a..00000000
--- a/app/Http/Controllers/old/DiscountController.php
+++ /dev/null
@@ -1,906 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-use App\Controllers\BaseController;
-use App\Models\DiscountVoucherModel;
-use App\Models\DiscountUsageModel;
-use App\Models\InvoiceModel;
-use App\Models\UserModel;
-use App\Models\ConfigurationModel;
-use App\Models\PaymentModel;
-use App\Models\EnrollmentModel;
-use App\Models\EventChargesModel;
-use App\Models\AdditionalChargeModel;
-use App\Models\ClassSectionModel;
-use CodeIgniter\Events\Events;
-
-class DiscountController extends BaseController
-{
-    protected $configModel;
-    protected $voucherModel;
-    protected $invoiceModel;
-    protected $userModel;
-    protected $db;
-    protected $schoolYear;
-    protected $semester;
-    protected $paymentModel;
-    protected $enrollmentModel;
-    protected $eventChargesModel;
-    protected $additionalChargeModel;
-    protected $classSectionModel;
-
-    public function __construct()
-    {
-        $this->configModel = new ConfigurationModel();
-        $this->voucherModel = new DiscountVoucherModel();
-        $this->invoiceModel = new InvoiceModel();
-        $this->userModel = new UserModel();
-        $this->db = \Config\Database::connect();
-        $this->paymentModel = new PaymentModel();
-        $this->enrollmentModel = new EnrollmentModel();
-        $this->eventChargesModel = new EventChargesModel();
-        $this->additionalChargeModel = new AdditionalChargeModel();
-        $this->classSectionModel = new ClassSectionModel();
-
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester = $this->configModel->getConfig('semester');
-    }
-
-    public function applyVoucher()
-    {
-        if (strtolower($this->request->getMethod()) === 'post') {
-            $voucherId = $this->request->getPost('voucher_id');
-            $parentIds = $this->request->getPost('parent_ids') ?? [];
-            $allowAdditional = (bool) $this->request->getPost('allow_additional');
-
-            if (empty($parentIds)) {
-                return redirect()->back()->with('error', 'Please select at least one parent.');
-            }
-
-            $voucher = $this->voucherModel->find($voucherId);
-            if (!$voucher) {
-                return redirect()->back()->with('error', 'Voucher not found.');
-            }
-
-            // Normalize description from voucher (optional)
-            $voucherDescription = trim((string) ($voucher['description'] ?? ''));
-            $voucherDescription = preg_replace(
-                '/^Auto-generated on \d{4}-\d{2}-\d{2}\s*[—-]\s*reason:\s*/i',
-                '',
-                $voucherDescription
-            );
-
-            $maxUsesRaw = $voucher['max_uses'] ?? null;
-            $maxUses = ($maxUsesRaw === null || $maxUsesRaw === '') ? null : (int) $maxUsesRaw;
-            $timesUsed = (int) ($voucher['times_used'] ?? 0);
-            $remainingUses = ($maxUses === null) ? PHP_INT_MAX : ($maxUses - $timesUsed);
-            if ($remainingUses <= 0) {
-                return redirect()->back()->with('error', 'This voucher has reached its maximum allowed uses.');
-            }
-
-            // If not allowing additional discounts, filter out parents who already have discounts this school year.
-            if (!$allowAdditional) {
-                $rows = $this->db->table('discount_usages du')
-                    ->select('i.parent_id')
-                    ->join('invoices i', 'i.id = du.invoice_id')
-                    ->whereIn('i.parent_id', $parentIds)
-                    ->where('i.school_year', $this->schoolYear)
-                    ->groupBy('i.parent_id')
-                    ->get()
-                    ->getResultArray();
-                $blockedParentIds = array_map(static fn($r) => (int) $r['parent_id'], $rows);
-                if (!empty($blockedParentIds)) {
-                    $parentIds = array_values(array_diff(
-                        array_map('intval', $parentIds),
-                        $blockedParentIds
-                    ));
-                }
-                if (empty($parentIds)) {
-                    return redirect()->back()->with('error', 'All selected parents already have discounts. Enable "Allow additional discounts" to apply another.');
-                }
-            }
-
-            $paymentDate = utc_now();
-
-            // Collect invoice IDs that end up fully covered by the voucher in this run
-            $fullyCoveredInvoiceIds = [];
-            $touchedInvoiceIds = [];
-            $appliedCount = 0;
-
-            $this->db->transStart();
-
-            foreach ($parentIds as $parentId) {
-                // Fetch invoices for this parent & school year
-                $invoices = $this->invoiceModel->getInvoicesByUserId($parentId, $this->schoolYear);
-                if (empty($invoices)) {
-                    // Do NOT early-return inside a transaction; just continue
-                    session()->setFlashdata('error', 'A selected parent has no invoice in record.');
-                    continue;
-                }
-
-                foreach ($invoices as $invoice) {
-                    if ($remainingUses <= 0) break 2; // out of parentIds loop too
-
-                    // Snapshot current balance BEFORE applying
-                    $initialPreBalance = (float) $this->getCurrentInvoiceBalance($invoice['id'], $this->schoolYear);
-                    if ($initialPreBalance <= 0) {
-                        log_message(
-                            'error',
-                            'applyVoucher skip: zero balance | voucher_id={vid} parent_id={pid} invoice_id={iid} invoice_number={inum} balance={bal}',
-                            [
-                                'vid'  => (int)$voucherId,
-                                'pid'  => (int)$parentId,
-                                'iid'  => (int)$invoice['id'],
-                                'inum' => (string)($invoice['invoice_number'] ?? ''),
-                                'bal'  => $initialPreBalance,
-                            ]
-                        );
-                        continue;
-                    }
-
-                    // Already used this voucher on this invoice?
-                    if (!$allowAdditional) {
-                        $exists = $this->db->table('discount_usages du')
-                            ->join('invoices i', 'du.invoice_id = i.id')
-                            ->where('du.voucher_id', $voucherId)
-                            ->where('du.invoice_id', $invoice['id'])
-                            ->where('i.school_year', $this->schoolYear)
-                            ->countAllResults();
-                        if ($exists) {
-                            log_message(
-                                'error',
-                                'applyVoucher skip: voucher already used | voucher_id={vid} parent_id={pid} invoice_id={iid} invoice_number={inum}',
-                                [
-                                    'vid'  => (int)$voucherId,
-                                    'pid'  => (int)$parentId,
-                                    'iid'  => (int)$invoice['id'],
-                                    'inum' => (string)($invoice['invoice_number'] ?? ''),
-                                ]
-                            );
-                            continue;
-                        }
-                    }
-
-                    // Calculate discount
-                    $rawDiscount = ($voucher['discount_type'] === 'percent')
-                        ? round(((float)$invoice['total_amount'] * (float)$voucher['discount_value']) / 100, 2)
-                        : (float) $voucher['discount_value'];
-
-                    // Cap by CURRENT invoice balance snapshot
-                    $discount = min($rawDiscount, $initialPreBalance);
-
-                    // Nothing to do if no discount
-                    if ($discount <= 0) {
-                        log_message(
-                            'error',
-                            'applyVoucher skip: discount <= 0 | voucher_id={vid} parent_id={pid} invoice_id={iid} invoice_number={inum} raw_discount={raw} balance={bal}',
-                            [
-                                'vid'  => (int)$voucherId,
-                                'pid'  => (int)$parentId,
-                                'iid'  => (int)$invoice['id'],
-                                'inum' => (string)($invoice['invoice_number'] ?? ''),
-                                'raw'  => $rawDiscount,
-                                'bal'  => $initialPreBalance,
-                            ]
-                        );
-                        continue;
-                    }
-
-                    // Insert discount usage
-                    $now = utc_now();
-                    $this->db->table('discount_usages')->insert([
-                        'voucher_id'      => $voucherId,
-                        'invoice_id'      => $invoice['id'],
-                        'parent_id'       => $parentId,
-                        'discount_amount' => $discount,
-                        'description'     => $voucherDescription,
-                        'school_year'     => $this->schoolYear,
-                        'updated_by'      => session()->get('user_id'),
-                        'used_at'         => $now,
-                        'created_at'      => $now,
-                        'updated_at'      => $now,
-                    ]);
-
-                    // Update invoice balance based on pre-discount snapshot (supports multiple discounts)
-                    $newBalance = max(0.0, round($initialPreBalance - $discount, 2));
-                    $this->db->table('invoices')
-                        ->where('id', $invoice['id'])
-                        ->update([
-                            'balance'      => $newBalance,
-                            'has_discount' => 1,
-                            'updated_at'   => $now,
-                        ]);
-
-                    // Compute post-balance based on pre-snapshot (more stable than $invoice['balance'])
-                    $postBalance = round($initialPreBalance - $discount, 2);
-                    if ($postBalance < 0) $postBalance = 0.0;
-
-                    // (Optional) current balance re-check (in case of concurrent writes)
-                    $currentBalance = (float) $this->getCurrentInvoiceBalance($invoice['id'], $this->schoolYear);
-
-                    // Increment voucher usage
-                    $this->db->table('discount_vouchers')
-                        ->where('id', $voucherId)
-                        ->set('times_used', 'COALESCE(times_used,0) + 1', false)
-                        ->update();
-
-                    // Prepare and trigger payment event
-                    [$eventData, $studentData] = $this->buildPaymentEventData(
-                        $invoice['id'],
-                        $voucherId,
-                        $discount,
-                        'discount',
-                        $paymentDate,
-                        '',
-                        0,
-                        $initialPreBalance,   // pre-payment snapshot
-                        $postBalance          // computed post-payment
-                    );
-                    Events::trigger('paymentReceived', $eventData, $studentData);
-
-                    $touchedInvoiceIds[] = (int) $invoice['id'];
-                    $appliedCount++;
-
-                    // If voucher covered the entire current balance, mark to update enrollments
-                    // Use a small epsilon to tolerate cents rounding.
-                    $epsilon = 0.01;
-                    $fullyCovered = (abs($discount - $initialPreBalance) <= $epsilon)
-                        || ($postBalance <= $epsilon)
-                        || ($currentBalance <= $epsilon);
-
-                    if ($fullyCovered) {
-                        $fullyCoveredInvoiceIds[] = (int) $invoice['id'];
-                    }
-
-                    $remainingUses--;
-
-                    // Deactivate if we just hit the cap
-                    if ($remainingUses <= 0 && $maxUses !== null) {
-                        $this->db->table('discount_vouchers')
-                            ->where('id', $voucherId)
-                            ->update([
-                                'is_active'  => 0,
-                                'updated_at' => $now,
-                            ]);
-                        break 2;
-                    }
-                }
-            }
-
-            $this->db->transComplete();
-
-            if ($this->db->transStatus() === false) {
-                return redirect()->back()->with('error', 'Voucher application failed. Transaction rolled back.');
-            }
-
-            if ($appliedCount === 0) {
-                return redirect()->back()->with('error', 'No discounts were applied. The voucher may already be used for these invoices or balances are zero.');
-            }
-
-            // ✅ Ensure voucher deactivates when max_uses reached (handles edge cases)
-            if ($maxUses !== null) {
-                $row = $this->db->table('discount_vouchers')
-                    ->select('times_used')
-                    ->where('id', $voucherId)
-                    ->get()
-                    ->getRowArray();
-                $usedNow = (int) ($row['times_used'] ?? 0);
-                if ($usedNow >= $maxUses) {
-                    $this->db->table('discount_vouchers')
-                        ->where('id', $voucherId)
-                        ->update([
-                            'is_active'  => 0,
-                            'updated_at' => utc_now(),
-                        ]);
-                }
-            }
-
-            // ✅ AFTER COMMIT: recalculate invoice totals/balance/paid/discount/refund
-            foreach (array_unique($touchedInvoiceIds) as $iid) {
-                try {
-                    $this->recalculateInvoice($iid, $this->schoolYear);
-                } catch (\Throwable $e) {
-                    log_message('error', 'recalculateInvoice failed for invoice {iid}: {err}', [
-                        'iid' => $iid,
-                        'err' => $e->getMessage(),
-                    ]);
-                }
-            }
-
-            // ✅ AFTER COMMIT: update enrollments for fully-covered invoices
-            // Avoid nested transactions by doing this post-commit.
-            $updatedTotal = 0;
-            foreach (array_unique($fullyCoveredInvoiceIds) as $iid) {
-                try {
-                    $updatedTotal += (int) $this->updateEnrollmentStatusIfPaid($iid);
-                } catch (\Throwable $e) {
-                    log_message('error', 'updateEnrollmentStatusIfPaid failed for invoice {iid}: {err}', [
-                        'iid' => $iid,
-                        'err' => $e->getMessage(),
-                    ]);
-                }
-            }
-
-            if ($updatedTotal > 0) {
-                return redirect()->back()->with('success', 'Voucher applied successfully and enrollments updated.');
-            }
-            return redirect()->back()->with('success', 'Voucher applied successfully.');
-        }
-
-        // GET: load page
-        $parents = $this->userModel->getParents();
-
-        foreach ($parents as &$parent) {
-            $discount = $this->db->table('discount_usages')
-                ->select('COALESCE(SUM(discount_amount),0) AS total_discount')
-                ->where('parent_id', $parent['id'])
-                ->where('school_year', $this->schoolYear)
-                ->get()
-                ->getRowArray();
-
-            $parent['total_discount'] = $discount['total_discount'] ?? 0;
-            $parent['has_discount']   = ($parent['total_discount'] > 0) ? 1 : 0;
-        }
-        unset($parent);
-
-        return view('discounts/apply_voucher', [
-            'vouchers' => $this->voucherModel->where('is_active', 1)->findAll(),
-            'parents'  => $parents,
-        ]);
-    }
-
-    private function updateEnrollmentStatusIfPaid(int $invoiceId): int
-    {
-        // 1) Fetch invoice
-        $invoice = $this->invoiceModel->find($invoiceId);
-        if (!$invoice) {
-            log_message('warning', 'Invoice not found: {id}', ['id' => $invoiceId]);
-            return 0;
-        }
-
-        // 2) Payment check (any payment recorded: balance < total)
-        $total   = (float) ($invoice['total_amount'] ?? 0);
-        $balance = (float) ($invoice['balance'] ?? 0);
-        if (!($total > 0 && $balance < $total)) {
-            log_message('info', 'No payment yet. Skipping enrollment update. Invoice #{id}', ['id' => $invoiceId]);
-            return 0;
-        }
-
-        $parentId   = (int) ($invoice['parent_id'] ?? 0);
-        $schoolYear = (string) $this->schoolYear;
-        if ($parentId <= 0 || $schoolYear === '') {
-            log_message('warning', 'updateEnrollmentStatusIfPaid: missing parent_id/school_year for invoice #{id}', ['id' => $invoiceId]);
-            return 0;
-        }
-
-        // 3) Try to limit to enrollments actually present on the invoice (optional)
-        //    If invoice_items.enrollment_id doesn't exist, this silently falls back to parent/year scope.
-        $paidEnrollmentIds = [];
-        try {
-            $rows = $this->db->table('invoice_items')
-                ->select('enrollment_id')
-                ->where('invoice_id', $invoiceId)
-                ->where('enrollment_id IS NOT NULL', null, false)
-                ->get()->getResultArray();
-            foreach ($rows as $r) {
-                $eid = (int) ($r['enrollment_id'] ?? 0);
-                if ($eid > 0) $paidEnrollmentIds[] = $eid;
-            }
-            $paidEnrollmentIds = array_values(array_unique($paidEnrollmentIds));
-        } catch (\Throwable $e) {
-            // No-op: table/column might not exist in your schema
-        }
-
-        $db = $this->db;
-        $db->transBegin();
-
-        try {
-            // 4) Preview IDs that will be updated (good for debugging “partials”)
-            $previewBuilder = $db->table('enrollments')
-                ->select('id')
-                ->where('parent_id', $parentId)
-                ->where('school_year', $schoolYear)
-                ->groupStart()
-                // tolerant match for 'payment pending' (case/space/nbsp)
-                ->where('enrollment_status', 'payment pending')
-                ->orWhere('enrollment_status', 'Payment pending')
-                ->orWhere('enrollment_status', 'Payment Pending')
-                ->orWhere('enrollment_status', 'PAYMENT PENDING')
-                ->orWhere("LOWER(TRIM(REPLACE(enrollment_status, CHAR(160), ' '))) = 'payment pending'", null, false)
-                ->groupEnd();
-
-            if (!empty($paidEnrollmentIds)) {
-                $previewBuilder->whereIn('id', $paidEnrollmentIds);
-            }
-
-            $toUpdateIds = array_map(
-                static fn($r) => (int)$r['id'],
-                $previewBuilder->get()->getResultArray()
-            );
-
-            if (empty($toUpdateIds)) {
-                $db->transCommit();
-                log_message('info', 'No enrollments matched pending status for parent {p}, year {y}, sem {s}.', [
-                    'p' => $parentId,
-                    'y' => $schoolYear,
-                    's' => 'ALL'
-                ]);
-                return 0;
-            }
-
-            // 5) Perform update with same filters
-            $builder = $db->table('enrollments');
-            $builder->set('enrollment_status', 'enrolled')
-                // Use DB date if you prefer: ->set('enrollment_date', 'CURRENT_DATE()', false)
-                ->set('enrollment_date', local_date(utc_now(), 'Y-m-d'))
-                ->whereIn('id', $toUpdateIds);
-
-            if ($builder->update() === false) {
-                $err = $db->error();
-                throw new \RuntimeException('Enrollments update failed: ' . ($err['message'] ?? 'unknown DB error'));
-            }
-
-            $affected = $db->affectedRows();
-            $db->transCommit();
-
-            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'   => 'ALL',
-                    'ids' => implode(',', $toUpdateIds),
-                ]
-            );
-
-            return $affected;
-        } catch (\Throwable $e) {
-            $db->transRollback();
-            log_message('error', 'updateEnrollmentStatusIfPaid error: ' . $e->getMessage());
-            return 0;
-        }
-    }
-
-
-    public function listVouchers()
-    {
-
-        $vouchers = $this->voucherModel->findAll();
-        return view('discounts/list', ['vouchers' => $vouchers]);
-    }
-
-    public function createVoucher()
-    {
-        if (strtolower($this->request->getMethod()) === 'post') {
-
-            // -------- Gather & normalize inputs --------
-            $rawCode        = (string) $this->request->getPost('code');
-            // Keep A–Z, 0–9 and dashes; uppercase for consistency
-            $code           = strtoupper(preg_replace('/[^A-Z0-9\-]/i', '', trim($rawCode)));
-
-            $discountType   = strtolower((string) $this->request->getPost('discount_type')); // 'percent' | 'fixed'
-            $discountValue  = (float) ($this->request->getPost('discount_value') ?? 0);
-            $maxUsesRaw     = $this->request->getPost('max_uses');
-            $maxUses        = ($maxUsesRaw === '' || $maxUsesRaw === null) ? null : max(0, (int) $maxUsesRaw);
-
-            $validFrom      = trim((string) ($this->request->getPost('valid_from') ?? ''));
-            $validUntil     = trim((string) ($this->request->getPost('valid_until') ?? ''));
-            $isActive       = $this->request->getPost('is_active') ? 1 : 0;
-
-            // NEW: Description / Reason
-            $description    = trim((string) ($this->request->getPost('description') ?? ''));
-
-            // -------- Basic validations (before model rules) --------
-            $errors = [];
-
-            if ($code === '') {
-                $errors[] = 'Voucher code is required.';
-            }
-
-            if (!in_array($discountType, ['percent', 'fixed'], true)) {
-                $errors[] = 'Discount type must be "percent" or "fixed".';
-            }
-
-            if ($discountType === 'percent') {
-                if ($discountValue <= 0 || $discountValue > 100) {
-                    $errors[] = 'Percentage discount must be between 0 and 100.';
-                }
-            } else { // fixed
-                if ($discountValue < 0) {
-                    $errors[] = 'Fixed discount must be 0 or greater.';
-                }
-            }
-
-            // Dates come from <input type="date"> as YYYY-MM-DD
-            $validFrom = $validFrom !== '' ? $validFrom : null;
-            $validUntil = $validUntil !== '' ? $validUntil : null;
-
-            // Ensure date format is plausible
-            $isDate = static function (?string $d): bool {
-                if ($d === null) return true;
-                return (bool) preg_match('/^\d{4}-\d{2}-\d{2}$/', $d);
-            };
-            if (!$isDate($validFrom))  $errors[] = 'Valid From must be a date (YYYY-MM-DD).';
-            if (!$isDate($validUntil)) $errors[] = 'Valid Until must be a date (YYYY-MM-DD).';
-
-            if ($validFrom && $validUntil && $validFrom > $validUntil) {
-                $errors[] = 'Valid Until must be the same as or after Valid From.';
-            }
-
-            // Optional: require a reason when auto-generated codes are used
-            // if ($description === '' && strlen($code) === 10) {
-            //     $errors[] = 'Please add a description/reason for this voucher.';
-            // }
-
-            if (!empty($errors)) {
-                return redirect()->back()->withInput()->with('error', implode(' ', $errors));
-            }
-
-            // -------- Prepare payload for model --------
-            $data = [
-                'code'           => $code,
-                'discount_type'  => $discountType,
-                'discount_value' => $discountValue,
-                'max_uses'       => $maxUses,
-                'valid_from'     => $validFrom,
-                'valid_until'    => $validUntil,
-                'is_active'      => $isActive,
-                'description'    => $description,   // <-- NEW
-            ];
-
-            if ($this->voucherModel->save($data)) {
-                return redirect()->to('/discounts/list')->with('success', 'Voucher created successfully.');
-            }
-
-            // Model-level errors (unique code, etc.)
-            return redirect()->back()
-                ->withInput()
-                ->with('error', 'Failed to save voucher: ' . implode('; ', (array) $this->voucherModel->errors()));
-        }
-
-        return view('discounts/create');
-    }
-
-
-    public function editVoucher($id)
-    {
-        $voucher = $this->voucherModel->find($id);
-
-        if (!$voucher) {
-            return redirect()->to('discounts/list')->with('error', 'Voucher not found');
-        }
-
-        if (strtolower($this->request->getMethod()) === 'post') {
-            $data = [
-                'id' => $id,
-                'code' => $this->request->getPost('code'),
-                'discount_type' => $this->request->getPost('discount_type'),
-                'discount_value' => $this->request->getPost('discount_value'),
-                'max_uses' => $this->request->getPost('max_uses'),
-                'valid_from' => $this->request->getPost('valid_from') ?: null,
-                'valid_until' => $this->request->getPost('valid_until') ?: null,
-                'is_active' => $this->request->getPost('is_active') ? 1 : 0,
-            ];
-
-            $this->voucherModel->save($data);
-            return redirect()->to('discounts/list')->with('success', 'Voucher updated successfully');
-        }
-
-        return view('discounts/edit', ['voucher' => $voucher]);
-    }
-
-    /**
-     * 🔄 Helper: Current invoice balance (school-year scoped) = total - payments - discounts - refundsPaid
-     */
-    private function getCurrentInvoiceBalance($invoiceId, $schoolYear)
-    {
-        $invoice = $this->invoiceModel->find($invoiceId);
-        if (!$invoice) return 0.0;
-
-        // Payments (exclude void/refund/failed, honor year)
-        $qb = $this->paymentModel
-            ->select('COALESCE(SUM(paid_amount),0) AS total_paid')
-            ->where('invoice_id', $invoiceId)
-            ->where('school_year', $schoolYear);
-
-        $table = $this->paymentModel->table;
-        $hasStatus = $this->db->fieldExists('status', $table);
-        $hasVoid   = $this->db->fieldExists('is_void', $table);
-        if ($hasStatus) {
-            $qb->groupStart()
-                ->whereNotIn('status', ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'])
-                ->orWhere('status IS NULL', null, false)
-            ->groupEnd();
-        }
-        if ($hasVoid) {
-            $qb->groupStart()
-                ->where('is_void', 0)
-                ->orWhere('is_void IS NULL', null, false)
-            ->groupEnd();
-        }
-        $rowPaid   = $qb->first();
-        $totalPaid = (float)($rowPaid['total_paid'] ?? 0);
-
-        // Discounts for this invoice in this year
-        $rowDisc = $this->db->table('discount_usages du')
-            ->select('COALESCE(SUM(du.discount_amount),0) AS total_disc')
-            ->join('invoices i', 'i.id = du.invoice_id')
-            ->where('du.invoice_id', $invoiceId)
-            ->where('i.school_year', $schoolYear)
-            ->get()->getRowArray();
-        $totalDisc = (float)($rowDisc['total_disc'] ?? 0);
-
-        // Refunds PAID for this invoice in this year
-        $rowRefund = $this->db->table('refunds')
-            ->select('COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid')
-            ->where('invoice_id', $invoiceId)
-            ->where('school_year', $schoolYear)
-            ->whereIn('status', ['Partial', 'Paid'])
-            ->get()->getRowArray();
-        $totalRefundPaid = (float)($rowRefund['total_refund_paid'] ?? 0);
-
-        $total = (float)($invoice['total_amount'] ?? 0);
-        return max(0.0, round($total - $totalPaid - $totalDisc - $totalRefundPaid, 2));
-    }
-
-    /**
-     * 🔄 Recalculate invoice totals and status based on all payments for current school year
-     */
-    private function recalculateInvoice($invoiceId, $schoolYear): void
-    {
-        $invoice = $this->invoiceModel->find($invoiceId);
-        if (!$invoice) return;
-
-        $parentId = (int)($invoice['parent_id'] ?? 0);
-        if ($parentId <= 0) return;
-
-        // ---- Tuition (recompute from enrollments) ----
-        $enrollments = $this->enrollmentModel
-            ->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 – if after deadline, withdrawn still billed
-        $refundDeadline = (string)($this->configModel->getConfig('refund_deadline') ?? '');
-        $refundAllowed  = true;
-        try {
-            $tzName   = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-            $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->configModel->getConfig('grade_fee') ?? 9);
-        $firstStudentFee  = (float)($this->configModel->getConfig('first_student_fee')  ?? 350);
-        $secondStudentFee = (float)($this->configModel->getConfig('second_student_fee') ?? 200);
-        $youthFee         = (float)($this->configModel->getConfig('youth_fee')          ?? 180);
-
-        // Normalize grades for tuition students
-        foreach ($tuitionStudents as &$s) {
-            $name = null;
-            if (!empty($s['class_section_id'])) {
-                $name = $this->classSectionModel->getClassSectionNameBySectionId($s['class_section_id']);
-            }
-            $s['grade_name'] = is_string($name) ? strtoupper(trim($name)) : 'N/A';
-        }
-        unset($s);
-
-        // Count regular vs youth and compute tuition
-        $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 (parent-year) ----
-        $eventSubtotal = 0.0;
-        try {
-            $events = $this->eventChargesModel->getChargesWithEventInfo($parentId, $schoolYear) ?? [];
-            foreach ($events as $ev) { $eventSubtotal += (float)($ev['charged'] ?? 0.0); }
-        } catch (\Throwable $e) {}
-
-        // ---- Additional charges (per-invoice) ----
-        $additionalSubtotal = 0.0;
-        try {
-            $rows = $this->additionalChargeModel
-                ->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 ----
-        $db        = $this->db;
-        $table     = $this->paymentModel->table;
-        $hasStatus = $db->fieldExists('status', $table);
-        $hasVoid   = $db->fieldExists('is_void', $table);
-        $exclude   = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
-
-        $qb = $this->paymentModel
-            ->where('invoice_id', $invoiceId)
-            ->where('school_year', $schoolYear);
-
-        if ($hasStatus) {
-            $qb->groupStart()
-                ->whereNotIn('status', $exclude)
-                ->orWhere('status IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        if ($hasVoid) {
-            $qb->groupStart()
-                ->where('is_void', 0)
-                ->orWhere('is_void IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        $payments = $qb->findAll();
-        $totalPaid = 0.0;
-        foreach ($payments as $p) { $totalPaid += (float)($p['paid_amount'] ?? 0); }
-
-        $discRow = $this->db->table('discount_usages')
-            ->select('COALESCE(SUM(discount_amount),0) AS total_disc')
-            ->where('invoice_id', $invoiceId)
-            ->get()->getRowArray();
-        $totalDisc = (float)($discRow['total_disc'] ?? 0);
-
-        $refundRow = $this->db->table('refunds')
-            ->select('COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid')
-            ->where('invoice_id', $invoiceId)
-            ->whereIn('status', ['Partial','Paid'])
-            ->get()->getRowArray();
-        $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');
-
-        $updateData = [
-            'total_amount' => $newTotal,
-            'paid_amount'  => $totalPaid,
-            'balance'      => $newBalance,
-            'status'       => $newStatus,
-            'has_discount' => ($totalDisc > 0.0) ? 1 : 0,
-        ];
-
-        if ($this->db->fieldExists('discount', $this->invoiceModel->table)) {
-            $updateData['discount'] = $totalDisc;
-        }
-
-        $this->invoiceModel->update($invoiceId, $updateData);
-    }
-
-    /**
-     * Parse a grade name into an integer level for tuition rules.
-     * Kindergarten -> 1, Youth -> > 9, numeric grades passthrough.
-     */
-    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/Kindergarten
-        $kg = ['K','KG','K G','KINDER','KINDERGARTEN'];
-        if (in_array($g, $kg, true)) return 1;
-        // Pre-K -> treat below regular
-        $pk = ['PK','P K','PREK','PRE K','PRE KINDER','PREKINDER'];
-        if (in_array($g, $pk, true)) return -1;
-        // Youth variants: Y, YOUTH, Y1, YOUTH2 -> map to 10+
-        if (preg_match('/^Y(?:OUTH)?\s*(\d+)?$/', $g, $m)) {
-            $n = isset($m[1]) && $m[1] !== '' ? max(1, (int)$m[1]) : 1;
-            $gradeFee = (int)($this->configModel->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;
-    }
-
-    /**
-     * Collect parent/invoice/payment data to trigger handlePaymentReceived().
-     *
-     * @return array [$data, $studentdata]
-     */
-    private function buildPaymentEventData(
-        int $invoiceId,
-        string $transactionIdOrRef,
-        float $amount,
-        string $paymentMethod,
-        string $paymentDate,
-        ?string $checkNumber,
-        int $installmentSeq,
-        float $preBalance,     // ✅ new param: initial (pre-payment) balance
-        float $postBalance     // ✅ new param: computed post-payment balance
-    ): array {
-        $invoice = $this->invoiceModel->find($invoiceId);
-        if (!$invoice) {
-            throw new \RuntimeException("Invoice {$invoiceId} not found");
-        }
-
-        $parentRow = $this->db->table('users')
-            ->select('id, firstname, lastname, email')
-            ->where('id', $invoice['parent_id'])
-            ->get()
-            ->getRowArray();
-
-        if (!$parentRow) {
-            throw new \RuntimeException("Parent not found for invoice {$invoiceId}");
-        }
-
-        // Students (adjust joins to your schema)
-        $studentRows = $this->db->table('students s')
-            ->select('s.id, s.firstname, s.lastname, sc.class_section_id')
-            ->join('student_class sc', 'sc.student_id = s.id', 'left')
-            ->where('s.parent_id', $invoice['parent_id'])
-            ->where('sc.school_year', $this->schoolYear)
-            ->get()
-            ->getResultArray();
-
-        $data = [
-            'user_id'         => (int) $parentRow['id'],
-            'email'           => $parentRow['email'],
-            'firstname'       => $parentRow['firstname'],
-            'lastname'        => $parentRow['lastname'],
-            'school_year'     => $this->schoolYear,
-            'semester'        => $this->semester,
-            'invoice_id'      => $invoiceId,
-            'transaction_id'  => $transactionIdOrRef,
-            'payment_date'    => $paymentDate,
-            'amount'          => $amount,
-            'method'          => $paymentMethod,
-            'check_number'    => $checkNumber,
-            'installment_seq' => $installmentSeq,
-            'invoice_total'   => (float) $invoice['total_amount'],
-            'pre_balance'     => $preBalance,   // ✅ the captured pre-payment balance
-            'post_balance'    => $postBalance,  // ✅ computed post-payment balance
-            'portalLink'      => site_url('parent/invoices/' . $invoiceId),
-        ];
-
-        return [$data, $studentRows];
-    }
-}
diff --git a/app/Http/Controllers/old/EmailService.php b/app/Http/Controllers/old/EmailService.php
new file mode 100644
index 00000000..3a06d438
--- /dev/null
+++ b/app/Http/Controllers/old/EmailService.php
@@ -0,0 +1,96 @@
+<?php
+
+namespace App\Services;
+
+use App\Controllers\View\EmailController;
+
+class EmailService
+{
+    protected array $senders;
+    protected EmailController $mailer;
+
+    public function __construct()
+    {
+        $json = env('MAIL_SENDERS', '{}');
+        $decoded = json_decode($json, true);
+        $this->senders = is_array($decoded) ? $decoded : [];
+        $this->mailer  = new EmailController();
+    }
+
+    protected function getSenderDetails(string $fromKey = 'general'): array
+    {
+        $senders = $this->senders;
+        if (isset($senders[$fromKey])) {
+            return $senders[$fromKey];
+        }
+        return $senders['general'] ?? [
+            'email' => getenv('SMTP_USER') ?: 'no-reply@alrahmaisgl.org',
+            'name'  => 'Al Rahma Sunday School',
+        ];
+    }
+
+    /** NEW: expose configured sender keys to build a dropdown in the UI */
+    public function listSenders(): array
+    {
+        // returns: ['general' => ['email' => '...', 'name' => '...'], 'finance' => [...], ...]
+        return $this->senders ?: [
+            'general' => [
+                'email' => getenv('SMTP_USER') ?: 'no-reply@alrahmaisgl.org',
+                'name'  => 'Al Rahma Sunday School',
+            ],
+        ];
+    }
+
+    /**
+     * Send a single HTML email.
+     * Backward-compatible: you can ignore $attachments/$headers.
+     */
+    public function send(string $to, string $subject, string $message, string $fromKey = 'general', array $attachments = [], array $headers = []): bool
+    {
+        $attachmentsPayload = $this->normalizeAttachments($attachments);
+        // Headers are ignored by EmailController but kept for interface compatibility.
+        return $this->mailer->sendEmail($to, $subject, $message, $fromKey, null, null, $attachmentsPayload);
+    }
+
+    /**
+     * NEW: BCC bulk send in a single SMTP call (To must be non-empty; we use the SMTP user).
+     */
+    public function sendBcc(array $bccList, string $subject, string $message, string $fromKey = 'general', array $attachments = [], array $headers = []): bool
+    {
+        if (empty($bccList)) {
+            return true; // nothing to send
+        }
+
+        $attachmentsPayload = $this->normalizeAttachments($attachments);
+        $allOk = true;
+        foreach ($bccList as $addr) {
+            $ok = $this->mailer->sendEmail($addr, $subject, $message, $fromKey, null, null, $attachmentsPayload);
+            if (!$ok) {
+                $allOk = false;
+                log_message('error', 'EmailService::sendBcc failed for ' . $addr);
+            }
+        }
+        return $allOk;
+    }
+
+    /**
+     * Normalize various attachment inputs to the format expected by EmailController.
+     */
+    private function normalizeAttachments(array $attachments): array
+    {
+        $out = [];
+        foreach ($attachments as $file) {
+            if (is_object($file) && method_exists($file, 'isValid') && $file->isValid()) {
+                $newName = $file->getRandomName();
+                $path = WRITEPATH . 'uploads/' . $newName;
+                $file->move(WRITEPATH . 'uploads', $newName, true);
+                $out[] = ['path' => $path, 'name' => $file->getClientName()];
+            } elseif (is_string($file) && is_file($file)) {
+                $out[] = ['path' => $file, 'name' => basename($file)];
+            } elseif (is_array($file) && !empty($file['path'])) {
+                $out[] = ['path' => $file['path'], 'name' => $file['name'] ?? basename($file['path'])];
+            }
+        }
+        return $out;
+    }
+}
diff --git a/app/Http/Controllers/old/ExpenseController.php b/app/Http/Controllers/old/ExpenseController.php
deleted file mode 100644
index 01bd5d33..00000000
--- a/app/Http/Controllers/old/ExpenseController.php
+++ /dev/null
@@ -1,348 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-use App\Controllers\BaseController;
-use App\Models\ExpenseModel;
-use App\Models\UserModel;
-use App\Models\ConfigurationModel;
-use CodeIgniter\Exceptions\PageNotFoundException;
-
-class ExpenseController extends BaseController
-{
-    protected $expenseModel;
-    protected $userModel;
-    protected $configModel;
-    protected $schoolYear;
-    protected $semester;
-    protected $retailors;
-
-    public function __construct()
-    {
-        $this->expenseModel = new ExpenseModel();
-        $this->userModel    = new UserModel();
-        $this->configModel  = new ConfigurationModel();
-
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester   = $this->configModel->getConfig('semester');
-
-        // Default list of common retailors; adjust as needed
-        $this->retailors = [
-            'Amazon',
-            'Walmart',
-            'Costco',
-            'BJ\'s',
-            'Market Basket',
-            'Aldi',
-            'Hannaford',
-            'Sam\'s Club',
-            'HomeGoods',
-            'Hostinger',
-            'Wicked Cheesy',
-            'Shatila',
-            'Brothers Pizzeria',
-            'Paradise Biryani Pointe',
-            'Emad Leiman',
-            'Nova Trampoline Park',
-            'Lubin\'s Awards',
-            'Dollar Tree',
-            'Stop & Shop',
-            'Dunkin\' Donuts',
-            'Giovanni\'s Pizza',
-            'Trader Joes'
-        ];
-    }
-
-    /**
-     * Return staff users (admins/teachers/etc.) excluding parents/guests.
-     */
-    private function staffUsers(): array
-    {
-        $rows = $this->userModel
-            ->select('users.id, users.firstname, users.lastname, roles.name AS role_name')
-            ->join('user_roles', 'user_roles.user_id = users.id', 'left')
-            ->join('roles', 'roles.id = user_roles.role_id', 'left')
-            ->where('roles.name IS NOT NULL', null, false)
-            ->findAll();
-
-        $excludedRoles = array_map('strtolower', ['parent', 'student', 'guest']);
-        $staff = [];
-
-        foreach ($rows as $row) {
-            $roleName = strtolower((string) ($row['role_name'] ?? ''));
-            $id       = (int) ($row['id'] ?? 0);
-            if ($id <= 0 || in_array($roleName, $excludedRoles, true)) {
-                continue;
-            }
-            if (!isset($staff[$id])) {
-                $staff[$id] = [
-                    'id'        => $id,
-                    'firstname' => $row['firstname'] ?? '',
-                    'lastname'  => $row['lastname'] ?? '',
-                ];
-            }
-        }
-
-        uasort($staff, static function ($a, $b) {
-            $nameA = trim(($a['firstname'] ?? '') . ' ' . ($a['lastname'] ?? ''));
-            $nameB = trim(($b['firstname'] ?? '') . ' ' . ($b['lastname'] ?? ''));
-            return strcasecmp($nameA, $nameB);
-        });
-
-        return array_values($staff);
-    }
-
-    public function index()
-    {
-        $expenses = $this->expenseModel
-            ->select("
-                expenses.*,
-                u.firstname AS purchaser_firstname, u.lastname AS purchaser_lastname,
-                approver.firstname AS approver_firstname, approver.lastname AS approver_lastname
-            ")
-            ->join('users u', 'u.id = expenses.purchased_by', 'left')
-            ->join('users approver', 'approver.id = expenses.approved_by', 'left')
-            ->orderBy('expenses.created_at', 'DESC')
-            ->findAll();
-
-        // Enrich each row with a URL that goes through Files::receipt($name)
-        // We store only the filename in 'receipt_path' (e.g., "1759...f62.png")
-        $expenses = array_map(function ($row) {
-            $name = $row['receipt_path'] ?? null;
-            $row['receipt_url'] = $this->receiptUrl($name);
-            return $row;
-        }, $expenses);
-
-        return view('expenses/index', ['expenses' => $expenses]);
-    }
-
-    public function create()
-    {
-        $users = $this->staffUsers();
-
-        return view('expenses/create', [
-            'users'     => $users,
-            'retailors' => $this->retailors,
-        ]);
-    }
-
-    public function store()
-    {
-        $rules = [
-            'category'     => 'required|in_list[Expense,Purchase,Reimbursement,Donation]',
-            'amount'       => 'required|decimal|greater_than[0]',
-            // Frontend sends purchased_by as "id|Full Name"
-            'purchased_by' => 'required',
-            // Optional extra fields
-            'retailor'         => 'permit_empty|max_length[255]',
-            'date_of_purchase' => 'permit_empty',
-            // allow JPG/JPEG/PNG/WEBP/GIF and PDF up to 2MB
-            'receipt'      => 'uploaded[receipt]'
-                . '|max_size[receipt,2048]'
-                . '|ext_in[receipt,jpg,jpeg,png,webp,gif,pdf]'
-                . '|mime_in[receipt,image/jpg,image/jpeg,image/png,image/webp,image/gif,application/pdf]',
-        ];
-
-        $messages = [
-            'receipt' => [
-                'uploaded' => 'Receipt file is required.',
-                'max_size' => 'Maximum file size is 2MB.',
-                'ext_in'   => 'Allowed formats: JPG, JPEG, PNG, WEBP, GIF, or PDF.',
-                'mime_in'  => 'Allowed formats: JPG, JPEG, PNG, WEBP, GIF, or PDF.',
-            ]
-        ];
-
-        if (!$this->validate($rules, $messages)) {
-            return redirect()->back()->withInput()->with('error', $this->validator->listErrors());
-        }
-
-        // Safe values
-        $category    = (string) $this->request->getPost('category');
-        $amount      = (string) $this->request->getPost('amount');
-        $description = (string) $this->request->getPost('description');
-        $retailor    = trim((string) $this->request->getPost('retailor'));
-        $datePurchase = (string) $this->request->getPost('date_of_purchase');
-        $userId      = (int) (session()->get('user_id') ?? 0);
-        $isDonation  = ($category === 'Donation');
-
-        // Parse "purchased_by" as "7|John Doe"
-        $purchasedInfo = (string) $this->request->getPost('purchased_by');
-        [$purchasedById, $purchasedByName] = array_pad(explode('|', $purchasedInfo, 2), 2, null);
-        $purchasedById = (int) $purchasedById;
-
-        // School context
-        $schoolYear = $this->schoolYear ?: date('Y');
-        $semester   = $this->semester ?: 'Fall';
-
-        // Handle upload: store under writable/uploads/receipts and save only the filename
-        $receiptName = null;
-        $file = $this->request->getFile('receipt');
-        if ($file && $file->isValid() && !$file->hasMoved()) {
-            $stored      = $file->store('receipts'); // -> writable/uploads/receipts/<randomname>.ext
-            $receiptName = basename($stored);
-        }
-
-        $status       = $isDonation ? 'approved' : 'pending';
-        $statusReason = $isDonation ? 'Marked as Donation (non-reimbursable).' : null;
-
-        $this->expenseModel->insert([
-            'category'     => $category,
-            'amount'       => $amount,
-            'receipt_path' => $receiptName, // filename only
-            'description'  => $description,
-            'retailor'     => ($retailor !== '') ? $retailor : null,
-            'date_of_purchase' => ($datePurchase !== '') ? $datePurchase : null,
-            'purchased_by' => $purchasedById,
-            'added_by'     => $userId,
-            'status'       => $status,
-            'status_reason'=> $statusReason,
-            'approved_by'  => $isDonation ? $userId : null,
-            'school_year'  => $schoolYear,
-            'semester'     => $semester,
-        ]);
-
-        return redirect()->to('/expenses/index')->with('success', 'Record added successfully!');
-    }
-
-
-    public function updateStatus()
-    {
-        $data   = $this->request->getJSON(true);
-        $id     = isset($data['id']) ? (int)$data['id'] : null;
-        $status = $data['status'] ?? null;
-        $reason = $data['reason'] ?? '';
-        $userId = (int) (session()->get('user_id') ?? 0);
-
-        if (!$id || !in_array($status, ['approved', 'denied'], true)) {
-            log_message('error', 'Invalid status or ID');
-            return $this->response->setJSON(['error' => 'Invalid data']);
-        }
-
-        $expense = $this->expenseModel->find($id);
-        if (!$expense) {
-            log_message('error', 'Expense not found for ID ' . $id);
-            return $this->response->setJSON(['error' => 'Expense not found']);
-        }
-
-        $success = $this->expenseModel->update($id, [
-            'status'        => $status,
-            'status_reason' => $reason,
-            'approved_by'   => $userId,
-            'updated_by'    => $userId
-        ]);
-
-        if (!$success) {
-            log_message('error', 'Expense update failed for ID ' . $id);
-            return $this->response->setJSON(['error' => 'Update failed']);
-        }
-
-        return $this->response->setJSON(['success' => true]);
-    }
-
-    /**
-     * Build a public URL for a receipt filename through Files::receipt($name).
-     * Expects just the filename (e.g., "1759113425_1c443e607e1900f92f62.png").
-     */
-    private function receiptUrl(?string $filename): ?string
-    {
-        if (!$filename) {
-            return null;
-        }
-        // Route should be defined as: $routes->get('receipts/(:any)', 'Files::receipt/$1');
-        return site_url('receipts/' . $filename);
-    }
-
-
-
-    public function edit(int $id)
-    {
-        $expense = $this->expenseModel->find($id);
-        if (!$expense) {
-            throw PageNotFoundException::forPageNotFound("Expense #$id not found");
-        }
-
-        // same user list you use in create()
-        $users = $this->staffUsers();
-
-        return view('expenses/edit', [
-            'expense'     => $expense,
-            'users'       => $users,
-            'retailors'   => $this->retailors,
-            'receipt_url' => $expense['receipt_path'] ? site_url('receipts/' . basename($expense['receipt_path'])) : null,
-        ]);
-    }
-
-    public function update(int $id)
-    {
-        helper(['form']);
-
-        $expense = $this->expenseModel->find($id);
-        if (!$expense) {
-            throw PageNotFoundException::forPageNotFound("Expense #$id not found");
-        }
-
-        // Base rules
-        $rules = [
-            'category'     => 'required|in_list[Expense,Purchase,Reimbursement,Donation]',
-            'amount'       => 'required|decimal|greater_than[0]',
-            'purchased_by' => 'required', // still "id|Full Name"
-            'retailor'         => 'permit_empty|max_length[255]',
-            'date_of_purchase' => 'permit_empty',
-        ];
-
-        // Optional new receipt validation (only if provided)
-        $file = $this->request->getFile('receipt');
-        if ($file && $file->isValid() && ($file->getSize() ?? 0) > 0) {
-            $rules['receipt'] = 'max_size[receipt,2048]'
-                . '|ext_in[receipt,jpg,jpeg,png,webp,gif,pdf]'
-                . '|mime_in[receipt,image/jpg,image/jpeg,image/png,image/webp,image/gif,application/pdf]';
-        }
-
-        if (!$this->validate($rules)) {
-            return redirect()->back()->withInput()->with('errors', $this->validator->getErrors());
-        }
-
-        // Parse "id|Name"
-        [$purchasedById] = array_pad(explode('|', (string) $this->request->getPost('purchased_by'), 2), 2, null);
-        $purchasedById = (int) $purchasedById;
-        $category   = (string) $this->request->getPost('category');
-        $isDonation = ($category === 'Donation');
-        $userId     = (int) (session()->get('user_id') ?? 0);
-
-        // Keep old receipt unless replaced or removed
-        $receiptName = $expense['receipt_path'];
-        if ($file && $file->isValid() && !$file->hasMoved() && ($file->getSize() ?? 0) > 0) {
-            $stored      = $file->store('receipts');
-            $receiptName = basename($stored);
-        }
-        if ($this->request->getPost('remove_receipt') === '1') {
-            $receiptName = null;
-        }
-
-        $updateData = [
-            'category'     => $category,
-            'amount'       => (string) $this->request->getPost('amount'),
-            'description'  => (string) $this->request->getPost('description'),
-            'retailor'     => trim((string) $this->request->getPost('retailor')) ?: null,
-            'date_of_purchase' => (string) $this->request->getPost('date_of_purchase') ?: null,
-            'purchased_by' => $purchasedById,
-            'receipt_path' => $receiptName,
-            'updated_by'   => $userId,
-        ];
-
-        if ($isDonation) {
-            $updateData['status']           = 'approved';
-            $updateData['status_reason']    = 'Marked as Donation (non-reimbursable).';
-            $updateData['approved_by']      = $userId ?: null;
-            $updateData['reimbursement_id'] = null;
-        } elseif (($expense['category'] ?? '') === 'Donation') {
-            // Moving a donation back to a reimbursable category: clear the marker.
-            $updateData['status_reason'] = null;
-            $updateData['approved_by']   = $expense['approved_by'] ?? null;
-            $updateData['status']        = $expense['status'] ?? 'pending';
-        }
-
-        $this->expenseModel->update($id, $updateData);
-
-        return redirect()->to('/expenses/index')->with('success', 'Expense updated.');
-    }
-}
diff --git a/app/Http/Controllers/old/ExtraChargesController.php b/app/Http/Controllers/old/ExtraChargesController.php
deleted file mode 100644
index 37cd2bf0..00000000
--- a/app/Http/Controllers/old/ExtraChargesController.php
+++ /dev/null
@@ -1,588 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Controllers\BaseController;
-use App\Models\AdditionalChargeModel;
-use CodeIgniter\Controller;
-use App\Models\UserModel;
-use App\Models\ConfigurationModel;
-use CodeIgniter\Events\Events;
-use App\Models\InvoiceModel;
-use CodeIgniter\I18n\Time;
-
-class ExtraChargesController extends BaseController
-{
-    protected $additionalChargeModel;
-    protected $db;
-    protected $configModel;
-    protected $semester;
-    protected $schoolYear;
-    protected $attendanceDataModel;
-    protected $studentModel;
-    protected $emergencyContactModel;
-    protected $userModel;
-    protected $teacherClassSection;
-    protected $invoiceModel;
-    protected $classSectionModel;
-    protected $studentClassModel;
-    protected $enableAttendance;
-    protected $attendanceDayModel;
-
-    public function __construct()
-    {
-        // Initialize the database connection in the constructor
-        $this->db = \Config\Database::connect();
-        $this->configModel = new ConfigurationModel();
-        $this->additionalChargeModel = new AdditionalChargeModel();
-        $this->userModel = new UserModel();
-        $this->invoiceModel = new InvoiceModel();
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-    }
-
-    public function index()
-    {
-        // API-first: delegate to JSON list endpoint
-        return $this->apiList();
-    }
-
-    /** Render HTML management page */
-    public function page()
-    {
-        $parentId   = (int)($this->request->getGet('parent_id') ?? 0);
-        $status     = $this->request->getGet('status') ?: null;
-        $yearSelect = (string)($this->request->getGet('school_year') ?? $this->schoolYear);
-
-        $rows = [];
-        if ($parentId > 0) {
-            $rows = $this->additionalChargeModel
-                ->byParentTerm($parentId, $this->schoolYear, $this->semester, $status);
-        }
-
-        // Load ALL parents for current view
-        $parents = $this->userModel->select('users.id, users.firstname, users.lastname')
-            ->join('user_roles', 'user_roles.user_id = users.id')
-            ->join('roles', 'roles.id = user_roles.role_id')
-            ->where('LOWER(roles.name) =', 'parent')
-            ->where('user_roles.deleted_at IS NULL', null, false)
-            ->orderBy('users.lastname', 'ASC')
-            ->orderBy('users.firstname', 'ASC')
-            ->findAll();
-
-        // Map parent id -> "Lastname, Firstname" (no email/ID shown)
-        $parentMap = [];
-        foreach ($parents as $p) {
-            $label = trim(($p['lastname'] ?? '') . ', ' . ($p['firstname'] ?? ''));
-            $parentMap[(int)$p['id']] = $label !== '' && $label !== ',' ? $label : ('User #' . (int)$p['id']);
-        }
-
-        // 🔹 Get ALL invoices for ALL parents this year, group by parent_id
-        $parentIds = array_map(fn($r) => (int)$r['id'], $parents);
-        $invoicesByParent = [];
-        if (!empty($parentIds)) {
-            $all = $this->invoiceModel->getAllInvoicesByUserIds($parentIds, $yearSelect);
-            foreach ($all as $inv) {
-                $pid = (int)$inv['parent_id'];
-                $invoicesByParent[$pid][] = [
-                    'id'             => (int)$inv['id'],
-                    'invoice_number' => (string)$inv['invoice_number'],
-                    'status'         => (string)($inv['status'] ?? ''),
-                    'balance'        => (float)($inv['balance'] ?? 0),
-                    'issue_date'     => $inv['issue_date'] ?? null,
-                ];
-            }
-        }
-
-        // Label for preselect (if filtering by a parent)
-        $selectedParentLabel = ($parentId > 0 && isset($parentMap[$parentId])) ? $parentMap[$parentId] : '';
-
-        // Optional filters
-        $status = $this->request->getGet('status') ?: null;
-        $q      = trim((string)($this->request->getGet('q') ?? ''));
-
-        // ✅ Always pull all charges for the selected year & current semester (all parents)
-        $rows   = $this->additionalChargeModel->listAllForTerm(
-            $yearSelect,
-            $this->semester,
-            $status,
-            $q,
-            50 // per-page
-        );
-        $pager  = $this->additionalChargeModel->pager;
-
-        // Build school year options from data (additional_charges + invoices)
-        $schoolYears = [];
-        try {
-            $q1 = $this->db->table('additional_charges')->select('DISTINCT school_year', false)
-                ->where('school_year IS NOT NULL', null, false)
-                ->orderBy('school_year', 'DESC')->get()->getResultArray();
-            foreach ($q1 as $r) {
-                $val = (string)($r['school_year'] ?? '');
-                if ($val !== '' && !in_array($val, $schoolYears, true)) $schoolYears[] = $val;
-            }
-        } catch (\Throwable $e) {}
-        try {
-            $q2 = $this->db->table('invoices')->select('DISTINCT school_year', false)
-                ->where('school_year IS NOT NULL', null, false)
-                ->orderBy('school_year', 'DESC')->get()->getResultArray();
-            foreach ($q2 as $r) {
-                $val = (string)($r['school_year'] ?? '');
-                if ($val !== '' && !in_array($val, $schoolYears, true)) $schoolYears[] = $val;
-            }
-        } catch (\Throwable $e) {}
-        if (empty($schoolYears) && is_string($this->schoolYear) && $this->schoolYear !== '') {
-            // fallback: generate recent years around configured schoolYear
-            $schoolYears[] = $this->schoolYear;
-            // Optionally add previous/next
-            [$start, $end] = explode('-', $this->schoolYear) + [0 => date('Y'), 1 => date('Y')+1];
-            $start = (int)$start;
-            for ($i = 1; $i <= 3; $i++) {
-                $schoolYears[] = ($start - $i) . '-' . (($start - $i) + 1);
-            }
-        }
-        rsort($schoolYears);
-
-        return view('payment/extra_charges', [
-            'q'          => $q,
-            'pager'      => $pager,
-            'rows'                => $rows,
-            'parents'             => $parents,
-            'parentMap'           => $parentMap,
-            'invoicesByParent'    => $invoicesByParent, // 🔹 pass the grouped map
-            'parentId'            => $parentId,
-            'selectedParentLabel' => $selectedParentLabel,
-            'status'              => $status,
-            'schoolYear'          => $yearSelect,
-            'schoolYears'         => $schoolYears,
-            'semester'            => $this->semester,
-        ]);
-    }
-
-    private function wantsJson(): bool
-    {
-        $accept = strtolower((string)($this->request->getHeaderLine('Accept') ?? ''));
-        return $this->request->isAJAX() || str_contains($accept, 'application/json');
-    }
-
-    /** Used by Select2 AJAX: returns {results:[{id,text}]} */
-    public function parentOptions()
-    {
-        $q     = trim((string)($this->request->getGet('q') ?? ''));
-        $limit = 20;
-
-        $builder = $this->userModel
-            ->select('users.id, users.firstname, users.lastname, users.email')
-            ->join('user_roles', 'user_roles.user_id = users.id')
-            ->join('roles', 'roles.id = user_roles.role_id')
-            // If your role name may have different case, use LOWER(...):
-            // ->where('LOWER(roles.name) =', 'parent')
-            ->where('roles.name', 'parent')
-            // Make sure this produces IS NULL; if not, use the raw condition line below
-            ->where('user_roles.deleted_at', null);
-
-        // Alternative guaranteed-IS-NULL:
-        // $builder->where('user_roles.deleted_at IS NULL', null, false);
-
-        if ($q !== '') {
-            $builder->groupStart()
-                ->like('users.firstname', $q)
-                ->orLike('users.lastname', $q)
-                ->orLike('users.email', $q)
-                ->groupEnd();
-        }
-
-        $rows = $builder
-            ->orderBy('users.lastname', 'ASC')
-            ->orderBy('users.firstname', 'ASC')
-            ->limit($limit)
-            ->find();
-
-        $results = array_map(function ($r) {
-            $name  = trim(($r['lastname'] ?? '') . ', ' . ($r['firstname'] ?? ''));
-            $email = $r['email'] ?? '';
-            $label = $name !== ',' ? $name : ('User #' . $r['id']);
-            if ($email) $label .= ' — ' . $email;
-            $label .= ' (ID: ' . $r['id'] . ')';
-            return ['id' => (int)$r['id'], 'text' => $label];
-        }, $rows);
-
-        return $this->response->setJSON(['results' => $results]);
-    }
-
-    /** Helper for preselect label in the modal */
-    private function getParentLabel(int $id): string
-    {
-        $p = $this->userModel->select('firstname, lastname, email')->find($id);
-        if (!$p) return 'User #' . $id;
-        $name  = trim(($p['lastname'] ?? '') . ', ' . ($p['firstname'] ?? ''));
-        $email = $p['email'] ?? '';
-        $label = $name !== ',' ? $name : ('User #' . $id);
-        if ($email) $label .= ' — ' . $email;
-        return $label . ' (ID: ' . $id . ')';
-    }
-
-    public function update($id)
-    {
-        $row = $this->additionalChargeModel->find($id);
-        if (!$row) {
-            if ($this->wantsJson()) return $this->response->setJSON(['ok' => false, 'error' => 'Charge not found', 'csrf_token' => csrf_token(), 'csrf_hash' => csrf_hash()]);
-            return redirect()->back()->with('error', 'Charge not found.');
-        }
-
-        $data = $this->request->getPost();
-        $newAmount = isset($data['amount']) ? (float)$data['amount'] : (float)$row['amount'];
-        $delta = $newAmount - (float)$row['amount'];
-
-        $db = \Config\Database::connect();
-        $db->transStart();
-
-        // Update the charge first
-        $this->additionalChargeModel->update($id, [
-            'title'       => trim($data['title'] ?? $row['title']),
-            'description' => trim($data['description'] ?? $row['description']),
-            'amount'      => $newAmount,
-            'due_date'    => $data['due_date'] ?? $row['due_date'],
-            'charge_type' => $data['charge_type'] ?? $row['charge_type'],
-            // keep status as-is
-        ]);
-
-        // If it’s already applied on an invoice and the amount changed, reflect the delta
-        if ($row['status'] === 'applied' && !empty($row['invoice_id']) && abs($delta) > 0.00001) {
-            if ($delta > 0) {
-                $this->invoiceModel->applyAdditionalCharge((int)$row['invoice_id'], $delta);
-            } else {
-                $this->invoiceModel->reverseAdditionalCharge((int)$row['invoice_id'], -$delta);
-            }
-        }
-
-        $db->transComplete();
-
-        if (!$db->transStatus()) {
-            if ($this->wantsJson()) return $this->response->setJSON(['ok' => false, 'error' => 'Failed to update charge', 'csrf_token' => csrf_token(), 'csrf_hash' => csrf_hash()]);
-            return redirect()->back()->with('error', 'Failed to update charge.');
-        }
-
-        if ($this->wantsJson()) return $this->response->setJSON(['ok' => true, 'id' => (int)$id, 'csrf_token' => csrf_token(), 'csrf_hash' => csrf_hash()]);
-        return redirect()->back()->with('status', 'Charge updated.');
-    }
-
-    // (removed duplicate model-like listAllForTerm method; use AdditionalChargeModel::listAllForTerm)
-
-    // ExtraChargesController.php
-    public function invoicesForParent()
-    {
-        $parentId   = (int)($this->request->getGet('parent_id') ?? 0);
-        $schoolYear = (string)($this->request->getGet('school_year') ?? $this->schoolYear);
-
-        $rows = ($parentId > 0)
-            ? ($this->invoiceModel->getInvoicesByUserId($parentId, $schoolYear) ?? [])
-            : [];
-
-        $results = array_map(function ($inv) {
-            $id       = (int)($inv['id'] ?? 0);
-            $num      = (string)($inv['invoice_number'] ?? ('INV-' . $id));
-            $status   = strtolower((string)($inv['status'] ?? ''));
-            $balance  = (float)($inv['balance'] ?? 0);
-            $issue    = $inv['issue_date'] ?? null;
-
-            return [
-                'id'             => $id,
-                'invoice_number' => $num,
-                'status'         => $status,
-                'balance'        => $balance,
-                'issue_date'     => $issue,
-                'text'           => $num
-                    . ($status ? ' — ' . ucfirst($status) : '')
-                    . ' (Bal: $' . number_format($balance, 2) . ')',
-            ];
-        }, $rows);
-
-        return $this->response->setJSON(['results' => $results]);
-    }
-
-
-    public function store()
-    {
-        $data = $this->request->getPost();
-
-        $rules = [
-            'parent_id'   => 'required|integer',  // this is actually the user_id of the parent
-            'title'       => 'required|string|min_length[2]',
-            'amount'      => 'required|decimal',
-            'charge_type' => 'required|in_list[add,deduct]',
-            'due_date'    => 'permit_empty|valid_date',
-            'invoice_id'  => 'permit_empty|integer',
-        ];
-        if (!$this->validate($rules)) {
-            $msg = implode(' ', $this->validator->getErrors());
-            if ($this->wantsJson()) {
-                return $this->response->setJSON([
-                    'ok' => false,
-                    'error' => $msg,
-                    'csrf_token' => csrf_token(),
-                    'csrf_hash' => csrf_hash(),
-                ]);
-            }
-            return redirect()->back()->withInput()->with('error', $msg);
-        }
-
-        $invoiceId  = !empty($data['invoice_id']) ? (int)$data['invoice_id'] : null;
-        $chargeType = (string)$data['charge_type'];
-
-        $amountAbs    = round(abs((float)$data['amount']), 2);
-        $signedAmount = ($chargeType === 'add') ? $amountAbs : -$amountAbs;
-
-        $payload = [
-            'parent_id'   => (int)$data['parent_id'], // ← users.id of the parent
-            'invoice_id'  => $invoiceId,
-            'school_year' => $data['school_year'] ?? $this->schoolYear,
-            'semester'    => $data['semester']    ?? $this->semester,
-            'charge_type' => $chargeType,
-            'title'       => trim($data['title']),
-            'description' => trim($data['description'] ?? ''),
-            'amount'      => $signedAmount,
-            'due_date'    => !empty($data['due_date']) ? $data['due_date'] : null,
-            'status'      => $invoiceId ? 'applied' : 'pending',
-            'created_by'  => (int)(session()->get('user_id') ?? 0),
-            'created_at'  => \CodeIgniter\I18n\Time::now('UTC')->toDateTimeString(), // store UTC
-        ];
-
-        $this->db->transStart();
-
-        // BEFORE
-        $invoiceBefore = $this->invoiceModel->getInvoicesByParentId($data['parent_id'], $this->schoolYear);
-
-        // Insert charge
-        $this->additionalChargeModel->insert($payload);
-        $chargeId = (int)$this->additionalChargeModel->getInsertID();
-
-        // Apply to invoice if present
-        if ($invoiceId) {
-            try {
-                if ($chargeType === 'add') {
-                    $this->invoiceModel->applyAdditionalCharge($invoiceId, $amountAbs);
-                } else {
-                    $this->invoiceModel->deductAdditionalCharge($invoiceId, $amountAbs);
-                }
-            } catch (\Throwable $e) {
-                log_message('error', 'apply/deductAdditionalCharge failed: ' . $e->getMessage());
-            }
-        }
-
-        // AFTER
-        $invoiceAfter = $this->invoiceModel->getInvoicesByParentId($data['parent_id'], $this->schoolYear);
-
-        // Parent USER (not parent table)
-        $parentUser = $this->userModel->getUserInfoById($data['parent_id']);
-
-        $this->db->transComplete();
-
-        if (!$this->db->transStatus()) {
-            $err = $this->db->error();
-            log_message('error', 'Transaction failed in ExtraChargesController::store: ' . json_encode($err));
-            if ($this->wantsJson()) {
-                return $this->response->setJSON(['ok' => false, 'error' => 'Failed to save charge', 'csrf_token' => csrf_token(), 'csrf_hash' => csrf_hash()]);
-            }
-            return redirect()->back()->withInput()->with('error', 'Failed to save charge.');
-        }
-
-        // Build event payload (same style as your payment handler)
-        // allow either first_name/last_name OR firstname/lastname from users table
-        $first = $parentUser['first_name'] ?? $parentUser['firstname'] ?? '';
-        $last  = $parentUser['last_name']  ?? $parentUser['lastname']  ?? '';
-        $parentName = trim($first . ' ' . $last);
-
-        $invoiceBefore = $this->normalizeRow($invoiceBefore);
-        $invoiceAfter  = $this->normalizeRow($invoiceAfter);
-
-        $invoiceTotal = $invoiceAfter ? (float)($invoiceAfter['total_amount'] ?? 0) : 0.0;
-        $preBalance   = $invoiceBefore ? (float)($invoiceBefore['balance'] ?? 0) : 0.0;
-        $postBalance  = $invoiceAfter  ? (float)($invoiceAfter['balance'] ?? 0)  : 0.0;
-
-        $eventData = [
-            // user identity (parent user)
-            'user_id'        => (int)($parentUser['id'] ?? 0),
-            'email'          => $parentUser['email'] ?? null,
-            'firstname'      => $first,
-            'lastname'       => $last,
-            'parentName'     => $parentName,
-
-            // context
-            'school_year'    => $payload['school_year'],
-            'semester'       => $payload['semester'],
-
-            // invoice
-            'invoice_id'     => $invoiceId,
-            'invoice_number' => $invoiceAfter['invoice_number'] ?? ($invoiceId ? 'INV-' . $invoiceId : null),
-
-            // charge details
-            'charge_id'      => $chargeId,
-            'charge_title'   => $payload['title'],
-            'charge_desc'    => $payload['description'],
-            'charge_type'    => $payload['charge_type'],     // add|deduct
-            'amount_signed'  => $signedAmount,
-            'amount_abs'     => $amountAbs,
-            'due_date'       => $payload['due_date'],
-            'created_at'     => $payload['created_at'],
-
-            // money snapshot
-            'pre_balance'    => $preBalance,
-            'post_balance'   => $postBalance,
-            'invoice_total'  => $invoiceTotal,
-
-            // links
-            'portal_link'    => base_url('/login'),
-            'invoice_link'   => $invoiceId ? site_url('parent/invoices/view/' . $invoiceId) : site_url('parent/invoices'),
-        ];
-
-        $students = []; // keep [] unless you want to include children under this user
-        Events::trigger('extraCharge', $eventData, $students);
-
-        if ($this->wantsJson()) {
-            return $this->response->setJSON([
-                'ok'          => true,
-                'id'          => $chargeId,
-                'invoice_id'  => $invoiceId,
-                'parent_id'   => (int)$data['parent_id'],
-                'csrf_token'  => csrf_token(),
-                'csrf_hash'   => csrf_hash(),
-            ]);
-        }
-        return redirect()->to(site_url('admin/charges'))->with('status', 'Charge recorded.');
-    }
-
-    /**
-     * Mark a charge as void and roll back its impact on the invoice if applied.
-     */
-    public function void($id)
-    {
-        $row = $this->additionalChargeModel->find((int)$id);
-        if (!$row) {
-            if ($this->wantsJson()) return $this->response->setJSON(['ok' => false, 'error' => 'Charge not found']);
-            return redirect()->back()->with('error', 'Charge not found.');
-        }
-
-        $invoiceId  = (int)($row['invoice_id'] ?? 0);
-        $amountAbs  = round(abs((float)($row['amount'] ?? 0)), 2);
-        $chargeType = (string)($row['charge_type'] ?? 'add');
-        $status     = (string)($row['status'] ?? 'pending');
-
-        $this->db->transStart();
-
-        if ($status === 'applied' && $invoiceId > 0 && $amountAbs > 0) {
-            try {
-                if ($chargeType === 'add') {
-                    $this->invoiceModel->reverseAdditionalCharge($invoiceId, $amountAbs);
-                } else {
-                    // voiding a deduction -> add back
-                    $this->invoiceModel->applyAdditionalCharge($invoiceId, $amountAbs);
-                }
-            } catch (\Throwable $e) {
-                log_message('error', 'void(): invoice adjust failed: ' . $e->getMessage());
-            }
-        }
-
-        $this->additionalChargeModel->update((int)$id, [
-            'status' => 'void',
-        ]);
-
-        $this->db->transComplete();
-
-        if (!$this->db->transStatus()) {
-            if ($this->wantsJson()) return $this->response->setJSON(['ok' => false, 'error' => 'Failed to void charge']);
-            return redirect()->back()->with('error', 'Failed to void charge.');
-        }
-
-        if ($this->wantsJson()) return $this->response->setJSON(['ok' => true]);
-        return redirect()->back()->with('status', 'Charge voided.');
-    }
-
-    /**
-     * Reverse a previously applied charge: undo invoice impact and return to pending state.
-     */
-    public function reverse($id)
-    {
-        $row = $this->additionalChargeModel->find((int)$id);
-        if (!$row) {
-            if ($this->wantsJson()) return $this->response->setJSON(['ok' => false, 'error' => 'Charge not found']);
-            return redirect()->back()->with('error', 'Charge not found.');
-        }
-
-        $invoiceId  = (int)($row['invoice_id'] ?? 0);
-        $amountAbs  = round(abs((float)($row['amount'] ?? 0)), 2);
-        $chargeType = (string)($row['charge_type'] ?? 'add');
-        $status     = (string)($row['status'] ?? 'pending');
-
-        if ($status !== 'applied' || $invoiceId <= 0 || $amountAbs <= 0) {
-            if ($this->wantsJson()) return $this->response->setJSON(['ok' => false, 'error' => 'Nothing to reverse']);
-            return redirect()->back()->with('error', 'Nothing to reverse.');
-        }
-
-        $this->db->transStart();
-        try {
-            if ($chargeType === 'add') {
-                $this->invoiceModel->reverseAdditionalCharge($invoiceId, $amountAbs);
-            } else {
-                $this->invoiceModel->applyAdditionalCharge($invoiceId, $amountAbs);
-            }
-        } catch (\Throwable $e) {
-            log_message('error', 'reverse(): invoice adjust failed: ' . $e->getMessage());
-        }
-
-        $this->additionalChargeModel->update((int)$id, [
-            'status'     => 'pending',
-            'invoice_id' => null,
-        ]);
-
-        $this->db->transComplete();
-
-        if (!$this->db->transStatus()) {
-            if ($this->wantsJson()) return $this->response->setJSON(['ok' => false, 'error' => 'Failed to reverse charge']);
-            return redirect()->back()->with('error', 'Failed to reverse charge.');
-        }
-
-        if ($this->wantsJson()) return $this->response->setJSON(['ok' => true]);
-        return redirect()->back()->with('status', 'Charge reversed to pending.');
-    }
-
-    /** JSON: list charges for the current term (with optional filters). */
-    public function apiList()
-    {
-        $year   = (string)($this->request->getGet('school_year') ?? $this->schoolYear);
-        $sem    = (string)($this->request->getGet('semester')    ?? $this->semester);
-        $status = $this->request->getGet('status') ?: null;
-        $q      = trim((string)($this->request->getGet('q') ?? '')) ?: null;
-        $per    = (int)($this->request->getGet('per_page') ?? 50);
-
-        $rows   = $this->additionalChargeModel->listAllForTerm($year, $sem, $status, $q, $per);
-        $pager  = $this->additionalChargeModel->pager;
-
-        $meta = [
-            'perPage'   => method_exists($pager, 'getPerPage') ? $pager->getPerPage() : $per,
-            'page'      => method_exists($pager, 'getCurrentPage') ? $pager->getCurrentPage() : null,
-            'total'     => method_exists($pager, 'getTotal') ? $pager->getTotal() : null,
-            'pageCount' => method_exists($pager, 'getPageCount') ? $pager->getPageCount() : null,
-        ];
-
-        return $this->response->setJSON([
-            'ok'          => true,
-            'school_year' => $year,
-            'semester'    => $sem,
-            'rows'        => $rows,
-            'pager'       => $meta,
-            'csrf_token'  => csrf_token(),
-            'csrf_hash'   => csrf_hash(),
-        ]);
-    }
-
-    // Normalize query result into a single associative row
-    private function normalizeRow($row): ?array
-    {
-        if (!$row) return null;
-        if (is_array($row) && isset($row[0]) && is_array($row[0])) {
-            return $row[0]; // unwrap first row from a result set
-        }
-        return is_array($row) ? $row : null;
-    }
-}
diff --git a/app/Http/Controllers/old/FeeCalculationService.php b/app/Http/Controllers/old/FeeCalculationService.php
new file mode 100644
index 00000000..f5540f32
--- /dev/null
+++ b/app/Http/Controllers/old/FeeCalculationService.php
@@ -0,0 +1,183 @@
+<?php
+namespace App\Services;
+
+use App\Models\ConfigurationModel;
+use App\Models\PaymentModel;
+use App\Models\InvoiceModel;
+use App\Models\ClassSectionModel;
+
+class FeeCalculationService
+{
+    public function calculateRefund(array $students, int $parentId): float
+    {
+        $configModel = new ConfigurationModel();
+        $paymentModel = new PaymentModel();
+        $invoiceModel = new InvoiceModel();
+        $classSectionModel = new ClassSectionModel();
+
+        $schoolYear = $configModel->getConfig('school_year');
+        $refundDeadline = date('Y-m-d', strtotime($configModel->getConfig('refund_deadline')));
+        $weekOfStudy = (float) ($configModel->getConfig('weeks_study') ?? 8);
+        $schoolEndDate = date('Y-m-d', strtotime($configModel->getConfig('last_school_day')));
+        $totalPaid = $paymentModel->getTotalPaidByParentId($parentId, $schoolYear);
+
+        if ($totalPaid <= 0) {
+            log_message('info', "No payments made. Refund = 0.");
+            return 0;
+        }
+
+        // Classify and enrich student data
+        $registeredStudents = [];
+        $withdrawnStudents = [];
+
+        foreach ($students as &$student) {
+            $gradeName = $classSectionModel->getClassSectionNameBySectionId($student['class_section_id']);
+            $student['grade'] = strtoupper(trim($gradeName));
+
+            if (in_array($student['enrollment_status'], ['withdrawn', 'refund pending', 'withdraw under review'])) {
+                $withdrawnStudents[] = $student;
+            } elseif (
+                in_array($student['enrollment_status'], ['enrolled', 'payment pending']) &&
+                $student['admission_status'] === 'accepted'
+            ) {
+                $registeredStudents[] = $student;
+            }
+        }
+        unset($student);
+
+        if (empty($withdrawnStudents)) {
+            log_message('info', "No withdrawn students found. Refund = 0.");
+            return 0;
+        }
+
+        // Combine all students for proper fee tiering
+        $allStudents = array_merge($registeredStudents, $withdrawnStudents);
+
+        // Sort all students by grade for correct tiering
+        usort($allStudents, function ($a, $b) {
+            return $this->compareGrades($a['grade'], $b['grade']);
+        });
+
+        // Retrieve fee configs
+        $firstStudentFee = (float) ($configModel->getConfig('first_student_fee') ?? 350);
+        $secondStudentFee = (float) ($configModel->getConfig('second_student_fee') ?? 200);
+        $youthFee = (float) ($configModel->getConfig('youth_fee') ?? 180);
+
+        // Assign tuition_fee to all students (before filtering refunds)
+        $regularCount = 0;
+        foreach ($allStudents as &$student) {
+            $gradeLevel = $this->getGradeLevel($student['grade']);
+
+            if ($gradeLevel > 9) {
+                $studentFee = $youthFee;
+            } else {
+                $studentFee = ($regularCount === 0) ? $firstStudentFee : $secondStudentFee;
+                $regularCount++;
+            }
+        }
+        unset($student);
+
+        // Calculate refund for withdrawn students
+        $refundAmount = 0;
+
+        foreach ($withdrawnStudents as $student) {
+            if (empty($student['withdrawal_date'])) {
+                log_message('warning', "Missing withdraw date for student ID: {$student['student_id']}");
+                continue;
+            }
+
+            $withdrawDate = date('Y-m-d', strtotime($student['withdrawal_date']));
+            if (strtotime($withdrawDate) > strtotime($refundDeadline)) {
+                log_message('info', "Withdraw date {$withdrawDate} is after refund deadline {$refundDeadline}. No refund for this student.");
+                continue;
+            }
+
+            $withdrawDateObj = new \DateTime($withdrawDate);
+            $schoolEndDateObj = new \DateTime($schoolEndDate);
+            $daysRemaining = $withdrawDateObj->diff($schoolEndDateObj)->days;
+            $weeksRemaining = min($weekOfStudy, max(0, ceil($daysRemaining / 7)));
+
+            //$studentFee = $student['tuition_fee'];
+            $proportionalRefund = ($studentFee / $weekOfStudy) * $weeksRemaining;
+            $refundAmount += $proportionalRefund;
+
+            log_message('info', "Student ID {$student['student_id']} refund portion: {$proportionalRefund} of {$studentFee} for {$weeksRemaining} weeks.");
+        }
+
+        if ($refundAmount > $totalPaid) {
+            log_message('info', "Refund capped at total paid amount: {$totalPaid}");
+            return $totalPaid;
+        }
+
+        log_message('info', "Final calculated refund: {$refundAmount}");
+        return $refundAmount;
+    }
+
+
+    private function compareGrades($gradeA, $gradeB)
+    {
+        $valA = $this->getGradeLevel($gradeA);
+        $valB = $this->getGradeLevel($gradeB);
+
+        if ($valA !== $valB) return $valA <=> $valB;
+
+        // Same level, compare suffix
+        preg_match('/\d+([A-Z]*)$/i', strtoupper($gradeA), $suffixA);
+        preg_match('/\d+([A-Z]*)$/i', strtoupper($gradeB), $suffixB);
+
+        return strcmp($suffixA[1] ?? '', $suffixB[1] ?? '');
+    }
+
+    private function getGradeLevel($grade)
+    {
+        if (strtoupper($grade) === 'K') return 0;
+        if (strtoupper($grade) === 'Y') return 99;
+
+        if (preg_match('/^(\d+)([A-Z]*)$/i', $grade, $matches)) {
+            return (int) $matches[1];
+        }
+
+        return 999; // fallback for unknown/malformed grades
+    }
+
+
+    private function calculateTotalTuitionFee(array $students): float
+    {
+        $configModel = new ConfigurationModel();
+        $classSectionModel = new \App\Models\ClassSectionModel();
+
+        $firstStudentFee = (float) ($configModel->getConfig('first_student_fee') ?? 350);
+        $secondStudentFee = (float) ($configModel->getConfig('second_student_fee') ?? 200);
+        $youthFee = (float) ($configModel->getConfig('youth_fee') ?? 180);
+
+        // ✅ Pre-fetch and assign grade/class section names before sorting
+        foreach ($students as &$student) {
+            $gradeName = $classSectionModel->getClassSectionNameBySectionId($student['class_section_id']);
+            $student['grade'] = strtoupper(trim($gradeName));
+        }
+        unset($student); // break reference
+
+        // ✅ Sort students by grade
+        usort($students, function ($a, $b) {
+            return $this->compareGrades($a['grade'], $b['grade']);
+        });
+
+        $regularCount = 0;
+        $totalFee = 0;
+
+        // ✅ Calculate fee
+        foreach ($students as $student) {
+            $gradeLevel = $this->getGradeLevel($student['grade']);
+
+            if ($gradeLevel > 9) {
+                $totalFee += $youthFee;
+            } else {
+                $totalFee += ($regularCount === 0) ? $firstStudentFee : $secondStudentFee;
+                $regularCount++;
+            }
+        }
+
+        return $totalFee;
+    }
+
+}
diff --git a/app/Http/Controllers/old/FilesController.php b/app/Http/Controllers/old/FilesController.php
deleted file mode 100644
index 31a04946..00000000
--- a/app/Http/Controllers/old/FilesController.php
+++ /dev/null
@@ -1,304 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use CodeIgniter\Controller;
-use CodeIgniter\Exceptions\PageNotFoundException;
-use Config\Database;
-
-class FilesController extends Controller
-{
-    public function receipt(string $name)
-    {
-        // 1) Path traversal guard
-        if ($name !== basename($name)) {
-            return $this->response->setStatusCode(400, 'Invalid filename');
-        }
-
-        // 2) Allow-list extensions (optional but safer)
-        $ext = strtolower(pathinfo($name, PATHINFO_EXTENSION));
-        $allowed = ['jpg', 'jpeg', 'png', 'webp', 'gif', 'pdf'];
-        if (!in_array($ext, $allowed, true)) {
-            throw PageNotFoundException::forPageNotFound();
-        }
-
-        // 3) Build path under writable
-        $path = WRITEPATH . 'uploads/receipts/' . $name;
-        if (!is_file($path)) {
-            throw PageNotFoundException::forPageNotFound();
-        }
-
-        // 4) MIME detection (finfo is more reliable than mime_content_type)
-        $mime = 'application/octet-stream';
-        if (function_exists('finfo_open')) {
-            $fi = finfo_open(FILEINFO_MIME_TYPE);
-            if ($fi) {
-                $detected = finfo_file($fi, $path);
-                if ($detected) $mime = $detected;
-                finfo_close($fi);
-            }
-        }
-
-        // 5) Caching (ETag + Last-Modified) and 304 support
-        $mtime = filemtime($path) ?: time();
-        $etag  = md5($name . '|' . $mtime . '|' . filesize($path));
-
-        $ifNoneMatch     = $this->request->getHeaderLine('If-None-Match');
-        $ifModifiedSince = $this->request->getHeaderLine('If-Modified-Since');
-
-        if ($ifNoneMatch === $etag || (strtotime($ifModifiedSince) >= $mtime)) {
-            return $this->response
-                ->setStatusCode(304)
-                ->setHeader('ETag', $etag)
-                ->setHeader('Last-Modified', gmdate('D, d M Y H:i:s', $mtime) . ' GMT');
-        }
-
-        // 6) Stream the file inline
-        return $this->response
-            ->setStatusCode(200)
-            ->setHeader('Content-Type', $mime)
-            ->setHeader('Content-Disposition', 'inline; filename="' . $name . '"')
-            ->setHeader('Content-Length', (string) filesize($path))
-            ->setHeader('ETag', $etag)
-            ->setHeader('Last-Modified', gmdate('D, d M Y H:i:s', $mtime) . ' GMT')
-            ->setHeader('Cache-Control', 'public, max-age=86400')
-            ->setBody(file_get_contents($path));
-    }
-
-    public function reimb(string $name)
-    {
-        // 1) Path traversal guard
-        if ($name !== basename($name)) {
-            return $this->response->setStatusCode(400, 'Invalid filename');
-        }
-
-        // 2) Allow-list extensions
-        $ext = strtolower(pathinfo($name, PATHINFO_EXTENSION));
-        $allowed = ['jpg', 'jpeg', 'png', 'webp', 'gif', 'pdf'];
-        if (!in_array($ext, $allowed, true)) {
-            throw \CodeIgniter\Exceptions\PageNotFoundException::forPageNotFound();
-        }
-
-        // 3) Build path under writable (REIMBURSEMENTS)
-        $path = WRITEPATH . 'uploads/reimbursements/' . $name;
-        if (!is_file($path)) {
-            throw \CodeIgniter\Exceptions\PageNotFoundException::forPageNotFound();
-        }
-
-        // 4) MIME detection (prefer finfo)
-        $mime = 'application/octet-stream';
-        if (function_exists('finfo_open')) {
-            $fi = finfo_open(FILEINFO_MIME_TYPE);
-            if ($fi) {
-                $detected = finfo_file($fi, $path);
-                if ($detected) {
-                    $mime = $detected;
-                }
-                finfo_close($fi);
-            }
-        } elseif (function_exists('mime_content_type')) {
-            $mime = mime_content_type($path) ?: $mime;
-        }
-
-        // 5) Caching (ETag + Last-Modified) and 304 support
-        $mtime = filemtime($path) ?: time();
-        $size  = filesize($path) ?: 0;
-        $etag  = md5($name . '|' . $mtime . '|' . $size);
-
-        $ifNoneMatch     = trim($this->request->getHeaderLine('If-None-Match'), '"');
-        $ifModifiedSince = $this->request->getHeaderLine('If-Modified-Since');
-        $imsTime         = $ifModifiedSince ? strtotime($ifModifiedSince) : false;
-
-        if (($ifNoneMatch && $ifNoneMatch === $etag) ||
-            ($imsTime !== false && $imsTime >= $mtime)
-        ) {
-            return $this->response
-                ->setStatusCode(304)
-                ->setHeader('ETag', $etag)
-                ->setHeader('Last-Modified', gmdate('D, d M Y H:i:s', $mtime) . ' GMT');
-        }
-
-        // 6) Stream the file inline
-        return $this->response
-            ->setStatusCode(200)
-            ->setHeader('Content-Type', $mime)
-            ->setHeader('X-Content-Type-Options', 'nosniff')
-            ->setHeader('Content-Disposition', 'inline; filename="' . $name . '"')
-            ->setHeader('Content-Length', (string) $size)
-            ->setHeader('ETag', $etag)
-            ->setHeader('Last-Modified', gmdate('D, d M Y H:i:s', $mtime) . ' GMT')
-            ->setHeader('Cache-Control', 'public, max-age=86400')
-            ->setBody(file_get_contents($path));
-    }
-
-    public function earlyDismissalSignature(string $name)
-    {
-        // 1) Path traversal guard
-        if ($name !== basename($name)) {
-            return $this->response->setStatusCode(400, 'Invalid filename');
-        }
-
-        // 2) Allow-list extensions
-        $ext = strtolower(pathinfo($name, PATHINFO_EXTENSION));
-        $allowed = ['jpg', 'jpeg', 'png', 'webp', 'gif', 'pdf'];
-        if (!in_array($ext, $allowed, true)) {
-            throw PageNotFoundException::forPageNotFound();
-        }
-
-        // 3) Build path under writable (EARLY DISMISSAL SIGNATURES)
-        $path = WRITEPATH . 'uploads/early_dismissal_signatures/' . $name;
-        if (!is_file($path)) {
-            throw PageNotFoundException::forPageNotFound();
-        }
-
-        // 4) MIME detection (prefer finfo)
-        $mime = 'application/octet-stream';
-        if (function_exists('finfo_open')) {
-            $fi = finfo_open(FILEINFO_MIME_TYPE);
-            if ($fi) {
-                $detected = finfo_file($fi, $path);
-                if ($detected) {
-                    $mime = $detected;
-                }
-                finfo_close($fi);
-            }
-        } elseif (function_exists('mime_content_type')) {
-            $mime = mime_content_type($path) ?: $mime;
-        }
-
-        // 5) Caching (ETag + Last-Modified) and 304 support
-        $mtime = filemtime($path) ?: time();
-        $size  = filesize($path) ?: 0;
-        $etag  = md5($name . '|' . $mtime . '|' . $size);
-
-        $ifNoneMatch     = trim($this->request->getHeaderLine('If-None-Match'), '"');
-        $ifModifiedSince = $this->request->getHeaderLine('If-Modified-Since');
-        $imsTime         = $ifModifiedSince ? strtotime($ifModifiedSince) : false;
-
-        if (($ifNoneMatch && $ifNoneMatch === $etag) ||
-            ($imsTime !== false && $imsTime >= $mtime)
-        ) {
-            return $this->response
-                ->setStatusCode(304)
-                ->setHeader('ETag', $etag)
-                ->setHeader('Last-Modified', gmdate('D, d M Y H:i:s', $mtime) . ' GMT');
-        }
-
-        // 6) Stream the file inline
-        return $this->response
-            ->setStatusCode(200)
-            ->setHeader('Content-Type', $mime)
-            ->setHeader('X-Content-Type-Options', 'nosniff')
-            ->setHeader('Content-Disposition', 'inline; filename="' . $name . '"')
-            ->setHeader('Content-Length', (string) $size)
-            ->setHeader('ETag', $etag)
-            ->setHeader('Last-Modified', gmdate('D, d M Y H:i:s', $mtime) . ' GMT')
-            ->setHeader('Cache-Control', 'public, max-age=86400')
-            ->setBody(file_get_contents($path));
-    }
-
-    public function examDraftTeacher(string $name)
-    {
-        return $this->serveExamDraftFile($name, 'drafts');
-    }
-
-    public function examDraftFinal(string $name)
-    {
-        return $this->serveExamDraftFile($name, 'finals');
-    }
-
-    private function serveExamDraftFile(string $name, string $subdir)
-    {
-        if ($name !== basename($name)) {
-            return $this->response->setStatusCode(400, 'Invalid filename');
-        }
-
-        $ext = strtolower(pathinfo($name, PATHINFO_EXTENSION));
-        $allowed = ['doc', 'docx', 'pdf'];
-        if (!in_array($ext, $allowed, true)) {
-            throw PageNotFoundException::forPageNotFound();
-        }
-
-        $path = WRITEPATH . 'uploads/exams/' . trim($subdir, '/') . '/' . $name;
-        if (!is_file($path)) {
-            throw PageNotFoundException::forPageNotFound();
-        }
-
-        $mime = 'application/octet-stream';
-        if (function_exists('finfo_open')) {
-            $fi = finfo_open(FILEINFO_MIME_TYPE);
-            if ($fi) {
-                $detected = finfo_file($fi, $path);
-                if ($detected) {
-                    $mime = $detected;
-                }
-                finfo_close($fi);
-            }
-        } elseif (function_exists('mime_content_type')) {
-            $mime = mime_content_type($path) ?: $mime;
-        }
-
-        $mtime = filemtime($path) ?: time();
-        $size  = filesize($path) ?: 0;
-        $etag  = md5($name . '|' . $mtime . '|' . $size);
-
-        $ifNoneMatch     = trim($this->request->getHeaderLine('If-None-Match'), '"');
-        $ifModifiedSince = $this->request->getHeaderLine('If-Modified-Since');
-        $imsTime         = $ifModifiedSince ? strtotime($ifModifiedSince) : false;
-
-        if (($ifNoneMatch && $ifNoneMatch === $etag) ||
-            ($imsTime !== false && $imsTime >= $mtime)
-        ) {
-            return $this->response
-                ->setStatusCode(304)
-                ->setHeader('ETag', $etag)
-                ->setHeader('Last-Modified', gmdate('D, d M Y H:i:s', $mtime) . ' GMT');
-        }
-
-        $downloadName = $this->buildDraftDownloadName($name, $subdir);
-
-        return $this->response
-            ->setStatusCode(200)
-            ->setHeader('Content-Type', $mime)
-            ->setHeader('X-Content-Type-Options', 'nosniff')
-            ->setHeader('Content-Disposition', 'inline; filename="' . $downloadName . '.' . $ext . '"')
-            ->setHeader('Content-Length', (string) $size)
-            ->setHeader('ETag', $etag)
-            ->setHeader('Last-Modified', gmdate('D, d M Y H:i:s', $mtime) . ' GMT')
-            ->setHeader('Cache-Control', 'public, max-age=86400')
-            ->setBody(file_get_contents($path));
-    }
-
-    private function buildDraftDownloadName(string $filename, string $subdir): string
-    {
-        $column = $subdir === 'finals' ? 'final_file' : 'teacher_file';
-        $db = Database::connect();
-        $row = $db->table('exam_drafts ed')
-            ->select('ed.version, ed.exam_type, ed.class_section_id, cs.class_section_name')
-            ->join('classSection cs', 'cs.class_section_id = ed.class_section_id', 'left')
-            ->where('ed.' . $column, $filename)
-            ->limit(1)
-            ->get()
-            ->getRowArray();
-
-        $classLabel = trim((string) ($row['class_section_name'] ?? 'Class' . ($row['class_section_id'] ?? '0')));
-        $typeLabel = trim((string) ($row['exam_type'] ?? 'Exam'));
-        $version = 'v' . max(1, (int) ($row['version'] ?? 1));
-
-        $parts = array_filter([
-            $this->slugify($classLabel),
-            $this->slugify($typeLabel),
-            $version,
-        ]);
-
-        return implode('_', $parts);
-    }
-
-    private function slugify(string $value): string
-    {
-        $value = trim($value);
-        $value = preg_replace('/[^\p{L}\p{N}]+/u', '_', $value);
-        $value = trim($value, '_');
-        return $value === '' ? 'Exam' : mb_strtolower($value);
-    }
-}
diff --git a/app/Http/Controllers/old/FinalController.php b/app/Http/Controllers/old/FinalController.php
deleted file mode 100644
index c028396a..00000000
--- a/app/Http/Controllers/old/FinalController.php
+++ /dev/null
@@ -1,159 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-use App\Controllers\BaseController;
-use CodeIgniter\Controller;
-use App\Models\TeacherClassModel;
-use App\Models\StudentModel;
-use App\Models\ConfigurationModel;
-use App\Models\GradingLockModel;
-use App\Models\MissingScoreOverrideModel;
-
-class FinalController extends BaseController
-{
-    protected $db;
-    protected $schoolYear;
-    protected $semester;
-    protected $configModel;
-    protected $studentModel;
-    protected $teacherClassModel;
-    protected $gradingLockModel;
-    protected $missingScoreOverrideModel;
-
-    public function __construct()
-    {
-        $this->db = \Config\Database::connect();
-        $this->configModel = new ConfigurationModel();
-        $this->studentModel = new StudentModel();
-        $this->teacherClassModel = new TeacherClassModel();
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->gradingLockModel = new GradingLockModel();
-        $this->missingScoreOverrideModel = new MissingScoreOverrideModel();
-    }
-
-    public function add()
-    {
-        // Accept class_section_id from POST/GET with session fallback
-        $incoming = $this->request->getPost('class_section_id')
-            ?? $this->request->getGet('class_section_id')
-            ?? session()->get('class_section_id');
-
-        $classSectionId = (int) ($incoming ?: 0);
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('status', 'Missing class section.');
-        }
-
-        // Persist for downstream calls
-        session()->set('class_section_id', $classSectionId);
-
-        $semester = $this->getTeacherSelectedSemester();
-        $schoolYear = $this->schoolYear;
-        try {
-            $result = $this->getSavedScores($classSectionId, $semester, $schoolYear);
-            $missingOkMap = $this->missingScoreOverrideModel->getOverridesMap($classSectionId, $semester, $schoolYear, 'final_exam');
-
-            return view('teacher/add_final_exam', [
-                'students'       => $result['students'],
-                'semester'       => $result['semester'],
-                'schoolYear'     => $result['schoolYear'],
-                'classSectionId' => $classSectionId,
-                'missingOkMap'   => $missingOkMap,
-            ]);
-        } catch (\Throwable $e) {
-            return redirect()->back()->with('status', $e->getMessage());
-        }
-    }
-
-    public function showFinalMngt()
-    {
-        $incoming = $this->request->getPost('class_section_id')
-            ?? $this->request->getGet('class_section_id')
-            ?? session()->get('class_section_id');
-
-        $classSectionId = (int) ($incoming ?: 0);
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('status', 'Missing class section.');
-        }
-
-        $semester = $this->getTeacherSelectedSemester();
-        $schoolYear = $this->schoolYear;
-        try {
-            $result = $this->getSavedScores($classSectionId, $semester, $schoolYear);
-            $scoresLocked = $this->gradingLockModel->isLocked($classSectionId, $semester, $schoolYear);
-
-            return view('grading/final', [
-                'students'       => $result['students'],
-                'semester'       => $result['semester'],
-                'schoolYear'     => $result['schoolYear'],
-                'classSectionId' => $classSectionId,
-                'scoresLocked'   => $scoresLocked,
-            ]);
-        } catch (\Throwable $e) {
-            return redirect()->back()->with('status', $e->getMessage());
-        }
-    }
-
-    private function getSavedScores(int $classSectionId, string $semester, string $schoolYear): array
-    {
-        if ($classSectionId <= 0) {
-            throw new \InvalidArgumentException('Invalid class section id.');
-        }
-
-        session()->set('class_section_id', $classSectionId);
-
-        // Subquery: pick ONE final exam row per student (latest by id)
-        $latestFinalSub = $this->db->table('final_exam')
-            ->select('student_id, MAX(id) AS max_id')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->groupBy('student_id')
-            ->getCompiledSelect();
-
-        // Main query: roster + LEFT JOIN the single final exam row
-        $qb = $this->studentModel
-            ->select('
-            s.id AS student_id,
-            s.school_id,
-            s.firstname,
-            s.lastname,
-            fe.score
-        ')
-            ->from('students s')
-            ->join(
-                'student_class sc',
-                'sc.student_id = s.id
-             AND sc.class_section_id = ' . (int) $classSectionId . '
-             AND sc.school_year = ' . $this->db->escape($schoolYear),
-                'inner',
-                false
-            )
-            ->join('(' . $latestFinalSub . ') fl', 'fl.student_id = s.id', 'left', false)
-            ->join('final_exam fe', 'fe.id = fl.max_id', 'left')
-            ->orderBy('s.lastname', 'ASC')
-            ->orderBy('s.firstname', 'ASC');
-
-        $qb->distinct();
-        $rows = $qb->get()->getResultArray();
-
-        // Ensure one row per student
-        $unique = [];
-        foreach ($rows as $r) {
-            $unique[(int)$r['student_id']] = $r;
-        }
-        $students = array_values($unique);
-
-        return [
-            'students'   => $students,
-            'semester'   => $semester,
-            'schoolYear' => $schoolYear,
-        ];
-    }
-
-    private function getTeacherSelectedSemester(): string
-    {
-        helper('semester_selection_helper');
-        return selected_teacher_semester();
-    }
-}
diff --git a/app/Http/Controllers/old/FinancialController.php b/app/Http/Controllers/old/FinancialController.php
deleted file mode 100644
index 8b2323cc..00000000
--- a/app/Http/Controllers/old/FinancialController.php
+++ /dev/null
@@ -1,1349 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-use App\Controllers\BaseController;
-use App\Models\DiscountUsageModel;
-use App\Models\InvoiceModel;
-use App\Models\PaymentModel;
-use App\Models\RefundModel;
-use App\Models\ExpenseModel;
-use App\Models\ReimbursementModel;
-use App\Models\UserModel;
-
-require_once APPPATH . 'ThirdParty/fpdf/fpdf.php';
-use FPDF;
-
-class FinancialController extends BaseController
-{   
-    private function wantsJson(): bool
-    {
-        $accept = strtolower((string)($this->request->getHeaderLine('Accept') ?? ''));
-        return $this->request->isAJAX() || str_contains($accept, 'application/json');
-    }
-    
-public function financialReport()
-{
-    $invoiceModel        = new InvoiceModel();
-    $paymentModel        = new PaymentModel();
-    $refundModel         = new RefundModel();
-    $expenseModel        = new ExpenseModel();
-    $reimbursementModel  = new ReimbursementModel();
-    $discountModel       = new DiscountUsageModel();
-
-    $dateFrom   = $this->request->getGet('date_from');
-    $dateTo     = $this->request->getGet('date_to');
-    $schoolYear = $this->request->getGet('school_year');
-
-    // === Apply filters to models (invoice/refund/discount/expense/reimb) ===
-    if ($schoolYear) {
-        $invoiceModel->where('invoices.school_year', $schoolYear);
-        $refundModel->where('school_year', $schoolYear);
-        $discountModel->where('school_year', $schoolYear);
-        // If these tables have school_year columns:
-        $expenseModel->where('school_year', $schoolYear);
-        $reimbursementModel->where('school_year', $schoolYear);
-        // Payments are filtered separately below to ensure reuse across queries
-    }
-
-    // Apply date filters (support from-only and to-only) using domain-appropriate fields
-    $hasFrom = !empty($dateFrom);
-    $hasTo   = !empty($dateTo);
-    if ($hasFrom) {
-        // Invoices: prefer issue_date, fallback to created_at
-        $invoiceModel->where('DATE(COALESCE(invoices.issue_date, invoices.created_at)) >=', $dateFrom);
-        // Refunds: prefer refunded_at, fallback to created_at
-        $refundModel->where('DATE(COALESCE(refunded_at, created_at)) >=', $dateFrom);
-        // Discounts: prefer used_at, fallback to created_at
-        $discountModel->where('DATE(COALESCE(used_at, created_at)) >=', $dateFrom);
-        // Expenses & Reimbursements: created_at
-        $expenseModel->where('DATE(created_at) >=', $dateFrom);
-        $reimbursementModel->where('DATE(created_at) >=', $dateFrom);
-    }
-    if ($hasTo) {
-        $invoiceModel->where('DATE(COALESCE(invoices.issue_date, invoices.created_at)) <=', $dateTo);
-        $refundModel->where('DATE(COALESCE(refunded_at, created_at)) <=', $dateTo);
-        $discountModel->where('DATE(COALESCE(used_at, created_at)) <=', $dateTo);
-        $expenseModel->where('DATE(created_at) <=', $dateTo);
-        $reimbursementModel->where('DATE(created_at) <=', $dateTo);
-    }
-
-    // === Invoices ===
-    $invoices = $invoiceModel
-        ->select("invoices.*, CONCAT(users.firstname, ' ', users.lastname) AS parent_name")
-        ->join('users', 'users.id = invoices.parent_id')
-        ->findAll();
-
-    // Helper to build a fresh, filtered PaymentModel each time (so filters don't get lost between queries)
-    $buildPaymentModel = function () use ($schoolYear, $dateFrom, $dateTo) {
-        $pm = new PaymentModel();
-        if ($schoolYear) {
-            $pm->where('school_year', $schoolYear);
-        }
-        if (!empty($dateFrom)) {
-            $pm->where('DATE(payment_date) >=', $dateFrom);
-        }
-        if (!empty($dateTo)) {
-            $pm->where('DATE(payment_date) <=', $dateTo);
-        }
-        return $pm;
-    };
-    // Filter out void/failed/chargeback/etc. payments (align with balance logic elsewhere)
-    $applyPaymentFilters = function ($qb) {
-        try {
-            $db = \Config\Database::connect();
-            $hasStatus = $db->fieldExists('status', 'payments');
-            $hasVoid   = $db->fieldExists('is_void', 'payments');
-            $exclude   = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
-
-            if ($hasStatus) {
-                $qb->groupStart()
-                    ->whereNotIn('status', $exclude)
-                    ->orWhere('status IS NULL', null, false)
-                    ->groupEnd();
-            }
-            if ($hasVoid) {
-                $qb->groupStart()
-                    ->where('is_void', 0)
-                    ->orWhere('is_void IS NULL', null, false)
-                    ->groupEnd();
-            }
-        } catch (\Throwable $e) {
-            // If schema checks fail, fall back to unfiltered results.
-        }
-        return $qb;
-    };
-
-    // === Payments aggregated by invoice_id (for the "Paid" column) ===
-    $payments = $applyPaymentFilters($buildPaymentModel())
-        ->select('invoice_id, SUM(paid_amount) AS paid_amount')
-        ->where('invoice_id IS NOT NULL')
-        ->groupBy('invoice_id')
-        ->findAll();
-
-    // === Per-invoice breakdown by normalized method (cash/credit/check) ===
-    // Normalization rules:
-    //  - 'cash' => 'cash'
-    //  - 'check','cheque' => 'check'
-    //  - 'credit','card','credit card','debit','debit card','visa','mastercard' => 'credit'
-    //  - everything else => 'other' (not shown per-invoice, still included in grand totals)
-    $paymentBreakdownRows = $applyPaymentFilters($buildPaymentModel())
-        ->select("
-            invoice_id,
-            CASE
-                WHEN LOWER(TRIM(payment_method)) = 'cash' THEN 'cash'
-                WHEN LOWER(TRIM(payment_method)) IN ('check','cheque') THEN 'check'
-                WHEN LOWER(TRIM(payment_method)) IN ('credit','card','credit card','debit','debit card','visa','mastercard') THEN 'credit'
-                ELSE 'other'
-            END AS method,
-            SUM(paid_amount) AS amount
-        ")
-        ->where('invoice_id IS NOT NULL')
-        ->groupBy('invoice_id, method')
-        ->findAll();
-
-    // Map to [invoice_id => ['cash' => x, 'credit' => y, 'check' => z, 'other' => o]]
-    $paymentBreakdown = [];
-    foreach ($paymentBreakdownRows as $row) {
-        $iid = (int)($row['invoice_id'] ?? 0);
-        if ($iid <= 0) continue;
-        $method = (string)$row['method'];
-        $amount = (float)$row['amount'];
-        if (!isset($paymentBreakdown[$iid])) $paymentBreakdown[$iid] = [];
-        $paymentBreakdown[$iid][$method] = $amount;
-    }
-
-    // === Overall totals by method + grand total ===
-    $paymentTotalsRow = $applyPaymentFilters($buildPaymentModel())
-        ->select("
-            SUM(paid_amount) AS total_all,
-            SUM(CASE WHEN LOWER(TRIM(payment_method)) = 'cash' THEN paid_amount ELSE 0 END) AS total_cash,
-            SUM(CASE WHEN LOWER(TRIM(payment_method)) IN ('check','cheque') THEN paid_amount ELSE 0 END) AS total_check,
-            SUM(CASE WHEN LOWER(TRIM(payment_method)) IN ('credit','card','credit card','debit','debit card','visa','mastercard') THEN paid_amount ELSE 0 END) AS total_credit
-        ")
-        ->where('invoice_id IS NOT NULL')
-        ->first() ?? [];
-
-    $paymentTotals = [
-        'total_all'    => (float)($paymentTotalsRow['total_all']    ?? 0),
-        'total_cash'   => (float)($paymentTotalsRow['total_cash']   ?? 0),
-        'total_check'  => (float)($paymentTotalsRow['total_check']  ?? 0),
-        'total_credit' => (float)($paymentTotalsRow['total_credit'] ?? 0),
-    ];
-
-    // === Refunds (grouped) ===
-    $refunds = $refundModel
-        ->select('invoice_id, school_year, SUM(refund_paid_amount) AS total_refunded')
-        ->where('invoice_id IS NOT NULL')
-        ->whereIn('status', ['Partial', 'Paid'])
-        ->groupBy(['invoice_id', 'school_year'])
-        ->findAll();
-
-    // === Discounts (grouped) ===
-    $discounts = $discountModel
-        ->select('invoice_id, school_year, SUM(discount_amount) AS discount_amount')
-        ->where('invoice_id IS NOT NULL')
-        ->groupBy(['invoice_id', 'school_year'])
-        ->get()
-        ->getResultArray();
-
-    // === Expenses ===
-    $expenses = $expenseModel
-        ->select('category, SUM(amount) AS total_amount')
-        ->groupBy('category')
-        ->findAll();
-
-    // === Reimbursements ===
-    $reimbursements = $reimbursementModel
-        ->select('status, SUM(amount) AS total_amount')
-        ->groupBy('status')
-        ->findAll();
-
-    // --- School year options (for detailed view & JSON) ---
-    $schoolYears = [];
-    try {
-        $db = \Config\Database::connect();
-        $rows = $db->table('invoices')
-            ->select('DISTINCT school_year', false)
-            ->where('school_year IS NOT NULL', null, false)
-            ->orderBy('school_year', 'DESC')
-            ->get()->getResultArray();
-        foreach ($rows as $r) {
-            $val = (string)($r['school_year'] ?? '');
-            if ($val !== '' && !in_array($val, $schoolYears, true)) $schoolYears[] = $val;
-        }
-    } catch (\Throwable $e) {}
-    if (empty($schoolYears) && !empty($schoolYear)) {
-        $schoolYears[] = (string)$schoolYear;
-    }
-    
-    // JSON API support
-    if ($this->wantsJson() || strtolower((string)($this->request->getGet('format') ?? '')) === 'json') {
-        return $this->response->setJSON([
-            'ok'               => true,
-            'selectedYear'     => $schoolYear,
-            'dateFrom'         => $dateFrom,
-            'dateTo'           => $dateTo,
-            'schoolYears'      => $schoolYears,
-            'invoices'         => $invoices,
-            'payments'         => $payments,
-            'paymentBreakdown' => $paymentBreakdown,
-            'paymentTotals'    => $paymentTotals,
-            'refunds'          => $refunds,
-            'expenses'         => $expenses,
-            'reimbursements'   => $reimbursements,
-            'discounts'        => $discounts,
-            'csrf_token'       => csrf_token(),
-            'csrf_hash'        => csrf_hash(),
-        ]);
-    }
-
-    return view('payment/financial_report', [
-        'invoices'         => $invoices,
-        'payments'         => $payments,           // for Paid column
-        'paymentBreakdown' => $paymentBreakdown,   // per-invoice Cash/Credit/Check
-        'paymentTotals'    => $paymentTotals,      // summary totals + grand total
-        'refunds'          => $refunds,
-        'expenses'         => $expenses,
-        'reimbursements'   => $reimbursements,
-        'discounts'        => $discounts,
-        'selectedYear'     => $schoolYear,
-        'schoolYears'      => $schoolYears,
-        'dateFrom'         => $dateFrom,
-        'dateTo'           => $dateTo,
-    ]);
-}
-
-
-    public function financialReportSummary()
-    {
-        $dateFrom   = $this->request->getGet('date_from');
-        $dateTo     = $this->request->getGet('date_to');
-        $schoolYear = $this->request->getGet('school_year');
-
-        $data = $this->getFinancialSummary($dateFrom, $dateTo, $schoolYear);
-
-        // Build school year options from invoices table (fallback to configured year)
-        $schoolYears = [];
-        try {
-            $db = \Config\Database::connect();
-            $rows = $db->table('invoices')
-                ->select('DISTINCT school_year', false)
-                ->where('school_year IS NOT NULL', null, false)
-                ->orderBy('school_year', 'DESC')
-                ->get()->getResultArray();
-            foreach ($rows as $r) {
-                $val = (string)($r['school_year'] ?? '');
-                if ($val !== '' && !in_array($val, $schoolYears, true)) $schoolYears[] = $val;
-            }
-        } catch (\Throwable $e) {}
-        if (empty($schoolYears) && !empty($data['schoolYear'])) {
-            $schoolYears[] = (string)$data['schoolYear'];
-        }
-        $data['schoolYears'] = $schoolYears;
-        if ($this->wantsJson() || strtolower((string)($this->request->getGet('format') ?? '')) === 'json') {
-            return $this->response->setJSON(['ok' => true] + $data + [
-                'csrf_token' => csrf_token(),
-                'csrf_hash'  => csrf_hash(),
-            ]);
-        }
-        return view('payment/financial_report_summary', $data);
-    }
-
-    public function financialReportData()
-    {
-        $this->response->setHeader('Accept', 'application/json');
-        return $this->financialReport();
-    }
-
-    public function financialReportSummaryData()
-    {
-        $this->response->setHeader('Accept', 'application/json');
-        return $this->financialReportSummary();
-    }
-
-        public function downloadCsv()
-        {
-
-            $invoiceModel       = new InvoiceModel();
-            $refundModel        = new RefundModel();
-            $discountModel      = new DiscountUsageModel();
-            $expenseModel       = new ExpenseModel();
-            $reimbursementModel = new ReimbursementModel();
-
-        $dateFrom   = $this->request->getGet('date_from');
-        $dateTo     = $this->request->getGet('date_to');
-        $schoolYear = $this->request->getGet('school_year');
-
-        // Invoices with filters (school year + date range on issue_date/created_at)
-        $invBuilder = $invoiceModel
-            ->select("invoices.*, CONCAT(users.firstname, ' ', users.lastname) AS parent_name")
-            ->join('users', 'users.id = invoices.parent_id');
-        if (!empty($schoolYear)) {
-            $invBuilder->where('invoices.school_year', $schoolYear);
-        }
-        if (!empty($dateFrom)) {
-            $invBuilder->where('DATE(COALESCE(invoices.issue_date, invoices.created_at)) >=', $dateFrom);
-        }
-        if (!empty($dateTo)) {
-            $invBuilder->where('DATE(COALESCE(invoices.issue_date, invoices.created_at)) <=', $dateTo);
-        }
-        $invoices = $invBuilder->findAll();
-
-        $hasFrom = !empty($dateFrom);
-        $hasTo   = !empty($dateTo);
-
-        $buildPaymentModel = function () use ($schoolYear, $dateFrom, $dateTo) {
-            $pm = new PaymentModel();
-            if ($schoolYear) {
-                $pm->where('school_year', $schoolYear);
-            }
-            if (!empty($dateFrom)) {
-                $pm->where('DATE(payment_date) >=', $dateFrom);
-            }
-            if (!empty($dateTo)) {
-                $pm->where('DATE(payment_date) <=', $dateTo);
-            }
-            return $pm;
-        };
-        $applyPaymentFilters = function ($qb) {
-            try {
-                $db = \Config\Database::connect();
-                $hasStatus = $db->fieldExists('status', 'payments');
-                $hasVoid   = $db->fieldExists('is_void', 'payments');
-                $exclude   = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
-                if ($hasStatus) {
-                    $qb->groupStart()
-                        ->whereNotIn('status', $exclude)
-                        ->orWhere('status IS NULL', null, false)
-                        ->groupEnd();
-                }
-                if ($hasVoid) {
-                    $qb->groupStart()
-                        ->where('is_void', 0)
-                        ->orWhere('is_void IS NULL', null, false)
-                        ->groupEnd();
-                }
-            } catch (\Throwable $e) {
-            }
-            return $qb;
-        };
-
-        $payments = $applyPaymentFilters($buildPaymentModel())
-            ->select('invoice_id, SUM(paid_amount) AS paid_amount')
-            ->where('invoice_id IS NOT NULL')
-            ->groupBy('invoice_id')
-            ->findAll();
-
-        $paymentsMap = [];
-        foreach ($payments as $payment) {
-            $paymentsMap[(int)($payment['invoice_id'] ?? 0)] = (float)($payment['paid_amount'] ?? 0);
-        }
-
-        $paymentBreakdownRows = $applyPaymentFilters($buildPaymentModel())
-            ->select("
-                invoice_id,
-                CASE
-                    WHEN LOWER(TRIM(payment_method)) = 'cash' THEN 'cash'
-                    WHEN LOWER(TRIM(payment_method)) IN ('check','cheque') THEN 'check'
-                    WHEN LOWER(TRIM(payment_method)) IN ('credit','card','credit card','debit','debit card','visa','mastercard') THEN 'credit'
-                    ELSE 'other'
-                END AS method,
-                SUM(paid_amount) AS amount
-            ")
-            ->where('invoice_id IS NOT NULL')
-            ->groupBy('invoice_id, method')
-            ->findAll();
-
-        $paymentBreakdown = [];
-        foreach ($paymentBreakdownRows as $row) {
-            $iid = (int)($row['invoice_id'] ?? 0);
-            if ($iid <= 0) continue;
-            $method = (string)$row['method'];
-            $amount = (float)($row['amount'] ?? 0);
-            if (!isset($paymentBreakdown[$iid])) $paymentBreakdown[$iid] = [];
-            $paymentBreakdown[$iid][$method] = $amount;
-        }
-
-        // Expenses summary with filters
-        $expBuilder = $expenseModel
-            ->select('category, SUM(amount) AS total_amount');
-        if (!empty($schoolYear)) {
-            $expBuilder->where('school_year', $schoolYear);
-        }
-        if (!empty($dateFrom)) {
-            $expBuilder->where('DATE(created_at) >=', $dateFrom);
-        }
-        if (!empty($dateTo)) {
-            $expBuilder->where('DATE(created_at) <=', $dateTo);
-        }
-        $expenses = $expBuilder->groupBy('category')->findAll();
-
-        // Reimbursements summary with filters
-        $reimbBuilder = $reimbursementModel
-            ->select('status, SUM(amount) AS total_amount');
-        if (!empty($schoolYear)) {
-            $reimbBuilder->where('school_year', $schoolYear);
-        }
-        if (!empty($dateFrom)) {
-            $reimbBuilder->where('DATE(created_at) >=', $dateFrom);
-        }
-        if (!empty($dateTo)) {
-            $reimbBuilder->where('DATE(created_at) <=', $dateTo);
-        }
-        $reimbursements = $reimbBuilder->groupBy('status')->findAll();
-
-        // Refunds (grouped)
-        if (!empty($schoolYear)) {
-            $refundModel->where('school_year', $schoolYear);
-        }
-        if ($hasFrom) {
-            $refundModel->where('DATE(COALESCE(refunded_at, created_at)) >=', $dateFrom);
-        }
-        if ($hasTo) {
-            $refundModel->where('DATE(COALESCE(refunded_at, created_at)) <=', $dateTo);
-        }
-        $refundsData = $refundModel
-            ->select('invoice_id, SUM(refund_paid_amount) AS total_refunded')
-            ->where('invoice_id IS NOT NULL')
-            ->whereIn('status', ['Partial', 'Paid'])
-            ->groupBy('invoice_id')
-            ->findAll();
-        $refunds = [];
-        foreach ($refundsData as $refund) {
-            $refunds[$refund['invoice_id']] = $refund['total_refunded'];
-        }
-
-        $discountBuilder = $discountModel;
-        if (!empty($schoolYear)) {
-            $discountBuilder->where('school_year', $schoolYear);
-        }
-        if ($hasFrom) {
-            $discountBuilder->where('DATE(COALESCE(used_at, created_at)) >=', $dateFrom);
-        }
-        if ($hasTo) {
-            $discountBuilder->where('DATE(COALESCE(used_at, created_at)) <=', $dateTo);
-        }
-        $discountsData = $discountBuilder
-            ->select('invoice_id, SUM(discount_amount) AS discount_amount')
-            ->where('invoice_id IS NOT NULL')
-            ->groupBy('invoice_id')
-            ->get()
-            ->getResultArray();
-
-        $discounts = [];
-        foreach ($discountsData as $disc) {
-            $discounts[$disc['invoice_id']] = $disc['discount_amount'];
-        }
-
-        $filename = 'financial_report_' . date('Ymd_His') . '.csv';
-
-        header('Content-Type: text/csv');
-        header('Content-Disposition: attachment; filename="' . $filename . '"');
-
-        $out = fopen('php://output', 'w');
-
-        // Invoices section
-        fputcsv($out, ['Invoice #', 'Parent', 'School Year', 'Total', 'Paid', 'Cash', 'Credit', 'Check', 'Balance', 'Refund', 'Discount', 'Status']);
-        $sumTotal = 0.0;
-        $sumPaid = 0.0;
-        $sumCash = 0.0;
-        $sumCredit = 0.0;
-        $sumCheck = 0.0;
-        $sumBalance = 0.0;
-        $sumRefund = 0.0;
-        $sumDiscount = 0.0;
-        foreach ($invoices as $inv) {
-            $invoiceId = (int)($inv['id'] ?? 0);
-            $paid      = (float)($paymentsMap[$invoiceId] ?? 0);
-            $bd        = $paymentBreakdown[$invoiceId] ?? [];
-            $cash      = (float)($bd['cash']   ?? 0);
-            $credit    = (float)($bd['credit'] ?? 0);
-            $check     = (float)($bd['check']  ?? 0);
-            $refunded  = (float)($refunds[$invoiceId] ?? 0);
-            $discount  = (float)($discounts[$invoiceId] ?? 0);
-            $total     = (float)($inv['total_amount'] ?? 0);
-            $balance   = $total - $paid - $discount - $refunded;
-            if ($balance < 0) $balance = 0.0;
-            $status    = ($balance === 0.0) ? 'Paid' : 'Unpaid';
-
-            fputcsv($out, [
-                $inv['invoice_number'],
-                $inv['parent_name'] ?? '',
-                $inv['school_year'],
-                $total,
-                $paid,
-                $cash,
-                $credit,
-                $check,
-                $balance,
-                $refunded,
-                $discount,
-                $status,
-            ]);
-
-            $sumTotal += $total;
-            $sumPaid += $paid;
-            $sumCash += $cash;
-            $sumCredit += $credit;
-            $sumCheck += $check;
-            $sumBalance += $balance;
-            $sumRefund += $refunded;
-            $sumDiscount += $discount;
-        }
-        fputcsv($out, [
-            'TOTALS',
-            '',
-            '',
-            $sumTotal,
-            $sumPaid,
-            $sumCash,
-            $sumCredit,
-            $sumCheck,
-            $sumBalance,
-            $sumRefund,
-            $sumDiscount,
-            '',
-        ]);
-
-        // Expenses section
-        fputcsv($out, []); // blank line
-        fputcsv($out, ['Expenses Summary']);
-        fputcsv($out, ['Category', 'Total Amount']);
-        foreach ($expenses as $exp) {
-            fputcsv($out, [
-                $exp['category'],
-                $exp['total_amount']
-            ]);
-        }
-
-        // Reimbursements section
-        fputcsv($out, []); // blank line
-        fputcsv($out, ['Reimbursements Summary']);
-        fputcsv($out, ['Status', 'Total Amount']);
-        foreach ($reimbursements as $r) {
-            fputcsv($out, [
-                $r['status'],
-                $r['total_amount']
-            ]);
-        }
-
-        fclose($out);
-        exit;
-    }
-
-    public function downloadFinancialReport()
-    {
-        helper('filesystem');
-
-        $dateFrom   = $this->request->getGet('date_from');
-        $dateTo     = $this->request->getGet('date_to');
-        $schoolYear = $this->request->getGet('school_year');
-        $data = $this->getFinancialSummary($dateFrom, $dateTo, $schoolYear);
-
-        // === Generate charts ===
-        $this->generateBarChart($data);
-        $this->generatePieChart($data);
-
-        $pdf = new \FPDF();
-        $pdf->AddPage();
-        $pdf->SetFont('Arial', 'B', 16);
-        $pdf->Cell(0, 10, 'Financial Report for School Year: ' . $data['schoolYear'], 0, 1, 'C');
-
-        $pdf->Ln(10);
-        $pdf->SetFont('Arial', 'B', 12);
-        $pdf->Cell(130, 10, 'Description', 1);
-        $pdf->Cell(60, 10, 'Amount (USD)', 1);
-        $pdf->Ln();
-
-        $rows = [
-            'Total Charges' => $data['totalCharges'],
-            'Total Extra Charges' => $data['totalExtraCharges'] ?? 0,
-            'Total Discounts' => $data['totalDiscounts'],
-            'Total Refunds' => $data['totalRefunds'],
-            'Total Expenses' => $data['totalExpenses'],
-            'Total Reimbursements' => $data['totalReimbursements'],
-            'Donation to School (Masjid/Donation reimbursements)' => $data['donationToSchool'] ?? 0,
-            'Net Amount (Earned Income)' => $data['netAmount'],
-            'Amount Collected (Paid)' => $data['amountCollected'],
-            'Amount Unpaid (Outstanding)' => $data['totalUnpaid'],
-        ];
-
-        $pdf->SetFont('Arial', '', 11);
-        foreach ($rows as $label => $amount) {
-            $pdf->Cell(130, 10, $label, 1);
-            $pdf->Cell(60, 10, '$' . number_format($amount, 2), 1);
-            $pdf->Ln();
-        }
-
-        // === Add Bar Chart ===
-        $barChart = WRITEPATH . 'reports/bar_chart.png';
-        if (file_exists($barChart)) {
-            $pdf->Ln(10);
-            $pdf->SetFont('Arial', 'B', 12);
-            $pdf->Cell(0, 10, 'Summary Graph', 0, 1);
-            $pdf->Image($barChart, null, null, 180);
-        }
-
-        // === Add Pie Chart ===
-        $pieChart = WRITEPATH . 'reports/pie_chart.png';
-        if (file_exists($pieChart)) {
-            $pdf->Ln(10);
-            $pdf->SetFont('Arial', 'B', 12);
-            $pdf->Cell(0, 10, 'Expense Breakdown', 0, 1);
-            $pdf->Image($pieChart, null, null, 120);
-        }
-
-        // Output file
-        $pdf->Output('D', 'Financial_Report_' . $data['schoolYear'] . '.pdf');
-        exit;
-    }
-
-    private function generateBarChart(array $data)
-    {
-        $chartData = [
-            'type' => 'bar',
-            'data' => [
-                'labels' => ['Charges', 'Paid', 'Unpaid', 'Discounts', 'Refunds', 'Expenses', 'Reimbursements', 'Net'],
-                'datasets' => [[
-                    'label' => 'Amount (USD)',
-                    'data' => [
-                        $data['totalCharges'],
-                        $data['amountCollected'],
-                        $data['totalUnpaid'],
-                        $data['totalDiscounts'],
-                        $data['totalRefunds'],
-                        $data['totalExpenses'],
-                        $data['totalReimbursements'],
-                        $data['netAmount'],
-                    ],
-                    'backgroundColor' => 'rgba(54, 162, 235, 0.6)',
-                ]]
-            ]
-        ];
-
-        $url = 'https://quickchart.io/chart?c=' . urlencode(json_encode($chartData));
-        file_put_contents(WRITEPATH . 'reports/bar_chart.png', file_get_contents($url));
-    }
-
-    private function generatePieChart(array $data)
-    {
-        $chartData = [
-            'type' => 'pie',
-            'data' => [
-                'labels' => ['Expenses', 'Reimbursements'],
-                'datasets' => [[
-                    'data' => [
-                        $data['totalExpenses'],
-                        $data['totalReimbursements'],
-                    ],
-                    'backgroundColor' => ['#e74c3c', '#8e44ad']
-                ]]
-            ]
-        ];
-
-        $url = 'https://quickchart.io/chart?c=' . urlencode(json_encode($chartData));
-        file_put_contents(WRITEPATH . 'reports/pie_chart.png', file_get_contents($url));
-    }
-
-    private function getFinancialSummary(?string $dateFrom = null, ?string $dateTo = null, ?string $schoolYear = null): array
-    {
-        $invoiceModel = new \App\Models\InvoiceModel();
-        $paymentModel = new \App\Models\PaymentModel();
-        $refundModel = new \App\Models\RefundModel();
-        $expenseModel = new \App\Models\ExpenseModel();
-        $reimbursementModel = new \App\Models\ReimbursementModel();
-        $discountModel = new \App\Models\DiscountUsageModel();
-        $configModel = new \App\Models\ConfigurationModel();
-        $additionalModel = new \App\Models\AdditionalChargeModel();
-
-        // Allow override via parameter; fallback to configured year
-        $schoolYear = $schoolYear ?: $configModel->getConfig('school_year');
-        $derivedDateFrom = null;
-        $derivedDateTo   = null;
-        if (!empty($schoolYear) && empty($dateFrom) && empty($dateTo)) {
-            if (preg_match('/^(\\d{4})[^\\d]?(\\d{4})$/', $schoolYear, $m)) {
-                $derivedDateFrom = $m[1] . '-01-01';
-                $derivedDateTo   = $m[2] . '-12-31';
-            }
-        }
-
-        $db = \Config\Database::connect();
-
-        // === Invoices: Total Charges ===
-        $invoiceBuilder = $invoiceModel->where('school_year', $schoolYear);
-        $invoiceDateFrom = $dateFrom ?: $derivedDateFrom;
-        $invoiceDateTo   = $dateTo   ?: $derivedDateTo;
-        if (!empty($invoiceDateFrom)) {
-            $invoiceBuilder->where('DATE(COALESCE(invoices.issue_date, invoices.created_at)) >=', $invoiceDateFrom);
-        }
-        if (!empty($invoiceDateTo)) {
-            $invoiceBuilder->where('DATE(COALESCE(invoices.issue_date, invoices.created_at)) <=', $invoiceDateTo);
-        }
-        $invoices = $invoiceBuilder->findAll();
-        $totalCharges = array_sum(array_column($invoices, 'total_amount'));
-        $invoiceIds = array_values(array_unique(array_filter(array_map(static function ($inv) {
-            $id = (int)($inv['id'] ?? 0);
-            return $id > 0 ? $id : null;
-        }, $invoices))));
-
-        // === Additional Charges ===
-        $hasExplicitDates = !empty($dateFrom) || !empty($dateTo);
-        $sumExpr = "COALESCE(SUM(ac.amount), 0) AS amount";
-
-        $acAllBuilder = $db->table('additional_charges ac')
-            ->select($sumExpr, false)
-            ->where('ac.school_year', $schoolYear)
-            ->where('ac.status !=', 'void');
-        if ($hasExplicitDates) {
-            if (!empty($dateFrom)) $acAllBuilder->where('DATE(ac.due_date) >=', $dateFrom);
-            if (!empty($dateTo)) $acAllBuilder->where('DATE(ac.due_date) <=', $dateTo);
-        }
-        $acAllRow = $acAllBuilder->get()->getRowArray();
-        $totalExtraCharges = isset($acAllRow['amount']) ? (float) $acAllRow['amount'] : 0.00;
-
-        // Extra charges not reflected in invoice totals (unapplied or missing invoice_id)
-        $extraByParent = [];
-        $extraChargesUnapplied = 0.0;
-        $acExtraBuilder = $db->table('additional_charges ac')
-            ->select('ac.parent_id, ' . $sumExpr, false)
-            ->where('ac.school_year', $schoolYear)
-            ->where('ac.status !=', 'void')
-            ->groupStart()
-                ->where('ac.invoice_id IS NULL', null, false)
-                ->orWhere('ac.invoice_id', 0)
-                ->orWhere('ac.status !=', 'applied')
-            ->groupEnd()
-            ->groupBy('ac.parent_id');
-        if ($hasExplicitDates) {
-            if (!empty($dateFrom)) $acExtraBuilder->where('DATE(ac.due_date) >=', $dateFrom);
-            if (!empty($dateTo)) $acExtraBuilder->where('DATE(ac.due_date) <=', $dateTo);
-        }
-        $acExtraRows = $acExtraBuilder->get()->getResultArray();
-        foreach ($acExtraRows as $row) {
-            $pid = (int)($row['parent_id'] ?? 0);
-            if ($pid <= 0) continue;
-            $amt = (float)($row['amount'] ?? 0);
-            if (abs($amt) < 0.00001) continue;
-            $extraByParent[$pid] = $amt;
-            $extraChargesUnapplied += $amt;
-        }
-
-        $totalCharges += $extraChargesUnapplied;
-
-        // === Payments: Total Paid ===
-        $paymentBuilder = $paymentModel->where('school_year', $schoolYear);
-        if (!empty($invoiceDateFrom)) {
-            $paymentBuilder->where('DATE(payment_date) >=', $invoiceDateFrom);
-        }
-        if (!empty($invoiceDateTo)) {
-            $paymentBuilder->where('DATE(payment_date) <=', $invoiceDateTo);
-        }
-        $payHasStatus = $db->fieldExists('status', 'payments');
-        $payHasVoid   = $db->fieldExists('is_void', 'payments');
-        if ($payHasStatus) {
-            $paymentBuilder->groupStart()
-                ->whereNotIn('status', ['void','voided','refunded','failed','chargeback','declined','reversed','canceled','cancelled'])
-                ->orWhere('status IS NULL', null, false)
-                ->groupEnd();
-        }
-        if ($payHasVoid) {
-            $paymentBuilder->groupStart()
-                ->where('is_void', 0)
-                ->orWhere('is_void IS NULL', null, false)
-                ->groupEnd();
-        }
-        $paymentResult = $paymentBuilder->selectSum('paid_amount')->get()->getRowArray();
-        $totalPaid = isset($paymentResult['paid_amount']) ? (float) $paymentResult['paid_amount'] : 0.00;
-
-        // === Per-invoice paid/discount/refund totals for outstanding balance ===
-        $paidByInvoice = [];
-        $discountByInvoice = [];
-        $refundByInvoice = [];
-        if (!empty($invoiceIds)) {
-            $paidRows = $db->table('payments')
-                ->select('invoice_id, COALESCE(SUM(paid_amount),0) AS total_paid')
-                ->whereIn('invoice_id', $invoiceIds);
-            if (!empty($schoolYear)) {
-                $paidRows->where('school_year', $schoolYear);
-            }
-            if (!empty($invoiceDateFrom)) {
-                $paidRows->where('DATE(payment_date) >=', $invoiceDateFrom);
-            }
-            if (!empty($invoiceDateTo)) {
-                $paidRows->where('DATE(payment_date) <=', $invoiceDateTo);
-            }
-            if ($payHasStatus) {
-                $paidRows->groupStart()
-                    ->whereNotIn('status', ['void','voided','refunded','failed','chargeback','declined','reversed','canceled','cancelled'])
-                    ->orWhere('status IS NULL', null, false)
-                    ->groupEnd();
-            }
-            if ($payHasVoid) {
-                $paidRows->groupStart()
-                    ->where('is_void', 0)
-                    ->orWhere('is_void IS NULL', null, false)
-                    ->groupEnd();
-            }
-            $paidRows = $paidRows->groupBy('invoice_id')->get()->getResultArray();
-            foreach ($paidRows as $r) {
-                $iid = (int)($r['invoice_id'] ?? 0);
-                if ($iid > 0) $paidByInvoice[$iid] = (float)($r['total_paid'] ?? 0);
-            }
-
-            $discRows = $db->table('discount_usages')
-                ->select('invoice_id, COALESCE(SUM(discount_amount),0) AS total_disc')
-                ->whereIn('invoice_id', $invoiceIds);
-            if (!empty($dateFrom)) {
-                $discRows->where('DATE(COALESCE(used_at, created_at)) >=', $dateFrom);
-            }
-            if (!empty($dateTo)) {
-                $discRows->where('DATE(COALESCE(used_at, created_at)) <=', $dateTo);
-            }
-            $discRows = $discRows->groupBy('invoice_id')->get()->getResultArray();
-            foreach ($discRows as $r) {
-                $iid = (int)($r['invoice_id'] ?? 0);
-                if ($iid > 0) $discountByInvoice[$iid] = (float)($r['total_disc'] ?? 0);
-            }
-
-            $refRows = $db->table('refunds')
-                ->select('invoice_id, COALESCE(SUM(refund_paid_amount),0) AS total_refund')
-                ->whereIn('invoice_id', $invoiceIds)
-                ->whereIn('status', ['Partial', 'Paid']);
-            if (!empty($dateFrom)) {
-                $refRows->where('DATE(COALESCE(refunded_at, created_at)) >=', $dateFrom);
-            }
-            if (!empty($dateTo)) {
-                $refRows->where('DATE(COALESCE(refunded_at, created_at)) <=', $dateTo);
-            }
-            $refRows = $refRows->groupBy('invoice_id')->get()->getResultArray();
-            foreach ($refRows as $r) {
-                $iid = (int)($r['invoice_id'] ?? 0);
-                if ($iid > 0) $refundByInvoice[$iid] = (float)($r['total_refund'] ?? 0);
-            }
-        }
-
-        // === Expenses ===
-        $expenseBuilder = $expenseModel->where('school_year', $schoolYear);
-        if (!empty($invoiceDateFrom)) {
-            $expenseBuilder->where('DATE(created_at) >=', $invoiceDateFrom);
-        }
-        if (!empty($invoiceDateTo)) {
-            $expenseBuilder->where('DATE(created_at) <=', $invoiceDateTo);
-        }
-        $expenseResult = $expenseBuilder->selectSum('amount')->get()->getRowArray();
-        $totalExpenses = isset($expenseResult['amount']) ? (float) $expenseResult['amount'] : 0.00;
-
-        // === Reimbursements ===
-        // Reimbursements: include rows missing school_year by falling back to expense.school_year
-        $normalizeYear = static function (?string $year): string {
-            return preg_replace('/[^0-9]/', '', (string) $year);
-        };
-        $normalizedYear = $normalizeYear($schoolYear);
-
-        $reimbBuilder = $db->table('reimbursements r')
-            ->select('SUM(r.amount) AS amount')
-            ->join('expenses e', 'e.id = r.expense_id', 'left');
-        if (!empty($schoolYear)) {
-            $reimbBuilder
-                ->groupStart()
-                    ->groupStart()
-                        ->where('r.school_year', $schoolYear)
-                        ->orWhere(
-                            "REPLACE(REPLACE(REPLACE(REPLACE(r.school_year, ' ', ''), '-', ''), '/', ''), '\\\\', '')",
-                            $normalizedYear
-                        )
-                    ->groupEnd()
-                    ->orGroupStart()
-                        ->where('r.school_year IS NULL', null, false)
-                        ->groupStart()
-                            ->where('e.school_year', $schoolYear)
-                            ->orWhere(
-                                "REPLACE(REPLACE(REPLACE(REPLACE(e.school_year, ' ', ''), '-', ''), '/', ''), '\\\\', '')",
-                                $normalizedYear
-                            )
-                        ->groupEnd()
-                    ->groupEnd()
-                ->groupEnd();
-        }
-        if (!empty($invoiceDateFrom)) {
-            $reimbBuilder->where('DATE(COALESCE(r.created_at, e.created_at)) >=', $invoiceDateFrom);
-        }
-        if (!empty($invoiceDateTo)) {
-            $reimbBuilder->where('DATE(COALESCE(r.created_at, e.created_at)) <=', $invoiceDateTo);
-        }
-        $reimbursementResult = $reimbBuilder->get()->getRowArray();
-        $totalReimbursements = isset($reimbursementResult['amount']) ? (float) $reimbursementResult['amount'] : 0.00;
-
-        // Fallback: include closed batch items that never created a reimbursement record
-        $batchFallback = $db->table('reimbursement_batch_items bi')
-            ->select('SUM(e.amount) AS amount')
-            ->join('reimbursement_batches b', 'b.id = bi.batch_id', 'inner')
-            ->join('expenses e', 'e.id = bi.expense_id', 'inner')
-            ->join('reimbursements r', 'r.expense_id = e.id', 'left')
-            ->where('b.status', 'closed')
-            ->where('bi.unassigned_at IS NULL', null, false)
-            ->where('r.id IS NULL');
-        if (!empty($schoolYear)) {
-            $batchFallback
-                ->groupStart()
-                    ->where('e.school_year', $schoolYear)
-                    ->orWhere(
-                        "REPLACE(REPLACE(REPLACE(REPLACE(e.school_year, ' ', ''), '-', ''), '/', ''), '\\\\', '')",
-                        $normalizedYear
-                    )
-                ->groupEnd();
-        }
-        if (!empty($invoiceDateFrom)) {
-            $batchFallback->where('DATE(COALESCE(e.created_at, b.closed_at)) >=', $invoiceDateFrom);
-        }
-        if (!empty($invoiceDateTo)) {
-            $batchFallback->where('DATE(COALESCE(e.created_at, b.closed_at)) <=', $invoiceDateTo);
-        }
-        $batchFallbackRow = $batchFallback->get()->getRowArray();
-        $fallbackAmount = isset($batchFallbackRow['amount']) ? (float) $batchFallbackRow['amount'] : 0.00;
-        $totalReimbursements += $fallbackAmount;
-
-        // Donations line: donations captured as expenses (category=Donation) plus legacy Masjid/Donation reimbursements.
-        $donationExpense = 0.0;
-        $donationExpenseBuilder = (new ExpenseModel())
-            ->where('school_year', $schoolYear)
-            ->where('category', 'Donation');
-        if (!empty($invoiceDateFrom)) {
-            $donationExpenseBuilder->where('DATE(created_at) >=', $invoiceDateFrom);
-        }
-        if (!empty($invoiceDateTo)) {
-            $donationExpenseBuilder->where('DATE(created_at) <=', $invoiceDateTo);
-        }
-        $donationExpenseRow = $donationExpenseBuilder->selectSum('amount')->get()->getRowArray();
-        $donationExpense = isset($donationExpenseRow['amount']) ? (float) $donationExpenseRow['amount'] : 0.00;
-
-        $donationReimb = 0.0;
-        $specialRecipientIds = array_map('intval', array_keys(ReimbursementController::SPECIAL_RECIPIENTS));
-        if (!empty($specialRecipientIds)) {
-            $donationBuilder = $db->table('reimbursements r')
-                ->select('SUM(r.amount) AS amount')
-                ->join('expenses e', 'e.id = r.expense_id', 'left')
-                ->whereIn('r.reimbursed_to', $specialRecipientIds);
-            if (!empty($schoolYear)) {
-                $donationBuilder
-                    ->groupStart()
-                        ->groupStart()
-                            ->where('r.school_year', $schoolYear)
-                            ->orWhere(
-                                "REPLACE(REPLACE(REPLACE(REPLACE(r.school_year, ' ', ''), '-', ''), '/', ''), '\\\\', '')",
-                                $normalizedYear
-                            )
-                        ->groupEnd()
-                        ->orGroupStart()
-                            ->where('r.school_year IS NULL', null, false)
-                            ->groupStart()
-                                ->where('e.school_year', $schoolYear)
-                                ->orWhere(
-                                    "REPLACE(REPLACE(REPLACE(REPLACE(e.school_year, ' ', ''), '-', ''), '/', ''), '\\\\', '')",
-                                    $normalizedYear
-                                )
-                            ->groupEnd()
-                        ->groupEnd()
-                    ->groupEnd();
-            }
-            if (!empty($invoiceDateFrom)) {
-                $donationBuilder->where('DATE(COALESCE(r.created_at, e.created_at)) >=', $invoiceDateFrom);
-            }
-            if (!empty($invoiceDateTo)) {
-                $donationBuilder->where('DATE(COALESCE(r.created_at, e.created_at)) <=', $invoiceDateTo);
-            }
-            $donationRow = $donationBuilder->get()->getRowArray();
-            $donationReimb = isset($donationRow['amount']) ? (float) $donationRow['amount'] : 0.00;
-        }
-
-        $donationToSchool = $donationExpense + $donationReimb;
-        $totalReimbursements = max(0.0, $totalReimbursements - $donationReimb);
-
-        // === Refunds ===
-        $refundBuilder = $refundModel
-            ->where('school_year', $schoolYear)
-            ->whereIn('status', ['Partial', 'Paid'])
-            ->where('refund_paid_amount IS NOT NULL');
-
-        if (!empty($dateFrom)) {
-            $refundBuilder->where('DATE(COALESCE(refunded_at, created_at)) >=', $dateFrom);
-        }
-        if (!empty($dateTo)) {
-            $refundBuilder->where('DATE(COALESCE(refunded_at, created_at)) <=', $dateTo);
-        }
-
-        $refundResult = $refundBuilder
-            ->selectSum('refund_paid_amount')
-            ->get()
-            ->getRowArray();
-
-        $totalRefunds = isset($refundResult['refund_paid_amount']) ? (float) $refundResult['refund_paid_amount'] : 0.00;
-
-        // === Discounts ===
-        $discountBuilder = $discountModel
-            ->join('invoices', 'invoices.id = discount_usages.invoice_id')
-            ->where('invoices.school_year', $schoolYear);
-        if (!empty($dateFrom)) {
-            $discountBuilder->where('DATE(COALESCE(discount_usages.used_at, discount_usages.created_at)) >=', $dateFrom);
-        }
-        if (!empty($dateTo)) {
-            $discountBuilder->where('DATE(COALESCE(discount_usages.used_at, discount_usages.created_at)) <=', $dateTo);
-        }
-        $discountResult = $discountBuilder->selectSum('discount_amount')->get()->getRowArray();
-        $totalDiscounts = isset($discountResult['discount_amount']) ? (float) $discountResult['discount_amount'] : 0.00;
-
-        // === Net & Unpaid ===
-        // Sum positive per-parent balances (per-invoice balance + unapplied extra charges)
-        $parentBalances = [];
-        foreach ($invoices as $inv) {
-            $iid = (int)($inv['id'] ?? 0);
-            $pid = (int)($inv['parent_id'] ?? 0);
-            if ($iid <= 0 || $pid <= 0) continue;
-            $total = (float)($inv['total_amount'] ?? 0);
-            $paid  = (float)($paidByInvoice[$iid] ?? 0);
-            $disc  = (float)($discountByInvoice[$iid] ?? 0);
-            $ref   = (float)($refundByInvoice[$iid] ?? 0);
-            $bal   = max(0.0, round($total - $disc - $paid - $ref, 2));
-            if (!isset($parentBalances[$pid])) $parentBalances[$pid] = 0.0;
-            $parentBalances[$pid] += $bal;
-        }
-        foreach ($extraByParent as $pid => $extra) {
-            if (!isset($parentBalances[$pid])) $parentBalances[$pid] = 0.0;
-            $parentBalances[$pid] += (float)$extra;
-        }
-        $totalUnpaid = 0.0;
-        foreach ($parentBalances as $bal) {
-            if ($bal > 0.00001) $totalUnpaid += $bal;
-        }
-        $amountCollected = $totalPaid;
-        $netAmount = ($totalCharges - $totalDiscounts - $totalRefunds);
-
-        return [
-            'schoolYear' => $schoolYear,
-            'dateFrom' => $dateFrom,
-            'dateTo' => $dateTo,
-            'totalCharges' => $totalCharges,
-            'totalExtraCharges' => $totalExtraCharges,
-            'totalDiscounts' => $totalDiscounts,
-            'totalRefunds' => $totalRefunds,
-            'totalExpenses' => $totalExpenses,
-            'totalReimbursements' => $totalReimbursements,
-            'donationToSchool' => $donationToSchool,
-            'totalPaid' => $totalPaid,
-            'amountCollected' => $amountCollected,
-            'totalUnpaid' => $totalUnpaid,
-            'netAmount' => $netAmount,
-        ];
-    }
-
-
-    /**
-     * Management page: list parents with outstanding balances (> 0) for a school year.
-     * Supports HTML and JSON (Accept: application/json or format=json).
-     */
-    public function unpaidParents()
-    {
-        $configModel = new \App\Models\ConfigurationModel();
-        $schoolYear = trim((string)($this->request->getGet('school_year') ?? ''));
-        if ($schoolYear === '') {
-            $schoolYear = (string) ($configModel->getConfig('school_year') ?? date('Y'));
-        }
-
-        // Build school year options from invoices
-        $schoolYears = [];
-        try {
-            $db = \Config\Database::connect();
-            $rows = $db->table('invoices')
-                ->select('DISTINCT school_year', false)
-                ->where('school_year IS NOT NULL', null, false)
-                ->orderBy('school_year', 'DESC')
-                ->get()->getResultArray();
-            foreach ($rows as $r) {
-                $val = (string)($r['school_year'] ?? '');
-                if ($val !== '' && !in_array($val, $schoolYears, true)) $schoolYears[] = $val;
-            }
-        } catch (\Throwable $e) {}
-        if (empty($schoolYears) && !empty($schoolYear)) {
-            $schoolYears[] = (string)$schoolYear;
-        }
-
-        // Aggregate balances by parent for selected school year
-        // IMPORTANT: Compute current balance = total - payments - discounts - refundsPaid
-        // rather than trusting invoices.balance which may become stale.
-        $db = \Config\Database::connect();
-        $invRows = $db->table('invoices i')
-            ->select('i.id, i.parent_id, i.total_amount, u.firstname, u.lastname, u.email')
-            ->join('users u', 'u.id = i.parent_id', 'inner')
-            ->where('i.school_year', $schoolYear)
-            ->orderBy('i.parent_id', 'ASC')
-            ->orderBy('i.id', 'ASC')
-            ->get()->getResultArray();
-
-        // Group by parent and compute balances dynamically
-        $byParent = [];
-        $paymentsTbl = 'payments';
-        $hasStatus   = $db->fieldExists('status', $paymentsTbl);
-        $hasVoid     = $db->fieldExists('is_void', $paymentsTbl);
-
-        foreach ($invRows as $r) {
-            $iid = (int)($r['id'] ?? 0);
-            $pid = (int)($r['parent_id'] ?? 0);
-            if ($iid <= 0 || $pid <= 0) continue;
-
-            // Sum payments for this invoice (exclude void/failed if such columns exist)
-            $qb = $db->table('payments')->select('COALESCE(SUM(paid_amount),0) AS tot')->where('invoice_id', $iid);
-            if ($hasStatus) {
-                $qb->groupStart()
-                    ->whereNotIn('status', ['void','voided','refunded','failed','chargeback','declined','reversed','canceled','cancelled'])
-                    ->orWhere('status IS NULL', null, false)
-                   ->groupEnd();
-            }
-            if ($hasVoid) {
-                $qb->groupStart()
-                    ->where('is_void', 0)
-                    ->orWhere('is_void IS NULL', null, false)
-                   ->groupEnd();
-            }
-            $paidRow   = $qb->get()->getRowArray();
-            $paidSum   = (float)($paidRow['tot'] ?? 0);
-
-            // Sum discounts for this invoice
-            $discRow = $db->table('discount_usages')
-                ->select('COALESCE(SUM(discount_amount),0) AS tot')
-                ->where('invoice_id', $iid)
-                ->get()->getRowArray();
-            $discSum = (float)($discRow['tot'] ?? 0);
-
-            // Sum refunds PAID for this invoice (Partial/Paid only)
-            $refRow = $db->table('refunds')
-                ->select('COALESCE(SUM(refund_paid_amount),0) AS tot')
-                ->where('invoice_id', $iid)
-                ->whereIn('status', ['Partial','Paid'])
-                ->get()->getRowArray();
-            $refSum = (float)($refRow['tot'] ?? 0);
-
-            $total   = (float)($r['total_amount'] ?? 0);
-            $balance = max(0.0, round($total - $discSum - $paidSum - $refSum, 2));
-
-            if (!isset($byParent[$pid])) {
-                $byParent[$pid] = [
-                    'parent_id'     => $pid,
-                    'firstname'     => (string)($r['firstname'] ?? ''),
-                    'lastname'      => (string)($r['lastname'] ?? ''),
-                    'email'         => (string)($r['email'] ?? ''),
-                    'total_invoice' => 0.0,
-                    'total_balance' => 0.0,
-                    'total_paid'    => 0.0,
-                    'total_discount'=> 0.0,
-                ];
-            }
-            $byParent[$pid]['total_invoice'] += $total;
-            $byParent[$pid]['total_balance'] += $balance;
-            $byParent[$pid]['total_paid']    += $paidSum; // aggregated payments (for type classification)
-            $byParent[$pid]['total_discount']+= $discSum;
-        }
-
-        // Add extra charges not yet applied to invoices (or missing invoice_id)
-        $extraRows = $db->table('additional_charges ac')
-            ->select(
-                "ac.parent_id,
-                 u.firstname,
-                 u.lastname,
-                 u.email,
-                 COALESCE(SUM(ac.amount), 0) AS total_extra",
-                false
-            )
-            ->join('users u', 'u.id = ac.parent_id', 'left')
-            ->where('ac.school_year', $schoolYear)
-            ->where('ac.status !=', 'void')
-            ->groupStart()
-                ->where('ac.invoice_id IS NULL', null, false)
-                ->orWhere('ac.invoice_id', 0)
-                ->orWhere('ac.status !=', 'applied')
-            ->groupEnd()
-            ->groupBy('ac.parent_id')
-            ->get()
-            ->getResultArray();
-
-        foreach ($extraRows as $er) {
-            $pid = (int)($er['parent_id'] ?? 0);
-            if ($pid <= 0) continue;
-            $extra = (float)($er['total_extra'] ?? 0);
-            if (abs($extra) < 0.00001) continue;
-            if (!isset($byParent[$pid])) {
-                $byParent[$pid] = [
-                    'parent_id'     => $pid,
-                    'firstname'     => (string)($er['firstname'] ?? ''),
-                    'lastname'      => (string)($er['lastname'] ?? ''),
-                    'email'         => (string)($er['email'] ?? ''),
-                    'total_invoice' => 0.0,
-                    'total_balance' => 0.0,
-                    'total_paid'    => 0.0,
-                    'total_discount'=> 0.0,
-                ];
-            }
-            $byParent[$pid]['total_invoice'] += $extra;
-            $byParent[$pid]['total_balance'] += $extra;
-        }
-
-        // Reduce into rows list; only parents with positive balance
-        // Also compute remaining installments and suggested monthly amount
-        $rows = [];
-        // Installment end date from config (same source as manual pay UI)
-        $installmentEndRaw = (string) (new \App\Models\ConfigurationModel())->getConfig('installment_date');
-        $tzName = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-        $tzNY = new \DateTimeZone($tzName);
-        $todayNY = new \DateTimeImmutable('today', $tzNY);
-        $endDate = null;
-        if ($installmentEndRaw) {
-            try { $endDate = new \DateTimeImmutable($installmentEndRaw, $tzNY); } catch (\Throwable $e) { $endDate = null; }
-        }
-        $monthsUntil = function (?\DateTimeImmutable $end) use ($todayNY): int {
-            if (!$end) return 0;
-            $y = (int)$end->format('Y') - (int)$todayNY->format('Y');
-            $m = (int)$end->format('n') - (int)$todayNY->format('n');
-            $months = $y * 12 + $m;
-            if ((int)$end->format('j') > (int)$todayNY->format('j')) $months += 1;
-            return max(0, $months);
-        };
-
-        foreach ($byParent as $pid => $agg) {
-            $balance = (float)($agg['total_balance'] ?? 0);
-            if ($balance > 0.00001) {
-                $remMonths = $monthsUntil($endDate);
-                $remainingInstallments = max(1, $remMonths);
-                $instAmount = round($balance / $remainingInstallments, 2);
-
-                $rows[] = [
-                    'parent_id'     => $pid,
-                    'firstname'     => $agg['firstname'],
-                    'lastname'      => $agg['lastname'],
-                    'email'         => $agg['email'],
-                    'total_invoice' => (float)$agg['total_invoice'],
-                    'total_balance' => $balance,
-                    'total_discount'=> (float)($agg['total_discount'] ?? 0),
-                    'remaining_installments' => $remainingInstallments,
-                    'installment_amount'     => $instAmount,
-                ];
-            }
-        }
-
-        // Order by total_balance desc (to mimic previous builder ordering)
-        usort($rows, static function ($a, $b) {
-            return ($b['total_balance'] <=> $a['total_balance']);
-        });
-
-        // Compute a global next installment date (first day of next month, local time)
-        $tz   = new \DateTimeZone($tzName);
-        $now  = new \DateTime('now', $tz);
-        $nextInstallmentDt = (clone $now)->modify('first day of next month');
-        $nextInstallmentYmd = $nextInstallmentDt->format('Y-m-d');
-
-        // Determine whether each parent has any payments for this year (installment vs no_payment)
-        $parentIds = array_values(array_unique(array_map(static fn($r) => (int)($r['parent_id'] ?? 0), $rows)));
-        $hasPayments = [];
-        $paidTotals  = [];
-        $paymentCounts = [];
-        if (!empty($parentIds)) {
-            try {
-                $pRows = $db->table('payments')
-                    ->select('parent_id, SUM(paid_amount) AS total_paid, COUNT(*) AS payment_count')
-                    ->whereIn('parent_id', $parentIds)
-                    ->where('school_year', $schoolYear)
-                    ->groupBy('parent_id')
-                    ->get()->getResultArray();
-                foreach ($pRows as $pr) {
-                    $pid = (int)($pr['parent_id'] ?? 0);
-                    if ($pid > 0) {
-                        $hasPayments[$pid] = true;
-                        $paidTotals[$pid]  = (float)($pr['total_paid'] ?? 0);
-                        $paymentCounts[$pid] = (int)($pr['payment_count'] ?? 0);
-                    }
-                }
-            } catch (\Throwable $e) {
-                // ignore; default type will be 'no_payment'
-            }
-        }
-
-        $dataRows = array_map(function(array $r) use ($hasPayments, $paidTotals, $paymentCounts, $nextInstallmentYmd) {
-            $pid = (int)($r['parent_id'] ?? 0);
-            $name = trim((string)($r['firstname'] ?? '') . ' ' . (string)($r['lastname'] ?? ''));
-            return [
-                'parent_id'     => $pid,
-                'parent_name'   => $name,
-                'email'         => (string)($r['email'] ?? ''),
-                'total_invoice' => (float)($r['total_invoice'] ?? 0),
-                'total_balance' => (float)($r['total_balance'] ?? 0),
-                'total_discount'=> (float)($r['total_discount'] ?? 0),
-                'remaining_installments' => (int)($r['remaining_installments'] ?? 0),
-                'installment_amount'     => (float)($r['installment_amount'] ?? 0),
-                'type'          => isset($hasPayments[$pid]) ? 'installment' : 'no_payment',
-                'total_paid'    => isset($paidTotals[$pid]) ? (float)$paidTotals[$pid] : 0.0,
-                'payment_count' => isset($paymentCounts[$pid]) ? (int)$paymentCounts[$pid] : 0,
-                'has_installment'=> isset($hasPayments[$pid]) ? 1 : 0,
-                'next_installment' => $nextInstallmentYmd,
-            ];
-        }, $rows);
-
-        if ($this->wantsJson() || strtolower((string)($this->request->getGet('format') ?? '')) === 'json') {
-            return $this->response->setJSON([
-                'ok'          => true,
-                'school_year' => $schoolYear,
-                'schoolYears' => $schoolYears,
-                'results'     => $dataRows,
-                'csrf_token'  => csrf_token(),
-                'csrf_hash'   => csrf_hash(),
-            ]);
-        }
-
-        return view('payment/unpaid_parents', [
-            'school_year' => $schoolYear,
-            'schoolYears' => $schoolYears,
-            'rows'        => $dataRows,
-        ]);
-    }
-
-
-
-
-}
diff --git a/app/Http/Controllers/old/FlagController.php b/app/Http/Controllers/old/FlagController.php
deleted file mode 100644
index 6e6e7eff..00000000
--- a/app/Http/Controllers/old/FlagController.php
+++ /dev/null
@@ -1,568 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Models\CurrentFlagModel;
-use App\Models\FlagModel;
-use App\Models\StudentModel;
-use App\Models\ClassSectionModel;
-use App\Models\StudentClassModel;
-use App\Models\ConfigurationModel;
-
-use CodeIgniter\Controller;
-
-
-class FlagController extends Controller
-{
-    protected $userModel;
-    protected $db;
-
-    public function __construct()
-    {
-        $this->db = \Config\Database::connect();
-        //$this->userModel = new UserModel();
-        helper(['url', 'form']);
-    }
-
-    public function index()
-    {
-        $currentFlagModel = new CurrentFlagModel();
-        $classSectionModel = new ClassSectionModel();
-        $studentClassModel = new StudentClassModel();
-        $configModel = new ConfigurationModel();
-
-        // Format grades with id and name for passing to the view
-        $grades = [];
-
-        // Retrieve flags and class sections that currently have active students
-        $flags = $currentFlagModel->findAll();
-        $schoolYear = $configModel->getConfig('school_year');
-        $studentCounts = $studentClassModel->getStudentCountsBySection($schoolYear);
-        $classSections = [];
-
-        if (!empty($studentCounts)) {
-            $classSectionIdsWithStudents = array_keys($studentCounts);
-            $classSections = $classSectionModel
-                ->orderBy('class_section_name', 'ASC')
-                ->whereIn('class_section_id', $classSectionIdsWithStudents)
-                ->findAll();
-        }
-
-        foreach ($classSections as $section) {
-            $grades[] = [
-                'id' => $section['class_section_id'],
-                'name' => $section['class_section_name']
-            ];
-        }
-
-        // Map updater user IDs to display names for the view
-        $updaterIds = [];
-        foreach ($flags as $flag) {
-            foreach (['updated_by_open', 'updated_by_closed', 'updated_by_canceled'] as $key) {
-                if (!empty($flag[$key])) {
-                    $updaterIds[(int)$flag[$key]] = true;
-                }
-            }
-        }
-
-        $updaterMap = [];
-        if (!empty($updaterIds)) {
-            $rows = $this->db->table('users')
-                ->select('id, firstname, lastname')
-                ->whereIn('id', array_keys($updaterIds))
-                ->get()
-                ->getResultArray();
-
-            foreach ($rows as $row) {
-                $name = trim((string)($row['firstname'] ?? '') . ' ' . (string)($row['lastname'] ?? ''));
-                $updaterMap[(int)$row['id']] = $name !== '' ? $name : ('User #' . $row['id']);
-            }
-        }
-
-        foreach ($flags as &$flag) {
-            foreach (['updated_by_open', 'updated_by_closed', 'updated_by_canceled'] as $key) {
-                $id = (int)($flag[$key] ?? 0);
-                $flag[$key . '_name'] = $id > 0 ? ($updaterMap[$id] ?? null) : null;
-            }
-        }
-        unset($flag);
-
-        // Pass flags and formatted grades to the view
-        return view('flags/flags_management', [
-            'flags' => $flags,
-            'grades' => $grades // Now grades include both id and class_section_name
-        ]);
-    }
-
-    public function history()
-    {
-        $flagModel = new FlagModel();
-
-        $schoolYear = (string)($this->request->getGet('school_year') ?? '');
-        $semester = (string)($this->request->getGet('semester') ?? '');
-
-        $builder = $flagModel->orderBy('flag_datetime', 'DESC');
-        if ($schoolYear !== '') {
-            $builder->where('school_year', $schoolYear);
-        }
-        if ($semester !== '') {
-            $builder->where('semester', $semester);
-        }
-
-        return $this->response->setJSON([
-            'flags' => $builder->findAll(),
-        ]);
-    }
-
-    public function processedFlags()
-    {
-        $flagModel = new FlagModel();
-        $classSectionModel = new ClassSectionModel();
-
-        $schoolYear = (string)($this->request->getGet('school_year') ?? '');
-        $semester = (string)($this->request->getGet('semester') ?? '');
-
-        $builder = $flagModel->orderBy('flag_datetime', 'DESC');
-        if ($schoolYear !== '') {
-            $builder->where('school_year', $schoolYear);
-        }
-        if ($semester !== '') {
-            $builder->where('semester', $semester);
-        }
-
-        $flags = $builder->findAll();
-
-        $gradeIds = [];
-        foreach ($flags as $flag) {
-            $gradeValue = $flag['grade'] ?? '';
-            if (is_numeric($gradeValue)) {
-                $gradeIds[(int)$gradeValue] = true;
-            }
-        }
-
-        $gradeMap = [];
-        if (!empty($gradeIds)) {
-            $rows = $classSectionModel
-                ->select('class_section_id, class_section_name')
-                ->whereIn('class_section_id', array_keys($gradeIds))
-                ->findAll();
-
-            foreach ($rows as $row) {
-                $gradeMap[(int)$row['class_section_id']] = (string)($row['class_section_name'] ?? '');
-            }
-        }
-
-        // Map updater user IDs to display names for the view
-        $updaterIds = [];
-        foreach ($flags as $flag) {
-            foreach (['updated_by_open', 'updated_by_closed', 'updated_by_canceled'] as $key) {
-                if (!empty($flag[$key])) {
-                    $updaterIds[(int)$flag[$key]] = true;
-                }
-            }
-        }
-
-        $updaterMap = [];
-        if (!empty($updaterIds)) {
-            $rows = $this->db->table('users')
-                ->select('id, firstname, lastname')
-                ->whereIn('id', array_keys($updaterIds))
-                ->get()
-                ->getResultArray();
-
-            foreach ($rows as $row) {
-                $name = trim((string)($row['firstname'] ?? '') . ' ' . (string)($row['lastname'] ?? ''));
-                $updaterMap[(int)$row['id']] = $name !== '' ? $name : ('User #' . $row['id']);
-            }
-        }
-
-        foreach ($flags as &$flag) {
-            foreach (['updated_by_open', 'updated_by_closed', 'updated_by_canceled'] as $key) {
-                $id = (int)($flag[$key] ?? 0);
-                $flag[$key . '_name'] = $id > 0 ? ($updaterMap[$id] ?? null) : null;
-            }
-
-            $gradeValue = $flag['grade'] ?? '';
-            if (is_numeric($gradeValue)) {
-                $flag['grade'] = $gradeMap[(int)$gradeValue] ?? (string)$gradeValue;
-            }
-        }
-        unset($flag);
-
-        return view('flags/processed_flags', [
-            'flags' => $flags
-        ]);
-    }
-
-    public function incidentAnalysis()
-    {
-        $flagModel = new FlagModel();
-        $classSectionModel = new ClassSectionModel();
-
-        $schoolYear = (string)($this->request->getGet('school_year') ?? '');
-        $semester = (string)($this->request->getGet('semester') ?? '');
-
-        $builder = $flagModel->orderBy('flag_datetime', 'DESC');
-        if ($schoolYear !== '') {
-            $builder->where('school_year', $schoolYear);
-        }
-        if ($semester !== '') {
-            $builder->where('semester', $semester);
-        }
-
-        $flags = $builder->findAll();
-
-        $gradeIds = [];
-        foreach ($flags as $flag) {
-            $gradeValue = $flag['grade'] ?? '';
-            if (is_numeric($gradeValue)) {
-                $gradeIds[(int)$gradeValue] = true;
-            }
-        }
-
-        $gradeMap = [];
-        if (!empty($gradeIds)) {
-            $rows = $classSectionModel
-                ->select('class_section_id, class_section_name')
-                ->whereIn('class_section_id', array_keys($gradeIds))
-                ->findAll();
-
-            foreach ($rows as $row) {
-                $gradeMap[(int)$row['class_section_id']] = (string)($row['class_section_name'] ?? '');
-            }
-        }
-
-        $students = [];
-        foreach ($flags as $flag) {
-            $studentId = (string)($flag['student_id'] ?? '');
-            $studentName = (string)($flag['student_name'] ?? '');
-            $studentKey = $studentId !== '' ? 'id:' . $studentId : 'name:' . strtolower(trim($studentName));
-            $gradeValue = $flag['grade'] ?? '';
-            $gradeLabel = $gradeValue;
-            if (is_numeric($gradeValue)) {
-                $gradeLabel = $gradeMap[(int)$gradeValue] ?? (string)$gradeValue;
-            }
-
-            if (!isset($students[$studentKey])) {
-                $students[$studentKey] = [
-                    'student_id' => $studentId,
-                    'student_name' => $studentName,
-                    'grade' => (string)$gradeLabel,
-                    'total' => 0,
-                    'open' => 0,
-                    'closed' => 0,
-                    'canceled' => 0,
-                    'last_incident' => null,
-                    'logs' => [],
-                ];
-            }
-
-            $students[$studentKey]['total'] += 1;
-
-            $state = (string)($flag['flag_state'] ?? '');
-            if ($state === 'Open') {
-                $students[$studentKey]['open'] += 1;
-            } elseif ($state === 'Closed') {
-                $students[$studentKey]['closed'] += 1;
-            } elseif ($state === 'Canceled') {
-                $students[$studentKey]['canceled'] += 1;
-            }
-
-            if ($students[$studentKey]['last_incident'] === null) {
-                $students[$studentKey]['last_incident'] = $flag['flag_datetime'] ?? null;
-            }
-
-            $students[$studentKey]['logs'][] = [
-                'flag' => $flag['flag'] ?? '',
-                'flag_state' => $state,
-                'flag_datetime' => $flag['flag_datetime'] ?? null,
-                'open_description' => $flag['open_description'] ?? null,
-                'close_description' => $flag['close_description'] ?? null,
-                'cancel_description' => $flag['cancel_description'] ?? null,
-                'action_taken' => $flag['action_taken'] ?? null,
-            ];
-        }
-
-        $studentRows = array_values($students);
-        usort($studentRows, function ($a, $b) {
-            if ($a['total'] === $b['total']) {
-                return strcasecmp($a['student_name'], $b['student_name']);
-            }
-            return $b['total'] <=> $a['total'];
-        });
-
-        return view('flags/incident_analysis', [
-            'students' => $studentRows,
-            'schoolYear' => $schoolYear,
-            'semester' => $semester,
-        ]);
-    }
-
-    public function getStudentsByGrade($gradeId)
-    {
-        $studentClassModel = new StudentClassModel(); // Model for the student_class table
-        $studentModel = new StudentModel();           // Model for the students table
-
-        // Fetch student IDs for the selected grade
-        $studentIds = $studentClassModel
-            ->active()
-            ->where('student_class.class_section_id', $gradeId)
-            ->findColumn('student_id');
-
-        // If no student IDs are found, return an empty JSON array
-        if (empty($studentIds)) {
-            return $this->response->setJSON([]);
-        }
-
-        // Fetch student details from students table using the retrieved IDs
-        $students = $studentModel
-            ->whereIn('id', $studentIds)
-            ->where('is_active', 1)
-            ->findAll();
-
-        // Prepare data for JSON response with both ID and full name
-        $studentData = [];
-        foreach ($students as $student) {
-            $studentData[] = [
-                'id' => $student['id'], // Student ID
-                'name' => $student['firstname'] . ' ' . $student['lastname'] // Full name
-            ];
-        }
-
-        // Return JSON response with student ID and full name
-        return $this->response->setJSON($studentData);
-    }
-
-    public function addFlag()
-    {
-        $currentFlagModel = new CurrentFlagModel();
-        $studentModel = new StudentModel();
-        $configModel = new ConfigurationModel();
-
-        // Get the data from the form submission
-        $studentId = $this->request->getPost('student');
-        $flagType = $this->request->getPost('flag');
-        $description = $this->request->getPost('description');
-        $flagState = $this->request->getPost('flag_state');
-        $stateDescription = $this->request->getPost('state_description'); // Additional description for "Closed" or "Canceled"
-
-        // Retrieve student information from the database
-        $student = $studentModel->find($studentId);
-        if (!$student) {
-            session()->setFlashdata('error', 'Student not found.');
-            return $this->index();
-        }
-
-        // Get the user_id from the session for updated_by
-        $userId = session()->get('user_id');
-
-        // Get the semester and school year from configuration
-        $semester = $configModel->getConfig('semester');
-        $schoolYear = $configModel->getConfig('school_year');
-
-        // Set the current system date and time for flag_datetime
-        $currentDateTime = utc_now();
-
-        // Check if a flag of the same type already exists for this student
-        $existingFlag = $currentFlagModel->where('student_id', $studentId)
-            ->where('flag', $flagType)
-            ->first();
-
-        if ($existingFlag) {
-            // If the flag exists, update it based on the new state and description
-            $data = [
-                'flag_datetime'    => $currentDateTime,
-                'updated_by_open'  => $userId
-            ];
-
-            // Append the new description to the appropriate field based on flag state
-            if ($flagState === 'Closed') {
-                $data['flag_state'] = 'Closed';
-                $data['close_description'] = ($existingFlag['close_description'] ?? '') . PHP_EOL . $stateDescription;
-            } elseif ($flagState === 'Canceled') {
-                $data['flag_state'] = 'Canceled';
-                $data['cancel_description'] = ($existingFlag['cancel_description'] ?? '') . PHP_EOL . $stateDescription;
-            } else {
-                $data['open_description'] = $existingFlag['open_description'] . PHP_EOL . $description;
-            }
-
-            // Update the existing flag
-            $currentFlagModel->update($existingFlag['id'], $data);
-            session()->setFlashdata('success', 'Flag updated successfully!');
-        } else {
-            // If no existing flag is found, prepare the data for insertion
-            $data = [
-                'student_id'        => $student['id'],
-                'student_name'      => $student['firstname'] . ' ' . $student['lastname'],
-                'grade'             => $this->request->getPost('grade'),
-                'flag'              => $flagType,
-                'flag_datetime'     => $currentDateTime,
-                'flag_state'        => 'Open', // Set initial state to 'Open'
-                'updated_by_open'   => $userId,
-                'open_description'  => $description,
-                'semester'          => $semester,
-                'school_year'       => $schoolYear
-            ];
-
-            // Insert the new flag
-            if ($currentFlagModel->insert($data)) {
-                session()->setFlashdata('success', 'New incident added successfully!');
-            } else {
-                session()->setFlashdata('error', 'Failed to add new incident.');
-            }
-        }
-        // Redirect to the list view
-        return $this->index();
-    }
-
-    public function updateState($id)
-    {
-        log_message('debug', 'updateState method called for ID: ' . $id);
-        log_message('debug', 'Flag state: ' . $this->request->getPost('flag_state'));
-
-        $currentFlagModel = new CurrentFlagModel();
-
-        // Get the new flag state from the form
-        $newState = $this->request->getPost('flag_state');
-
-        if (!$newState) {
-            session()->setFlashdata('error', 'incident state not provided.');
-            return $this->index();
-        }
-
-        // Update the flag state in the database
-        if ($currentFlagModel->update($id, ['flag_state' => $newState])) {
-            session()->setFlashdata('success', 'Incident state updated successfully!');
-        } else {
-            $errors = $currentFlagModel->errors();
-            log_message('error', 'Failed to update incident state: ' . print_r($errors, true));
-            session()->setFlashdata('error', 'Failed to update incident state.');
-        }
-
-        // Redirect back to the flags list
-        return $this->index();
-    }
-
-    public function closeFlag($flagId)
-    {
-        // Log the whole session array
-        log_message('debug', json_encode(session()->get()));
-        $currentFlagModel = new CurrentFlagModel();
-        $userId = session()->get('user_id');
-
-        // Get the current flag data
-        $flagData = $currentFlagModel->find($flagId);
-
-        // Log and check if flag data is found
-        if (!$flagData) {
-            log_message('error', "incident with ID {$flagId} not found in database.");
-            session()->setFlashdata('error', 'Incident not found.');
-            return redirect()->back();
-        }
-
-        // Proceed only if flag is not closed
-        if ($flagData['flag_state'] !== 'Closed') {
-            // Retrieve 'close_description' from POST request
-            $closeDescription = $this->request->getPost('state_description');
-            $actionTaken = $this->request->getPost('action_taken');
-
-            // Debugging: Check if the close description is received
-            if (empty($closeDescription)) {
-                session()->setFlashdata('error', 'Close description is missing.');
-                return redirect()->back();
-            }
-
-            // Update the flag state to Closed
-            $currentFlagModel->update($flagId, [
-                'flag_state' => 'Closed',
-                'updated_by_closed' => $userId,
-                'close_description' => $closeDescription, // Use dynamic description from form
-                'action_taken' => $actionTaken
-            ]);
-
-            $flagData = $currentFlagModel->find($flagId);
-            return $this->moveToHistory($flagData);
-        } else {
-            session()->setFlashdata('error', 'Incident is already closed.');
-        }
-        return $this->index();
-    }
-
-    public function cancelFlag($flagId)
-    {
-        $currentFlagModel = new CurrentFlagModel();
-        $userId = session()->get('user_id');
-
-        // Retrieve 'cancel_description' from POST request
-        $cancelDescription = $this->request->getPost('state_description');
-        $actionTaken = $this->request->getPost('action_taken');
-
-        // Get the current flag data
-        $flagData = $currentFlagModel->find($flagId);
-
-        // Check if flag data is found
-        if (!$flagData) {
-            log_message('error', "Incident with ID {$flagId} not found in database.");
-            session()->setFlashdata('error', 'Incident not found.');
-            return redirect()->back();
-        }
-
-        // Check if the flag is not already canceled
-        if ($flagData['flag_state'] !== 'Canceled') {
-            // Update the flag state to Canceled
-            $currentFlagModel->update($flagId, [
-                'flag_state' => 'Canceled',
-                'updated_by_canceled' => $userId,
-                'cancel_description' => $cancelDescription,
-                'action_taken' => $actionTaken
-            ]);
-
-            // Retrieve updated flag data to ensure latest state
-            $flagData = $currentFlagModel->find($flagId);
-            return $this->moveToHistory($flagData);
-        } else {
-            session()->setFlashdata('error', 'Incident is already canceled.');
-        }
-
-        return $this->index();
-    }
-
-
-    private function moveToHistory($flagData)
-    {
-        $flagModel = new FlagModel();
-
-        // Prepare data for the flag table
-        $dataToInsert = [
-            'student_id'            => $flagData['student_id'],
-            'student_name'          => $flagData['student_name'],
-            'grade'                 => $flagData['grade'],
-            'flag'                  => $flagData['flag'],
-            'flag_datetime'         => $flagData['flag_datetime'],
-            'flag_state'            => $flagData['flag_state'],
-            'updated_by_open'       => $flagData['updated_by_open'],
-            'open_description'      => $flagData['open_description'],
-            'updated_by_closed'     => $flagData['updated_by_closed'],
-            'close_description'     => $flagData['close_description'],
-            'action_taken'          => $flagData['action_taken'],
-            'updated_by_canceled'   => $flagData['updated_by_canceled'],
-            'cancel_description'    => $flagData['cancel_description'],
-            'semester'              => $flagData['semester'],
-            'school_year'           => $flagData['school_year'],
-            'created_at'            => $flagData['created_at'],
-            'updated_at'            => $flagData['updated_at']
-        ];
-
-        // Insert data into the flag table
-        if ($flagModel->insert($dataToInsert)) {
-            // Delete the entry from the current_flag table
-            $currentFlagModel = new CurrentFlagModel();
-            $currentFlagModel->delete($flagData['id']);
-            session()->setFlashdata('success', 'Incident has been moved to history.');
-        } else {
-            session()->setFlashdata('error', 'Failed to move incident to history.');
-        }
-
-        return $this->index();
-    }
-}
diff --git a/app/Http/Controllers/old/GradingController.php b/app/Http/Controllers/old/GradingController.php
deleted file mode 100644
index f323d6e1..00000000
--- a/app/Http/Controllers/old/GradingController.php
+++ /dev/null
@@ -1,2237 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Models\StudentModel;
-use App\Models\StudentClassModel;
-use App\Models\ConfigurationModel;
-use CodeIgniter\Controller;
-use CodeIgniter\Events\Events;
-use App\Models\HomeworkModel;
-use App\Models\QuizModel;
-use App\Models\ProjectModel;
-use App\Models\MidtermExamModel;
-use App\Models\FinalExamModel;
-use App\Models\SemesterScoreModel; // Assuming you use test_avg here
-use App\Models\ScoreCommentModel;
-use App\Models\TeacherClassModel;
-use App\Models\UserModel;
-use App\Models\ClassSectionModel;
-use App\Models\CalendarModel;
-use App\Models\AttendanceRecordModel;
-use App\Services\Calculators\AttendanceCalculator;
-use RuntimeException;
-use Config\Services;
-use App\Models\ParentMeetingScheduleModel;
-use App\Models\CurrentFlagModel;
-use App\Models\PlacementLevelModel;
-use App\Models\PlacementBatchModel;
-use App\Models\PlacementScoreModel;
-use App\Models\GradingLockModel;
-use App\Services\NavbarService;
-
-//use App\Models\ScoreModel;
-
-
-class GradingController extends Controller
-{
-    protected $semesterScoreService;
-    protected $db;
-    protected $configModel;
-    protected $homeworkModel;
-    protected $userModel;
-    protected $schoolYear;
-    protected $semester;
-    protected $studentClassModel;
-    protected $studentModel;
-    protected $teacherClassModel;
-    protected $classSection;
-    protected $attendanceCalculator;
-    protected $parentMeetingModel;
-    protected $placementLevelModel;
-    protected $placementBatchModel;
-    protected $placementScoreModel;
-    protected $gradingLockModel;
-
-    public function __construct()
-    {
-        // Initialize models
-        $this->teacherClassModel = new TeacherClassModel();
-        $this->homeworkModel = new HomeworkModel();
-        $this->userModel = new UserModel();
-        $this->studentClassModel = new StudentClassModel();
-        $this->studentModel      = new StudentModel();
-        $this->configModel = new ConfigurationModel();
-        $this->db = \Config\Database::connect();
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->classSection = new ClassSectionModel();
-        $this->attendanceCalculator = new AttendanceCalculator(
-            new AttendanceRecordModel(),
-            $this->configModel,
-            new CalendarModel()
-        );
-        $this->parentMeetingModel = new ParentMeetingScheduleModel();
-        $this->placementLevelModel = new PlacementLevelModel();
-        $this->placementBatchModel = new PlacementBatchModel();
-        $this->placementScoreModel = new PlacementScoreModel();
-        $this->gradingLockModel = new GradingLockModel();
-
-        // Log the service initialization
-        log_message('debug', 'Initializing SemesterScoreService');
-
-        $this->semesterScoreService = service('semesterScoreService');
-    }
-
-    public function show($type, $classSectionId, $studentId)
-    {
-        $scoreModel = $this->getModelByType($type);
-        $studentModel = new StudentModel();
-        $configModel = new ConfigurationModel();
-
-        $schoolYear = $configModel->getConfig('school_year');
-        $semester = $configModel->getConfig('semester');
-
-        $student = $studentModel->find($studentId);
-        $scores = $scoreModel->where([
-            'student_id' => $studentId,
-            'semester' => $semester,
-            'school_year' => $schoolYear
-        ])->findAll();
-        $scoresLocked = false;
-        $classSectionIdInt = (int) ($classSectionId ?? 0);
-        if ($classSectionIdInt > 0) {
-            $scoresLocked = $this->gradingLockModel->isLocked($classSectionIdInt, $semester, $schoolYear);
-        }
-
-        return view("grading/{$type}", [
-            'student' => $student,
-            'scores' => $scores,
-            'type' => $type,
-            'classSectionId' => $classSectionId, // ✅ pass it manually
-            'semester' => $semester, // ✅ Pass semester to the view
-            'scoresLocked' => $scoresLocked,
-        ]);
-    }
-
-    private function getModelByType($type)
-    {
-        return match ($type) {
-            'homework' => new HomeworkModel(),
-            'quiz' => new QuizModel(),
-            'project' => new ProjectModel(),
-            'midterm' => new MidtermExamModel(),
-            'final' => new FinalExamModel(),
-            'test' => new SemesterScoreModel(), // Assuming you use test_avg here
-            'comments' => new ScoreCommentModel(),
-            default => throw new \InvalidArgumentException("Invalid type: $type"),
-        };
-    }
-
-    public function update()
-    {
-        $type = $this->request->getPost('type');
-        $studentId = $this->request->getPost('student_id');
-        $classSectionId = $this->request->getPost('class_section_id');
-        $configModel = new ConfigurationModel();
-        $studentModel = new StudentModel();
-
-        $schoolYear = $configModel->getConfig('school_year');
-        $semester = $configModel->getConfig('semester');
-
-        $model = $this->getModelByType($type);
-        $classSectionIdInt = (int) ($classSectionId ?? 0);
-        if ($classSectionIdInt > 0 && $this->isScoresLocked($classSectionIdInt, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-
-        if (in_array($type, ['homework', 'quiz', 'project'])) {
-            $scoreIds = $this->request->getPost('score_ids');
-            $scores = $this->request->getPost('scores');
-            $comments = $this->request->getPost('comments');
-
-            foreach ($scoreIds as $i => $id) {
-                $model->update($id, [
-                    'score' => $scores[$i],
-                    'comment' => $comments[$i] ?? null,
-                    'updated_at' => utc_now()
-                ]);
-            }
-        } elseif (in_array($type, ['midterm', 'final', 'test'])) {
-            $score = $this->request->getPost('score');
-
-            $data = [
-                'score' => $score,
-                'updated_at' => utc_now()
-            ];
-
-            $existing = $model->where([
-                'student_id' => $studentId,
-                'class_section_id' => $classSectionId,
-                'semester' => $semester,
-                'school_year' => $schoolYear
-            ])->first();
-
-            if ($existing) {
-                $model->update($existing['id'], $data);
-            } else {
-                $data += [
-                    'student_id' => $studentId,
-                    'class_section_id' => $classSectionId,
-                    'semester' => $semester,
-                    'school_year' => $schoolYear,
-                    'created_at' => utc_now()
-                ];
-                $model->insert($data);
-            }
-        } elseif ($type === 'comments') {
-            $comment = $this->request->getPost('comment');
-
-            $model->where([
-                'student_id' => $studentId,
-                'semester' => $semester,
-                'school_year' => $schoolYear
-            ])->delete(); // Remove existing comments of this type (optional)
-
-            $model->insert([
-                'student_id' => $studentId,
-                'score_type' => 'general',
-                'semester' => $semester,
-                'school_year' => $schoolYear,
-                'comment' => $comment,
-                'commented_by' => session()->get('user_id'),
-                'created_at' => utc_now()
-            ]);
-        }
-
-        $studentTeacherInfo = $studentModel->getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear);
-        // Call the updateScoresForStudents method
-        try {
-
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-        return redirect()->back()->with('status', 'Scores updated successfully.');
-    }
-
-    public function grading()
-    {
-        $schoolYear = (string) $this->schoolYear;
-        $configuredSemester = (string) $this->semester;
-        $requestedClassId = (int) ($this->request->getGet('class_id') ?? 0);
-        $semesterOptions = $this->getSemestersForSchoolYear($schoolYear, $configuredSemester);
-        $session = session();
-        $requestedSemester = $this->normalizeSemesterInput($this->request->getGet('semester'));
-        $sessionSemester = $this->normalizeSemesterInput($session->get('grading_selected_semester'));
-        $effectiveRequested = $requestedSemester ?? $sessionSemester;
-        $semester = trim($this->resolveSemesterSelection($effectiveRequested, $semesterOptions, $configuredSemester));
-        if ($semester === '') {
-            $semester = $configuredSemester !== '' ? $configuredSemester : ($semesterOptions[0] ?? 'Fall');
-        }
-        if (!in_array($semester, $semesterOptions, true)) {
-            $semesterOptions[] = $semester;
-        }
-        $semesterOptions = array_values(array_unique($semesterOptions));
-        $session->set('grading_selected_semester', $semester);
-
-        $this->ensureParentReleaseKeyExists('Fall');
-        $this->ensureParentReleaseKeyExists('Spring');
-        $scoresReleased = $this->getParentScoresReleasedForSemester($semester);
-        $scoresReleasedFall = $this->getParentScoresReleasedForSemester('Fall');
-        $scoresReleasedSpring = $this->getParentScoresReleasedForSemester('Spring');
-
-        // Refresh PTAP/semester scores for the requested class (if provided) so values are present.
-        if ($requestedClassId > 0 && $this->semesterScoreService !== null) {
-            $sectionIds = $this->classSection
-                ->select('class_section_id')
-                ->where('class_id', $requestedClassId)
-                ->findAll();
-
-            $sectionIds = array_values(array_filter(array_map(
-                static fn($row) => (int)($row['class_section_id'] ?? 0),
-                $sectionIds
-            ), static fn($id) => $id > 0));
-
-            foreach ($sectionIds as $sectionId) {
-                $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId(
-                    $sectionId,
-                    $semester,
-                    $schoolYear
-                );
-                if (empty($studentTeacherInfo)) {
-                    continue;
-                }
-                try {
-                    $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-                } catch (\Throwable $e) {
-                    log_message(
-                        'error',
-                        'GradingController::grading score refresh failed for section '
-                        . $sectionId . ': ' . $e->getMessage()
-                    );
-                }
-            }
-        }
-
-        // Normalize the semester text for safe comparison
-        $semEsc = $this->db->escape($semester);
-        $yrEsc  = $this->db->escape($schoolYear);
-
-        $rows = $this->buildGradingRows($semEsc, $yrEsc, $schoolYear);
-
-        // Preload quiz/homework/project/participation/midterm score counts to distinguish true zeros from empty scores
-        $quizCounts = [];
-        $homeworkCounts = [];
-        $projectCounts = [];
-        $participationCounts = [];
-        $midtermCounts = [];
-        if (!empty($rows)) {
-            $sectionIds = [];
-            $studentIds = [];
-            foreach ($rows as $r) {
-                $sid = (int) ($r['student_id'] ?? 0);
-                $sec = (int) ($r['section_id'] ?? 0);
-                if ($sid > 0) $studentIds[$sid] = true;
-                if ($sec > 0) $sectionIds[$sec] = true;
-            }
-            $sectionIds = array_keys($sectionIds);
-            $studentIds = array_keys($studentIds);
-
-            if (!empty($sectionIds) && !empty($studentIds)) {
-                $quizRows = $this->db->table('quiz')
-                    ->select('student_id, class_section_id, COUNT(*) AS cnt')
-                    ->where('semester', $semester)
-                    ->where('school_year', $schoolYear)
-                    ->whereIn('class_section_id', $sectionIds)
-                    ->whereIn('student_id', $studentIds)
-                    ->where('score IS NOT NULL', null, false)
-                    ->groupBy('student_id, class_section_id')
-                    ->get()->getResultArray();
-
-                foreach ($quizRows as $qr) {
-                    $sec = (int) ($qr['class_section_id'] ?? 0);
-                    $sid = (int) ($qr['student_id'] ?? 0);
-                    if ($sec > 0 && $sid > 0) {
-                        $quizCounts[$sec][$sid] = (int) ($qr['cnt'] ?? 0);
-                    }
-                }
-
-                $hwRows = $this->db->table('homework')
-                    ->select('student_id, class_section_id, COUNT(*) AS cnt')
-                    ->where('semester', $semester)
-                    ->where('school_year', $schoolYear)
-                    ->whereIn('class_section_id', $sectionIds)
-                    ->whereIn('student_id', $studentIds)
-                    ->where('score IS NOT NULL', null, false)
-                    ->groupBy('student_id, class_section_id')
-                    ->get()->getResultArray();
-
-                foreach ($hwRows as $hr) {
-                    $sec = (int) ($hr['class_section_id'] ?? 0);
-                    $sid = (int) ($hr['student_id'] ?? 0);
-                    if ($sec > 0 && $sid > 0) {
-                        $homeworkCounts[$sec][$sid] = (int) ($hr['cnt'] ?? 0);
-                    }
-                }
-
-                $projectRows = $this->db->table('project')
-                    ->select('student_id, class_section_id, COUNT(*) AS cnt')
-                    ->where('semester', $semester)
-                    ->where('school_year', $schoolYear)
-                    ->whereIn('class_section_id', $sectionIds)
-                    ->whereIn('student_id', $studentIds)
-                    ->where('score IS NOT NULL', null, false)
-                    ->groupBy('student_id, class_section_id')
-                    ->get()->getResultArray();
-
-                foreach ($projectRows as $pr) {
-                    $sec = (int) ($pr['class_section_id'] ?? 0);
-                    $sid = (int) ($pr['student_id'] ?? 0);
-                    if ($sec > 0 && $sid > 0) {
-                        $projectCounts[$sec][$sid] = (int) ($pr['cnt'] ?? 0);
-                    }
-                }
-
-                $participationRows = $this->db->table('participation')
-                    ->select('student_id, class_section_id, COUNT(*) AS cnt')
-                    ->where('semester', $semester)
-                    ->where('school_year', $schoolYear)
-                    ->whereIn('class_section_id', $sectionIds)
-                    ->whereIn('student_id', $studentIds)
-                    ->where('score IS NOT NULL', null, false)
-                    ->groupBy('student_id, class_section_id')
-                    ->get()->getResultArray();
-
-                foreach ($participationRows as $par) {
-                    $sec = (int) ($par['class_section_id'] ?? 0);
-                    $sid = (int) ($par['student_id'] ?? 0);
-                    if ($sec > 0 && $sid > 0) {
-                        $participationCounts[$sec][$sid] = (int) ($par['cnt'] ?? 0);
-                    }
-                }
-
-                $midtermRows = $this->db->table('midterm_exam')
-                    ->select('student_id, class_section_id, COUNT(*) AS cnt')
-                    ->where('semester', $semester)
-                    ->where('school_year', $schoolYear)
-                    ->whereIn('class_section_id', $sectionIds)
-                    ->whereIn('student_id', $studentIds)
-                    ->where('score IS NOT NULL', null, false)
-                    ->groupBy('student_id, class_section_id')
-                    ->get()->getResultArray();
-
-                foreach ($midtermRows as $mr) {
-                    $sec = (int) ($mr['class_section_id'] ?? 0);
-                    $sid = (int) ($mr['student_id'] ?? 0);
-                    if ($sec > 0 && $sid > 0) {
-                        $midtermCounts[$sec][$sid] = (int) ($mr['cnt'] ?? 0);
-                    }
-                }
-            }
-        }
-
-        // If any section is missing PTAP or semester score, refresh and reload once
-        $sectionsNeedingRefresh = [];
-        foreach ($rows as $r) {
-            $sectionId = (int) ($r['section_id'] ?? 0);
-            if ($sectionId <= 0) continue;
-            $ptapMissing = $r['ss_ptap_score'] === null;
-            $semMissing  = $r['ss_semester_score'] === null;
-            if ($ptapMissing || $semMissing) {
-                $sectionsNeedingRefresh[$sectionId] = true;
-            }
-        }
-
-        if (!empty($sectionsNeedingRefresh) && $this->semesterScoreService !== null) {
-            foreach (array_keys($sectionsNeedingRefresh) as $sectionId) {
-                $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId(
-                    $sectionId,
-                    $semester,
-                    $schoolYear
-                );
-                if (empty($studentTeacherInfo)) {
-                    continue;
-                }
-                try {
-                    $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-                } catch (\Throwable $e) {
-                    log_message(
-                        'error',
-                        'GradingController::grading refresh missing scores for section '
-                        . $sectionId . ': ' . $e->getMessage()
-                    );
-                }
-            }
-            // Reload rows after refresh
-            $rows = $this->buildGradingRows($semEsc, $yrEsc, $schoolYear);
-        }
-
-        // Build structures keyed by BUSINESS section id
-        $grades            = []; // class_id => [ ['class_section_id','class_section_name'], ... ]
-        $studentsBySection = []; // section_id => [ students... ]
-
-        foreach ($rows as $r) {
-            $sectionId   = (int) ($r['section_id'] ?? 0);   // BUSINESS id
-            $classId     = (int) ($r['class_id'] ?? 0);
-            $sectionName = (string) ($r['class_section_name'] ?? '');
-            if ($sectionId <= 0 || $classId <= 0) continue;
-
-            if (!isset($grades[$classId])) $grades[$classId] = [];
-            $exists = false;
-            foreach ($grades[$classId] as $s) {
-                if ((int)$s['class_section_id'] === $sectionId) {
-                    $exists = true;
-                    break;
-                }
-            }
-            if (!$exists) {
-                $grades[$classId][] = [
-                    'class_section_id'   => $sectionId,
-                    'class_section_name' => $sectionName,
-                ];
-            }
-
-            $sid = (int) ($r['student_id'] ?? 0);
-            if ($sid <= 0) continue;
-
-            $ptapScore     = $r['ss_ptap_score'] ?? null;
-            $semesterScore = $r['ss_semester_score'] ?? null;
-
-            $attendanceScore = $this->calculateAttendanceScoreForStudent(
-                $sid,
-                $semester,
-                $schoolYear,
-                $sectionId
-            );
-            if ($attendanceScore === null) {
-                $rawAttendance = $r['ss_attendance_score'] ?? null;
-                if ($rawAttendance !== null && $rawAttendance !== '') {
-                    $attendanceScore = round((float) $rawAttendance, 2);
-                }
-            }
-            $homeworkAvg = isset($r['ss_homework_avg']) && $r['ss_homework_avg'] !== '' ? round((float) $r['ss_homework_avg'], 2) : null;
-            if ($homeworkAvg !== null && (float) $homeworkAvg === 0.0) {
-                $hwCount = (int) ($homeworkCounts[$sectionId][$sid] ?? 0);
-                if ($hwCount === 0) {
-                    $homeworkAvg = null;
-                }
-            }
-
-            $projectAvg = isset($r['ss_project_avg']) && $r['ss_project_avg'] !== '' ? round((float) $r['ss_project_avg'], 2) : null;
-            if ($projectAvg !== null && (float) $projectAvg === 0.0) {
-                $prCount = (int) ($projectCounts[$sectionId][$sid] ?? 0);
-                if ($prCount === 0) {
-                    $projectAvg = null;
-                }
-            }
-
-            $participationScore = isset($r['ss_participation_score']) && $r['ss_participation_score'] !== '' ? round((float) $r['ss_participation_score'], 2) : null;
-            if ($participationScore !== null && (float) $participationScore === 0.0) {
-                $pCount = (int) ($participationCounts[$sectionId][$sid] ?? 0);
-                if ($pCount === 0) {
-                    $participationScore = null;
-                }
-            }
-
-            $midtermExam = isset($r['ss_midterm_exam_score']) && $r['ss_midterm_exam_score'] !== '' ? round((float) $r['ss_midterm_exam_score'], 2) : null;
-            if ($midtermExam !== null && (float) $midtermExam === 0.0) {
-                $mCount = (int) ($midtermCounts[$sectionId][$sid] ?? 0);
-                if ($mCount === 0) {
-                    $midtermExam = null;
-                }
-            }
-
-            $quizAvg = isset($r['ss_quiz_avg']) && $r['ss_quiz_avg'] !== '' ? round((float) $r['ss_quiz_avg'], 2) : null;
-            if ($quizAvg !== null && (float) $quizAvg === 0.0) {
-                $quizCount = (int) ($quizCounts[$sectionId][$sid] ?? 0);
-                if ($quizCount === 0) {
-                    $quizAvg = null;
-                }
-            }
-
-            $studentsBySection[$sectionId][] = [
-                'id'             => $sid,
-                'school_id'      => $r['school_id'] ?? null,
-                'firstname'      => $r['firstname'] ?? null,
-                'lastname'       => $r['lastname'] ?? null,
-                'class_id'       => $classId,
-                'ptap'           => is_null($ptapScore) ? null : round((float) $ptapScore, 2),
-                'semester_score' => is_null($semesterScore) ? null : round((float) $semesterScore, 2),
-                'attendance'     => $attendanceScore,
-                'homework_avg'   => $homeworkAvg,
-                'project_avg'    => $projectAvg,
-                'quiz_avg'       => $quizAvg,
-                'participation'  => $participationScore,
-                'midterm_exam'   => $midtermExam,
-                'final_exam'     => isset($r['ss_final_exam_score']) && $r['ss_final_exam_score'] !== '' ? round((float) $r['ss_final_exam_score'], 2) : null,
-                'matched_biz_csid' => $r['matched_biz_csid'] ?? null,
-                'matched_pk_csid'  => $r['matched_pk_csid'] ?? null,
-                'placement_level' => $r['placement_level'] ?? null,
-            ];
-        }
-
-        $scoreLocks = [];
-        $lockSectionIds = [];
-        foreach ($grades as $sections) {
-            foreach ($sections as $section) {
-                $sid = (int) ($section['class_section_id'] ?? 0);
-                if ($sid > 0) {
-                    $lockSectionIds[$sid] = true;
-                }
-            }
-        }
-        $lockSectionIds = array_keys($lockSectionIds);
-        if (!empty($lockSectionIds)) {
-            $lockRows = $this->gradingLockModel
-                ->whereIn('class_section_id', $lockSectionIds)
-                ->where('semester', $semester)
-                ->where('school_year', $schoolYear)
-                ->findAll();
-            foreach ($lockRows as $row) {
-                $scoreLocks[(int) ($row['class_section_id'] ?? 0)] = !empty($row['is_locked']);
-            }
-        }
-
-        return view('grading/grading_main', [
-            'grades'            => $grades,
-            'studentsBySection' => $studentsBySection,
-            'semester'          => $semester,
-            'schoolYear'        => $schoolYear,
-            'requestedClassId'  => $requestedClassId,
-            'semesterOptions'   => $semesterOptions,
-            'scoresReleased'    => $scoresReleased,
-            'scoresReleasedFall' => $scoresReleasedFall,
-            'scoresReleasedSpring' => $scoresReleasedSpring,
-            'scoreLocks'        => $scoreLocks,
-        ]);
-    }
-
-    public function toggleScoreLock()
-    {
-        $classSectionId = (int) ($this->request->getPost('class_section_id') ?? 0);
-        $semester = trim((string) ($this->request->getPost('semester') ?? $this->semester));
-        $schoolYear = trim((string) ($this->request->getPost('school_year') ?? $this->schoolYear));
-
-        if ($classSectionId <= 0 || $semester === '' || $schoolYear === '') {
-            return redirect()->back()->with('error', 'Missing class section or term.');
-        }
-
-        $existing = $this->gradingLockModel->getLock($classSectionId, $semester, $schoolYear);
-        $userId = (int) (session()->get('user_id') ?? 0);
-
-        if (!empty($existing) && !empty($existing['is_locked'])) {
-            $this->gradingLockModel->update($existing['id'], [
-                'is_locked' => 0,
-                'locked_by' => null,
-                'locked_at' => null,
-            ]);
-            return redirect()->back()->with('status', 'Scores unlocked for this class.');
-        }
-
-        if (!empty($existing)) {
-            $this->gradingLockModel->update($existing['id'], [
-                'is_locked' => 1,
-                'locked_by' => $userId > 0 ? $userId : null,
-                'locked_at' => utc_now(),
-            ]);
-        } else {
-            $this->gradingLockModel->insert([
-                'class_section_id' => $classSectionId,
-                'semester' => $semester,
-                'school_year' => $schoolYear,
-                'is_locked' => 1,
-                'locked_by' => $userId > 0 ? $userId : null,
-                'locked_at' => utc_now(),
-            ]);
-        }
-
-        return redirect()->back()->with('status', 'Scores locked for this class.');
-    }
-
-    public function lockAllScores()
-    {
-        $semester = trim((string) ($this->request->getPost('semester') ?? $this->semester));
-        $schoolYear = trim((string) ($this->request->getPost('school_year') ?? $this->schoolYear));
-
-        if ($semester === '' || $schoolYear === '') {
-            return redirect()->back()->with('error', 'Missing semester or school year.');
-        }
-
-        $sectionRows = $this->classSection
-            ->select('class_section_id')
-            ->groupBy('class_section_id')
-            ->findAll();
-
-        $sectionIds = array_values(array_filter(array_map(
-            static fn($row) => (int) ($row['class_section_id'] ?? 0),
-            $sectionRows
-        ), static fn($id) => $id > 0));
-
-        if (empty($sectionIds)) {
-            return redirect()->back()->with('error', 'No class sections found to lock.');
-        }
-
-        $existingLocks = $this->gradingLockModel
-            ->whereIn('class_section_id', $sectionIds)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        $existingBySection = [];
-        foreach ($existingLocks as $row) {
-            $sid = (int) ($row['class_section_id'] ?? 0);
-            if ($sid > 0) {
-                $existingBySection[$sid] = $row;
-            }
-        }
-
-        $userId = (int) (session()->get('user_id') ?? 0);
-        $now = utc_now();
-        $insertRows = [];
-
-        foreach ($sectionIds as $sid) {
-            if (!empty($existingBySection[$sid])) {
-                if (!empty($existingBySection[$sid]['is_locked'])) {
-                    continue;
-                }
-                $this->gradingLockModel->update($existingBySection[$sid]['id'], [
-                    'is_locked' => 1,
-                    'locked_by' => $userId > 0 ? $userId : null,
-                    'locked_at' => $now,
-                ]);
-                continue;
-            }
-
-            $insertRows[] = [
-                'class_section_id' => $sid,
-                'semester' => $semester,
-                'school_year' => $schoolYear,
-                'is_locked' => 1,
-                'locked_by' => $userId > 0 ? $userId : null,
-                'locked_at' => $now,
-                'created_at' => $now,
-                'updated_at' => $now,
-            ];
-        }
-
-        if (!empty($insertRows)) {
-            $this->gradingLockModel->insertBatch($insertRows);
-        }
-
-        return redirect()->back()->with('status', 'Scores locked for all classes.');
-    }
-
-    private function isScoresLocked(int $classSectionId, string $semester, string $schoolYear): bool
-    {
-        return $this->gradingLockModel->isLocked($classSectionId, $semester, $schoolYear);
-    }
-
-    public function updatePlacementLevel()
-    {
-        $studentId = (int) ($this->request->getPost('student_id') ?? 0);
-        $levelRaw = trim((string) ($this->request->getPost('placement_level') ?? ''));
-        $schoolYear = (string) ($this->request->getPost('school_year') ?? $this->schoolYear);
-
-        if ($studentId <= 0 || $schoolYear === '') {
-            return redirect()->back()->with('error', 'Missing student or school year.');
-        }
-
-        $level = $levelRaw === '' ? null : (int) $levelRaw;
-        if ($level !== null && !in_array($level, [1, 2, 3], true)) {
-            return redirect()->back()->with('error', 'Invalid placement level.');
-        }
-
-        $existing = $this->placementLevelModel
-            ->where('student_id', $studentId)
-            ->where('school_year', $schoolYear)
-            ->first();
-
-        if ($level === null) {
-            if ($existing) {
-                $this->placementLevelModel->delete($existing['id']);
-            }
-            return redirect()->back()->with('status', 'Placement level cleared.');
-        }
-
-        $payload = [
-            'student_id' => $studentId,
-            'school_year' => $schoolYear,
-            'level' => $level,
-            'updated_by' => session()->get('user_id'),
-        ];
-
-        if ($existing) {
-            $this->placementLevelModel->update($existing['id'], $payload);
-        } else {
-            $payload['created_by'] = session()->get('user_id');
-            $this->placementLevelModel->insert($payload);
-        }
-
-        return redirect()->back()->with('status', 'Placement level updated.');
-    }
-
-    public function placement()
-    {
-        $classSectionId = (int) ($this->request->getGet('class_section_id') ?? 0);
-        $schoolYear = (string) ($this->request->getGet('school_year') ?? $this->schoolYear);
-        $placementTest = (string) ($this->request->getGet('placement_test') ?? '');
-        $openFlag = (string) ($this->request->getGet('open') ?? '');
-
-        if ($classSectionId <= 0 || $schoolYear === '') {
-            $showStudents = ($placementTest !== '' && $openFlag === '1');
-            $students = $showStudents ? $this->fetchActiveStudentsWithSection($schoolYear) : [];
-            $batches = $this->fetchPlacementBatches($schoolYear);
-            $batchDetails = $this->fetchPlacementBatchDetails($batches, $schoolYear);
-            return view('grading/placement_index', [
-                'schoolYear' => $schoolYear,
-                'students' => $students,
-                'batches' => $batches,
-                'batchDetails' => $batchDetails,
-                'placementTest' => $placementTest,
-                'showStudents' => $showStudents,
-            ]);
-        }
-
-        $sectionName = $this->classSection->getClassSectionNameBySectionId($classSectionId) ?? '';
-        $classId = $this->classSection->getClassId($classSectionId);
-
-        $students = $this->studentModel->getStudentInfoByClassSectionId($classSectionId, null, $schoolYear);
-        $studentIds = array_values(array_filter(array_map(
-            static fn($row) => (int) ($row['student_id'] ?? 0),
-            $students
-        ), static fn($id) => $id > 0));
-
-        $levels = [];
-        if (!empty($studentIds)) {
-            $rows = $this->placementLevelModel
-                ->whereIn('student_id', $studentIds)
-                ->where('school_year', $schoolYear)
-                ->findAll();
-            foreach ($rows as $row) {
-                $levels[(int) $row['student_id']] = $row['level'] ?? null;
-            }
-        }
-
-        return view('grading/placement', [
-            'classSectionId' => $classSectionId,
-            'classSectionName' => $sectionName,
-            'classId' => $classId,
-            'schoolYear' => $schoolYear,
-            'students' => $students,
-            'levels' => $levels,
-        ]);
-    }
-
-    public function updatePlacementLevels()
-    {
-        $classSectionId = (int) ($this->request->getPost('class_section_id') ?? 0);
-        $schoolYear = (string) ($this->request->getPost('school_year') ?? $this->schoolYear);
-        $levels = $this->request->getPost('placement_level') ?? [];
-
-        if ($classSectionId <= 0 || $schoolYear === '') {
-            return redirect()->back()->with('error', 'Missing class section or school year.');
-        }
-
-        $students = $this->studentModel->getStudentInfoByClassSectionId($classSectionId, null, $schoolYear);
-        $validIds = array_values(array_filter(array_map(
-            static fn($row) => (int) ($row['student_id'] ?? 0),
-            $students
-        ), static fn($id) => $id > 0));
-
-        $validSet = array_flip($validIds);
-        $existingRows = [];
-        if (!empty($validIds)) {
-            $rows = $this->placementLevelModel
-                ->whereIn('student_id', $validIds)
-                ->where('school_year', $schoolYear)
-                ->findAll();
-            foreach ($rows as $row) {
-                $existingRows[(int) $row['student_id']] = $row;
-            }
-        }
-
-        $userId = session()->get('user_id');
-        foreach ($levels as $studentIdRaw => $levelRaw) {
-            $studentId = (int) $studentIdRaw;
-            if (!isset($validSet[$studentId])) {
-                continue;
-            }
-            $levelRaw = trim((string) $levelRaw);
-            $level = $levelRaw === '' ? null : (int) $levelRaw;
-            if ($level !== null && !in_array($level, [1, 2, 3], true)) {
-                continue;
-            }
-
-            if ($level === null) {
-                if (isset($existingRows[$studentId])) {
-                    $this->placementLevelModel->delete($existingRows[$studentId]['id']);
-                }
-                continue;
-            }
-
-            $payload = [
-                'student_id' => $studentId,
-                'school_year' => $schoolYear,
-                'level' => $level,
-                'updated_by' => $userId,
-            ];
-
-            if (isset($existingRows[$studentId])) {
-                $this->placementLevelModel->update($existingRows[$studentId]['id'], $payload);
-            } else {
-                $payload['created_by'] = $userId;
-                $this->placementLevelModel->insert($payload);
-            }
-        }
-
-        return redirect()->back()->with('status', 'Placement levels updated.');
-    }
-
-    public function updatePlacementLevelsAll()
-    {
-        $schoolYear = (string) ($this->request->getPost('school_year') ?? $this->schoolYear);
-        $placementTest = (string) ($this->request->getPost('placement_test') ?? '');
-        $levels = $this->request->getPost('placement_level') ?? [];
-
-        if ($schoolYear === '' || $placementTest === '') {
-            return redirect()->back()->with('error', 'Missing placement test or school year.');
-        }
-
-        $students = $this->fetchActiveStudentsWithSection($schoolYear);
-        $validIds = array_values(array_filter(array_map(
-            static fn($row) => (int) ($row['student_id'] ?? 0),
-            $students
-        ), static fn($id) => $id > 0));
-
-        $validSet = array_flip($validIds);
-        $userId = session()->get('user_id');
-
-        $batchId = $this->placementBatchModel->insert([
-            'placement_test' => $placementTest,
-            'school_year' => $schoolYear,
-            'created_by' => $userId,
-            'updated_by' => $userId,
-        ]);
-
-        if (!$batchId) {
-            return redirect()->back()->with('error', 'Unable to create placement batch.');
-        }
-
-        $savedCount = 0;
-        foreach ($levels as $studentIdRaw => $levelRaw) {
-            $studentId = (int) $studentIdRaw;
-            if (!isset($validSet[$studentId])) {
-                continue;
-            }
-            $levelRaw = trim((string) $levelRaw);
-            if ($levelRaw === '') {
-                continue;
-            }
-            $level = (int) $levelRaw;
-            if ($level < 0 || $level > 100) {
-                continue;
-            }
-
-            $this->placementScoreModel->insert([
-                'batch_id' => (int) $batchId,
-                'student_id' => $studentId,
-                'score' => $level,
-                'created_by' => $userId,
-                'updated_by' => $userId,
-            ]);
-            $savedCount++;
-        }
-
-        if ($savedCount === 0) {
-            $this->placementBatchModel->delete((int) $batchId);
-            return redirect()->back()->with('error', 'No scores entered. Batch not saved.');
-        }
-
-        return redirect()->to(base_url('grading/placement'))
-            ->with('status', 'Placement batch saved.');
-    }
-
-    public function editPlacementBatch(int $batchId)
-    {
-        $batch = $this->placementBatchModel->find($batchId);
-        if (!$batch) {
-            return redirect()->to(base_url('grading/placement'))
-                ->with('error', 'Placement batch not found.');
-        }
-
-        $schoolYear = (string) ($batch['school_year'] ?? $this->schoolYear);
-        $students = $this->fetchActiveStudentsWithSection($schoolYear);
-        $scores = $this->fetchPlacementScoresForBatch($batchId);
-
-        return view('grading/placement_batch', [
-            'batch' => $batch,
-            'students' => $students,
-            'scores' => $scores,
-        ]);
-    }
-
-    public function updatePlacementBatch(int $batchId)
-    {
-        $batch = $this->placementBatchModel->find($batchId);
-        if (!$batch) {
-            return redirect()->to(base_url('grading/placement'))
-                ->with('error', 'Placement batch not found.');
-        }
-
-        $schoolYear = (string) ($batch['school_year'] ?? $this->schoolYear);
-        $levels = $this->request->getPost('placement_level') ?? [];
-
-        $students = $this->fetchActiveStudentsWithSection($schoolYear);
-        $validIds = array_values(array_filter(array_map(
-            static fn($row) => (int) ($row['student_id'] ?? 0),
-            $students
-        ), static fn($id) => $id > 0));
-
-        $validSet = array_flip($validIds);
-        $existing = $this->fetchPlacementScoresForBatch($batchId);
-
-        $userId = session()->get('user_id');
-        foreach ($levels as $studentIdRaw => $scoreRaw) {
-            $studentId = (int) $studentIdRaw;
-            if (!isset($validSet[$studentId])) {
-                continue;
-            }
-            $scoreRaw = trim((string) $scoreRaw);
-            if ($scoreRaw === '') {
-                if (isset($existing[$studentId])) {
-                    $this->placementScoreModel->delete($existing[$studentId]['id']);
-                }
-                continue;
-            }
-            $score = (int) $scoreRaw;
-            if ($score < 0 || $score > 100) {
-                continue;
-            }
-
-            if (isset($existing[$studentId])) {
-                $this->placementScoreModel->update($existing[$studentId]['id'], [
-                    'score' => $score,
-                    'updated_by' => $userId,
-                ]);
-            } else {
-                $this->placementScoreModel->insert([
-                    'batch_id' => $batchId,
-                    'student_id' => $studentId,
-                    'score' => $score,
-                    'created_by' => $userId,
-                    'updated_by' => $userId,
-                ]);
-            }
-        }
-
-        $this->placementBatchModel->update($batchId, [
-            'updated_by' => $userId,
-        ]);
-
-        return redirect()->to(base_url('grading/placement'))
-            ->with('status', 'Placement batch updated.');
-    }
-
-    private function fetchActiveStudentsWithSection(string $schoolYear): array
-    {
-        return $this->db->table('students s')
-            ->select('s.id AS student_id, s.school_id, s.firstname, s.lastname, sc.class_section_id, cs.class_section_name, c.class_name')
-            ->join('student_class sc', 'sc.student_id = s.id AND sc.school_year = ' . $this->db->escape($schoolYear), 'left')
-            ->join('`classSection` cs', 'cs.class_section_id = sc.class_section_id', 'left')
-            ->join('classes c', 'c.id = cs.class_id', 'left')
-            ->where('s.is_active', 1)
-            ->orderBy('s.lastname', 'ASC')
-            ->orderBy('s.firstname', 'ASC')
-            ->get()
-            ->getResultArray();
-    }
-
-    private function fetchPlacementBatches(string $schoolYear): array
-    {
-        return $this->placementBatchModel
-            ->where('school_year', $schoolYear)
-            ->orderBy('created_at', 'DESC')
-            ->findAll();
-    }
-
-    private function fetchPlacementBatchDetails(array $batches, string $schoolYear): array
-    {
-        if (empty($batches)) {
-            return [];
-        }
-
-        $batchIds = array_values(array_filter(array_map(
-            static fn($row) => (int) ($row['id'] ?? 0),
-            $batches
-        ), static fn($id) => $id > 0));
-
-        if (empty($batchIds)) {
-            return [];
-        }
-
-        $rows = $this->db->table('placement_scores ps')
-            ->select('ps.batch_id, ps.score, s.school_id, s.firstname, s.lastname, cs.class_section_name, c.class_name')
-            ->join('students s', 's.id = ps.student_id', 'inner')
-            ->join('student_class sc', 'sc.student_id = s.id AND sc.school_year = ' . $this->db->escape($schoolYear), 'left')
-            ->join('`classSection` cs', 'cs.class_section_id = sc.class_section_id', 'left')
-            ->join('classes c', 'c.id = cs.class_id', 'left')
-            ->whereIn('ps.batch_id', $batchIds)
-            ->where('s.is_active', 1)
-            ->orderBy('ps.batch_id', 'ASC')
-            ->orderBy('s.lastname', 'ASC')
-            ->orderBy('s.firstname', 'ASC')
-            ->get()
-            ->getResultArray();
-
-        $details = [];
-        foreach ($rows as $row) {
-            $bid = (int) ($row['batch_id'] ?? 0);
-            if ($bid <= 0) continue;
-            $details[$bid][] = $row;
-        }
-
-        return $details;
-    }
-
-    private function fetchPlacementScoresForBatch(int $batchId): array
-    {
-        $rows = $this->placementScoreModel
-            ->where('batch_id', $batchId)
-            ->findAll();
-        $scores = [];
-        foreach ($rows as $row) {
-            $scores[(int) $row['student_id']] = $row;
-        }
-        return $scores;
-    }
-
-    public function belowSixty()
-    {
-        $configuredSemester = (string) $this->semester;
-        $configuredYear = (string) $this->schoolYear;
-
-        $requestedSemester = trim((string)($this->request->getGet('semester') ?? ''));
-        $requestedYear = trim((string)($this->request->getGet('school_year') ?? ''));
-
-        $semester = $requestedSemester !== '' ? $requestedSemester : ($configuredSemester !== '' ? $configuredSemester : 'Fall');
-        $schoolYear = $requestedYear !== '' ? $requestedYear : $configuredYear;
-
-        $schoolYears = $this->getSchoolYearsForScores($schoolYear);
-        $rows = $this->fetchBelowSixtyRows($schoolYear, $semester);
-
-        $canViewGrading = $this->userHasMenuUrl('grading');
-
-        return view('grading/below_sixty', [
-            'rows' => $rows,
-            'semester' => $semester,
-            'schoolYear' => $schoolYear,
-            'schoolYears' => $schoolYears,
-            'canViewGrading' => $canViewGrading,
-        ]);
-    }
-
-    public function editBelowSixtyEmail()
-    {
-        $studentId = (int)$this->request->getGet('student_id');
-        $semester = trim((string)$this->request->getGet('semester'));
-        $schoolYear = trim((string)$this->request->getGet('school_year'));
-
-        if ($studentId <= 0 || $semester === '' || $schoolYear === '') {
-            return redirect()->back()->with('error', 'Missing student or term.');
-        }
-
-        $row = $this->fetchBelowSixtyEmailRow($studentId, $schoolYear, $semester);
-        if (empty($row)) {
-            return redirect()->back()->with('error', 'Student record not found for the selected term.');
-        }
-
-        $studentName = trim((string)($row['firstname'] ?? '') . ' ' . (string)($row['lastname'] ?? ''));
-        $subject = $this->buildBelowSixtySubject($studentName, $semester, $schoolYear);
-        $parentName = $this->fetchBelowSixtyParentName($studentId);
-
-        $scores = [
-            'homework_avg' => $row['homework_avg'] ?? null,
-            'project_avg' => $row['project_avg'] ?? null,
-            'participation_score' => $row['participation_score'] ?? null,
-            'test_avg' => $row['test_avg'] ?? null,
-            'ptap_score' => $row['ptap_score'] ?? null,
-            'attendance_score' => $row['attendance_score'] ?? null,
-            'midterm_exam_score' => $row['midterm_exam_score'] ?? null,
-            'semester_score' => $row['semester_score'] ?? null,
-        ];
-
-        $emailData = [
-            'title'              => $subject,
-            'parent_name'        => $parentName,
-            'student_name'       => $studentName !== '' ? $studentName : 'your student',
-            'class_section_name' => $row['class_section_name'] ?? '',
-            'semester'           => $semester,
-            'school_year'        => $schoolYear,
-            'scores'             => $scores,
-            'comment'            => $row['comment'] ?? '',
-            'sent_at'            => utc_now(),
-        ];
-
-        $html = view('emails/below_sixty_performance', $emailData, ['saveData' => true]);
-
-        return view('grading/below_sixty_email_editor', [
-            'studentId' => $studentId,
-            'studentName' => $studentName,
-            'semester' => $semester,
-            'schoolYear' => $schoolYear,
-            'subject' => $subject,
-            'html' => $html,
-        ]);
-    }
-
-    public function sendBelowSixtyEmail()
-    {
-        $studentId = (int)$this->request->getPost('student_id');
-        $semester = trim((string)$this->request->getPost('semester'));
-        $schoolYear = trim((string)$this->request->getPost('school_year'));
-        $subjectInput = trim((string)$this->request->getPost('subject'));
-        $htmlInput = (string)($this->request->getPost('html') ?? '');
-
-        if ($studentId <= 0 || $semester === '' || $schoolYear === '') {
-            return redirect()->back()->with('error', 'Missing student or term.');
-        }
-
-        $row = $this->fetchBelowSixtyEmailRow($studentId, $schoolYear, $semester);
-        if (empty($row)) {
-            return redirect()->back()->with('error', 'Student record not found for the selected term.');
-        }
-
-        $studentName = trim((string)($row['firstname'] ?? '') . ' ' . (string)($row['lastname'] ?? ''));
-        $subject = $subjectInput !== ''
-            ? $subjectInput
-            : $this->buildBelowSixtySubject($studentName, $semester, $schoolYear);
-        $scores = [
-            'homework_avg' => $row['homework_avg'] ?? null,
-            'project_avg' => $row['project_avg'] ?? null,
-            'participation_score' => $row['participation_score'] ?? null,
-            'test_avg' => $row['test_avg'] ?? null,
-            'ptap_score' => $row['ptap_score'] ?? null,
-            'attendance_score' => $row['attendance_score'] ?? null,
-            'midterm_exam_score' => $row['midterm_exam_score'] ?? null,
-            'semester_score' => $row['semester_score'] ?? null,
-        ];
-
-        $payload = [
-            'student_id' => $studentId,
-            'student_name' => $studentName,
-            'class_section_name' => $row['class_section_name'] ?? '',
-            'semester' => $semester,
-            'school_year' => $schoolYear,
-            'scores' => $scores,
-            'comment' => $row['comment'] ?? '',
-            'subject' => $subject,
-        ];
-
-        if (trim($htmlInput) !== '') {
-            $payload['html'] = $htmlInput;
-        }
-
-        Events::trigger('below60.email', $payload);
-
-        return redirect()->back()->with('status', 'Email sent to parent(s).');
-    }
-
-    public function updateBelowSixtyStatus()
-    {
-        $studentId = (int)$this->request->getPost('student_id');
-        $semester = trim((string)$this->request->getPost('semester'));
-        $schoolYear = trim((string)$this->request->getPost('school_year'));
-        $status = trim((string)$this->request->getPost('status'));
-        $note = trim((string)$this->request->getPost('note'));
-
-        if ($studentId <= 0 || $semester === '' || $schoolYear === '' || $status === '') {
-            return redirect()->back()->with('error', 'Missing required status data.');
-        }
-
-        $status = ucfirst(strtolower($status));
-        if (!in_array($status, ['Open', 'Closed'], true)) {
-            return redirect()->back()->with('error', 'Invalid status.');
-        }
-
-        $flagModel = new CurrentFlagModel();
-        $semKey = strtolower(trim($semester));
-
-        $existing = $flagModel
-            ->where('student_id', $studentId)
-            ->where('flag', 'grade')
-            ->where('school_year', $schoolYear)
-            ->where('LOWER(TRIM(semester))', $semKey)
-            ->first();
-
-        $userId = (int)(session()->get('user_id') ?? 0) ?: null;
-        $now = utc_now();
-
-        if ($existing) {
-            $data = [
-                'flag_state' => $status,
-                'flag_datetime' => $now,
-                'updated_at' => $now,
-            ];
-            if ($status === 'Open') {
-                $data['updated_by_open'] = $userId;
-                if ($note !== '') {
-                    $prev = (string)($existing['open_description'] ?? '');
-                    $data['open_description'] = trim($prev . PHP_EOL . $note);
-                }
-            } else {
-                $data['updated_by_closed'] = $userId;
-                if ($note !== '') {
-                    $prev = (string)($existing['close_description'] ?? '');
-                    $data['close_description'] = trim($prev . PHP_EOL . $note);
-                }
-            }
-            $flagModel->update((int)$existing['id'], $data);
-        } else {
-            $row = $this->fetchBelowSixtyEmailRow($studentId, $schoolYear, $semester);
-            $studentName = trim((string)($row['firstname'] ?? '') . ' ' . (string)($row['lastname'] ?? ''));
-            $grade = (string)($row['class_section_name'] ?? '');
-            $data = [
-                'student_id' => $studentId,
-                'student_name' => $studentName !== '' ? $studentName : 'Student',
-                'grade' => $grade,
-                'flag' => 'grade',
-                'flag_datetime' => $now,
-                'flag_state' => $status,
-                'semester' => $semester,
-                'school_year' => $schoolYear,
-                'updated_at' => $now,
-            ];
-            if ($status === 'Open') {
-                $data['updated_by_open'] = $userId;
-                if ($note !== '') $data['open_description'] = $note;
-            } else {
-                $data['updated_by_closed'] = $userId;
-                if ($note !== '') $data['close_description'] = $note;
-            }
-            $flagModel->insert($data);
-        }
-
-        return redirect()->back()->with('status', 'Status updated.');
-    }
-
-    public function scheduleBelowSixty()
-    {
-        $studentId = (int)($this->request->getGet('student_id') ?? 0);
-        $semester = trim((string)($this->request->getGet('semester') ?? ''));
-        $schoolYear = trim((string)($this->request->getGet('school_year') ?? ''));
-
-        if ($studentId <= 0 || $semester === '' || $schoolYear === '') {
-            return redirect()->back()->with('error', 'Missing student or term.');
-        }
-
-        $context = $this->fetchBelowSixtyMeetingContext($studentId, $schoolYear, $semester);
-        if (empty($context)) {
-            return redirect()->back()->with('error', 'Student record not found for the selected term.');
-        }
-
-        return view('grading/schedule_meeting', [
-            'studentId' => $studentId,
-            'studentName' => $context['student_name'],
-            'parentName' => $context['parent_name'],
-            'classSection' => $context['class_section_name'],
-            'semester' => $semester,
-            'schoolYear' => $schoolYear,
-        ]);
-    }
-
-    public function saveBelowSixtyMeeting()
-    {
-        $studentId = (int)$this->request->getPost('student_id');
-        $semester = trim((string)$this->request->getPost('semester'));
-        $schoolYear = trim((string)$this->request->getPost('school_year'));
-        $date = trim((string)$this->request->getPost('date'));
-        $time = trim((string)$this->request->getPost('time'));
-        $notes = trim((string)$this->request->getPost('notes'));
-
-        if ($studentId <= 0 || $semester === '' || $schoolYear === '' || $date === '') {
-            return redirect()->back()->withInput()->with('error', 'Missing required fields.');
-        }
-
-        $context = $this->fetchBelowSixtyMeetingContext($studentId, $schoolYear, $semester);
-        if (empty($context)) {
-            return redirect()->back()->withInput()->with('error', 'Student record not found for the selected term.');
-        }
-
-        $studentName = $context['student_name'];
-        $parentName = $context['parent_name'];
-        $classSection = $context['class_section_name'];
-        $timeLabel = $time !== '' ? (' ' . $time) : '';
-
-        $title = 'Parent Meeting: ' . $parentName . ' — ' . $studentName;
-        if ($time !== '') {
-            $title .= ' (' . $time . ')';
-        }
-
-        $descriptionParts = [];
-        $descriptionParts[] = 'Student: ' . $studentName;
-        $descriptionParts[] = 'Parent: ' . $parentName;
-        if ($classSection !== '') {
-            $descriptionParts[] = 'Section: ' . $classSection;
-        }
-        $descriptionParts[] = 'Date/Time: ' . $date . $timeLabel;
-        if ($notes !== '') {
-            $descriptionParts[] = 'Notes: ' . $notes;
-        }
-        $description = implode("\n", $descriptionParts);
-
-        $data = [
-            'student_id' => $studentId,
-            'parent_user_id' => $context['parent_user_id'] ?? null,
-            'parent_name' => $parentName,
-            'student_name' => $studentName,
-            'class_section_name' => $classSection,
-            'date' => $date,
-            'time' => $time !== '' ? $time : null,
-            'notes' => $notes !== '' ? $notes : null,
-            'semester' => $semester,
-            'school_year' => $schoolYear,
-            'status' => 'scheduled',
-            'created_by' => (int)(session()->get('user_id') ?? 0) ?: null,
-        ];
-
-        $ok = $this->parentMeetingModel->insert($data);
-        if ($ok) {
-            $query = http_build_query([
-                'semester' => $semester,
-                'school_year' => $schoolYear,
-            ]);
-            return redirect()->to(base_url('grading/below-60') . ($query ? ('?' . $query) : ''))
-                ->with('status', 'Meeting scheduled and added to calendars.');
-        }
-
-        return redirect()->back()->withInput()->with('error', 'Failed to schedule the meeting.');
-    }
-
-    public function toggleParentScoresRelease()
-    {
-        $semester = (string) ($this->request->getPost('semester') ?? '');
-        if ($semester === '') {
-            $semester = (string) (session()->get('grading_selected_semester') ?? $this->semester);
-        }
-        $configKey = $this->getParentReleaseKey($semester) ?? 'parent_scores_released';
-
-        $releaseScoresRaw = (string) ($this->configModel->getConfig($configKey) ?? '');
-        $scoresReleased = in_array(strtolower(trim($releaseScoresRaw)), ['1', 'true', 'yes', 'y', 'on'], true);
-        $nextValue = $scoresReleased ? '0' : '1';
-
-        $ok = $this->configModel->setConfigValueByKey($configKey, $nextValue);
-        log_message('info', 'toggleParentScoresRelease', [
-            'semester' => $semester,
-            'config_key' => $configKey,
-            'prev' => $releaseScoresRaw,
-            'next' => $nextValue,
-            'ok' => $ok,
-        ]);
-
-        if ($ok) {
-            $msg = $scoresReleased
-                ? 'Parent exam/semester scores are now hidden.'
-                : 'Parent exam/semester scores are now released.';
-            $msg .= ' (' . $configKey . '=' . $nextValue . ')';
-            return redirect()->back()->with('status', $msg);
-        }
-
-        return redirect()->back()->with('error', 'Unable to update the scores release flag.');
-    }
-
-    private function getParentReleaseKey(string $semester): ?string
-    {
-        $norm = strtolower(trim((string) $semester));
-        if ($norm === 'fall') {
-            return 'parent_scores_released_fall';
-        }
-        if ($norm === 'spring') {
-            return 'parent_scores_released_spring';
-        }
-        return null;
-    }
-
-    private function getParentScoresReleasedForSemester(string $semester): bool
-    {
-        $key = $this->getParentReleaseKey($semester);
-        $raw = $key ? $this->configModel->getConfig($key) : null;
-        $raw = (string) ($raw ?? '');
-        return in_array(strtolower(trim($raw)), ['1', 'true', 'yes', 'y', 'on'], true);
-    }
-
-    private function ensureParentReleaseKeyExists(string $semester): void
-    {
-        $key = $this->getParentReleaseKey($semester);
-        if (!$key) {
-            return;
-        }
-        if ($this->configModel->getConfigValueByKey($key) === null) {
-            $this->configModel->setConfigValueByKey($key, '0');
-        }
-    }
-
-    public function refreshSemesterScores()
-    {
-        $classSectionId = (int) ($this->request->getPost('class_section_id') ?? 0);
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('error', 'Missing class section.');
-        }
-
-        $requestedSemester = (string) ($this->request->getPost('semester') ?? '');
-        $requestedYear = (string) ($this->request->getPost('school_year') ?? '');
-        $semester = $this->normalizeSemesterInput($requestedSemester) ?? $requestedSemester;
-        if ($semester === '') {
-            $semester = (string) $this->semester;
-        }
-        $schoolYear = trim($requestedYear) !== '' ? trim($requestedYear) : (string) $this->schoolYear;
-
-        $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId(
-            $classSectionId,
-            $semester,
-            $schoolYear
-        );
-        if (empty($studentTeacherInfo)) {
-            return redirect()->back()->with('error', 'No students found for this class/term.');
-        }
-
-        try {
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-            $this->refreshAttendanceComments($classSectionId, $semester, $schoolYear);
-        } catch (\Throwable $e) {
-            log_message('error', 'refreshSemesterScores failed: ' . $e->getMessage());
-            return redirect()->back()->with('error', 'Refresh failed. Check logs.');
-        }
-
-        return redirect()->back()->with('status', 'Semester scores refreshed for this class/term.');
-    }
-
-    private function refreshAttendanceComments(int $classSectionId, string $semester, string $schoolYear): void
-    {
-        helper('attendance_comment');
-
-        $scoreModel = new SemesterScoreModel();
-        $commentModel = new ScoreCommentModel();
-
-        $scoreRows = $scoreModel
-            ->select(['student_id', 'attendance_score'])
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        if (empty($scoreRows)) {
-            return;
-        }
-
-        $studentIds = array_values(array_unique(array_map(
-            static fn($row) => (int) ($row['student_id'] ?? 0),
-            $scoreRows
-        )));
-        $studentIds = array_values(array_filter($studentIds, static fn($id) => $id > 0));
-        if (empty($studentIds)) {
-            return;
-        }
-
-        $students = $this->studentModel
-            ->select(['id', 'firstname'])
-            ->whereIn('id', $studentIds)
-            ->findAll();
-        $nameMap = [];
-        foreach ($students as $st) {
-            $nameMap[(int)$st['id']] = (string) ($st['firstname'] ?? '');
-        }
-
-        $existing = $commentModel
-            ->where('score_type', 'attendance')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->whereIn('student_id', $studentIds)
-            ->findAll();
-        $existingByStudent = [];
-        foreach ($existing as $row) {
-            $existingByStudent[(int)$row['student_id']] = $row;
-        }
-
-        foreach ($scoreRows as $row) {
-            $sid = (int) ($row['student_id'] ?? 0);
-            if ($sid <= 0) {
-                continue;
-            }
-            $score = isset($row['attendance_score']) ? (float) $row['attendance_score'] : null;
-            if ($score === null) {
-                continue;
-            }
-            $auto = attendance_comment_from_score($score, $nameMap[$sid] ?? '');
-            if ($auto === null) {
-                continue;
-            }
-
-            if (isset($existingByStudent[$sid])) {
-                $commentModel->update($existingByStudent[$sid]['id'], [
-                    'comment' => $auto,
-                ]);
-            } else {
-                $commentModel->insert([
-                    'student_id'       => $sid,
-                    'class_section_id' => $classSectionId,
-                    'score_type'       => 'attendance',
-                    'semester'         => $semester,
-                    'school_year'      => $schoolYear,
-                    'comment'          => $auto,
-                    'commented_by'     => null,
-                    'created_at'       => utc_now(),
-                ]);
-            }
-        }
-    }
-
-    /**
-     * Build grading rows with PTAP and semester scores (business + pk join).
-     *
-     * @param string $semEsc Escaped semester string for SQL
-     * @param string $yrEsc  Escaped school year string for SQL
-     * @param string $schoolYear Raw school year value for filtering student_class
-     * @return array
-     */
-    private function buildGradingRows(string $semEsc, string $yrEsc, string $schoolYear): array
-    {
-        $builder = $this->db->table('student_class sc')
-            ->select([
-                'cs.id                         AS section_pk',
-                'cs.class_section_id           AS section_id',      // BUSINESS id used in URLs
-                'cs.class_id                   AS class_id',        // 13=KG, 1..11=Grade N, 12=Youth
-                'cs.class_section_name',
-                's.id                          AS student_id',
-                's.school_id',
-                's.firstname',
-                's.lastname',
-                'pl.level                    AS placement_level',
-
-                // Prefer business-id match; fall back to pk match
-                'COALESCE(ss_b.ptap_score, ss_p.ptap_score)          AS ss_ptap_score',
-                'COALESCE(ss_b.semester_score, ss_p.semester_score)  AS ss_semester_score',
-                'COALESCE(ss_b.attendance_score, ss_p.attendance_score) AS ss_attendance_score',
-                'COALESCE(ss_b.homework_avg, ss_p.homework_avg)      AS ss_homework_avg',
-                'COALESCE(ss_b.project_avg, ss_p.project_avg)        AS ss_project_avg',
-                'COALESCE(ss_b.quiz_avg, ss_p.quiz_avg)              AS ss_quiz_avg',
-                'COALESCE(ss_b.participation_score, ss_p.participation_score) AS ss_participation_score',
-                'COALESCE(ss_b.midterm_exam_score, ss_p.midterm_exam_score)   AS ss_midterm_exam_score',
-                'COALESCE(ss_b.final_exam_score, ss_p.final_exam_score)       AS ss_final_exam_score',
-                // helpful to debug what matched:
-                'ss_b.class_section_id        AS matched_biz_csid',
-                'ss_p.class_section_id        AS matched_pk_csid'
-            ])
-            ->join('`classSection` cs', 'cs.class_section_id = sc.class_section_id', 'left')
-            ->join('students s', 's.id = sc.student_id', 'inner')
-            ->join(
-                'placement_levels pl',
-                "pl.student_id = s.id AND pl.school_year = {$yrEsc}",
-                'left'
-            )
-
-            // business-id join
-            ->join(
-                'semester_scores ss_b',
-                "ss_b.student_id = s.id
-             AND ss_b.class_section_id = sc.class_section_id
-             AND LOWER(ss_b.semester) = LOWER(TRIM({$semEsc}))
-             AND ss_b.school_year = {$yrEsc}",
-                'left'
-            )
-            // pk join
-            ->join(
-                'semester_scores ss_p',
-                "ss_p.student_id = s.id
-             AND ss_p.class_section_id = cs.id
-             AND LOWER(ss_p.semester) = LOWER(TRIM({$semEsc}))
-             AND ss_p.school_year = {$yrEsc}",
-                'left'
-            )
-            ->where('sc.school_year', $schoolYear)
-            ->where('s.is_active', 1); // Exclude removed/inactive students
-
-        return $builder
-            ->orderBy('cs.class_id', 'ASC')
-            ->orderBy('cs.class_section_name', 'ASC')
-            ->orderBy('s.lastname', 'ASC')
-            ->orderBy('s.firstname', 'ASC')
-            ->get()->getResultArray();
-    }
-
-    private function calculateAttendanceScoreForStudent(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): ?float
-    {
-        try {
-            $result = $this->attendanceCalculator->calculate($studentId, $semester, $schoolYear, $classSectionId);
-            $score = $result['attendance_score'] ?? null;
-            if ($score === null || $score === '') {
-                return null;
-            }
-            return round((float) $score, 2);
-        } catch (\Throwable $e) {
-            log_message(
-                'error',
-                'GradingController::calculateAttendanceScoreForStudent failed for '
-                . "student {$studentId}: " . $e->getMessage()
-            );
-        }
-        return null;
-    }
-
-    private function normalizeSemesterInput(?string $semester): ?string
-    {
-        if (!is_string($semester)) {
-            return null;
-        }
-        $trimmed = trim($semester);
-        return $trimmed === '' ? null : $trimmed;
-    }
-
-    private function resolveSemesterSelection(?string $requestedSemester, array $semesterOptions, ?string $fallbackSemester): string
-    {
-        if ($requestedSemester !== null) {
-            foreach ($semesterOptions as $option) {
-                if (strcasecmp($option, $requestedSemester) === 0) {
-                    return $option;
-                }
-            }
-            return $requestedSemester;
-        }
-        if ($fallbackSemester !== null && $fallbackSemester !== '') {
-            foreach ($semesterOptions as $option) {
-                if (strcasecmp($option, $fallbackSemester) === 0) {
-                    return $option;
-                }
-            }
-            return $fallbackSemester;
-        }
-        return $semesterOptions[0] ?? '';
-    }
-
-    private function getSemestersForSchoolYear(string $schoolYear, ?string $fallbackSemester = null): array
-    {
-        $rows = $this->db->table('semester_scores')
-            ->select('DISTINCT semester', false)
-            ->where('semester IS NOT NULL', null, false)
-            ->where('semester != ""', null, false)
-            ->where('school_year', $schoolYear)
-            ->orderBy('semester', 'ASC')
-            ->get()
-            ->getResultArray();
-
-        $semesters = [];
-        foreach ($rows as $row) {
-            $value = trim((string) ($row['semester'] ?? ''));
-            if ($value === '') continue;
-            $semesters[] = $value;
-        }
-
-        if (empty($semesters)) {
-            $semesters = ['Fall', 'Spring'];
-        }
-
-        if ($fallbackSemester !== null && $fallbackSemester !== '' && !in_array($fallbackSemester, $semesters, true)) {
-            array_unshift($semesters, $fallbackSemester);
-        }
-
-        return array_values(array_unique($semesters));
-    }
-
-    private function getSchoolYearsForScores(?string $fallback = null): array
-    {
-        $schoolYears = [];
-        try {
-            $rows = $this->db->table('semester_scores')
-                ->select('DISTINCT school_year', false)
-                ->where('school_year IS NOT NULL', null, false)
-                ->where('school_year != ""', null, false)
-                ->orderBy('school_year', 'DESC')
-                ->get()
-                ->getResultArray();
-            foreach ($rows as $row) {
-                $val = (string)($row['school_year'] ?? '');
-                if ($val !== '') $schoolYears[] = $val;
-            }
-        } catch (\Throwable $e) {
-        }
-        try {
-            $rows2 = $this->db->table('student_class')
-                ->select('DISTINCT school_year', false)
-                ->where('school_year IS NOT NULL', null, false)
-                ->where('school_year != ""', null, false)
-                ->orderBy('school_year', 'DESC')
-                ->get()
-                ->getResultArray();
-            foreach ($rows2 as $row) {
-                $val = (string)($row['school_year'] ?? '');
-                if ($val !== '' && !in_array($val, $schoolYears, true)) $schoolYears[] = $val;
-            }
-        } catch (\Throwable $e) {
-        }
-        if ($fallback && !in_array($fallback, $schoolYears, true)) {
-            array_unshift($schoolYears, $fallback);
-        }
-        return array_values(array_unique($schoolYears));
-    }
-
-    private function fetchBelowSixtyRows(string $schoolYear, string $semester): array
-    {
-        $semesterKey = strtolower(trim($semester));
-        $rows = $this->db->table('semester_scores ss')
-            ->select([
-                's.id AS student_id',
-                's.school_id',
-                's.firstname',
-                's.lastname',
-                'cs.class_section_name',
-                'ss.homework_avg',
-                'ss.project_avg',
-                'ss.participation_score',
-                'COALESCE(ss.test_avg, ss.quiz_avg) AS test_avg',
-                'ss.ptap_score',
-                'ss.attendance_score',
-                'ss.midterm_exam_score',
-                'ss.final_exam_score',
-                'ss.semester_score',
-            ])
-            ->join('students s', 's.id = ss.student_id', 'inner')
-            ->join('classSection cs', 'cs.class_section_id = ss.class_section_id', 'left')
-            ->where('s.is_active', 1)
-            ->where('ss.school_year', $schoolYear)
-            ->where("LOWER(TRIM(ss.semester))", $semesterKey)
-            ->where('ss.semester_score IS NOT NULL', null, false)
-            ->where('ss.semester_score <', 60)
-            ->orderBy('s.lastname', 'ASC')
-            ->orderBy('s.firstname', 'ASC')
-            ->get()
-            ->getResultArray();
-
-        if (empty($rows)) {
-            return [];
-        }
-
-        $studentIds = array_values(array_unique(array_map(
-            static fn($r) => (int)($r['student_id'] ?? 0),
-            $rows
-        )));
-        $studentIds = array_values(array_filter($studentIds, static fn($id) => $id > 0));
-
-        $commentMap = [];
-        if (!empty($studentIds)) {
-            $commentRows = $this->db->table('score_comments')
-                ->select('student_id, comment, created_at')
-                ->where('score_type', 'general')
-                ->where('school_year', $schoolYear)
-                ->where("LOWER(TRIM(semester))", $semesterKey)
-                ->whereIn('student_id', $studentIds)
-                ->orderBy('created_at', 'DESC')
-                ->get()
-                ->getResultArray();
-            foreach ($commentRows as $row) {
-                $sid = (int)($row['student_id'] ?? 0);
-                if ($sid > 0 && !isset($commentMap[$sid])) {
-                    $commentMap[$sid] = (string)($row['comment'] ?? '');
-                }
-            }
-        }
-
-        $statusMap = [];
-        if (!empty($studentIds)) {
-            $flagRows = $this->db->table('current_flag')
-                ->select('student_id, flag_state')
-                ->where('flag', 'grade')
-                ->where('school_year', $schoolYear)
-                ->where("LOWER(TRIM(semester))", $semesterKey)
-                ->whereIn('student_id', $studentIds)
-                ->get()
-                ->getResultArray();
-            foreach ($flagRows as $row) {
-                $sid = (int)($row['student_id'] ?? 0);
-                if ($sid <= 0) continue;
-                $statusMap[$sid] = (string)($row['flag_state'] ?? '');
-            }
-        }
-
-        foreach ($rows as &$row) {
-            $sid = (int)($row['student_id'] ?? 0);
-            $row['comment'] = $commentMap[$sid] ?? '';
-            $flagState = strtolower(trim((string)($statusMap[$sid] ?? '')));
-            $row['status'] = ($flagState === 'closed' || $flagState === 'canceled') ? 'Closed' : 'Open';
-        }
-        unset($row);
-
-        return $rows;
-    }
-
-    private function fetchBelowSixtyEmailRow(int $studentId, string $schoolYear, string $semester): array
-    {
-        $semesterKey = strtolower(trim($semester));
-        $row = $this->db->table('semester_scores ss')
-            ->select([
-                's.id AS student_id',
-                's.firstname',
-                's.lastname',
-                'cs.class_section_name',
-                'ss.homework_avg',
-                'ss.project_avg',
-                'ss.participation_score',
-                'COALESCE(ss.test_avg, ss.quiz_avg) AS test_avg',
-                'ss.ptap_score',
-                'ss.attendance_score',
-                'ss.midterm_exam_score',
-                'ss.semester_score',
-            ])
-            ->join('students s', 's.id = ss.student_id', 'inner')
-            ->join('classSection cs', 'cs.class_section_id = ss.class_section_id', 'left')
-            ->where('ss.school_year', $schoolYear)
-            ->where('ss.student_id', $studentId)
-            ->where('s.is_active', 1)
-            ->where("LOWER(TRIM(ss.semester))", $semesterKey)
-            ->get()
-            ->getRowArray();
-
-        if (!$row) return [];
-
-        $commentRow = $this->db->table('score_comments')
-            ->select('comment')
-            ->where('score_type', 'general')
-            ->where('school_year', $schoolYear)
-            ->where("LOWER(TRIM(semester))", $semesterKey)
-            ->where('student_id', $studentId)
-            ->orderBy('created_at', 'DESC')
-            ->get()
-            ->getRowArray();
-        $row['comment'] = (string)($commentRow['comment'] ?? '');
-
-        return $row;
-    }
-
-    private function userHasMenuUrl(string $needle): bool
-    {
-        $needle = strtolower(trim($needle));
-        if ($needle === '') {
-            return false;
-        }
-
-        $rawRole = session()->get('role');
-        $roles = is_array($rawRole) ? $rawRole : [$rawRole ?? 'guest'];
-        $roles = array_values(array_filter(array_map('strval', $roles)));
-        if (empty($roles)) {
-            return false;
-        }
-
-        $service = new NavbarService();
-        $menu = $service->getMenuForRoles($roles);
-        if (empty($menu)) {
-            return false;
-        }
-
-        $normalize = static function (string $url) use ($needle): string {
-            $url = strtolower(trim($url));
-            if ($url === '') return '';
-            $url = preg_replace('#^https?://[^/]+/#i', '', $url);
-            $url = ltrim($url, '/');
-            return $url;
-        };
-
-        $target = $normalize($needle);
-        $stack = $menu;
-        while (!empty($stack)) {
-            $node = array_shift($stack);
-            if (!empty($node['url'])) {
-                $url = $normalize((string)$node['url']);
-                if ($url !== '' && $url === $target) {
-                    return true;
-                }
-            }
-            if (!empty($node['children']) && is_array($node['children'])) {
-                foreach ($node['children'] as $child) {
-                    $stack[] = $child;
-                }
-            }
-        }
-
-        return false;
-    }
-
-    private function fetchBelowSixtyParentName(int $studentId): string
-    {
-        $parentName = 'Parent/Guardian';
-        try {
-            $rows = $this->db->query(
-                "SELECT u.firstname, u.lastname
-                   FROM family_students fs
-                   JOIN family_guardians fg ON fg.family_id = fs.family_id
-                   JOIN users u ON u.id = fg.user_id
-                  WHERE fs.student_id = ?
-                  ORDER BY fg.is_primary DESC, u.lastname, u.firstname
-                  LIMIT 1",
-                [$studentId]
-            )->getResultArray();
-            if (!empty($rows[0])) {
-                $candidate = trim((string)($rows[0]['firstname'] ?? '') . ' ' . (string)($rows[0]['lastname'] ?? ''));
-                if ($candidate !== '') {
-                    $parentName = $candidate;
-                }
-            }
-        } catch (\Throwable $e) {
-        }
-        return $parentName;
-    }
-
-    private function buildBelowSixtySubject(string $studentName, string $semester, string $schoolYear): string
-    {
-        $subject = 'Student Performance Alert';
-        if ($studentName !== '') {
-            $subject .= ' — ' . $studentName;
-        }
-        if ($semester !== '' || $schoolYear !== '') {
-            $subject .= ' (' . trim($semester . ' ' . $schoolYear) . ')';
-        }
-        return $subject;
-    }
-
-    private function fetchBelowSixtyMeetingContext(int $studentId, string $schoolYear, string $semester): array
-    {
-        $row = $this->fetchBelowSixtyEmailRow($studentId, $schoolYear, $semester);
-        if (empty($row)) {
-            return [];
-        }
-
-        $db = $this->db;
-        $parentName = 'Parent/Guardian';
-        $parentUserId = null;
-        try {
-            $pRows = $db->query(
-                "SELECT u.id AS user_id, u.firstname, u.lastname
-                   FROM family_students fs
-                   JOIN family_guardians fg ON fg.family_id = fs.family_id
-                   JOIN users u ON u.id = fg.user_id
-                  WHERE fs.student_id = ?
-                  ORDER BY fg.is_primary DESC, u.lastname, u.firstname
-                  LIMIT 1",
-                [$studentId]
-            )->getResultArray();
-            if (!empty($pRows[0])) {
-                $parentUserId = (int)($pRows[0]['user_id'] ?? 0) ?: null;
-                $parentName = trim((string)($pRows[0]['firstname'] ?? '') . ' ' . (string)($pRows[0]['lastname'] ?? ''));
-                if ($parentName === '') {
-                    $parentName = 'Parent/Guardian';
-                }
-            }
-        } catch (\Throwable $e) {
-        }
-
-        // Legacy fallback: students.parent_id
-        if ($parentUserId === null) {
-            try {
-                $srow = $db->query(
-                    "SELECT s.parent_id, u.firstname, u.lastname
-                       FROM students s
-                       LEFT JOIN users u ON u.id = s.parent_id
-                      WHERE s.id = ?
-                      LIMIT 1",
-                    [$studentId]
-                )->getRowArray();
-                if (!empty($srow)) {
-                    $parentUserId = (int)($srow['parent_id'] ?? 0) ?: null;
-                    $fallbackName = trim((string)($srow['firstname'] ?? '') . ' ' . (string)($srow['lastname'] ?? ''));
-                    if ($fallbackName !== '') {
-                        $parentName = $fallbackName;
-                    }
-                }
-            } catch (\Throwable $e) {
-            }
-        }
-
-        $studentName = trim((string)($row['firstname'] ?? '') . ' ' . (string)($row['lastname'] ?? ''));
-        return [
-            'student_name' => $studentName !== '' ? $studentName : 'Student',
-            'parent_name' => $parentName,
-            'parent_user_id' => $parentUserId,
-            'class_section_name' => (string)($row['class_section_name'] ?? ''),
-        ];
-    }
-
-
-    /**
-     * Parses a classSection name into a (classId, label) pair compatible with your Attendance view.
-     * - KG   -> (0, 'KG')
-     * - Youth-> (13, 'Youth')
-     * - Grade N -> (N, 'Grade N')
-     * Fallback: tries to extract first number; else returns (99, original).
-     */
-    private function parseClassIdFromSectionName(string $name): array
-    {
-        $n = trim($name);
-
-        // Common patterns used in your data
-        if (preg_match('/\bKG\b/i', $n)) {
-            return [0, 'KG'];
-        }
-        if (preg_match('/\bYouth\b/i', $n)) {
-            return [13, 'Youth'];
-        }
-        if (preg_match('/Grade\s*(\d+)/i', $n, $m)) {
-            $g = (int)$m[1];
-            return [$g, 'Grade ' . $g];
-        }
-
-        // Fallback: any number present becomes the grade id
-        if (preg_match('/(\d+)/', $n, $m2)) {
-            $g = (int)$m2[1];
-            return [$g, 'Grade ' . $g];
-        }
-
-        // Last fallback
-        return [99, $n];
-    }
-
-
-
-
-    /**
-     * Resolve class_section_id for a student in the current term.
-     */
-    private function resolveClassSectionIdForStudent(int $studentId): int
-    {
-        $row = $this->db->table('student_class')
-            ->select('class_section_id')
-            ->where('student_id', $studentId)
-            ->where('school_year', $this->schoolYear)
-            ->where('semester', $this->semester)
-            ->get()->getRow();
-
-        return $row ? (int)$row->class_section_id : 0;
-    }
-
-    /** Simple slugifier used as array keys for tabs */
-    private function slugify(string $s): string
-    {
-        $s = strtolower($s);
-        $s = preg_replace('/[^a-z0-9]+/i', '-', $s);
-        return trim($s, '-');
-    }
-
-    /** Rank: KG first, numbers ascending, Youth last */
-    private function rankOf(string $name): int
-    {
-        $k = strtolower(trim($name));
-        if ($k === 'kg' || $k === 'kindergarten') return -100;
-        if ($k === 'youth') return 100000;
-        if (preg_match('/\d+/', $k, $m)) return (int)$m[0];
-        return 50000;
-    }
-
-
-    public function getScoreComment()
-    {
-        // Get all students for the current semester and school year
-        $studentClassEntries = $this->studentClassModel
-            ->where('semester', $this->semester)
-            ->where('school_year', $this->schoolYear)
-            ->findAll();
-
-        // Group student IDs
-        $studentIds = array_map(fn($entry) => $entry['student_id'], $studentClassEntries);
-
-        // Fetch all scores and comments for the students
-        $scoresAndComments = $this->getAllScoresAndComments($studentIds, $this->semester, $this->schoolYear);
-
-        return $scoresAndComments;
-    }
-
-    /**
-     * Fetch all scores and comments for a list of students based on semester and school year.
-     *
-     * @param array $studentIds List of student IDs.
-     * @param string $semester Current semester (e.g., 'fall', 'spring').
-     * @param string $schoolYear Current school year (e.g., '2025-2026').
-     * @return array
-     */
-    private function getAllScoresAndComments($studentIds, $semester, $schoolYear)
-    {
-        // Validate input parameters
-        if (empty($studentIds) || !is_array($studentIds)) {
-            return [];
-        }
-
-        if (empty($this->semester) || empty($this->schoolYear)) {
-            throw new \InvalidArgumentException('Semester and school year must be provided');
-        }
-
-        // Initialize models
-        $models = [
-            'final_exam' => new FinalExamModel(),
-            'homework' => new HomeworkModel(),
-            'midterm' => new MidtermExamModel(),
-            'project' => new ProjectModel(),
-            'quiz' => new QuizModel(),
-            'comments' => new ScoreCommentModel(),
-            'semester_scores' => new SemesterScoreModel(),
-            'student' => new StudentModel(),
-            'student_class' => new StudentClassModel(),
-            'teacher_class' => new TeacherClassModel(),
-            'config' => new ConfigurationModel(),
-            'attendance' => new AttendanceRecordModel()
-        ];
-
-        // Get semester days configuration
-        $semesterKey = strtolower($semester) === 'fall' ? 'total_semester1_days' : 'total_semester2_days';
-        $totalSemesterDays = $models['config']->getConfig($semesterKey) ?? 0;
-
-        // Common query conditions
-        $conditions = [
-            'semester' => $this->semester,
-            'school_year' => $this->schoolYear
-        ];
-
-        // Fetch all student data first
-        $students = $models['student']->whereIn('id', $studentIds)
-            ->where('school_year', $this->schoolYear)
-            ->findAll();
-
-        if (empty($students)) {
-            return [];
-        }
-
-        // Initialize result array with student data
-        $allScores = [];
-        foreach ($students as $student) {
-            $className = $models['student_class']->getClassSectionsByStudentId($student['id'], $this->schoolYear);
-            $updatedBy = $models['teacher_class']->getTeacherIdByClassSection($className, $this->semester, $this->schoolYear);
-
-            $allScores[$student['id']] = [
-                'school_id' => $student['school_id'],
-                'firstname' => $student['firstname'],
-                'lastname' => $student['lastname'],
-                'class_name' => $className,
-                //'teacherId' => $updatedBy,
-                'comments' => [] // Initialize empty comments array
-            ];
-        }
-
-        // Fetch and process attendance data
-        foreach ($studentIds as $studentId) {
-            if (!isset($allScores[$studentId])) continue;
-
-            $absences = $models['attendance']->getTotalAbsences($studentId, $this->semester, $this->schoolYear);
-            $attendance = min((($totalSemesterDays - $absences + 1) / $totalSemesterDays) * 100, 100);
-
-            $allScores[$studentId]['attendance'] = [
-                'score' => round($attendance, 2),
-                'absences' => $absences,
-                'total_days' => $totalSemesterDays
-            ];
-        }
-
-        // Fetch and process all score types
-        $scoreTypes = [
-            'final_exam' => $models['final_exam'],
-            'homework' => $models['homework'],
-            'midterm' => $models['midterm'],
-            'project' => $models['project'],
-            'quiz' => $models['quiz'],
-            'semester_score' => $models['semester_scores']
-        ];
-
-        foreach ($scoreTypes as $type => $model) {
-            $scores = $model->whereIn('student_id', $studentIds)
-                ->where($conditions)
-                ->findAll();
-
-            foreach ($scores as $score) {
-                if ($type === 'semester_score') {
-                    $allScores[$score['student_id']][$type] = [
-                        'homework_avg' => $score['homework_avg'],
-                        'quiz_avg' => $score['quiz_avg'],
-                        'project_avg' => $score['project_avg'],
-                        'midterm_exam_score' => $score['midterm_exam_score'],
-                        'final_exam_score' => $score['final_exam_score'],
-                        'attendance_score' => $score['attendance_score'],
-                        'participation_score' => $score['participation_score'],
-                        'ptap_score' => $score['ptap_score'],
-                        'test_avg' => $score['test_avg'],
-                        'semester_score' => $score['semester_score'],
-                        'semester' => $score['semester'],
-                        'school_year' => $score['school_year']
-                    ];
-                } else {
-                    $allScores[$score['student_id']][$type] = $score;
-                }
-            }
-        }
-
-        // Fetch and process comments
-        $comments = $models['comments']->whereIn('student_id', $studentIds)
-            ->where($conditions)
-            ->findAll();
-
-        foreach ($comments as $comment) {
-            $allScores[$comment['student_id']]['comments'][] = $comment;
-        }
-
-        return $allScores;
-    }
-}
diff --git a/app/Http/Controllers/old/HomeworkController.php b/app/Http/Controllers/old/HomeworkController.php
deleted file mode 100644
index 47594e77..00000000
--- a/app/Http/Controllers/old/HomeworkController.php
+++ /dev/null
@@ -1,656 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Models\HomeworkModel;
-use App\Models\StudentModel;
-use App\Models\StudentClassModel;
-use CodeIgniter\Controller;
-use App\Models\TeacherClassModel;
-use App\Models\ConfigurationModel;
-use App\Models\UserModel;
-use RuntimeException;
-use App\Services\SemesterScoreService;
-use Config\Services;
-use App\Controllers\View\GradingController;
-use App\Models\GradingLockModel;
-use App\Models\MissingScoreOverrideModel;
-
-class HomeworkController extends Controller
-{
-    protected $db;
-    protected $semesterScoreService;
-    protected $configModel;
-    protected $homeworkModel;
-    protected $userModel;
-    protected $schoolYear;
-    protected $semester;
-    protected $studentClassModel;
-    protected $studentModel;
-    protected $teacherClassModel;
-    protected $gradingLockModel;
-    protected $missingScoreOverrideModel;
-
-    public function __construct()
-    {
-        $this->db = \Config\Database::connect();
-        $this->teacherClassModel = new TeacherClassModel();
-        $this->homeworkModel = new HomeworkModel();
-        $this->userModel = new UserModel();
-        $this->studentClassModel = new StudentClassModel();
-        $this->studentModel      = new StudentModel();
-        $this->configModel = new ConfigurationModel();
-
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester = $this->configModel->getConfig('semester');
-
-        // Log the service initialization
-        log_message('debug', 'Initializing SemesterScoreService');
-
-        //$this->semesterScoreService = Services::SemesterScoreService();
-        $this->semesterScoreService = service('semesterScoreService');
-        // $this->semesterScoreService = \Config\Services::semesterScoreService();   
-        $this->gradingLockModel = new GradingLockModel();
-        $this->missingScoreOverrideModel = new MissingScoreOverrideModel();
-
-        // Check if the service is null
-        if ($this->semesterScoreService === null) {
-            log_message('error', 'SemesterScoreService is null');
-        }
-    }
-
-    public function updateHomeworkScores(array $scores = null, int $updatedBy = null, int $classSectionId = null)
-    {
-        $scores = $this->request->getPost('scores');
-        $semester = $this->request->getPost('semester') ?? $this->semester;
-        $schoolYear = $this->request->getPost('school_year') ?? $this->schoolYear;
-
-        if ($updatedBy === null) {
-            $updatedBy = session()->get('user_id');
-        }
-        $classSectionId = $this->request->getPost('class_section_id') ?? session()->get('class_section_id');
-        $classSectionId = (int) ($classSectionId ?? 0);
-        if ($classSectionId > 0 && $this->isScoresLocked($classSectionId, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-
-        $missingOk = $this->request->getPost('missing_ok') ?? [];
-        $studentIds = is_array($scores) ? array_keys($scores) : array_keys((array) $missingOk);
-        $indexSet = [];
-        if (is_array($scores)) {
-            foreach ($scores as $studentId => $hwData) {
-                if (!is_array($hwData)) {
-                    continue;
-                }
-                foreach ($hwData as $index => $score) {
-                    if (is_numeric($index)) {
-                        $indexSet[(int)$index] = true;
-                    }
-                }
-            }
-        }
-        $checkedItems = [];
-        if (is_array($missingOk)) {
-            foreach ($missingOk as $studentId => $indexes) {
-                if (!is_array($indexes)) {
-                    continue;
-                }
-                foreach ($indexes as $index => $flag) {
-                    if (!is_numeric($index)) {
-                        continue;
-                    }
-                    $checkedItems[] = [
-                        'student_id' => (int) $studentId,
-                        'item_index' => (int) $index,
-                    ];
-                }
-            }
-        }
-        $this->missingScoreOverrideModel->replaceOverrides(
-            $classSectionId,
-            (string) $semester,
-            (string) $schoolYear,
-            'homework',
-            $studentIds,
-            array_keys($indexSet),
-            $checkedItems,
-            $updatedBy
-        );
-
-        if (is_array($scores)) {
-            foreach ($scores as $studentId => $hwData) {
-                if (!is_numeric($studentId)) continue;
-
-                $student = $this->studentModel->find($studentId);
-                if (!$student) continue;
-
-                foreach ($hwData as $index => $score) {
-                    $rawScore = $score ?? null;
-                    $isBlank = $rawScore === null || (is_string($rawScore) && trim($rawScore) === '');
-                    $normalizedScore = (!$isBlank && is_numeric($rawScore)) ? (float) $rawScore : null;
-
-                    // STEP 1: Always fetch the existing record
-                    $existing = $this->homeworkModel->where([
-                        'student_id'       => $studentId,
-                        'homework_index'   => $index,
-                        'class_section_id' => $classSectionId,
-                        //'teacher_id'       => $updatedBy,
-                        'semester'         => $semester,
-                        'school_year'      => $schoolYear,
-                    ])->first();
-
-                    // STEP 2: Save numeric score (blank -> null)
-                    $data = [
-                        'student_id'       => $studentId,
-                        'school_id'        => $student['school_id'] ?? '',
-                        'class_section_id' => $classSectionId,
-                        'updated_by'       => $updatedBy,
-                        'homework_index'   => $index,
-                        'score'            => $normalizedScore,
-                        'semester'         => $semester,
-                        'school_year'      => $schoolYear,
-                        'updated_at'       => utc_now(),
-                    ];
-
-                    if ($isBlank) {
-                        if ($existing) {
-                            $this->homeworkModel->update($existing['id'], $data);
-                            log_message('debug', "Updated homework ID {$existing['id']} with score null");
-                        } else {
-                            $data['created_at'] = utc_now();
-                            $this->homeworkModel->insert($data);
-                            log_message('debug', "Inserted blank homework for student $studentId index $index");
-                        }
-                        continue;
-                    }
-
-                    if ($existing) {
-                        $this->homeworkModel->update($existing['id'], $data);
-                        log_message('debug', "Updated homework ID {$existing['id']} with score {$normalizedScore}");
-                    } else {
-                        $data['created_at'] = utc_now();
-                        $this->homeworkModel->insert($data);
-                        log_message('debug', "Inserted score for student $studentId index $index");
-                    }
-                }
-            }
-        }
-        $studentUserInfo = $this->studentModel->getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear);
-
-        // Call the updateScoresForStudents method
-        try {
-            $this->semesterScoreService->updateScoresForStudents($studentUserInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-
-        return redirect()->to(base_url('/teacher/addHomework'))->with('status', 'Homework scores updated successfully.');
-    }
-
-
-    public function addNextHomeworkColumn()
-    {
-        $updatedBy = session()->get('user_id');
-        $classSectionId = session()->get('class_section_id');
-        $selectedSemester = $this->getSelectedSemester();
-        $normalized = $this->normalizeSemesterSelection($selectedSemester);
-        $semesterLabel = $normalized !== '' ? ucfirst($normalized) : $selectedSemester;
-
-        // Step 1: Get the highest existing homework_index
-        $existingIndexes = $this->homeworkModel
-            ->select('homework_index')
-            ->where('class_section_id', $classSectionId)
-            //->where('teacher_id', $updatedBy)
-            ->whereIn('semester', $this->getSemesterVariants($semesterLabel))
-            ->where('school_year', $this->schoolYear)
-            ->groupBy('homework_index')
-            ->orderBy('homework_index', 'DESC')
-            ->findAll();
-
-        $maxIndex = 0;
-        foreach ($existingIndexes as $row) {
-            if (isset($row['homework_index']) && is_numeric($row['homework_index'])) {
-                $maxIndex = max($maxIndex, (int)$row['homework_index']);
-            }
-        }
-
-        $nextIndex = $maxIndex + 1;
-
-        // Step 2: Get all students in the class
-        $students = $this->studentClassModel
-            ->where('class_section_id', $classSectionId)
-            ->findAll();
-
-        // Step 3: Insert a new homework row for each student if not already exists
-        $firstInsertedId = null;
-        foreach ($students as $i => $student) {
-            $studentId = $student['student_id'];
-
-            // Check if record already exists
-            $existing = $this->homeworkModel
-                ->where('student_id', $studentId)
-                ->where('homework_index', $nextIndex)
-                ->where('class_section_id', $classSectionId)
-                //->where('teacher_id', $updatedBy)
-                ->whereIn('semester', $this->getSemesterVariants($semesterLabel))
-                ->where('school_year', $this->schoolYear)
-                ->first();
-
-            if ($existing) continue;
-
-            $insertData = [
-                'student_id'       => $studentId,
-                'school_id'        => '', // Optional: populate if needed
-                'class_section_id' => $classSectionId,
-                'updated_by'       => $updatedBy,
-                'homework_index'   => $nextIndex,
-                'score'            => null,
-                'semester'         => $semesterLabel,
-                'school_year'      => $this->schoolYear,
-                'created_at'       => utc_now(),
-                'updated_at'       => utc_now()
-            ];
-
-            $id = $this->homeworkModel->insert($insertData, true);
-            if ($i === 0) {
-                $firstInsertedId = $id;
-            }
-        }
-
-        // Step 4: Return index and ID to frontend
-        return $this->response->setJSON([
-            'status' => 'success',
-            'homework_index' => $nextIndex,
-            'new_homework_id' => $firstInsertedId
-        ]);
-    }
-
-
-    public function showHomework()
-    {
-        $updatedBy = session()->get('user_id');
-        $classSectionId = $this->getClassSectionIdForTeacher($updatedBy);
-        if (!$classSectionId) {
-            return redirect()->back()->with('status', 'No class section found for the current teacher.');
-        }
-
-        session()->set('class_section_id', $classSectionId);
-
-        $semester = $this->getSelectedSemester();
-        $homeworkHeaders = $this->getHomeworkHeaders($classSectionId, $semester, $this->schoolYear);
-        if (empty($homeworkHeaders)) {
-            $homeworkHeaders = [1];
-        }
-        $students = $this->getStudentsWithHomeworkScores(
-            $classSectionId,
-            $homeworkHeaders,
-            $semester,
-            $this->schoolYear
-        );
-        $missingOkMap = $this->missingScoreOverrideModel->getOverridesMap($classSectionId, $semester, $this->schoolYear, 'homework');
-
-        return view('teacher/add_homework', [
-            'students'         => $students,
-            'homeworkHeaders'  => $homeworkHeaders,
-            'semester'         => $semester,
-            'schoolYear'       => $this->schoolYear,
-            'class_section_id' => $classSectionId,
-            'missingOkMap'     => $missingOkMap,
-        ]);
-    }
-
-    // In your GradingController (or the controller that owns this action)
-    public function showHomeworkMngt()
-    {
-        // Accept POST first, then GET (query string), then session fallback
-        $incomingId = $this->request->getPost('class_section_id');
-        if (!$incomingId) {
-            $incomingId = $this->request->getGet('class_section_id');
-        }
-
-        $classSectionId = (int) ($incomingId ?: (session()->get('class_section_id') ?? 0));
-
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('status', 'No class section found for the current teacher or selection.');
-        }
-        $updatedBy = (int) (session()->get('user_id') ?? 0);
-
-        $semesterParam = $this->request->getPost('semester')
-            ?? $this->request->getGet('semester')
-            ?? $this->request->getGet('filter');
-        $normalizedSemester = $this->normalizeSemesterSelection($semesterParam);
-        if ($normalizedSemester !== '') {
-            $label = ucfirst($normalizedSemester);
-            $session = session();
-            $session->set('teacher_scores_selected_semester', $label);
-            $session->set('semester', $label);
-        }
-
-        $schoolYearParam = $this->request->getPost('school_year') ?? $this->request->getGet('school_year');
-        $schoolYear = $this->normalizeSchoolYear($schoolYearParam) ?? $this->schoolYear;
-        /*
-    // OPTIONAL (recommended): ensure the classSectionId belongs to this teacher for the active term
-    $updatedBy = (int) (session()->get('user_id') ?? 0);
-    if ($updatedBy > 0) {
-        // If you have a TeacherClassModel with new schema (position = 'main' or 'ta'):
-        $isOwned = $this->teacherClassModel
-            ->where('teacher_id', $updatedBy)
-            ->where('class_section_id', $classSectionId)
-            ->where('school_year', $this->schoolYear)
-            ->where('semester', $this->semester)
-            ->countAllResults() > 0;
-
-        if (!$isOwned) {
-            return redirect()->back()->with('status', 'You do not have access to that class section.');
-        }
-    }
-*/
-        // Persist chosen class section in the session
-        session()->set('class_section_id', $classSectionId);
-
-        // Load data for the view
-        $semester = $this->getSelectedSemester();
-        $homeworkScores  = $this->getHomeworkScoresByStudent($classSectionId, $semester, $schoolYear);
-        $students        = $this->getStudentsByClassSectionAndYear($classSectionId, $schoolYear);
-        $homeworkHeaders = $this->getHomeworkHeaders($classSectionId, $semester, $schoolYear);
-        $scoresLocked    = $this->isScoresLocked($classSectionId, $semester, $schoolYear);
-
-        // Render
-        return view('grading/homework', [
-            'homeworkScores'  => $homeworkScores,
-            'students'        => $students,
-            'semester'        => $semester,
-            'schoolYear'      => $schoolYear,
-            'homeworkHeaders' => $homeworkHeaders,
-            'classSectionId'  => $classSectionId,
-            'hasHomeworkCols' => !empty($homeworkHeaders),
-            'isManagement'    => true,
-            'scoresLocked'    => $scoresLocked,
-        ]);
-    }
-
-
-    public function updateHomework()
-    {
-        $scores       = $this->request->getPost('scores');
-        $studentIds   = $this->request->getPost('student_ids');
-        $semester     = $this->request->getPost('semester') ?? $this->getSelectedSemester();
-        $schoolYear   = $this->request->getPost('school_year') ?? $this->schoolYear;
-
-        $updatedBy = $this->request->getPost('teacher_id') ?? session()->get('user_id');
-        $classSectionId = $this->request->getPost('class_section_id') ?? session()->get('class_section_id'); // persisted in showHomeworkMngt
-        $classSectionIdInt = (int) ($classSectionId ?? 0);
-        if ($classSectionIdInt > 0 && $this->isScoresLocked($classSectionIdInt, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-
-        if ($scores && $studentIds && $semester && $schoolYear && $classSectionId) {
-            $this->updateHomeworkScores($scores, $updatedBy, $classSectionId);
-            session()->setFlashdata('status', 'Homework scores updated successfully.');
-
-            // ⬇️ Directly call the method and return its view
-            return $this->showHomeworkMngt($updatedBy);
-        }
-
-        $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId($classSectionId);
-        // Call the updateScoresForStudents method
-        try {
-
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-        return redirect()->back()->with('status', 'Failed to update scores.');
-    }
-
-    private function isScoresLocked(int $classSectionId, string $semester, string $schoolYear): bool
-    {
-        return $this->gradingLockModel->isLocked($classSectionId, $semester, $schoolYear);
-    }
-
-    // ──────────────── Helpers ────────────────
-
-    private function saveHomeworkScores(array $scores, array $studentIds, string $semester, string $schoolYear, int $updatedBy, int $classSectionId)
-    {
-        $now = utc_now();
-
-        foreach ($studentIds as $studentId) {
-            if (!isset($scores[$studentId])) {
-                continue;
-            }
-
-            foreach ($scores[$studentId] as $index => $score) {
-                $isBlank = $score === null || (is_string($score) && trim($score) === '');
-
-                // Check if the record exists
-                $existing = $this->homeworkModel
-                    ->where('student_id', $studentId)
-                    ->where('homework_index', $index)
-                    ->where('semester', $semester)
-                    ->where('school_year', $schoolYear)
-                    ->where('class_section_id', $classSectionId)
-                    //->where('teacher_id', $updatedBy)
-                    ->first();
-
-                if ($isBlank) {
-                    if ($existing) {
-                        $this->homeworkModel->update($existing['id'], [
-                            'score'      => null,
-                            'updated_by' => $updatedBy,
-                            'updated_at' => $now,
-                        ]);
-                    } else {
-                        $this->homeworkModel->insert([
-                            'student_id'       => $studentId,
-                            'class_section_id' => $classSectionId,
-                            'updated_by'       => $updatedBy,
-                            'homework_index'   => $index,
-                            'score'            => null,
-                            'semester'         => $semester,
-                            'school_year'      => $schoolYear,
-                            'created_at'       => $now,
-                            'updated_at'       => $now,
-                        ]);
-                    }
-                    continue;
-                }
-
-                $data = [
-                    'student_id'       => $studentId,
-                    'class_section_id' => $classSectionId,
-                    'updated_by'       => $updatedBy,
-                    'homework_index'   => $index,
-                    'score'            => is_numeric($score) ? floatval($score) : null,
-                    'semester'         => $semester,
-                    'school_year'      => $schoolYear,
-                    'updated_at'       => $now,
-                ];
-
-                if ($existing) {
-                    $this->homeworkModel->update($existing['id'], $data);
-                } else {
-                    $data['created_at'] = $now;
-                    $data['school_id'] = ''; // Set if needed
-                    $this->homeworkModel->insert($data);
-                }
-            }
-        }
-    }
-
-    private function getStudentsByClassSectionAndYear($classSectionId, $schoolYear)
-    {
-        // Step 1: Get student IDs from student_class table
-        $studentClassRows = $this->studentClassModel
-            ->select('student_id')
-            ->where('class_section_id', $classSectionId)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        $studentIds = array_column($studentClassRows, 'student_id');
-
-        if (empty($studentIds)) {
-            return []; // No students found
-        }
-
-        // Step 2: Get student data from students table
-        $students = $this->studentModel
-            ->whereIn('id', $studentIds)
-            ->where('is_active', 1)
-            ->orderBy('lastname', 'ASC')
-            ->findAll();
-
-        return $students;
-    }
-
-    private function getClassSectionIdForTeacher($updatedBy)
-    {
-        $class = $this->teacherClassModel->where('teacher_id', $updatedBy)->first();
-        return $class['class_section_id'] ?? null;
-    }
-
-
-    private function getHomeworkScoresByStudent($classSectionId, $semester, $schoolYear)
-    {
-        $semVariants = $this->getSemesterVariants($semester);
-        $rows = $this->homeworkModel
-            ->select('student_id, homework_index, score')
-            ->where('class_section_id', $classSectionId)
-            ->whereIn('semester', $semVariants)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        $studentScores = [];
-        foreach ($rows as $row) {
-            $studentId = $row['student_id'];
-            $index = $row['homework_index'];
-            $score = $row['score'];
-
-            $studentScores[$studentId]['scores'][$index] = $score;
-        }
-
-        return $studentScores;
-    }
-
-    private function getStudentsWithHomeworkScores($classSectionId, $homeworkHeaders, $semester, $schoolYear)
-    {
-        $semVariants = $this->getSemesterVariants($semester);
-        $studentClasses = $this->studentClassModel
-            ->active()
-            ->where('student_class.class_section_id', $classSectionId)
-            ->findAll();
-        $students = [];
-
-        foreach ($studentClasses as $sc) {
-            $student = $this->studentModel
-                ->where('id', $sc['student_id'])
-                ->where('is_active', 1)
-                ->first();
-            if (!$student) continue;
-
-            $scores = [];
-                foreach ($homeworkHeaders as $ids) {
-                    $entry = $this->homeworkModel->where('homework_index', $ids)
-                        ->where('student_id', $sc['student_id'])
-                        ->where('class_section_id', $classSectionId)
-                        ->whereIn('semester', $semVariants)
-                        ->where('school_year', $schoolYear)
-                        ->first();
-                // Keep null/blank when no entry exists yet
-                $scores[$ids] = $entry['score'] ?? null;
-            }
-
-            $students[] = [
-                'student_id' => $sc['student_id'],
-                'firstname'  => $student['firstname'],
-                'lastname'   => $student['lastname'],
-                'scores'     => $scores
-            ];
-        }
-
-        usort($students, fn($a, $b) => strcmp($a['lastname'], $b['lastname']) ?: strcmp($a['firstname'], $b['firstname']));
-        return $students;
-    }
-
-    private function getHomeworkHeaders($classSectionId, $semester, $schoolYear)
-    {
-
-        $semVariants = $this->getSemesterVariants($semester);
-        $rows = $this->homeworkModel
-            ->select('homework_index')
-            ->where('class_section_id', $classSectionId)
-            //->where('teacher_id', $updatedBy)
-            ->whereIn('semester', $semVariants)
-            ->where('school_year', $schoolYear)
-            ->orderBy('homework_index', 'ASC')
-            ->findAll();
-
-        $headers = [];
-
-        foreach ($rows as $row) {
-            $index = $row['homework_index'];
-            if (!is_array($index)) {
-                $headers[$index] = true;
-            }
-        }
-
-        ksort($headers);
-        return array_keys($headers);
-    }
-
-    private function getSemesterVariants(?string $semester): array
-    {
-        $raw = trim((string) $semester);
-        $variants = [
-            $raw,
-            strtolower($raw),
-            ucfirst(strtolower($raw)),
-        ];
-        $normalized = $this->normalizeSemesterSelection($raw);
-        if ($normalized === 'fall') {
-            $variants[] = 'First Semester';
-            $variants[] = 'Semester 1';
-            $variants[] = '1st Semester';
-            $variants[] = 'Fall Semester';
-        } elseif ($normalized === 'spring') {
-            $variants[] = 'Second Semester';
-            $variants[] = 'Semester 2';
-            $variants[] = '2nd Semester';
-            $variants[] = 'Spring Semester';
-        }
-        return array_values(array_unique(array_filter($variants, static fn($v) => $v !== '')));
-    }
-
-    private function getSelectedSemester(): string
-    {
-        $session = session();
-        $selected = $session->get('teacher_scores_selected_semester');
-        if (!empty($selected)) {
-            return (string) $selected;
-        }
-        return $session->get('semester') ?? $this->semester;
-    }
-
-    private function normalizeSemesterSelection(?string $input): string
-    {
-        $value = strtolower(trim((string) $input));
-        if ($value === 'fall' || str_contains($value, '1')) {
-            return 'fall';
-        }
-        if ($value === 'spring' || str_contains($value, '2')) {
-            return 'spring';
-        }
-        return '';
-    }
-
-    private function normalizeSchoolYear(?string $input): ?string
-    {
-        $value = trim((string) $input);
-        if ($value === '') {
-            return null;
-        }
-        if (preg_match('/^\\d{4}\\s*[-\\/]\\s*\\d{4}$/', $value)) {
-            return preg_replace('/\\s+/', '', str_replace('/', '-', $value));
-        }
-        return null;
-    }
-}
diff --git a/app/Http/Controllers/old/HomeworkTrackingController.php b/app/Http/Controllers/old/HomeworkTrackingController.php
deleted file mode 100644
index 516941f9..00000000
--- a/app/Http/Controllers/old/HomeworkTrackingController.php
+++ /dev/null
@@ -1,289 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Controllers\BaseController;
-use App\Models\ConfigurationModel;
-use App\Models\CalendarModel;
-use App\Models\HomeworkModel;
-
-class HomeworkTrackingController extends BaseController
-{
-    protected $configModel;
-    protected $calendarModel;
-    protected $homeworkModel;
-    protected $db;
-
-    protected string $semester;
-    protected string $schoolYear;
-    /** cache for teacher assignment presence per term */
-    private array $teacherAssignmentCache = [];
-
-    public function __construct()
-    {
-        $this->configModel   = new ConfigurationModel();
-        $this->calendarModel = new CalendarModel();
-        $this->homeworkModel = new HomeworkModel();
-        $this->db            = \Config\Database::connect();
-
-        $this->semester   = (string) ($this->configModel->getConfig('semester') ?? '');
-        $this->schoolYear = (string) ($this->configModel->getConfig('school_year') ?? '');
-    }
-
-    public function index()
-    {
-        // Semester-based date range (Fall or Spring) derived from school year start.
-        [$start, $end] = $this->getDateRangeForSemester($this->schoolYear, $this->semester);
-
-        // Move start to the first Sunday on/after start
-        if ((int)$start->format('w') !== 0) {
-            $start = (clone $start)->modify('next sunday');
-        }
-
-        // Collect all Sundays within range
-        $sundays = [];
-        $d = clone $start;
-        while ($d <= $end) {
-            $sundays[] = $d->format('Y-m-d');
-            $d->modify('+7 days');
-        }
-
-        // Map "no school" events by date (Y-m-d) using explicit DB flag
-        $events    = $this->calendarModel->getEventsBySchoolYear($this->schoolYear) ?? [];
-        $eventDays = [];
-        foreach ($events as $ev) {
-            $ymd = substr((string)($ev['date'] ?? ''), 0, 10);
-            $no  = (int)($ev['no_school'] ?? 0);
-            if ($ymd && $no === 1) {
-                $eventDays[$ymd] = true; // yellow highlight for no-school day
-            }
-        }
-
-        // Map Sundays to ordinal homework_index, skipping event Sundays
-        $dateToIndex = [];
-        $idx = 0;
-        foreach ($sundays as $ymd) {
-            if (!isset($eventDays[$ymd])) {
-                $idx++;
-                $dateToIndex[$ymd] = $idx;
-            } else {
-                $dateToIndex[$ymd] = null; // event day (no homework expected)
-            }
-        }
-
-        $limitToSemester = $this->hasTeacherAssignments($this->schoolYear, $this->semester);
-
-        // Aggregate homework presence + first entered date per class_section_id + homework_index
-        $hwQ = $this->db->table('homework')
-            ->select('class_section_id, homework_index, MIN(created_at) AS first_created, COUNT(*) AS cnt')
-            ->where('school_year', $this->schoolYear);
-        if ($limitToSemester && $this->semester !== '') {
-            $hwQ->where('semester', $this->semester);
-        }
-        $rows = $hwQ->groupBy('class_section_id, homework_index')
-            ->get()
-            ->getResultArray();
-
-        $hasHomework = [];
-        $hwEnteredAt = [];
-        foreach ($rows as $r) {
-            $csid = (int)($r['class_section_id'] ?? 0);
-            $hi   = (int)($r['homework_index'] ?? 0);
-            $cnt  = (int)($r['cnt'] ?? 0);
-            if ($csid > 0 && $hi > 0 && $cnt > 0) {
-                $hasHomework[$csid][$hi] = true;
-                $dateStr = substr((string)($r['first_created'] ?? ''), 0, 10);
-                $hwEnteredAt[$csid][$hi] = $dateStr ?: null;
-            }
-        }
-
-        // Build date-based presence mapped to the nearest prior non-NoSchool Sunday.
-        $hb = $this->db->table('homework')
-            ->select("class_section_id, DATE(created_at) AS hw_date, MIN(created_at) AS first_created, COUNT(*) AS cnt", false)
-            ->where('school_year', $this->schoolYear);
-        if ($limitToSemester && $this->semester !== '') {
-            $hb->where('semester', $this->semester);
-        }
-        $rowsByDate = $hb->groupBy('class_section_id, DATE(created_at)', '', false)
-            ->orderBy('hw_date', 'ASC', false)
-            ->get()
-            ->getResultArray();
-
-        $hasHomeworkByDate = [];
-        $hwEnteredAtByDate = [];
-        foreach ($rowsByDate as $r) {
-            $csid = (int)($r['class_section_id'] ?? 0);
-            $d    = substr((string)($r['hw_date'] ?? ''), 0, 10);
-            $cnt  = (int)($r['cnt'] ?? 0);
-            $firstCreated = substr((string)($r['first_created'] ?? ''), 0, 10);
-            if ($csid <= 0 || !$d || $cnt <= 0) { continue; }
-
-            // Find the index of the last Sunday on or before $d
-            $baseIndex = -1;
-            for ($i = count($sundays) - 1; $i >= 0; $i--) {
-                if ($sundays[$i] <= $d) { $baseIndex = $i; break; }
-            }
-            if ($baseIndex < 0) { continue; }
-
-            // Map this homework day to only the nearest prior non–No School Sunday
-            $j = $baseIndex;
-            while ($j >= 0 && !empty($eventDays[$sundays[$j]])) { $j--; }
-            if ($j < 0) { continue; }
-            $sd = $sundays[$j];
-
-            // Mark homework on that Sunday for this class_section (single mapping)
-            $hasHomeworkByDate[$csid][$sd] = true;
-            if (empty($hwEnteredAtByDate[$csid][$sd])) {
-                $hwEnteredAtByDate[$csid][$sd] = $firstCreated ?: $d;
-            } else {
-                // Keep the earliest date for display
-                $existing = (string)$hwEnteredAtByDate[$csid][$sd];
-                $candidate = $firstCreated ?: $d;
-                if ($candidate && (!$existing || $candidate < $existing)) {
-                    $hwEnteredAtByDate[$csid][$sd] = $candidate;
-                }
-            }
-        }
-
-        // Fetch teachers and TAs per section for this term
-        $tb = $this->db->table('teacher_class tc')
-            ->select('tc.class_section_id, tc.position, cs.class_section_name, cs.class_id, u.firstname, u.lastname')
-            ->join('classSection cs', 'cs.class_section_id = tc.class_section_id', 'left')
-            ->join('users u', 'u.id = tc.teacher_id', 'left')
-            ->where('tc.school_year', $this->schoolYear);
-        $teacherRows = $tb->where('tc.class_section_id IS NOT NULL', null, false)
-            ->whereIn('tc.position', ['main','ta'])
-            ->orderBy('cs.class_id', 'ASC')
-            ->orderBy('cs.class_section_name', 'ASC')
-            ->orderBy("FIELD(tc.position, 'main','ta')", '', false)
-            ->orderBy('u.firstname', 'ASC')
-            ->get()
-            ->getResultArray();
-
-        $bySection = [];
-        foreach ($teacherRows as $r) {
-            $sid = (int)($r['class_section_id'] ?? 0);
-            if ($sid <= 0) continue;
-            if (!isset($bySection[$sid])) {
-                $bySection[$sid] = [
-                    'class_section_id'   => $sid,
-                    'class_id'           => (int)($r['class_id'] ?? 0),
-                    'class_section_name' => (string)($r['class_section_name'] ?? ''),
-                    'teachers'           => [],
-                    'tas'                => [],
-                ];
-            }
-            $name = trim(($r['firstname'] ?? '') . ' ' . ($r['lastname'] ?? ''));
-            $pos  = strtolower((string)($r['position'] ?? ''));
-            if ($name !== '') {
-                if ($pos === 'main') { $bySection[$sid]['teachers'][] = $name; }
-                elseif ($pos === 'ta') { $bySection[$sid]['tas'][] = $name; }
-            }
-        }
-
-        $teachers = array_values($bySection);
-
-        // Sort by grade order: KG(13) → Grade 1..11 → Youth(12) → others
-        usort($teachers, function ($a, $b) {
-            $ai = (int)($a['class_id'] ?? 0);
-            $bi = (int)($b['class_id'] ?? 0);
-            $ord = function ($cid) {
-                if ($cid === 13) return 0;      // KG first
-                if ($cid >= 1 && $cid <= 11) return $cid; // Grades 1..11
-                if ($cid === 12) return 99;     // Youth last of known
-                return 200 + $cid;              // any others after
-            };
-            $cmp = $ord($ai) <=> $ord($bi);
-            if ($cmp !== 0) return $cmp;
-            return strnatcasecmp($a['class_section_name'] ?? '', $b['class_section_name'] ?? '');
-        });
-
-        // Simple server-side pagination for rows (8 lines per page)
-        $perPage = 8;
-        $totalRows = count($teachers);
-        $totalPages = max(1, (int)ceil($totalRows / $perPage));
-        $page = (int) ($this->request->getGet('page') ?? 1);
-        if ($page < 1) $page = 1;
-        if ($page > $totalPages) $page = $totalPages;
-        $offset = ($page - 1) * $perPage;
-        $teachersPage = array_slice($teachers, $offset, $perPage);
-
-        return view('grading/homework_tracking', [
-            'semester'     => $this->semester,
-            'schoolYear'   => $this->schoolYear,
-            'sundays'      => $sundays,
-            'eventDays'    => $eventDays,
-            'dateToIndex'  => $dateToIndex,
-            'teachers'     => $teachersPage,
-            'hasHomework'  => $hasHomework,
-            'hwEnteredAt'  => $hwEnteredAt,
-            'hasHomeworkByDate' => $hasHomeworkByDate,
-            'hwEnteredAtByDate' => $hwEnteredAtByDate,
-            'page'         => $page,
-            'totalPages'   => $totalPages,
-            'perPage'      => $perPage,
-            'totalRows'    => $totalRows,
-        ]);
-    }
-
-    /**
-     * Returns true if teacher_class has any rows for the given school year.
-     * The semester argument is ignored because assignments are tracked per year.
-     */
-    private function hasTeacherAssignments(string $schoolYear, string $semester): bool
-    {
-        $year = trim((string)$schoolYear);
-        if ($year === '') {
-            return false;
-        }
-
-        if (array_key_exists($year, $this->teacherAssignmentCache)) {
-            return $this->teacherAssignmentCache[$year];
-        }
-
-        $cnt = $this->db->table('teacher_class')
-            ->where('school_year', $year)
-            ->countAllResults();
-
-        $this->teacherAssignmentCache[$year] = $cnt > 0;
-        return $this->teacherAssignmentCache[$year];
-    }
-
-    /**
-     * Compute start/end dates for the given semester within the school year.
-     * Fall: 09/21/{startYear} to 01/18/{startYear+1}
-     * Spring: 01/25/{startYear+1} to 05/31/{startYear+1}
-     * Defaults to today if parsing fails.
-     */
-    private function getDateRangeForSemester(string $schoolYear, string $semester): array
-    {
-        $startYear = null;
-        if (preg_match('/\b(20\d{2})\b/', $schoolYear, $m)) {
-            $startYear = (int)$m[1];
-        }
-        if ($startYear === null) {
-            $today = new \DateTime('today');
-            return [$today, $today];
-        }
-
-        $nextYear = $startYear + 1;
-        $sem = strtolower(trim($semester));
-
-        $start = $end = null;
-        try {
-            if ($sem === 'spring') {
-                $start = new \DateTime("{$nextYear}-01-25");
-                $end   = new \DateTime("{$nextYear}-05-31");
-            } else {
-                // default/fall
-                $start = new \DateTime("{$startYear}-09-21");
-                $end   = new \DateTime("{$nextYear}-01-18");
-            }
-        } catch (\Throwable $e) {
-            $today = new \DateTime('today');
-            return [$today, $today];
-        }
-
-        return [$start, $end];
-    }
-}
diff --git a/app/Http/Controllers/old/InvoiceController.php b/app/Http/Controllers/old/InvoiceController.php
deleted file mode 100644
index a3c68296..00000000
--- a/app/Http/Controllers/old/InvoiceController.php
+++ /dev/null
@@ -1,1701 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-require_once APPPATH . 'ThirdParty/fpdf/fpdf.php';
-
-use App\Models\InvoiceModel;
-use App\Models\InvoiceStudentListModel;
-use App\Models\StudentModel;
-use App\Models\EnrollmentModel;
-use App\Models\StudentClassModel;
-use App\Models\ConfigurationModel;
-use App\Models\EventChargesModel;
-use App\Models\UserModel;
-use App\Models\AdditionalChargeModel;
-use App\Models\PaymentModel;
-use App\Models\InvoiceEventModel;
-use App\Models\ClassSectionModel;
-use App\Models\DiscountUsageModel;
-use App\Models\RefundModel;
-use DateTime;
-use DateTimeZone;
-
-
-use CodeIgniter\RESTful\ResourceController;
-
-class InvoiceController extends ResourceController
-{
-    protected $invoiceModel;
-    protected $additionalChargeModel;
-    protected $studentModel;
-    protected $enrollmentModel;
-    protected $invoicestudentModel;
-    protected $schoolYear;  // Declare global variable for the controller
-    protected $semester;
-    protected $dueDate;
-    protected $db;
-    protected $configModel;
-    protected $userModel;
-    protected $studentClassModel;
-    protected $firstStudentFee;
-    protected $secondStudentFee;
-    protected $youthFee;
-    protected $refundDeadline;
-    protected $invoiceEventModel;
-    protected $paymentModel;
-    protected $chargesModel;
-    protected $discountUsageModel;
-    protected $refundModel;
-    protected $request;
-    protected $gradeFee;
-    protected $classSectionModel;
-
-    public function __construct()
-    {
-        $this->additionalChargeModel = new AdditionalChargeModel();
-        $this->classSectionModel = new ClassSectionModel();
-        $this->invoiceModel = new InvoiceModel();
-        $this->invoicestudentModel = new InvoiceStudentListModel();
-        $this->studentModel = new StudentModel();
-        $this->enrollmentModel = new EnrollmentModel();
-        $this->configModel = new ConfigurationModel();
-        $this->userModel = new UserModel();
-        $this->studentClassModel = new StudentClassModel();
-        $this->invoiceEventModel = new InvoiceEventModel();
-        $this->paymentModel = new PaymentModel();
-        $this->chargesModel = new EventChargesModel();
-        $this->discountUsageModel = new DiscountUsageModel();
-        $this->refundModel = new RefundModel();
-
-        $this->gradeFee = $this->configModel->getConfig('grade_fee');
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->dueDate = $this->configModel->getConfig('due_date');
-        $this->firstStudentFee = (float) ($this->configModel->getConfig('first_student_fee') ?? 350);
-        $this->secondStudentFee = (float) ($this->configModel->getConfig('second_student_fee') ?? 200);
-        $this->youthFee = (float) ($this->configModel->getConfig('youth_fee') ?? 180);
-        $this->refundDeadline = date('Y-m-d', strtotime($this->configModel->getConfig('refund_deadline')));
-        $this->db = \Config\Database::connect();
-        $this->request = \Config\Services::request();
-    }
-
-    public function index($schoolYear = null)
-    {
-        // Get school years from invoices
-        $schoolYears = $this->invoiceModel
-            ->select('school_year')
-            ->distinct()
-            ->orderBy('school_year', 'DESC')
-            ->findAll();
-
-        // Default school year
-        if (!$schoolYear) {
-            $schoolYear = $this->schoolYear;
-        }
-
-        log_message('info', "Selected school year for invoice retrieval: $schoolYear");
-
-        $invoiceData = [];
-        $parents = $this->userModel->getUsersByRoleAndSchoolYear('parent', $schoolYear);
-
-        foreach ($parents as $parent) {
-            $students = $this->studentModel->where('parent_id', $parent['id'])->findAll();
-
-            $parentData = [
-                'parent_name' => $parent['firstname'] . ' ' . $parent['lastname'],
-                'parent_id' => $parent['id'],
-                'enrolledKids' => [],
-                'withdrawnKids' => [],
-                'invoice_amount' => 0,
-                'refund_amount' => 0, // default
-                'last_updated' => null,
-                'invoice_date' => null
-            ];
-
-            // Fetch most recent invoice
-            $invoices = $this->invoiceModel->getInvoicesByParentId($parent['id'], $schoolYear);
-            foreach ($invoices as $invoice) {
-                if ($invoice) {
-                    $parentData['invoice_amount'] = $invoice['total_amount'];
-                    $parentData['last_updated'] = $invoice['updated_at'];
-                    // Prefer issue_date (UTC) and render in configured/user local time for display
-                    $tzName = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-                    $parentData['invoice_date'] = !empty($invoice['issue_date'])
-                        ? (new \DateTimeImmutable($invoice['issue_date'], new \DateTimeZone('UTC')))
-                            ->setTimezone(new \DateTimeZone($tzName))
-                            ->format('Y-m-d H:i:s')
-                        : ($invoice['updated_at'] ?? null);
-                    $parentData['invoice_id'] = $invoice['id'];
-
-                    // ✅ Fetch refund amount actually PAID this year (Partial/Paid)
-                    $refund = $this->db->table('refunds')
-                        ->select('COALESCE(SUM(refund_paid_amount),0) AS refund_paid_amount')
-                        ->where('parent_id', $parent['id'])
-                        ->where('school_year', $schoolYear)
-                        ->whereIn('status', ['Partial','Paid'])
-                        ->get()
-                        ->getRowArray();
-
-                    $parentData['refund_amount'] = (float)($refund['refund_paid_amount'] ?? 0.0);
-
-                    log_message('info', "Latest invoice for parent {$parent['firstname']} {$parent['lastname']} in school year $schoolYear: Amount = {$invoice['total_amount']}, Updated at = {$invoice['updated_at']}");
-                } else {
-                    log_message('error', "No invoice found for parent {$parent['firstname']} {$parent['lastname']} in school year $schoolYear.");
-                }
-            }
-
-            foreach ($students as $student) {
-                $studentClass = $this->db->table('student_class')
-                    ->where('student_id', $student['id'])
-                    ->where('school_year', $schoolYear)
-                    ->get()->getRowArray();
-
-                $grade = 'N/A';
-                if ($studentClass && isset($studentClass['class_section_id'])) {
-                    $classSection = $this->db->table('classSection')
-                        ->where('class_section_id', $studentClass['class_section_id'])
-                        ->get()->getRowArray();
-
-                    if ($classSection && isset($classSection['class_section_name'])) {
-                        $grade = $classSection['class_section_name'];
-                    }
-                }
-
-                $enrollments = $this->enrollmentModel
-                    ->where('student_id', $student['id'])
-                    ->where('school_year', $schoolYear)
-                    ->findAll();
-
-                foreach ($enrollments as $enrollment) {
-                    $kidData = [
-                        'name' => $student['firstname'] . ' ' . $student['lastname'],
-                        'grade' => $grade,
-                        'tuition_fee' => $enrollment['tuition_fee'] ?? 0
-                    ];
-
-                    switch ($enrollment['enrollment_status']) {
-                        case 'payment pending':
-                        case 'enrolled':
-                            $parentData['enrolledKids'][] = $kidData;
-                            break;
-                        case 'withdraw under review':
-                        case 'withdrawn':
-                        case 'refund pending':
-                            $parentData['withdrawnKids'][] = $kidData;
-                            break;
-                        case 'admission under review':
-                            log_message('info', "Student ID {$student['id']} is under admission review and not included in the invoice.");
-                            break;
-                        case 'waitlist':
-                            log_message('info', "Student ID {$student['id']} is in waitlist and not included in the invoice.");
-                            break;
-                        case 'denied':
-                            log_message('info', "Student ID {$student['id']} is denied and not included in the invoice.");
-                            break;
-                        default:
-                            log_message('error', "Unexpected enrollment status '{$enrollment['enrollment_status']}' for student ID {$student['id']}.");
-                            break;
-                    }
-                }
-            }
-
-            if (!empty($parentData['enrolledKids']) || !empty($parentData['withdrawnKids'])) {
-                $invoiceData[] = $parentData;
-            }
-        }
-
-        return view('invoice_payment/invoice_management', [
-            'invoices' => $invoiceData,
-            'schoolYears' => $schoolYears,
-            'selectedYear' => $schoolYear,
-            'parents' => array_column($invoiceData, 'parent_name')
-        ]);
-    }
-
-    /**
-     * API: Invoice management composite data (used by invoice_management view)
-     * Returns the same structure previously rendered server-side in index().
-     */
-    public function managementData()
-    {
-        $schoolYear = trim((string)($this->request->getGet('schoolYear') ?? $this->request->getGet('year') ?? ''));
-        if ($schoolYear === '') {
-            $schoolYear = $this->schoolYear;
-        }
-
-        $invoiceData = [];
-        try {
-            // Distinct school years (for selector)
-            $yearsRows = $this->invoiceModel
-                ->select('school_year')
-                ->distinct()
-                ->orderBy('school_year', 'DESC')
-                ->findAll();
-            $schoolYears = array_values(array_filter(array_map(static function ($r) {
-                return isset($r['school_year']) ? (string)$r['school_year'] : null;
-            }, $yearsRows)));
-            if (empty($schoolYears)) {
-                $schoolYears = [$this->schoolYear];
-            }
-
-            $parents = $this->userModel->getUsersByRoleAndSchoolYear('parent', $schoolYear);
-
-            foreach ($parents as $parent) {
-                $students = $this->studentModel->where('parent_id', $parent['id'])->findAll();
-
-                $parentData = [
-                    'parent_name'   => trim(($parent['firstname'] ?? '') . ' ' . ($parent['lastname'] ?? '')),
-                    'parent_id'     => (int)$parent['id'],
-                    'enrolledKids'  => [],
-                    'withdrawnKids' => [],
-                    'invoice_amount'=> 0,
-                    'refund_amount' => 0,
-                    'last_updated'  => null,
-                    'invoice_date'  => null,
-                    'invoice_id'    => null,
-                ];
-
-                // Latest invoice
-                $invoices = $this->invoiceModel->getInvoicesByParentId($parent['id'], $schoolYear);
-                foreach ($invoices as $invoice) {
-                    if ($invoice) {
-                        $parentData['invoice_amount'] = (float)($invoice['total_amount'] ?? 0);
-                        $parentData['last_updated']   = $invoice['updated_at'] ?? null;
-                        // Prefer issue_date (UTC) -> local; fall back to updated_at/created_at
-                        if (!empty($invoice['issue_date'])) {
-                            $tzName = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-                            $parentData['invoice_date'] = (new \DateTimeImmutable($invoice['issue_date'], new \DateTimeZone('UTC')))
-                                ->setTimezone(new \DateTimeZone($tzName))
-                                ->format('Y-m-d H:i:s');
-                        } else {
-                            $parentData['invoice_date'] = date('Y-m-d H:i:s', strtotime($invoice['updated_at'] ?? $invoice['created_at'] ?? 'now'));
-                        }
-                        $parentData['invoice_id']     = $invoice['id'] ?? null;
-
-                        // Refund total paid for parent/year (Partial/Paid)
-                        $refund = $this->db->table('refunds')
-                            ->select('COALESCE(SUM(refund_paid_amount),0) AS refund_paid_amount')
-                            ->where('parent_id', $parent['id'])
-                            ->where('school_year', $schoolYear)
-                            ->whereIn('status', ['Partial','Paid'])
-                            ->get()->getRowArray();
-                        $parentData['refund_amount'] = (float)($refund['refund_paid_amount'] ?? 0.0);
-                        break; // only most recent as before
-                    }
-                }
-
-                // Build kids lists based on enrollment statuses
-                foreach ($students as $student) {
-                    $studentClass = $this->db->table('student_class')
-                        ->where('student_id', $student['id'])
-                        ->where('school_year', $schoolYear)
-                        ->get()->getRowArray();
-
-                    $grade = 'N/A';
-                    if ($studentClass && isset($studentClass['class_section_id'])) {
-                        $classSection = $this->db->table('classSection')
-                            ->where('class_section_id', $studentClass['class_section_id'])
-                            ->get()->getRowArray();
-                        if ($classSection && isset($classSection['class_section_name'])) {
-                            $grade = $classSection['class_section_name'];
-                        }
-                    }
-
-                    $enrollments = $this->enrollmentModel
-                        ->where('student_id', $student['id'])
-                        ->where('school_year', $schoolYear)
-                        ->findAll();
-
-                    foreach ($enrollments as $enrollment) {
-                        $kid = [
-                            'name'        => trim(($student['firstname'] ?? '') . ' ' . ($student['lastname'] ?? '')),
-                            'grade'       => $grade,
-                            'tuition_fee' => (float)($enrollment['tuition_fee'] ?? 0),
-                        ];
-                        switch ($enrollment['enrollment_status']) {
-                            case 'payment pending':
-                            case 'enrolled':
-                                $parentData['enrolledKids'][] = $kid;
-                                break;
-                            case 'withdraw under review':
-                            case 'withdrawn':
-                            case 'refund pending':
-                                $parentData['withdrawnKids'][] = $kid;
-                                break;
-                            default:
-                                // ignore others for invoice summary
-                                break;
-                        }
-                    }
-                }
-
-                if (!empty($parentData['enrolledKids']) || !empty($parentData['withdrawnKids'])) {
-                    $invoiceData[] = $parentData;
-                }
-            }
-
-            return $this->response->setJSON([
-                'ok'           => true,
-                'schoolYear'   => $schoolYear,
-                'schoolYears'  => $schoolYears,
-                'invoices'     => $invoiceData,
-            ]);
-        } catch (\Throwable $e) {
-            log_message('error', 'managementData error: ' . $e->getMessage());
-            return $this->response->setStatusCode(500)->setJSON(['ok' => false, 'error' => 'Server error']);
-        }
-    }
-
-
-    private function hasClassAssignment(string $schoolYear, string $parentId): bool
-    {
-        //$parentId = session()->get('user_id');
-
-        if (!$parentId) {
-            return false;
-        }
-
-
-        // Get all students for the parent
-        $students = $this->studentModel->where('parent_id', $parentId)->findAll();
-
-        if (empty($students)) {
-            return false;
-        }
-
-        // Check if at least one student has a class assignment
-        foreach ($students as $student) {
-            $studentId = $student['id'];
-
-            $exists = $this->studentClassModel
-                ->where('student_id', $studentId)
-                ->where('school_year', $schoolYear)
-                ->first();
-
-            if ($exists) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    public function generateInvoice(string $parentId = null)
-    {
-        $isAjax = $this->request->isAJAX() || str_contains(strtolower($this->request->getHeaderLine('Accept')), 'application/json');
-        if ($parentId == null) {
-            $parentId = (int)$this->request->getPost('parent_id');
-        }
-        $schoolYear = (string) $this->schoolYear;
-
-        // Fetch enrolled + withdrawn students
-        $enrollments = $this->enrollmentModel
-            ->where('parent_id', $parentId)
-            ->where('school_year', $this->schoolYear)
-            ->findAll();
-
-        if (empty($enrollments)) {
-            if ($isAjax) {
-                return $this->response->setJSON(['ok' => false, 'message' => 'No enrollment records found.']);
-            }
-            return redirect()->back()->with('error', 'No enrollment records found.');
-        }
-
-        $registeredKids = [];
-        $withdrawnKids = [];
-
-        foreach ($enrollments as $enrollment) {
-            $studentData = [
-                'student_id'        => $enrollment['student_id'],
-                'parent_id'         => $enrollment['parent_id'],
-                'class_section_id'  => $enrollment['class_section_id'],
-                'enrollment_status' => $enrollment['enrollment_status'],
-                'school_year'       => $enrollment['school_year'],
-                'semester'          => $enrollment['semester'],
-                'admission_status'  => $enrollment['admission_status'],
-                'is_withdrawn'      => $enrollment['is_withdrawn']
-            ];
-
-            // Treat 'payment pending' and 'enrolled' as billable regardless of admission_status,
-            // since admin mapping should have already normalized this to 'accepted'.
-            // This makes the calculation resilient to legacy data.
-            if (in_array($enrollment['enrollment_status'], ['enrolled', 'payment pending'], true)) {
-                $registeredKids[] = $studentData;
-            } elseif (in_array($enrollment['enrollment_status'], ['withdrawn', 'refund pending', 'withdraw under review'])) {
-                $withdrawnKids[] = $studentData;
-            } else {
-                log_message('info', "Enrollment skipped for student_id {$enrollment['student_id']} with status: {$enrollment['enrollment_status']} and admission_status: {$enrollment['admission_status']}");
-            }
-        }
-
-        $registeredKids = array_values(array_filter($registeredKids, function ($student) use ($schoolYear) {
-            $sid = (int)($student['student_id'] ?? 0);
-            return $sid > 0 && $this->studentClassModel->hasNonEventAssignment($sid, $schoolYear);
-        }));
-
-        $withdrawnKids = array_values(array_filter($withdrawnKids, function ($student) use ($schoolYear) {
-            $sid = (int)($student['student_id'] ?? 0);
-            return $sid > 0 && $this->studentClassModel->hasNonEventAssignment($sid, $schoolYear);
-        }));
-
-        // ✅ Use your helper to calculate tuition fee
-        $fees = $this->calculateTuitionFee($registeredKids, $withdrawnKids);
-        $tuitionFee = $fees['tuition_fee'];
-
-        // ✅ Fetch event charges
-        $eventsList = $this->chargesModel->getChargesWithEventInfo($parentId, $this->schoolYear);
-        $eventchargeTotal = array_sum(array_column($eventsList, 'charged'));
-
-        $totalDiscount = $this->recalculateAndUpdateDiscount(
-            $parentId,
-            $this->schoolYear,
-            $tuitionFee,
-            $enrollments
-        );
-
-        $semester = $this->semester;
-        // ✅ Refunds PAID to the parent for this year (Partial/Paid)
-        $refundPaid = (float) $this->refundModel->getTotalApprovedRefundByParentIdAndSchoolYear($parentId, $this->schoolYear);
-
-        $totalPaid = $this->paymentModel->getTotalPaidByParentId($parentId, $this->schoolYear);
-
-        $discountedTuition = max(0, $tuitionFee);
-        $totalAmount = $discountedTuition + $eventchargeTotal;
-
-        // Parent-level balance (informational); we will recalc per invoice below
-        $parentBalance = $totalAmount  // original charges (tuition + events)
-            - $totalDiscount           // any applied discounts/vouchers
-            - $refundPaid              // approved refunds paid to parent
-            - $totalPaid;              // payments received
-
-        // Your invoice fetch
-        $existingInvoices = $this->invoiceModel->getInvoicesByParentId($parentId, $this->schoolYear);
-
-        $updated = false;
-
-        $updatedIds = [];
-        if (!empty($existingInvoices)) {
-            foreach ($existingInvoices as $invoice) {
-                if (!isset($invoice['id'])) {
-                    continue;
-                }
-
-                // Preserve applied additional charges and recalc this invoice only
-                $extrasSum = 0.0;
-                try {
-                    $rows = $this->db->table('additional_charges')
-                        ->select('charge_type, amount')
-                        ->where('invoice_id', (int)$invoice['id'])
-                        ->where('school_year', $this->schoolYear)
-                        ->where('status', 'applied')
-                        ->get()->getResultArray();
-                    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);
-                        $extrasSum += $amt;
-                    }
-                } catch (\Throwable $e) {
-                    log_message('error', 'additional_charges sum failed for invoice ' . (int)$invoice['id'] . ': ' . $e->getMessage());
-                }
-
-                $newTotal   = round($totalAmount + $extrasSum, 2);
-
-                // Per-invoice discount
-                $invDiscount = 0.0;
-                try {
-                    $d = $this->db->table('discount_usages')
-                        ->select('COALESCE(SUM(discount_amount),0) AS tot')
-                        ->where('invoice_id', (int)$invoice['id'])
-                        ->get()->getRowArray();
-                    $invDiscount = (float)($d['tot'] ?? 0.0);
-                } catch (\Throwable $e) {
-                    log_message('error', 'discount sum failed for invoice ' . (int)$invoice['id'] . ': ' . $e->getMessage());
-                }
-
-                // Per-invoice refunds paid
-                $invRefunds = 0.0;
-                try {
-                    $r = $this->db->table('refunds')
-                        ->select('COALESCE(SUM(refund_paid_amount),0) AS tot')
-                        ->where('invoice_id', (int)$invoice['id'])
-                        ->where('school_year', $this->schoolYear)
-                        ->whereIn('status', ['Partial','Paid'])
-                        ->get()->getRowArray();
-                    $invRefunds = (float)($r['tot'] ?? 0.0);
-                } catch (\Throwable $e) {
-                    log_message('error', 'refund sum failed for invoice ' . (int)$invoice['id'] . ': ' . $e->getMessage());
-                }
-
-                // Payments recorded on this invoice (denormalized field kept in sync by PaymentController)
-                $paidOnInv  = (float)($invoice['paid_amount'] ?? 0.0);
-
-                $newBalance = $newTotal - $invDiscount - $invRefunds - $paidOnInv;
-                $newStatus  = ($newBalance <= 0.00001)
-                    ? 'Paid'
-                    : (($paidOnInv > 0) ? 'Partially Paid' : 'Unpaid');
-
-                $this->invoiceModel->update($invoice['id'], [
-                    'total_amount' => $newTotal,
-                    'paid_amount'  => $paidOnInv,
-                    'balance'      => $newBalance,
-                'status'       => $newStatus,
-                    'updated_at'   => utc_now()
-                ]);
-
-                $updatedIds[] = (int)$invoice['id'];
-                log_message('info', "Updated invoice ID {$invoice['id']} for parent ID {$parentId}.");
-                $updated = true;
-            }
-        } else {
-            // Generate invoice number
-            $schoolId = $this->userModel->getSchoolIdByUserId($parentId);
-            if (!empty($schoolId)) {
-                $invoiceNumber = 'INV-' . $schoolId . '-' . uniqid();
-            } else {
-                log_message('warning', "No school ID found for parent_id {$parentId}, generating fallback invoice number.");
-                $invoiceNumber = uniqid('INV-');
-            }
-
-            $issueUtc = (new DateTime('now', new DateTimeZone('UTC')))->format('Y-m-d H:i:s');
-
-            // Due date: interpret the date in configured/user local TZ,
-            // set a default time (noon to avoid DST edge cases), then convert to UTC.
-            $dueUtc = null;
-            if (!empty($this->dueDate)) {
-                $tzName = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-                $dueLocal = new DateTime($this->dueDate . ' 19:59:59', new DateTimeZone($tzName));
-                $dueLocal->setTimezone(new DateTimeZone('UTC'));
-                $dueUtc = $dueLocal->format('Y-m-d H:i:s');
-            }
-
-            $insertId = $this->invoiceModel->insert([
-                'parent_id'      => $parentId,
-                'invoice_number' => $invoiceNumber,
-                'total_amount'   => $totalAmount,
-                'paid_amount'    => 0,
-                // Initial balance equals the created total; discounts/refunds/payments will adjust later
-                'balance'        => $totalAmount,
-                'status'         => 'Unpaid',
-                'school_year'    => $this->schoolYear,
-                'semester'       => $semester,
-                'issue_date'     => $issueUtc,
-                'due_date'       => $dueUtc,
-                'created_at'     => utc_now(),
-                'updated_at'     => utc_now()
-            ]);
-
-            if (!$insertId) {
-                log_message('error', 'Invoice insert failed: ' . json_encode($this->invoiceModel->errors()));
-                if ($isAjax) {
-                    return $this->response->setJSON(['ok' => false, 'message' => 'Failed to create invoice.']);
-                }
-                return redirect()->back()->with('error', 'Failed to create invoice. Please check input values.');
-            } else {
-                log_message('info', "Invoice created successfully. Insert ID: {$insertId}");
-            }
-            $updated = false;
-        }
-
-        // Success response
-        if ($isAjax) {
-            return $this->response->setJSON([
-                'ok'      => true,
-                'updated' => $updated,
-                'updated_ids' => $updatedIds,
-                'insert_id'   => isset($insertId) ? (int)$insertId : null,
-                csrf_token()  => csrf_hash(),
-                'csrfTokenName' => csrf_token(),
-                'csrfHash'      => csrf_hash(),
-            ]);
-        }
-
-        return redirect()->to(route_to('InvoiceController::index'))
-            ->with('success', $updated ? 'Invoice updated.' : 'Invoice created.');
-    }
-
-    private function recalculateAndUpdateDiscount(
-        int $parentId,
-        string $schoolYear,
-        float $tuitionFee,
-        array $enrollments
-    ): float {
-        $totalDiscount = 0.00;
-        $eventchargeTotal = 0.0;
-        try {
-            $eventsList = $this->chargesModel->getChargesWithEventInfo($parentId, $schoolYear);
-            $eventchargeTotal = array_sum(array_column($eventsList, 'charged'));
-        } catch (\Throwable $e) {
-            log_message('error', 'Failed to load event charges for discount recalculation: ' . $e->getMessage());
-        }
-
-        // Get all invoices for this parent and school year
-        $invoices = $this->invoiceModel->getInvoicesByParentId($parentId, $schoolYear);
-
-        if (empty($invoices)) {
-            log_message('info', "No invoices found for parent ID $parentId in school year $schoolYear.");
-            return 0.00;
-        }
-
-        foreach ($invoices as $invoice) {
-            if (!isset($invoice['id'])) {
-                continue;
-            }
-
-            $invoiceId = $invoice['id'];
-
-            // Get discount usage + voucher details
-            $discountUsage = $this->db->table('discount_usages du')
-                ->select('du.id, dv.id as voucher_id, dv.discount_type, dv.discount_value')
-                ->join('discount_vouchers dv', 'du.voucher_id = dv.id')
-                ->join('invoices i', 'du.invoice_id = i.id')
-                ->where('du.invoice_id', $invoiceId)
-                ->where('i.school_year', $schoolYear)
-                ->get()
-                ->getRowArray();
-
-            if (!$discountUsage) {
-                log_message('info', "No discount applied to invoice ID $invoiceId.");
-                continue;
-            }
-
-            $extrasSum = 0.0;
-            try {
-                $rows = $this->db->table('additional_charges')
-                    ->select('charge_type, amount')
-                    ->where('invoice_id', (int)$invoice['id'])
-                    ->where('school_year', $schoolYear)
-                    ->where('status', 'applied')
-                    ->get()->getResultArray();
-                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);
-                    $extrasSum += $amt;
-                }
-            } catch (\Throwable $e) {
-                log_message('error', 'additional_charges sum failed for discount recalculation invoice ' . (int)$invoice['id'] . ': ' . $e->getMessage());
-            }
-
-            $baseTotal = round($tuitionFee + $eventchargeTotal + $extrasSum, 2);
-
-            // Recalculate discount
-            if ($discountUsage['discount_type'] === 'percent') {
-                $discountAmount = round(($baseTotal * $discountUsage['discount_value']) / 100, 2);
-            } else {
-                $discountAmount = min($discountUsage['discount_value'], $baseTotal);
-            }
-
-            // Update discount usage
-            $this->db->table('discount_usages')
-                ->where('id', $discountUsage['id'])
-                ->update([
-                    'discount_amount' => $discountAmount,
-                    'updated_at' => utc_now(),
-                    'updated_by' => session()->get('user_id')
-                ]);
-
-            $totalDiscount += $discountAmount;
-
-            // Log enrollment summary
-            $added = [];
-            $withdrawn = [];
-            foreach ($enrollments as $e) {
-                if (
-                    in_array($e['enrollment_status'], ['enrolled', 'payment pending']) &&
-                    $e['admission_status'] === 'accepted'
-                ) {
-                    $added[] = $e['student_id'];
-                } elseif (in_array($e['enrollment_status'], ['withdrawn', 'refund pending', 'withdraw under review'])) {
-                    $withdrawn[] = $e['student_id'];
-                }
-            }
-
-            log_message('info', "Recalculated discount for invoice ID $invoiceId: Added students [" . implode(',', $added) . "], Withdrawn students [" . implode(',', $withdrawn) . "]. Discount updated to $discountAmount.");
-        }
-
-        return $totalDiscount;
-    }
-
-
-    /**
-     * Returns an array:
-     * [
-     *   'tuition_fee'   => <float>,   // what the parent still owes after any withdrawals
-     *   'refund_amount' => <float>,   // what the school should return (0 if none)
-     * ]
-     */
-    private function calculateTuitionFee(array $registeredKids, array $withdrawnKids): array
-    {
-        // If we are within the refund window, exclude withdrawn kids from billing.
-        // After the deadline, treat withdrawn kids as billable (no refunds allowed).
-        try {
-            $tzName      = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-            $tz          = new \DateTimeZone($tzName);
-            $today       = new \DateTimeImmutable('today', $tz);
-            $deadline    = new \DateTimeImmutable($this->refundDeadline, $tz);
-            $refundOk    = $today <= $deadline;
-        } catch (\Throwable $e) {
-            $refundOk = true; // default conservative
-        }
-
-        $tuitionStudents = $refundOk ? $registeredKids : array_merge($registeredKids, $withdrawnKids);
-
-        $tuitionFee = $this->calculateTotalTuitionFee($tuitionStudents);
-
-        log_message('info', 'Total Tuition Fee (refund ' . ($refundOk ? 'allowed' : 'not allowed') . ") = $tuitionFee");
-
-        return [
-            'tuition_fee'   => $tuitionFee,
-        ];
-    }
-
-    private function calculateTotalTuitionFee(array $students): float
-    {
-        // 1) Normalize each student's grade name (once)
-        foreach ($students as &$student) {
-            $gradeName       = $this->classSectionModel
-                ->getClassSectionNameBySectionId($student['class_section_id']);
-            $student['grade'] = strtoupper(trim($gradeName));
-        }
-        unset($student); // break reference
-
-        // 2) Partition into regular (<= grade 9) vs youth (> grade 9)
-        $regularCount = 0;
-        $youthCount   = 0;
-
-        foreach ($students as $student) {
-            $levelInfo = $this->getGradeLevel($student['grade']);
-            $level     = (int) ($levelInfo['level'] ?? 999);
-
-            // Youth if level > $this->gradeFee (e.g., gradeFee = 9)
-            if ($level > $this->gradeFee) {
-                $youthCount++;
-            } else {
-                $regularCount++;
-            }
-        }
-
-        // 3) Calculate totals per your rules
-        $total = 0.0;
-
-        // Youth: flat youth fee per student
-        $total += $youthCount * $this->youthFee;
-
-        // Regulars: first student full price, others discounted — but only if 2+ regulars
-        if ($regularCount >= 2) {
-            $total += $this->firstStudentFee;                         // one full
-            $total += ($regularCount - 1) * $this->secondStudentFee;  // rest discounted
-        } elseif ($regularCount === 1) {
-            $total += $this->firstStudentFee; // single regular: no discount even if there are youths
-        }
-        // if 0 regulars, nothing to add here
-
-        return $total;
-    }
-
-
-    // Method to check and generate an invoice when enrollment status changes
-    public function checkAndGenerateInvoice($parentId, $status)
-    {
-        if ($status == 'payment pending') {
-            $this->generateInvoice($parentId);
-        } elseif ($status == 'withdrawn' || $status == 'enrolled') {
-            $this->generateInvoice($parentId);
-        }
-    }
-
-    public function generatePdfInvoice($invoiceId)
-    {
-        $data = $this->prepareInvoiceData($invoiceId);
-        if (isset($data['error'])) {
-            return $this->generateErrorPdf($data['error']);
-        }
-
-        // Fetch discount_amount from discount_usages
-        $discountResult = $this->db->table('discount_usages du')
-            ->selectSum('du.discount_amount', 'total_discount')
-            ->join('invoices i', 'du.invoice_id = i.id')
-            ->where('du.invoice_id', $invoiceId)
-            ->where('i.school_year', $this->schoolYear)
-            ->get()
-            ->getRowArray();
-
-
-        $discountAmount = isset($discountResult['total_discount']) ? (float)$discountResult['total_discount'] : 0.00;
-
-        // Attach discount amount to data
-        $data['discount_amount'] = $discountAmount;
-
-        $this->renderPdfInvoice($data);
-    }
-
-    // Add this helper method in the same class (once)
-
-
-    private function prepareInvoiceData($invoiceId)
-    {
-        $invoice = $this->invoiceModel->find($invoiceId);
-        if (!$invoice) {
-            return ['error' => "No invoice was generated. Please contact the school administration."];
-        }
-
-        $parentId   = $invoice['parent_id'];
-        $schoolYear = $invoice['school_year'];
-
-        // --- Payments ---
-        $db        = $this->db;
-        $table     = $this->paymentModel->table;
-        $hasStatus = $db->fieldExists('status', $table);
-        $hasVoid   = $db->fieldExists('is_void', $table);
-        $exclude   = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
-
-        $qb = $this->paymentModel
-            ->where('parent_id', $parentId)
-            ->where('school_year', $schoolYear)
-            ->where('invoice_id', $invoiceId);
-
-        if ($hasStatus) {
-            $qb->groupStart()
-                ->whereNotIn('status', $exclude)
-                ->orWhere('status IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        if ($hasVoid) {
-            $qb->groupStart()
-                ->where('is_void', 0)
-                ->orWhere('is_void IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        $payments = $qb->findAll();
-
-        $parent = $this->userModel->find($parentId);
-        if (!$parent) {
-            return ['error' => "Parent associated with the invoice was not found."];
-        }
-
-        $enrollments = $this->enrollmentModel
-            ->where('parent_id', $parentId)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        if (empty($enrollments)) {
-            return ['error' => 'No enrollments found for this invoice.'];
-        }
-
-        $registeredKids = [];
-        $withdrawnKids  = [];
-
-        foreach ($enrollments as $enrollment) {
-            $student = $this->studentModel->find($enrollment['student_id']);
-            if (!$student) {
-                log_message('error', "Student not found for ID: {$enrollment['student_id']}");
-                continue;
-            }
-
-            $grade = $this->studentClassModel->getStudentGrade($student['id']);
-
-            $studentData = [
-                'student_id'        => $student['id'],
-                'student_firstname' => $student['firstname'],
-                'student_lastname'  => $student['lastname'],
-                'grade'             => $grade,
-                'tuition_fee'       => $enrollment['tuition_fee'] ?? 0,
-                'enrollment_status' => $enrollment['enrollment_status'],
-            ];
-
-            if (in_array($enrollment['enrollment_status'], ['enrolled', 'payment pending'], true)) {
-                $registeredKids[] = $studentData;
-            } elseif (in_array($enrollment['enrollment_status'], ['withdrawn', 'withdraw under review', 'refund pending'], true)) {
-                $withdrawnKids[] = $studentData;
-            } else {
-                log_message('info', "Skipping student ID {$student['id']} with status {$enrollment['enrollment_status']}");
-            }
-        }
-
-        $registeredKids = array_values(array_filter($registeredKids, function ($student) use ($schoolYear) {
-            $sid = (int)($student['student_id'] ?? 0);
-            return $sid > 0 && $this->studentClassModel->hasNonEventAssignment($sid, $schoolYear);
-        }));
-
-        $withdrawnKids = array_values(array_filter($withdrawnKids, function ($student) use ($schoolYear) {
-            $sid = (int)($student['student_id'] ?? 0);
-            return $sid > 0 && $this->studentClassModel->hasNonEventAssignment($sid, $schoolYear);
-        }));
-
-        usort($registeredKids, fn($a, $b) => $this->compareGrades($a['grade'], $b['grade']));
-        usort($withdrawnKids,  fn($a, $b) => $this->compareGrades($a['grade'], $b['grade']));
-
-        $tzName        = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-        $tz            = new \DateTimeZone($tzName);
-        $currentDate   = new \DateTimeImmutable('today', $tz);
-        $deadline      = new \DateTimeImmutable($this->refundDeadline, $tz);
-        $refundAllowed = $currentDate <= $deadline;
-
-        $studentCharges = [];
-        $regularCount   = 0;
-
-        /**
-         * Computes the fee for a student given numeric level and original grade name.
-         * - KG/K/Kindergarten are always treated as "regular".
-         * - Otherwise, "regular" means gradeLevel <= $this->gradeFee threshold.
-         */
-        $computeCharge = function (int $gradeLevel, string $gradeName) use (&$regularCount) {
-            $threshold = (int) $this->gradeFee;
-
-            // Force Kindergarten to be regular regardless of numeric mapping
-            $isRegular = $this->isKindergarten($gradeName) || ($gradeLevel > 0 && $gradeLevel <= $threshold);
-
-            if ($isRegular) {
-                $fee = ($regularCount === 0) ? $this->firstStudentFee : $this->secondStudentFee;
-                $regularCount++;
-                return $fee;
-            }
-            return $this->youthFee;
-        };
-
-        // Registered kids -> pay unit fee
-        foreach ($registeredKids as $student) {
-            $gradeName  = (string)$student['grade'];
-            $gradeLevel = $this->gradeLevelInt($gradeName);
-            $unitFee    = $computeCharge($gradeLevel, $gradeName);
-            $studentCharges[$student['student_id']] = ['unit_fee' => $unitFee, 'refund' => 0];
-        }
-
-        // Refund NOT allowed -> withdrawn students still owe unit fee
-        if (!$refundAllowed) {
-            foreach ($withdrawnKids as $student) {
-                $gradeName  = (string)$student['grade'];
-                $gradeLevel = $this->gradeLevelInt($gradeName);
-                $unitFee    = $computeCharge($gradeLevel, $gradeName);
-                $studentCharges[$student['student_id']] = ['unit_fee' => $unitFee, 'refund' => 0];
-            }
-        }
-
-        $eventsList = $this->chargesModel->getChargesWithEventInfo($parentId, $schoolYear);
-
-        // Attach SCHOOL IDs
-        $allKids    = array_merge($registeredKids, $withdrawnKids);
-        $studentIds = array_column($allKids, 'student_id');
-
-        $schoolIdMap = [];
-        if ($studentIds) {
-            $rows = $this->studentModel
-                ->select('id, school_id')
-                ->whereIn('id', $studentIds)
-                ->findAll();
-            foreach ($rows as $row) {
-                $schoolIdMap[(int)$row['id']] = $row['school_id'] ?? 'N/A';
-            }
-        }
-
-        $students = $allKids;
-        foreach ($students as $i => $s) {
-            $sid = (int)$s['student_id'];
-            $students[$i]['student_school_id'] = $schoolIdMap[$sid] ?? 'N/A';
-        }
-
-        $discounts = $this->discountUsageModel
-            ->where('invoice_id',  $invoiceId)
-            ->where('parent_id',   $parentId)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        // Refunds PAID for this specific invoice (money returned to the parent)
-        $refundsPaidTotal = 0.0;
-        try {
-            $r = $this->db->table('refunds')
-                ->select('COALESCE(SUM(refund_paid_amount),0) AS tot')
-                ->where('invoice_id', $invoiceId)
-                ->where('school_year', $schoolYear)
-                ->whereIn('status', ['Partial','Paid'])
-                ->get()->getRowArray();
-            $refundsPaidTotal = (float)($r['tot'] ?? 0.0);
-        } catch (\Throwable $e) {
-            log_message('error', 'Failed to sum refunds for invoice ' . (int)$invoiceId . ': ' . $e->getMessage());
-        }
-
-        /* ============================================================
-     * ADDITIONAL CHARGES (itemized) for this invoice
-     *  - uses the additional_charges table for line items
-     *  - uses invoice.additional_charge as the authoritative total (Strategy B)
-     * ============================================================ */
-        $acRows = $this->additionalChargeModel
-            ->select('id, charge_type, title, description, amount, due_date, status, created_at')
-            ->where('invoice_id', $invoiceId)
-            ->where('status !=', 'void')
-            ->orderBy('created_at', 'ASC')
-            ->orderBy('id', 'ASC')
-            ->findAll();
-
-        $additionalChargeLines  = [];
-        $additionalChargesTotal = 0.0;
-
-        foreach ($acRows as $ac) {
-            $signed = (float)($ac['amount'] ?? 0);
-            $ctype  = strtolower((string)($ac['charge_type'] ?? ''));
-
-            if (in_array($ctype, ['deduct'], true) && $signed > 0) {
-                $signed = -$signed;
-            } elseif (in_array($ctype, ['add'], true) && $signed < 0) {
-                $signed = abs($signed);
-            }
-
-            $lineDate = !empty($ac['created_at'])
-                ? date('Y-m-d', strtotime($ac['created_at']))
-                : (!empty($invoice['created_at']) ? local_date($invoice['created_at'], 'Y-m-d') : local_date(utc_now(), 'Y-m-d'));
-
-            $typeLabel = in_array($ctype, ['deduct'], true) ? 'Deduct' : 'Add';
-            $title     = ''; //trim((string)($ac['title'] ?? 'Additional Charge'));
-            $desc      = $typeLabel . ': ';
-
-            if (!empty($ac['description'])) {
-                $desc = $ac['description'];
-            }
-
-            $additionalChargesTotal += $signed;
-
-            $additionalChargeLines[] = [
-                'date'        => $lineDate,
-                'description' => $desc,
-                'amount'      => $signed,
-                'meta'        => [
-                    'id'       => (int)$ac['id'],
-                    'due_date' => $ac['due_date'] ?? null,
-                    'status'   => (string)($ac['status'] ?? ''),
-                    'type'     => $ctype,
-                ],
-            ];
-        }
-
-        $additionalChargesTotal = round($additionalChargesTotal, 2);
-
-        return [
-            'invoice'                => $invoice,
-            'parent'                 => $parent,
-            'registeredKids'         => $registeredKids,
-            'withdrawnKids'          => $withdrawnKids,
-            'studentCharges'         => $studentCharges,
-            'events'                 => $eventsList,
-            'students'               => $students,
-            'payments'               => $payments,
-            'discounts'              => $discounts,
-            'additionalChargesTotal' => $additionalChargesTotal,
-            'additionalChargeLines'  => $additionalChargeLines,
-            'refundsPaidTotal'       => $refundsPaidTotal,
-        ];
-    }
-
-
-    /**
-     * Treat common KG spellings as Kindergarten.
-     */
-    private function isKindergarten(string $grade): bool
-    {
-        $g = strtolower(trim($grade));
-        return in_array($g, ['KG', 'kg', 'k', 'kindergarten', 'k-g', 'k.g', 'k g'], true);
-    }
-
-
-    private function renderPdfInvoice($data)
-    {
-        // Unpack prepared data
-        extract($data);
-
-        // $data keys expected from prepareInvoiceData():
-        // - invoice, parent, registeredKids, withdrawnKids, studentCharges, events, students, payments, discounts
-        // - additionalChargeLines, additionalChargesTotal
-
-        $pdf = new class extends \FPDF {
-            function Footer()
-            {
-                $this->SetY(-15);
-                $this->SetFont('Arial', 'I', 8);
-                $this->Cell(0, 10, 'Page ' . $this->PageNo() . '/{nb}', 0, 0, 'C');
-            }
-        };
-
-        $pdf->AliasNbPages();
-        $pdf->AddPage();
-
-        // --- Column widths
-        $dateCell    = 30;
-        $descripCell = 130;
-        $amountCell  = 30;
-
-        // --- Header section
-        if (defined('FCPATH')) {
-            @$pdf->Image(FCPATH . 'images/logo.png',       170, 8, 30);
-            @$pdf->Image(FCPATH . 'images/Isgl_logo.png',   10, 8, 30);
-        }
-        $pdf->Ln(25);
-        $pdf->SetFont('Arial', 'B', 18);
-        $pdf->Cell(0, 10, 'Al Rahma Sunday School', 0, 1, 'C');
-        $pdf->SetFont('Arial', 'B', 18);
-        $pdf->Cell(0, 10, 'Invoice', 0, 1, 'C');
-        $pdf->Ln(15);
-
-        $pdf->SetFont('Arial', 'B', 12);
-        $pdf->Cell(40, 6, 'Parent Name:', 0, 0, 'L');
-        $pdf->SetFont('Arial', '', 12);
-        $pdf->Cell(0, 6, ($parent['firstname'] ?? '') . ' ' . ($parent['lastname'] ?? ''), 0, 1, 'L');
-
-        $pdf->SetFont('Arial', 'B', 12);
-        $pdf->Cell(40, 6, 'Invoice Date:', 0, 0, 'L');
-        $pdf->SetFont('Arial', '', 12);
-        $issueLocal = null;
-        try {
-            $tzName = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-            if (!empty($invoice['issue_date'])) {
-                $issueLocal = (new \DateTimeImmutable($invoice['issue_date'], new \DateTimeZone('UTC')))
-                    ->setTimezone(new \DateTimeZone($tzName));
-            } elseif (!empty($invoice['created_at'])) {
-                $issueLocal = new \DateTimeImmutable($invoice['created_at'], new \DateTimeZone($tzName));
-            }
-        } catch (\Throwable $e) {}
-        if (!$issueLocal) { $issueLocal = new \DateTimeImmutable('now', new \DateTimeZone($tzName ?? 'UTC')); }
-        $pdf->Cell(0, 6, $issueLocal->format('m-d-Y'), 0, 1, 'L');
-
-        $pdf->SetFont('Arial', 'B', 12);
-        $pdf->Cell(40, 6, 'Invoice Number:', 0, 0, 'L');
-        $pdf->SetFont('Arial', '', 12);
-        $pdf->Cell(0, 6, (string)($invoice['invoice_number'] ?? ''), 0, 1, 'L');
-
-        $pdf->SetFont('Arial', 'B', 12);
-        $pdf->Cell(40, 6, 'Due Date:', 0, 0, 'L');
-        $pdf->SetFont('Arial', '', 12);
-        $dueLocal = null;
-        try {
-            $tzName = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-            if (!empty($invoice['due_date'])) {
-                $dueLocal = (new \DateTimeImmutable($invoice['due_date'], new \DateTimeZone('UTC')))
-                    ->setTimezone(new \DateTimeZone($tzName));
-            } elseif (!empty($invoice['created_at'])) {
-                $dueLocal = new \DateTimeImmutable($invoice['created_at'], new \DateTimeZone($tzName));
-            }
-        } catch (\Throwable $e) {}
-        if (!$dueLocal) { $dueLocal = new \DateTimeImmutable('now', new \DateTimeZone($tzName ?? 'UTC')); }
-        $pdf->Cell(0, 6, $dueLocal->format('m-d-Y'), 0, 1, 'L');
-
-        $pdf->Ln(5);
-        $pdf->SetFont('Arial', '', 9);
-        $pdf->MultiCell(0, 5, "Please make the payment by the due date mentioned above. For any queries regarding this invoice, contact the school administration at alrahma.isgl@gmail.com or call +1 978-364-0219.");
-        $pdf->Ln(4);
-
-        // --- Table header
-        $pdf->SetFont('Arial', 'B', 12);
-        $pdf->Cell($dateCell, 7, 'Date', 1, 0);
-        $pdf->Cell($descripCell, 7, 'Description', 1);
-        $pdf->Cell($amountCell, 7, 'Amount', 1, 1, 'R');
-
-        // --- Additional charges data presence
-        $additionalChargeLines  = $data['additionalChargeLines']  ?? [];
-        $additionalChargesTotal = (float)($data['additionalChargesTotal'] ?? 0.0);
-        $hasAdditional          = abs($additionalChargesTotal) > 0.00001;
-
-        // --- Helpers for robust date handling & row pushing ---
-        $tzName = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-        $tz = new \DateTimeZone($tzName);
-
-        /**
-         * Normalize a raw date string to configured/user local timezone.
-         * @param ?string $raw
-         * @param bool $assumeUtc If true, treat $raw as UTC and convert; if false, parse as local.
-         */
-        $toLocal = function (?string $raw, bool $assumeUtc = false) use ($tz): \DateTimeImmutable {
-            $fallback = new \DateTimeImmutable('now', $tz);
-            if (!$raw) return $fallback;
-
-            try {
-                if ($assumeUtc) {
-                    $dt = new \DateTimeImmutable($raw, new \DateTimeZone('UTC'));
-                    return $dt->setTimezone($tz);
-                }
-                // Parse directly with local tz; PHP will interpret Y-m-d and Y-m-d H:i:s fine here
-                $dt = new \DateTimeImmutable($raw, $tz);
-                return $dt;
-            } catch (\Throwable $e) {
-                $ts = @strtotime($raw);
-                if ($ts === false) return $fallback;
-                return (new \DateTimeImmutable('@' . $ts))->setTimezone($tz);
-            }
-        };
-
-        $transactions  = [];
-        $totalPaid     = 0.0;
-        $totalDiscount = 0.0;
-        $seq = 0; // stable tie-breaker to preserve insertion order for identical timestamps
-
-        $push = function (\DateTimeImmutable $dt, string $desc, float $amount, string $category = 'other') use (&$transactions, &$seq) {
-            $transactions[] = [
-                'dt'          => $dt,
-                'description' => $desc,
-                'amount'      => $amount,
-                'cat'         => $category,
-                'seq'         => $seq++,
-            ];
-        };
-
-        // --- Tuition/registration lines (charges) ---
-        foreach ($registeredKids as $student) {
-            $id   = $student['student_id'];
-            $unit = (float)($studentCharges[$id]['unit_fee'] ?? 0.0);
-            $name = $student['student_firstname'] . ' ' . $student['student_lastname'];
-
-            $classSectionName = $this->classSectionModel->getClassSectionNameByClassId($student['grade']);
-            $lowerCaseName = strtolower((string)$classSectionName);
-            $gradeName = ($lowerCaseName === 'kg')
-                ? 'in Kindergarten '
-                : (($lowerCaseName === 'youth') ? 'in Youth ' : ('in Grade ' . $classSectionName));
-
-            $dt = $toLocal($invoice['created_at'] ?? null, false);
-            $push($dt, 'Registration of student "' . $name . '" ' . $gradeName, $unit, 'registration');
-        }
-
-        // --- Event charges (charges) ---
-        foreach ($events as $event) {
-            $studentName = 'N/A';
-            if (!empty($event['student_id'])) {
-                foreach ($students as $st) {
-                    if (($st['student_id'] ?? null) == $event['student_id']) {
-                        $studentName = $st['student_firstname'] . ' ' . $st['student_lastname'];
-                        break;
-                    }
-                }
-            }
-
-            $dt        = $toLocal($event['created_at'] ?? null, false);
-            $amount    = (float)($event['charged'] ?? 0.0);
-            $eventName = !empty($event['event_name']) ? $event['event_name'] : 'with no name';
-
-            $push($dt, 'Event ' . $eventName . ' charge for "' . $studentName . '"', $amount, 'event');
-        }
-
-        // --- Withdrawn refunds (negative) — only if a non-zero refund figure exists
-        foreach ($withdrawnKids as $student) {
-            $id   = $student['student_id'];
-            $ref  = (float)($studentCharges[$id]['refund'] ?? 0.0);
-            if ($ref <= 0) { continue; }
-            $name = $student['student_firstname'] . ' ' . $student['student_lastname'];
-
-            $dt = $toLocal($invoice['created_at'] ?? null, false);
-            $push($dt, 'Refund for student "' . $name . '"', -1 * $ref, 'refund');
-        }
-
-        // --- Payments (negative) — stored in local time
-        foreach ($payments as $payment) {
-            $dt     = $toLocal($payment['payment_date'] ?? null, false /* local */);
-            $amount = (float)($payment['paid_amount'] ?? 0.0);
-            $totalPaid += $amount;
-            $push($dt, 'Payment (' . ($payment['payment_method'] ?? 'Payment') . ')', -1 * $amount, 'payment');
-        }
-
-        // --- Additional charges (already signed: deduct < 0, add > 0)
-        foreach ($additionalChargeLines as $l) {
-            $dt   = $toLocal($l['date'] ?? null, false);
-            $desc = (string)($l['description'] ?? 'Additional Charge');
-            $amt  = (float)($l['amount'] ?? 0.0);
-            $push($dt, $desc, $amt, 'additional');
-        }
-
-        // --- Discounts (negative) integrated into the timeline
-        foreach (($discounts ?? []) as $discount) {
-            $amt = (float)($discount['discount_amount'] ?? 0.0);
-            $totalDiscount += $amt;
-
-            $dt   = $toLocal($discount['used_at'] ?? ($invoice['created_at'] ?? null), false);
-            $desc = "Discount applied (Reason: {$discount['description']})";
-            $push($dt, $desc, -1 * $amt, 'discount');
-        }
-
-        // --- Sort by exact timestamp, then by insertion sequence for stability
-        usort($transactions, function ($a, $b) {
-            // Different days: keep chronological by timestamp
-            $dayA = $a['dt']->format('Y-m-d');
-            $dayB = $b['dt']->format('Y-m-d');
-            if ($dayA !== $dayB) {
-                return $a['dt'] <=> $b['dt'];
-            }
-
-            // Same day: ensure desired category priority (registration before payment)
-            $pri = [
-                'registration' => 10,
-                'event'        => 20,
-                'additional'   => 25,
-                'discount'     => 30,
-                'refund'       => 40,
-                'payment'      => 90,
-                'other'        => 50,
-            ];
-            $ca = $a['cat'] ?? 'other';
-            $cb = $b['cat'] ?? 'other';
-            $pa = $pri[$ca] ?? 50;
-            $pb = $pri[$cb] ?? 50;
-            if ($pa !== $pb) {
-                return $pa <=> $pb;
-            }
-
-            // Same category: fall back to exact timestamp, then insertion order
-            $cmp = $a['dt'] <=> $b['dt'];
-            return $cmp !== 0 ? $cmp : ($a['seq'] <=> $b['seq']);
-        });
-
-        // --- Render transactions (strict chronological order)
-        $pdf->SetFont('Arial', '', 11);
-        foreach ($transactions as $t) {
-            $pdf->Cell($dateCell,    7, $t['dt']->format('m-d-Y'), 1);
-            $pdf->Cell($descripCell, 7, $t['description'],         1);
-            $pdf->Cell($amountCell,  7, ($t['amount'] < 0 ? '-$' : '$') . number_format(abs($t['amount']), 2), 1, 1, 'R');
-        }
-
-        // ======== SUMMARY (bottom) ========
-        // Compute total charges from components (tuition + event charges + additional charges)
-        // to ensure the PDF always reflects all elements accurately.
-        $tuitionSubtotal = 0.0;
-        foreach (($studentCharges ?? []) as $sc) {
-            $tuitionSubtotal += (float)($sc['unit_fee'] ?? 0.0);
-        }
-
-        $eventSubtotal = 0.0;
-        foreach (($events ?? []) as $ev) {
-            $eventSubtotal += (float)($ev['charged'] ?? 0.0);
-        }
-
-        $additionalSubtotal = (float)($additionalChargesTotal ?? 0.0);
-
-        $totalRefund  = (float)($data['refundsPaidTotal'] ?? 0.0);
-        $totalAmount  = round($tuitionSubtotal + $eventSubtotal + $additionalSubtotal, 2);
-        $calcBalance  = $totalAmount - $totalPaid - $totalDiscount - $totalRefund;
-        // Prefer computed balance in PDF to avoid stale DB values
-        $totalBalance = $calcBalance;
-
-        // Display rule: if negative, show as Credit (Overpayment) and clamp balance due to 0.00
-        $displayBalance  = $totalBalance;
-        $creditOverpay   = 0.0;
-        if ($displayBalance < -0.00001) {
-            $creditOverpay  = abs($displayBalance);
-            $displayBalance = 0.00;
-        }
-
-        $pdf->Ln(5);
-        $labelWidth  = 165;
-        $amountWidth = 25;
-
-        $pdf->SetFont('Arial', 'B', 12);
-        $pdf->Cell($labelWidth, 7, 'Total Charges:', 0, 0, 'R');
-        $pdf->SetFont('Arial', '', 12);
-        $pdf->Cell($amountWidth, 7, '$' . number_format($totalAmount, 2), 0, 1, 'R');
-
-        // Show Additional Charges subtotal if any (informational)
-        if ($hasAdditional) {
-            $pdf->SetFont('Arial', 'B', 12);
-            $pdf->Cell($labelWidth, 7, 'Additional Charges (included):', 0, 0, 'R');
-            $pdf->SetFont('Arial', '', 12);
-            $pdf->Cell($amountWidth, 7, '$' . number_format($additionalChargesTotal, 2), 0, 1, 'R');
-        }
-
-        if ($totalDiscount > 0.0) {
-            $pdf->SetFont('Arial', 'B', 12);
-            $pdf->Cell($labelWidth, 7, 'Total Discount:', 0, 0, 'R');
-            $pdf->SetFont('Arial', '', 12);
-            $pdf->Cell($amountWidth, 7, '$' . number_format($totalDiscount, 2), 0, 1, 'R');
-        }
-
-        if ($totalRefund > 0.0) {
-            $pdf->SetFont('Arial', 'B', 12);
-            $pdf->Cell($labelWidth, 7, 'Refunds Paid:', 0, 0, 'R');
-            $pdf->SetFont('Arial', '', 12);
-            $pdf->Cell($amountWidth, 7, '$' . number_format($totalRefund, 2), 0, 1, 'R');
-        }
-
-        // Show credit if overpaid
-        if ($creditOverpay > 0.0) {
-            $pdf->SetFont('Arial', 'B', 12);
-            $pdf->Cell($labelWidth, 7, 'Credit (Overpayment):', 0, 0, 'R');
-            $pdf->SetFont('Arial', '', 12);
-            $pdf->Cell($amountWidth, 7, '$' . number_format($creditOverpay, 2), 0, 1, 'R');
-        }
-
-        $pdf->SetFont('Arial', 'B', 12);
-        $pdf->Cell($labelWidth, 7, 'Total Paid:', 0, 0, 'R');
-        $pdf->SetFont('Arial', '', 12);
-        $pdf->Cell($amountWidth, 7, '$' . number_format($totalPaid, 2), 0, 1, 'R');
-
-        $pdf->SetFont('Arial', 'B', 12);
-        $pdf->Cell($labelWidth, 7, 'Balance Due:', 0, 0, 'R');
-        $pdf->SetFont('Arial', '', 12);
-        $pdf->Cell($amountWidth, 7, '$' . number_format($displayBalance, 2), 0, 1, 'R');
-
-        // --- Output
-        header('Content-Type: application/pdf');
-        header('Content-Disposition: inline; filename="invoice_' . ($invoice['invoice_number'] ?? 'N/A') . '.pdf"');
-        header('Cache-Control: private, max-age=0, must-revalidate');
-
-        $pdf->Output('I', 'invoice_' . ($invoice['invoice_number'] ?? 'N/A') . '.pdf');
-        exit;
-    }
-
-    // --- Grade helpers ---
-    private function compareGrades($gradeA, $gradeB)
-    {
-        $valA = $this->getGradeLevel($gradeA);
-        $valB = $this->getGradeLevel($gradeB);
-
-        // First compare numeric levels
-        if ($valA['level'] !== $valB['level']) {
-            return $valA['level'] <=> $valB['level'];
-        }
-
-        // Same level, compare suffix lexicographically (A < B)
-        return strcmp($valA['suffix'] ?? '', $valB['suffix'] ?? '');
-    }
-
-    private function gradeLevelInt($grade): int
-    {
-        $gl = $this->getGradeLevel($grade);
-        return (int) ($gl['level'] ?? 0);
-    }
-
-    /**
-     * Robust grade parser. Returns ['level' => int, 'suffix' => string]
-     * Examples:
-     *  - 'PK' => -1, 'K'/'Kindergarten' => 0
-     *  - '1', '2A', 'Grade 5', 'G5' => 1,2,5
-     *  - 'Y', 'Youth', 'Y1', 'Youth 2' => map to > 9 (10, 11, 12 ...)
-     */
-private function getGradeLevel($grade): array
-{
-    // Normalize
-    if (is_numeric($grade)) {
-        $num = (int)$grade;
-        if ($num === 13) {
-            // KG special case
-            return ['level' => 1, 'suffix' => '', 'classId' => 13];
-        }
-        // If you want, you could also handle Pre-K or Youth by number here
-        return ['level' => $num, 'suffix' => '', 'classId' => null];
-    }
-
-    if (!is_string($grade)) {
-        return ['level' => 999, 'suffix' => '', 'classId' => null];
-    }
-
-    $g = strtoupper(trim($grade));
-    $g = preg_replace('/\s+/', ' ', $g);
-    $g = str_replace(['.', '_'], '', $g);
-    $g = str_replace('-', ' ', $g);
-
-    // Kindergarten (string forms)
-    $kg = ['K', 'KG', 'K G', 'KINDER', 'KINDERGARTEN'];
-    if (in_array($g, $kg, true)) {
-        return ['level' => 1, 'suffix' => '', 'classId' => 13];
-    }
-
-    // Pre-K
-    $pk = ['PK', 'P K', 'PREK', 'PRE K', 'PRE-K', 'PRE KINDER', 'PREKINDER'];
-    if (in_array($g, $pk, true)) {
-        return ['level' => -1, 'suffix' => '', 'classId' => null];
-    }
-
-    // Youth: Y, YOUTH, Y1, YOUTH2, etc.
-    if (preg_match('/^Y(?:OUTH)?(?:\s*(\d+))?$/', $g, $m)) {
-        $n = isset($m[1]) && $m[1] !== '' ? max(1, (int)$m[1]) : 1;
-        return [
-            'level'  => (int)$this->gradeFee + $n,
-            'suffix' => '',
-            'classId'=> null
-        ];
-    }
-
-    // Numeric grades like "5", "GRADE 5", "G5", "5A"
-    if (preg_match('/^(?:GR?ADE\s*)?(\d{1,2})\s*([A-Z]*)$/', $g, $m)) {
-        return [
-            'level'  => (int) $m[1],
-            'suffix' => $m[2] ?? '',
-            'classId'=> null
-        ];
-    }
-
-    return ['level' => 999, 'suffix' => '', 'classId' => null];
-}
-
-    private function generateErrorPdf($message)
-    {
-        // Create a new instance of FPDF
-        $pdf = new \FPDF();
-        $pdf->AddPage();
-
-        // Set title
-        $pdf->SetFont('Arial', 'B', 16);
-        $pdf->Cell(0, 10, 'Error', 0, 1, 'C');  // Add the error title centered
-
-        // Set message font and size
-        $pdf->SetFont('Arial', '', 12);
-        $pdf->Ln(10);  // Add a line break
-
-        // Add the message to the PDF
-        $pdf->MultiCell(0, 10, $message);  // Allow the message to wrap in multiple lines
-
-        // Output the PDF
-        $pdf->Output('I', 'error.pdf');  // Output PDF inline (browser)
-    }
-
-    public function invoicePayment()
-    {
-        $parentId = session()->get('user_id');
-
-        if (!$parentId) {
-            return redirect()->back()->with('error', 'Unable to retrieve student data. Please contact support.');
-        }
-
-        $currentSchoolYear = $this->schoolYear;
-
-        // Get available school years from invoices
-        $schoolYears = $this->invoiceModel
-            ->select('school_year')
-            ->distinct()
-            ->where('parent_id', $parentId)
-            ->orderBy('school_year', 'DESC')
-            ->findAll();
-
-        // Determine which year to show
-        $selectedYear = $this->request->getGet('school_year');
-
-        if (empty($selectedYear)) {
-            $hasCurrentYear = in_array($currentSchoolYear, array_column($schoolYears, 'school_year'));
-            $selectedYear = $hasCurrentYear ? $currentSchoolYear : (!empty($schoolYears) ? $schoolYears[0]['school_year'] : null);
-        }
-
-        // Fetch invoices for the selected year
-        $invoices = [];
-        if ($selectedYear) {
-            $invoices = $this->invoiceModel->getInvoicesByParentId($parentId, $selectedYear);
-        }
-
-        // Fetch refund amounts PAID for these invoices
-        $invoiceIds = array_column($invoices, 'id');
-        $refunds = [];
-        if (!empty($invoiceIds)) {
-            $refundResults = $this->db->table('refunds')
-                ->select('invoice_id, COALESCE(SUM(refund_paid_amount),0) as refund_paid_amount')
-                ->whereIn('invoice_id', $invoiceIds)
-                ->whereIn('status', ['Partial','Paid'])
-                ->groupBy('invoice_id')
-                ->get()
-                ->getResultArray();
-
-            foreach ($refundResults as $row) {
-                $refunds[$row['invoice_id']] = $row['refund_paid_amount'];
-            }
-        }
-
-        // Fetch last payment data for these invoices
-        $lastPayments = [];
-        if (!empty($invoiceIds)) {
-            $paymentResults = $this->paymentModel->getPaymentsByInvoice($invoiceIds);
-
-            foreach ($paymentResults as $payment) {
-                $lastPayments[$payment['invoice_id']] = [
-                    'last_paid_amount'  => $payment['last_paid_amount'],
-                    'last_payment_date' => $payment['last_payment_date']
-                ];
-            }
-        }
-
-        // Attach refund amount and last payment data to each invoice
-        foreach ($invoices as &$invoice) {
-            $invoice['refund_amount'] = $refunds[$invoice['id']] ?? 0.00;
-            $invoice['last_paid_amount'] = $lastPayments[$invoice['id']]['last_paid_amount'] ?? 0.00;
-            $invoice['last_payment_date'] = $lastPayments[$invoice['id']]['last_payment_date'] ?? null;
-        }
-
-        return view('/parent/invoice_payment', [
-            'invoices' => $invoices,
-            'schoolYears' => $schoolYears,
-            'selectedYear' => $selectedYear,
-            'currentSchoolYear' => $currentSchoolYear,
-            'dueDate' => $this->dueDate
-        ]);
-    }
-
-    // API: Create a new invoice
-    public function createAPI()
-    {
-        $data = [
-            'parent_id' => $this->request->getPost('parent_id'),
-            'registeredKids' => $this->request->getPost('registeredKids'),
-            'invoice_number' => $this->request->getPost('invoice_number'),
-            'total_amount' => $this->request->getPost('total_amount'),
-            'refund_amount' => $this->request->getPost('refund_amount'),
-            'balance' => $this->request->getPost('balance'),
-            'school_year' => $this->request->getPost('school_year'),
-            'issue_date' => $this->request->getPost('issue_date'),
-            'refund_issue_date' => $this->request->getPost('refund_issue_date'),
-            'due_date' => $this->request->getPost('due_date'),
-            'status' => 'Unpaid',
-            'description' => $this->request->getPost('description'),
-        ];
-
-        if ($this->invoiceModel->save($data)) {
-            return $this->respondCreated($data); // Send successful response
-        } else {
-            return $this->failValidationErrors($this->invoiceModel->errors()); // Return validation errors
-        }
-    }
-
-    // API: Get invoices by parent ID
-    public function getByParentAPI($parentId)
-    {
-        $invoices = $this->invoiceModel->getInvoicesByUserId($parentId, $this->schoolYear);
-        if ($invoices) {
-            return $this->respond($invoices); // Send the invoices in the response
-        } else {
-            return $this->failNotFound('Invoices not found for the parent.');
-        }
-    }
-
-    // View: Get invoices by parent ID (for web views)
-    public function getByParent($parentId)
-    {
-        $invoices = $this->invoiceModel->getInvoicesByUserId($parentId, $this->schoolYear);
-        return view('invoice_list', ['invoices' => $invoices]);
-    }
-
-    // View: Create a new invoice
-    public function create()
-    {
-        return view('invoice_create');
-    }
-
-    // API: Update invoice status
-    public function updateStatusAPI($invoiceId)
-    {
-        $status = $this->request->getPost('status');
-        if ($this->invoiceModel->updateInvoiceStatus($invoiceId, $status)) {
-            return $this->respond(['status' => 'success']);
-        } else {
-            return $this->failNotFound('Invoice not found.');
-        }
-    }
-
-    // View: Update invoice status
-    public function updateStatus($invoiceId)
-    {
-        $status = $this->request->getPost('status');
-        if ($this->invoiceModel->updateInvoiceStatus($invoiceId, $status)) {
-            return redirect()->to('/invoices');
-        } else {
-            return redirect()->back()->with('error', 'Failed to update status.');
-        }
-    }
-
-    // View: Get unpaid invoices
-    public function unpaidInvoices()
-    {
-        $unpaidInvoices = $this->invoiceModel->getUnpaidInvoices();
-        return view('unpaid_invoices', ['invoices' => $unpaidInvoices]);
-    }
-}
diff --git a/app/Http/Controllers/old/MidtermController.php b/app/Http/Controllers/old/MidtermController.php
deleted file mode 100644
index 9d35f8ad..00000000
--- a/app/Http/Controllers/old/MidtermController.php
+++ /dev/null
@@ -1,364 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-use App\Controllers\BaseController;
-use CodeIgniter\Controller;
-use App\Models\TeacherClassModel;
-use App\Models\StudentClassModel;
-use App\Models\StudentModel;
-use App\Models\MidtermExamModel;
-use App\Models\ConfigurationModel;
-use RuntimeException;
-use App\Services\SemesterScoreService;
-use Config\Services;
-use App\Models\GradingLockModel;
-use App\Models\MissingScoreOverrideModel;
-
-
-class MidtermController extends BaseController
-{
-    protected $db;
-    protected $semesterScoreService;
-    protected $schoolYear;  // Declare global variable for the controller
-    protected $semester;
-    protected $configModel;
-    protected $studentModel;
-    protected $teacherClassModel;
-    protected $gradingLockModel;
-    protected $missingScoreOverrideModel;
-
-    public function __construct()
-    {
-        $this->db = \Config\Database::connect();
-
-        $this->configModel = new ConfigurationModel();
-        $this->studentModel      = new StudentModel();
-        $this->teacherClassModel = new TeacherClassModel();
-        $this->semesterScoreService = service('semesterScoreService');
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->gradingLockModel = new GradingLockModel();
-        $this->missingScoreOverrideModel = new MissingScoreOverrideModel();
-    }
-
-    public function add()
-    {
-        // 1) class_section_id from the view (POST/GET) with session fallback
-        $incoming = $this->request->getPost('class_section_id')
-            ?? $this->request->getGet('class_section_id')
-            ?? session()->get('class_section_id');
-
-        $classSectionId = (int) ($incoming ?: 0);
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('status', 'Missing class section.');
-        }
-
-        // (optional) persist for downstream use
-        session()->set('class_section_id', $classSectionId);
-
-        // (optional) access check if you restrict by teacher assignments
-        // if (!$this->canAccessClassSection((int)(session()->get('user_id') ?? 0), $classSectionId)) {
-        //     return redirect()->back()->with('status', 'You do not have access to that class section.');
-        // }
-
-        $semester = $this->getSelectedSemesterFromRequest();
-        $schoolYear = $this->getSelectedSchoolYearFromRequest() ?? $this->schoolYear;
-        try {
-            $result = $this->getSavedScores($classSectionId, $semester, $schoolYear);
-            $missingOkMap = $this->missingScoreOverrideModel->getOverridesMap($classSectionId, $semester, $schoolYear, 'midterm_exam');
-
-            return view('teacher/add_midterm_exam', [
-                'students'       => $result['students'],
-                'semester'       => $result['semester'],
-                'schoolYear'     => $result['schoolYear'],
-                'classSectionId' => $classSectionId,
-                'missingOkMap'   => $missingOkMap,
-            ]);
-        } catch (\Throwable $e) {
-            return redirect()->back()->with('status', $e->getMessage());
-        }
-    }
-
-
-
-    public function update()
-    {
-        $updatedBy = session()->get('user_id');
-        $scores          = $this->request->getPost('final_score');
-        $classSectionId  = session()->get('class_section_id');
-
-        if (!is_array($scores)) {
-            return redirect()->back()->with('error', 'No scores submitted.');
-        }
-
-        $semester = $this->getSelectedSemesterFromRequest();
-        $schoolYear = $this->getSelectedSchoolYearFromRequest() ?? $this->schoolYear;
-        $classSectionId = (int) ($classSectionId ?? 0);
-        if ($classSectionId > 0 && $this->isScoresLocked($classSectionId, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-        $this->saveExamScores('midterm_exam', $scores, $updatedBy, $classSectionId, $semester, $schoolYear);
-
-        $missingOk = $this->request->getPost('missing_ok') ?? [];
-        $studentIds = array_keys($scores);
-        $checkedItems = [];
-        if (is_array($missingOk)) {
-            foreach ($missingOk as $studentId => $flags) {
-                $checkedItems[] = [
-                    'student_id' => (int) $studentId,
-                    'item_index' => null,
-                ];
-            }
-        }
-        $this->missingScoreOverrideModel->replaceOverrides(
-            $classSectionId,
-            (string) $semester,
-            (string) $schoolYear,
-            'midterm_exam',
-            $studentIds,
-            null,
-            $checkedItems,
-            $updatedBy,
-            true
-        );
-
-        $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear);
-        // Call the updateScoresForStudents method
-        try {
-
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-
-        return redirect()->to(base_url('/teacher/addMidtermExam'))
-            ->with('status', 'Midterm exam scores updated successfully.');
-    }
-
-    public function updateMngt()
-    {
-        $scores          = $this->request->getPost('final_score');
-        $updatedBy       = $this->request->getPost('teacher_id') ?? session()->get('user_id'); // default to session user
-        $classSectionId  = session()->get('class_section_id');
-
-        if (!is_array($scores)) {
-            return redirect()->back()->with('error', 'No scores submitted.');
-        }
-
-        $semester = $this->getSelectedSemesterFromRequest();
-        $schoolYear = $this->getSelectedSchoolYearFromRequest() ?? $this->schoolYear;
-        $classSectionId = (int) ($classSectionId ?? 0);
-        if ($classSectionId > 0 && $this->isScoresLocked($classSectionId, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-        $this->saveExamScores('midterm_exam', $scores, $updatedBy, $classSectionId, $semester, $schoolYear);
-
-        session()->setFlashdata('status', 'Midterm exam scores updated successfully.');
-
-        $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear);
-        // Call the updateScoresForStudents method
-        try {
-
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-        // ⬇️ Directly call the method and return its view
-        return $this->showMidtermMngt();
-    }
-
-
-    public function showMidtermMngt()
-    {
-        // 1) Get class_section_id from POST -> GET -> session
-        $incoming = $this->request->getPost('class_section_id')
-            ?? $this->request->getGet('class_section_id')
-            ?? session()->get('class_section_id');
-
-        $classSectionId = (int) ($incoming ?: 0);
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('status', 'Missing class section.');
-        }
-
-        try {
-            // 2) Load roster + saved scores for this class/term
-            $semester = $this->getSelectedSemesterFromRequest();
-            $schoolYear = $this->getSelectedSchoolYearFromRequest() ?? $this->schoolYear;
-            $result = $this->getSavedScores($classSectionId, $semester, $schoolYear);
-            $scoresLocked = $this->isScoresLocked($classSectionId, $semester, $schoolYear);
-
-            // 3) Render view (no teacherId anymore)
-            return view('grading/midterm', [
-                'students'        => $result['students'],
-                'semester'        => $result['semester'],
-                'schoolYear'      => $result['schoolYear'],
-                'classSectionId'  => $classSectionId,
-                'scoresLocked'    => $scoresLocked,
-            ]);
-        } catch (\Throwable $e) {
-            return redirect()->back()->with('status', $e->getMessage());
-        }
-    }
-
-    private function isScoresLocked(int $classSectionId, string $semester, string $schoolYear): bool
-    {
-        return $this->gradingLockModel->isLocked($classSectionId, $semester, $schoolYear);
-    }
-
-
-
-    private function saveExamScores(string $table, array $scores, int $updatedBy, int $classSectionId, string $semester, string $schoolYear): void
-    {
-        $builder = $this->db->table($table);
-        $now = utc_now();
-
-        foreach ($scores as $studentId => $data) {
-            if (!is_numeric($studentId) || !isset($data['score'])) {
-                continue;
-            }
-
-            $score = is_numeric($data['score']) ? (float) $data['score'] : null;
-
-            $existing = $builder
-                ->where('student_id', $studentId)
-                ->where('class_section_id', $classSectionId)
-                ->where('semester', $semester)
-                ->where('school_year', $schoolYear)
-                ->get()
-                ->getRow();
-
-            $dataToSave = [
-                'student_id'       => $studentId,
-                'class_section_id' => $classSectionId,
-                'updated_by'       => $updatedBy,
-                'score'            => $score,
-                'semester'         => $semester,
-                'school_year'      => $schoolYear,
-                'updated_at'       => $now,
-            ];
-
-            if ($existing) {
-                $builder->where('id', $existing->id)->update($dataToSave);
-            } else {
-                $dataToSave['created_at'] = $now;
-                $builder->insert($dataToSave);
-            }
-        }
-    }
-
-    /**
-     * Get roster + saved midterm scores for a specific classSection/term.
-     */
-    private function getSavedScores(int $classSectionId, string $semester, string $schoolYear): array
-    {
-        if ($classSectionId <= 0) {
-            throw new \InvalidArgumentException('Invalid class section id.');
-        }
-
-        session()->set('class_section_id', $classSectionId);
-
-        // Subquery: pick ONE midterm row per student (latest by id).
-        // If your table doesn't have 'id', swap to MAX(updated_at) or MAX(exam_date).
-        $latestMidtermSub = $this->db->table('midterm_exam')
-            ->select('student_id, MAX(id) AS max_id')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->groupBy('student_id')
-            ->getCompiledSelect();
-
-        // Main query: roster for this class/term + LEFT JOIN the single midterm row
-        $qb = $this->studentModel
-            ->select('
-            s.id AS student_id,
-            s.school_id,
-            s.firstname,
-            s.lastname,
-            me.score
-        ')
-            ->from('students s')
-            ->join(
-                'student_class sc',
-                'sc.student_id = s.id
-             AND sc.class_section_id = ' . (int) $classSectionId . '
-             AND sc.school_year = ' . $this->db->escape($schoolYear),
-                'inner',
-                false
-            )
-            // Join the "latest midterm per student" subquery, then the actual midterm row
-            ->join('(' . $latestMidtermSub . ') ml', 'ml.student_id = s.id', 'left', false)
-            ->join('midterm_exam me', 'me.id = ml.max_id', 'left')
-            ->orderBy('s.lastname', 'ASC')
-            ->orderBy('s.firstname', 'ASC');
-
-        // DISTINCT protects against rare duplicate sc rows that match the same select columns
-        $qb->distinct();
-
-        $rows = $qb->get()->getResultArray();
-
-        // Final safety net: ensure one row per student_id
-        $unique = [];
-        foreach ($rows as $r) {
-            $unique[(int)$r['student_id']] = $r;
-        }
-        $students = array_values($unique);
-
-        return [
-            'students'   => $students,
-            'semester'   => $semester,
-            'schoolYear' => $schoolYear,
-        ];
-    }
-
-    private function getTeacherSelectedSemester(): string
-    {
-        helper('semester_selection_helper');
-        return selected_teacher_semester();
-    }
-
-    private function getSelectedSemesterFromRequest(): string
-    {
-        $semesterParam = $this->request->getPost('semester')
-            ?? $this->request->getGet('semester')
-            ?? $this->request->getGet('filter');
-        $normalized = $this->normalizeSemesterSelection($semesterParam);
-        if ($normalized !== '') {
-            $label = ucfirst($normalized);
-            $session = session();
-            $session->set('teacher_scores_selected_semester', $label);
-            $session->set('semester', $label);
-        }
-
-        return $this->getTeacherSelectedSemester();
-    }
-
-    private function getSelectedSchoolYearFromRequest(): ?string
-    {
-        $yearParam = $this->request->getPost('school_year') ?? $this->request->getGet('school_year');
-        return $this->normalizeSchoolYear($yearParam);
-    }
-
-    private function normalizeSemesterSelection(?string $input): string
-    {
-        $value = strtolower(trim((string) $input));
-        if ($value === 'fall' || str_contains($value, '1')) {
-            return 'fall';
-        }
-        if ($value === 'spring' || str_contains($value, '2')) {
-            return 'spring';
-        }
-        return '';
-    }
-
-    private function normalizeSchoolYear(?string $input): ?string
-    {
-        $value = trim((string) $input);
-        if ($value === '') {
-            return null;
-        }
-        if (preg_match('/^\\d{4}\\s*[-\\/]\\s*\\d{4}$/', $value)) {
-            return preg_replace('/\\s+/', '', str_replace('/', '-', $value));
-        }
-        return null;
-    }
-}
diff --git a/app/Http/Controllers/old/NavbarService.php b/app/Http/Controllers/old/NavbarService.php
new file mode 100644
index 00000000..183184b1
--- /dev/null
+++ b/app/Http/Controllers/old/NavbarService.php
@@ -0,0 +1,66 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\NavItemModel;
+use App\Models\RoleNavItemModel;
+use CodeIgniter\Cache\CacheInterface;
+
+class NavbarService
+{
+    public function __construct(
+        protected NavItemModel $navModel = new NavItemModel(),
+        protected RoleNavItemModel $mapModel = new RoleNavItemModel(),
+        protected ?CacheInterface $cache = null
+    ){
+        $this->cache ??= cache();
+    }
+
+    public function getMenuForRoles(array $roles): array
+    {
+        $roles = array_map(fn($r)=>strtolower(trim((string)$r)), $roles);
+        $cacheKey = 'navbar_' . md5(json_encode($roles));
+
+        if ($menu = $this->cache->get($cacheKey)) {
+            return $menu;
+        }
+
+        // Which items this user can see
+        $allowedIds = $this->mapModel->getNavItemIdsForRoles($roles);
+        if (empty($allowedIds)) return [];
+
+        // Load all enabled items, then filter
+        $rows = $this->navModel->where('is_enabled', 1)
+            ->orderBy('sort_order', 'ASC')
+            ->findAll();
+
+        // index by id
+        $byId = [];
+        foreach ($rows as $r) {
+            if (in_array($r['id'], $allowedIds, true)) {
+                $r['children'] = [];
+                $byId[$r['id']] = $r;
+            }
+        }
+
+        // Build tree
+        $tree = [];
+        foreach ($byId as $id => &$node) {
+            $pid = $node['menu_parent_id'];
+            if ($pid && isset($byId[$pid])) {
+                $byId[$pid]['children'][] = &$node;
+            } else {
+                $tree[] = &$node;
+            }
+        }
+
+        $this->cache->save($cacheKey, $tree, 300); // 5 minutes
+        return $tree;
+    }
+
+    public function clearCache(): void
+    {
+        // simplest: flush; or if you have a tagged cache, clear only keys
+        cache()->clean();
+    }
+}
diff --git a/app/Http/Controllers/old/NotificationService.php b/app/Http/Controllers/old/NotificationService.php
new file mode 100644
index 00000000..1388041f
--- /dev/null
+++ b/app/Http/Controllers/old/NotificationService.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Services;
+
+use CodeIgniter\Events\Events;
+
+class NotificationService
+{
+    /**
+     * Trigger a notification event by type and payload.
+     *
+     * @param string $eventType  The name of the event (e.g., 'userRegistered')
+     * @param array  $payload    The data to pass to the listener
+     * @return void
+     */
+    public static function trigger(string $eventType, array $payload): void
+    {
+        Events::trigger($eventType, $payload);
+    }
+
+    /**
+     * Helper for sending to a specific user.
+     *
+     * @param int    $userId
+     * @param string $title
+     * @param string $message
+     * @param array  $channels
+     * @return void
+     */
+    public static function toUser(int $userId, string $title, string $message, array $channels = ['in_app']): void
+    {
+        self::trigger('customNotification', [
+            'user_id'  => $userId,
+            'title'    => $title,
+            'message'  => $message,
+            'channels' => $channels
+        ]);
+    }
+}
\ No newline at end of file
diff --git a/app/Http/Controllers/old/ParticipationController.php b/app/Http/Controllers/old/ParticipationController.php
deleted file mode 100644
index 5b0e52ce..00000000
--- a/app/Http/Controllers/old/ParticipationController.php
+++ /dev/null
@@ -1,355 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-use App\Controllers\BaseController;
-use CodeIgniter\Controller;
-use App\Models\TeacherClassModel;
-use App\Models\StudentClassModel;
-use App\Models\StudentModel;
-use App\Models\ParticipationModel;
-use App\Models\ConfigurationModel;
-use RuntimeException;
-use App\Services\SemesterScoreService;
-use Config\Services;
-use App\Models\GradingLockModel;
-use App\Models\MissingScoreOverrideModel;
-
-
-class ParticipationController extends BaseController
-{
-    protected $db;
-    protected $semesterScoreService;
-    protected $schoolYear;  // Declare global variable for the controller
-    protected $semester;
-    protected $configModel;
-    protected $studentModel;
-    protected $teacherClassModel;
-    protected $gradingLockModel;
-    protected $missingScoreOverrideModel;
-
-    public function __construct()
-    {
-        $this->db = \Config\Database::connect();
-
-        $this->configModel = new ConfigurationModel();
-        $this->studentModel      = new StudentModel();
-        $this->teacherClassModel = new TeacherClassModel();
-
-        $this->semesterScoreService = service('semesterScoreService');
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->gradingLockModel = new GradingLockModel();
-        $this->missingScoreOverrideModel = new MissingScoreOverrideModel();
-    }
-
-    public function add()
-    {
-        // 1) Get class_section_id from the view (POST/GET) with session fallback
-        $incoming = $this->request->getPost('class_section_id')
-            ?? $this->request->getGet('class_section_id')
-            ?? session()->get('class_section_id');
-
-        $classSectionId = (int) ($incoming ?: 0);
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('status', 'Missing class section.');
-        }
-
-        // (Optional) persist for downstream pages
-        session()->set('class_section_id', $classSectionId);
-
-        // (Optional) access check if you’re restricting by teacher/TA roles
-        // if (!$this->canAccessClassSection((int)(session()->get('user_id') ?? 0), $classSectionId)) {
-        //     return redirect()->back()->with('status', 'You do not have access to that class section.');
-        // }
-
-        $semester = $this->getSelectedSemesterFromRequest();
-        $schoolYear = $this->getSelectedSchoolYearFromRequest() ?? $this->schoolYear;
-        try {
-            $result = $this->getSavedScores($classSectionId, $semester, $schoolYear);
-            $missingOkMap = $this->missingScoreOverrideModel->getOverridesMap($classSectionId, $semester, $schoolYear, 'participation');
-
-            return view('teacher/add_participation', [
-                'students'       => $result['students'],
-                'semester'       => $result['semester'],
-                'schoolYear'     => $result['schoolYear'],
-                'classSectionId' => $classSectionId,
-                'missingOkMap'   => $missingOkMap,
-            ]);
-        } catch (\Throwable $e) {
-            return redirect()->back()->with('status', $e->getMessage());
-        }
-    }
-
-
-
-    public function update()
-    {
-        $updatedBy = session()->get('user_id');
-        $scores          = $this->request->getPost('final_score');
-        $classSectionId  = session()->get('class_section_id');
-
-        if (!is_array($scores)) {
-            return redirect()->back()->with('error', 'No scores submitted.');
-        }
-
-        $semester = $this->getSelectedSemesterFromRequest();
-        $schoolYear = $this->getSelectedSchoolYearFromRequest() ?? $this->schoolYear;
-        $classSectionId = (int) ($classSectionId ?? 0);
-        if ($classSectionId > 0 && $this->isScoresLocked($classSectionId, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-        $this->saveParticipationScores('participation', $scores, $updatedBy, $classSectionId, $semester, $schoolYear);
-
-        $missingOk = $this->request->getPost('missing_ok') ?? [];
-        $studentIds = array_keys($scores);
-        $checkedItems = [];
-        if (is_array($missingOk)) {
-            foreach ($missingOk as $studentId => $flags) {
-                $checkedItems[] = [
-                    'student_id' => (int) $studentId,
-                    'item_index' => null,
-                ];
-            }
-        }
-        $this->missingScoreOverrideModel->replaceOverrides(
-            $classSectionId,
-            (string) $semester,
-            (string) $schoolYear,
-            'participation',
-            $studentIds,
-            null,
-            $checkedItems,
-            $updatedBy,
-            true
-        );
-
-        $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear);
-        // Call the updateScoresForStudents method
-        try {
-
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-
-        return redirect()->to(base_url('/teacher/addParticipation'))
-            ->with('status', 'Participation scores updated successfully.');
-    }
-
-    public function updateMngt()
-    {
-        $scores          = $this->request->getPost('final_score');
-        $updatedBy       = $this->request->getPost('teacher_id') ?? session()->get('user_id'); // default to session user
-        $classSectionId  = session()->get('class_section_id');
-
-        if (!is_array($scores)) {
-            return redirect()->back()->with('error', 'No scores submitted.');
-        }
-
-        $semester = $this->getSelectedSemesterFromRequest();
-        $schoolYear = $this->getSelectedSchoolYearFromRequest() ?? $this->schoolYear;
-        $classSectionId = (int) ($classSectionId ?? 0);
-        if ($classSectionId > 0 && $this->isScoresLocked($classSectionId, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-        $this->saveParticipationScores('participation', $scores, $updatedBy, $classSectionId, $semester, $schoolYear);
-
-        session()->setFlashdata('status', 'Participation scores updated successfully.');
-
-        $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear);
-        // Call the updateScoresForStudents method
-        try {
-
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-        // ⬇️ Directly call the method and return its view
-        return $this->showParticipationMngt();
-    }
-
-
-    public function showParticipationMngt()
-    {
-        // Get class_section_id from view (POST/GET) with session fallback
-        $incoming = $this->request->getPost('class_section_id')
-            ?? $this->request->getGet('class_section_id')
-            ?? session()->get('class_section_id');
-
-        $classSectionId = (int) ($incoming ?: 0);
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('status', 'Missing class section.');
-        }
-
-        // OPTIONAL: enforce access like we did for homework/midterm
-        // if (!$this->canAccessClassSection((int)(session()->get('user_id') ?? 0), $classSectionId)) {
-        //     return redirect()->back()->with('status', 'You do not have access to that class section.');
-        // }
-
-        try {
-            // Pull roster + saved (participation/midterm) scores for this section/term
-            // If you have a dedicated participation table, call its getter here instead.
-            $semester = $this->getSelectedSemesterFromRequest();
-            $schoolYear = $this->getSelectedSchoolYearFromRequest() ?? $this->schoolYear;
-            $result = $this->getSavedScores($classSectionId, $semester, $schoolYear);
-            $scoresLocked = $this->isScoresLocked($classSectionId, $semester, $schoolYear);
-
-            return view('grading/participation', [
-                'students'       => $result['students'],  // already includes school_id
-                'semester'       => $result['semester'],
-                'schoolYear'     => $result['schoolYear'],
-                'classSectionId' => $classSectionId,
-                'scoresLocked'   => $scoresLocked,
-            ]);
-        } catch (\Throwable $e) {
-            return redirect()->back()->with('status', $e->getMessage());
-        }
-    }
-
-    private function isScoresLocked(int $classSectionId, string $semester, string $schoolYear): bool
-    {
-        return $this->gradingLockModel->isLocked($classSectionId, $semester, $schoolYear);
-    }
-
-
-
-    private function saveParticipationScores(string $table, array $scores, int $updatedBy, int $classSectionId, string $semester, string $schoolYear): void
-    {
-        $db = \Config\Database::connect();
-        $builder = $db->table($table);
-        $now = utc_now();
-
-        foreach ($scores as $studentId => $data) {
-            if (!is_numeric($studentId) || !isset($data['score'])) {
-                continue;
-            }
-
-            $score = is_numeric($data['score']) ? (float) $data['score'] : null;
-
-            $existing = $builder
-                ->where('student_id', $studentId)
-                ->where('class_section_id', $classSectionId)
-                ->where('semester', $semester)
-                ->where('school_year', $schoolYear)
-                ->get()
-                ->getRow();
-
-            $dataToSave = [
-                'student_id'       => $studentId,
-                'class_section_id' => $classSectionId,
-                'updated_by'       => $updatedBy,
-                'score'            => $score,
-                'semester'         => $semester,
-                'school_year'      => $schoolYear,
-                'updated_at'       => $now,
-            ];
-
-            if ($existing) {
-                $builder->where('id', $existing->id)->update($dataToSave);
-            } else {
-                $dataToSave['created_at'] = $now;
-                $builder->insert($dataToSave);
-            }
-        }
-    }
-
-    private function getSavedScores(int $classSectionId, string $semester, string $schoolYear): array
-    {
-        if ($classSectionId <= 0) {
-            throw new \InvalidArgumentException('Invalid class section id.');
-        }
-
-        session()->set('class_section_id', $classSectionId);
-
-        // Build a DISTINCT roster subquery correctly (no 'DISTINCT' inside select string)
-        $rosterSub = $this->db->table('student_class')
-            ->select('student_id')   // <-- just the column
-            ->distinct()             // <-- ask CI4 to add DISTINCT
-            ->where('class_section_id', $classSectionId)
-            ->where('school_year', $schoolYear)
-            ->getCompiledSelect();
-
-        // Main query: Students + LEFT JOIN participation for same section/term
-        $students = $this->db->table('students s')
-            ->select('
-            s.id AS student_id,
-            s.school_id,
-            s.firstname,
-            s.lastname,
-            p.score
-        ')
-            ->join("({$rosterSub}) sc", 'sc.student_id = s.id', 'inner', false)
-            ->join(
-                'participation p',
-                'p.student_id = s.id
-             AND p.class_section_id = ' . (int)$classSectionId . '
-             AND p.semester = ' . $this->db->escape($semester) . '
-             AND p.school_year = ' . $this->db->escape($schoolYear),
-                'left',
-                false
-            )
-            ->where('s.is_active', 1)
-            ->orderBy('s.lastname', 'ASC')
-            ->orderBy('s.firstname', 'ASC')
-            ->get()
-            ->getResultArray();
-
-        return [
-            'students'   => $students,
-            'semester'   => $semester,
-            'schoolYear' => $schoolYear,
-        ];
-    }
-
-    private function getTeacherSelectedSemester(): string
-    {
-        helper('semester_selection_helper');
-        return selected_teacher_semester();
-    }
-
-    private function getSelectedSemesterFromRequest(): string
-    {
-        $semesterParam = $this->request->getPost('semester')
-            ?? $this->request->getGet('semester')
-            ?? $this->request->getGet('filter');
-        $normalized = $this->normalizeSemesterSelection($semesterParam);
-        if ($normalized !== '') {
-            $label = ucfirst($normalized);
-            $session = session();
-            $session->set('teacher_scores_selected_semester', $label);
-            $session->set('semester', $label);
-        }
-
-        return $this->getTeacherSelectedSemester();
-    }
-
-    private function getSelectedSchoolYearFromRequest(): ?string
-    {
-        $yearParam = $this->request->getPost('school_year') ?? $this->request->getGet('school_year');
-        return $this->normalizeSchoolYear($yearParam);
-    }
-
-    private function normalizeSemesterSelection(?string $input): string
-    {
-        $value = strtolower(trim((string) $input));
-        if ($value === 'fall' || str_contains($value, '1')) {
-            return 'fall';
-        }
-        if ($value === 'spring' || str_contains($value, '2')) {
-            return 'spring';
-        }
-        return '';
-    }
-
-    private function normalizeSchoolYear(?string $input): ?string
-    {
-        $value = trim((string) $input);
-        if ($value === '') {
-            return null;
-        }
-        if (preg_match('/^\\d{4}\\s*[-\\/]\\s*\\d{4}$/', $value)) {
-            return preg_replace('/\\s+/', '', str_replace('/', '-', $value));
-        }
-        return null;
-    }
-}
diff --git a/app/Http/Controllers/old/PaymentController.php b/app/Http/Controllers/old/PaymentController.php
deleted file mode 100644
index 029c2d34..00000000
--- a/app/Http/Controllers/old/PaymentController.php
+++ /dev/null
@@ -1,1775 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Models\PaymentModel;
-use App\Models\AdditionalChargeModel;
-use App\Models\ClassSectionModel;
-use App\Models\ManualPaymentModel;
-use App\Models\EventChargesModel;
-use App\Models\UserModel;
-use App\Models\StudentModel;
-use App\Models\EnrollmentModel;
-use App\Models\ConfigurationModel;
-use App\Models\StudentClassModel;
-use App\Models\PaymentErrorModel;
-use App\Models\InvoiceModel;
-use App\Models\TeacherClassModel;
-use App\Models\DiscountUsageModel;
-use Config\PaypalConfig;
-use PayPal\Api\Amount;
-use PayPal\Api\Payment;
-use PayPal\Api\PaymentExecution;
-use PayPal\Api\Payer;
-use PayPal\Api\Transaction;
-use PayPal\Rest\ApiContext;
-use PayPal\Auth\OAuthTokenCredential;
-
-use CodeIgniter\RESTful\ResourceController;
-use CodeIgniter\Events\Events;
-
-class PaymentController extends ResourceController
-{
-    protected $paymentModel;
-    protected $paypalConfig;
-    protected $apiContext;
-    protected $request;
-    protected $db;
-    protected $invoiceModel;
-    protected $configModel;
-    protected $manualPaymentModel;
-    protected $eventChargesModel;
-    protected $userModel;
-    protected $schoolYear;
-    protected $semester;
-    protected $enrollmentModel;
-    protected $studentModel;
-    protected $studentClassModel;
-    protected $paymentErrorModel;
-    protected $installmentDate;
-    protected $teacherClassModel;
-    protected $discountUsageModel;
-    protected $additionalChargeModel;
-    protected $classSectionModel;
-
-    public function __construct()
-    {
-        $this->teacherClassModel = new TeacherClassModel();
-        $this->paymentErrorModel = new PaymentErrorModel();
-        $this->userModel = new UserModel();
-        $this->eventChargesModel = new EventChargesModel();
-        $this->manualPaymentModel = new ManualPaymentModel();
-        $this->paymentModel = new PaymentModel();
-        $this->paypalConfig = new PaypalConfig();
-        $this->request = \Config\Services::request();
-        $this->db = \Config\Database::connect();
-        $this->invoiceModel = new InvoiceModel();
-        $this->configModel = new ConfigurationModel();
-        $this->enrollmentModel = new EnrollmentModel();
-        $this->studentModel = new StudentModel();
-        $this->studentClassModel = new StudentClassModel();
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester = $this->configModel->getConfig('semester'); //installment_date
-        $this->installmentDate = $this->configModel->getConfig('installment_date');
-        $this->discountUsageModel = new DiscountUsageModel();
-        $this->additionalChargeModel = new AdditionalChargeModel();
-        $this->classSectionModel     = new ClassSectionModel();
-
-        // Set up PayPal API context
-        $this->apiContext = new ApiContext(
-            new OAuthTokenCredential(
-                $this->paypalConfig->paypalClientId,
-                $this->paypalConfig->paypalSecret
-            )
-        );
-
-        $this->apiContext->setConfig([
-            'mode' => $this->paypalConfig->paypalMode, // 'sandbox' or 'live'
-            'http.headers' => ['Connection' => 'Close']
-        ]);
-    }
-
-    // API: Create a new payment plan
-    public function createAPI()
-    {
-        $data = [
-            'parent_id' => $this->request->getPost('parent_id'),
-            'total_amount' => $this->request->getPost('total_amount'),
-            'number_of_installments' => $this->request->getPost('number_of_installments'),
-            'paid_amount' => 0,
-            'balance_amount' => $this->request->getPost('total_amount'),
-            'payment_date' => $this->request->getPost('payment_date'),
-            'payment_type' => $this->request->getPost('payment_type'),
-            'status' => 'Pending',
-            'semester' => $this->request->getPost('semester'),
-            'school_year' => $this->request->getPost('school_year'),
-        ];
-
-        if ($this->paymentModel->save($data)) {
-            return $this->respondCreated($data); // Send successful response
-        } else {
-            return $this->failValidationErrors($this->paymentModel->errors()); // Return validation errors
-        }
-    }
-
-    // API: Get payments by parent ID
-    public function getByParentAPI($parentId)
-    {
-        $payments = $this->paymentModel->getPaymentsByParentId($parentId);
-        if ($payments) {
-            return $this->respond($payments);
-        } else {
-            return $this->failNotFound('Payments not found for the parent.');
-        }
-    }
-
-    // View: Get payments by parent ID (for web views)
-    public function getByParent($parentId)
-    {
-        // Fetch payments with invoice number (if available)
-        $payments = $this->paymentModel
-            ->select('payments.*, invoices.invoice_number')
-            ->join('invoices', 'invoices.id = payments.invoice_id', 'left')
-            ->where('payments.parent_id', (int)$parentId)
-            ->orderBy('payments.payment_date', 'DESC')
-            ->findAll();
-
-        // Parent display name
-        $parent = $this->userModel->select('firstname, lastname')->find((int)$parentId) ?: [];
-        $parentName = trim(($parent['firstname'] ?? '') . ' ' . ($parent['lastname'] ?? ''));
-
-        // If requested for modal, return a fragment (no layout)
-        $isModal = (string)($this->request->getGet('modal') ?? '') === '1';
-        if ($isModal) {
-            return view('payment/_list_modal', [
-                'payments'   => $payments,
-                'parentId'   => (int)$parentId,
-                'parentName' => $parentName,
-            ], ['saveData' => true]);
-        }
-
-        // Full page fallback
-        return view('payment_list', [
-            'payments'   => $payments,
-            'parentId'   => (int)$parentId,
-            'parentName' => $parentName,
-        ]);
-    }
-
-    // View: Create a new payment plan
-    public function create()
-    {
-        return view('payment_create');
-    }
-
-    // API: Update balance after payment
-    public function updateBalanceAPI($paymentId)
-    {
-        $amountPaid = $this->request->getPost('paid_amount');
-        if ($this->paymentModel->updateBalance($paymentId, $amountPaid)) {
-            return $this->respond(['status' => 'success']);
-        } else {
-            return $this->failNotFound('Payment not found.');
-        }
-    }
-
-    // View: Update balance after payment
-    public function updateBalance($paymentId)
-    {
-        $amountPaid = $this->request->getPost('paid_amount');
-        if ($this->paymentModel->updateBalance($paymentId, $amountPaid)) {
-            return redirect()->to('/payments');
-        } else {
-            return redirect()->back()->with('error', 'Failed to update balance.');
-        }
-    }
-
-
-    // Create a PayPal payment
-    public function createPaypalPayment($paymentId)
-    {
-        // Fetch the payment details from the database
-        $payment = $this->paymentModel->find($paymentId);
-
-        // Create the payer object (who is making the payment)
-        $payer = new Payer();
-        $payer->setPaymentMethod('paypal');
-
-        // Set up the payment amount
-        $amount = new Amount();
-        $amount->setCurrency('USD')
-            ->setTotal($payment['balance_amount']);  // The balance amount to be paid
-
-        // Set up the transaction details
-        $transaction = new Transaction();
-        $transaction->setAmount($amount)
-            ->setDescription('Payment for school fees')
-            ->setInvoiceNumber(uniqid());
-
-        // Create the payment and set the redirect URLs
-        $payment = new Payment();
-        $payment->setIntent('sale')
-            ->setPayer($payer)
-            ->setTransactions([$transaction]);
-
-        // Set the approval URL for the payment
-        $redirectUrls = new \PayPal\Api\RedirectUrls();
-        $redirectUrls->setReturnUrl(base_url('payments/executePaypalPayment')) // Set this to where the user will be redirected after approval
-            ->setCancelUrl(base_url('payments/cancelPaypalPayment'));
-
-        $payment->setRedirectUrls($redirectUrls);
-
-        // Create the payment and get the approval URL
-        try {
-            $payment->create($this->apiContext);
-            // Store the payment ID in the session to retrieve it later
-            session()->set('paypalPaymentId', $payment->getId());
-            session()->set('paymentId', $paymentId);
-            $approvalUrl = $payment->getApprovalLink();
-
-            return redirect()->to($approvalUrl);  // Redirect the user to PayPal's approval page
-        } catch (\PayPal\Exception\PayPalConnectionException $ex) {
-            // Handle errors
-            echo $ex->getData();
-            exit;
-        }
-    }
-
-    // Execute the PayPal payment after user approval
-    public function executePaypalPayment()
-    {
-        // Get the payment ID and Payer ID from the request
-        $paymentId = session()->get('paypalPaymentId');
-        $payerId = $this->request->getGet('PayerID');
-
-        // Get the payment object using the payment ID
-        $payment = Payment::get($paymentId, $this->apiContext);
-
-        // Create an execution object to execute the payment
-        $execution = new PaymentExecution();
-        $execution->setPayerId($payerId);
-
-        // Execute the payment
-        try {
-            $result = $payment->execute($execution, $this->apiContext);
-
-            // Payment successful, update the payment status in the database
-            $paymentId = session()->get('paymentId');
-            $this->paymentModel->update($paymentId, ['status' => 'Completed']);
-
-            return redirect()->to('/payments');  // Redirect to the payments page after success
-        } catch (\PayPal\Exception\PayPalConnectionException $ex) {
-            // Handle payment execution failure
-            echo $ex->getData();
-            exit;
-        }
-    }
-
-    // Cancel the PayPal payment
-    public function cancelPaypalPayment()
-    {
-        // Payment was canceled by the user
-        return redirect()->to('/payments')->with('error', 'Payment was canceled.');
-    }
-
-
-    public function redirectPage()
-    {
-        $modeCheck = $this->configModel->getConfig('paypal_mode');
-
-        $parentId = session()->get('user_id'); // assuming this is the logged-in parent
-
-        // Get parent name and school ID
-        $parent = $this->db->table('users')
-            ->select('firstname, lastname, school_id')
-            ->where('id', $parentId)
-            ->get()
-            ->getRowArray();
-
-        $parentName = isset($parent['firstname'], $parent['lastname'])
-            ? $parent['firstname'] . ' ' . $parent['lastname']
-            : 'Parent';
-
-        $schoolId = $parent['school_id'] ?? null;
-
-        // Get latest invoice total_amount
-        $latestInvoice = $this->invoiceModel->where('parent_id', $parentId)
-            ->orderBy('created_at', 'DESC')
-            ->select('total_amount')
-            ->get()
-            ->getRowArray();
-
-        $totalAmount = $latestInvoice['total_amount'] ?? 0;
-
-        return view('payment/payment_redirect', [
-            'parentName'   => $parentName,
-            'totalAmount'  => $totalAmount,
-            'schoolId'     => $schoolId,
-            'modeCheck'    => $modeCheck,
-        ]);
-    }
-
-
-    public function paypal()
-    {
-        // Redirect to PayPal API or show instructions
-        return redirect()->to('https://www.paypal.com/ncp/payment/87FJL3EV8C7NE');
-    }
-
-    public function manual()
-    {
-        if (strtolower($this->request->getMethod()) === 'post') {
-            $data = [
-                'invoice_number'   => $this->request->getPost('invoice_number'),
-                'amount'           => $this->request->getPost('amount'),
-                'payment_method'   => $this->request->getPost('payment_method'),
-                'reference'        => $this->request->getPost('reference'),
-                'created_at'       => utc_now(),
-            ];
-
-            // Handle file upload if present
-            $proof = $this->request->getFile('proof');
-            if ($proof && $proof->isValid() && !$proof->hasMoved()) {
-                $filename = $proof->getRandomName();
-                $proof->move(WRITEPATH . 'uploads/payments/', $filename);
-                $data['proof_path'] = $filename;
-            }
-
-            $this->manualPaymentModel->insert($data);
-
-            return redirect()->back()->with('success', 'Payment info submitted successfully!');
-        }
-
-        return view('payment/manual_payment');
-    }
-
-    public function eventChargesShow()
-    {
-        $parents = $this->userModel->getParents();
-        $school_Year = $this->request->getGet('school_year') ?? $this->schoolYear;
-        $seme_ster = $this->request->getGet('semester') ?? $this->semester;
-
-        // Join with users and students for full info
-        $charges = $this->eventChargesModel
-            ->select('event_charges.*, users.firstname AS parent_firstname, users.lastname AS parent_lastname, students.firstname AS student_firstname, students.lastname AS student_lastname')
-            ->join('users', 'users.id = event_charges.parent_id', 'left')
-            ->join('students', 'students.id = event_charges.student_id', 'left')
-            ->where('event_charges.school_year', $school_Year)
-            ->where('event_charges.semester', $seme_ster)
-            ->orderBy('event_charges.created_at', 'DESC')
-            ->findAll();
-
-        return view('payment/event_charges', [
-            'charges' => $charges,
-            'parents' => $parents,
-            'school_year' => $school_Year,
-            'semester' => $seme_ster,
-        ]);
-    }
-
-    public function eventChargesUpdate()
-    {
-        $studentIds = $this->request->getPost('student_ids') ?? [];
-        $userId = session()->get('user_id');
-
-        $commonData = [
-            'parent_id'   => $this->request->getPost('parent_id'),
-            'event_name'  => $this->request->getPost('event_name'),
-            'description' => $this->request->getPost('description'),
-            'amount'      => $this->request->getPost('amount'),
-            'semester'    => $this->request->getPost('semester'),
-            'school_year' => $this->request->getPost('school_year'),
-            'charged'     => 0,
-            'updated_by'  => $userId,
-        ];
-
-        $success = false;
-
-        if (!empty($studentIds)) {
-            foreach ($studentIds as $studentId) {
-                $data = array_merge($commonData, ['student_id' => $studentId]);
-                $this->eventChargesModel->insert($data);
-                $success = true;
-            }
-        } elseif ($this->request->getPost('student_id')) {
-            $data = array_merge($commonData, ['student_id' => $this->request->getPost('student_id')]);
-            $this->eventChargesModel->insert($data);
-            $success = true;
-        }
-
-        if (!$success) {
-            return redirect()->back()->with('error', 'No student selected. Please select at least one.');
-        }
-
-        return redirect()->back()->with('success', 'Event charge(s) added successfully.');
-    }
-
-    public function getEnrolledStudents($parentId)
-    {
-        $enrollments = $this->enrollmentModel->getEnrolledStudents((int) $parentId, $this->schoolYear);
-
-        $students = [];
-        foreach ($enrollments as $row) {
-            $students[] = [
-                'id' => $row['id'],
-                'firstname' => $row['firstname'],
-                'lastname' => $row['lastname'],
-                'grade' => $this->studentClassModel->getStudentGrade($row['id']) ?? 'N/A',
-            ];
-        }
-
-        return $this->response->setJSON($students);
-    }
-
-    public function manualPaySearch()
-    {
-        helper('form');
-
-        $parentData = null;
-        $students   = [];
-        $payments   = [];
-        $invoices   = [];
-        $pager      = null;
-
-        // Read the search term (email or phone)
-        $searchTerm = trim((string) $this->request->getGet('search_term'));
-
-        // --- Installment end date comes ONLY from config ---
-        $installmentDateRaw = (string) ($this->installmentDate ?? '');
-        $installmentEndYmd  = '';
-        if ($installmentDateRaw) {
-            $ts = strtotime($installmentDateRaw);
-            if ($ts !== false) {
-                $installmentEndYmd = date('Y-m-d', $ts); // ensure 'YYYY-MM-DD'
-            }
-        }
-
-        if ($searchTerm !== '') {
-            $searchClean     = preg_replace('/\D/', '', $searchTerm);
-            $searchFormatted = $this->formatPhone($searchClean);
-
-            $builder = $this->db->table('users');
-            $builder->select('*');
-
-            // Build search conditions
-            $builder->groupStart();
-            $builder->where('email', $searchTerm);
-
-            if (!empty($searchClean)) {
-                if (strlen($searchClean) === 10) {
-                    $formattedPhone = substr($searchClean, 0, 3) . '-' . substr($searchClean, 3, 3) . '-' . substr($searchClean, 6, 4);
-                    $builder->orWhere('cellphone', $formattedPhone);
-                }
-
-                // compare stripped formatting
-                $builder->orWhere(
-                    "REPLACE(REPLACE(REPLACE(REPLACE(cellphone, '(', ''), ')', ''), '-', ''), ' ', '') =",
-                    $this->db->escapeString($searchClean),
-                    false
-                );
-            }
-
-            if (!empty($searchFormatted)) {
-                $builder->orWhere('cellphone', $searchFormatted);
-            }
-            $builder->groupEnd();
-
-            // Execute query
-            $parent = $builder->get()->getRowArray();
-
-            if (is_array($parent) && array_key_exists('password', $parent)) {
-                unset($parent['password']);
-            }
-
-            if ($parent && !empty($parent['id'])) {
-                $parentData = $parent;
-                $parentId   = (int) $parent['id'];
-
-                // Students
-                $students = $this->studentModel
-                    ->where('parent_id', $parentId)
-                    ->findAll();
-
-                // Payments (paginated)
-                $payments = $this->paymentModel
-                    ->where('parent_id', $parentId)
-                    ->orderBy('payment_date', 'DESC')
-                    ->paginate(10);
-                $pager = $this->paymentModel->pager;
-
-                // Invoices
-                $rawInvoices = $this->invoiceModel
-                    ->where('parent_id', $parentId) // <- fixed (removed "value:")
-                    ->orderBy('issue_date', 'DESC')
-                    ->findAll();
-
-                // Preload sums of actual payments/discounts/refunds per invoice to avoid stale invoice.paid_amount/balance
-                $paidByInvoice = [];
-                $discountByInvoice = [];
-                $refundByInvoice = [];
-                if (!empty($rawInvoices)) {
-                    $invoiceIds = array_values(array_unique(array_map(static fn($r) => (int)($r['id'] ?? 0), $rawInvoices)));
-                    if (!empty($invoiceIds)) {
-                        $rows = $this->paymentModel
-                            ->select('invoice_id, COALESCE(SUM(paid_amount),0) AS total_paid')
-                            ->whereIn('invoice_id', $invoiceIds)
-                            ->groupBy('invoice_id')
-                            ->get()->getResultArray();
-                        foreach ($rows as $r) {
-                            $iid = (int)($r['invoice_id'] ?? 0);
-                            $paidByInvoice[$iid] = (float)($r['total_paid'] ?? 0);
-                        }
-
-                        // Sum discounts per invoice_id
-                        $discRows = $this->db->table('discount_usages')
-                            ->select('invoice_id, COALESCE(SUM(discount_amount),0) AS total_disc')
-                            ->whereIn('invoice_id', $invoiceIds)
-                            ->groupBy('invoice_id')
-                            ->get()->getResultArray();
-                        foreach ($discRows as $dr) {
-                            $iid = (int)($dr['invoice_id'] ?? 0);
-                            $discountByInvoice[$iid] = (float)($dr['total_disc'] ?? 0);
-                        }
-
-                        // Sum PAID refunds per invoice_id (only Partial/Paid reduce liability)
-                        $refRows = $this->db->table('refunds')
-                            ->select('invoice_id, COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid')
-                            ->whereIn('invoice_id', $invoiceIds)
-                            ->whereIn('status', ['Partial','Paid'])
-                            ->groupBy('invoice_id')
-                            ->get()->getResultArray();
-                        foreach ($refRows as $rr) {
-                            $iid = (int)($rr['invoice_id'] ?? 0);
-                            $refundByInvoice[$iid] = (float)($rr['total_refund_paid'] ?? 0);
-                        }
-                    }
-                }
-
-                // Normalize invoices for the view/JS; force due_ymd to the CONFIG date
-                $invoices = array_map(function (array $inv) use ($installmentEndYmd, $paidByInvoice, $discountByInvoice, $refundByInvoice) {
-                    // Cast numeric fields we rely on
-                    $inv['total_amount'] = isset($inv['total_amount']) ? (float) $inv['total_amount'] : 0.0;
-                    // Prefer actual sum of payments for paid_amount
-                    $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);
-                    // Per-invoice discount
-                    $inv['discount'] = isset($discountByInvoice[$iid]) ? (float)$discountByInvoice[$iid] : (float)($inv['discount'] ?? 0.0);
-
-                    // Per-invoice refunds (paid out)
-                    $inv['refund_paid'] = isset($refundByInvoice[$iid]) ? (float)$refundByInvoice[$iid] : 0.0;
-
-                    // Derive balance from total - paid - discount - refundsPaid (never below 0)
-                    $inv['balance'] = max(0.0, (float)$inv['total_amount'] - (float)$inv['paid_amount'] - (float)$inv['discount'] - (float)$inv['refund_paid']);
-
-                    // Always use the configured end date for installments
-                    $inv['due_ymd'] = $installmentEndYmd;
-
-                    // Optional: keep a start marker if you ever need it elsewhere
-                    $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 view('payment/manual_pay', [
-            'parent'                 => $parentData,
-            'students'               => $students,
-            'payments'               => $payments,
-            'invoices'               => $invoices,
-            'pager'                  => $pager,
-            'searchTermUsedInSearch' => $searchTerm,
-            'todayYmd'               => utc_now(),
-            'installmentEndYmd'      => $installmentEndYmd, // SELECT will use this in data-end-date
-        ]);
-    }
-
-    public function manualPaySuggest()
-    {
-        $q = trim((string)($this->request->getGet('q') ?? ''));
-        if ($q === '') {
-            return $this->response->setJSON(['items' => []]);
-        }
-
-        $db = $this->db;
-        $qs = '%' . $db->escapeLikeString($q) . '%';
-        $digits = preg_replace('/\D/', '', $q);
-
-        $sql = "SELECT id, firstname, lastname, email, cellphone
-                  FROM users
-                 WHERE (
-                        CONCAT_WS(' ', firstname, lastname) LIKE ?
-                     OR email LIKE ?
-                     OR cellphone LIKE ?";
-        $params = [$qs, $qs, $qs];
-
-        if ($digits !== '') {
-            $sql .= " OR REPLACE(REPLACE(REPLACE(REPLACE(cellphone, '(', ''), ')', ''), '-', ''), ' ', '') LIKE ?";
-            $params[] = '%' . $digits . '%';
-        }
-
-        $sql .= ")
-                 ORDER BY lastname, firstname
-                 LIMIT 20";
-
-        $rows = $db->query($sql, $params)->getResultArray();
-        $items = [];
-        foreach ($rows as $row) {
-            $label = trim(($row['firstname'] ?? '') . ' ' . ($row['lastname'] ?? ''));
-            $email = trim((string)($row['email'] ?? ''));
-            $phone = trim((string)($row['cellphone'] ?? ''));
-            $sub = trim($email . ' ' . $phone);
-            $value = $email !== '' ? $email : ($phone !== '' ? $phone : $label);
-
-            $items[] = [
-                'id'    => (int)($row['id'] ?? 0),
-                'label' => $label,
-                'sub'   => $sub,
-                'value' => $value,
-            ];
-        }
-
-        return $this->response->setJSON(['items' => $items]);
-    }
-
-    private function updateEnrollmentStatusIfPaid(int $invoiceId): int
-{
-    // 1) Fetch invoice
-    $invoice = $this->invoiceModel->find($invoiceId);
-    if (!$invoice) {
-        log_message('warning', 'Invoice not found: {id}', ['id' => $invoiceId]);
-        return 0;
-    }
-
-    // 2) Payment check: recompute current balance from payments (authoritative)
-    $total         = (float) ($invoice['total_amount'] ?? 0);
-    $currentBal    = $this->getCurrentInvoiceBalance($invoiceId); // <-- uses the safe helper
-    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;
-    }
-
-    // 3) Try to limit to enrollments actually present on the invoice (optional)
-    $paidEnrollmentIds = [];
-    try {
-        $hasInvoiceItems = false;
-        try {
-            $hasInvoiceItems = (bool) $this->db->query("SHOW TABLES LIKE 'invoice_items'")->getNumRows();
-        } catch (\Throwable $e) {
-            $hasInvoiceItems = false;
-        }
-
-        if ($hasInvoiceItems) {
-            $rows = $this->db->table('invoice_items')
-                ->select('enrollment_id')
-                ->where('invoice_id', $invoiceId)
-                ->where('enrollment_id IS NOT NULL', null, false)
-                ->get()->getResultArray();
-
-            foreach ($rows as $r) {
-                $eid = (int)($r['enrollment_id'] ?? 0);
-                if ($eid > 0) $paidEnrollmentIds[] = $eid;
-            }
-            $paidEnrollmentIds = array_values(array_unique($paidEnrollmentIds));
-        }
-    } catch (\Throwable $e) {
-        // proceed without narrowing
-        $paidEnrollmentIds = [];
-    }
-
-    // 4) Preview IDs that will be updated (good for debugging “partials”)
-    $previewBuilder = $this->db->table('enrollments')
-        ->select('id')
-        ->where('parent_id', $parentId)
-        ->where('school_year', $schoolYear)
-        ->groupStart()
-            // tolerant match for 'payment pending' (case/space/nbsp)
-            ->where('enrollment_status', 'payment pending')
-            ->orWhere('enrollment_status', 'Payment pending')
-            ->orWhere('enrollment_status', 'Payment Pending')
-            ->orWhere('enrollment_status', 'PAYMENT PENDING')
-            ->orWhere("LOWER(TRIM(REPLACE(enrollment_status, CHAR(160), ' '))) = 'payment pending'", null, false)
-        ->groupEnd();
-
-    if ($semester !== null) {
-        $previewBuilder->where('semester', $semester);
-    }
-    if (!empty($paidEnrollmentIds)) {
-        $previewBuilder->whereIn('id', $paidEnrollmentIds);
-    }
-
-    $toUpdateIds = array_map(
-        static fn($r) => (int)$r['id'],
-        $previewBuilder->get()->getResultArray()
-    );
-
-    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;
-    }
-
-    // 5) Perform update only if we have rows to change
-    $db = $this->db;
-    $db->transBegin();
-    try {
-        $builder = $db->table('enrollments');
-        $builder->set('enrollment_status', 'enrolled')
-                ->set('enrollment_date', local_date(utc_now(), 'Y-m-d')) // or 'CURRENT_DATE()' with false flag
-                ->whereIn('id', $toUpdateIds);
-
-        if ($builder->update() === false) {
-            $err = $db->error();
-            throw new \RuntimeException('Enrollments update failed: ' . ($err['message'] ?? 'unknown DB error'));
-        }
-
-        $affected = $db->affectedRows();
-        $db->transCommit();
-
-        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->transRollback();
-        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 ?? site_url('/login');
-
-        // --- Parent/User info ---
-        $parent = $this->db->table('users')
-            ->select('id, firstname, lastname, email')
-            ->where('id', $parentId)
-            ->get()->getRowArray();
-
-        if (!$parent) {
-            throw new \RuntimeException("Parent user #{$parentId} not found");
-        }
-
-        // Normalize student ids and guard against empty arrays
-        $ids = array_values(array_unique(array_map('intval', $studentIds)));
-        if (empty($ids)) {
-            // If none provided, fetch all of this parent's students for the current term (optional behavior)
-            $ids = array_map(
-                fn($r) => (int)$r['id'],
-                $this->db->table('students')
-                    ->select('id')
-                    ->where('parent_id', $parentId)
-                    ->get()->getResultArray()
-            );
-        }
-
-        // If still empty, return minimal payload
-        if (empty($ids)) {
-            $data = [
-                'user_id'     => (int) $parent['id'],
-                'email'       => $parent['email'] ?? null,
-                'firstname'   => $parent['firstname'] ?? '',
-                'lastname'    => $parent['lastname'] ?? '',
-                'school_year' => $schoolYear,
-            ];
-            return [$data, []];
-        }
-
-        // --- One-shot enrichment query ---
-        // NOTE on classSection PK:
-        // If your classSection PK is `class_section_id` (common in your code), keep the join below.
-        // If it’s `id`, change the ON to `cs.id = sc.class_section_id`.
-        $qb = $this->db->table('students s');
-        $qb->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
-    ");
-
-        // current term assignment (left join so unassigned students still appear)
-        $qb->join(
-            'student_class sc',
-            'sc.student_id = s.id AND sc.school_year = ' . $this->db->escape($schoolYear),
-            'left'
-        );
-
-        // section name
-        $qb->join(
-            'classSection cs',
-            'cs.class_section_id = sc.class_section_id',
-            'left'
-        );
-
-        // main teacher for that section in the same term
-        $qb->join(
-            'teacher_class tc',
-            'tc.class_section_id = sc.class_section_id
-         AND tc.position = "main"
-         AND tc.school_year = ' . $this->db->escape($schoolYear),
-            'left'
-        );
-
-        // teacher user for name
-        $qb->join('users tu', 'tu.id = tc.teacher_id', 'left');
-
-        $qb->where('s.parent_id', $parentId)
-            ->whereIn('s.id', $ids);
-
-        // If a student can have multiple sc rows for the same term, you may need a strategy to pick one.
-        // The simplest is to prefer the most recently updated:
-        $qb->orderBy('sc.updated_at', 'DESC');
-
-        $rows = $qb->get()->getResultArray();
-
-        // Fallback minimal data if nothing came back (should be rare)
-        if (!$rows) {
-            $rows = $this->db->table('students 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()->getResultArray();
-        }
-
-        // Build normalized student array
-        $studentdata = [];
-        $seen = []; // to avoid duplicates if joins produce multiple rows per student
-        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; // keep null if no teacher yet
-            }
-
-            $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'] ?? ''), // what they registered for
-                'class_section_id' => isset($r['class_section_id']) ? (int)$r['class_section_id'] : null,
-                'class_section_name' => $r['class_section_name'] ?? null,        // actual placed section (if any)
-                'teacher_name'     => $teacherFull,                               // main teacher for placed section/term
-                'start_date'       => '',                                         // fill if you have it elsewhere
-                'portal_link'      => $portalLink,
-            ];
-        }
-
-        // Top-level envelope consumed by handleStudentEnrolled()
-        $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->invoiceModel->find($invoiceId) ?: [];
-        $parentId = (int) ($invoice['parent_id'] ?? 0);
-
-        $parent = $parentId
-            ? ($this->db->table('users')->select('id, firstname, lastname, email')->where('id', $parentId)->get()->getRowArray() ?: [])
-            : [];
-
-        $eventData = [
-            'invoice_id'        => $invoiceId,
-            'invoice_number'    => $invoice['invoice_number'] ?? null,
-
-            // both keys, to satisfy any template
-            'transaction_id'    => $transactionId,
-            'transactionId'     => $transactionId,
-
-            // payment
-            'amount'            => (float) $amount,
-            'payment_method'    => $paymentMethod,
-            'method'            => $paymentMethod,
-            'payment_date'      => $paymentDate,
-            'check_number'      => $checkNumber ?: null,
-            'installment_seq'   => (int) $installmentSeq,
-
-            // balances
-            'pre_balance'       => (float) $preBalance,
-            'post_balance'      => (float) $postBalance,
-
-            // totals
-            'invoice_total'     => (float) ($invoice['total_amount'] ?? 0),
-
-            // parent
-            '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;
-        }
-
-        // lightweight student list
-        $students = [];
-        if ($parentId) {
-            $studentRows = $this->db->table('students')
-                ->select('id, firstname, lastname')
-                ->where('parent_id', $parentId)
-                ->orderBy('lastname', 'ASC')
-                ->get()->getResultArray();
-            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];
-    }
-
-    public function manualPayUpdate()
-    {
-        $invoiceId      = (int) $this->request->getPost('invoice_id');
-        $amount         = (float) $this->request->getPost('amount');
-        $paymentMethod  = strtolower(trim((string) $this->request->getPost('payment_method'))); // cash|check|card
-        $checkNumber    = trim((string) $this->request->getPost('check_number'));
-        $searchTerm     = $this->request->getPost('search_term') ?? $this->request->getGet('search_term') ?? '';
-
-        // UI-only
-        $paymentType    = strtolower((string) ($this->request->getPost('payment_type') ?? 'full')); // full|installment
-
-        // Accept user-entered date or now()
-        $paymentDateStr = $this->request->getPost('payment_date');
-        $paymentDate    = $paymentDateStr ? date('Y-m-d H:i:s', strtotime($paymentDateStr)) : utc_now();
-
-        // Basic validation
-        if (!$invoiceId || !$amount || !$paymentMethod) {
-            return redirect()->back()->withInput()->with('error', 'Missing required fields (invoice, amount, or method).');
-        }
-
-        $allowedMethods = ['cash', 'check', 'card'];
-        if (!in_array($paymentMethod, $allowedMethods, true)) {
-            return redirect()->back()->withInput()->with('error', 'Invalid payment method.');
-        }
-
-        if ($paymentMethod === 'check' && $checkNumber === '') {
-            return redirect()->back()->withInput()->with('error', 'Check number is required for check payments.');
-        }
-
-        if ($amount <= 0) {
-            return redirect()->back()->withInput()->with('error', 'Invalid amount: ' . number_format($amount, 2));
-        }
-
-        $invoice = $this->invoiceModel->find($invoiceId);
-        if (!$invoice) {
-            return redirect()->back()->with('error', 'Invoice 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 redirect()->back()->withInput()->with(
-                'error',
-                'Debit/Credit Card payments must equal the full remaining balance (' . number_format($initialPreBalance, 2) . ').'
-            );
-        }
-
-        // Optional receipt upload
-        $checkFile   = null;
-        $paymentFile = $this->request->getFile('payment_file');
-        if ($paymentFile && $paymentFile->isValid() && !$paymentFile->hasMoved()) {
-            $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 redirect()->back()->withInput()->with('error', 'Unsupported file type. Use JPG, PNG, or PDF.');
-            }
-            if ($paymentFile->getSize() > 5 * 1024 * 1024) {
-                return redirect()->back()->withInput()->with('error', 'File too large. Max 5MB.');
-            }
-
-            $fileName  = $paymentFile->getRandomName();
-            $subdir    = ($paymentMethod === 'check') ? 'checks' : (($paymentMethod === 'card') ? 'cards' : 'misc');
-            $targetDir = WRITEPATH . 'uploads/' . $subdir . '/';
-            if (!is_dir($targetDir)) @mkdir($targetDir, 0775, true);
-            $paymentFile->move($targetDir, $fileName);
-            $checkFile = $fileName;
-        }
-        $this->db->transBegin();
-
-        try {
-            // Lock invoice & get context (also ensure totals are up-to-date before validation)
-            $row = $this->db->query(
-                'SELECT id, parent_id, total_amount, school_year FROM invoices WHERE id = ? FOR UPDATE',
-                [$invoiceId]
-            )->getRowArray();
-
-            if (!$row) {
-                $this->db->transRollback();
-                return redirect()->back()->with('error', 'Invoice not found.');
-            }
-
-            $parentId = (int)($row['parent_id'] ?? 0);
-            $invYear  = (string)($row['school_year'] ?? $this->schoolYear);
-
-            // Recompute invoice totals from tuition + events + additional charges
-            $this->recalculateInvoice($invoiceId, $invYear);
-
-            // Authoritative balance
-            $currentBalance = $this->getCurrentInvoiceBalance($invoiceId);
-
-            if ($amount > $currentBalance + 0.00001) {
-                $this->db->transRollback();
-                return redirect()->back()->withInput()->with(
-                    'error',
-                    'Entered amount (' . number_format($amount, 2) . ') exceeds remaining balance (' . number_format($currentBalance, 2) . ').'
-                );
-            }
-
-            if ($paymentMethod === 'card' && (float)round($amount, 2) !== (float)round($currentBalance, 2)) {
-                $this->db->transRollback();
-                return redirect()->back()->withInput()->with(
-                    'error',
-                    'Debit/Credit Card payments must equal the full remaining balance (' . number_format($currentBalance, 2) . ').'
-                );
-            }
-
-            // Installment sequence
-            $paidCount      = $this->getSuccessfulPaymentCount($invoiceId);
-            $installmentSeq = $paidCount + 1;
-
-            // Generate a stable transaction id
-            $transactionId = 'INV-' . $invoiceId . '-' . str_replace('.', '', (string)microtime(true));
-
-            // Record payment
-            $ok = $this->processPayment(
-                $invoiceId,
-                $amount,
-                $paymentMethod,
-                $checkFile,
-                $transactionId,
-                $paymentDate,
-                $this->schoolYear,
-                $this->semester,
-                $checkNumber,
-                $installmentSeq
-            );
-
-            if (!$ok) {
-                $this->db->transRollback();
-                return redirect()->back()->with('error', 'Failed to record payment.');
-            }
-
-            // Ensure invoice totals/balance reflect discounts and this payment
-            $this->recalculateInvoice($invoiceId, $this->schoolYear);
-
-            // Post-payment balance from snapshot
-            $postBalance = (float)round($initialPreBalance - $amount, 2);
-            if ($postBalance < 0) $postBalance = 0.0;
-
-            // Optional enrollment update
-            $enrollmentupdated = $this->updateEnrollmentStatusIfPaid($invoiceId);
-            if ($enrollmentupdated != 0) {
-                $studentIds = $this->studentModel->getStudentIdsByParentId($parentId);
-                [$eventDataEnroll, $studentDataEnroll] = $this->buildStudentEnrolledEventData($parentId, $studentIds);
-                Events::trigger('studentEnrolled', $eventDataEnroll, $studentDataEnroll);
-            }
-
-            // --- Discounts (keep payment and discount separate!)
-            // Per-invoice discount: sum by invoice_id ONLY (no year filter so we never miss it)
-            $invoiceDiscount = 0.0;
-            $rowDisc = $this->db->table('discount_usages')
-                ->selectSum('discount_amount', 'sum_disc')
-                ->where('invoice_id', $invoiceId)
-                ->get()->getRowArray();
-            if ($rowDisc && isset($rowDisc['sum_disc'])) {
-                $invoiceDiscount = (float)$rowDisc['sum_disc'];
-            }
-
-            // Parent YTD (same school year)
-            $parentYearDiscountTotal = 0.0;
-            $rowParentDisc = $this->db->table('discount_usages')
-                ->selectSum('discount_amount', 'sum_disc')
-                ->where('parent_id', $parentId)
-                ->where('school_year', $this->schoolYear)
-                ->get()->getRowArray();
-            if ($rowParentDisc && isset($rowParentDisc['sum_disc'])) {
-                $parentYearDiscountTotal = (float)$rowParentDisc['sum_disc'];
-            }
-
-            $this->db->transCommit();
-
-            // Build payload & notify
-            [$eventData, $studentData] = $this->buildPaymentEventData(
-                $invoiceId,
-                $transactionId,
-                $amount,
-                $paymentMethod,
-                $paymentDate,
-                $checkNumber,
-                $installmentSeq,
-                $initialPreBalance,
-                $postBalance,
-                $invoiceDiscount,
-                $parentYearDiscountTotal
-            );
-
-            Events::trigger('paymentReceived', $eventData, $studentData);
-
-            return redirect()
-                ->to(site_url('payment/manual_pay?search_term=' . urlencode($searchTerm)))
-                ->with('success', 'Payment recorded successfully (Installment #' . $installmentSeq . '). Transaction ID: ' . $transactionId);
-        } catch (\Throwable $e) {
-            if ($this->db->transStatus()) $this->db->transRollback();
-            log_message('error', '[manualPayUpdate] ' . $e->getMessage());
-            return redirect()->back()->withInput()->with('error', 'Unexpected error while recording payment.');
-        }
-    }
-
-
-    public function manualPayEdit()
-    {
-        $paymentId     = (int) $this->request->getPost('payment_id');
-        $paidAmount    = (float) $this->request->getPost('paid_amount');
-        $paymentMethod = $this->request->getPost('payment_method');
-        $checkNumber   = $this->request->getPost('check_number'); // ✅ Added check_number
-
-        if (!$paymentId || !$paidAmount || !$paymentMethod) {
-            return redirect()->back()->with('error', 'Missing required fields.');
-        }
-
-        $payment = $this->paymentModel->find($paymentId);
-        if (!$payment) {
-            return redirect()->back()->with('error', 'Original payment not found.');
-        }
-
-        $invoice = $this->invoiceModel->find($payment['invoice_id']);
-        if (!$invoice) {
-            return redirect()->back()->with('error', 'Linked invoice not found.');
-        }
-
-        //$schoolYear = (new ConfigurationModel())->getConfig('school_year');
-        $checkFile  = $payment['check_file']; // default keep old file
-
-        // Handle optional check or card payment receipt upload
-        if (strtolower($paymentMethod) === 'check') {
-            $paymentFile = $this->request->getFile('payment_file'); // ✅ Updated to payment_file
-            if ($paymentFile && $paymentFile->isValid() && !$paymentFile->hasMoved()) {
-                $fileName = $paymentFile->getRandomName();
-                $paymentFile->move(WRITEPATH . 'uploads/checks/', $fileName);
-                $checkFile = $fileName;
-            }
-        } elseif (strtolower($paymentMethod) === 'card') {
-            $paymentFile = $this->request->getFile('payment_file'); // ✅ Updated to payment_file
-            if ($paymentFile && $paymentFile->isValid() && !$paymentFile->hasMoved()) {
-                $fileName = $paymentFile->getRandomName();
-                $paymentFile->move(WRITEPATH . 'uploads/cards/', $fileName);
-                $checkFile = $fileName; // reuse for compatibility
-            }
-        }
-
-        // ❌ Validate amount - negative or zero
-        if ($paidAmount <= 0) {
-            return redirect()->back()->with(
-                'error',
-                'Invalid amount entered: ' . number_format($paidAmount, 2) . '. Amount must be greater than zero.'
-            );
-        }
-
-        // 🔄 Recalculate invoice first to ensure totals reflect tuition + events + additional
-        $this->recalculateInvoice($payment['invoice_id'], $this->schoolYear);
-
-        // 🔄 Get current balance based on actual payments (with school_year filter)
-        // We need to calculate what the balance would be WITHOUT the current payment being edited
-        $currentBalance = $this->getCurrentInvoiceBalanceExcludingPayment($payment['invoice_id'], $paymentId);
-
-        if ($paidAmount > $currentBalance) {
-            return redirect()->back()->with(
-                'error',
-                'Entered amount (' . number_format($paidAmount, 2) . ') exceeds remaining balance (' . number_format($currentBalance, 2) . ').'
-            );
-        }
-
-        // ✅ Update edited payment with check_number
-        $updateData = [
-            'paid_amount'   => $paidAmount,
-            'payment_method' => strtolower($paymentMethod),
-            'check_file'    => $checkFile,
-            'updated_by'    => session()->get('user_id')
-        ];
-
-        // ✅ Only add check_number if payment method is check
-        if (strtolower($paymentMethod) === 'check') {
-            $updateData['check_number'] = $checkNumber;
-        } else {
-            $updateData['check_number'] = null; // Clear check number for non-check payments
-        }
-
-        $this->paymentModel->update($paymentId, $updateData);
-
-        // 🔄 Always recalc invoice after change
-        $this->recalculateInvoice($payment['invoice_id'], $this->schoolYear);
-
-        return redirect()->back()->with('success', 'Payment updated successfully.');
-    }
-
-
-    /**
-     * 🔄 Helper: Recalculate invoice totals and status based on all payments for current school year
-     */
-    private function recalculateInvoice($invoiceId, $schoolYear)
-    {
-        $invoice = $this->invoiceModel->find($invoiceId);
-        if (!$invoice) return;
-
-        $parentId = (int)($invoice['parent_id'] ?? 0);
-        if ($parentId <= 0) return;
-
-        // ---- Tuition (recompute from enrollments) ----
-        $enrollments = $this->enrollmentModel
-            ->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 – if after deadline, withdrawn still billed
-        $refundDeadline = (string)($this->configModel->getConfig('refund_deadline') ?? '');
-        $refundAllowed  = true;
-        try {
-            $tzName   = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-            $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);
-        }
-
-        $tuitionStudents = array_values(array_filter($tuitionStudents, function ($student) use ($schoolYear) {
-            $sid = (int)($student['student_id'] ?? 0);
-            return $sid > 0 && $this->studentClassModel->hasNonEventAssignment($sid, $schoolYear);
-        }));
-
-        // Grade threshold and fees
-        $gradeFee         = (int)($this->configModel->getConfig('grade_fee') ?? 9);
-        $firstStudentFee  = (float)($this->configModel->getConfig('first_student_fee')  ?? 350);
-        $secondStudentFee = (float)($this->configModel->getConfig('second_student_fee') ?? 200);
-        $youthFee         = (float)($this->configModel->getConfig('youth_fee')          ?? 180);
-
-        // Normalize grades for tuition students
-        foreach ($tuitionStudents as &$s) {
-            $name = null;
-            if (!empty($s['class_section_id'])) {
-                $name = $this->classSectionModel->getClassSectionNameBySectionId($s['class_section_id']);
-            }
-            $s['grade_name'] = is_string($name) ? strtoupper(trim($name)) : 'N/A';
-        }
-        unset($s);
-
-        // Count regular vs youth and compute tuition
-        $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 (parent-year) ----
-        $eventSubtotal = 0.0;
-        try {
-            $events = $this->eventChargesModel->getChargesWithEventInfo($parentId, $schoolYear) ?? [];
-            foreach ($events as $ev) { $eventSubtotal += (float)($ev['charged'] ?? 0.0); }
-        } catch (\Throwable $e) {}
-
-        // ---- Additional charges (per-invoice) ----
-        $additionalSubtotal = 0.0;
-        try {
-            $rows = $this->additionalChargeModel
-                ->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 ----
-        $db        = $this->db;
-        $table     = $this->paymentModel->table;
-        $hasStatus = $db->fieldExists('status', $table);
-        $hasVoid   = $db->fieldExists('is_void', $table);
-        $exclude   = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
-
-        $qb = $this->paymentModel
-            ->where('invoice_id', $invoiceId)
-            ->where('school_year', $schoolYear);
-
-        if ($hasStatus) {
-            $qb->groupStart()
-                ->whereNotIn('status', $exclude)
-                ->orWhere('status IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        if ($hasVoid) {
-            $qb->groupStart()
-                ->where('is_void', 0)
-                ->orWhere('is_void IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        $payments = $qb->findAll();
-        $totalPaid = 0.0;
-        foreach ($payments as $p) { $totalPaid += (float)($p['paid_amount'] ?? 0); }
-
-        $discRow = $this->db->table('discount_usages')
-            ->select('COALESCE(SUM(discount_amount),0) AS total_disc')
-            ->where('invoice_id', $invoiceId)
-            ->get()->getRowArray();
-        $totalDisc = (float)($discRow['total_disc'] ?? 0);
-
-        $refundRow = $this->db->table('refunds')
-            ->select('COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid')
-            ->where('invoice_id', $invoiceId)
-            ->whereIn('status', ['Partial','Paid'])
-            ->get()->getRowArray();
-        $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->invoiceModel->update($invoiceId, [
-            'total_amount' => $newTotal,
-            'paid_amount'  => $totalPaid,
-            'balance'      => $newBalance,
-            'status'       => $newStatus,
-        ]);
-    }
-
-    /**
-     * Recalculate invoice totals by invoice number or ID (school-year only).
-     */
-    public function recalculateInvoiceByNumber(string $invoiceNumber)
-    {
-        $invoiceNumber = trim($invoiceNumber);
-        $invoice = null;
-
-        if ($invoiceNumber !== '' && ctype_digit($invoiceNumber)) {
-            $invoice = $this->invoiceModel->find((int)$invoiceNumber);
-        }
-        if (!$invoice) {
-            $invoice = $this->invoiceModel
-                ->where('invoice_number', $invoiceNumber)
-                ->first();
-        }
-
-        if (!$invoice) {
-            return redirect()->back()->with('error', 'Invoice not found.');
-        }
-
-        $schoolYear = (string)($invoice['school_year'] ?? $this->schoolYear);
-        $this->recalculateInvoice((int)$invoice['id'], $schoolYear);
-
-        return redirect()->back()->with('success', 'Invoice recalculated.');
-    }
-
-    /**
-     * Parse a grade name into an integer level for tuition rules.
-     * Kindergarten -> 1, Youth -> > 9, numeric grades passthrough.
-     */
-    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/Kindergarten
-        $kg = ['K','KG','K G','KINDER','KINDERGARTEN'];
-        if (in_array($g, $kg, true)) return 1;
-        // Pre-K -> treat below regular
-        $pk = ['PK','P K','PREK','PRE K','PRE KINDER','PREKINDER'];
-        if (in_array($g, $pk, true)) return -1;
-        // Youth variants: Y, YOUTH, Y1, YOUTH2 -> map to 10+
-        if (preg_match('/^Y(?:OUTH)?\s*(\d+)?$/', $g, $m)) {
-            $n = isset($m[1]) && $m[1] !== '' ? max(1, (int)$m[1]) : 1;
-            $gradeFee = (int)($this->configModel->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;
-    }
-
-    /** Get current invoice balance = total - payments - discounts - refundsPaid (no school_year filter). */
-    private function getCurrentInvoiceBalance(int $invoiceId): float
-    {
-        $invoice = $this->invoiceModel->find($invoiceId);
-        if (!$invoice) return 0.0;
-
-        $db       = $this->db;
-        $table    = $this->paymentModel->table;        // usually 'payments'
-        $hasStatus = $db->fieldExists('status', $table);
-        $hasVoid  = $db->fieldExists('is_void', $table);
-
-        $qb = $this->paymentModel
-            ->select('COALESCE(SUM(paid_amount),0) AS total_paid')
-            ->where('invoice_id', $invoiceId);
-
-        if ($hasStatus) {
-            $qb->groupStart()
-                ->whereNotIn('status', ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'])
-                ->orWhere('status IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        if ($hasVoid) {
-            $qb->groupStart()
-                ->where('is_void', 0)
-                ->orWhere('is_void IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        $row       = $qb->first();
-        $totalPaid = (float)($row['total_paid'] ?? 0);
-
-        // Discount sum on this invoice
-        $discRow = $this->db->table('discount_usages')
-            ->select('COALESCE(SUM(discount_amount),0) AS total_disc')
-            ->where('invoice_id', $invoiceId)
-            ->get()->getRowArray();
-        $totalDisc = (float)($discRow['total_disc'] ?? 0);
-
-        // Refunds paid
-        $refundRow = $this->db->table('refunds')
-            ->select('COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid')
-            ->where('invoice_id', $invoiceId)
-            ->whereIn('status', ['Partial','Paid'])
-            ->get()->getRowArray();
-        $totalRefundPaid = (float)($refundRow['total_refund_paid'] ?? 0);
-
-        $total     = (float)($invoice['total_amount'] ?? 0);
-
-        return max(0.0, round($total - $totalPaid - $totalDisc - $totalRefundPaid, 2));
-    }
-
-    /** Balance excluding a specific payment (for edit scenarios) and subtracting discounts/refunds. */
-    private function getCurrentInvoiceBalanceExcludingPayment(int $invoiceId, int $excludePaymentId): float
-    {
-        $invoice = $this->invoiceModel->find($invoiceId);
-        if (!$invoice) return 0.0;
-
-        $db       = $this->db;
-        $table    = $this->paymentModel->table;
-        $hasStatus = $db->fieldExists('status', $table);
-        $hasVoid  = $db->fieldExists('is_void', $table);
-
-        $qb = $this->paymentModel
-            ->select('COALESCE(SUM(paid_amount),0) AS total_paid')
-            ->where('invoice_id', $invoiceId)
-            ->where('id !=', $excludePaymentId);
-
-        if ($hasStatus) {
-            $qb->groupStart()
-                ->whereNotIn('status', ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'])
-                ->orWhere('status IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        if ($hasVoid) {
-            $qb->groupStart()
-                ->where('is_void', 0)
-                ->orWhere('is_void IS NULL', null, false)
-                ->groupEnd();
-        }
-
-        $row       = $qb->first();
-        $totalPaid = (float)($row['total_paid'] ?? 0);
-
-        // Discount sum on this invoice
-        $discRow = $this->db->table('discount_usages')
-            ->select('COALESCE(SUM(discount_amount),0) AS total_disc')
-            ->where('invoice_id', $invoiceId)
-            ->get()->getRowArray();
-        $totalDisc = (float)($discRow['total_disc'] ?? 0);
-
-        // Refunds paid
-        $refundRow = $this->db->table('refunds')
-            ->select('COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid')
-            ->where('invoice_id', $invoiceId)
-            ->whereIn('status', ['Partial','Paid'])
-            ->get()->getRowArray();
-        $totalRefundPaid = (float)($refundRow['total_refund_paid'] ?? 0);
-
-        $total     = (float)($invoice['total_amount'] ?? 0);
-
-        return max(0.0, round($total - $totalPaid - $totalDisc - $totalRefundPaid, 2));
-    }
-
-
-    /**
-     * 🔄 Helper: Get current invoice balance based on actual payments
-     */
-
-    function formatPhone($input)
-    {
-        // Remove any non-digits just in case
-        $digits = preg_replace('/\D/', '', $input);
-
-        if (strlen($digits) !== 10) {
-            return $input; // Return original if not exactly 10 digits
-        }
-
-        return sprintf(
-            '(%s)-%s-%s',
-            substr($digits, 0, 3),
-            substr($digits, 3, 3),
-            substr($digits, 6, 4)
-        );
-    }
-
-    private function processPayment(
-        $invoiceId,
-        $amount,
-        $paymentMethod,
-        $checkFile = null,
-        $transactionId = null,
-        $paymentDate = null,
-        $schoolYear = null,
-        $semester = null,
-        $checkNumber = null,
-        ?int $installmentSeq = null // <-- NOW: the installment sequence (1,2,3,...) for this invoice
-    ) {
-        $invoice = $this->invoiceModel->find($invoiceId);
-        if (!$invoice) {
-            return false;
-        }
-
-        $transactionId = $transactionId ?? 'INV-' . $invoiceId . '-' . time();
-        $paymentDate   = $paymentDate   ?? utc_now();
-
-        // If sequence wasn't provided (legacy callers), compute it here.
-        // NOTE: If you call this from inside a transaction (recommended), this will be consistent.
-        if ($installmentSeq === null || $installmentSeq < 1) {
-            $exclude = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
-            $priorCount = $this->paymentModel
-                ->where('invoice_id', $invoiceId)
-                ->where('paid_amount >', 0)
-                ->whereNotIn('status', $exclude)
-                ->countAllResults();
-            $installmentSeq = $priorCount + 1;
-        }
-
-
-        // Compute new totals
-        $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']; // fallback
-        }
-
-        // Update invoice
-        $invoiceUpdateData = [
-            'paid_amount' => $newPaid,
-            'balance'     => $newBalance,
-            'status'      => $paymentStatus,
-            'updated_by'  => session()->get('user_id'),
-        ];
-        if (!$this->invoiceModel->update($invoiceId, $invoiceUpdateData)) {
-            return false;
-        }
-
-        // Store the *sequence* in number_of_installments (kept for schema compatibility)
-        // Consider renaming the column to `installment_seq` in a future migration.
-        $paymentData = [
-            'parent_id'              => $invoice['parent_id'],
-            'invoice_id'             => $invoiceId,
-            'total_amount'           => $invoice['total_amount'],
-            'paid_amount'            => $amount,
-            'balance'                => $newBalance,
-            'number_of_installments' => $installmentSeq, // <-- installment sequence (1,2,3,...)
-            'transaction_id'         => $transactionId,
-            'payment_method'         => strtolower($paymentMethod),
-            'payment_date'           => $paymentDate,
-            'status'                 => $paymentStatus,
-            'check_file'             => $checkFile,
-            'check_number'           => (strtolower($paymentMethod) === 'check') ? $checkNumber : null,
-            'updated_by'             => session()->get('user_id'),
-            'school_year'            => $schoolYear ?? $this->schoolYear,
-            'semester'               => $semester   ?? $this->semester,
-            // 'installment_index'    => $installmentSeq, // use if you add a dedicated column later
-        ];
-
-        if (!$this->paymentModel->insert($paymentData)) {
-            return false;
-        }
-
-        return true;
-    }
-
-    private function getSuccessfulPaymentCount(int $invoiceId): int
-    {
-        $exclude = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
-
-        return $this->paymentModel
-            ->where('invoice_id', $invoiceId)
-            ->where('paid_amount >', 0)
-            ->whereNotIn('status', $exclude)
-            ->countAllResults();
-    }
-
-    public function serveCheckFile($filename, $mode = 'download')
-    {
-        $filename = basename($filename);
-        $roots = [
-            WRITEPATH . 'uploads/checks/' . $filename,
-            WRITEPATH . 'uploads/cards/'  . $filename,
-            WRITEPATH . 'uploads/misc/'   . $filename,
-            WRITEPATH . 'uploads/'        . $filename, // final fallback
-        ];
-
-        $path = null;
-        foreach ($roots as $candidate) {
-            if (is_file($candidate)) {
-                $path = $candidate;
-                break;
-            }
-        }
-
-        if (!$path) {
-            throw new \CodeIgniter\Exceptions\PageNotFoundException('Payment file not found: ' . esc($filename));
-        }
-
-        if ($mode === 'inline') {
-            return $this->response
-                ->setHeader('Content-Type', mime_content_type($path))
-                ->setHeader('Content-Disposition', 'inline; filename="' . $filename . '"')
-                ->setBody(file_get_contents($path));
-        }
-
-        return $this->response->download($path, null);
-    }
-}
diff --git a/app/Http/Controllers/old/PaymentNotificationController.php b/app/Http/Controllers/old/PaymentNotificationController.php
deleted file mode 100644
index 17eed995..00000000
--- a/app/Http/Controllers/old/PaymentNotificationController.php
+++ /dev/null
@@ -1,365 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-use App\Controllers\BaseController;
-use App\Models\PaymentNotificationLogModel;
-use App\Models\UserModel;
-use App\Models\ConfigurationModel;
-use App\Models\InvoiceModel;
-use App\Models\PaymentModel;
-use App\Models\FamilyGuardianModel;
-use App\Services\EmailService;
-use App\Services\NotificationService;
-
-class PaymentNotificationController extends BaseController
-{
-    protected PaymentNotificationLogModel $logModel;
-    protected UserModel $userModel;
-    protected ConfigurationModel $configModel;
-    protected InvoiceModel $invoiceModel;
-    protected PaymentModel $paymentModel;
-    protected FamilyGuardianModel $familyGuardianModel;
-    protected EmailService $emailService;
-
-    public function __construct()
-    {
-        $this->logModel  = new PaymentNotificationLogModel();
-        $this->userModel = new UserModel();
-        $this->configModel = new ConfigurationModel();
-        $this->invoiceModel = new InvoiceModel();
-        $this->paymentModel = new PaymentModel();
-        $this->familyGuardianModel = new FamilyGuardianModel();
-        $this->emailService = new EmailService();
-    }
-
-    public function index()
-    {
-        helper(['form', 'url']);
-
-        $from = $this->request->getGet('from');
-        $to   = $this->request->getGet('to');
-        $type = $this->request->getGet('type');
-
-        $rows = $this->logModel->listLogs($from, $to, $type);
-
-        // Preload parent names
-        $parents = [];
-        foreach ($rows as $r) {
-            $pid = (int) ($r['parent_id'] ?? 0);
-            if ($pid && !isset($parents[$pid])) {
-                $u = $this->userModel->select('firstname,lastname')->find($pid);
-                $parents[$pid] = trim(($u['firstname'] ?? '') . ' ' . ($u['lastname'] ?? ''));
-            }
-        }
-
-        return view('payment/notification_management', [
-            'logs'        => $rows,
-            'parentsById' => $parents,
-            'filters'     => ['from' => $from, 'to' => $to, 'type' => $type],
-        ]);
-    }
-
-    private function wantsJson(): bool
-    {
-        $accept = strtolower((string)($this->request->getHeaderLine('Accept') ?? ''));
-        $fmt    = strtolower((string)($this->request->getGet('format') ?? $this->request->getPost('format') ?? ''));
-        return $this->request->isAJAX() || str_contains($accept, 'application/json') || $fmt === 'json';
-    }
-
-    /**
-     * POST /api/payments/notifications/send
-     * Body: parent_id? (int), type? ('no_payment'|'installment'), school_year?
-     * - When parent_id provided: send for that parent only (if balance > 0 or force=1)
-     * - Otherwise: send to all parents with positive balance for selected school year
-     *   respecting idempotency (1 email per month/type) unless force=1.
-     */
-    public function send()
-    {
-        $parentId   = (int)($this->request->getPost('parent_id') ?? 0);
-        $typeInput  = (string)($this->request->getPost('type') ?? '');
-        $force      = (int)($this->request->getPost('force') ?? 0) === 1;
-        $schoolYear = (string)($this->request->getPost('school_year') ?? ($this->configModel->getConfig('school_year') ?? date('Y')));
-        $returnTo   = (string)($this->request->getPost('return_to') ?? '');
-
-        $tzName = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-        $tz   = new \DateTimeZone($tzName);
-        $now  = new \DateTime('now', $tz);
-        $year = (int)$now->format('Y');
-        $month= (int)$now->format('n');
-
-        // Helper: compute current total balance across invoices for this parent/year
-        $computeBalance = function (int $pid) use ($schoolYear): array {
-            $db = \Config\Database::connect();
-            $rows = $db->table('invoices')
-                ->select('id, total_amount')
-                ->where('parent_id', $pid)
-                ->where('school_year', $schoolYear)
-                ->get()->getResultArray();
-            $paymentsTbl = 'payments';
-            $hasStatus   = $db->fieldExists('status', $paymentsTbl);
-            $hasVoid     = $db->fieldExists('is_void', $paymentsTbl);
-
-            $sumBalance = 0.0; $latestId = null;
-            foreach ($rows as $ir) {
-                $iid = (int)$ir['id'];
-                if ($latestId === null) $latestId = $iid;
-                $total = (float)($ir['total_amount'] ?? 0);
-
-                $qb = $db->table('payments')->select('COALESCE(SUM(paid_amount),0) AS tot')->where('invoice_id', $iid);
-                if ($hasStatus) {
-                    $qb->groupStart()
-                        ->whereNotIn('status', ['void','voided','refunded','failed','chargeback','declined','reversed','canceled','cancelled'])
-                        ->orWhere('status IS NULL', null, false)
-                       ->groupEnd();
-                }
-                if ($hasVoid) {
-                    $qb->groupStart()
-                        ->where('is_void', 0)
-                        ->orWhere('is_void IS NULL', null, false)
-                       ->groupEnd();
-                }
-                $paid = (float)($qb->get()->getRowArray()['tot'] ?? 0);
-
-                $disc = (float)($db->table('discount_usages')->select('COALESCE(SUM(discount_amount),0) AS tot')->where('invoice_id', $iid)->get()->getRowArray()['tot'] ?? 0);
-                $rfnd = (float)($db->table('refunds')->select('COALESCE(SUM(refund_paid_amount),0) AS tot')->where('invoice_id', $iid)->whereIn('status', ['Partial','Paid'])->get()->getRowArray()['tot'] ?? 0);
-
-                $sumBalance += max(0.0, round($total - $disc - $paid - $rfnd, 2));
-            }
-            return [$sumBalance, $latestId];
-        };
-
-        // Helper: get secondary guardian email
-        $getSecondary = function (int $primaryUserId): ?string {
-            $row = $this->familyGuardianModel->where('user_id', $primaryUserId)->first();
-            if (!$row || empty($row['family_id'])) return null;
-            $others = $this->familyGuardianModel
-                ->where('family_id', (int)$row['family_id'])
-                ->where('user_id !=', $primaryUserId)
-                ->where('receive_emails', 1)
-                ->findAll();
-            foreach ($others as $g) {
-                $email = $this->userModel->select('email')->find((int)$g['user_id'])['email'] ?? null;
-                if ($email && filter_var($email, FILTER_VALIDATE_EMAIL)) return $email;
-            }
-            return null;
-        };
-
-        // Compose subject/body using same content as CLI command
-        $compose = function (int $pid, float $balance) use ($schoolYear, $now): array {
-            $u = $this->userModel->find($pid) ?: [];
-            $parentName = trim(($u['firstname'] ?? '') . ' ' . ($u['lastname'] ?? ''));
-            $greeting   = $parentName !== '' ? "Dear {$parentName}," : 'Dear Parent,';
-            $monthYear  = $now->format('F Y');
-            $subject    = sprintf('Monthly Tuition Reminder — %s', $schoolYear);
-            $balanceFmt = '$' . number_format($balance, 2);
-            $intro = 'This is your monthly installment reminder for ' . $schoolYear . '.';
-            // Compute remaining/max installments similar to Manual Payment UI
-            $installmentEndRaw = (string)$this->configModel->getConfig('installment_date');
-            $tzName = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-            $tz = new \DateTimeZone($tzName);
-            $today = new \DateTimeImmutable('today', $tz);
-            $end = null; try { if ($installmentEndRaw) { $end = new \DateTimeImmutable($installmentEndRaw, $tz); } } catch (\Throwable $e) { $end = null; }
-            $remMonths = 0;
-            if ($end) {
-                $y = (int)$end->format('Y') - (int)$today->format('Y');
-                $m = (int)$end->format('n') - (int)$today->format('n');
-                $remMonths = $y * 12 + $m;
-                if ((int)$end->format('j') > (int)$today->format('j')) $remMonths += 1;
-                if ($remMonths < 0) $remMonths = 0;
-            }
-            $remainingInst = max(1, $remMonths);
-            $maxInst = max(($remMonths ?: 0), ($balance > 0 ? 2 : 0));
-            $instDueFmt = '$' . number_format($remainingInst > 0 ? ($balance / $remainingInst) : 0, 2);
-            $bodyHtml = <<<HTML
-                <div style="font-family:Arial,Helvetica,sans-serif; font-size:14px; color:#212529; line-height:1.5;">
-                  <h2 style="margin:0 0 10px; font-size:18px;">Monthly Tuition Reminder</h2>
-                  <p>{$greeting}</p>
-                  <p>{$intro}</p>
-                  <p><strong>Current Outstanding Balance:</strong> {$balanceFmt}</p>
-                  <ul>
-                    <li><strong>Remaining installments:</strong> {$remainingInst}</li>
-                    <li><strong>Suggested installment this month:</strong> {$instDueFmt}</li>
-                    <li><strong>Maximum installments available:</strong> {$maxInst}</li>
-                  </ul>
-                  <p>As a friendly reminder, our tuition installments are due at the beginning of each month.</p>
-                  <p>You can review your invoice and payment options by logging in to your parent portal.</p>
-                  <p>Thank you for your prompt attention.</p>
-                  <p><em>Reminder Period:</em> {$monthYear}</p>
-                </div>
-            HTML;
-            $body = view('emails/_wrap_layout', [ 'title' => 'Monthly Tuition Reminder', 'body_html' => $bodyHtml ], ['saveData' => true]);
-            return [$subject, $body];
-        };
-
-        $results = [ 'sent' => 0, 'skipped' => 0, 'failed' => 0, 'details' => [] ];
-
-        if ($parentId > 0) {
-            [$balance, $latestInv] = $computeBalance($parentId);
-
-            // detect type if not provided
-            if ($typeInput === 'no_payment' || $typeInput === 'installment') {
-                $type = $typeInput;
-            } else {
-                $hasPayments = $this->paymentModel
-                    ->where('parent_id', $parentId)
-                    ->where('school_year', $schoolYear)
-                    ->countAllResults() > 0;
-                $type = $hasPayments ? 'installment' : 'no_payment';
-            }
-
-            // Idempotency: skip if already sent this month for this type
-            if (!$force && $this->logModel->existsForPeriod($parentId, $year, $month, $type)) {
-                $results['skipped']++;
-                $results['details'][] = ['parent_id' => $parentId, 'result' => 'already_sent'];
-            } else {
-                
-                if ($balance <= 0 && !$force) {
-                    $results['skipped']++;
-                    $results['details'][] = ['parent_id' => $parentId, 'result' => 'no_balance'];
-                // For HTML submit, redirect back with details
-                if (!$this->wantsJson()) {
-                    $dest = $returnTo !== '' ? $returnTo : site_url('payment/unpaid-parents?school_year=' . rawurlencode($schoolYear));
-                    return redirect()->to($dest)->with('status', 'No balance to remind this parent.');
-                }
-            } else {
-                // Compute current-month installment suggestion
-                $installmentEndRaw = (string)$this->configModel->getConfig('installment_date');
-                $tzName   = (string) (config('School')->attendance['timezone'] ?? user_timezone());
-                $tz   = new \DateTimeZone($tzName);
-                $nowD = new \DateTimeImmutable('today', $tz);
-                $endD = null; try { if ($installmentEndRaw) $endD = new \DateTimeImmutable($installmentEndRaw, $tz); } catch (\Throwable $e) { $endD = null; }
-                $remMonths = 0;
-                if ($endD) {
-                    $y = (int)$endD->format('Y') - (int)$nowD->format('Y');
-                    $m = (int)$endD->format('n') - (int)$nowD->format('n');
-                    $remMonths = $y * 12 + $m;
-                    if ((int)$endD->format('j') > (int)$nowD->format('j')) $remMonths += 1;
-                    if ($remMonths < 0) $remMonths = 0;
-                }
-                $remInst = max(1, $remMonths);
-                $instDue = round($balance / $remInst, 2);
-                $toEmail = $this->userModel->select('email')->find($parentId)['email'] ?? null;
-                $toEmail = $toEmail && filter_var($toEmail, FILTER_VALIDATE_EMAIL) ? $toEmail : null;
-                $ccEmail = $getSecondary($parentId);
-                [$subject, $body] = $compose($parentId, $balance);
-
-                $ok = $toEmail ? $this->emailService->send($toEmail, $subject, $body, 'finance') : false;
-                if ($ok && $ccEmail && strcasecmp($ccEmail, (string)$toEmail) !== 0) {
-                    $this->emailService->send($ccEmail, $subject, $body, 'finance');
-                }
-
-                $this->logModel->insert([
-                    'parent_id'        => $parentId,
-                    'invoice_id'       => $latestInv,
-                    'school_year'      => $schoolYear,
-                    'period_year'      => $year,
-                    'period_month'     => $month,
-                    'type'             => $type,
-                    'to_email'         => $toEmail,
-                    'cc_email'         => $ccEmail,
-                    'head_fa_notified' => 0,
-                    'subject'          => $subject,
-                    'body'             => $body,
-                    'status'           => $ok ? 'sent' : 'failed',
-                    'error_message'    => $ok ? null : 'Missing/invalid email or send failed',
-                    'balance_snapshot' => $balance,
-                    'sent_at'          => $now->format('Y-m-d H:i:s'),
-                ]);
-
-                if ($ok) { $results['sent']++; $results['details'][] = ['parent_id' => $parentId, 'result' => 'sent', 'balance' => $balance, 'installment_due' => $instDue, 'remaining' => $remInst]; }
-                else { $results['failed']++; $results['details'][] = ['parent_id' => $parentId, 'result' => 'failed']; }
-
-                // For HTML submit, redirect back with detailed message
-                if (!$this->wantsJson()) {
-                    $dest = $returnTo !== '' ? $returnTo : site_url('payment/unpaid-parents?school_year=' . rawurlencode($schoolYear));
-                    $msg = sprintf('Reminder sent. Remaining balance: $%s. Current installment due: $%s. Remaining installments: %d',
-                        number_format($balance, 2), number_format($instDue, 2), (int)$remInst);
-                    return redirect()->to($dest)->with('status', $msg);
-                }
-            }
-        }
-
-        // Single-parent branch handled; otherwise do bulk
-        } else {
-
-        // Bulk: parents with positive balance in selected year
-        $db = \Config\Database::connect();
-        $rows = $db->table('invoices')
-            ->select('DISTINCT parent_id', false)
-            ->where('school_year', $schoolYear)
-            ->get()->getResultArray();
-        $pids = array_values(array_unique(array_map(static fn($r) => (int)$r['parent_id'], $rows)));
-
-        foreach ($pids as $pid) {
-            [$balance, $latestInv] = $computeBalance($pid);
-            if ($balance <= 0 && !$force) { $results['skipped']++; continue; }
-
-            $hasPayments = $this->paymentModel
-                ->where('parent_id', $pid)
-                ->where('school_year', $schoolYear)
-                ->countAllResults() > 0;
-            $type = $hasPayments ? 'installment' : 'no_payment';
-
-            if (!$force && $this->logModel->existsForPeriod($pid, $year, $month, $type)) { $results['skipped']++; continue; }
-
-            $toEmail = $this->userModel->select('email')->find($pid)['email'] ?? null;
-            $toEmail = $toEmail && filter_var($toEmail, FILTER_VALIDATE_EMAIL) ? $toEmail : null;
-            $ccEmail = $getSecondary($pid);
-            [$subject, $body] = $compose($pid, $balance);
-
-            $ok = $toEmail ? $this->emailService->send($toEmail, $subject, $body, 'finance') : false;
-            if ($ok && $ccEmail && strcasecmp($ccEmail, (string)$toEmail) !== 0) {
-                $this->emailService->send($ccEmail, $subject, $body, 'finance');
-            }
-
-            // Optional: notify head of finance in-app
-            foreach ($this->getHeadOfFinanceUsers() as $u) {
-                NotificationService::toUser((int)$u['id'], 'Payment Reminder Sent',
-                    sprintf('A %s reminder was sent to parent #%d (balance: $%0.2f).', $type, $pid, $balance),
-                    ['in_app']
-                );
-            }
-
-            $this->logModel->insert([
-                'parent_id'        => $pid,
-                'invoice_id'       => $latestInv,
-                'school_year'      => $schoolYear,
-                'period_year'      => $year,
-                'period_month'     => $month,
-                'type'             => $type,
-                'to_email'         => $toEmail,
-                'cc_email'         => $ccEmail,
-                'head_fa_notified' => 1,
-                'subject'          => $subject,
-                'body'             => $body,
-                'status'           => $ok ? 'sent' : 'failed',
-                'error_message'    => $ok ? null : 'Missing/invalid email or send failed',
-                'balance_snapshot' => $balance,
-                'sent_at'          => $now->format('Y-m-d H:i:s'),
-            ]);
-
-            if ($ok) $results['sent']++; else $results['failed']++;
-        }
-
-        }
-
-        // Respond
-        if ($this->wantsJson()) {
-            return $this->response->setJSON(['ok' => true] + $results + [
-                'csrf_token' => csrf_token(), 'csrf_hash' => csrf_hash(),
-            ]);
-        }
-
-        $msg = sprintf('Reminders — sent: %d, skipped: %d, failed: %d', (int)$results['sent'], (int)$results['skipped'], (int)$results['failed']);
-        $dest = $returnTo !== '' ? $returnTo : site_url('payment/unpaid-parents?school_year=' . rawurlencode($schoolYear));
-        return redirect()->to($dest)->with('status', $msg);
-    }
-
-    private function getHeadOfFinanceUsers(): array
-    {
-        $heads = $this->userModel->getUsersByRole('head of department (finance)');
-        if (!empty($heads)) return $heads;
-        $acct = $this->userModel->getUsersByRole('accountant');
-        return $acct ?: [];
-    }
-}
diff --git a/app/Http/Controllers/old/PaymentTransactionController.php b/app/Http/Controllers/old/PaymentTransactionController.php
deleted file mode 100644
index 461f51d7..00000000
--- a/app/Http/Controllers/old/PaymentTransactionController.php
+++ /dev/null
@@ -1,84 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Models\PaymentTransactionModel;
-use CodeIgniter\RESTful\ResourceController;
-
-class PaymentTransactionController extends ResourceController
-{
-    protected $paymentTransactionModel;
-
-    public function __construct()
-    {
-        $this->paymentTransactionModel = new PaymentTransactionModel();
-    }
-
-    // API: Create a new payment transaction (installment)
-    public function createAPI()
-    {
-        $data = [
-            'transaction_id' => $this->request->getPost('transaction_id'),
-            'payment_id' => $this->request->getPost('payment_id'),
-            'transaction_date' => $this->request->getPost('transaction_date'),
-            'amount' => $this->request->getPost('amount'),
-            'payment_method' => $this->request->getPost('payment_method'),
-            'payment_status' => 'Pending',
-            'transaction_fee' => $this->request->getPost('transaction_fee'),
-            'payment_reference' => $this->request->getPost('payment_reference'),
-            'is_full_payment' => $this->request->getPost('is_full_payment') ? 1 : 0,
-        ];
-
-        if ($this->paymentTransactionModel->save($data)) {
-            return $this->respondCreated($data);
-        } else {
-            return $this->failValidationErrors($this->paymentTransactionModel->errors());
-        }
-    }
-
-    // API: Get all transactions for a specific payment
-    public function getByPaymentAPI($paymentId)
-    {
-        $transactions = $this->paymentTransactionModel->getTransactionsByPaymentId($paymentId);
-        if ($transactions) {
-            return $this->respond($transactions);
-        } else {
-            return $this->failNotFound('Transactions not found for the payment.');
-        }
-    }
-
-    // View: Get all transactions for a specific payment (for web views)
-    public function getByPayment($paymentId)
-    {
-        $transactions = $this->paymentTransactionModel->getTransactionsByPaymentId($paymentId);
-        return view('payment_transaction_list', ['transactions' => $transactions]);
-    }
-
-    // View: Create a new payment transaction
-    public function create()
-    {
-        return view('payment_transaction_create');
-    }
-
-    // API: Update payment status by transaction ID
-    public function updateStatusAPI($transactionId)
-    {
-        $status = $this->request->getPost('status');
-        if ($this->paymentTransactionModel->updateTransactionStatus($transactionId, $status)) {
-            return $this->respond(['status' => 'success']);
-        } else {
-            return $this->failNotFound('Transaction not found.');
-        }
-    }
-
-    // View: Update payment status by transaction ID
-    public function updateStatus($transactionId)
-    {
-        $status = $this->request->getPost('status');
-        if ($this->paymentTransactionModel->updateTransactionStatus($transactionId, $status)) {
-            return redirect()->to('/payment_transactions');
-        } else {
-            return redirect()->back()->with('error', 'Failed to update status.');
-        }
-    }
-}
\ No newline at end of file
diff --git a/app/Http/Controllers/old/PaypalTransactionsController.php b/app/Http/Controllers/old/PaypalTransactionsController.php
deleted file mode 100644
index 370d991c..00000000
--- a/app/Http/Controllers/old/PaypalTransactionsController.php
+++ /dev/null
@@ -1,99 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Controllers\BaseController;
-use App\Models\PayPalPaymentModel;
-use App\Models\PaymentModel;
-use App\Models\UserModel;
-use App\Models\ConfigurationModel;
-use App\Models\InvoiceModel;
-
-class PaypalTransactionsController extends BaseController
-{
-    public function index()
-    {
-        $model = new PayPalPaymentModel();
-
-        $keyword = $this->request->getGet('q');
-        $perPage = 10;
-
-        if ($keyword) {
-            $transactions = $model
-                ->groupStart()
-                    ->like('transaction_id', $keyword)
-                    ->orLike('payer_email', $keyword)
-                    ->orLike('event_type', $keyword)
-                    ->orLike('order_id', $keyword)
-                    ->orLike('parent_school_id', $keyword)
-                ->groupEnd()
-                ->orderBy('created_at', 'DESC')
-                ->paginate($perPage);
-        } else {
-            $transactions = $model
-                ->orderBy('created_at', 'DESC')
-                ->paginate($perPage);
-        }
-
-        return view('administrator/paypal_transactions', [
-            'transactions' => $transactions,
-            'pager' => $model->pager,
-            'keyword' => $keyword
-        ]);
-    }
-
-    public function exportCsv()
-    {
-        $model = new PayPalPaymentModel();
-        $keyword = $this->request->getGet('q');
-
-        if ($keyword) {
-            $transactions = $model
-                ->groupStart()
-                    ->like('transaction_id', $keyword)
-                    ->orLike('payer_email', $keyword)
-                    ->orLike('event_type', $keyword)
-                    ->orLike('order_id', $keyword)
-                    ->orLike('parent_school_id', $keyword)
-                ->groupEnd()
-                ->orderBy('created_at', 'DESC')
-                ->findAll();
-        } else {
-            $transactions = $model->orderBy('created_at', 'DESC')->findAll();
-        }
-
-        $filename = 'paypal_transactions_' . date('Ymd_His') . '.csv';
-
-        header('Content-Type: text/csv');
-        header("Content-Disposition: attachment; filename=\"$filename\"");
-
-        $output = fopen('php://output', 'w');
-
-        // CSV headers
-        fputcsv($output, [
-            'ID', 'Transaction ID', 'Order ID', 'Parent School ID',
-            'Email', 'Amount', 'Net Amount', 'Currency',
-            'Status', 'Event Type', 'Created At'
-        ]);
-
-        foreach ($transactions as $t) {
-            fputcsv($output, [
-                $t['id'],
-                $t['transaction_id'],
-                $t['order_id'],
-                $t['parent_school_id'],
-                $t['payer_email'],
-                $t['amount'],
-                $t['net_amount'],
-                $t['currency'],
-                $t['status'],
-                $t['event_type'],
-                $t['created_at'],
-            ]);
-        }
-
-        fclose($output);
-        exit;
-    }
-
-}
diff --git a/app/Http/Controllers/old/PhoneFormatterService.php b/app/Http/Controllers/old/PhoneFormatterService.php
new file mode 100644
index 00000000..9cd47f76
--- /dev/null
+++ b/app/Http/Controllers/old/PhoneFormatterService.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Services;
+
+class PhoneFormatterService
+{
+    /**
+     * Format a raw phone number to (xxx)-xxx-xxxx format
+     *
+     * @param string $number
+     * @return string|null
+     */
+    public function formatPhoneNumber(string $number): ?string
+    {
+        // Remove non-digit characters
+        $digits = preg_replace('/\D/', '', $number);
+
+        // Ensure it's exactly 10 digits
+        if (strlen($digits) === 10) {
+            return sprintf(
+                '%s-%s-%s',
+                substr($digits, 0, 3),
+                substr($digits, 3, 3),
+                substr($digits, 6)
+            );
+        }
+
+        // Invalid number
+        return null;
+    }
+}
diff --git a/app/Http/Controllers/old/ProjectController.php b/app/Http/Controllers/old/ProjectController.php
deleted file mode 100644
index 21eea661..00000000
--- a/app/Http/Controllers/old/ProjectController.php
+++ /dev/null
@@ -1,540 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Models\ProjectModel;
-use App\Models\StudentModel;
-use App\Models\StudentClassModel;
-use CodeIgniter\Controller;
-use App\Models\TeacherClassModel;
-use App\Models\ConfigurationModel;
-use RuntimeException;
-use App\Services\SemesterScoreService;
-use Config\Services;
-use App\Models\GradingLockModel;
-use App\Models\MissingScoreOverrideModel;
-
-
-class ProjectController extends Controller
-{
-    protected $db;
-    protected ConfigurationModel $configModel;
-    protected string $schoolYear;
-    protected $semesterScoreService;
-    protected $gradingLockModel;
-    protected $missingScoreOverrideModel;
-
-    public function __construct()
-    {
-        $this->semesterScoreService = service('semesterScoreService');
-        $this->db = \Config\Database::connect();
-        $this->configModel = new ConfigurationModel();
-        $this->schoolYear = (string) ($this->configModel->getConfig('school_year') ?? '');
-        $this->gradingLockModel = new GradingLockModel();
-        $this->missingScoreOverrideModel = new MissingScoreOverrideModel();
-    }
-
-    public function addProject()
-    {
-        $updatedBy = session()->get('user_id');
-        $teacherClassModel = new TeacherClassModel();
-        $studentClassModel = new StudentClassModel();
-        $studentModel = new StudentModel();
-        $projectModel = new ProjectModel();
-
-        $teacherClass = $teacherClassModel->where('teacher_id', $updatedBy)->first();
-        if (!$teacherClass) {
-            return redirect()->back()->with('status', 'No class section found for the current teacher.');
-        }
-
-        $classSectionId = $teacherClass['class_section_id'];
-        session()->set('class_section_id', $classSectionId);
-
-        $semester = $this->getTeacherSelectedSemester();
-        $schoolYear = $this->getTeacherSchoolYear();
-
-        $projectRows = $projectModel
-            ->select('id, project_index')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->orderBy('project_index', 'ASC')
-            ->findAll();
-
-        $projectHeaders = [];
-        foreach ($projectRows as $row) {
-            $projectHeaders[$row['project_index']][] = $row['id'];
-        }
-
-        $headerLabels = array_keys($projectHeaders);
-
-        $studentsClasses = $studentClassModel
-            ->active()
-            ->where('student_class.class_section_id', $classSectionId)
-            ->findAll();
-        $students = [];
-
-        foreach ($studentsClasses as $studentClass) {
-            $studentId = $studentClass['student_id'];
-            $student = $studentModel
-                ->where('id', $studentId)
-                ->where('is_active', 1)
-                ->first();
-
-            if ($student) {
-                $scores = [];
-                foreach ($projectHeaders as $index => $ids) {
-                    $entry = $projectModel
-                        ->where('student_id', $studentId)
-                        ->where('project_index', $index)
-                        ->where('class_section_id', $classSectionId)
-                        ->where('semester', $semester)
-                        ->where('school_year', $schoolYear)
-                        ->first();
-
-                    $scores[$index] = $entry['score'] ?? '';
-                }
-
-                $students[] = [
-                    'student_id' => $studentId,
-                    'firstname'  => $student['firstname'],
-                    'lastname'   => $student['lastname'],
-                    'scores'     => $scores
-                ];
-            }
-        }
-
-        usort($students, fn($a, $b) => strcmp($a['lastname'], $b['lastname']) ?: strcmp($a['firstname'], $b['firstname']));
-
-        return view('/teacher/add_project', [
-            'students' => $students,
-            'projectHeaders' => $headerLabels,
-            'semester' => $semester,
-            'schoolYear' => $schoolYear,
-            'missingOkMap' => $this->missingScoreOverrideModel->getOverridesMap($classSectionId, $semester, $schoolYear, 'project'),
-        ]);
-    }
-
-    public function updateProjectScores(array $scores = null, int $updatedBy = null, int $classSectionId = null)
-    {
-        $scores = $this->request->getPost('scores');
-        $projectModel = new ProjectModel();
-        $studentModel = new StudentModel();
-
-        if ($updatedBy === null) {
-            $updatedBy = session()->get('user_id');
-        }
-        $classSectionId = session()->get('class_section_id');
-        $semester = $this->getTeacherSelectedSemester();
-        $schoolYear = $this->getTeacherSchoolYear();
-        $classSectionId = (int) ($classSectionId ?? 0);
-        if ($classSectionId > 0 && $this->isScoresLocked($classSectionId, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-
-        if (!is_array($scores)) {
-            return redirect()->back()->with('error', 'No project scores submitted.');
-        }
-
-        $missingOk = $this->request->getPost('missing_ok') ?? [];
-        $studentIds = array_keys($scores);
-        $indexSet = [];
-        foreach ($scores as $studentId => $projects) {
-            if (!is_array($projects)) {
-                continue;
-            }
-            foreach ($projects as $index => $score) {
-                if (is_numeric($index)) {
-                    $indexSet[(int)$index] = true;
-                }
-            }
-        }
-        $checkedItems = [];
-        if (is_array($missingOk)) {
-            foreach ($missingOk as $studentId => $indexes) {
-                if (!is_array($indexes)) {
-                    continue;
-                }
-                foreach ($indexes as $index => $flag) {
-                    if (!is_numeric($index)) {
-                        continue;
-                    }
-                    $checkedItems[] = [
-                        'student_id' => (int) $studentId,
-                        'item_index' => (int) $index,
-                    ];
-                }
-            }
-        }
-        $this->missingScoreOverrideModel->replaceOverrides(
-            $classSectionId,
-            (string) $semester,
-            (string) $schoolYear,
-            'project',
-            $studentIds,
-            array_keys($indexSet),
-            $checkedItems,
-            $updatedBy
-        );
-
-        foreach ($scores as $studentId => $projects) {
-            if (!is_numeric($studentId)) continue;
-
-            $student = $studentModel->find($studentId);
-            if (!$student) continue;
-
-            foreach ($projects as $index => $score) {
-                $normalizedScore = is_numeric($score) ? (float) $score : null;
-
-                $existing = $projectModel->where([
-                    'student_id' => $studentId,
-                    'project_index' => $index,
-                    'class_section_id' => $classSectionId,
-                    'semester' => $semester
-                ])->first();
-
-                $data = [
-                    'student_id' => $studentId,
-                    'school_id' => $student['school_id'],
-                    'class_section_id' => $classSectionId,
-                    'updated_by' => $updatedBy,
-                    'project_index' => $index,
-                    'score' => $normalizedScore,
-                    'semester' => $semester,
-                    'school_year' => $schoolYear,
-                    'updated_at' => utc_now(),
-                ];
-
-                if ($existing) {
-                    $projectModel->update($existing['id'], $data);
-                } else {
-                    $data['created_at'] = utc_now();
-                    $projectModel->insert($data);
-                }
-            }
-        }
-
-        $studentTeacherInfo = $studentModel->getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear);
-        // Call the updateScoresForStudents method
-        try {
-
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-        return redirect()->to(base_url('/teacher/addProject'))->with('status', 'Project scores updated successfully.');
-    }
-
-    public function addNextProjectColumn()
-    {
-        $updatedBy = session()->get('user_id');
-        $classSectionId = session()->get('class_section_id');
-        $semester = $this->getTeacherSelectedSemester();
-        $schoolYear = $this->getTeacherSchoolYear();
-
-        $projectModel = new ProjectModel();
-        $studentClassModel = new StudentClassModel();
-
-        $existingIndexes = $projectModel
-            ->select('project_index')
-            ->where('class_section_id', $classSectionId)
-            ->where('updated_by', $updatedBy)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->groupBy('project_index')
-            ->orderBy('project_index', 'DESC')
-            ->findAll();
-
-        $maxIndex = 0;
-        foreach ($existingIndexes as $row) {
-            if (isset($row['project_index']) && is_numeric($row['project_index'])) {
-                $maxIndex = max($maxIndex, (int)$row['project_index']);
-            }
-        }
-
-        $nextIndex = $maxIndex + 1;
-
-        $students = $studentClassModel
-            ->active()
-            ->where('student_class.class_section_id', $classSectionId)
-            ->findAll();
-
-        foreach ($students as $student) {
-            $exists = $projectModel->where([
-                'student_id' => $student['student_id'],
-                'project_index' => $nextIndex,
-                'class_section_id' => $classSectionId,
-                'semester' => $semester,
-                'school_year' => $schoolYear,
-            ])->first();
-
-            if (!$exists) {
-                $projectModel->insert([
-                    'student_id' => $student['student_id'],
-                    'class_section_id' => $classSectionId,
-                    'updated_by' => $updatedBy,
-                    'project_index' => $nextIndex,
-                    'score' => null,
-                    'semester' => $semester,
-                    'school_year' => $schoolYear,
-                    'created_at' => utc_now(),
-                    'updated_at' => utc_now()
-                ]);
-            }
-        }
-
-        return $this->response->setJSON([
-            'status' => 'success',
-            'project_index' => $nextIndex
-        ]);
-    }
-
-    public function showProjectMngt()
-    {
-        // Accept POST first, then GET (query string), then session fallback
-        $incomingId = $this->request->getPost('class_section_id');
-        if (!$incomingId) {
-            $incomingId = $this->request->getGet('class_section_id');
-        }
-
-        $classSectionId = (int) ($incomingId ?: (session()->get('class_section_id') ?? 0));
-
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('status', 'No class section found for the current teacher or selection.');
-        }
-
-        session()->set('class_section_id', $classSectionId);
-
-        $semester   = $this->getTeacherSelectedSemester();
-        $schoolYear = $this->getTeacherSchoolYear();
-        $projectScores = $this->getProjectScoresByStudent($classSectionId, $semester, $schoolYear);
-        $students = $this->getStudentsByClassSectionAndYear($classSectionId, $schoolYear);
-        $projectHeaders = $this->getProjectHeaders($classSectionId, $semester, $schoolYear);
-        $scoresLocked = $this->isScoresLocked($classSectionId, $semester, $schoolYear);
-
-        return view('grading/project', [
-            'projectScores'     => $projectScores,
-            'students'          => $students,
-            'semester'          => $semester,
-            'schoolYear'        => $schoolYear,
-            'projectHeaders'    => $projectHeaders,
-            'classSectionId'    => $classSectionId,
-            'scoresLocked'      => $scoresLocked,
-        ]);
-    }
-
-    public function updateProject()
-    {
-        $studentModel = new StudentModel();
-        $scores       = $this->request->getPost('scores');
-        $studentIds   = $this->request->getPost('student_ids');
-        $semester     = $this->request->getPost('semester') ?? $this->getTeacherSelectedSemester();
-        $schoolYear   = $this->request->getPost('school_year') ?? $this->getTeacherSchoolYear();
-
-        $updatedBy = $this->request->getPost('teacher_id') ?? session()->get('user_id');
-        $classSectionId = $this->request->getPost('class_section_id') ?? session()->get('class_section_id'); // already stored in showProjectMngt
-        $classSectionId = (int) ($classSectionId ?? 0);
-        if ($classSectionId > 0 && $this->isScoresLocked($classSectionId, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-
-        if ($scores && $studentIds && $semester && $schoolYear && $classSectionId) {
-            $this->updateProjectScores($scores, $updatedBy, $classSectionId);
-            session()->setFlashdata('status', 'Project scores updated successfully.');
-
-            // ⬇️ Directly call the method and return its view
-            return $this->showProjectMngt($updatedBy);
-        }
-
-        $studentTeacherInfo = $studentModel->getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear);
-        // Call the updateScoresForStudents method
-        try {
-
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-        return redirect()->back()->with('status', 'Failed to update scores.');
-    }
-
-    private function isScoresLocked(int $classSectionId, string $semester, string $schoolYear): bool
-    {
-        return $this->gradingLockModel->isLocked($classSectionId, $semester, $schoolYear);
-    }
-
-    /**____________________helpers________________________ */
-
-    private function saveProjectScores(array $scores, array $studentIds, string $semester, string $schoolYear, int $updatedBy, int $classSectionId)
-    {
-        $projectModel = new \App\Models\ProjectModel();
-        $now = utc_now();
-
-        foreach ($studentIds as $studentId) {
-            if (!isset($scores[$studentId])) {
-                continue;
-            }
-
-            foreach ($scores[$studentId] as $index => $score) {
-                // Check if the record exists
-                $existing = $projectModel
-                    ->where('student_id', $studentId)
-                    ->where('project_index', $index)
-                    ->where('semester', $semester)
-                    ->where('school_year', $schoolYear)
-                    ->where('class_section_id', $classSectionId)
-                    ->where('updated_by', $updatedBy)
-                    ->first();
-
-                $data = [
-                    'student_id'       => $studentId,
-                    'class_section_id' => $classSectionId,
-                    'updated_by'       => $updatedBy,
-                    'project_index'   => $index,
-                    'score'            => is_numeric($score) ? floatval($score) : null,
-                    'semester'         => $semester,
-                    'school_year'      => $schoolYear,
-                    'updated_at'       => $now,
-                ];
-
-                if ($existing && isset($existing['id'])) {
-                    $projectModel->update($existing['id'], $data);
-                } else {
-                    $data['created_at'] = $now;
-                    $data['school_id'] = ''; // Set if needed
-                    $projectModel->insert($data);
-                }
-            }
-        }
-    }
-
-    private function getProjectHeaders($classSectionId, $semester, $schoolYear)
-    {
-        $projectModel = new ProjectModel();
-        $rows = $projectModel
-            ->select('project_index')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->orderBy('project_index', 'ASC')
-            ->findAll();
-
-        $headers = [];
-
-        foreach ($rows as $row) {
-            $index = $row['project_index'];
-            if (!is_array($index)) {
-                $headers[$index] = true;
-            }
-        }
-
-        ksort($headers);
-        return array_keys($headers);
-    }
-    private function getStudentsByClassSectionAndYear($classSectionId, $schoolYear)
-    {
-        $studentClassModel = new \App\Models\StudentClassModel();
-        $studentModel      = new \App\Models\StudentModel();
-
-        // Step 1: Get student IDs from student_class table
-        $studentClassRows = $studentClassModel
-            ->select('student_id')
-            ->where('class_section_id', $classSectionId)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        $studentIds = array_column($studentClassRows, 'student_id');
-
-        if (empty($studentIds)) {
-            return []; // No students found
-        }
-
-        // Step 2: Get student data from students table
-        $students = $studentModel
-            ->whereIn('id', $studentIds)
-            ->where('is_active', 1)
-            ->orderBy('lastname', 'ASC')
-            ->findAll();
-
-        return $students;
-    }
-
-    private function getClassSectionIdForTeacher($updatedBy)
-    {
-        $teacherClassModel = new TeacherClassModel();
-        $class = $teacherClassModel->where('teacher_id', $updatedBy)->first();
-        return $class['class_section_id'] ?? null;
-    }
-
-    private function getProjectScoresByStudent($classSectionId, $semester, $schoolYear)
-    {
-        $projectModel = new ProjectModel();
-
-        $rows = $projectModel
-            ->select('student_id, project_index, score')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        $studentScores = [];
-        foreach ($rows as $row) {
-            $studentId = $row['student_id'];
-            $index = $row['project_index'];
-            $score = $row['score'];
-
-            $studentScores[$studentId]['scores'][$index] = $score;
-        }
-
-        return $studentScores;
-    }
-
-    private function getStudentsWithProjectScores($classSectionId, $projectHeaders)
-    {
-        $studentClassModel = new StudentClassModel();
-        $studentModel = new StudentModel();
-        $projectModel = new ProjectModel();
-
-        $studentClasses = $studentClassModel
-            ->active()
-            ->where('student_class.class_section_id', $classSectionId)
-            ->findAll();
-        $students = [];
-
-        foreach ($studentClasses as $sc) {
-            $student = $studentModel
-                ->where('id', $sc['student_id'])
-                ->where('is_active', 1)
-                ->first();
-            if (!$student) continue;
-
-            $scores = [];
-            foreach ($projectHeaders as $index => $ids) {
-                $entry = $projectModel->where('project_index', $index)
-                    ->where('student_id', $sc['student_id'])
-                    ->first();
-                $scores[$index] = $entry['score'] ?? '';
-            }
-
-            $students[] = [
-                'student_id' => $sc['student_id'],
-                'firstname'  => $student['firstname'],
-                'lastname'   => $student['lastname'],
-                'scores'     => $scores
-            ];
-        }
-
-        usort($students, fn($a, $b) => strcmp($a['lastname'], $b['lastname']) ?: strcmp($a['firstname'], $b['firstname']));
-        return $students;
-    }
-
-    private function getTeacherSelectedSemester(): string
-    {
-        helper('semester_selection_helper');
-        return selected_teacher_semester();
-    }
-
-    private function getTeacherSchoolYear(): string
-    {
-        return (string) $this->schoolYear;
-    }
-}
diff --git a/app/Http/Controllers/old/QuizController.php b/app/Http/Controllers/old/QuizController.php
deleted file mode 100644
index 88923eb7..00000000
--- a/app/Http/Controllers/old/QuizController.php
+++ /dev/null
@@ -1,577 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use CodeIgniter\Controller;
-use App\Models\TeacherClassModel;
-use App\Models\StudentClassModel;
-use App\Models\StudentModel;
-use App\Models\QuizModel;
-use App\Models\HomeworkModel;
-use App\Models\UserModel;
-use App\Models\ConfigurationModel;
-use App\Controllers\View\GradingController;
-use RuntimeException;
-use App\Services\SemesterScoreService;
-use Config\Services;
-use App\Models\GradingLockModel;
-use App\Models\MissingScoreOverrideModel;
-
-class QuizController extends Controller
-{
-    protected $db;
-    protected $semesterScoreService;
-    protected $quizModel;
-    protected $configModel;
-    protected $homeworkModel;
-    protected $userModel;
-    protected $schoolYear;
-    protected $semester;
-    protected $studentClassModel;
-    protected $studentModel;
-    protected $teacherClassModel;
-    protected $gradingLockModel;
-    protected $missingScoreOverrideModel;
-
-    public function __construct()
-    {
-        $this->db = \Config\Database::connect();
-        $this->teacherClassModel = new TeacherClassModel();
-        $this->homeworkModel = new HomeworkModel();
-        $this->userModel = new UserModel();
-        $this->studentClassModel = new StudentClassModel();
-        $this->studentModel      = new StudentModel();
-        $this->configModel = new ConfigurationModel();
-        $this->quizModel         = new QuizModel();
-        $this->semesterScoreService = service('semesterScoreService');
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->gradingLockModel = new GradingLockModel();
-        $this->missingScoreOverrideModel = new MissingScoreOverrideModel();
-    }
-
-    public function updateQuizScores(array $scores = null, int $updatedBy = null, int $classSectionId = null)
-    {
-        $scores = $this->request->getPost('scores');
-        log_message('error', '✅ Raw Scores: ' . print_r($scores, true));
-
-        if ($updatedBy === null) {
-            $updatedBy = session()->get('user_id');
-        }
-        $classSectionId = $this->request->getPost('class_section_id') ?? session()->get('class_section_id');
-        $semester = $this->request->getPost('semester') ?? $this->getTeacherSelectedSemester();
-        $schoolYear = $this->request->getPost('school_year') ?? $this->schoolYear;
-        $classSectionId = (int) ($classSectionId ?? 0);
-        if ($classSectionId > 0 && $this->isScoresLocked($classSectionId, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-
-        $missingOk = $this->request->getPost('missing_ok') ?? [];
-        $studentIds = is_array($scores) ? array_keys($scores) : array_keys((array) $missingOk);
-        $indexSet = [];
-        if (is_array($scores)) {
-            foreach ($scores as $studentId => $quizData) {
-                if (!is_array($quizData)) {
-                    continue;
-                }
-                foreach ($quizData as $index => $score) {
-                    if (is_numeric($index)) {
-                        $indexSet[(int)$index] = true;
-                    }
-                }
-            }
-        }
-        $checkedItems = [];
-        if (is_array($missingOk)) {
-            foreach ($missingOk as $studentId => $indexes) {
-                if (!is_array($indexes)) {
-                    continue;
-                }
-                foreach ($indexes as $index => $flag) {
-                    if (!is_numeric($index)) {
-                        continue;
-                    }
-                    $checkedItems[] = [
-                        'student_id' => (int) $studentId,
-                        'item_index' => (int) $index,
-                    ];
-                }
-            }
-        }
-        $this->missingScoreOverrideModel->replaceOverrides(
-            $classSectionId,
-            (string) $semester,
-            (string) $schoolYear,
-            'quiz',
-            $studentIds,
-            array_keys($indexSet),
-            $checkedItems,
-            $updatedBy
-        );
-
-        if (is_array($scores)) {
-            foreach ($scores as $studentId => $quizData) {
-                if (!is_numeric($studentId) || $studentId <= 0) continue;
-
-                // Normalize: if single input submitted
-                if (!is_array($quizData)) {
-                    $quizData = [1 => $quizData];
-                }
-
-                foreach ($quizData as $quizNumber => $score) {
-                    if (!is_numeric($quizNumber)) continue;
-
-                    $isBlank = $score === null || (is_string($score) && trim($score) === '');
-                    $normalizedScore = (!$isBlank && is_numeric($score)) ? (float) $score : null;
-
-                    $existing = $this->quizModel->where([
-                        'student_id'       => $studentId,
-                        'quiz_index'      => $quizNumber,
-                        'class_section_id' => $classSectionId,
-                        'semester'         => $semester,
-                        'school_year'      => $schoolYear,
-                    ])->first();
-
-                    if ($isBlank) {
-                        if ($existing) {
-                            $this->quizModel->update($existing['id'], [
-                                'score'      => null,
-                                'updated_at' => utc_now(),
-                            ]);
-                        } else {
-                            $this->quizModel->insert([
-                                'student_id'       => $studentId,
-                                'school_id'        => '', // Optional
-                                'class_section_id' => $classSectionId,
-                                'updated_by'       => $updatedBy,
-                                'quiz_index'      => $quizNumber,
-                                'score'            => null,
-                                'semester'         => $semester,
-                                'school_year'      => $schoolYear,
-                                'created_at'       => utc_now(),
-                                'updated_at'       => utc_now()
-                            ]);
-                        }
-                        continue;
-                    }
-
-                    if ($existing) {
-                        $this->quizModel->update($existing['id'], [
-                            'score'      => $normalizedScore,
-                            'updated_at' => utc_now()
-                        ]);
-                        log_message('debug', "✅ Updated quiz ID {$existing['id']} with score {$normalizedScore}");
-                    } else {
-                        $this->quizModel->insert([
-                            'student_id'       => $studentId,
-                            'school_id'        => '', // Optional
-                            'class_section_id' => $classSectionId,
-                            'updated_by'       => $updatedBy,
-                            'quiz_index'      => $quizNumber,
-                            'score'            => $normalizedScore,
-                        'semester'         => $semester,
-                        'school_year'      => $schoolYear,
-                            'created_at'       => utc_now(),
-                            'updated_at'       => utc_now()
-                        ]);
-                        log_message('debug', "✅ Inserted quiz for student $studentId quiz $quizNumber with score $score");
-                    }
-                }
-            }
-        }
-
-        $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear);
-        // Call the updateScoresForStudents method
-        try {
-
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-        return redirect()->to(base_url('/teacher/addQuiz'))->with('status', 'Quiz scores updated successfully.');
-    }
-
-    public function addQuiz()
-    {
-        // 1) class_section_id from view (POST/GET) with session fallback
-        $incoming = $this->request->getPost('class_section_id')
-            ?? $this->request->getGet('class_section_id')
-            ?? session()->get('class_section_id');
-
-        $classSectionId = (int) ($incoming ?: 0);
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('status', 'Missing class section.');
-        }
-        session()->set('class_section_id', $classSectionId);
-
-        // 3) Headers: distinct quiz_index for this class/term
-        $semester = $this->getTeacherSelectedSemester();
-        $schoolYear = $this->schoolYear;
-        $quizHeaderRows = $this->quizModel->select('quiz_index')
-            ->where('class_section_id', $classSectionId)
-            ->where('school_year', $schoolYear)
-            ->where('semester', $semester)
-            ->groupBy('quiz_index')
-            ->orderBy('quiz_index', 'ASC')
-            ->get()->getResultArray();
-
-        $quizHeaders = array_map(static fn($r) => (int)$r['quiz_index'], $quizHeaderRows); // [1,2,3,...]
-
-        // 4) Roster (distinct students for this section/term)
-        $roster = $this->db->table('student_class sc')
-            ->select('s.id AS student_id, s.firstname, s.lastname, s.school_id')
-            ->distinct() // ✅ apply DISTINCT correctly
-            ->join('students s', 's.id = sc.student_id', 'inner')
-            ->where('sc.class_section_id', $classSectionId)
-            ->where('sc.school_year', $schoolYear)
-            ->orderBy('s.lastname', 'ASC')
-            ->orderBy('s.firstname', 'ASC')
-            ->get()->getResultArray();
-
-
-        // 5) All existing quiz scores (single query) -> pivot
-        $scoreRows = $this->quizModel->select('id, student_id, quiz_index, score')
-            ->where('class_section_id', $classSectionId)
-            ->where('school_year', $schoolYear)
-            ->where('semester', $semester)
-            ->get()->getResultArray();
-
-        $scoresMap = []; // [student_id][quiz_index] => score
-        $idMap     = []; // [student_id][quiz_index] => id (if you need to update existing rows)
-
-        foreach ($scoreRows as $r) {
-            $sid = (int)$r['student_id'];
-            $qi  = (int)$r['quiz_index'];
-            $scoresMap[$sid][$qi] = $r['score'];
-            $idMap[$sid][$qi]     = (int)$r['id'];
-        }
-
-        // 6) Build students array with per-quiz scores
-        $students = [];
-        foreach ($roster as $st) {
-            $sid = (int)$st['student_id'];
-
-            $quizScores = [];
-            foreach ($quizHeaders as $qi) {
-                $quizScores[$qi] = $scoresMap[$sid][$qi] ?? ''; // empty if none yet
-            }
-
-            $students[] = [
-                'student_id' => $sid,
-                'firstname'  => $st['firstname'],
-                'lastname'   => $st['lastname'],
-                'school_id'  => $st['school_id'] ?? null,
-                'scores'     => $quizScores,
-                // If your view needs existing row ids to decide update vs insert:
-                'existingIds' => $idMap[$sid] ?? [], // optional
-            ];
-        }
-
-        // 7) Render
-        return view('teacher/add_quiz', [
-            'students'       => $students,
-            'quizHeaders'    => $quizHeaders,  // e.g., [1,2,3]
-            'semester'       => $semester,
-            'schoolYear'     => $this->schoolYear,
-            'classSectionId' => $classSectionId,
-            'missingOkMap'   => $this->missingScoreOverrideModel->getOverridesMap($classSectionId, $semester, $this->schoolYear, 'quiz'),
-        ]);
-    }
-
-
-    public function addNextQuizColumn()
-    {
-        $updatedBy = session()->get('user_id');
-        $classSectionId = session()->get('class_section_id');
-
-        if (!$updatedBy || !$classSectionId) {
-            return $this->response->setJSON([
-                'status'  => 'error',
-                'message' => 'Missing teacher or class section data.'
-            ]);
-        }
-
-        try {
-
-        $semester = $this->getTeacherSelectedSemester();
-        $schoolYear = $this->schoolYear;
-        $existingQuizNumbers = $this->quizModel
-            ->select('quiz_index')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-                ->groupBy('quiz_index')
-                ->orderBy('quiz_index', 'DESC')
-                ->findAll();
-
-            $maxQuizNumber = 0;
-            foreach ($existingQuizNumbers as $row) {
-                if (is_numeric($row['quiz_index'])) {
-                    $maxQuizNumber = max($maxQuizNumber, (int)$row['quiz_index']);
-                }
-            }
-
-            $nextQuizNumber = $maxQuizNumber + 1;
-
-            if ($nextQuizNumber <= 0) {
-                return $this->response->setJSON([
-                    'status'     => 'error',
-                    'message'    => '🚫 Invalid quiz number',
-                    'calculated' => $nextQuizNumber
-                ]);
-            }
-
-            $students = $this->studentClassModel
-                ->where('class_section_id', $classSectionId)
-                ->findAll();
-
-            if (empty($students)) {
-                return $this->response->setJSON([
-                    'status'  => 'error',
-                    'message' => 'No students found in this class section.'
-                ]);
-            }
-
-            $firstInsertedId = null;
-
-            foreach ($students as $i => $student) {
-                $exists = $this->quizModel
-                    ->where([
-                        'student_id'       => $student['student_id'],
-                        'quiz_index'      => $nextQuizNumber,
-                        'class_section_id' => $classSectionId,
-                        'updated_by'       => $updatedBy,
-                        'semester'         => $this->semester,
-                        'school_year'      => $this->schoolYear,
-                    ])
-                    ->first();
-
-                if ($exists) continue;
-
-                $insertData = [
-                    'student_id'       => $student['student_id'],
-                    'class_section_id' => $classSectionId,
-                    'updated_by'       => $updatedBy,
-                    'quiz_index'      => $nextQuizNumber,
-                    'score'            => null,
-                    'semester'         => $semester,
-                    'school_year'      => $schoolYear,
-                    'created_at'       => utc_now(),
-                    'updated_at'       => utc_now(),
-                ];
-
-                log_message('error', '✅ Inserting quiz row: ' . json_encode($insertData));
-
-                try {
-                    $id = $this->quizModel->insert($insertData, true);
-                    if ($i === 0) $firstInsertedId = $id;
-                } catch (\Throwable $e) {
-                    return $this->response->setJSON([
-                        'status'  => 'error',
-                        'message' => '❌ Insert failed: ' . $e->getMessage(),
-                        'debug'   => $insertData
-                    ]);
-                }
-            }
-
-            return $this->response->setJSON([
-                'status'        => 'success',
-                'quiz_index'   => $nextQuizNumber,
-                'new_quiz_id'   => $firstInsertedId
-            ]);
-        } catch (\Throwable $e) {
-            return $this->response->setJSON([
-                'status'  => 'error',
-                'message' => '❌ Unexpected error: ' . $e->getMessage()
-            ]);
-        }
-    }
-
-    public function showQuizMngt()
-    {
-        // Accept POST first, then GET (query string), then session fallback
-        $incomingId = $this->request->getPost('class_section_id');
-        if (!$incomingId) {
-            $incomingId = $this->request->getGet('class_section_id');
-        }
-
-        $classSectionId = (int) ($incomingId ?: (session()->get('class_section_id') ?? 0));
-
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('status', 'No class section found for the current teacher or selection.');
-        }
-        session()->set('class_section_id', $classSectionId);
-        $semester = $this->getTeacherSelectedSemester();
-        $schoolYear = $this->schoolYear;
-        $quizScores = $this->getquizScoresByStudent($classSectionId, $semester, $schoolYear);
-        $students = $this->getStudentsByClassSectionAndYear($classSectionId, $schoolYear);
-        $quizHeaders = $this->getquizHeaders($classSectionId, $semester, $schoolYear);
-        $scoresLocked = $this->isScoresLocked($classSectionId, $semester, $schoolYear);
-
-        return view('grading/quiz', [
-            'quizScores'    => $quizScores,
-            'students'          => $students,
-            'semester'          => $semester,
-            'schoolYear'        => $schoolYear,
-            'quizHeaders'   => $quizHeaders,
-            'classSectionId' => $classSectionId,
-            'scoresLocked'   => $scoresLocked,
-        ]);
-    }
-
-    public function updateQuiz()
-    {
-        $scores       = $this->request->getPost('scores');
-        $studentIds   = $this->request->getPost('student_ids');
-        $semester     = $this->request->getPost('semester') ?? $this->getTeacherSelectedSemester();
-        $schoolYear   = $this->request->getPost('school_year') ?? $this->schoolYear;
-
-        $updatedBy = $this->request->getPost('teacher_id') ?? session()->get('user_id');
-        $classSectionId = $this->request->getPost('class_section_id') ?? session()->get('class_section_id'); // or query it
-        $classSectionId = (int) ($classSectionId ?? 0);
-        if ($classSectionId > 0 && $this->isScoresLocked($classSectionId, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-
-        if ($scores && $studentIds && $semester && $schoolYear && $classSectionId) {
-            $this->updateQuizScores($scores, $updatedBy, $classSectionId);
-            session()->setFlashdata('status', 'quiz scores updated successfully.');
-
-            // ⬇️ Directly call the method and return its view
-            return $this->showQuizMngt();
-        }
-
-        $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear);
-        // Call the updateScoresForStudents method
-        try {
-
-            $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
-        } catch (RuntimeException $e) {
-            // Handle error
-        }
-        return redirect()->back()->with('status', 'Failed to update scores.');
-    }
-
-    private function isScoresLocked(int $classSectionId, string $semester, string $schoolYear): bool
-    {
-        return $this->gradingLockModel->isLocked($classSectionId, $semester, $schoolYear);
-    }
-
-    private function getStudentsByClassSectionAndYear($classSectionId, $schoolYear)
-    {
-        // Step 1: Get student IDs from student_class table
-        $studentClassRows = $this->studentClassModel
-            ->select('student_id')
-            ->where('class_section_id', $classSectionId)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        $studentIds = array_column($studentClassRows, 'student_id');
-
-        if (empty($studentIds)) {
-            return []; // No students found
-        }
-
-        // Step 2: Get student data from students table
-        $students = $this->studentModel
-            ->whereIn('id', $studentIds)
-            ->where('is_active', 1)
-            ->orderBy('lastname', 'ASC')
-            ->findAll();
-
-        return $students;
-    }
-
-    private function getquizHeaders($classSectionId, $semester, $schoolYear)
-    {
-        $rows = $this->quizModel
-            ->select('quiz_index')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->orderBy('quiz_index', 'ASC')
-            ->findAll();
-
-        $headers = [];
-
-        foreach ($rows as $row) {
-            $index = $row['quiz_index'];
-            if (!is_array($index)) {
-                $headers[$index] = true;
-            }
-        }
-
-        ksort($headers);
-        return array_keys($headers);
-    }
-
-    private function getClassSectionIdForTeacher($updatedBy)
-    {
-        $teacherClassModel = new TeacherClassModel();
-        $class = $teacherClassModel->where('teacher_id', $updatedBy)->first();
-        return $class['class_section_id'] ?? null;
-    }
-
-
-    private function getquizScoresByStudent($classSectionId, $semester, $schoolYear)
-    {
-        $rows = $this->quizModel
-            ->select('student_id, quiz_index, score')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        $studentScores = [];
-        foreach ($rows as $row) {
-            $studentId = $row['student_id'];
-            $index = $row['quiz_index'];
-            $score = $row['score'];
-
-            $studentScores[$studentId]['scores'][$index] = $score;
-        }
-
-        return $studentScores;
-    }
-
-    private function getStudentsWithquizScores($classSectionId, $quizHeaders)
-    {
-        $studentClasses = $this->studentClassModel
-            ->active()
-            ->where('student_class.class_section_id', $classSectionId)
-            ->findAll();
-        $students = [];
-
-        foreach ($studentClasses as $sc) {
-            $student = $this->studentModel
-                ->where('id', $sc['student_id'])
-                ->where('is_active', 1)
-                ->first();
-            if (!$student) continue;
-
-            $scores = [];
-            foreach ($quizHeaders as $index => $ids) {
-                $entry = $this->quizModel->where('quiz_index', $ids)
-                    ->where('student_id', $sc['student_id'])
-                    ->first();
-                $scores[$index] = $entry['score'] ?? '';
-            }
-
-            $students[] = [
-                'student_id' => $sc['student_id'],
-                'firstname'  => $student['firstname'],
-                'lastname'   => $student['lastname'],
-                'scores'     => $scores
-            ];
-        }
-
-        usort($students, fn($a, $b) => strcmp($a['lastname'], $b['lastname']) ?: strcmp($a['firstname'], $b['firstname']));
-        return $students;
-    }
-
-    private function getTeacherSelectedSemester(): string
-    {
-        helper('semester_selection_helper');
-        return selected_teacher_semester();
-    }
-}
diff --git a/app/Http/Controllers/old/RegisterController.php b/app/Http/Controllers/old/RegisterController.php
deleted file mode 100644
index fe223449..00000000
--- a/app/Http/Controllers/old/RegisterController.php
+++ /dev/null
@@ -1,360 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use CodeIgniter\Controller;
-use App\Models\ConfigurationModel;
-use App\Models\UserModel;
-use App\Models\AuthorizedUserModel;
-use App\Models\RoleModel;
-use App\Models\ParentModel;
-use App\Models\UserRoleModel;
-use App\Services\EmailService;
-use App\Services\SchoolIdService;
-use App\Services\PhoneFormatterService;
-
-class RegisterController extends Controller
-{
-    protected $db;
-    protected $configModel;
-    protected $semester;
-    protected $schoolYear;
-    protected $userRoleModel;
-    protected $roleModel;
-    protected $userModel;
-    protected $parentModel;
-
-    public function __construct()
-    {
-        // Load the database service
-        $this->db = \Config\Database::connect();
-        // Check if the database connection is established
-        if (!$this->db->connect()) {
-            log_message('error', 'Database connection failed.');
-            throw new \Exception('Database connection failed.');
-        } else {
-            log_message('info', 'Database connection successful.');
-        }
-        $this->configModel = new ConfigurationModel(); 
-        $this->userRoleModel = new UserRoleModel();
-        $this->roleModel = new RoleModel();
-        $this->userModel = new UserModel();
-        $this->parentModel = new ParentModel();
-
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-    }
-        
-    public function index()
-    {
-        log_message('debug', 'CAPTCHA session value: ' . session()->get('captcha_answer'));
-
-        // Only generate CAPTCHA if not already set (first visit or after submission)
-        if (!session()->has('captcha_answer')) {
-            $length = rand(4, 8);
-            $captchaText = $this->generateCaptchaText($length);
-            session()->set('captcha_answer', $captchaText);
-        }
-
-        $data['captchaQuestion'] = session()->get('captcha_answer');
-
-        // ✅ NO need to check policy_accepted here
-        return view('user/register', $data);
-    }
-
-    private function generateCaptchaText($length)
-    {
-        $characters = 'ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjkmnopqrstuvwxyz0123456789';
-        $captchaText = '';
-
-        for ($i = 0; $i < $length; $i++) {
-            $captchaText .= $characters[rand(0, strlen($characters) - 1)];
-        }
-
-        return $captchaText;
-    }
-
-    public function success()
-    {
-        // Start session
-        $session = session();
-
-        // Check if the session has 'user_email'
-        if (!$session->has('user_email')) {
-            // If not, redirect to the registration page
-            return redirect()->to('/register');
-        }
-
-        // Get 'user_email' from session
-        $email = $session->get('user_email');
-
-        // Pass the 'email' variable to the success view
-        return view('success', ['email' => $email]);
-    }
-
-
-    public function register()
-    {
-        helper(['url', 'form']);
-        log_message('debug', 'CAPTCHA session value: ' . session()->get('captcha_answer'));
-
-        /* ───────────── 1.  Load services ───────────── */  
-        $schoolIdService = new SchoolIdService();
-
-        /* ───────────── 2.  Sanitize & raw data ───────────── */
-        $post    = $this->formatUserInput($this->request); // safe / formatted
-        $rawPost = $this->request->getPost();              // raw (for flags etc.)
-        $captcha = $rawPost['captcha'] ?? '';
-
-        /* ───────────── 3.  Validation rules ───────────── */
-        $rules = [
-            'firstname'  => 'required|regex_match[/^[a-zA-Z\s-]+$/]|min_length[2]|max_length[30]',
-            'lastname'   => 'required|regex_match[/^[a-zA-Z\s-]+$/]|min_length[2]|max_length[30]',
-            'gender'     => 'required|in_list[Male,Female]',
-            'email'      => 'required|valid_email|max_length[50]',
-            'confirm_email' => 'required|matches[email]',
-            'cellphone'  => 'required|regex_match[/^[\d\s\-\(\)\.]+$/]|min_length[10]|max_length[20]',
-            'address_street' => 'permit_empty|regex_match[/^[a-zA-Z0-9\s\-]+$/]|max_length[150]',
-            'apt'        => 'permit_empty|regex_match[/^[a-zA-Z0-9\s-]+$/]|max_length[10]',
-            'city'       => 'required|alpha_space|min_length[2]|max_length[30]',
-            'state'      => 'required|in_list[CT,ME,MA,NH,NY,RI,VT]',
-            'zip'        => 'required|regex_match[/^\d{5}$/]',
-            'accept_school_policy' => 'required',
-            'captcha'    => 'required|alpha_numeric|min_length[4]|max_length[10]',
-        ];
-
-        // 1. Check if "I am a parent" checkbox is ticked
-        $isParent = isset($rawPost['is_parent']) && $rawPost['is_parent'] == '1';
-
-        // 2. If parent, handle second parent logic
-        if ($isParent) {
-            $noSecondParent = isset($rawPost['no_second_parent_info']) && $rawPost['no_second_parent_info'] == '1';
-
-            $secondParentProvided = !empty($rawPost['second_firstname']) ||
-                                    !empty($rawPost['second_lastname']) ||
-                                    !empty($rawPost['second_gender']) ||
-                                    !empty($rawPost['second_email']) ||
-                                    !empty($rawPost['second_cellphone']);
-
-            // 3. Error: must provide second parent or check "no second parent"
-            if (!$noSecondParent && !$secondParentProvided) {
-                return redirect()->back()->withInput()->with('errors', [
-                    'second_parent_info' => 'As a parent, please provide second parent information or check "No second parent info".'
-                ]);
-            }
-
-            // 4. Add second parent field rules only if "no second parent" is NOT checked
-            if (!$noSecondParent) {
-                $rules += [
-                    'second_firstname' => 'required|regex_match[/^[a-zA-Z\s\-]+$/]|min_length[2]|max_length[30]',
-                    'second_lastname'  => 'required|regex_match[/^[a-zA-Z\s\-]+$/]|min_length[2]|max_length[30]',
-                    'second_gender'    => 'required|in_list[Male,Female]',
-                    'second_email'     => 'required|valid_email|max_length[50]',
-                    'second_cellphone' => 'required|regex_match[/^[\d\s\-\(\)\.]+$/]|min_length[10]|max_length[20]',
-                ];
-            }
-        }
-
-        log_message('debug', '🧪 Starting validation check...');
-        if (!$this->validate($rules)) {
-            return redirect()->back()->withInput()->with('errors', $this->validator->getErrors());
-        }
-
-        /* ───────────── 4.  CAPTCHA check ───────────── */
-        if ($captcha !== session()->get('captcha_answer')) {
-            return redirect()->back()
-                ->withInput()
-                ->with('errors', ['captcha' => '']) // keeps input marked as invalid
-                ->with('top_error', 'Incorrect CAPTCHA answer. Please try again.');
-        }
-
-        /* ───────────── 5.  Unique e-mail ───────────── */
-        // Step 1: Check if a user with this email exists
-        $existingUser = $this->userModel->where('email', $post['email'])->first();
-
-        if ($existingUser) {
-            // Step 2: Check if the user has a token (i.e., not verified yet)
-            if (!empty($existingUser['token']) && $existingUser['is_verified'] == 0) {
-                // User exists and is unverified
-                return redirect()->back()->withInput()->with('error',
-                    'This email address is already registered and is pending activation. Please check your email to activate your account.');
-            } else {
-                // User exists and is already active or has no token
-                return redirect()->back()->withInput()->with('error',
-                    'The email address you entered is already in use. Please try a different one.');
-            }
-        }
-
-        /* ───────────── 6.  Determine role ───────────── */
-        $roleName = !empty($rawPost['is_parent']) ? 'parent' : 'guest';
-        $role     = $this->roleModel->where('name', $roleName)->first();
-        if (!$role) {
-            return redirect()->back()->withInput()->with('errors', ['role' => 'Role not found']);
-        }
-
-        /* ───────────── 7.  Build & insert user ───────────── */
-        $token    = bin2hex(random_bytes(48));
-        $userData = [
-            'firstname'  => $post['firstname'],
-            'lastname'   => $post['lastname'],
-            'gender'     => $post['gender'],
-            'email'      => $post['email'],
-            'cellphone'  => $post['cellphone'],
-            'address_street' => $post['address_street'] ?? null,
-            'apt'        => $post['apt'] ?? null,
-            'city'       => $post['city'],
-            'state'      => $post['state'],
-            'zip'        => $post['zip'],
-            'token'      => $token,
-            'is_verified'=> 0,
-            'accept_school_policy' => (int) $post['accept_school_policy'],
-            'status'     => 'Inactive',
-            'school_id'  => $schoolIdService->generateUserSchoolId(),
-            'semester'   => $this->semester,
-            'school_year'=> $this->schoolYear,
-        ];
-
-        $this->db->transStart();
-
-        if (!$this->userModel->insert($userData)) {
-            $this->db->transRollback();
-            return redirect()->back()->withInput()->with('errors', $this->userModel->errors());
-        }
-        $firstParentId = $this->userModel->getInsertID();
-
-        $this->userRoleModel->insert([
-            'user_id'    => $firstParentId,
-            'role_id'    => $role['id'],
-            'created_at' => utc_now(),
-        ]);
-
-        /* ───────────── 8.  Optional second-parent insert ───────────── */
-        if ($isParent) {
-            if (empty($rawPost['no_second_parent_info'])) {
-                $this->parentModel->insert([
-                    'secondparent_firstname' => $post['second_firstname'],
-                    'secondparent_lastname'  => $post['second_lastname'],
-                    'secondparent_gender'    => $post['second_gender'],
-                    'secondparent_email'     => $post['second_email'],
-                    'secondparent_phone'     => $post['second_cellphone'],
-                    'firstparent_id'         => $firstParentId,
-                    'semester'               => $this->semester,
-                    'school_year'            => $this->schoolYear,
-                ]);
-            }
-        }
-
-        $this->db->transComplete();
-        if (!$this->db->transStatus()) {
-            return redirect()->back()->withInput()->with('error', 'Registration failed, please try again.');
-        }
-
-        /* ───────────── 9.  Confirmation e-mail ───────────── */
-        $recipientName   = $post['firstname'] . ' ' . $post['lastname'];
-        $activationLink  = site_url('/user/confirm/' . $token);
-        $orgName         = 'Al Rahma Sunday School';
-        $contactInfo     = 'alrahma.isgl@gmail.com';
-        $logoUrl         = 'https://alrahmaisgl.org/assets/images/alrahma_logo.png';
-
-        $emailData = [
-            'recipientName'  => $recipientName,
-            'activationLink' => $activationLink,
-            'orgName'        => $orgName,
-            'contactInfo'    => $contactInfo,
-            'logoUrl'        => $logoUrl,
-            'subject'        => 'Email Confirmation'
-        ];
-
-        if ($isParent) {
-            $html = view('emails/welcome_parent', $emailData);
-        } else {
-            $html = view('emails/welcome_staff', $emailData);
-        }
-
-        (new EmailService())->send($post['email'], 'Email Confirmation', $html, 'general');
-
-
-        /* ───────────── 10.  Redirect to success ───────────── */
-        session()->set('user_email', $post['email']);
-        session()->remove('captcha_answer'); // Clear CAPTCHA after success
-        return redirect()->to('/register/success');
-    }
-
-    private function formatName(string $name): string
-    {
-        $name = trim($name);
-        return ucwords(strtolower($name), " -");
-    }
-
-    private function formatEmail(?string $email): string
-    {
-        $email = strtolower(trim($email));
-/*
-        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
-            throw new \InvalidArgumentException('Please enter a valid email address.');
-        }*/
-        return $email;
-    }
-
-    private function formatAddress(string $address): string
-    {
-        return ucwords(strtolower(trim($address)));
-    }
-
-    private function formatUserInput($request): array
-{
-    $formatter = new PhoneFormatterService();
-    $post = (array) $request->getPost();
-
-    // tiny helper: safe getter + trim + cast to string
-    $g = static function (string $key) use ($post): string {
-        return trim((string) ($post[$key] ?? ''));
-    };
-
-    $data = [
-        'firstname'            => $this->formatName($g('firstname')),
-        'lastname'             => $this->formatName($g('lastname')),
-        'email'                => $this->formatEmail($g('email')),
-        'gender'               => $g('gender'),
-        'city'                 => $this->formatName($g('city')),
-        'cellphone'            => $formatter->formatPhoneNumber($g('cellphone')),   // ✅ safe
-        'address_street'       => $this->formatAddress($g('address_street')),
-        'apt'                  => strtoupper($g('apt')),
-        'state'                => strtoupper($g('state')),
-        'zip'                  => $g('zip'),
-        'accept_school_policy' => (int) ($post['accept_school_policy'] ?? 0),
-    ];
-
-    // if user says "no second parent info", skip entirely
-    $noSecondInfo = !empty($post['no_second_parent_info']);
-
-    // collect (safely) and see if anything was provided
-    $second_firstname = $this->formatName($g('second_firstname'));
-    $second_lastname  = $this->formatName($g('second_lastname'));
-    $second_gender    = $g('second_gender');
-    $second_email     = $this->formatEmail($g('second_email'));
-    $second_cellphone = $formatter->formatPhoneNumber($g('second_cellphone'));      // ✅ safe
-
-    $secondProvided = !$noSecondInfo && (
-        $second_firstname !== '' ||
-        $second_lastname  !== '' ||
-        $second_gender    !== '' ||
-        $second_email     !== '' ||
-        preg_replace('/\D/', '', $second_cellphone) !== ''
-    );
-
-    if ($secondProvided) {
-        $data['second_firstname'] = $second_firstname;
-        $data['second_lastname']  = $second_lastname;
-        $data['second_gender']    = $second_gender;
-        $data['second_email']     = $second_email;
-        $data['second_cellphone'] = $second_cellphone;
-    }
-
-    return $data;
-}
-
-
-
-
-}
\ No newline at end of file
diff --git a/app/Http/Controllers/old/RoleService.php b/app/Http/Controllers/old/RoleService.php
new file mode 100644
index 00000000..f496ec53
--- /dev/null
+++ b/app/Http/Controllers/old/RoleService.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\RoleModel;
+
+class RoleService
+{
+    public function __construct(private RoleModel $roles = new RoleModel()) {}
+
+    /** @param string[] $roleKeys names or slugs */
+    public function bestDashboardRouteFor(array $roleKeys): string
+    {
+        $rows = $this->roles->findByNamesOrSlugs($roleKeys);
+        if (!empty($rows)) {
+            // first row is highest priority due to orderBy('priority','ASC')
+            return $rows[0]['dashboard_route'] ?? '/landing_page/guest_dashboard';
+        }
+        return '/landing_page/guest_dashboard';
+    }
+}
diff --git a/app/Http/Controllers/old/SchoolIdService.php b/app/Http/Controllers/old/SchoolIdService.php
new file mode 100644
index 00000000..84876f7d
--- /dev/null
+++ b/app/Http/Controllers/old/SchoolIdService.php
@@ -0,0 +1,74 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\UserModel;
+use CodeIgniter\Database\BaseConnection;
+
+class SchoolIdService
+{
+    protected $db;
+    protected $userModel;
+
+    public function __construct()
+    {
+        $this->db = \Config\Database::connect();
+        $this->userModel = new UserModel();
+    }
+
+    public function assignSchoolIdToUser($userId)
+    {
+        $user = $this->userModel->find($userId);
+        if (!$user || $user['school_id']) {
+            return $user['school_id'] ?? null;
+        }
+
+        $schoolId = $this->generateUserSchoolId();
+
+        $this->userModel->update($userId, ['school_id' => $schoolId]);
+
+        return $schoolId;
+    }
+
+public function generateStudentSchoolId()
+{
+    $year = date('y');
+    $maxId = 0;
+
+    // Match the real prefix: STU + year
+    $studentMax = $this->db->table('students')
+        ->select('MAX(school_id) AS max_id')
+        ->like('school_id', "STU{$year}", 'after')
+        ->get()
+        ->getRowArray();
+
+    if (!empty($studentMax['max_id'])) {
+        // Skip "STUyy" (5 chars)
+        $numericPart = substr($studentMax['max_id'], 5);
+        $maxId = (int) $numericPart;
+    }
+
+    $nextId = str_pad($maxId + 1, 5, '0', STR_PAD_LEFT);
+    return "STU{$year}{$nextId}";
+}
+
+
+    public function generateUserSchoolId()
+    {
+        $year = date('y');
+        $maxId = 0;
+
+        // Get maximum user ID for current year
+        $userMax = $this->db->table('users')->select('MAX(school_id) AS max_id')
+            ->notLike('school_id', 'S%') // Exclude student IDs
+            ->like('school_id', $year, 'after')->get()->getRowArray();
+
+        if (!empty($userMax['max_id'])) {
+            $numericPart = substr($userMax['max_id'], 2); // Skip 2-digit year
+            $maxId = max($maxId, (int)$numericPart);
+        }
+
+        $nextId = str_pad($maxId + 1, 5, '0', STR_PAD_LEFT);
+        return "{$year}{$nextId}";
+    }
+}
diff --git a/app/Http/Controllers/old/ScoreCommentController.php b/app/Http/Controllers/old/ScoreCommentController.php
deleted file mode 100644
index 5f9d0ae1..00000000
--- a/app/Http/Controllers/old/ScoreCommentController.php
+++ /dev/null
@@ -1,550 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Controllers\BaseController;
-use App\Models\ScoreCommentModel;
-use App\Models\ConfigurationModel;
-use App\Models\StudentModel;
-use App\Models\SemesterScoreModel;
-use App\Models\GradingLockModel;
-use App\Models\MissingScoreOverrideModel;
-
-class ScoreCommentController extends BaseController
-{
-    protected $db;
-    protected $configModel;
-    protected $semester;
-    protected $schoolYear;
-    protected $scoreCommentModel;
-    protected $studentModel;
-    protected $semesterScoreModel;
-    protected $gradingLockModel;
-    protected $missingScoreOverrideModel;
-
-    public function __construct()
-    {
-                // Load the database service
-        $this->db = \Config\Database::connect();
-        // Check if the database connection is established
-        if (!$this->db->connect()) {
-            log_message('error', 'Database connection failed.');
-            throw new \Exception('Database connection failed.');
-        } else {
-            log_message('info', 'Database connection successful.');
-        }
-        $this->configModel = new ConfigurationModel(); 
-        $this->scoreCommentModel = new ScoreCommentModel();
-        $this->studentModel = new StudentModel();
-        $this->semesterScoreModel = new SemesterScoreModel();
-        $this->gradingLockModel = new GradingLockModel();
-        $this->missingScoreOverrideModel = new MissingScoreOverrideModel();
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-    }
-
-
-    public function saveComments()
-    {
-        $comments = $this->request->getPost('comments');
-        $classSectionId = (int)($this->request->getPost('class_section_id') ?? session()->get('class_section_id') ?? 0);
-        $schoolYear = (string) ($this->request->getPost('school_year') ?? $this->schoolYear);
-        $rawSelectedSemester = $this->request->getPost('selected_semester');
-        $normalizedSelected = $this->normalizeSemesterSelection($rawSelectedSemester);
-        if ($normalizedSelected !== '') {
-            $semester = ucfirst($normalizedSelected);
-        } else {
-            $semester = session()->get('teacher_scores_selected_semester')
-                ?? session()->get('semester')
-                ?? $this->semester;
-        }
-        $teacherId = session()->get('user_id');
-
-        if ($classSectionId <= 0) {
-            return redirect()->back()->with('error', 'Missing class section.');
-        }
-        if ($this->gradingLockModel->isLocked($classSectionId, $semester, $schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-
-        if (!is_array($comments)) {
-            return redirect()->back()->with('error', 'No comments were submitted.');
-        }
-
-        $missingOk = $this->request->getPost('missing_ok') ?? [];
-
-        $studentIds = array_map('intval', array_keys($comments));
-        $studentNames = $this->getStudentFirstNames($studentIds);
-
-        $isFall = strtolower((string) $semester) === 'fall';
-        $isSpring = strtolower((string) $semester) === 'spring';
-        $commentTypes = ['ptap_comment'];
-        if ($isFall) {
-            $commentTypes[] = 'midterm_comment';
-        }
-        if ($isSpring) {
-            $commentTypes[] = 'final_comment';
-        }
-        foreach ($commentTypes as $type) {
-            $checkedItems = [];
-            if (is_array($missingOk)) {
-                foreach ($missingOk as $studentId => $types) {
-                    if (!is_array($types) || empty($types[$type])) {
-                        continue;
-                    }
-                    $checkedItems[] = [
-                        'student_id' => (int) $studentId,
-                        'item_index' => null,
-                    ];
-                }
-            }
-            $this->missingScoreOverrideModel->replaceOverrides(
-                $classSectionId,
-                (string) $semester,
-                (string) $schoolYear,
-                $type,
-                $studentIds,
-                null,
-                $checkedItems,
-                $teacherId,
-                true
-            );
-        }
-
-        $errors = [];
-        $payload = [];
-
-        foreach ($comments as $studentId => $commentTypes) {
-            foreach ($commentTypes as $scoreType => $comment) {
-                $normalizedScoreType = strtolower((string)$scoreType);
-                $trimmedComment = trim((string)$comment);
-                if ($trimmedComment === '') {
-                    continue;
-                }
-
-                $validationError = $this->validateComment($trimmedComment, (int)$studentId, $normalizedScoreType, $studentNames);
-                if ($validationError !== null) {
-                    $errors[] = $validationError;
-                    log_message(
-                        'warning',
-                        "ScoreComment validation failed: teacher_id={$teacherId}, student_id={$studentId}, score_type={$normalizedScoreType}, error={$validationError}, length=" . mb_strlen($trimmedComment, 'UTF-8')
-                    );
-                    continue;
-                }
-
-                $payload[] = [
-                    'student_id' => $studentId,
-                    'class_section_id' => $classSectionId,
-                    'score_type' => $normalizedScoreType, // 'ptap', 'midterm', 'final'
-                    'semester' => $semester,
-                    'school_year' => $schoolYear,
-                    'comment' => $trimmedComment,
-                    'commented_by' => $teacherId,
-                    'created_at' => utc_now(),
-                ];
-            }
-        }
-
-        if (!empty($errors)) {
-            return redirect()->back()->with('errors', $errors)->withInput();
-        }
-
-        foreach ($payload as $data) {
-            $existing = $this->scoreCommentModel
-                ->where('student_id', $data['student_id'])
-                ->groupStart()
-                    ->where('class_section_id', $data['class_section_id'])
-                    ->orWhere('class_section_id', null)
-                ->groupEnd()
-                ->where('score_type', $data['score_type'])
-                ->where('semester', $data['semester'])
-                ->where('school_year', $data['school_year'])
-                ->first();
-
-            if ($existing) {
-                $this->scoreCommentModel->update($existing['id'], $data);
-            } else {
-                $this->scoreCommentModel->insert($data);
-            }
-        }
-
-        return redirect()->back()->with('status', 'Comments saved successfully.');
-    }
-
-
-    public function viewCommentsMngt()
-    {
-        $rawSelectedSemester = $this->request->getGet('semester')
-            ?? $this->request->getPost('semester')
-            ?? session()->get('teacher_scores_selected_semester')
-            ?? session()->get('semester')
-            ?? $this->semester;
-        $normalizedSelected = $this->normalizeSemesterSelection($rawSelectedSemester);
-        if ($normalizedSelected !== '') {
-            $activeSemester = ucfirst($normalizedSelected);
-        } else {
-            $activeSemester = $this->semester;
-        }
-
-        $incoming = $this->request->getPost('class_section_id')
-            ?? $this->request->getGet('class_section_id')
-            ?? session()->get('class_section_id');
-
-        $isAllSections = is_string($incoming) && strtolower(trim($incoming)) === 'allsections';
-        $classSectionId = $isAllSections ? null : (int) ($incoming ?: 0);
-
-        if (!$isAllSections && $classSectionId <= 0) {
-            return redirect()->back()->with('status', 'Missing class section.');
-        }
-        session()->set('class_section_id', $isAllSections ? 'allsections' : $classSectionId);
-
-        $builder = $this->db->table('student_class sc')
-            ->distinct('SELECT s.id AS student_id, s.firstname, s.lastname, s.school_id')
-            ->join('students s', 's.id = sc.student_id', 'inner')
-            ->where('sc.school_year', $this->schoolYear);
-
-        if (!$isAllSections) {
-            $builder->where('sc.class_section_id', $classSectionId);
-        }
-
-        $students = $builder
-            ->orderBy('s.lastname', 'ASC')
-            ->orderBy('s.firstname', 'ASC')
-            ->get()
-            ->getResultArray();
-
-    // 3) Load only comments for these students in this term (ptap, midterm, final)
-    $comments = [];
-    if (!empty($students)) {
-        $studentIds = array_map(static fn($r) => (int)$r['student_id'], $students);
-
-        $rawCommentsBuilder = $this->scoreCommentModel
-            ->whereIn('student_id', $studentIds)
-            ->whereIn('score_type', ['midterm', 'final', 'ptap', 'attendance'])
-            ->where('semester', $activeSemester)
-            ->where('school_year', $this->schoolYear);
-
-        if (!$isAllSections) {
-            $rawCommentsBuilder->groupStart()
-                ->where('class_section_id', $classSectionId)
-                ->orWhere('class_section_id', null); // legacy rows without class_section_id
-            $rawCommentsBuilder->groupEnd();
-        }
-
-        $rawComments = $rawCommentsBuilder->findAll();
-
-        $existingAttendance = [];
-        foreach ($rawComments as $c) {
-            $sid = (int)$c['student_id'];
-            $typ = (string)$c['score_type'];
-            $comments[$sid][$typ] = [
-                'comment'        => $c['comment'] ?? null,
-                'comment_review' => $c['comment_review'] ?? null,
-                'commented_by'   => $c['commented_by'] ?? null,
-                'reviewed_by'    => $c['reviewed_by'] ?? null,
-            ];
-            if ($typ === 'attendance') {
-                $existingAttendance[$sid] = $c;
-            }
-        }
-
-        helper('attendance_comment');
-        // Autogenerate attendance comments for display when missing
-        $attendanceScores = [];
-        $scoreRows = $this->semesterScoreModel
-            ->select(['student_id', 'attendance_score'])
-            ->whereIn('student_id', $studentIds)
-            ->where('semester', $activeSemester)
-            ->where('school_year', $this->schoolYear)
-            ->findAll();
-        foreach ($scoreRows as $row) {
-            $attendanceScores[(int)$row['student_id']] = isset($row['attendance_score'])
-                ? (float)$row['attendance_score']
-                : null;
-        }
-        $attendanceInserts = [];
-        $attendanceUpdates = [];
-        foreach ($students as $student) {
-            $sid = (int)$student['student_id'];
-            $hasComment = isset($comments[$sid]['attendance']['comment']) && trim((string)$comments[$sid]['attendance']['comment']) !== '';
-            if ($hasComment) {
-                continue;
-            }
-            $score = $attendanceScores[$sid] ?? null;
-            if ($score === null) {
-                continue;
-            }
-            $auto = attendance_comment_from_score($score, $student['firstname'] ?? '');
-            if ($auto !== null) {
-                $comments[$sid]['attendance'] = [
-                    'comment'        => $auto,
-                    'comment_review' => $comments[$sid]['attendance']['comment_review'] ?? null,
-                    'commented_by'   => $comments[$sid]['attendance']['commented_by'] ?? null,
-                    'reviewed_by'    => $comments[$sid]['attendance']['reviewed_by'] ?? null,
-                ];
-                if (isset($existingAttendance[$sid])) {
-                    $attendanceUpdates[] = [
-                        'id'           => $existingAttendance[$sid]['id'],
-                        'comment'      => $auto,
-                        'commented_by' => $existingAttendance[$sid]['commented_by'] ?? null,
-                        'class_section_id' => $classSectionId,
-                    ];
-                } else {
-                    $attendanceInserts[] = [
-                        'student_id'  => $sid,
-                        'score_type'  => 'attendance',
-                        'semester'    => $activeSemester,
-                        'school_year' => $this->schoolYear,
-                        'comment'     => $auto,
-                        'commented_by'=> null,
-                        'class_section_id' => $classSectionId,
-                        'created_at'  => utc_now(),
-                    ];
-                }
-            }
-        }
-        if (!empty($attendanceUpdates)) {
-            foreach ($attendanceUpdates as $row) {
-                $id = $row['id'];
-                unset($row['id']);
-                $this->scoreCommentModel->update($id, $row);
-            }
-        }
-        if (!empty($attendanceInserts)) {
-            $this->scoreCommentModel->insertBatch($attendanceInserts);
-        }
-    }
-
-        // 4) Render
-        return view('grading/comments', [
-            'students'       => $students,
-            'semester'       => $activeSemester,
-            'schoolYear'     => $this->schoolYear,
-            'classSectionId' => $isAllSections ? 'allsections' : $classSectionId,
-            'comments'       => $comments,
-            'scoresLocked'   => (!$isAllSections && $classSectionId > 0)
-                ? $this->gradingLockModel->isLocked($classSectionId, $activeSemester, $this->schoolYear)
-                : false,
-        ]);
-    }
-
-
-    public function updateComments()
-    {
-        $semester   = $this->request->getPost('semester');
-        $schoolYear = $this->request->getPost('school_year');
-        $teacherId  = $this->request->getPost('teacher_id') ?? session()->get('user_id');
-        $classSectionId = $this->request->getPost('class_section_id') ?? session()->get('class_section_id');
-        $comments   = $this->request->getPost('comments') ?? [];
-        $reviews    = $this->request->getPost('reviews') ?? [];
-
-        $studentIds = array_unique(array_map(
-            'intval',
-            array_merge(array_keys($comments), array_keys($reviews))
-        ));
-        $studentNames = $this->getStudentFirstNames($studentIds);
-        $isReviewer = $this->isReviewer();
-        $classSectionId = is_numeric($classSectionId) ? (int)$classSectionId : $classSectionId;
-        if (is_int($classSectionId) && $classSectionId > 0) {
-            if ($this->gradingLockModel->isLocked($classSectionId, $semester, $schoolYear)) {
-                return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-            }
-        }
-
-        // Pull attendance scores once for auto-generated attendance comments
-        $attendanceScores = [];
-        if (!empty($studentIds)) {
-            $attendanceBuilder = $this->semesterScoreModel
-                ->select(['student_id', 'attendance_score'])
-                ->where('semester', $semester)
-                ->where('school_year', $schoolYear)
-                ->whereIn('student_id', $studentIds);
-
-            if (is_int($classSectionId) && $classSectionId > 0) {
-                $attendanceBuilder->where('class_section_id', $classSectionId);
-            }
-
-            $rows = $attendanceBuilder->findAll();
-            foreach ($rows as $row) {
-                $attendanceScores[(int)$row['student_id']] = isset($row['attendance_score'])
-                    ? (float)$row['attendance_score']
-                    : null;
-            }
-        }
-
-        helper('attendance_comment');
-
-        $errors = [];
-        $operations = [];
-
-        foreach ($comments as $studentId => $types) {
-            foreach ($types as $scoreType => $commentText) {
-                $normalizedScoreType = strtolower((string)$scoreType);
-                $commentText = trim((string)$commentText);
-
-                // Auto-generate attendance comment when empty based on the student's attendance score
-                if ($normalizedScoreType === 'attendance' && $commentText === '') {
-                    $attendanceScore = $attendanceScores[$studentId] ?? null;
-                    $auto = attendance_comment_from_score($attendanceScore, $studentNames[$studentId] ?? '');
-                    if ($auto !== null) {
-                        $commentText = $auto;
-                    }
-                }
-
-                $reviewText = isset($reviews[$studentId][$scoreType])
-                    ? trim((string)$reviews[$studentId][$scoreType])
-                    : '';
-                // Skip empty comment & empty review to avoid null inserts
-                if ($commentText === '' && $reviewText === '') {
-                    continue;
-                }
-
-                if ($commentText !== '') {
-                    $validationError = $this->validateComment($commentText, (int)$studentId, $normalizedScoreType, $studentNames);
-                    if ($validationError !== null) {
-                        $errors[] = $validationError;
-                        continue;
-                    }
-                }
-
-                $operations[] = [
-                    'student_id' => $studentId,
-                    'class_section_id' => is_int($classSectionId) ? $classSectionId : null,
-                    'score_type' => $normalizedScoreType,
-                    'comment' => $commentText === '' ? null : $commentText,
-                    'review' => $reviewText === '' ? null : $reviewText,
-                ];
-            }
-        }
-
-        if (!empty($errors)) {
-            return redirect()->back()->with('errors', $errors)->withInput();
-        }
-
-        foreach ($operations as $operation) {
-            $existingQuery = $this->scoreCommentModel
-                ->where('student_id', $operation['student_id'])
-                ->where('score_type', $operation['score_type'])
-                ->where('semester', $semester)
-                ->where('school_year', $schoolYear);
-
-            if (is_int($classSectionId) && $classSectionId > 0) {
-                $existingQuery->groupStart()
-                    ->where('class_section_id', $classSectionId)
-                    ->orWhere('class_section_id', null); // pick up legacy rows
-                $existingQuery->groupEnd();
-            }
-
-            $existing = $existingQuery->first();
-
-            $data = [
-                'comment' => $operation['comment'],
-                'commented_by' => $teacherId,
-                'class_section_id' => $operation['class_section_id'],
-            ];
-
-            if ($isReviewer && $operation['review'] !== null) {
-                $data['comment_review'] = $operation['review'];
-                $data['reviewed_by'] = $teacherId;
-            }
-
-            if ($existing) {
-                // Update
-                $this->scoreCommentModel->update($existing['id'], $data);
-            } else {
-                // Insert
-                $this->scoreCommentModel->insert(array_merge([
-                    'student_id'   => $operation['student_id'],
-                    'score_type'   => $operation['score_type'],
-                    'semester'     => $semester,
-                    'school_year'  => $schoolYear,
-                    'class_section_id' => $operation['class_section_id'],
-                ], $data));
-            }
-        }
-        return redirect()->back()->with('status', 'Comments updated successfully!');
-    }
-
-    // Helper function to check if current user is a reviewer
-    private function isReviewer()
-    {
-        $currentUserRole = session()->get('role'); // Make sure this matches your session role key
-        
-        // Get reviewer roles from configuration table
-        $reviewerRoles = $this->configModel->getConfig('comment_reviewer');
-        
-        if (!$reviewerRoles) {
-            return false;
-        }
-        
-        // Convert comma-separated string to array and trim whitespace
-        $allowedRoles = array_map('trim', explode(',', $reviewerRoles));
-        
-        // Check if current user role is in the allowed roles
-        return in_array($currentUserRole, $allowedRoles);
-    }
-
-    private function getStudentFirstNames(array $studentIds): array
-    {
-        $ids = array_values(array_filter(array_unique(array_map('intval', $studentIds)), static function ($id) {
-            return $id > 0;
-        }));
-
-        if (empty($ids)) {
-            return [];
-        }
-
-        $rows = $this->studentModel
-            ->select(['id', 'firstname'])
-            ->whereIn('id', $ids)
-            ->findAll();
-
-        $names = [];
-        foreach ($rows as $row) {
-            $names[(int)($row['id'] ?? 0)] = trim((string)($row['firstname'] ?? ''));
-        }
-
-        return $names;
-    }
-
-    private function validateComment(string $comment, int $studentId, string $scoreType, array $studentNames): ?string
-    {
-        $trimmed = trim($comment);
-        if ($trimmed === '') {
-            return null;
-        }
-
-        $firstName = $studentNames[$studentId] ?? '';
-        if ($firstName === '') {
-            return "Missing student first name for student ID {$studentId}.";
-        }
-
-        $length = mb_strlen($trimmed, 'UTF-8');
-        if ($length < 100) {
-            return "{$firstName}'s {$scoreType} comment must be at least 100 characters.";
-        }
-        if ($length > 400) {
-            return "{$firstName}'s {$scoreType} comment must be at most 400 characters.";
-        }
-
-        $pattern = '/^' . preg_quote($firstName, '/') . '\\b/i';
-        if (!preg_match($pattern, $trimmed)) {
-            return "{$firstName}'s {$scoreType} comment must start with the student's first name.";
-        }
-
-        return null;
-    }
-
-    private function normalizeSemesterSelection(?string $input): string
-    {
-        $value = strtolower(trim((string)$input));
-        if ($value === 'fall' || str_contains($value, '1')) {
-            return 'fall';
-        }
-        if ($value === 'spring' || str_contains($value, '2')) {
-            return 'spring';
-        }
-        return '';
-    }
-
-}
diff --git a/app/Http/Controllers/old/ScoreController.php b/app/Http/Controllers/old/ScoreController.php
deleted file mode 100644
index ff24070e..00000000
--- a/app/Http/Controllers/old/ScoreController.php
+++ /dev/null
@@ -1,1438 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use CodeIgniter\Controller;
-use App\Models\TeacherClassModel;
-use App\Models\StudentClassModel;
-use App\Models\StudentModel;
-use App\Models\QuizModel;
-use App\Models\HomeworkModel;
-use App\Models\FinalExamModel;
-use App\Models\MidtermExamModel;
-use App\Models\ProjectModel;
-use App\Models\SemesterScoreModel;
-use App\Models\ConfigurationModel;
-use App\Models\ScoreCommentModel;
-use App\Models\ParticipationModel;
-use App\Models\AttendanceRecordModel;
-use App\Models\AttendanceDataModel;
-use App\Models\ClassSectionModel;
-use App\Models\UserModel;
-use CodeIgniter\Events\Events;
-use Config\Services;
-use App\Models\CalendarModel;
-use App\Services\Calculators\AttendanceCalculator;
-use App\Models\GradingLockModel;
-use App\Models\MissingScoreOverrideModel;
-
-
-
-class ScoreController extends Controller
-{
-    protected $semesterScoreService;
-    protected $db;
-    protected $configModel;
-    protected $semester;
-    protected $schoolYear;
-    protected $classSectionModel;
-    protected $studentClassModel;
-    protected $teacherClassModel;
-    protected $userModel;
-    protected $targetHigh;
-    protected $targetLow;
-    protected $semesterScoreModel;
-    protected $studentModel;
-    protected $calendarModel;
-    protected $attendanceCalculator;
-    protected $gradingLockModel;
-    protected $missingScoreOverrideModel;
-
-    public function __construct()
-    {
-                // Load the database service
-        $this->db = \Config\Database::connect();
-        // Check if the database connection is established
-        if (!$this->db->connect()) {
-            log_message('error', 'Database connection failed.');
-            throw new \Exception('Database connection failed.');
-        } else {
-            log_message('info', 'Database connection successful.');
-        }
-
-        // Initialize the config model
-        $this->configModel = new ConfigurationModel(); 
-        $this->classSectionModel = new ClassSectionModel();
-        $this->teacherClassModel = new TeacherClassModel();
-        $this->semesterScoreModel = new SemesterScoreModel();
-        $this->studentModel = new StudentModel();
-        $this->studentClassModel = new StudentClassModel();
-        $this->userModel = new UserModel();
-        $this->calendarModel = new CalendarModel();
-        $this->attendanceCalculator = new AttendanceCalculator(
-            new AttendanceRecordModel(),
-            $this->configModel,
-            $this->calendarModel
-        );
-        $this->gradingLockModel = new GradingLockModel();
-        $this->missingScoreOverrideModel = new MissingScoreOverrideModel();
-        // Retrieve the configuration values
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->targetHigh = $this->configModel->getConfig('trophy_score');
-        $this->targetLow = $this->configModel->getConfig('pass_score');
-        $this->semesterScoreService = Services::semesterScoreService();
-    }
-
-
-    public function index()
-    {
-        log_message('debug', 'ScoreController::index invoked');
-        $semesterChoiceParam = $this->request->getGet('semester_choice');
-        $session = session();
-        if ($this->request->getGet('choose_semester') !== null) {
-            $session->remove('teacher_scores_selected_semester');
-            $session->remove('semester');
-            $semesterChoiceParam = null;
-        }
-        $normalizedChoice = $this->normalizeSemester($semesterChoiceParam);
-        $sessionSelected = $session->get('teacher_scores_selected_semester');
-        $selectedSemesterLabel = '';
-        if ($normalizedChoice !== '') {
-            $selectedSemesterLabel = ucfirst($normalizedChoice);
-            $session->set('teacher_scores_selected_semester', $selectedSemesterLabel);
-            $session->set('semester', $selectedSemesterLabel);
-        } elseif (!empty($sessionSelected)) {
-            $selectedSemesterLabel = $sessionSelected;
-        } else {
-            $invalidChoice = null;
-            if ($semesterChoiceParam !== null && $semesterChoiceParam !== '') {
-                $invalidChoice = $semesterChoiceParam;
-            }
-            return view('teacher/select_semester', [
-                'fallUrl' => base_url('/teacher/scores?semester_choice=Fall'),
-                'springUrl' => base_url('/teacher/scores?semester_choice=Spring'),
-                'invalidChoice' => $invalidChoice,
-            ]);
-        }
-        $focusTarget = $this->request->getGet('focus');
-        $focusTarget = in_array($focusTarget, ['scores', 'comments'], true) ? $focusTarget : null;
-
-        // Step 1: Get the teacher_id from the session
-        $teacherId = session()->get('user_id');
-        $teacher = $this->userModel->find($teacherId);
-        $teacherFirst = $teacher['firstname'] ?? $teacher['first_name'] ?? '';
-        $teacherLast  = $teacher['lastname']  ?? $teacher['last_name']  ?? '';
-        $teacherName  = ($teacherFirst !== '' || $teacherLast !== '')
-            ? trim($teacherFirst . ' ' . $teacherLast)
-            : 'Unknown';
-
-        $activeSemester = $selectedSemesterLabel;
-        $effectiveSemester = $activeSemester;
-        $effectiveSchoolYear = $this->schoolYear;
-
-        // ✅ Get class section ID for the active term (respect active selection)
-        $assignments = $this->teacherClassModel->getClassAssignmentsByUserId(
-            (int)$teacherId,
-            (string)$effectiveSchoolYear,
-            (string)$effectiveSemester
-        );
-
-        if (empty($assignments)) {
-            // Fallback: any class regardless of term
-            $fallback = $this->teacherClassModel
-                ->where('teacher_id', $teacherId)
-                ->first();
-            if ($fallback) {
-                $assignments = [[
-                    'class_section_id'   => $fallback['class_section_id'],
-                    'class_section_name' => null,
-                    'school_year'        => $fallback['school_year'] ?? $effectiveSchoolYear,
-                    'semester'           => $fallback['semester'] ?? $effectiveSemester,
-                ]];
-                $effectiveSemester   = $fallback['semester'] ?? $effectiveSemester;
-                $effectiveSchoolYear = $fallback['school_year'] ?? $effectiveSchoolYear;
-            } else {
-                log_message('info', 'No class section assigned to teacher ID: ' . $teacherId);
-                return redirect()
-                    ->to('no-classes')
-                    ->with('message', 'You do not have an assigned class yet. Please contact the administration.');
-            }
-        }
-
-        $allowedIds = array_map(static fn($a) => (int)($a['class_section_id'] ?? 0), $assignments);
-        $allowedIds = array_values(array_filter(array_unique($allowedIds)));
-
-        $requestedId = (int)($this->request->getGet('class_section_id') ?? 0);
-        $sessionId   = (int)(session()->get('class_section_id') ?? 0);
-        $chosenAssignment = null;
-        if ($requestedId && in_array($requestedId, $allowedIds, true)) {
-            $classSectionId = $requestedId;
-            foreach ($assignments as $a) {
-                if ((int)$a['class_section_id'] === $requestedId) { $chosenAssignment = $a; break; }
-            }
-        } elseif ($sessionId && in_array($sessionId, $allowedIds, true)) {
-            $classSectionId = $sessionId;
-            foreach ($assignments as $a) {
-                if ((int)$a['class_section_id'] === $sessionId) { $chosenAssignment = $a; break; }
-            }
-        } else {
-            $classSectionId = $allowedIds[0];
-            foreach ($assignments as $a) {
-                if ((int)$a['class_section_id'] === $classSectionId) { $chosenAssignment = $a; break; }
-            }
-        }
-
-        session()->set('class_section_id', $classSectionId);
-
-        if ($chosenAssignment) {
-            $effectiveSemester   = $chosenAssignment['semester'] ?? $effectiveSemester;
-            $effectiveSchoolYear = $chosenAssignment['school_year'] ?? $effectiveSchoolYear;
-        }
-
-        // Build assigned teacher/TA names for this section (current term)
-        $rows = $this->db->table('teacher_class tc')
-            ->select('tc.position, u.firstname, u.lastname')
-            ->join('users u', 'u.id = tc.teacher_id', 'inner')
-            ->where('tc.class_section_id', $classSectionId)
-            ->where('tc.school_year', $effectiveSchoolYear)
-            ->orderBy("FIELD(tc.position,'main','ta')", '', false)
-            ->orderBy('u.firstname', 'ASC')
-            ->get()->getResultArray();
-
-        $mains = [];
-        $tas   = [];
-        foreach ($rows as $r) {
-            $name = trim(($r['firstname'] ?? '') . ' ' . ($r['lastname'] ?? ''));
-            if ($name === '') continue;
-            $pos = strtolower((string)($r['position'] ?? ''));
-            if (in_array($pos, ['main', 'teacher'], true)) {
-                $mains[] = $name;
-            } elseif (in_array($pos, ['ta', 'assistant', 'teacher_assistant'], true)) {
-                $tas[] = $name;
-            }
-        }
-        if (empty($mains) && !empty($teacherName)) {
-            $mains = [$teacherName];
-        }
-        $mainsText = implode(', ', $mains);
-        $tasText   = implode(', ', $tas);
-
-        // Resolve class section name (by section code)
-        $csRow = $this->db->table('classSection')
-            ->select('class_section_name')
-            ->where('class_section_id', $classSectionId)
-            ->get()->getRowArray();
-        $classSectionName = $csRow['class_section_name'] ?? '';
-        log_message('debug', "ScoreController::index teacher {$teacherId} classSection {$classSectionId} semester {$effectiveSemester}");
-
-        $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId(
-            $classSectionId,
-            $effectiveSemester,
-            $effectiveSchoolYear
-        );
-        if (!empty($studentTeacherInfo) && $this->semesterScoreService !== null) {
-            try {
-                $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo);
-            } catch (\Throwable $e) {
-                log_message('error', 'ScoreController::index semester score refresh failed: ' . $e->getMessage());
-            }
-        }
-
-        // Step 2: Retrieve the student scores data
-        $students = $this->getStudentScores($classSectionId, $effectiveSemester, $effectiveSchoolYear, $teacherId);
-
-        // Step 3: Sort the students array by last name and then by first name
-        usort($students, function ($a, $b) {
-            $lastNameComparison = strcmp($a['lastname'], $b['lastname']);
-            return $lastNameComparison === 0
-                ? strcmp($a['firstname'], $b['firstname'])
-                : $lastNameComparison;
-        });
-
-        if (ENVIRONMENT !== 'production') {
-            $sampleRows = array_map(static function ($student) {
-                return [
-                    'id' => $student['student_id'],
-                    'attendance_score' => $student['attendance_score'] ?? null,
-                    'ptap_score' => $student['ptap_score'] ?? null,
-                    'final_exam' => $student['final_exam'][0] ?? null,
-                ];
-            }, array_slice($students, 0, 5));
-            log_message('debug', 'ScoreController::index sample rows: ' . json_encode($sampleRows));
-        }
-
-        $scoresLocked = $this->gradingLockModel->isLocked(
-            (int) $classSectionId,
-            (string) $effectiveSemester,
-            (string) $effectiveSchoolYear
-        );
-
-        // Step 4: Pass everything to the view
-        $data = [
-            'students' => $students,
-            'teacher_name' => $teacherName,
-            'class_section_id' => $classSectionId,
-            'class_section_name' => $classSectionName,
-            'mainsText' => $mainsText,
-            'tasText'   => $tasText,
-            'activeSemester' => $activeSemester,
-            'selectedSemester' => $activeSemester,
-            'focusTarget' => $focusTarget,
-            'schoolYear' => $effectiveSchoolYear,
-            'scoresLocked' => $scoresLocked,
-        ];
-
-        return view('/teacher/scores', $data);
-    }
-
-    public function submitScoresLock()
-    {
-        $classSectionId = (int) ($this->request->getPost('class_section_id') ?? session()->get('class_section_id') ?? 0);
-        $semesterRaw = (string) ($this->request->getPost('semester') ?? $this->request->getPost('selected_semester') ?? '');
-        $semesterNormalized = $this->normalizeSemester($semesterRaw);
-        $semester = $semesterNormalized !== '' ? ucfirst($semesterNormalized) : $this->semester;
-        $schoolYear = (string) ($this->request->getPost('school_year') ?? $this->schoolYear);
-
-        if ($classSectionId <= 0 || $semester === '' || $schoolYear === '') {
-            return redirect()->back()->with('error', 'Missing class section or term.');
-        }
-
-        $missingOk = $this->request->getPost('missing_ok') ?? [];
-        $studentIds = $this->request->getPost('student_ids') ?? array_keys((array) $missingOk);
-        $studentIds = array_map('intval', (array) $studentIds);
-        $teacherId = (int) (session()->get('user_id') ?? 0);
-        $isFall = strtolower($semester) === 'fall';
-        $isSpring = strtolower($semester) === 'spring';
-
-        $commentTypes = ['ptap_comment'];
-        if ($isFall) {
-            $commentTypes[] = 'midterm_comment';
-        }
-        if ($isSpring) {
-            $commentTypes[] = 'final_comment';
-        }
-
-        foreach ($commentTypes as $type) {
-            $checkedItems = [];
-            if (is_array($missingOk)) {
-                foreach ($missingOk as $studentId => $types) {
-                    if (!is_array($types) || empty($types[$type])) {
-                        continue;
-                    }
-                    $checkedItems[] = [
-                        'student_id' => (int) $studentId,
-                        'item_index' => null,
-                    ];
-                }
-            }
-            $this->missingScoreOverrideModel->replaceOverrides(
-                $classSectionId,
-                (string) $semester,
-                (string) $schoolYear,
-                $type,
-                $studentIds,
-                null,
-                $checkedItems,
-                $teacherId,
-                true
-            );
-        }
-
-        $existing = $this->gradingLockModel->getLock($classSectionId, $semester, $schoolYear);
-        if (!empty($existing) && !empty($existing['is_locked'])) {
-            return redirect()->back()->with('status', 'Scores already submitted and locked.');
-        }
-
-        $userId = $teacherId;
-        if (!empty($existing)) {
-            $this->gradingLockModel->update($existing['id'], [
-                'is_locked' => 1,
-                'locked_by' => $userId > 0 ? $userId : null,
-                'locked_at' => utc_now(),
-            ]);
-        } else {
-            $this->gradingLockModel->insert([
-                'class_section_id' => $classSectionId,
-                'semester' => $semester,
-                'school_year' => $schoolYear,
-                'is_locked' => 1,
-                'locked_by' => $userId > 0 ? $userId : null,
-                'locked_at' => utc_now(),
-            ]);
-        }
-
-        return redirect()->back()->with('status', 'Scores submitted and locked for this semester.');
-    }
-
-    public function noClasses()
-    {
-        return view('/teacher/no_classes');
-    }
-
-    private function getStudentScores(int $classSectionId, $semester, $schoolYear, int $teacherId)
-    {
-        if (!$semester || !$schoolYear) {
-            throw new \RuntimeException('Semester or school year configuration is missing.');
-        }
-
-        $totalSemesterDays = null;
-        $normSemester = $this->normalizeSemester($semester);
-        if ($schoolYear !== '' && $normSemester !== '') {
-            $semRange = $this->getSemesterRange($schoolYear, $normSemester);
-            if ($semRange) {
-                try {
-                    $events = $this->calendarModel->getEventsBySchoolYearAndSemester($schoolYear, $normSemester);
-                    $noSchoolSundays = 0;
-                    foreach ($events as $event) {
-                        if (!empty($event['no_school'])) {
-                            $date = new \DateTime($event['date']);
-                            if ($date->format('N') == 7) {
-                                if ($date->format('Y-m-d') >= $semRange[0] && $date->format('Y-m-d') <= $semRange[1]) {
-                                    $noSchoolSundays++;
-                                }
-                            }
-                        }
-                    }
-                    $totalSemesterDays = $this->countSundays($semRange[0], $semRange[1]) - $noSchoolSundays;
-                } catch (\Throwable $e) {
-                    log_message('error', 'Failed to count sundays for score calculation: ' . $e->getMessage());
-                    $totalSemesterDays = null;
-                }
-            }
-        }
-
-        if ($totalSemesterDays === null) {
-            $totalSemesterDays = strtolower($semester) === 'fall'
-                ? $this->configModel->getConfig('total_semester1_days')
-                : $this->configModel->getConfig('total_semester2_days');
-        }
-
-
-        if (!$totalSemesterDays) {
-            throw new \RuntimeException('Total semester days configuration is missing.');
-        }
-
-        if ($classSectionId <= 0) {
-            throw new \RuntimeException('Invalid class section for the current teacher.');
-        }
-        $students = $this->prepareStudents($classSectionId, $teacherId, $schoolYear);
-        $studentIds = array_keys($students);
-
-        // Load regular scores
-        $this->loadScoresByType(new HomeworkModel(), 'homework', $students, $classSectionId, $semester, $schoolYear);
-        $this->loadScoresByType(new QuizModel(), 'quiz', $students, $classSectionId, $semester, $schoolYear);
-        $this->loadScoresByType(new ProjectModel(), 'project', $students, $classSectionId, $semester, $schoolYear);
-        $this->loadScoresByType(new MidtermExamModel(), 'midterm', $students, $classSectionId, $semester, $schoolYear);
-        $this->loadScoresByType(new FinalExamModel(), 'final_exam', $students, $classSectionId, $semester, $schoolYear);
-        $this->loadScoresByType(new ParticipationModel(), 'participation', $students, $classSectionId, $semester, $schoolYear);
-
-        $this->calculateStudentScores($students, $classSectionId, $semester, $totalSemesterDays);
-
-        // Load all semester scores in one query
-        $this->loadSemesterScores($students, $classSectionId, $semester, $schoolYear);
-
-        $this->loadComments(new ScoreCommentModel(), $students, $studentIds, $semester, $schoolYear);
-
-        $homeworkIndexes = $this->loadIndexedScores(new HomeworkModel(), 'homework_index', $students, $classSectionId, $semester, $schoolYear, 'homework_scores_by_index');
-        $quizIndexes = $this->loadIndexedScores(new QuizModel(), 'quiz_index', $students, $classSectionId, $semester, $schoolYear, 'quiz_scores_by_index');
-        $projectIndexes = $this->loadIndexedScores(new ProjectModel(), 'project_index', $students, $classSectionId, $semester, $schoolYear, 'project_scores_by_index');
-        $this->loadMissingOverrides($students, $classSectionId, $semester, $schoolYear);
-        $this->buildMissingItems($students, $homeworkIndexes, $quizIndexes, $projectIndexes, $semester);
-
-        return $students;
-    }
-
-    private function loadSemesterScores(&$students, $classSectionId, $semester, $schoolYear)
-    {
-        // Get all scores in one query
-        $results = $this->semesterScoreModel->select('student_id, attendance_score, ptap_score, semester_score, midterm_exam_score, final_exam_score')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        foreach ($results as $row) {
-            $studentId = $row['student_id'];
-            
-            if (isset($students[$studentId])) {
-                $attendanceScore = $this->roundScore($row['attendance_score'] ?? null);
-                if ($attendanceScore !== null && !isset($students[$studentId]['attendance_score'])) {
-                    $students[$studentId]['attendance_score'] = $attendanceScore;
-                }
-                $ptapScore = $this->roundScore($row['ptap_score'] ?? null);
-                if ($ptapScore !== null && !isset($students[$studentId]['ptap_score'])) {
-                    $students[$studentId]['ptap_score'] = $ptapScore;
-                }
-                $semesterScore = $this->roundScore($row['semester_score'] ?? null);
-                if ($semesterScore !== null && !isset($students[$studentId]['semester_score'])) {
-                    $students[$studentId]['semester_score'] = $semesterScore;
-                }
-                $midtermScore = $this->roundScore($row['midterm_exam_score'] ?? null);
-                if ($midtermScore !== null && empty($students[$studentId]['midterm'])) {
-                    $students[$studentId]['midterm'][] = $midtermScore;
-                }
-                $finalExamScore = $this->roundScore($row['final_exam_score'] ?? null);
-                if ($finalExamScore !== null && empty($students[$studentId]['final_exam'])) {
-                    $students[$studentId]['final_exam'][] = $finalExamScore;
-                }
-            }
-        }
-    }
-
-    private function roundScore($value): ?float
-    {
-        if ($value === null) {
-            return null;
-        }
-        
-        // Ensure value is numeric before rounding
-        return is_numeric($value) ? round((float)$value, 1) : null;
-    }
-
-    private function prepareStudents($classSectionId, $teacherId, $schoolYear)
-    {
-        $students = [];
-        $studentClasses = $this->studentClassModel
-            ->active()
-            ->where('student_class.class_section_id', $classSectionId)
-            ->findAll();
-
-        foreach ($studentClasses as $studentClass) {
-            $student = $this->studentModel
-                ->select('id, firstname, lastname, age, school_id')
-                ->where('id', $studentClass['student_id'])
-                ->where('is_active', 1)
-                ->first();
-            if ($student) {
-                $students[$student['id']] = [
-                    'student_id' => $student['id'],
-                    'firstname' => $student['firstname'],
-                    'lastname' => $student['lastname'],
-                    'age' => $student['age'],
-                    'school_id' => $student['school_id'],
-                    'class_section_id' => $classSectionId,
-                    'school_year' => $schoolYear,
-                    'teacher_id' => $teacherId,
-                    'homework' => [],
-                    'quiz' => [],
-                    'midterm' => [],
-                    'final_exam' => [],
-                    'project' => [],
-                    'participation' => [],
-                    'ptap' => [],
-                    'ptap_comment' => '',
-                    'midterm_comment' => '',
-                    'final_comment' => ''
-                ];
-            }
-        }
-        return $students;
-    }
-
-    private function loadScoresByType($model, $type, &$students, $classSectionId, $semester, $schoolYear)
-    {
-        $records = $model->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        foreach ($records as $rec) {
-            if (!isset($students[$rec['student_id']])) {
-                continue;
-            }
-
-            // Only include real numeric scores; leave null/blank out entirely
-            if ($rec['score'] === null || $rec['score'] === '') {
-                continue;
-            }
-
-            if (!is_numeric($rec['score'])) {
-                continue;
-            }
-
-            $students[$rec['student_id']][$type][] = (float) $rec['score'];
-        }
-    }
-
-    private function loadIndexedScores($model, string $indexField, array &$students, int $classSectionId, $semester, $schoolYear, string $storeKey): array
-    {
-        $records = $model->select("student_id, {$indexField} as idx, score")
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        $indexes = [];
-        foreach ($records as $rec) {
-            $sid = (int) ($rec['student_id'] ?? 0);
-            $idx = (int) ($rec['idx'] ?? 0);
-            if ($idx <= 0) {
-                continue;
-            }
-            $indexes[$idx] = true;
-            if (isset($students[$sid])) {
-                if (!isset($students[$sid][$storeKey]) || !is_array($students[$sid][$storeKey])) {
-                    $students[$sid][$storeKey] = [];
-                }
-                $students[$sid][$storeKey][$idx] = $rec['score'] ?? null;
-            }
-        }
-
-        $indexList = array_keys($indexes);
-        sort($indexList, SORT_NUMERIC);
-        return $indexList;
-    }
-
-    private function loadComments($commentModel, &$students, $studentIds, $semester, $schoolYear)
-    {
-        if (empty($studentIds)) return;
-
-        $semVariants = array_values(array_unique(array_filter([
-            $semester,
-            strtolower((string)$semester),
-            ucfirst(strtolower((string)$semester)),
-        ], static fn($v) => $v !== '')));
-
-        $comments = $commentModel->whereIn('student_id', $studentIds)
-            ->whereIn('semester', $semVariants)
-            ->where('school_year', $schoolYear)
-            ->findAll();
-
-        foreach ($comments as $comment) {
-            $sid = $comment['student_id'];
-            if (!isset($students[$sid])) continue;
-            
-            $type = strtolower($comment['score_type']);
-            
-            // Set both comment and comment_review for each type
-            if ($type === 'ptap') {
-                $students[$sid]['ptap_comment'] = $comment['comment'];
-                $students[$sid]['ptap_comment_review'] = $comment['comment_review'] ?? null;
-            } 
-            elseif ($type === 'midterm') {
-                $students[$sid]['midterm_comment'] = $comment['comment'];
-                $students[$sid]['midterm_comment_review'] = $comment['comment_review'] ?? null;
-            } 
-            elseif ($type === 'final') {
-                $students[$sid]['final_comment'] = $comment['comment'];
-                $students[$sid]['final_comment_review'] = $comment['comment_review'] ?? null;
-            }
-            elseif ($type === 'attendance' || $type === 'attendance_comment') {
-                $students[$sid]['attendance_comment'] = $comment['comment'];
-                $students[$sid]['attendance_comment_review'] = $comment['comment_review'] ?? null;
-            }
-        }
-
-        // Fallback: if no attendance comment saved, derive one from score for display
-        helper('attendance_comment');
-        foreach ($students as $sid => &$student) {
-            if (!isset($student['attendance_comment']) && isset($student['attendance_score'])) {
-                $student['attendance_comment'] = attendance_comment_from_score(
-                    $student['attendance_score'],
-                    $student['firstname'] ?? ''
-                );
-            }
-        }
-    }
-
-    private function loadMissingOverrides(array &$students, int $classSectionId, $semester, $schoolYear): void
-    {
-        if ($classSectionId <= 0 || empty($students)) {
-            return;
-        }
-
-        $rows = $this->missingScoreOverrideModel
-            ->select('student_id, item_type, item_index')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->where('is_allowed', 1)
-            ->findAll();
-
-        foreach ($rows as $row) {
-            $sid = (int) ($row['student_id'] ?? 0);
-            if (!isset($students[$sid])) {
-                continue;
-            }
-            $type = (string) ($row['item_type'] ?? '');
-            if ($type === '') {
-                continue;
-            }
-            $idx = isset($row['item_index']) ? (int) $row['item_index'] : 0;
-            if (!isset($students[$sid]['missing_ok'])) {
-                $students[$sid]['missing_ok'] = [];
-            }
-            if (!isset($students[$sid]['missing_ok'][$type])) {
-                $students[$sid]['missing_ok'][$type] = [];
-            }
-            $students[$sid]['missing_ok'][$type][$idx] = true;
-        }
-    }
-
-    private function buildMissingItems(array &$students, array $homeworkIndexes, array $quizIndexes, array $projectIndexes, $semester): void
-    {
-        $isFall = strtolower((string) $semester) === 'fall';
-        $isSpring = strtolower((string) $semester) === 'spring';
-
-        foreach ($students as $sid => &$student) {
-            $missing = [];
-            $missingOk = $student['missing_ok'] ?? [];
-            $isAllowed = static function (array $missingOk, string $type, ?int $idx = null): bool {
-                $key = $idx === null ? 0 : $idx;
-                return !empty($missingOk[$type][$key]);
-            };
-
-            foreach ($homeworkIndexes as $idx) {
-                $val = $student['homework_scores_by_index'][$idx] ?? null;
-                if (($val === null || $val === '' || !is_numeric($val)) && !$isAllowed($missingOk, 'homework', $idx)) {
-                    $missing[] = 'Homework ' . $idx;
-                }
-            }
-
-            foreach ($quizIndexes as $idx) {
-                $val = $student['quiz_scores_by_index'][$idx] ?? null;
-                if (($val === null || $val === '' || !is_numeric($val)) && !$isAllowed($missingOk, 'quiz', $idx)) {
-                    $missing[] = 'Quiz ' . $idx;
-                }
-            }
-
-            foreach ($projectIndexes as $idx) {
-                $val = $student['project_scores_by_index'][$idx] ?? null;
-                if (($val === null || $val === '' || !is_numeric($val)) && !$isAllowed($missingOk, 'project', $idx)) {
-                    $missing[] = 'Project ' . $idx;
-                }
-            }
-
-            if (empty($student['participation']) && !$isAllowed($missingOk, 'participation', 0)) {
-                $missing[] = 'Participation';
-            }
-
-            if ($isFall && empty($student['midterm']) && !$isAllowed($missingOk, 'midterm_exam', 0)) {
-                $missing[] = 'Midterm Exam';
-            }
-
-            if ($isSpring && empty($student['final_exam']) && !$isAllowed($missingOk, 'final_exam', 0)) {
-                $missing[] = 'Final Exam';
-            }
-
-            $ptapComment = trim((string) ($student['ptap_comment'] ?? ''));
-            if ($ptapComment === '' && !$isAllowed($missingOk, 'ptap_comment', 0)) {
-                $missing[] = 'PTAP Comment';
-            }
-
-            if ($isFall) {
-                $midtermComment = trim((string) ($student['midterm_comment'] ?? ''));
-                if ($midtermComment === '' && !$isAllowed($missingOk, 'midterm_comment', 0)) {
-                    $missing[] = 'Midterm Comment';
-                }
-            }
-
-            if ($isSpring) {
-                $finalComment = trim((string) ($student['final_comment'] ?? ''));
-                if ($finalComment === '' && !$isAllowed($missingOk, 'final_comment', 0)) {
-                    $missing[] = 'Final Comment';
-                }
-            }
-
-            $student['missing_items'] = $missing;
-        }
-    }
-
-    private function calculateStudentScores(&$students, int $classSectionId, $semester, $totalDays)
-    {
-        foreach ($students as $sid => &$s) {
-            $attendanceScore = $this->calculateAttendanceScoreForStudent(
-                $sid,
-                $classSectionId,
-                $semester,
-                $s['school_year'] ?? '',
-                $totalDays
-            );
-            if ($attendanceScore === null) {
-                $attendanceScore = 100.0;
-            }
-            $attendance = $attendanceScore;
-
-            $homeworkScores = array_values(array_filter(
-                $s['homework'],
-                static fn($score) => $score !== null && $score !== '' && is_numeric($score)
-            ));
-            $avgHomework = !empty($homeworkScores) ? array_sum($homeworkScores) / count($homeworkScores) : null;
-
-            $quizScores = array_values(array_filter(
-                $s['quiz'],
-                static fn($score) => $score !== null && $score !== '' && is_numeric($score)
-            ));
-            $avgQuiz = !empty($quizScores) ? array_sum($quizScores) / count($quizScores) : null;
-
-            $projectScores = array_values(array_filter(
-                $s['project'],
-                static fn($score) => $score !== null && $score !== '' && is_numeric($score)
-            ));
-            $avgProject = !empty($projectScores) ? array_sum($projectScores) / count($projectScores) : null;
-
-            $participationScores = array_values(array_filter(
-                $s['participation'],
-                static fn($score) => $score !== null && $score !== '' && is_numeric($score)
-            ));
-            $avgParticipation = !empty($participationScores) ? array_sum($participationScores) / count($participationScores) : null;
-
-            $ptap = $this->calculatePtapScore($avgHomework, $avgQuiz, $avgProject, $avgParticipation);
-
-            $midterm = (!empty($s['midterm']) && $s['midterm'][0] !== null && $s['midterm'][0] !== '')
-                ? (float) $s['midterm'][0]
-                : null;
-            $final = (!empty($s['final_exam']) && $s['final_exam'][0] !== null && $s['final_exam'][0] !== '')
-                ? (float) $s['final_exam'][0]
-                : null;
-
-            $score = null;
-            if ($ptap !== null) {
-                $score = 0.2 * $ptap + 0.2 * $attendance;
-                if (strtolower($semester) === 'fall') {
-                    if ($midterm !== null) {
-                        $score += 0.6 * $midterm;
-                    } else {
-                        $score = null;
-                    }
-                } else {
-                    if ($final !== null) {
-                        $score += 0.6 * $final;
-                    } else {
-                        $score = null;
-                    }
-                }
-            }
-
-            $s['average_homework'] = $avgHomework !== null ? round($avgHomework, 1) : null;
-            $s['average_quiz'] = $avgQuiz !== null ? round($avgQuiz, 1) : null;
-            $s['average_project'] = $avgProject !== null ? round($avgProject, 1) : null;
-            $s['average_participation'] = $avgParticipation !== null ? round($avgParticipation, 1) : null;
-            $s['ptap_score'] = $ptap !== null ? round($ptap, 1) : null;
-            $s['midterm_score'] = $midterm !== null ? round($midterm, 1) : null;
-            $s['final_exam_score'] = $final !== null ? round($final, 1) : null;
-            $s['attendance_score'] = round($attendanceScore, 1);
-            $s['semester_score'] = $score !== null ? round(min($score, 100), 1) : null;
-        }
-    }
-
-    private function calculateAttendanceScoreForStudent(
-        int $studentId,
-        int $classSectionId,
-        string $semester,
-        string $schoolYear,
-        ?int $totalDays
-    ): ?float {
-        $score = $this->getAttendanceScoreFromCalculator(
-            $studentId,
-            $semester,
-            $schoolYear,
-            $classSectionId
-        );
-        if ($score !== null) {
-            return $score;
-        }
-        return $this->calculateAttendanceScoreFallback(
-            $studentId,
-            $semester,
-            $schoolYear,
-            $totalDays
-        );
-    }
-
-    private function getAttendanceScoreFromCalculator(
-        int $studentId,
-        string $semester,
-        string $schoolYear,
-        int $classSectionId
-    ): ?float {
-        try {
-            $result = $this->attendanceCalculator->calculate($studentId, $semester, $schoolYear, $classSectionId);
-            $score = $result['attendance_score'] ?? null;
-            if ($score === null || $score === '') {
-                return null;
-            }
-            return (float) $score;
-        } catch (\Throwable $e) {
-            log_message(
-                'error',
-                'ScoreController::getAttendanceScoreFromCalculator failed for '
-                . "student {$studentId}: " . $e->getMessage()
-            );
-        }
-        return null;
-    }
-
-    private function calculateAttendanceScoreFallback(
-        int $studentId,
-        string $semester,
-        string $schoolYear,
-        ?int $totalDays
-    ): ?float {
-        if ($totalDays === null || $totalDays <= 0) {
-            return 100.0;
-        }
-
-        $attendanceDataModel = new AttendanceDataModel();
-        $absences = $attendanceDataModel
-            ->where('student_id', $studentId)
-            ->where('semester', $semester)
-            ->where('school_year', $schoolYear)
-            ->where('status', 'absent')
-            ->countAllResults();
-
-        return max(0, ((($totalDays - $absences) / $totalDays) * 100));
-    }
-
-    /**
-     * PTAP weighting rules (tests are represented by quiz averages):
-     * - No tests and no projects: 50% homework, 50% participation.
-     * - No projects: 40% homework, 40% participation, 20% tests.
-     * - No tests: 34% homework, 33% participation, 33% projects.
-     * - All available: 30% homework, 30% participation, 30% projects, 10% tests.
-     */
-    private function calculatePtapScore(?float $avgHomework, ?float $avgQuiz, ?float $avgProject, ?float $avgParticipation): ?float
-    {
-        $hasTests = $avgQuiz !== null;
-        $hasProjects = $avgProject !== null;
-
-        if (!$hasTests && !$hasProjects) {
-            if ($avgHomework === null || $avgParticipation === null) {
-                return null;
-            }
-            return round(($avgHomework * 0.5) + ($avgParticipation * 0.5), 1);
-        }
-
-        if (!$hasProjects) {
-            if ($avgHomework === null || $avgParticipation === null || $avgQuiz === null) {
-                return null;
-            }
-            return round(($avgHomework * 0.4) + ($avgParticipation * 0.4) + ($avgQuiz * 0.2), 1);
-        }
-
-        if (!$hasTests) {
-            if ($avgHomework === null || $avgParticipation === null || $avgProject === null) {
-                return null;
-            }
-            return round(($avgHomework * 0.34) + ($avgParticipation * 0.33) + ($avgProject * 0.33), 1);
-        }
-
-        if ($avgHomework === null || $avgParticipation === null || $avgProject === null || $avgQuiz === null) {
-            return null;
-        }
-
-        return round(
-            ($avgHomework * 0.3) + ($avgParticipation * 0.3) + ($avgProject * 0.3) + ($avgQuiz * 0.1),
-            1
-        );
-    }
-
-    private function getHomeworkCount(int $classSectionId, string $semester, string $schoolYear): int
-    {
-        if ($classSectionId <= 0 || $semester === '' || $schoolYear === '') {
-            return 0;
-        }
-
-        $builder = $this->db->table('homework')
-            ->select('COUNT(DISTINCT homework_index) AS hw_count')
-            ->where('class_section_id', $classSectionId)
-            ->where('semester', $semester);
-
-        if ($schoolYear !== '') {
-            $builder->where('school_year', $schoolYear);
-        }
-
-        $row = $builder->get()->getRow();
-
-        // Fallback: if none found (school_year not populated), drop school_year filter
-        if ((!$row || $row->hw_count === null) && $schoolYear !== '') {
-            $row = $this->db->table('homework')
-                ->select('COUNT(DISTINCT homework_index) AS hw_count')
-                ->where('class_section_id', $classSectionId)
-                ->where('semester', $semester)
-                ->get()
-                ->getRow();
-        }
-
-        return ($row && $row->hw_count !== null) ? (int) $row->hw_count : 0;
-    }
-
-    private function saveFinalScores($students, $model, $teacherId, $classSectionId, $semester, $schoolYear)
-    {
-        foreach ($students as $s) {
-            $existing = $model->where('student_id', $s['student_id'])
-                ->where('class_section_id', $classSectionId)
-                ->where('semester', $semester)
-                ->where('school_year', $schoolYear)
-                ->first();
-
-            $data = [
-                'student_id' => $s['student_id'],
-                'class_section_id' => $classSectionId,
-                'updated_by' => $teacherId,
-                'score' => $s['semester_score'],
-                'score_letter' => $this->convertScoreToLetter($s['semester_score']),
-                'semester' => $semester,
-                'school_year' => $schoolYear,
-                'updated_at' => utc_now(),
-            ];
-
-            if ($existing) $model->update($existing['id'], $data);
-            else {
-                $data['created_at'] = utc_now();
-                $model->save($data);
-            }
-        }
-    }
-
-
-
-
-    private function convertScoreToLetter($score)
-    {
-        // Example conversion function, adjust logic as needed
-        if ($score >= 90) {
-            return 'A';
-        } elseif ($score >= 80) {
-            return 'B';
-        } elseif ($score >= 70) {
-            return 'C';
-        } elseif ($score >= 60) {
-            return 'D';
-        } else {
-            return 'F';
-        }
-    }
-
-    private function resolveActiveSemester(): string
-    {
-        $session = session();
-        $selected = $session->get('teacher_scores_selected_semester');
-        if (!empty($selected)) {
-            return (string) $selected;
-        }
-        return $session->get('semester') ?? $this->semester;
-    }
-
-    protected function normalizeSemester(?string $input): string
-    {
-        $s = strtolower(trim((string)$input));
-        if ($s === 'fall' || str_contains($s, '1')) return 'fall';
-        if ($s === 'spring' || str_contains($s, '2')) return 'spring';
-        return '';
-    }
-
-    protected function getSemesterRange(string $schoolYear, string $semester): ?array
-    {
-        $norm = $this->normalizeSemester($semester);
-        if ($norm === '' || !preg_match('/^(\\d{4})/', trim($schoolYear), $m)) {
-            return null;
-        }
-        $y1 = (int)$m[1];
-        $y2 = $y1 + 1;
-
-        $fallStartCfg   = (string)($this->configModel->getConfig('fall_semester_start')   ?? '');
-        $fallEndCfg     = (string)($this->configModel->getConfig('fall_end_date')     ?? ''); // e.g., 'YYYY-01-15'
-        $springStartCfg = (string)($this->configModel->getConfig('spring_semester_start') ?? ''); // e.g., 'YYYY-01-16'
-        $springEndCfg   = (string)($this->configModel->getConfig('last_school_day')   ?? '');
-
-        if ($norm === 'fall') {
-            $start = ($fallStartCfg !== '') ? date($y1 . '-m-d', strtotime($fallStartCfg)) : "{$y1}-09-01";
-            $end   = ($fallEndCfg   !== '') ? date($y2 . '-m-d', strtotime($fallEndCfg))   : "{$y2}-01-15";
-            return [$start, $end];
-        }
-
-        if ($norm === 'spring') {
-            $start = ($springStartCfg !== '') ? date($y2 . '-m-d', strtotime($springStartCfg)) : "{$y2}-01-16";
-            $end   = ($springEndCfg   !== '') ? date($y2 . '-m-d', strtotime($springEndCfg))   : "{$y2}-06-30";
-            return [$start, $end];
-        }
-
-        return null;
-    }
-
-    private function countSundays(string $startDate, string $endDate): int
-    {
-        $start = new \DateTime($startDate);
-        $end = new \DateTime($endDate);
-        $sundays = 0;
-        $interval = new \DateInterval('P1D');
-        $period = new \DatePeriod($start, $interval, $end->modify('+1 day')); // include end date
-
-        foreach ($period as $day) {
-            if ($day->format('N') == 7) {
-                $sundays++;
-            }
-        }
-        return $sundays;
-    }
-
-
-    public function updateFinalExamScores()
-    {
-        return $this->updateScores('final_exam');
-    }
-
-    public function updateFinalExamScoresForGrading()
-    {
-        return $this->updateScores('final_exam', base_url('grading'));
-    }
-
-    public function updateMidtermScores()
-    {
-        return $this->updateScores('midterm_exam');
-    }
-
-    public function updateScores(string $table, ?string $redirectUrl = null)
-    {
-        $builder = $this->db->table($table);
-
-        $scores = $this->request->getPost('final_score');  // name must match input form
-        $teacherId = session()->get('user_id');
-        $classSectionId = session()->get('class_section_id');
-        $semester = $this->resolveActiveSemester();
-        $affectedStudents = [];
-
-        $classSectionId = (int) ($classSectionId ?? 0);
-        if ($classSectionId > 0 && $this->gradingLockModel->isLocked($classSectionId, $semester, $this->schoolYear)) {
-            return redirect()->back()->with('error', 'Scores are locked for this class. Unlock to edit.');
-        }
-
-        if (is_array($scores) && in_array($table, ['midterm_exam', 'final_exam'], true)) {
-            $missingOk = $this->request->getPost('missing_ok') ?? [];
-            $studentIds = array_keys($scores);
-            $checkedItems = [];
-            if (is_array($missingOk)) {
-                foreach ($missingOk as $studentId => $flags) {
-                    $checkedItems[] = [
-                        'student_id' => (int) $studentId,
-                        'item_index' => null,
-                    ];
-                }
-            }
-            $this->missingScoreOverrideModel->replaceOverrides(
-                $classSectionId,
-                (string) $semester,
-                (string) $this->schoolYear,
-                $table === 'midterm_exam' ? 'midterm_exam' : 'final_exam',
-                $studentIds,
-                null,
-                $checkedItems,
-                $teacherId,
-                true
-            );
-        }
-
-        if (is_array($scores)) {
-            foreach ($scores as $studentId => $data) {
-                if (!is_numeric($studentId)) {
-                    continue;
-                }
-
-                $rawScore = $data['score'] ?? null;
-                $normalizedScore = is_numeric($rawScore) ? (float) $rawScore : null;
-
-                // Check if a record already exists for this student
-                $existing = $builder
-                    ->where('student_id', $studentId)
-                    ->where('class_section_id', $classSectionId)
-                    ->where('semester', $semester)
-                    ->where('school_year', $this->schoolYear)
-                    ->get()
-                    ->getRow();
-
-                $insertData = [
-                    'student_id' => $studentId,
-                    'class_section_id' => $classSectionId,
-                    'updated_by' => $teacherId,
-                'score' => $normalizedScore,
-                //'comment' => $data['comment'] ?? null,
-                    'semester' => $semester,
-                'school_year' => $this->schoolYear,
-                'updated_at' => utc_now()
-            ];
-
-                if (strcasecmp($table, 'quiz') === 0) {
-                    $insertData['quiz_index'] = $data['quiz_index'] ?? null;
-                }
-
-                if ($existing) {
-                    // Update existing
-                    $builder->where('id', $existing->id)->update($insertData);
-                } else {
-                    // Insert new
-                    $insertData['created_at'] = utc_now();
-                    $builder->insert($insertData);
-                }
-
-                // Track student for events (avoid duplicates)
-                $affectedStudents[(int)$studentId] = true;
-            }
-        }
-
-        // If final exam scores updated during Spring, trigger finalScoreReleased for these students
-        if (strcasecmp($table, 'final_exam') === 0 && strcasecmp((string)$this->semester, 'Spring') === 0 && !empty($affectedStudents)) {
-            $ids = array_keys($affectedStudents);
-            $payload = ['students' => array_map(static fn($sid) => ['id' => (int)$sid], $ids)];
-            //Events::trigger('finalScoreReleased', $payload);
-        }
-
-        // Ensure semester_scores are re-calculated when midterm/final exams change.
-        if (in_array(strtolower($table), ['final_exam', 'midterm_exam'], true) && $this->semesterScoreService !== null) {
-            try {
-                $studentTeacherInfo = $this->studentModel->getStudentInfoByClassSectionId(
-                    $classSectionId,
-                    $semester,
-                    $this->schoolYear
-                );
-                if (!empty($studentTeacherInfo)) {
-                    $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $this->schoolYear);
-                }
-            } catch (\Throwable $e) {
-                log_message('error', 'semester score resync failed after exam update: ' . $e->getMessage());
-            }
-        }
-
-        $statusMessage = ucfirst($table) . ' scores updated successfully.';
-        if ($redirectUrl !== null) {
-            return redirect()->to($redirectUrl)->with('status', $statusMessage);
-        }
-        return redirect()->back()->with('status', $statusMessage);
-    }
-
-
-    private function fetchAndOrganizeScores($db, &$organizedScores, $tableName, $parentId, $selectedYear, $selectedSemester)
-    {
-        // Only supports semester_scores table in this context
-        if ($tableName !== 'semester_scores') {
-            return;
-        }
-
-        // Define the columns to select
-        $columns = [
-            'students.id as student_id',
-            'students.school_id',
-            'students.firstname as student_firstname',
-            'students.lastname as student_lastname',
-            'classSection.class_section_name',
-            "$tableName.homework_avg",
-            "$tableName.quiz_avg",
-            "$tableName.project_avg",
-            "$tableName.midterm_exam_score",
-            "$tableName.final_exam_score",
-            "$tableName.attendance_score",
-            "$tableName.test_avg",
-            "$tableName.semester_score",
-            "$tableName.school_year",
-            "$tableName.semester",
-            "$tableName.created_at",
-            "$tableName.updated_at"
-            //  "$tableName.comment"
-        ];
-
-
-        // Build the query
-        $builder = $db->table($tableName);
-        $builder->select(implode(', ', $columns));
-        $builder->join('students', 'students.id = ' . $tableName . '.student_id');
-        // Join on the correct foreign key: classSection.class_section_id
-        $builder->join('classSection', 'classSection.class_section_id = ' . $tableName . '.class_section_id');
-        $builder->where('students.parent_id', $parentId)
-            ->where("$tableName.school_year", $selectedYear)
-            ->where("$tableName.semester", $selectedSemester);
-
-        $scores = $builder->get()->getResultArray();
-
-        foreach ($scores as $score) {
-            if (!isset($score['school_id'])) {
-                log_message('error', "Missing school_id for student ID: " . ($score['student_id'] ?? 'unknown'));
-                continue;
-            }
-
-            $schoolYear = $score['school_year'];
-            $semester = $score['semester'];
-            $studentSchoolId = $score['school_id'];
-
-            if (!isset($organizedScores[$schoolYear][$semester][$studentSchoolId])) {
-                $organizedScores[$schoolYear][$semester][$studentSchoolId] = [
-                    'student_firstname'     => $score['student_firstname'],
-                    'student_lastname'      => $score['student_lastname'],
-                    'class_section_name'    => $score['class_section_name'],
-                    'school_id'     => $studentSchoolId, // ✅ Add this line
-                    'scores'                => [],
-                    // 'comment'               => $score['comment'] ?? ''
-                ];
-            }
-
-
-            // Organize each category
-            $organizedScores[$schoolYear][$semester][$studentSchoolId]['scores'] = [
-                'homework'     => ['score' => $score['homework_avg']],
-                'quiz'         => ['score' => $score['quiz_avg']],
-                'project'      => ['score' => $score['project_avg']],
-                'midterm_exam' => ['score' => $score['midterm_exam_score']],
-                'final_exam'   => ['score' => $score['final_exam_score']],
-                'attendance'   => ['score' => $score['attendance_score']],
-                'test_avg'     => ['score' => $score['test_avg']],
-                'semester'     => ['score' => $score['semester_score']],
-            ];
-
-            // Optionally include comment
-            $organizedScores[$schoolYear][$semester][$studentSchoolId]['comment'] = $score['comment'] ?? '';
-        }
-    }
-
-
-public function viewStudentScore()
-{
-    $parentId = session()->get('user_id');
-    $userType = $_SESSION['user_type'];
-    $firstParentId = null;
-    $releaseFall = $this->getParentScoresReleasedForSemester('Fall');
-    $releaseSpring = $this->getParentScoresReleasedForSemester('Spring');
-    $releaseAny = $releaseFall || $releaseSpring;
-
-    // Identify the firstparent based on user type
-    if ($userType === 'primary') {
-        $firstParentId = $parentId;
-    } elseif ($userType === 'secondary') {
-        $parentData = $this->db->table('parents')
-            ->select('parent_id')
-            ->where('secondparent_user_id', $parentId)
-            ->get()
-            ->getRowArray();
-
-        if ($parentData) {
-            $firstParentId = $parentData['parent_id'];
-        }
-    } elseif ($userType === 'tertiary') {
-        $authUserData = $this->db->table('authorized_users')
-            ->select('user_id as parent_id')
-            ->where('authorized_user_id', $parentId)
-            ->get()
-            ->getRowArray();
-
-        if ($authUserData) {
-            $firstParentId = $authUserData['parent_id'];
-        }
-    }
-
-    if (!$firstParentId) {
-        return redirect()->back()->with('error', 'Unable to retrieve student data. Please contact support.');
-    }
-
-    // Handle selected school year (parents can view scores for any available year)
-    $selectedYear = $this->request->getVar('school_year') ?? $this->schoolYear;
-
-    // Fetch distinct school years only from semester_scores
-    $query = $this->db->table('semester_scores')
-        ->select('school_year')
-        ->distinct()
-        ->get();
-
-    $schoolYears = array_column($query->getResultArray(), 'school_year');
-    $schoolYears = array_unique($schoolYears);
-    rsort($schoolYears);
-
-    // Initialize scores array
-    $scores = [];
-
-    // First get all students with their class section info for this parent
-$students = $this->db->table('students')
-    ->select('students.id, students.school_id, students.firstname, students.lastname, classSection.class_section_name AS class_section_name')
-    ->join('student_class', 'student_class.student_id = students.id', 'left')
-    // Join using class_section_id FK stored in student_class
-    ->join('classSection', 'classSection.class_section_id = student_class.class_section_id', 'left')
-    ->where('students.parent_id', $firstParentId)
-    ->get()
-    ->getResultArray();
-
-    if (!empty($students)) {
-        $studentIdList = array_column($students, 'id');
-
-        // Fetch data from semester_scores for these students
-        $semesterScores = $this->db->table('semester_scores')
-            ->whereIn('student_id', $studentIdList)
-            ->where('school_year', $selectedYear)
-            ->get()
-            ->getResultArray();
-
-        $scoresByStudent = [];
-        foreach ($semesterScores as $score) {
-            $studentIdKey = (int)($score['student_id'] ?? 0);
-            $semesterName = trim((string)($score['semester'] ?? ''));
-            if ($studentIdKey === 0 || $semesterName === '') {
-                continue;
-            }
-            $normalizedSemester = ucfirst(strtolower($semesterName));
-            $scoresByStudent[$studentIdKey][$normalizedSemester] = $score;
-        }
-
-        foreach ($students as $student) {
-            $studentId = (int)$student['id'];
-            if (empty($scoresByStudent[$studentId])) {
-                continue;
-            }
-            foreach ($scoresByStudent[$studentId] as $semester => $score) {
-                $releaseScores = (strcasecmp($semester, 'Fall') === 0) ? $releaseFall
-                    : ((strcasecmp($semester, 'Spring') === 0) ? $releaseSpring : $releaseAny);
-                $scores[$selectedYear][$semester][$studentId] = [
-                    'student_id' => $studentId,
-                    'school_id' => $student['school_id'],
-                    'student_firstname' => $student['firstname'],
-                    'student_lastname' => $student['lastname'],
-                    'class_section_name' => $student['class_section_name'] ?? 'Unknown Class',
-                    'comment' => $score['comment'] ?? null,
-                    'scores' => [
-                        'homework' => ['score' => $score['homework_avg'] ?? '-'],
-                        'quiz' => ['score' => $score['quiz_avg'] ?? '-'],
-                        'project' => ['score' => $score['project_avg'] ?? '-'],
-                        'attendance' => ['score' => $score['attendance_score'] ?? '-'],
-                        'participation_score' => ['score' => $score['participation_score'] ?? '-'],
-                        'ptap' => ['score' => $releaseScores ? ($score['ptap_score'] ?? '-') : '-'],
-                        'midterm_exam' => ['score' => $releaseScores ? ($score['midterm_exam_score'] ?? '-') : '-'],
-                        'final_exam' => ['score' => $releaseScores ? ($score['final_exam_score'] ?? '-') : '-'],
-                        'semester' => ['score' => $releaseScores ? ($score['semester_score'] ?? '-') : '-']
-                    ]
-                ];
-            }
-        }
-    }
-
-    return view('/parent/scores', [
-        'organizedScores' => $scores,
-        'schoolYears' => $schoolYears,
-        'selectedYear' => $selectedYear,
-        'semesterOrder' => ['Fall', 'Spring'],
-        'showExamScores' => $releaseAny,
-        'showExamScoresBySemester' => [
-            'Fall' => $releaseFall,
-            'Spring' => $releaseSpring,
-        ],
-    ]);
-}
-
-private function getParentScoresReleasedForSemester(string $semester): bool
-{
-    $key = $this->getParentReleaseKey($semester);
-    $raw = $key ? $this->configModel->getConfig($key) : null;
-    $raw = (string) ($raw ?? '');
-    return in_array(strtolower(trim($raw)), ['1', 'true', 'yes', 'y', 'on'], true);
-}
-
-private function getParentReleaseKey(string $semester): ?string
-{
-    $s = strtolower(trim($semester));
-    if ($s === 'fall') {
-        return 'parent_scores_released_fall';
-    }
-    if ($s === 'spring') {
-        return 'parent_scores_released_spring';
-    }
-    return null;
-}
-
-
-
-}
diff --git a/app/Http/Controllers/old/ScorePredictor.php b/app/Http/Controllers/old/ScorePredictor.php
deleted file mode 100644
index a17d1ef4..00000000
--- a/app/Http/Controllers/old/ScorePredictor.php
+++ /dev/null
@@ -1,260 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use App\Models\ConfigurationModel;
-use App\Models\ClassSectionModel; 
-
-use CodeIgniter\Controller;
-
-class ScorePredictor extends Controller
-{
-    protected $db;
-    protected $configModel;
-    protected $semester;
-    protected $schoolYear;
-    protected $classSectionModel;
-    protected $studentClassModel;
-    protected $teacherModel;
-    protected $userModel;
-    protected $targetTrophy;
-    protected $targetLow;
-
-    public function __construct()
-    {
-                // Load the database service
-        $this->db = \Config\Database::connect();
-        // Check if the database connection is established
-        if (!$this->db->connect()) {
-            log_message('error', 'Database connection failed.');
-            throw new \Exception('Database connection failed.');
-        } else {
-            log_message('info', 'Database connection successful.');
-        }
-
-        // Initialize the config model
-        $this->configModel = new ConfigurationModel(); 
-        $this->classSectionModel = new ClassSectionModel();
-
-        // Retrieve the configuration values
-        $this->semester = $this->configModel->getConfig('semester');
-        $this->schoolYear = $this->configModel->getConfig('school_year');
-        $this->targetTrophy = $this->configModel->getConfig('trophy_score');
-        $this->targetLow = $this->configModel->getConfig('pass_score');
-    }
-
-    // Calculate the normal cumulative distribution function (CDF)
-    public static function normalCDF($z)
-    {
-        $t = 1 / (1 + 0.3275911 * abs($z));
-        $a1 = 0.254829592;
-        $a2 = -0.284496736;
-        $a3 = 1.421413741;
-        $a4 = -1.453152027;
-        $a5 = 1.061405429;
-        $erf = 1 - ((((($a5 * $t + $a4) * $t + $a3) * $t + $a2) * $t + $a1) * $t) * exp(-$z * $z);
-        $sign = $z < 0 ? -1 : 1;
-        return 0.5 * (1 + $sign * $erf);
-    }
-
-    public function combinedReport()
-    {
-        $request = service('request');
-        $currentSchoolYear = $this->schoolYear;
-
-        $selectedYear = $request->getVar('school_year') ?? $currentSchoolYear;
-        $classSectionId = $request->getVar('class_section_id');
-        // Only show class sections that have at least one student in the selected year
-        $classSections = $this->db->table('classSection cs')
-            ->select('cs.*')
-            ->join('student_class sc', 'sc.class_section_id = cs.class_section_id', 'inner')
-            ->where('sc.school_year', $selectedYear)
-            ->notLike('cs.class_section_name', 'KG', 'after')
-            ->groupBy('cs.id')
-            ->orderBy('cs.class_section_name', 'ASC')
-            ->get()
-            ->getResultArray();
-
-        $builder = $this->db->table('students s');
-        $builder->select('
-        s.id as student_id,
-        s.school_id,
-        s.firstname,
-        s.lastname,
-        fall.semester_score as fall_score,
-        spring.semester_score as spring_score');
-        // Also select class section for per-class trophy decision
-        $builder->select('sc.class_section_id as class_section_id');
-        $yearEsc = $this->db->escape($selectedYear);
-        $builder->join('student_class sc', 'sc.student_id = s.id AND sc.school_year = ' . $yearEsc, 'left');
-        $builder->join('classSection cs', 'cs.class_section_id = sc.class_section_id', 'left');
-        $builder->join('semester_scores fall', 'fall.student_id = s.id AND fall.semester = "fall" AND fall.school_year = "' . $selectedYear . '"', 'left');
-        $builder->join('semester_scores spring', 'spring.student_id = s.id AND spring.semester = "spring" AND spring.school_year = "' . $selectedYear . '"', 'left');
-        $builder->where('s.is_active', 1);
-        $builder->groupStart()
-            ->where('cs.class_section_name IS NULL')
-            ->orNotLike('cs.class_section_name', 'KG', 'after')
-            ->groupEnd();
-
-        if (!empty($classSectionId)) {
-            $builder->where('sc.class_section_id', $classSectionId);
-        }
-
-        $builder->groupBy('s.id');
-        $students = $builder->get()->getResultArray();
-
-        // Stats for spring
-        $springStatsQuery = $this->db->table('semester_scores')
-            ->select('AVG(semester_scores.semester_score) as mean, STDDEV(semester_scores.semester_score) as std')
-            ->join('student_class', 'student_class.student_id = semester_scores.student_id')
-            ->join('classSection cs', 'cs.class_section_id = student_class.class_section_id', 'left')
-            ->where('semester_scores.semester', 'spring')
-            ->where('semester_scores.school_year', $selectedYear)
-            ->where('student_class.school_year', $selectedYear)
-            ->groupStart()
-                ->where('cs.class_section_name IS NULL')
-                ->orNotLike('cs.class_section_name', 'KG', 'after')
-                ->groupEnd();
-
-        if (!empty($classSectionId)) {
-            $springStatsQuery->where('student_class.class_section_id', $classSectionId);
-        }
-
-        $springStats = $springStatsQuery->get()->getRow();
-        $mean = floatval($springStats->mean ?? 70);
-        $std = floatval($springStats->std ?? 0);
-
-        $results = [];
-        // Use explicit trophy parameters per new requirements
-        // Trophy threshold: minimum 94.0; allow higher configured value if set
-        $trophyThreshold = max(94.0, (float)($this->targetTrophy ?? 94.0));
-        foreach ($students as $s) {
-            $fallScore = is_numeric($s['fall_score']) ? (float)$s['fall_score'] : null;
-            $springScore = is_numeric($s['spring_score']) ? (float)$s['spring_score'] : null;
-
-            $scoreParts = array_values(array_filter([$fallScore, $springScore], static function ($v) {
-                return $v !== null;
-            }));
-            $finalAvg = !empty($scoreParts) ? round(array_sum($scoreParts) / count($scoreParts), 1) : null;
-
-            // When we already have a spring score, the year is effectively finished for trophy/pass logic.
-            $waitingForSpring = ($fallScore !== null && $springScore === null);
-
-            // Compute required spring score for trophy/pass only if spring is missing.
-            $requiredHigh = $waitingForSpring ? round(2 * $trophyThreshold - $fallScore, 2) : null;
-            $requiredLow = $waitingForSpring ? round(2 * $this->targetLow - $fallScore, 2) : null;
-
-            $zHigh = ($requiredHigh !== null && $std > 0) ? ($requiredHigh - $mean) / $std : null;
-            $zLow = ($requiredLow !== null && $std > 0) ? ($requiredLow - $mean) / $std : null;
-
-            $probHigh = $zHigh !== null ? 1 - self::normalCDF($zHigh) : null;
-            $probLow = $zLow !== null ? self::normalCDF($zLow) : null;
-
-            // Trophy determination: only award when the student's final/available average meets the threshold.
-            $riskHigh = match (true) {
-                $finalAvg !== null && !$waitingForSpring && $finalAvg >= $trophyThreshold => 'Achieved Trophy',
-                $finalAvg !== null && !$waitingForSpring => 'Unreachable',
-                $requiredHigh !== null && $requiredHigh > 100 => 'Unreachable',
-                is_null($probHigh) => 'New student',
-                $probHigh >= 0.66 => 'Low',
-                $probHigh >= 0.33 => 'Medium',
-                default => 'High'
-            };
-
-            // Fail risk
-            $riskLow = match (true) {
-                $finalAvg !== null && !$waitingForSpring && $finalAvg < $this->targetLow => 'High',
-                $finalAvg !== null && !$waitingForSpring => 'Low',
-                $requiredLow !== null && $requiredLow > 100 => 'Unlikely to pass',
-                is_null($probLow) => 'New student',
-                $probLow >= 0.66 => 'High',
-                $probLow >= 0.33 => 'Medium',
-                default => 'Low'
-            };
-
-            if ($finalAvg === null) {
-                $status = 'Undetermined';
-            } elseif ($waitingForSpring) {
-                $status = in_array($riskLow, ['High', 'Unlikely to pass'], true) ? 'May fail' : 'Can pass';
-            } else {
-                $status = $finalAvg >= 60 ? 'Passed' : 'Failed';
-            }
-
-            $results[] = [
-                'student_id' => (int)($s['student_id'] ?? 0),
-                'school_id' => $s['school_id'],
-                'firstname' => $s['firstname'],
-                'lastname' => $s['lastname'],
-                'class_section_id' => $s['class_section_id'] ?? null,
-                'fall_score' => $s['fall_score'] ?? 'N/A',
-                'spring_score' => $s['spring_score'] ?? 'N/A',
-                'final_average' => $finalAvg ?? 'N/A',
-                'required_spring_score' => $requiredHigh ?? 'N/A',
-                'winning_risk' => $riskHigh,
-                'required_spring_to_pass' => $requiredLow ?? 'N/A',
-                'failure_risk' => $riskLow,
-                'status' => $status,
-                'trophy_awarded' => ($riskHigh === 'Achieved Trophy'),
-                'trophy_reason' => ($riskHigh === 'Achieved Trophy') ? 'threshold' : '',
-            ];
-        }
-
-        // If a class section has zero threshold trophies, award trophies to top 3 ranked students
-        $bySection = [];
-        $hasThresholdTrophy = [];
-        foreach ($results as $idx => $row) {
-            $cid = (string)($row['class_section_id'] ?? '');
-            $bySection[$cid][] = $idx;
-            if (($row['trophy_reason'] ?? '') === 'threshold') {
-                $hasThresholdTrophy[$cid] = true;
-            }
-        }
-        foreach ($bySection as $cid => $indices) {
-            if (!empty($hasThresholdTrophy[$cid])) {
-                continue;
-            }
-            $candidates = [];
-            foreach ($indices as $idx) {
-                $val = $results[$idx]['final_average'] ?? null;
-                if (!is_numeric($val)) {
-                    $fall = $results[$idx]['fall_score'] ?? null;
-                    $spring = $results[$idx]['spring_score'] ?? null;
-                    $parts = [];
-                    if (is_numeric($fall)) $parts[] = (float)$fall;
-                    if (is_numeric($spring)) $parts[] = (float)$spring;
-                    if (!empty($parts)) {
-                        $val = array_sum($parts) / count($parts);
-                    }
-                }
-                if (is_numeric($val)) {
-                    $candidates[] = ['idx' => $idx, 'avg' => (float)$val];
-                }
-            }
-            if (empty($candidates)) {
-                continue;
-            }
-            usort($candidates, static fn($a, $b) => $b['avg'] <=> $a['avg']);
-            $top = array_slice($candidates, 0, 3);
-            foreach ($top as $entry) {
-                $i = $entry['idx'];
-                $results[$i]['trophy_awarded'] = true;
-                $results[$i]['trophy_reason'] = 'top3';
-                $results[$i]['winning_risk'] = 'Top 3 Trophy';
-            }
-        }
-
-        // Sort students by final average descending
-        usort($results, function ($a, $b) {
-            return ($b['final_average'] ?? 0) <=> ($a['final_average'] ?? 0);
-        });
-
-        return view('score_analysis/score_prediction', [
-            'students' => $results,
-            'school_year' => $selectedYear,
-            'classSections' => $classSections,
-            'selectedClassSectionId' => $classSectionId,
-            'semester' => $this->semester,
-        ]);
-    }
-
-}
diff --git a/app/Http/Controllers/old/TimeService.php b/app/Http/Controllers/old/TimeService.php
new file mode 100644
index 00000000..15cd02c2
--- /dev/null
+++ b/app/Http/Controllers/old/TimeService.php
@@ -0,0 +1,222 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\PreferencesModel;
+use App\Models\SettingsModel;
+use CodeIgniter\HTTP\RequestInterface;
+use CodeIgniter\I18n\Time;
+
+class TimeService
+{
+    private string $defaultUserTimezone = 'America/New_York';
+    private string $serverTimezone = 'UTC';
+
+    // Cached per-request user timezone
+    private ?string $cachedUserTz = null;
+
+    /**
+     * Prime detection cache from the Request (optional call, lazy by default).
+     */
+    public function primeFromRequest(?RequestInterface $request = null): void
+    {
+        $this->cachedUserTz = $this->detectUserTimezone($request);
+    }
+
+    /**
+     * Get the resolved user timezone (detect lazily if needed).
+     */
+    public function userTimezone(?RequestInterface $request = null): string
+    {
+        if ($this->cachedUserTz !== null) {
+            return $this->cachedUserTz;
+        }
+
+        $this->cachedUserTz = $this->detectUserTimezone($request);
+        return $this->cachedUserTz;
+    }
+
+    /**
+     * Core detection logic (headers > user pref > settings > school config > default).
+     */
+    public function detectUserTimezone(?RequestInterface $request = null): string
+    {
+        $request = $request ?: service('request');
+
+        // 1) Explicit client header
+        try {
+            $tzHeader = $request->getHeaderLine('X-Timezone')
+                ?: $request->getHeaderLine('Timezone')
+                ?: $request->getHeaderLine('Accept-Timezone')
+                ?: null;
+
+            if ($tzHeader && in_array($tzHeader, timezone_identifiers_list(), true)) {
+                return $tzHeader;
+            }
+        } catch (\Throwable $e) {
+            // ignore
+        }
+
+        // 2) User preference (if logged-in)
+        try {
+            $userId = (int) (session('user_id') ?: 0);
+            if ($userId > 0) {
+                // Do not select a specific column; some DBs may not have it yet
+                $pref = (new PreferencesModel())
+                    ->where('user_id', $userId)
+                    ->first();
+                $tz = $pref['timezone'] ?? null;
+                if ($tz && in_array($tz, timezone_identifiers_list(), true)) {
+                    return $tz;
+                }
+            }
+        } catch (\Throwable $e) {
+            // ignore
+        }
+
+        // 3) Global settings timezone (if available)
+        try {
+            $settings = (new SettingsModel())->getSettings();
+            $tz = $settings['timezone'] ?? null;
+            if ($tz && in_array($tz, timezone_identifiers_list(), true)) {
+                return $tz;
+            }
+        } catch (\Throwable $e) {
+            // ignore
+        }
+
+        // 4) School attendance timezone (if defined)
+        try {
+            $tz = (string) (config('School')->attendance['timezone'] ?? '');
+            if ($tz && in_array($tz, timezone_identifiers_list(), true)) {
+                return $tz;
+            }
+        } catch (\Throwable $e) {
+            // ignore
+        }
+
+        // 5) Default
+        return $this->defaultUserTimezone;
+    }
+
+    /**
+     * Server timezone (for storage/UTC operations).
+     */
+    public function serverTimezone(): string
+    {
+        return $this->serverTimezone;
+    }
+
+    /**
+     * Current time in user timezone as CI Time.
+     */
+    public function nowLocal(?string $tz = null): Time
+    {
+        $tz = $tz ?: $this->userTimezone();
+        return Time::now($tz);
+    }
+
+    /**
+     * Current time in UTC as CI Time.
+     */
+    public function nowUTC(): Time
+    {
+        return Time::now($this->serverTimezone);
+    }
+
+    /**
+     * Convert any supported input to UTC string (Y-m-d H:i:s by default).
+     *
+     * @param string|Time|\DateTimeInterface|null $value
+     */
+    public function toUTC($value, ?string $fromTz = null, string $format = 'Y-m-d H:i:s'): ?string
+    {
+        if ($value === null || $value === '') {
+            return null;
+        }
+
+        $fromTz = $fromTz ?: $this->userTimezone();
+
+        try {
+            if ($value instanceof Time) {
+                return $value->setTimezone($this->serverTimezone)->toDateTimeString();
+            }
+            if ($value instanceof \DateTimeInterface) {
+                return Time::createFromInstance($value)
+                    ->setTimezone($this->serverTimezone)
+                    ->format($format);
+            }
+
+            // assume string
+            return Time::parse((string)$value, $fromTz)
+                ->setTimezone($this->serverTimezone)
+                ->format($format);
+        } catch (\Throwable $e) {
+            return null;
+        }
+    }
+
+    /**
+     * Convert UTC (or provided timezone) to user-local string.
+     *
+     * @param string|Time|\DateTimeInterface|null $value
+     */
+    public function toLocal($value, ?string $sourceTz = null, ?string $targetTz = null, string $format = 'Y-m-d H:i:s'): ?string
+    {
+        if ($value === null || $value === '') {
+            return null;
+        }
+
+        $targetTz = $targetTz ?: $this->userTimezone();
+        if ($sourceTz === null && $this->isDateOnlyString($value)) {
+            // Date-only strings should not shift across timezones.
+            $sourceTz = $targetTz;
+        } else {
+            $sourceTz = $sourceTz ?: $this->serverTimezone;
+        }
+
+        try {
+            if ($value instanceof Time) {
+                return $value->setTimezone($targetTz)->format($format);
+            }
+            if ($value instanceof \DateTimeInterface) {
+                return Time::createFromInstance($value)
+                    ->setTimezone($targetTz)
+                    ->format($format);
+            }
+
+            // assume string
+            return Time::parse((string)$value, $sourceTz)
+                ->setTimezone($targetTz)
+                ->format($format);
+        } catch (\Throwable $e) {
+            return null;
+        }
+    }
+
+    /**
+     * Convenience formatter for user-local.
+     */
+    public function formatLocal($value, string $format = 'Y-m-d H:i', ?string $sourceTz = null): string
+    {
+        return (string) ($this->toLocal($value, $sourceTz, null, $format) ?? '');
+    }
+
+    /**
+     * Convenience formatter for UTC.
+     */
+    public function formatUTC($value, string $format = 'Y-m-d H:i:s', ?string $fromTz = null): string
+    {
+        return (string) ($this->toUTC($value, $fromTz, $format) ?? '');
+    }
+
+    private function isDateOnlyString($value): bool
+    {
+        if (!is_string($value)) {
+            return false;
+        }
+
+        $value = trim($value);
+        return (bool) preg_match('/^\d{4}-\d{2}-\d{2}$/', $value);
+    }
+}
diff --git a/app/Http/Controllers/old/UserController.php b/app/Http/Controllers/old/UserController.php
deleted file mode 100644
index f8d1c6fb..00000000
--- a/app/Http/Controllers/old/UserController.php
+++ /dev/null
@@ -1,874 +0,0 @@
-<?php
-
-namespace App\Controllers\View;
-
-use CodeIgniter\Events\Events;
-use App\Controllers\BaseController;
-use App\Models\UserModel;  // Assuming you have a UserModel
-use App\Models\PasswordResetModel; // Model for the password_resets table
-use CodeIgniter\I18n\Time;
-use App\Models\RoleModel;
-use App\Models\UserRoleModel;
-use App\Models\PasswordResetRequestModel;
-use App\Models\RolePermissionModel;
-use App\Models\IpAttemptModel;
-use CodeIgniter\Controller;
-use App\Controllers\View\EmailController;
-use App\Models\LoginActivityModel; // Make sure this import is present
-require_once APPPATH . 'Helpers/pbkdf2_helper.php';
-
-
-
-class UserController extends BaseController
-{
-    protected $userModel;
-    protected $roleModel;
-    protected $userRoleModel;
-    protected $db;
-    protected $passwordResetModel;
-    protected $loginActivityModel;
-    protected $resetRequestModel;
-
-    public function __construct()
-    {
-        // Load the database service
-        $this->db = \Config\Database::connect();
-        // Check if the database connection is established
-        if (!$this->db->connect()) {
-            log_message('error', 'Database connection failed.');
-            throw new \Exception('Database connection failed.');
-        } else {
-            log_message('info', 'Database connection successful.');
-        }
-        helper('auth');
-        $this->userModel = new UserModel();
-        $this->roleModel = new RoleModel();
-        $this->userRoleModel = new UserRoleModel();
-        $this->passwordResetModel = new PasswordResetModel();
-        $this->loginActivityModel = new LoginActivityModel();
-        $this->resetRequestModel = new PasswordResetRequestModel();
-    }
-
-    // Method to show the home page
-    public function home()
-    {
-        return view('/index');
-    }
-
-    // Method to show the about page
-    public function about()
-    {
-        return view('/about');
-    }
-
-    // Method to show the classes page
-    public function classes()
-    {
-        return view('/classes');
-    }
-
-    // Method to show the contact page
-    public function contact()
-    {
-        return view('/contact');
-    }
-
-    public function userList()
-    {
-        helper('url');
-
-        return view('user/user_list', [
-            'userListEndpoint' => site_url('api/users'),
-        ]);
-    }
-
-    // Method to show the list of users   
-    public function index()
-    {
-        // Fetch users along with their assigned roles
-        $builder = $this->db->table('users');
-        $builder->select('users.id, users.firstname, users.lastname, users.email, user_roles.role_id, roles.name as role, users.status, users.updated_at');
-        $builder->join('user_roles', 'users.id = user_roles.user_id', 'left');
-        $builder->join('roles', 'user_roles.role_id = roles.id', 'left');
-
-        $sort = $this->request->getGet('sort');
-        $order = $this->request->getGet('order') === 'desc' ? 'desc' : 'asc';
-
-        // Define allowed fields for sorting
-        $allowedFields = ['id', 'firstname', 'lastname', 'email', 'role'];
-
-        if (in_array($sort, $allowedFields)) {
-            $sort_column = $sort === 'role' ? 'roles.name' : 'users.' . $sort;
-            $builder->orderBy($sort_column, $order);
-        } else {
-            $builder->orderBy('users.id', 'asc');
-        }
-
-        $query = $builder->get();
-        $users = $query->getResultArray();
-
-        // Fetch available roles
-        $roleBuilder = $this->db->table('roles');
-        $roleQuery = $roleBuilder->get();
-        $roles = $roleQuery->getResultArray();
-
-        return view('user/user_list', [
-            'users' => $users,
-            'roles' => $roles,
-            'sort' => $sort,
-            'order' => $order,
-        ]);
-    }
-
-    public function userListData()
-    {
-        return $this->response->setJSON([
-            'users' => $this->buildUsersWithRoles(),
-        ]);
-    }
-
-    private function buildUsersWithRoles(): array
-    {
-        // Fetch all users
-        $users = $this->userModel->findAll();
-        if (!is_array($users)) {
-            return [];
-        }
-
-        // Aggregate guardian types (primary/secondary) by user_id
-        $gmap = [];
-        try {
-            $rows = $this->db->table('family_guardians')
-                ->select('user_id, MAX(is_primary) AS max_primary, COUNT(*) AS cnt', false)
-                ->groupBy('user_id')
-                ->get()->getResultArray();
-            foreach ($rows as $r) {
-                $uid = (int)($r['user_id'] ?? 0);
-                if ($uid <= 0) continue;
-                $maxp = (int)($r['max_primary'] ?? 0);
-                $cnt  = (int)($r['cnt'] ?? 0);
-                if ($cnt > 0) {
-                    $gmap[$uid] = $maxp > 0 ? 'Primary' : 'Secondary';
-                }
-            }
-        } catch (\Throwable $e) {
-            // ignore if table missing; leave map empty
-        }
-
-        // Aggregate "second parent presence" from legacy parents table
-        $secondByUserId = [];
-        $secondByEmail  = [];
-        try {
-            $parentFields = $this->db->getFieldNames('parents');
-            $hasSecondUid   = in_array('secondparent_user_id', $parentFields, true);
-            $hasSecondEmail = in_array('secondparent_email', $parentFields, true);
-
-            if ($hasSecondUid) {
-                // Map: user_id present in parents.secondparent_user_id
-                $uidRows = $this->db->table('parents')
-                    ->select('secondparent_user_id AS uid, COUNT(*) AS cnt', false)
-                    ->where('secondparent_user_id !=', 0)
-                    ->groupBy('secondparent_user_id')
-                    ->get()->getResultArray();
-                foreach ($uidRows as $r) {
-                    $u = (int)($r['uid'] ?? 0);
-                    if ($u > 0) {
-                        $secondByUserId[$u] = true;
-                    }
-                }
-            }
-
-            if ($hasSecondEmail) {
-                // Map: email present in parents.secondparent_email
-                $emailRows = $this->db->table('parents')
-                    ->select('LOWER(TRIM(secondparent_email)) AS em, COUNT(*) AS cnt', false)
-                    ->where('secondparent_email !=', '')
-                    ->groupBy('secondparent_email')
-                    ->get()->getResultArray();
-                foreach ($emailRows as $r) {
-                    $em = trim(strtolower((string)($r['em'] ?? '')));
-                    if ($em !== '') {
-                        $secondByEmail[$em] = true;
-                    }
-                }
-            }
-        } catch (\Throwable $e) {
-            // ignore if legacy table or fields are missing
-        }
-
-        // Prepare an array to store user data along with their roles
-        $usersWithRoles = [];
-
-        // Loop through each user and get their roles
-        foreach ($users as $user) {
-            if (!is_array($user)) {
-                continue;
-            }
-
-            // Get the user's roles from the user_roles table
-            $userRoles = $this->userRoleModel->where('user_id', $user['id'])->findAll() ?? [];
-
-            // Initialize arrays to hold role names/ids for this user
-            $roleNames = [];
-            $roleIds   = [];
-
-            // Fetch role names from the roles table
-            foreach ($userRoles as $userRole) {
-                if (!is_array($userRole) || empty($userRole['role_id'])) {
-                    continue;
-                }
-                $role = $this->roleModel->find($userRole['role_id']);
-                if ($role) {
-                    $roleIds[]   = (int) $role['id'];
-                    $roleNames[] = $role['name'];
-                }
-            }
-
-            // Parent type if user is a guardian in any family
-            $parentType = $gmap[(int)($user['id'] ?? 0)] ?? '';
-
-            // Second-from-parents flag: by secondparent_user_id or secondparent_email
-            $isSecond = false;
-            $uid = (int)($user['id'] ?? 0);
-            if ($uid > 0 && !empty($secondByUserId[$uid])) {
-                $isSecond = true;
-            } else {
-                $em = trim(strtolower((string)($user['email'] ?? '')));
-                if ($em !== '' && !empty($secondByEmail[$em])) $isSecond = true;
-            }
-
-            // Add the user data along with role names to the result array
-            $usersWithRoles[] = [
-                'user'         => $user,
-                'roles'        => $roleNames,
-                'role_ids'     => $roleIds,
-                'parent_type'  => $parentType, // 'Primary', 'Secondary', or ''
-                'second_from_parents' => $isSecond ? 'Yes' : '',
-            ];
-        }
-
-        return $usersWithRoles;
-    }
-
-    // Method to store a new user
-    public function store()
-    {
-        // Validate input data
-        $validation = \Config\Services::validation();
-        $validation->setRules([
-            'username' => 'required',
-            'password' => 'required|min_length[6]',
-            'lastname' => 'required',
-            'firstname' => 'required',
-            'cellphone' => 'required',
-            'email' => 'required|valid_email',
-            'address_street' => 'required',
-            'city' => 'required',
-            'state' => 'required',
-            'zip' => 'required',
-            'accept_school_policy' => 'required',
-            'role_id' => 'required|integer'
-        ]);
-
-        if (!$this->validate($validation->getRules())) {
-            $errors = $validation->getErrors();
-            return redirect()->back()->withInput()->with('errors', $errors);
-        }
-
-        // Prepare user data for insertion
-        $userData = [
-            'username' => $this->request->getPost('username'),
-            'password' => pbkdf2_hash($this->request->getPost('password')),
-            'lastname' => ucfirst($this->request->getPost('lastname')),
-            'firstname' => ucfirst($this->request->getPost('firstname')),
-            'cellphone' => $this->request->getPost('cellphone'),
-            'email' => strtolower($this->request->getPost('email')),
-            'address_street' => $this->request->getPost('address_street'),
-            'city' => ucfirst($this->request->getPost('city')),
-            'state' => $this->request->getPost('state'),
-            'zip' => $this->request->getPost('zip'),
-            'accept_school_policy' => $this->request->getPost('accept_school_policy'),
-        ];
-
-        // Insert user data into the database
-        if ($this->userModel->save($userData) === false) {
-            return redirect()->back()->withInput()->with('errors', $this->userModel->errors());
-        }
-
-        // Retrieve the newly created user ID
-        $userId = $this->userModel->getInsertID();
-
-        // Assign the role to the user in the user_roles table
-        $roleData = [
-            'user_id' => $userId,
-            'role_id' => $this->request->getPost('role_id'),
-            'created_at' => utc_now(),
-        ];
-
-        if ($this->userRoleModel->save($roleData) === false) {
-            return redirect()->back()->withInput()->with('errors', $this->userRoleModel->errors());
-        }
-
-        return redirect()->to('/user');
-    }
-
-    // Method to show the form for editing an existing user
-    public function edit($id)
-    {
-        $data['user'] = $this->userModel->find($id);
-        $data['roles'] = $this->roleModel->findAll();
-        $userRoles = $this->userRoleModel->where('user_id', $id)->findAll();
-        $data['assignedRoles'] = array_column($userRoles, 'role_id');
-
-        return view('user/edit', $data);
-    }
-
-
-    // Method to delete an existing user
-    public function delete($id)
-    {
-        $this->userModel->delete($id);
-
-        // Delete the user's roles from the user_roles table
-        $this->userRoleModel->where('user_id', $id)->delete();
-
-        return redirect()->to('/user');
-    }
-
-
-    //This function is necessary to display the initial forgot password form where the user enters their email address.
-    public function forgotPassword()
-    {
-        return view('/user/forgot_password');
-    }
-
-    //This function is crucial for processing the forgot password request, generating a reset token, storing it in the database, and sending an email with the reset link.
-    public function processForgotPassword()
-    {
-        log_message('debug', 'Entered processForgotPassword');
-
-        $ip = $this->request->getIPAddress();
-
-        $recentAttempts = $this->resetRequestModel
-            ->where('ip_address', $ip)
-            ->where('requested_at >=', Time::now()->subHours(24)->toDateTimeString())
-            ->countAllResults();
-
-        if ($recentAttempts >= 3) {
-            log_message('warning', "IP {$ip} blocked due to too many reset attempts.");
-            session()->setFlashdata('show_block_modal', true);
-            return redirect()->back();
-        }
-
-        // Log this attempt
-        $this->resetRequestModel->insert([
-            'ip_address'   => $ip,
-            'requested_at' => Time::now(),
-        ]);
-
-        $email = strtolower($this->request->getPost('email'));
-        $user  = $this->userModel->where('email', $email)->first();
-
-        // --- Handle unknown email ---
-        if (!$user) {
-            session()->setFlashdata('error', 'If this email is registered, you will receive a reset link.');
-            log_message('info', "Password reset requested for non-existing user {$email}");
-            return redirect()->back();
-        }
-
-        // --- Handle unverified accounts ---
-        if ((int) $user['is_verified'] === 0) {
-            session()->setFlashdata('error', 'Please check your email and complete the account activation process before resetting your password.');
-            log_message('info', "Password reset blocked for unverified user {$email}");
-            return redirect()->back();
-        }
-
-        // --- Verified user: continue with reset ---
-        $token      = bin2hex(random_bytes(48));
-        $expires_at = Time::now()->addHours(1);
-
-        $this->passwordResetModel->insert([
-            'email'      => $email,
-            'token'      => $token,
-            'created_at' => Time::now(),
-            'expires_at' => $expires_at,
-        ]);
-
-        $this->sendResetEmail($email, $token);
-
-        session()->setFlashdata('success', 'A password reset link has been sent to your email.');
-        log_message('info', "Password reset email sent to {$email}");
-
-        return redirect()->back();
-    }
-
-
-    public function blocked()
-    {
-        session()->setFlashdata('show_block_modal', true);
-        return redirect()->back(); // Show modal on the previous page
-    }
-
-    //This function is needed to display a confirmation page after the reset email has been sent, informing the user to check their email.
-    public function passwordResetConfirmation()
-    {
-        $email = session()->getFlashdata('reset_email');
-
-        return view('user/password_reset_confirmation', ['email' => $email]);
-    }
-
-    //This is a private helper function that handles sending the reset email. It’s separated out to keep the processForgotPassword function clean and focused.
-    public function sendResetEmail($email, $token)
-    {
-        $resetLink = site_url('/reset_password?token=' . $token);
-
-        // Render email template with data
-        $message = view('emails/reset_password', ['resetLink' => $resetLink]);
-
-        $emailController = new EmailController();
-        $subject = 'Password Reset Request';
-
-        if ($emailController->sendEmail($email, $subject, $message)) {
-            log_message('info', 'Password reset email successfully sent to ' . $email);
-        } else {
-            log_message('error', 'Failed to send password reset email to ' . $email);
-        }
-    }
-
-
-    //This function is necessary to display the form where the user can enter a new password, after clicking on the reset link in their email.
-    public function resetPassword()
-    {
-        // Retrieve the token from the query string
-        $token = $this->request->getGet('token');
-
-        if (!$token) {
-            return redirect()->to('/')->with('error', 'Invalid password reset link.');
-        }
-
-        // You may want to validate the token here
-        $resetEntry = $this->passwordResetModel->where('token', $token)
-            ->where('expires_at >=', Time::now())
-            ->first();
-
-        if (!$resetEntry) {
-            return redirect()->to('/')->with('error', 'Invalid or expired reset link.');
-        }
-
-        // Load the reset password view with the token
-        return view('user/reset_password', ['token' => $token]);
-    }
-
-    //This function processes the new password submission, validating the token, updating the user's password, and cleaning up the reset entry.
-    public function processResetPassword()
-    {
-        $token = $this->request->getPost('token');
-        $newPassword = $this->request->getPost('password');
-        $passConfirm = $this->request->getPost('pass_confirm');
-
-        // Validate the input
-        if (!$this->validate([
-            'password' => [
-                'label' => 'Password',
-                'rules' => 'required|min_length[8]|regex_match[/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@\-=\+*#$%&!?])[A-Za-z\d@\-=\+*#$%&!?]{8,}$/]',
-                'errors' => [
-                    'required' => 'Password is required.',
-                    'min_length' => 'Password must be at least 8 characters.',
-                    'regex_match' => 'Password must contain at least one lowercase letter, one uppercase letter, one number, and one special character (@, -, =, +, *, #, $, %, &, !, ?).'
-                ]
-            ],
-            'pass_confirm' => [
-                'label' => 'Confirm Password',
-                'rules' => 'required|matches[password]',
-                'errors' => [
-                    'required' => 'Password confirmation is required.',
-                    'matches' => 'Passwords do not match.'
-                ]
-            ]
-        ])) {
-            return redirect()->back()->withInput()->with('errors', $this->validator->getErrors());
-        }
-
-        // Find the password reset entry
-        $resetEntry = $this->passwordResetModel->where('token', $token)
-            ->where('expires_at >=', Time::now())
-            ->first();
-
-        if (!$resetEntry) {
-            return redirect()->to('/')->with('error', 'Invalid or expired reset link.');
-        }
-
-        // Find the user by email
-        $user = $this->userModel->where('email', $resetEntry['email'])->first();
-
-        if (!$user) {
-            return redirect()->to('/')->with('error', 'User not found.');
-        }
-
-        // 🛠 Hash the password using PBKDF2
-        $hashedPassword = pbkdf2_hash($newPassword);
-
-        // Update the password in the users table and set the account status to 'Active'
-        // Reset failed login attempts, suspension status, and last failed login time
-        $this->userModel->update($user['id'], [
-            'failed_attempts' => 0, // Reset failed attempts
-            'is_suspended'    => 0, // Unsuspend the account
-            'last_failed_at'  => null, // Reset the last failed login timestamp
-            'password' => $hashedPassword,
-            'status' => 'Active'
-        ]);
-
-        // Delete the used token from the password reset table
-        $this->passwordResetModel->where('token', $token)->delete();
-
-        // Retrieve the user's IP address from the request
-        $ipAddress = $this->request->getIPAddress();
-
-        // Delete the corresponding entry from the ip_attempts table, only if it exists
-        $ipAttemptModel = new IpAttemptModel();
-        $existingAttempt = $ipAttemptModel->where('ip_address', $ipAddress)->first();
-
-        if ($existingAttempt) {
-            // IP address entry exists, so delete it
-            $ipAttemptModel->where('ip_address', $ipAddress)->delete();
-        }
-
-        // Redirect to a success page with a success message
-        return view('user/password_set_success');
-    }
-
-
-
-    public function passwordSetSuccess()
-    {
-        return view('user/password_set_success');
-    }
-
-    public function confirm($token)
-    {
-        log_message('info', 'Processing email confirmation with token: ' . $token);
-
-
-        $user = $this->userModel->where('token', $token)->first();
-
-        if (!$user || $user['is_verified'] == 1) {
-            return redirect()->to('/invalid_token');
-        }
-
-
-        // Mark the user as verified and generate an account ID
-        $account_id = 'ACC' . str_pad($user['id'], 8, '0', STR_PAD_LEFT); // Example: ACC00000001
-        $this->userModel->update($user['id'], ['is_verified' => 1, 'token' => null, 'account_id' => $account_id]);
-
-        log_message('info', 'User verified and account ID generated: ' . $account_id);
-
-        // Redirect to the set password page
-        return redirect()->to('/set_password/' . $user['id']);
-    }
-
-    public function setPassword($token)
-    {
-        //echo "Reached setPassword with token: " . esc($token);
-        //echo "Token received: " . $token;
-        $user = $this->userModel->where('token', $token)->first();
-
-        if (!$user || $user['is_verified'] == 1) {
-            return redirect()->to('/invalid_token');
-        }
-
-        return view('user/set_password', [
-            'userId' => $user['id'],
-            'token' => $token
-        ]);
-    }
-
-    public function savePassword()
-    {
-        $validation = \Config\Services::validation();
-        $validation->setRules([
-            'password' => [
-                'label' => 'Password',
-                'rules' => 'required|min_length[8]|regex_match[/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@\-=\+*#$%&!?])[A-Za-z\d@\-=\+*#$%&!?]{8,}$/]',
-                'errors' => [
-                    'required' => 'Password is required.',
-                    'min_length' => 'Password must be at least 8 characters long.',
-                    'regex_match' => 'Password must contain at least one lowercase letter, one uppercase letter, one number, and one special character (@, -, =, +, *, #, $, %, &, !, ?).'
-                ]
-            ],
-            'password_confirm' => [
-                'label' => 'Confirm Password',
-                'rules' => 'required|matches[password]',
-                'errors' => [
-                    'required' => 'Password confirmation is required.',
-                    'matches' => 'Passwords do not match.'
-                ]
-            ],
-            'user_id' => 'required|integer',
-            'token' => 'required'
-        ]);
-
-        if (!$this->validate($validation->getRules())) {
-            return redirect()->back()->withInput()->with('errors', $validation->getErrors());
-        }
-
-        $userId = $this->request->getPost('user_id');
-        $token  = $this->request->getPost('token');
-        $password = $this->request->getPost('password');
-
-        $user = $this->userModel->where('id', $userId)->where('token', $token)->first();
-
-        log_message('debug', "Attempting to set password for user $userId with token $token");
-
-        if (!$user || $user['is_verified'] == 1) {
-            return redirect()->to('/invalid_token');
-        }
-
-        $hashedPassword = pbkdf2_hash($password); // Or use password_hash()
-
-        // Generate account_id only if it's not already set
-        $account_id = $user['account_id'] ?? null;
-        if (!$account_id) {
-            $account_id = 'ACC' . str_pad($userId, 8, '0', STR_PAD_LEFT);
-        }
-
-        $this->userModel->update($userId, [
-            'password'     => $hashedPassword,
-            'status'       => 'Active',
-            'is_verified'  => 1,
-            'token'        => null,
-            'account_id'   => $account_id,
-        ]);
-
-        // Optional: trigger event
-        $userData = $this->userModel->getUserInfoById($userId);
-        if (!is_array($userData)) {
-            $userData = (array) $userData;
-        }
-        $userData['id'] = $userId;
-        \CodeIgniter\Events\Events::trigger('user_registered', $userData);
-
-        return redirect()->to('/user/password_set_success');
-    }
-
-
-
-    public function invalidToken()
-    {
-        return view('errors/invalid_token');
-    }
-
-
-    public function selectRole()
-    {
-        log_message('info', 'Processing setRole form submission.');
-
-        if (!session()->get('is_logged_in')) {
-            log_message('error', 'User is not logged in.');
-            return redirect()->to('/user/login');
-        }
-
-        $roleKey = (string) $this->request->getPost('role');
-        log_message('info', 'Role selected: ' . $roleKey);
-
-        $roleModel = new RoleModel();
-        $route = $roleModel->getRouteByNameOrSlug($roleKey);
-
-        if ($route === null) {
-            log_message('error', 'Invalid or inactive role selected: ' . $roleKey);
-            return redirect()->back()->with('error', 'Invalid role selected.');
-        }
-
-        $userId = (int) session()->get('user_id');
-        log_message('info', 'User ID: ' . $userId);
-
-        // Persist the *exact* role name or slug—choose your convention.
-        // If you want to store the canonical name, fetch the row and use $row['name'].
-        $this->userModel->update($userId, ['role' => $roleKey]);
-        log_message('info', 'Role updated in database.');
-
-        log_message('info', 'Redirecting to role dashboard: ' . $route);
-        return redirect()->to($route);
-    }
-
-
-    public function welcomeBack()
-    {
-        if (!session()->get('is_logged_in')) {
-            return redirect()->to('/user/login');
-        }
-
-        return view('user/welcome_back');
-    }
-
-    public function delete_role($roleId)
-    {
-        // Fetch the role to be deleted
-        $role = $this->roleModel->find($roleId);
-        if (!$role) {
-            return redirect()->back()->with('error', 'Role not found.');
-        }
-
-        // Fetch the "Guest" role
-        $guestRole = $this->roleModel->where('name', 'Guest')->first();
-        if (!$guestRole) {
-            return redirect()->back()->with('error', 'Guest role not found.');
-        }
-
-        // Update users with the deleted role to have the "Guest" role
-        $this->userModel->where('role_id', $roleId)->set(['role_id' => $guestRole['id'], 'role' => 'Guest', 'status' => 'Inactive'])->update();
-
-        // Verify that users have been updated
-        $updatedUsers = $this->userModel->where('role_id', $guestRole['id'])->findAll();
-        log_message('debug', 'Updated users: ' . print_r($updatedUsers, true));
-
-        // Delete the role
-        if ($this->roleModel->delete($roleId)) {
-            return redirect()->to('/administrator/user_roles')->with('success', 'Role deleted successfully. Users with this role have been assigned the Guest role.');
-        } else {
-            return redirect()->back()->with('error', 'Failed to delete role.');
-        }
-    }
-
-    public function loginActivity()
-    {
-        helper('url');
-
-        $perPage = (int) ($this->request->getGet('per_page') ?? 25);
-
-        return view('user/login_activity', [
-            'loginActivityEndpoint' => site_url('api/login-activity'),
-            'defaultPerPage'        => $perPage > 0 ? $perPage : 25,
-        ]);
-    }
-
-    public function loginActivityData()
-    {
-        $perPage = (int) ($this->request->getGet('per_page') ?? 25);
-        $page    = (int) ($this->request->getGet('page') ?? 1);
-
-        return $this->response->setJSON($this->buildLoginActivityPayload($perPage, $page));
-    }
-
-    // Method to update an existing user
-    public function updateUser()
-    {
-        if (strtolower($this->request->getMethod()) !== 'post') {
-            return redirect()->to(site_url('user/user_list'))->with('error', 'Invalid request.');
-        }
-
-        $id = (int) $this->request->getPost('id');
-        if (!$id) {
-            return redirect()->to(site_url('user/user_list'))->with('error', 'User ID is missing.');
-        }
-
-        $user = $this->userModel->find($id);
-        if (!$user) {
-            return redirect()->to(site_url('user/user_list'))->with('error', 'User not found.');
-        }
-
-        // Helpers
-        $toBool = fn($k) => $this->request->getPost($k) ? 1 : 0;
-        $toDT   = function ($key) {
-            $v = trim((string)$this->request->getPost($key));
-            if ($v === '') return null;
-            // Expecting HTML datetime-local "YYYY-MM-DDTHH:MM"
-            $ts = strtotime($v);
-            return $ts ? date('Y-m-d H:i:s', $ts) : null;
-        };
-
-        $data = [
-            'id'                   => $id,
-            'account_id'           => trim((string)$this->request->getPost('account_id')),
-            'lastname'             => trim((string)$this->request->getPost('lastname')),
-            'firstname'            => trim((string)$this->request->getPost('firstname')),
-            'gender'               => trim((string)$this->request->getPost('gender')),
-            'cellphone'            => trim((string)$this->request->getPost('cellphone')),
-            'email'                => trim((string)$this->request->getPost('email')),
-            'address_street'       => trim((string)$this->request->getPost('address_street')),
-            'apt'                  => trim((string)$this->request->getPost('apt')),
-            'city'                 => trim((string)$this->request->getPost('city')),
-            'state'                => trim((string)$this->request->getPost('state')),
-            'zip'                  => trim((string)$this->request->getPost('zip')),
-            'accept_school_policy' => $toBool('accept_school_policy'),
-            'user_type'            => trim((string)$this->request->getPost('user_type')),
-            'rfid_tag'             => trim((string)$this->request->getPost('rfid_tag')),
-            'school_id'            => trim((string)$this->request->getPost('school_id')),
-            'failed_attempts'      => (string)$this->request->getPost('failed_attempts') === '' ? null : (int)$this->request->getPost('failed_attempts'),
-            'last_failed_at'       => $toDT('last_failed_at'),
-            'semester'             => trim((string)$this->request->getPost('semester')),
-            'school_year'          => trim((string)$this->request->getPost('school_year')),
-            'status'               => trim((string)$this->request->getPost('status')),
-            'is_suspended'         => $toBool('is_suspended'),
-            'is_verified'          => $toBool('is_verified'),
-            'token'                => trim((string)$this->request->getPost('token')),
-            'updated_at'           => $toDT('updated_at'),
-            'created_at'           => $toDT('created_at'),
-        ];
-
-        // Validation
-        $rules = [
-            'firstname' => 'required|min_length[2]|max_length[100]',
-            'lastname'  => 'required|min_length[2]|max_length[100]',
-            'email'     => "required|valid_email|is_unique[users.email,id,{$id}]",
-            'state'     => 'permit_empty|max_length[2]',
-            'zip'       => 'permit_empty|max_length[20]',
-            'cellphone' => 'permit_empty|max_length[50]',
-            'failed_attempts' => 'permit_empty|integer',
-            'gender'    => 'permit_empty|in_list[male,female,MALE,FEMALE]', // adjust as needed
-        ];
-
-        if (!$this->validate($rules)) {
-            return redirect()->back()
-                ->with('error', implode(' ', $this->validator->getErrors()))
-                ->withInput();
-        }
-
-        if (!$this->userModel->save($data)) {
-            return redirect()->back()->with('error', 'Failed to update user.')->withInput();
-        }
-
-        return redirect()->to(site_url('user/user_list'))->with('success', 'User updated successfully.');
-    }
-
-    private function buildLoginActivityPayload(int $perPage, int $page): array
-    {
-        $perPage = max(1, min($perPage, 200));
-        $page    = max(1, $page);
-
-        $totalActivities = (int) $this->loginActivityModel->countAll();
-        $activities = $this->loginActivityModel
-            ->orderBy('login_time', 'DESC')
-            ->paginate($perPage, 'loginActivity', $page) ?? [];
-
-        $pager = $this->loginActivityModel->pager;
-        $currentPage = $pager ? (int) $pager->getCurrentPage('loginActivity') : $page;
-        $pageCount = $pager ? (int) $pager->getPageCount('loginActivity') : (int) max(1, ceil($totalActivities / $perPage));
-
-        $normalized = array_map(static function ($activity) {
-            if (!is_array($activity)) {
-                return [];
-            }
-
-            return [
-                'user_id'     => $activity['user_id'] ?? null,
-                'email'       => $activity['email'] ?? null,
-                'login_time'  => $activity['login_time'] ?? null,
-                'logout_time' => $activity['logout_time'] ?? null,
-                'ip_address'  => $activity['ip_address'] ?? null,
-                'user_agent'  => $activity['user_agent'] ?? null,
-            ];
-        }, $activities);
-
-        return [
-            'activities' => $normalized,
-            'pagination' => [
-                'total'       => $totalActivities,
-                'perPage'     => $perPage,
-                'currentPage' => $currentPage,
-                'pageCount'   => $pageCount,
-                'hasNext'     => $currentPage < $pageCount,
-                'hasPrevious' => $currentPage > 1,
-            ],
-        ];
-    }
-}
diff --git a/app/Http/Requests/ApiFormRequest.php b/app/Http/Requests/ApiFormRequest.php
index afb6d217..b1266d21 100644
--- a/app/Http/Requests/ApiFormRequest.php
+++ b/app/Http/Requests/ApiFormRequest.php
@@ -8,6 +8,29 @@ use Illuminate\Http\Exceptions\HttpResponseException;
 
 abstract class ApiFormRequest extends FormRequest
 {
+    public function validationData(): array
+    {
+        $json = json_decode($this->getContent() ?: '', true);
+        $json = is_array($json) ? $json : [];
+
+        return array_merge(
+            $this->query->all(),
+            $this->request->all(),
+            $this->json()->all(),
+            $json
+        );
+    }
+
+    protected function prepareForValidation(): void
+    {
+        $json = json_decode($this->getContent() ?: '', true);
+        if (is_array($json)) {
+            $this->merge($json);
+        } else {
+            $this->merge($this->json()->all());
+        }
+    }
+
     protected function failedValidation(Validator $validator): void
     {
         throw new HttpResponseException(
diff --git a/app/Http/Requests/Auth/RegisterRequest.php b/app/Http/Requests/Auth/RegisterRequest.php
new file mode 100644
index 00000000..13401f00
--- /dev/null
+++ b/app/Http/Requests/Auth/RegisterRequest.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Http\Requests\Auth;
+
+use App\Http\Requests\ApiFormRequest;
+
+class RegisterRequest extends ApiFormRequest
+{
+    public static function ruleset(): array
+    {
+        return (new self())->rules();
+    }
+
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'firstname' => ['required', 'regex:/^[a-zA-Z\s-]+$/', 'min:2', 'max:30'],
+            'lastname' => ['required', 'regex:/^[a-zA-Z\s-]+$/', 'min:2', 'max:30'],
+            'gender' => ['required', 'in:Male,Female'],
+            'email' => ['required', 'email', 'max:50'],
+            'confirm_email' => ['required', 'same:email'],
+            'cellphone' => ['required', 'regex:/^[\d\s\-\(\)\.]+$/', 'min:10', 'max:20'],
+            'address_street' => ['nullable', 'regex:/^[a-zA-Z0-9\s\-]+$/', 'max:150'],
+            'apt' => ['nullable', 'regex:/^[a-zA-Z0-9\s-]+$/', 'max:10'],
+            'city' => ['required', 'regex:/^[a-zA-Z\s]+$/', 'min:2', 'max:30'],
+            'state' => ['required', 'in:CT,ME,MA,NH,NY,RI,VT'],
+            'zip' => ['required', 'regex:/^\d{5}$/'],
+            'accept_school_policy' => ['required'],
+            'captcha' => ['required', 'alpha_num', 'min:4', 'max:10'],
+            'is_parent' => ['nullable', 'boolean'],
+            'no_second_parent_info' => ['nullable', 'boolean'],
+            'second_firstname' => ['exclude_if:no_second_parent_info,1', 'required_if:is_parent,1', 'regex:/^[a-zA-Z\s\-]+$/', 'min:2', 'max:30'],
+            'second_lastname' => ['exclude_if:no_second_parent_info,1', 'required_if:is_parent,1', 'regex:/^[a-zA-Z\s\-]+$/', 'min:2', 'max:30'],
+            'second_gender' => ['exclude_if:no_second_parent_info,1', 'required_if:is_parent,1', 'in:Male,Female'],
+            'second_email' => ['exclude_if:no_second_parent_info,1', 'required_if:is_parent,1', 'email', 'max:50'],
+            'second_cellphone' => ['exclude_if:no_second_parent_info,1', 'required_if:is_parent,1', 'regex:/^[\d\s\-\(\)\.]+$/', 'min:10', 'max:20'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Discounts/ApplyDiscountVoucherRequest.php b/app/Http/Requests/Discounts/ApplyDiscountVoucherRequest.php
new file mode 100644
index 00000000..837eb514
--- /dev/null
+++ b/app/Http/Requests/Discounts/ApplyDiscountVoucherRequest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Requests\Discounts;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ApplyDiscountVoucherRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'voucher_id' => ['required', 'integer', 'min:1', 'exists:discount_vouchers,id'],
+            'parent_ids' => ['required', 'array', 'min:1'],
+            'parent_ids.*' => ['integer', 'min:1'],
+            'allow_additional' => ['nullable', 'boolean'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Discounts/StoreDiscountVoucherRequest.php b/app/Http/Requests/Discounts/StoreDiscountVoucherRequest.php
new file mode 100644
index 00000000..ce6f1326
--- /dev/null
+++ b/app/Http/Requests/Discounts/StoreDiscountVoucherRequest.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Http\Requests\Discounts;
+
+use App\Http\Requests\ApiFormRequest;
+
+class StoreDiscountVoucherRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'code' => ['required', 'string', 'max:50'],
+            'discount_type' => ['required', 'in:percent,fixed'],
+            'discount_value' => ['required', 'numeric', 'min:0'],
+            'max_uses' => ['nullable', 'integer', 'min:0'],
+            'valid_from' => ['nullable', 'date_format:Y-m-d'],
+            'valid_until' => ['nullable', 'date_format:Y-m-d', 'after_or_equal:valid_from'],
+            'is_active' => ['nullable', 'boolean'],
+            'description' => ['nullable', 'string'],
+            'school_year' => ['nullable', 'string'],
+            'semester' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Discounts/UpdateDiscountVoucherRequest.php b/app/Http/Requests/Discounts/UpdateDiscountVoucherRequest.php
new file mode 100644
index 00000000..42aeab3d
--- /dev/null
+++ b/app/Http/Requests/Discounts/UpdateDiscountVoucherRequest.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Http\Requests\Discounts;
+
+use App\Http\Requests\ApiFormRequest;
+
+class UpdateDiscountVoucherRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'code' => ['sometimes', 'string', 'max:50'],
+            'discount_type' => ['sometimes', 'in:percent,fixed'],
+            'discount_value' => ['sometimes', 'numeric', 'min:0'],
+            'max_uses' => ['nullable', 'integer', 'min:0'],
+            'valid_from' => ['nullable', 'date_format:Y-m-d'],
+            'valid_until' => ['nullable', 'date_format:Y-m-d', 'after_or_equal:valid_from'],
+            'is_active' => ['nullable', 'boolean'],
+            'description' => ['nullable', 'string'],
+            'school_year' => ['nullable', 'string'],
+            'semester' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Expenses/StoreExpenseRequest.php b/app/Http/Requests/Expenses/StoreExpenseRequest.php
new file mode 100644
index 00000000..d3d4e6bb
--- /dev/null
+++ b/app/Http/Requests/Expenses/StoreExpenseRequest.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Http\Requests\Expenses;
+
+use App\Http\Requests\ApiFormRequest;
+
+class StoreExpenseRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'category' => ['required', 'in:Expense,Purchase,Reimbursement,Donation'],
+            'amount' => ['required', 'numeric', 'gt:0'],
+            'purchased_by' => ['required', 'integer', 'min:1'],
+            'retailor' => ['nullable', 'string', 'max:255'],
+            'date_of_purchase' => ['required', 'date_format:Y-m-d'],
+            'description' => ['nullable', 'string'],
+            'receipt' => ['required', 'file', 'max:2048', 'mimes:jpg,jpeg,png,webp,gif,pdf'],
+            'school_year' => ['nullable', 'string'],
+            'semester' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Expenses/UpdateExpenseRequest.php b/app/Http/Requests/Expenses/UpdateExpenseRequest.php
new file mode 100644
index 00000000..9ed32e3d
--- /dev/null
+++ b/app/Http/Requests/Expenses/UpdateExpenseRequest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Http\Requests\Expenses;
+
+use App\Http\Requests\ApiFormRequest;
+
+class UpdateExpenseRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'category' => ['required', 'in:Expense,Purchase,Reimbursement,Donation'],
+            'amount' => ['required', 'numeric', 'gt:0'],
+            'purchased_by' => ['required', 'integer', 'min:1'],
+            'retailor' => ['nullable', 'string', 'max:255'],
+            'date_of_purchase' => ['required', 'date_format:Y-m-d'],
+            'description' => ['nullable', 'string'],
+            'receipt' => ['nullable', 'file', 'max:2048', 'mimes:jpg,jpeg,png,webp,gif,pdf'],
+            'remove_receipt' => ['nullable', 'boolean'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Expenses/UpdateExpenseStatusRequest.php b/app/Http/Requests/Expenses/UpdateExpenseStatusRequest.php
new file mode 100644
index 00000000..88f95d17
--- /dev/null
+++ b/app/Http/Requests/Expenses/UpdateExpenseStatusRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Expenses;
+
+use App\Http\Requests\ApiFormRequest;
+
+class UpdateExpenseStatusRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'status' => ['required', 'in:approved,denied'],
+            'reason' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/ExtraCharges/StoreExtraChargeRequest.php b/app/Http/Requests/ExtraCharges/StoreExtraChargeRequest.php
new file mode 100644
index 00000000..cd3eca62
--- /dev/null
+++ b/app/Http/Requests/ExtraCharges/StoreExtraChargeRequest.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Http\Requests\ExtraCharges;
+
+use App\Http\Requests\ApiFormRequest;
+
+class StoreExtraChargeRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'parent_id' => ['required', 'integer', 'min:1'],
+            'title' => ['required', 'string', 'min:2'],
+            'amount' => ['required', 'numeric'],
+            'charge_type' => ['required', 'in:add,deduct'],
+            'due_date' => ['nullable', 'date_format:Y-m-d'],
+            'invoice_id' => ['nullable', 'integer', 'min:1'],
+            'description' => ['nullable', 'string'],
+            'school_year' => ['nullable', 'string'],
+            'semester' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/ExtraCharges/UpdateExtraChargeRequest.php b/app/Http/Requests/ExtraCharges/UpdateExtraChargeRequest.php
new file mode 100644
index 00000000..0d58618b
--- /dev/null
+++ b/app/Http/Requests/ExtraCharges/UpdateExtraChargeRequest.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Requests\ExtraCharges;
+
+use App\Http\Requests\ApiFormRequest;
+
+class UpdateExtraChargeRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'title' => ['required', 'string', 'min:2'],
+            'amount' => ['required', 'numeric'],
+            'charge_type' => ['required', 'in:add,deduct'],
+            'due_date' => ['nullable', 'date_format:Y-m-d'],
+            'description' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Files/FileNameRequest.php b/app/Http/Requests/Files/FileNameRequest.php
new file mode 100644
index 00000000..11745939
--- /dev/null
+++ b/app/Http/Requests/Files/FileNameRequest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Http\Requests\Files;
+
+use App\Http\Requests\ApiFormRequest;
+
+class FileNameRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'name' => ['required', 'string', 'max:255', 'regex:/^[^\/\\\\]+$/'],
+        ];
+    }
+
+    protected function prepareForValidation(): void
+    {
+        if ($this->route('name') !== null) {
+            $this->merge(['name' => $this->route('name')]);
+        }
+    }
+}
diff --git a/app/Http/Requests/Finance/FinancialReportRequest.php b/app/Http/Requests/Finance/FinancialReportRequest.php
new file mode 100644
index 00000000..28c3aa5c
--- /dev/null
+++ b/app/Http/Requests/Finance/FinancialReportRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Finance;
+
+use App\Http\Requests\ApiFormRequest;
+
+class FinancialReportRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'date_from' => ['nullable', 'date_format:Y-m-d'],
+            'date_to' => ['nullable', 'date_format:Y-m-d', 'after_or_equal:date_from'],
+            'school_year' => ['nullable', 'string', 'max:20'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Finance/FinancialSummaryRequest.php b/app/Http/Requests/Finance/FinancialSummaryRequest.php
new file mode 100644
index 00000000..1f1c43dd
--- /dev/null
+++ b/app/Http/Requests/Finance/FinancialSummaryRequest.php
@@ -0,0 +1,7 @@
+<?php
+
+namespace App\Http\Requests\Finance;
+
+class FinancialSummaryRequest extends FinancialReportRequest
+{
+}
diff --git a/app/Http/Requests/Finance/FinancialUnpaidParentsRequest.php b/app/Http/Requests/Finance/FinancialUnpaidParentsRequest.php
new file mode 100644
index 00000000..a555b306
--- /dev/null
+++ b/app/Http/Requests/Finance/FinancialUnpaidParentsRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Finance;
+
+use App\Http\Requests\ApiFormRequest;
+
+class FinancialUnpaidParentsRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['nullable', 'string', 'max:20'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/BelowSixtyEmailRequest.php b/app/Http/Requests/Grading/BelowSixtyEmailRequest.php
new file mode 100644
index 00000000..ae522f03
--- /dev/null
+++ b/app/Http/Requests/Grading/BelowSixtyEmailRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class BelowSixtyEmailRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'student_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/BelowSixtyListRequest.php b/app/Http/Requests/Grading/BelowSixtyListRequest.php
new file mode 100644
index 00000000..b7d9aa76
--- /dev/null
+++ b/app/Http/Requests/Grading/BelowSixtyListRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class BelowSixtyListRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/BelowSixtyMeetingRequest.php b/app/Http/Requests/Grading/BelowSixtyMeetingRequest.php
new file mode 100644
index 00000000..2ef7d547
--- /dev/null
+++ b/app/Http/Requests/Grading/BelowSixtyMeetingRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class BelowSixtyMeetingRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'student_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/BelowSixtyMeetingSaveRequest.php b/app/Http/Requests/Grading/BelowSixtyMeetingSaveRequest.php
new file mode 100644
index 00000000..a2edf090
--- /dev/null
+++ b/app/Http/Requests/Grading/BelowSixtyMeetingSaveRequest.php
@@ -0,0 +1,25 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class BelowSixtyMeetingSaveRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'student_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'date' => ['required', 'string', 'max:20'],
+            'time' => ['nullable', 'string', 'max:20'],
+            'notes' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/BelowSixtySendRequest.php b/app/Http/Requests/Grading/BelowSixtySendRequest.php
new file mode 100644
index 00000000..117a8154
--- /dev/null
+++ b/app/Http/Requests/Grading/BelowSixtySendRequest.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class BelowSixtySendRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'student_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'subject' => ['nullable', 'string', 'max:255'],
+            'html' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/BelowSixtyStatusRequest.php b/app/Http/Requests/Grading/BelowSixtyStatusRequest.php
new file mode 100644
index 00000000..8339abfc
--- /dev/null
+++ b/app/Http/Requests/Grading/BelowSixtyStatusRequest.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class BelowSixtyStatusRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'student_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'status' => ['required', 'string', 'in:Open,Closed,open,closed'],
+            'note' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/GradingLockAllRequest.php b/app/Http/Requests/Grading/GradingLockAllRequest.php
new file mode 100644
index 00000000..d3a54393
--- /dev/null
+++ b/app/Http/Requests/Grading/GradingLockAllRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class GradingLockAllRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/GradingLockRequest.php b/app/Http/Requests/Grading/GradingLockRequest.php
new file mode 100644
index 00000000..9b262b3e
--- /dev/null
+++ b/app/Http/Requests/Grading/GradingLockRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class GradingLockRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/GradingOverviewRequest.php b/app/Http/Requests/Grading/GradingOverviewRequest.php
new file mode 100644
index 00000000..f0e06e7b
--- /dev/null
+++ b/app/Http/Requests/Grading/GradingOverviewRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class GradingOverviewRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_id' => ['nullable', 'integer', 'min:1'],
+            'semester' => ['nullable', 'string', 'max:50'],
+            'school_year' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/GradingRefreshRequest.php b/app/Http/Requests/Grading/GradingRefreshRequest.php
new file mode 100644
index 00000000..5a54de98
--- /dev/null
+++ b/app/Http/Requests/Grading/GradingRefreshRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class GradingRefreshRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/GradingScoreShowRequest.php b/app/Http/Requests/Grading/GradingScoreShowRequest.php
new file mode 100644
index 00000000..cb025e86
--- /dev/null
+++ b/app/Http/Requests/Grading/GradingScoreShowRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class GradingScoreShowRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/GradingScoreUpdateRequest.php b/app/Http/Requests/Grading/GradingScoreUpdateRequest.php
new file mode 100644
index 00000000..0ba665ab
--- /dev/null
+++ b/app/Http/Requests/Grading/GradingScoreUpdateRequest.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class GradingScoreUpdateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'type' => ['required', 'string', 'in:homework,quiz,project,midterm,final,test,comments'],
+            'student_id' => ['required', 'integer', 'min:1'],
+            'class_section_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'score_ids' => ['nullable', 'array'],
+            'scores' => ['nullable', 'array'],
+            'comments' => ['nullable', 'array'],
+            'score' => ['nullable', 'numeric'],
+            'comment' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/HomeworkTrackingRequest.php b/app/Http/Requests/Grading/HomeworkTrackingRequest.php
new file mode 100644
index 00000000..945dc150
--- /dev/null
+++ b/app/Http/Requests/Grading/HomeworkTrackingRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class HomeworkTrackingRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'semester' => ['nullable', 'string', 'max:50'],
+            'school_year' => ['nullable', 'string', 'max:50'],
+            'page' => ['nullable', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/PlacementBatchRequest.php b/app/Http/Requests/Grading/PlacementBatchRequest.php
new file mode 100644
index 00000000..49353aa5
--- /dev/null
+++ b/app/Http/Requests/Grading/PlacementBatchRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PlacementBatchRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['required', 'string', 'max:50'],
+            'placement_test' => ['required', 'string', 'max:100'],
+            'placement_level' => ['nullable', 'array'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/PlacementBatchUpdateRequest.php b/app/Http/Requests/Grading/PlacementBatchUpdateRequest.php
new file mode 100644
index 00000000..95127d36
--- /dev/null
+++ b/app/Http/Requests/Grading/PlacementBatchUpdateRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PlacementBatchUpdateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['required', 'string', 'max:50'],
+            'placement_level' => ['nullable', 'array'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/PlacementLevelRequest.php b/app/Http/Requests/Grading/PlacementLevelRequest.php
new file mode 100644
index 00000000..7b026430
--- /dev/null
+++ b/app/Http/Requests/Grading/PlacementLevelRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PlacementLevelRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'student_id' => ['required', 'integer', 'min:1'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'placement_level' => ['nullable', 'integer', 'min:1', 'max:3'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/PlacementLevelsRequest.php b/app/Http/Requests/Grading/PlacementLevelsRequest.php
new file mode 100644
index 00000000..bf14daec
--- /dev/null
+++ b/app/Http/Requests/Grading/PlacementLevelsRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PlacementLevelsRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['required', 'integer', 'min:1'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'placement_level' => ['nullable', 'array'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Grading/PlacementRequest.php b/app/Http/Requests/Grading/PlacementRequest.php
new file mode 100644
index 00000000..5bf9ee2a
--- /dev/null
+++ b/app/Http/Requests/Grading/PlacementRequest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Requests\Grading;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PlacementRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['nullable', 'integer', 'min:1'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'placement_test' => ['nullable', 'string', 'max:100'],
+            'open' => ['nullable', 'string', 'max:5'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Incidents/IncidentCancelRequest.php b/app/Http/Requests/Incidents/IncidentCancelRequest.php
new file mode 100644
index 00000000..5ed63c0b
--- /dev/null
+++ b/app/Http/Requests/Incidents/IncidentCancelRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Incidents;
+
+use App\Http\Requests\ApiFormRequest;
+
+class IncidentCancelRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'state_description' => ['nullable', 'string', 'max:2000'],
+            'action_taken' => ['nullable', 'string', 'max:2000'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Incidents/IncidentCloseRequest.php b/app/Http/Requests/Incidents/IncidentCloseRequest.php
new file mode 100644
index 00000000..7f125196
--- /dev/null
+++ b/app/Http/Requests/Incidents/IncidentCloseRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Incidents;
+
+use App\Http\Requests\ApiFormRequest;
+
+class IncidentCloseRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'state_description' => ['required', 'string', 'max:2000'],
+            'action_taken' => ['nullable', 'string', 'max:2000'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Incidents/IncidentListRequest.php b/app/Http/Requests/Incidents/IncidentListRequest.php
new file mode 100644
index 00000000..ecbb71e8
--- /dev/null
+++ b/app/Http/Requests/Incidents/IncidentListRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Incidents;
+
+use App\Http\Requests\ApiFormRequest;
+
+class IncidentListRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['nullable', 'string', 'max:50'],
+            'semester' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Incidents/IncidentStateRequest.php b/app/Http/Requests/Incidents/IncidentStateRequest.php
new file mode 100644
index 00000000..a87fb612
--- /dev/null
+++ b/app/Http/Requests/Incidents/IncidentStateRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Incidents;
+
+use App\Http\Requests\ApiFormRequest;
+
+class IncidentStateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'incident_state' => ['required', 'string', 'in:Open,Closed,Canceled'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Incidents/IncidentStoreRequest.php b/app/Http/Requests/Incidents/IncidentStoreRequest.php
new file mode 100644
index 00000000..b9de4dbb
--- /dev/null
+++ b/app/Http/Requests/Incidents/IncidentStoreRequest.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace App\Http\Requests\Incidents;
+
+use App\Http\Requests\ApiFormRequest;
+
+class IncidentStoreRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        $incidentTypes = [
+            'payment',
+            'attendance',
+            'grade',
+            'behavior',
+            'talking_off_task',
+            'calling_out',
+            'minor_disruption',
+            'minor_dress_code',
+            'forgetting_materials',
+            'repeated_defiance',
+            'disrespectful_tone',
+            'minor_profanity',
+            'repeated_tardiness',
+            'device_misuse',
+            'minor_conflict',
+            'bullying_harassment',
+            'fighting_aggression',
+            'threats',
+            'theft',
+            'vandalism',
+            'sexual_harassment',
+            'serious_cyber_incident',
+            'contraband',
+            'weapons_drugs',
+            'other',
+        ];
+
+        return [
+            'student_id' => ['required', 'integer', 'min:1', 'exists:students,id'],
+            'grade' => ['required', 'string', 'max:50'],
+            'incident' => ['required', 'string', 'in:' . implode(',', $incidentTypes)],
+            'description' => ['required', 'string', 'max:2000'],
+            'incident_state' => ['nullable', 'string', 'in:Open,Closed,Canceled'],
+            'state_description' => ['nullable', 'string', 'max:2000'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Invoices/InvoiceGenerateRequest.php b/app/Http/Requests/Invoices/InvoiceGenerateRequest.php
new file mode 100644
index 00000000..6059932f
--- /dev/null
+++ b/app/Http/Requests/Invoices/InvoiceGenerateRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Invoices;
+
+use App\Http\Requests\ApiFormRequest;
+
+class InvoiceGenerateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'parent_id' => ['required', 'integer', 'exists:users,id'],
+            'school_year' => ['nullable', 'string', 'max:20'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Invoices/InvoiceManagementRequest.php b/app/Http/Requests/Invoices/InvoiceManagementRequest.php
new file mode 100644
index 00000000..4831f86a
--- /dev/null
+++ b/app/Http/Requests/Invoices/InvoiceManagementRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Invoices;
+
+use App\Http\Requests\ApiFormRequest;
+
+class InvoiceManagementRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['nullable', 'string', 'max:20'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Invoices/InvoiceParentRequest.php b/app/Http/Requests/Invoices/InvoiceParentRequest.php
new file mode 100644
index 00000000..988f5a7b
--- /dev/null
+++ b/app/Http/Requests/Invoices/InvoiceParentRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Invoices;
+
+use App\Http\Requests\ApiFormRequest;
+
+class InvoiceParentRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['nullable', 'string', 'max:20'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Invoices/InvoiceStatusRequest.php b/app/Http/Requests/Invoices/InvoiceStatusRequest.php
new file mode 100644
index 00000000..57b4cb84
--- /dev/null
+++ b/app/Http/Requests/Invoices/InvoiceStatusRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Invoices;
+
+use App\Http\Requests\ApiFormRequest;
+
+class InvoiceStatusRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'status' => ['required', 'string', 'in:Unpaid,Partially Paid,Paid,unpaid,partially paid,paid'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentByParentRequest.php b/app/Http/Requests/Payments/PaymentByParentRequest.php
new file mode 100644
index 00000000..dc04c147
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentByParentRequest.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentByParentRequest extends ApiFormRequest
+{
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentCreateRequest.php b/app/Http/Requests/Payments/PaymentCreateRequest.php
new file mode 100644
index 00000000..7988d911
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentCreateRequest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentCreateRequest extends ApiFormRequest
+{
+    public function rules(): array
+    {
+        return [
+            'parent_id' => ['required', 'integer', 'exists:users,id'],
+            'total_amount' => ['required', 'numeric', 'min:0.01'],
+            'number_of_installments' => ['required', 'integer', 'min:1'],
+            'payment_date' => ['nullable', 'date'],
+            'payment_method' => ['nullable', 'string', 'max:50'],
+            'payment_type' => ['nullable', 'string', 'max:50'],
+            'status' => ['nullable', 'string', 'max:50'],
+            'semester' => ['nullable', 'string', 'max:50'],
+            'school_year' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentEventChargesListRequest.php b/app/Http/Requests/Payments/PaymentEventChargesListRequest.php
new file mode 100644
index 00000000..47a7cd17
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentEventChargesListRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentEventChargesListRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['nullable', 'string', 'max:50'],
+            'semester' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentEventChargesStoreRequest.php b/app/Http/Requests/Payments/PaymentEventChargesStoreRequest.php
new file mode 100644
index 00000000..c2ca92af
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentEventChargesStoreRequest.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentEventChargesStoreRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'parent_id' => ['required', 'integer', 'min:1'],
+            'event_name' => ['required', 'string', 'max:255'],
+            'description' => ['nullable', 'string', 'max:1000'],
+            'amount' => ['required', 'numeric', 'min:0'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'student_ids' => ['nullable', 'array'],
+            'student_ids.*' => ['integer', 'min:1'],
+            'student_id' => ['nullable', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentManualEditRequest.php b/app/Http/Requests/Payments/PaymentManualEditRequest.php
new file mode 100644
index 00000000..5332d2a6
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentManualEditRequest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentManualEditRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'paid_amount' => ['required', 'numeric', 'min:0.01'],
+            'payment_method' => ['required', 'string', 'max:50'],
+            'check_number' => ['nullable', 'string', 'max:100'],
+            'payment_file' => ['nullable', 'file', 'mimes:jpg,jpeg,png,pdf', 'max:5120'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentManualSearchRequest.php b/app/Http/Requests/Payments/PaymentManualSearchRequest.php
new file mode 100644
index 00000000..9b25c5aa
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentManualSearchRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentManualSearchRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'search_term' => ['nullable', 'string', 'max:255'],
+            'school_year' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentManualSuggestRequest.php b/app/Http/Requests/Payments/PaymentManualSuggestRequest.php
new file mode 100644
index 00000000..d87af565
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentManualSuggestRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentManualSuggestRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'q' => ['required', 'string', 'max:255'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentManualUpdateRequest.php b/app/Http/Requests/Payments/PaymentManualUpdateRequest.php
new file mode 100644
index 00000000..8f7283a4
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentManualUpdateRequest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentManualUpdateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'amount' => ['required', 'numeric', 'min:0.01'],
+            'payment_method' => ['required', 'string', 'max:50'],
+            'payment_date' => ['nullable', 'date'],
+            'payment_type' => ['nullable', 'string', 'max:50'],
+            'check_number' => ['nullable', 'string', 'max:100'],
+            'payment_file' => ['nullable', 'file', 'mimes:jpg,jpeg,png,pdf', 'max:5120'],
+            'school_year' => ['nullable', 'string', 'max:50'],
+            'semester' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentNotificationListRequest.php b/app/Http/Requests/Payments/PaymentNotificationListRequest.php
new file mode 100644
index 00000000..e63a96d5
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentNotificationListRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentNotificationListRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'from' => ['nullable', 'date'],
+            'to' => ['nullable', 'date'],
+            'type' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentNotificationSendRequest.php b/app/Http/Requests/Payments/PaymentNotificationSendRequest.php
new file mode 100644
index 00000000..cc77ad73
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentNotificationSendRequest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentNotificationSendRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'parent_id' => ['nullable', 'integer', 'min:1'],
+            'type' => ['nullable', 'string', 'max:50'],
+            'force' => ['nullable', 'boolean'],
+            'school_year' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentTransactionCreateRequest.php b/app/Http/Requests/Payments/PaymentTransactionCreateRequest.php
new file mode 100644
index 00000000..3774ffe1
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentTransactionCreateRequest.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentTransactionCreateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'transaction_id' => ['required', 'string', 'max:100'],
+            'payment_id' => ['required', 'integer', 'min:1'],
+            'transaction_date' => ['nullable', 'date'],
+            'amount' => ['required', 'numeric', 'min:0.01'],
+            'payment_method' => ['required', 'string', 'max:50'],
+            'payment_status' => ['nullable', 'string', 'max:50'],
+            'transaction_fee' => ['nullable', 'numeric', 'min:0'],
+            'payment_reference' => ['nullable', 'string', 'max:100'],
+            'is_full_payment' => ['nullable', 'boolean'],
+            'school_year' => ['nullable', 'string', 'max:50'],
+            'semester' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentTransactionStatusRequest.php b/app/Http/Requests/Payments/PaymentTransactionStatusRequest.php
new file mode 100644
index 00000000..116d7946
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentTransactionStatusRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentTransactionStatusRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'status' => ['required', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaymentUpdateBalanceRequest.php b/app/Http/Requests/Payments/PaymentUpdateBalanceRequest.php
new file mode 100644
index 00000000..f7f6e29b
--- /dev/null
+++ b/app/Http/Requests/Payments/PaymentUpdateBalanceRequest.php
@@ -0,0 +1,15 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaymentUpdateBalanceRequest extends ApiFormRequest
+{
+    public function rules(): array
+    {
+        return [
+            'paid_amount' => ['required', 'numeric', 'min:0.01'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaypalExecuteRequest.php b/app/Http/Requests/Payments/PaypalExecuteRequest.php
new file mode 100644
index 00000000..7879bba9
--- /dev/null
+++ b/app/Http/Requests/Payments/PaypalExecuteRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaypalExecuteRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'payer_id' => ['required', 'string', 'max:100'],
+            'paypal_payment_id' => ['nullable', 'string', 'max:100'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Payments/PaypalTransactionsListRequest.php b/app/Http/Requests/Payments/PaypalTransactionsListRequest.php
new file mode 100644
index 00000000..7f7a1dea
--- /dev/null
+++ b/app/Http/Requests/Payments/PaypalTransactionsListRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Payments;
+
+use App\Http\Requests\ApiFormRequest;
+
+class PaypalTransactionsListRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'q' => ['nullable', 'string', 'max:200'],
+            'per_page' => ['nullable', 'integer', 'min:1', 'max:100'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementBatchAdminFileRequest.php b/app/Http/Requests/Reimbursements/ReimbursementBatchAdminFileRequest.php
new file mode 100644
index 00000000..292b87f5
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementBatchAdminFileRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementBatchAdminFileRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'batch_id' => ['required', 'integer', 'min:1'],
+            'admin_id' => ['required', 'integer', 'min:0'],
+            'check_file' => ['required', 'file', 'max:5120', 'mimes:jpg,jpeg,png,webp,gif,pdf'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementBatchAssignmentRequest.php b/app/Http/Requests/Reimbursements/ReimbursementBatchAssignmentRequest.php
new file mode 100644
index 00000000..39af028a
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementBatchAssignmentRequest.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementBatchAssignmentRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'expense_id' => ['required', 'integer', 'min:1'],
+            'batch_id' => ['nullable', 'integer', 'min:0'],
+            'batch_number' => ['nullable', 'integer', 'min:0'],
+            'admin_id' => ['nullable', 'integer', 'min:0'],
+            'reimbursement_id' => ['nullable', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementBatchCreateRequest.php b/app/Http/Requests/Reimbursements/ReimbursementBatchCreateRequest.php
new file mode 100644
index 00000000..082c8c06
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementBatchCreateRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementBatchCreateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'title' => ['nullable', 'string', 'max:255'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementBatchEmailRequest.php b/app/Http/Requests/Reimbursements/ReimbursementBatchEmailRequest.php
new file mode 100644
index 00000000..afff7739
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementBatchEmailRequest.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementBatchEmailRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'batch_id' => ['required', 'integer', 'min:1'],
+            'recipient_email' => ['required', 'email'],
+            'message' => ['nullable', 'string'],
+            'receipts' => ['nullable', 'array'],
+            'receipts.*' => ['integer', 'min:1'],
+            'checks' => ['nullable', 'array'],
+            'checks.*' => ['integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementBatchLockRequest.php b/app/Http/Requests/Reimbursements/ReimbursementBatchLockRequest.php
new file mode 100644
index 00000000..7f26eb24
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementBatchLockRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementBatchLockRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'batch_id' => ['required', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementExportBatchRequest.php b/app/Http/Requests/Reimbursements/ReimbursementExportBatchRequest.php
new file mode 100644
index 00000000..10e3e5f4
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementExportBatchRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementExportBatchRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'batch_id' => ['required', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementExportRequest.php b/app/Http/Requests/Reimbursements/ReimbursementExportRequest.php
new file mode 100644
index 00000000..2f6523cf
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementExportRequest.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementExportRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'type' => ['nullable', 'in:processed,under_processing'],
+            'school_year' => ['nullable', 'string', 'max:20'],
+            'semester' => ['nullable', 'string', 'max:20'],
+            'status' => ['nullable', 'string', 'max:50'],
+            'user_id' => ['nullable', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementIndexRequest.php b/app/Http/Requests/Reimbursements/ReimbursementIndexRequest.php
new file mode 100644
index 00000000..6d99a380
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementIndexRequest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementIndexRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['nullable', 'string', 'max:20'],
+            'semester' => ['nullable', 'string', 'max:20'],
+            'status' => ['nullable', 'string', 'max:50'],
+            'user_id' => ['nullable', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementMarkDonationRequest.php b/app/Http/Requests/Reimbursements/ReimbursementMarkDonationRequest.php
new file mode 100644
index 00000000..9c819910
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementMarkDonationRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementMarkDonationRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'expense_id' => ['required', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementProcessRequest.php b/app/Http/Requests/Reimbursements/ReimbursementProcessRequest.php
new file mode 100644
index 00000000..33a0f11c
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementProcessRequest.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementProcessRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'amount' => ['required', 'numeric', 'gt:0'],
+            'reimbursed_to' => ['required', 'integer', 'min:1'],
+            'reimbursement_method' => ['required', 'in:Cash,Check'],
+            'check_number' => ['required_if:reimbursement_method,Check', 'nullable', 'string', 'max:50'],
+            'receipt' => ['nullable', 'file', 'max:2048', 'mimes:jpg,jpeg,png,webp,gif,pdf'],
+            'expense_id' => ['nullable', 'integer', 'min:1'],
+            'description' => ['nullable', 'string'],
+            'school_year' => ['nullable', 'string', 'max:20'],
+            'semester' => ['nullable', 'string', 'max:20'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementStoreRequest.php b/app/Http/Requests/Reimbursements/ReimbursementStoreRequest.php
new file mode 100644
index 00000000..83423544
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementStoreRequest.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementStoreRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'amount' => ['required', 'numeric', 'gt:0'],
+            'reimbursed_to' => ['required', 'integer', 'min:1'],
+            'reimbursement_method' => ['required', 'in:Cash,Check'],
+            'check_number' => ['required_if:reimbursement_method,Check', 'nullable', 'string', 'max:50'],
+            'receipt' => ['required_if:reimbursement_method,Check', 'nullable', 'file', 'max:2048', 'mimes:jpg,jpeg,png,webp,gif,pdf'],
+            'expense_id' => ['nullable', 'integer', 'min:1'],
+            'description' => ['nullable', 'string'],
+            'school_year' => ['nullable', 'string', 'max:20'],
+            'semester' => ['nullable', 'string', 'max:20'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementUnderProcessingRequest.php b/app/Http/Requests/Reimbursements/ReimbursementUnderProcessingRequest.php
new file mode 100644
index 00000000..e4343265
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementUnderProcessingRequest.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementUnderProcessingRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [];
+    }
+}
diff --git a/app/Http/Requests/Reimbursements/ReimbursementUpdateRequest.php b/app/Http/Requests/Reimbursements/ReimbursementUpdateRequest.php
new file mode 100644
index 00000000..cedd7ce5
--- /dev/null
+++ b/app/Http/Requests/Reimbursements/ReimbursementUpdateRequest.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Http\Requests\Reimbursements;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ReimbursementUpdateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'amount' => ['required', 'numeric', 'gt:0'],
+            'reimbursed_to' => ['required', 'integer', 'min:1'],
+            'reimbursement_method' => ['required', 'in:Cash,Check'],
+            'check_number' => ['required_if:reimbursement_method,Check', 'nullable', 'string', 'max:50'],
+            'receipt' => ['nullable', 'file', 'max:2048', 'mimes:jpg,jpeg,png,webp,gif,pdf'],
+            'remove_receipt' => ['nullable', 'boolean'],
+            'description' => ['nullable', 'string'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Scores/ScoreAddColumnRequest.php b/app/Http/Requests/Scores/ScoreAddColumnRequest.php
new file mode 100644
index 00000000..68b01ba3
--- /dev/null
+++ b/app/Http/Requests/Scores/ScoreAddColumnRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Scores;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ScoreAddColumnRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Scores/ScoreClassRequest.php b/app/Http/Requests/Scores/ScoreClassRequest.php
new file mode 100644
index 00000000..27aba95e
--- /dev/null
+++ b/app/Http/Requests/Scores/ScoreClassRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Scores;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ScoreClassRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['nullable', 'string', 'max:50'],
+            'school_year' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Scores/ScoreCommentListRequest.php b/app/Http/Requests/Scores/ScoreCommentListRequest.php
new file mode 100644
index 00000000..44860acb
--- /dev/null
+++ b/app/Http/Requests/Scores/ScoreCommentListRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Scores;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ScoreCommentListRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['nullable'],
+            'semester' => ['nullable', 'string', 'max:50'],
+            'school_year' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Scores/ScoreCommentSaveRequest.php b/app/Http/Requests/Scores/ScoreCommentSaveRequest.php
new file mode 100644
index 00000000..7ca48fe0
--- /dev/null
+++ b/app/Http/Requests/Scores/ScoreCommentSaveRequest.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Requests\Scores;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ScoreCommentSaveRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'comments' => ['required', 'array'],
+            'missing_ok' => ['nullable', 'array'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Scores/ScoreCommentUpdateRequest.php b/app/Http/Requests/Scores/ScoreCommentUpdateRequest.php
new file mode 100644
index 00000000..558cbe04
--- /dev/null
+++ b/app/Http/Requests/Scores/ScoreCommentUpdateRequest.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Requests\Scores;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ScoreCommentUpdateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'comments' => ['nullable', 'array'],
+            'reviews' => ['nullable', 'array'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Scores/ScoreLockRequest.php b/app/Http/Requests/Scores/ScoreLockRequest.php
new file mode 100644
index 00000000..c576943a
--- /dev/null
+++ b/app/Http/Requests/Scores/ScoreLockRequest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Requests\Scores;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ScoreLockRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'missing_ok' => ['nullable', 'array'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Scores/ScoreOverviewRequest.php b/app/Http/Requests/Scores/ScoreOverviewRequest.php
new file mode 100644
index 00000000..969200a0
--- /dev/null
+++ b/app/Http/Requests/Scores/ScoreOverviewRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Scores;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ScoreOverviewRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['nullable', 'integer', 'min:1'],
+            'semester' => ['nullable', 'string', 'max:50'],
+            'school_year' => ['nullable', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Scores/ScorePredictorRequest.php b/app/Http/Requests/Scores/ScorePredictorRequest.php
new file mode 100644
index 00000000..aa0b3127
--- /dev/null
+++ b/app/Http/Requests/Scores/ScorePredictorRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Scores;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ScorePredictorRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['nullable', 'string', 'max:50'],
+            'class_section_id' => ['nullable', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Scores/ScoreStudentRequest.php b/app/Http/Requests/Scores/ScoreStudentRequest.php
new file mode 100644
index 00000000..fbf6264a
--- /dev/null
+++ b/app/Http/Requests/Scores/ScoreStudentRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Scores;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ScoreStudentRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['required', 'string', 'max:50'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Scores/ScoreUpdateRequest.php b/app/Http/Requests/Scores/ScoreUpdateRequest.php
new file mode 100644
index 00000000..944e0a31
--- /dev/null
+++ b/app/Http/Requests/Scores/ScoreUpdateRequest.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Requests\Scores;
+
+use App\Http\Requests\ApiFormRequest;
+
+class ScoreUpdateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'class_section_id' => ['required', 'integer', 'min:1'],
+            'semester' => ['required', 'string', 'max:50'],
+            'school_year' => ['required', 'string', 'max:50'],
+            'scores' => ['required', 'array'],
+            'missing_ok' => ['nullable', 'array'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Semesters/SchoolYearRangeRequest.php b/app/Http/Requests/Semesters/SchoolYearRangeRequest.php
new file mode 100644
index 00000000..7519d1ad
--- /dev/null
+++ b/app/Http/Requests/Semesters/SchoolYearRangeRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Semesters;
+
+use App\Http\Requests\ApiFormRequest;
+
+class SchoolYearRangeRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['required', 'string', 'regex:/^\\d{4}-\\d{4}$/'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Semesters/SemesterNormalizeRequest.php b/app/Http/Requests/Semesters/SemesterNormalizeRequest.php
new file mode 100644
index 00000000..26ad860c
--- /dev/null
+++ b/app/Http/Requests/Semesters/SemesterNormalizeRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Semesters;
+
+use App\Http\Requests\ApiFormRequest;
+
+class SemesterNormalizeRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'semester' => ['required', 'string', 'max:20'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Semesters/SemesterRangeRequest.php b/app/Http/Requests/Semesters/SemesterRangeRequest.php
new file mode 100644
index 00000000..098eb8aa
--- /dev/null
+++ b/app/Http/Requests/Semesters/SemesterRangeRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Semesters;
+
+use App\Http\Requests\ApiFormRequest;
+
+class SemesterRangeRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'school_year' => ['required', 'string', 'regex:/^\\d{4}-\\d{4}$/'],
+            'semester' => ['required', 'string', 'in:Fall,Spring,fall,spring'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Semesters/SemesterResolveRequest.php b/app/Http/Requests/Semesters/SemesterResolveRequest.php
new file mode 100644
index 00000000..18eaade8
--- /dev/null
+++ b/app/Http/Requests/Semesters/SemesterResolveRequest.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Requests\Semesters;
+
+use App\Http\Requests\ApiFormRequest;
+
+class SemesterResolveRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'date' => ['nullable', 'date'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Users/LoginActivityRequest.php b/app/Http/Requests/Users/LoginActivityRequest.php
new file mode 100644
index 00000000..0f0aa6a9
--- /dev/null
+++ b/app/Http/Requests/Users/LoginActivityRequest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Requests\Users;
+
+use App\Http\Requests\ApiFormRequest;
+
+class LoginActivityRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'per_page' => ['nullable', 'integer', 'min:1', 'max:200'],
+            'page' => ['nullable', 'integer', 'min:1'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Users/UserListRequest.php b/app/Http/Requests/Users/UserListRequest.php
new file mode 100644
index 00000000..83138bc1
--- /dev/null
+++ b/app/Http/Requests/Users/UserListRequest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Requests\Users;
+
+use App\Http\Requests\ApiFormRequest;
+use Illuminate\Validation\Rule;
+
+class UserListRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'sort' => ['nullable', 'string', Rule::in(['id', 'firstname', 'lastname', 'email', 'status', 'updated_at'])],
+            'order' => ['nullable', 'string', Rule::in(['asc', 'desc'])],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Users/UserStoreRequest.php b/app/Http/Requests/Users/UserStoreRequest.php
new file mode 100644
index 00000000..71e8339d
--- /dev/null
+++ b/app/Http/Requests/Users/UserStoreRequest.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Http\Requests\Users;
+
+use App\Http\Requests\ApiFormRequest;
+use Illuminate\Validation\Rule;
+
+class UserStoreRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        return [
+            'firstname' => ['required', 'string', 'max:255'],
+            'lastname' => ['required', 'string', 'max:255'],
+            'gender' => ['nullable', 'string', Rule::in(['Male', 'Female', 'male', 'female', 'MALE', 'FEMALE'])],
+            'cellphone' => ['required', 'string', 'max:25'],
+            'email' => ['required', 'email', 'max:255', 'unique:users,email'],
+            'address_street' => ['required', 'string', 'max:255'],
+            'apt' => ['nullable', 'string', 'max:25'],
+            'city' => ['required', 'string', 'max:255'],
+            'state' => ['required', 'string', 'max:25'],
+            'zip' => ['required', 'string', 'max:25'],
+            'accept_school_policy' => ['required', 'boolean'],
+            'role_id' => ['required', 'integer', 'exists:roles,id'],
+            'password' => ['required', 'string', 'min:6'],
+            'semester' => ['required', 'string', 'max:255'],
+            'school_year' => ['nullable', 'string', 'max:9'],
+            'school_id' => ['nullable', 'integer'],
+            'user_type' => ['nullable', 'string', Rule::in(['primary', 'secondary', 'tertiary'])],
+            'rfid_tag' => ['nullable', 'string', 'max:100'],
+            'status' => ['nullable', 'string', Rule::in(['Active', 'Inactive'])],
+            'is_verified' => ['nullable', 'boolean'],
+            'is_suspended' => ['nullable', 'boolean'],
+            'failed_attempts' => ['nullable', 'integer'],
+            'last_failed_at' => ['nullable', 'date'],
+            'token' => ['nullable', 'string', 'max:255'],
+            'account_id' => ['nullable', 'string', 'max:255'],
+        ];
+    }
+}
diff --git a/app/Http/Requests/Users/UserUpdateRequest.php b/app/Http/Requests/Users/UserUpdateRequest.php
new file mode 100644
index 00000000..0fb48c0f
--- /dev/null
+++ b/app/Http/Requests/Users/UserUpdateRequest.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Http\Requests\Users;
+
+use App\Http\Requests\ApiFormRequest;
+use Illuminate\Validation\Rule;
+
+class UserUpdateRequest extends ApiFormRequest
+{
+    public function authorize(): bool
+    {
+        return true;
+    }
+
+    public function rules(): array
+    {
+        $userId = (int) ($this->route('userId') ?? 0);
+
+        return [
+            'firstname' => ['sometimes', 'string', 'max:255'],
+            'lastname' => ['sometimes', 'string', 'max:255'],
+            'gender' => ['sometimes', 'nullable', 'string', Rule::in(['Male', 'Female', 'male', 'female', 'MALE', 'FEMALE'])],
+            'cellphone' => ['sometimes', 'string', 'max:25'],
+            'email' => ['sometimes', 'email', 'max:255', Rule::unique('users', 'email')->ignore($userId)],
+            'address_street' => ['sometimes', 'string', 'max:255'],
+            'apt' => ['sometimes', 'nullable', 'string', 'max:25'],
+            'city' => ['sometimes', 'string', 'max:255'],
+            'state' => ['sometimes', 'string', 'max:25'],
+            'zip' => ['sometimes', 'string', 'max:25'],
+            'accept_school_policy' => ['sometimes', 'boolean'],
+            'semester' => ['sometimes', 'string', 'max:255'],
+            'school_year' => ['sometimes', 'nullable', 'string', 'max:9'],
+            'school_id' => ['sometimes', 'nullable', 'integer'],
+            'user_type' => ['sometimes', 'nullable', 'string', Rule::in(['primary', 'secondary', 'tertiary'])],
+            'rfid_tag' => ['sometimes', 'nullable', 'string', 'max:100'],
+            'status' => ['sometimes', 'string', Rule::in(['Active', 'Inactive'])],
+            'is_verified' => ['sometimes', 'boolean'],
+            'is_suspended' => ['sometimes', 'boolean'],
+            'failed_attempts' => ['sometimes', 'nullable', 'integer'],
+            'last_failed_at' => ['sometimes', 'nullable', 'date'],
+            'token' => ['sometimes', 'nullable', 'string', 'max:255'],
+            'account_id' => ['sometimes', 'nullable', 'string', 'max:255'],
+        ];
+    }
+}
diff --git a/app/Http/Resources/Auth/RegisterResource.php b/app/Http/Resources/Auth/RegisterResource.php
new file mode 100644
index 00000000..8ea04cc4
--- /dev/null
+++ b/app/Http/Resources/Auth/RegisterResource.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Http\Resources\Auth;
+
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class RegisterResource extends JsonResource
+{
+    public function toArray($request): array
+    {
+        $user = $this->resource['user'] ?? null;
+
+        return [
+            'user_id' => $user?->id,
+            'email' => $user?->email,
+            'firstname' => $user?->firstname,
+            'lastname' => $user?->lastname,
+            'role' => $this->resource['role'] ?? null,
+            'activation_sent' => (bool) ($this->resource['activation_sent'] ?? false),
+        ];
+    }
+}
diff --git a/app/Http/Resources/Discounts/DiscountParentResource.php b/app/Http/Resources/Discounts/DiscountParentResource.php
new file mode 100644
index 00000000..b88fd7f5
--- /dev/null
+++ b/app/Http/Resources/Discounts/DiscountParentResource.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Resources\Discounts;
+
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class DiscountParentResource extends JsonResource
+{
+    public function toArray($request): array
+    {
+        return [
+            'id' => $this['id'] ?? null,
+            'firstname' => $this['firstname'] ?? '',
+            'lastname' => $this['lastname'] ?? '',
+            'email' => $this['email'] ?? '',
+            'total_discount' => (float) ($this['total_discount'] ?? 0),
+            'has_discount' => (int) ($this['has_discount'] ?? 0),
+        ];
+    }
+}
diff --git a/app/Http/Resources/Discounts/DiscountVoucherResource.php b/app/Http/Resources/Discounts/DiscountVoucherResource.php
new file mode 100644
index 00000000..33262b1e
--- /dev/null
+++ b/app/Http/Resources/Discounts/DiscountVoucherResource.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Http\Resources\Discounts;
+
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class DiscountVoucherResource extends JsonResource
+{
+    public function toArray($request): array
+    {
+        return [
+            'id' => $this->id,
+            'code' => $this->code,
+            'discount_type' => $this->discount_type,
+            'discount_value' => $this->discount_value,
+            'max_uses' => $this->max_uses,
+            'times_used' => $this->times_used,
+            'valid_from' => $this->valid_from,
+            'valid_until' => $this->valid_until,
+            'is_active' => (bool) $this->is_active,
+            'description' => $this->description,
+            'school_year' => $this->school_year,
+            'semester' => $this->semester,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Expenses/ExpenseResource.php b/app/Http/Resources/Expenses/ExpenseResource.php
new file mode 100644
index 00000000..5fd63293
--- /dev/null
+++ b/app/Http/Resources/Expenses/ExpenseResource.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Http\Resources\Expenses;
+
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ExpenseResource extends JsonResource
+{
+    public function toArray($request): array
+    {
+        return [
+            'id' => $this['id'] ?? $this->id,
+            'category' => $this['category'] ?? $this->category,
+            'amount' => $this['amount'] ?? $this->amount,
+            'receipt_path' => $this['receipt_path'] ?? $this->receipt_path,
+            'receipt_url' => $this['receipt_url'] ?? null,
+            'description' => $this['description'] ?? $this->description,
+            'retailor' => $this['retailor'] ?? $this->retailor,
+            'date_of_purchase' => $this['date_of_purchase'] ?? $this->date_of_purchase,
+            'purchased_by' => $this['purchased_by'] ?? $this->purchased_by,
+            'added_by' => $this['added_by'] ?? $this->added_by,
+            'school_year' => $this['school_year'] ?? $this->school_year,
+            'semester' => $this['semester'] ?? $this->semester,
+            'status' => $this['status'] ?? $this->status,
+            'status_reason' => $this['status_reason'] ?? $this->status_reason,
+            'approved_by' => $this['approved_by'] ?? $this->approved_by,
+            'updated_by' => $this['updated_by'] ?? $this->updated_by,
+            'purchaser_firstname' => $this['purchaser_firstname'] ?? null,
+            'purchaser_lastname' => $this['purchaser_lastname'] ?? null,
+            'approver_firstname' => $this['approver_firstname'] ?? null,
+            'approver_lastname' => $this['approver_lastname'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Expenses/ExpenseStaffResource.php b/app/Http/Resources/Expenses/ExpenseStaffResource.php
new file mode 100644
index 00000000..18a63838
--- /dev/null
+++ b/app/Http/Resources/Expenses/ExpenseStaffResource.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Resources\Expenses;
+
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ExpenseStaffResource extends JsonResource
+{
+    public function toArray($request): array
+    {
+        return [
+            'id' => $this['id'] ?? null,
+            'firstname' => $this['firstname'] ?? '',
+            'lastname' => $this['lastname'] ?? '',
+        ];
+    }
+}
diff --git a/app/Http/Resources/ExtraCharges/ExtraChargeInvoiceOptionResource.php b/app/Http/Resources/ExtraCharges/ExtraChargeInvoiceOptionResource.php
new file mode 100644
index 00000000..c976eea4
--- /dev/null
+++ b/app/Http/Resources/ExtraCharges/ExtraChargeInvoiceOptionResource.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Resources\ExtraCharges;
+
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ExtraChargeInvoiceOptionResource extends JsonResource
+{
+    public function toArray($request): array
+    {
+        return [
+            'id' => $this['id'] ?? null,
+            'invoice_number' => $this['invoice_number'] ?? '',
+            'status' => $this['status'] ?? '',
+            'balance' => $this['balance'] ?? 0,
+            'issue_date' => $this['issue_date'] ?? null,
+            'text' => $this['text'] ?? '',
+        ];
+    }
+}
diff --git a/app/Http/Resources/ExtraCharges/ExtraChargeParentOptionResource.php b/app/Http/Resources/ExtraCharges/ExtraChargeParentOptionResource.php
new file mode 100644
index 00000000..c88bd5a1
--- /dev/null
+++ b/app/Http/Resources/ExtraCharges/ExtraChargeParentOptionResource.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Http\Resources\ExtraCharges;
+
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ExtraChargeParentOptionResource extends JsonResource
+{
+    public function toArray($request): array
+    {
+        return [
+            'id' => $this['id'] ?? null,
+            'text' => $this['text'] ?? '',
+        ];
+    }
+}
diff --git a/app/Http/Resources/ExtraCharges/ExtraChargeResource.php b/app/Http/Resources/ExtraCharges/ExtraChargeResource.php
new file mode 100644
index 00000000..2904b146
--- /dev/null
+++ b/app/Http/Resources/ExtraCharges/ExtraChargeResource.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Http\Resources\ExtraCharges;
+
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ExtraChargeResource extends JsonResource
+{
+    public function toArray($request): array
+    {
+        $data = is_array($this->resource) ? $this->resource : $this->resource->toArray();
+
+        return [
+            'id' => (int) ($data['id'] ?? 0),
+            'parent_id' => $data['parent_id'] ?? null,
+            'invoice_id' => $data['invoice_id'] ?? null,
+            'school_year' => $data['school_year'] ?? null,
+            'semester' => $data['semester'] ?? null,
+            'charge_type' => $data['charge_type'] ?? null,
+            'title' => $data['title'] ?? null,
+            'description' => $data['description'] ?? null,
+            'amount' => $data['amount'] ?? null,
+            'due_date' => $data['due_date'] ?? null,
+            'status' => $data['status'] ?? null,
+            'created_by' => $data['created_by'] ?? null,
+            'created_at' => $data['created_at'] ?? null,
+            'parent_name' => $data['parent_name'] ?? null,
+            'invoice_number' => $data['invoice_number'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Files/FileMetaResource.php b/app/Http/Resources/Files/FileMetaResource.php
new file mode 100644
index 00000000..490ace4e
--- /dev/null
+++ b/app/Http/Resources/Files/FileMetaResource.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Resources\Files;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FileMetaResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'name' => $this->resource['name'] ?? null,
+            'mime' => $this->resource['mime'] ?? null,
+            'size' => $this->resource['size'] ?? null,
+            'etag' => $this->resource['etag'] ?? null,
+            'last_modified' => $this->resource['last_modified'] ?? null,
+            'download_name' => $this->resource['download_name'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Finance/FinancialDiscountResource.php b/app/Http/Resources/Finance/FinancialDiscountResource.php
new file mode 100644
index 00000000..c9dba25d
--- /dev/null
+++ b/app/Http/Resources/Finance/FinancialDiscountResource.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Http\Resources\Finance;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FinancialDiscountResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'invoice_id' => (int) ($this->resource['invoice_id'] ?? 0),
+            'school_year' => $this->resource['school_year'] ?? null,
+            'discount_amount' => (float) ($this->resource['discount_amount'] ?? 0),
+        ];
+    }
+}
diff --git a/app/Http/Resources/Finance/FinancialExpenseSummaryResource.php b/app/Http/Resources/Finance/FinancialExpenseSummaryResource.php
new file mode 100644
index 00000000..89fd078a
--- /dev/null
+++ b/app/Http/Resources/Finance/FinancialExpenseSummaryResource.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Resources\Finance;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FinancialExpenseSummaryResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'category' => $this->resource['category'] ?? null,
+            'total_amount' => (float) ($this->resource['total_amount'] ?? 0),
+        ];
+    }
+}
diff --git a/app/Http/Resources/Finance/FinancialInvoiceResource.php b/app/Http/Resources/Finance/FinancialInvoiceResource.php
new file mode 100644
index 00000000..472f0075
--- /dev/null
+++ b/app/Http/Resources/Finance/FinancialInvoiceResource.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Http\Resources\Finance;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FinancialInvoiceResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => (int) ($this->resource['id'] ?? 0),
+            'invoice_number' => $this->resource['invoice_number'] ?? null,
+            'parent_id' => (int) ($this->resource['parent_id'] ?? 0),
+            'parent_name' => $this->resource['parent_name'] ?? null,
+            'school_year' => $this->resource['school_year'] ?? null,
+            'total_amount' => (float) ($this->resource['total_amount'] ?? 0),
+            'paid_amount' => (float) ($this->resource['paid_amount'] ?? 0),
+            'balance' => (float) ($this->resource['balance'] ?? 0),
+            'status' => $this->resource['status'] ?? null,
+            'issue_date' => $this->resource['issue_date'] ?? null,
+            'due_date' => $this->resource['due_date'] ?? null,
+            'created_at' => $this->resource['created_at'] ?? null,
+            'updated_at' => $this->resource['updated_at'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Finance/FinancialPaymentResource.php b/app/Http/Resources/Finance/FinancialPaymentResource.php
new file mode 100644
index 00000000..9e712c0b
--- /dev/null
+++ b/app/Http/Resources/Finance/FinancialPaymentResource.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Resources\Finance;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FinancialPaymentResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'invoice_id' => (int) ($this->resource['invoice_id'] ?? 0),
+            'paid_amount' => (float) ($this->resource['paid_amount'] ?? 0),
+        ];
+    }
+}
diff --git a/app/Http/Resources/Finance/FinancialRefundResource.php b/app/Http/Resources/Finance/FinancialRefundResource.php
new file mode 100644
index 00000000..eab06035
--- /dev/null
+++ b/app/Http/Resources/Finance/FinancialRefundResource.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Http\Resources\Finance;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FinancialRefundResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'invoice_id' => (int) ($this->resource['invoice_id'] ?? 0),
+            'school_year' => $this->resource['school_year'] ?? null,
+            'total_refunded' => (float) ($this->resource['total_refunded'] ?? 0),
+        ];
+    }
+}
diff --git a/app/Http/Resources/Finance/FinancialReimbursementSummaryResource.php b/app/Http/Resources/Finance/FinancialReimbursementSummaryResource.php
new file mode 100644
index 00000000..f883ff02
--- /dev/null
+++ b/app/Http/Resources/Finance/FinancialReimbursementSummaryResource.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Resources\Finance;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FinancialReimbursementSummaryResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'status' => $this->resource['status'] ?? null,
+            'total_amount' => (float) ($this->resource['total_amount'] ?? 0),
+        ];
+    }
+}
diff --git a/app/Http/Resources/Finance/FinancialReportResource.php b/app/Http/Resources/Finance/FinancialReportResource.php
new file mode 100644
index 00000000..c0f68f64
--- /dev/null
+++ b/app/Http/Resources/Finance/FinancialReportResource.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Http\Resources\Finance;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FinancialReportResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'selectedYear' => $this->resource['selectedYear'] ?? null,
+            'dateFrom' => $this->resource['dateFrom'] ?? null,
+            'dateTo' => $this->resource['dateTo'] ?? null,
+            'schoolYears' => $this->resource['schoolYears'] ?? [],
+            'invoices' => FinancialInvoiceResource::collection($this->resource['invoices'] ?? []),
+            'payments' => FinancialPaymentResource::collection($this->resource['payments'] ?? []),
+            'paymentBreakdown' => $this->resource['paymentBreakdown'] ?? [],
+            'paymentTotals' => $this->resource['paymentTotals'] ?? [],
+            'refunds' => FinancialRefundResource::collection($this->resource['refunds'] ?? []),
+            'expenses' => FinancialExpenseSummaryResource::collection($this->resource['expenses'] ?? []),
+            'reimbursements' => FinancialReimbursementSummaryResource::collection($this->resource['reimbursements'] ?? []),
+            'discounts' => FinancialDiscountResource::collection($this->resource['discounts'] ?? []),
+        ];
+    }
+}
diff --git a/app/Http/Resources/Finance/FinancialSummaryResource.php b/app/Http/Resources/Finance/FinancialSummaryResource.php
new file mode 100644
index 00000000..837b8fd0
--- /dev/null
+++ b/app/Http/Resources/Finance/FinancialSummaryResource.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace App\Http\Resources\Finance;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FinancialSummaryResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'schoolYear' => $this->resource['schoolYear'] ?? null,
+            'dateFrom' => $this->resource['dateFrom'] ?? null,
+            'dateTo' => $this->resource['dateTo'] ?? null,
+            'totalCharges' => (float) ($this->resource['totalCharges'] ?? 0),
+            'totalExtraCharges' => (float) ($this->resource['totalExtraCharges'] ?? 0),
+            'totalDiscounts' => (float) ($this->resource['totalDiscounts'] ?? 0),
+            'totalRefunds' => (float) ($this->resource['totalRefunds'] ?? 0),
+            'totalExpenses' => (float) ($this->resource['totalExpenses'] ?? 0),
+            'totalReimbursements' => (float) ($this->resource['totalReimbursements'] ?? 0),
+            'donationToSchool' => (float) ($this->resource['donationToSchool'] ?? 0),
+            'totalPaid' => (float) ($this->resource['totalPaid'] ?? 0),
+            'amountCollected' => (float) ($this->resource['amountCollected'] ?? 0),
+            'totalUnpaid' => (float) ($this->resource['totalUnpaid'] ?? 0),
+            'netAmount' => (float) ($this->resource['netAmount'] ?? 0),
+        ];
+    }
+}
diff --git a/app/Http/Resources/Finance/FinancialUnpaidParentResource.php b/app/Http/Resources/Finance/FinancialUnpaidParentResource.php
new file mode 100644
index 00000000..1ec1dc7f
--- /dev/null
+++ b/app/Http/Resources/Finance/FinancialUnpaidParentResource.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Http\Resources\Finance;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class FinancialUnpaidParentResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'parent_id' => (int) ($this->resource['parent_id'] ?? 0),
+            'parent_name' => $this->resource['parent_name'] ?? null,
+            'email' => $this->resource['email'] ?? null,
+            'total_invoice' => (float) ($this->resource['total_invoice'] ?? 0),
+            'total_balance' => (float) ($this->resource['total_balance'] ?? 0),
+            'total_discount' => (float) ($this->resource['total_discount'] ?? 0),
+            'remaining_installments' => (int) ($this->resource['remaining_installments'] ?? 0),
+            'installment_amount' => (float) ($this->resource['installment_amount'] ?? 0),
+            'type' => $this->resource['type'] ?? null,
+            'total_paid' => (float) ($this->resource['total_paid'] ?? 0),
+            'payment_count' => (int) ($this->resource['payment_count'] ?? 0),
+            'has_installment' => (int) ($this->resource['has_installment'] ?? 0),
+            'next_installment' => $this->resource['next_installment'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Grading/BelowSixtyStudentResource.php b/app/Http/Resources/Grading/BelowSixtyStudentResource.php
new file mode 100644
index 00000000..a0a02ae0
--- /dev/null
+++ b/app/Http/Resources/Grading/BelowSixtyStudentResource.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Http\Resources\Grading;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class BelowSixtyStudentResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'student_id' => (int) ($this->resource['student_id'] ?? 0),
+            'school_id' => $this->resource['school_id'] ?? null,
+            'firstname' => $this->resource['firstname'] ?? null,
+            'lastname' => $this->resource['lastname'] ?? null,
+            'class_section_name' => $this->resource['class_section_name'] ?? null,
+            'homework_avg' => $this->resource['homework_avg'] ?? null,
+            'project_avg' => $this->resource['project_avg'] ?? null,
+            'participation_score' => $this->resource['participation_score'] ?? null,
+            'test_avg' => $this->resource['test_avg'] ?? null,
+            'ptap_score' => $this->resource['ptap_score'] ?? null,
+            'attendance_score' => $this->resource['attendance_score'] ?? null,
+            'midterm_exam_score' => $this->resource['midterm_exam_score'] ?? null,
+            'final_exam_score' => $this->resource['final_exam_score'] ?? null,
+            'semester_score' => $this->resource['semester_score'] ?? null,
+            'comment' => $this->resource['comment'] ?? null,
+            'status' => $this->resource['status'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Grading/GradingScoreResource.php b/app/Http/Resources/Grading/GradingScoreResource.php
new file mode 100644
index 00000000..59d22921
--- /dev/null
+++ b/app/Http/Resources/Grading/GradingScoreResource.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace App\Http\Resources\Grading;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class GradingScoreResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return $this->resource->toArray();
+    }
+}
diff --git a/app/Http/Resources/Grading/HomeworkTrackingTeacherResource.php b/app/Http/Resources/Grading/HomeworkTrackingTeacherResource.php
new file mode 100644
index 00000000..8ebd4f51
--- /dev/null
+++ b/app/Http/Resources/Grading/HomeworkTrackingTeacherResource.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Resources\Grading;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class HomeworkTrackingTeacherResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'class_section_id' => (int) ($this->resource['class_section_id'] ?? 0),
+            'class_id' => $this->resource['class_id'] ?? null,
+            'class_section_name' => $this->resource['class_section_name'] ?? null,
+            'teachers' => $this->resource['teachers'] ?? [],
+            'tas' => $this->resource['tas'] ?? [],
+        ];
+    }
+}
diff --git a/app/Http/Resources/Incidents/IncidentAnalysisStudentResource.php b/app/Http/Resources/Incidents/IncidentAnalysisStudentResource.php
new file mode 100644
index 00000000..9e81270c
--- /dev/null
+++ b/app/Http/Resources/Incidents/IncidentAnalysisStudentResource.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Resources\Incidents;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class IncidentAnalysisStudentResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'student_id' => $this->resource['student_id'] ?? null,
+            'student_name' => $this->resource['student_name'] ?? null,
+            'grade' => $this->resource['grade'] ?? null,
+            'total' => (int) ($this->resource['total'] ?? 0),
+            'open' => (int) ($this->resource['open'] ?? 0),
+            'closed' => (int) ($this->resource['closed'] ?? 0),
+            'canceled' => (int) ($this->resource['canceled'] ?? 0),
+            'last_incident' => $this->resource['last_incident'] ?? null,
+            'logs' => $this->resource['logs'] ?? [],
+        ];
+    }
+}
diff --git a/app/Http/Resources/Incidents/IncidentGradeResource.php b/app/Http/Resources/Incidents/IncidentGradeResource.php
new file mode 100644
index 00000000..71d47e86
--- /dev/null
+++ b/app/Http/Resources/Incidents/IncidentGradeResource.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Resources\Incidents;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class IncidentGradeResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->resource['id'] ?? null,
+            'name' => $this->resource['name'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Incidents/IncidentResource.php b/app/Http/Resources/Incidents/IncidentResource.php
new file mode 100644
index 00000000..0b9d64a7
--- /dev/null
+++ b/app/Http/Resources/Incidents/IncidentResource.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Http\Resources\Incidents;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class IncidentResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => $this->resource['id'] ?? null,
+            'student_id' => $this->resource['student_id'] ?? null,
+            'student_name' => $this->resource['student_name'] ?? null,
+            'grade' => $this->resource['grade'] ?? null,
+            'incident' => $this->resource['incident'] ?? null,
+            'incident_datetime' => $this->resource['incident_datetime'] ?? null,
+            'incident_state' => $this->resource['incident_state'] ?? null,
+            'updated_by_open' => $this->resource['updated_by_open'] ?? null,
+            'updated_by_open_name' => $this->resource['updated_by_open_name'] ?? null,
+            'open_description' => $this->resource['open_description'] ?? null,
+            'updated_by_closed' => $this->resource['updated_by_closed'] ?? null,
+            'updated_by_closed_name' => $this->resource['updated_by_closed_name'] ?? null,
+            'close_description' => $this->resource['close_description'] ?? null,
+            'action_taken' => $this->resource['action_taken'] ?? null,
+            'updated_by_canceled' => $this->resource['updated_by_canceled'] ?? null,
+            'updated_by_canceled_name' => $this->resource['updated_by_canceled_name'] ?? null,
+            'cancel_description' => $this->resource['cancel_description'] ?? null,
+            'semester' => $this->resource['semester'] ?? null,
+            'school_year' => $this->resource['school_year'] ?? null,
+            'created_at' => $this->resource['created_at'] ?? null,
+            'updated_at' => $this->resource['updated_at'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Incidents/IncidentStudentOptionResource.php b/app/Http/Resources/Incidents/IncidentStudentOptionResource.php
new file mode 100644
index 00000000..94c25fc3
--- /dev/null
+++ b/app/Http/Resources/Incidents/IncidentStudentOptionResource.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Resources\Incidents;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class IncidentStudentOptionResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => (int) ($this->resource['id'] ?? 0),
+            'name' => $this->resource['name'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Invoices/InvoiceManagementParentResource.php b/app/Http/Resources/Invoices/InvoiceManagementParentResource.php
new file mode 100644
index 00000000..625b4607
--- /dev/null
+++ b/app/Http/Resources/Invoices/InvoiceManagementParentResource.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Resources\Invoices;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class InvoiceManagementParentResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'parent_name' => $this->resource['parent_name'] ?? '',
+            'parent_id' => (int) ($this->resource['parent_id'] ?? 0),
+            'enrolledKids' => $this->resource['enrolledKids'] ?? [],
+            'withdrawnKids' => $this->resource['withdrawnKids'] ?? [],
+            'invoice_amount' => (float) ($this->resource['invoice_amount'] ?? 0),
+            'refund_amount' => (float) ($this->resource['refund_amount'] ?? 0),
+            'last_updated' => $this->resource['last_updated'] ?? null,
+            'invoice_date' => $this->resource['invoice_date'] ?? null,
+            'invoice_id' => $this->resource['invoice_id'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Invoices/InvoiceResource.php b/app/Http/Resources/Invoices/InvoiceResource.php
new file mode 100644
index 00000000..e9db6cfb
--- /dev/null
+++ b/app/Http/Resources/Invoices/InvoiceResource.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Http\Resources\Invoices;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class InvoiceResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => (int) ($this->resource['id'] ?? 0),
+            'parent_id' => (int) ($this->resource['parent_id'] ?? 0),
+            'invoice_number' => $this->resource['invoice_number'] ?? null,
+            'total_amount' => (float) ($this->resource['total_amount'] ?? 0),
+            'paid_amount' => (float) ($this->resource['paid_amount'] ?? 0),
+            'balance' => (float) ($this->resource['balance'] ?? 0),
+            'status' => $this->resource['status'] ?? null,
+            'school_year' => $this->resource['school_year'] ?? null,
+            'semester' => $this->resource['semester'] ?? null,
+            'issue_date' => $this->resource['issue_date'] ?? null,
+            'due_date' => $this->resource['due_date'] ?? null,
+            'created_at' => $this->resource['created_at'] ?? null,
+            'updated_at' => $this->resource['updated_at'] ?? null,
+            'refund_amount' => (float) ($this->resource['refund_amount'] ?? 0),
+            'last_paid_amount' => (float) ($this->resource['last_paid_amount'] ?? 0),
+            'last_payment_date' => $this->resource['last_payment_date'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Payments/PaymentNotificationLogResource.php b/app/Http/Resources/Payments/PaymentNotificationLogResource.php
new file mode 100644
index 00000000..78b5a744
--- /dev/null
+++ b/app/Http/Resources/Payments/PaymentNotificationLogResource.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Http\Resources\Payments;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class PaymentNotificationLogResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        $parent = $this->resource->parent ?? null;
+        $parentName = $parent ? trim(($parent->firstname ?? '') . ' ' . ($parent->lastname ?? '')) : null;
+
+        return [
+            'id' => (int) ($this->resource->id ?? 0),
+            'parent_id' => (int) ($this->resource->parent_id ?? 0),
+            'parent_name' => $parentName,
+            'invoice_id' => $this->resource->invoice_id ? (int) $this->resource->invoice_id : null,
+            'school_year' => $this->resource->school_year ?? null,
+            'period_year' => (int) ($this->resource->period_year ?? 0),
+            'period_month' => (int) ($this->resource->period_month ?? 0),
+            'type' => $this->resource->type ?? null,
+            'to_email' => $this->resource->to_email ?? null,
+            'cc_email' => $this->resource->cc_email ?? null,
+            'status' => $this->resource->status ?? null,
+            'error_message' => $this->resource->error_message ?? null,
+            'balance_snapshot' => (float) ($this->resource->balance_snapshot ?? 0),
+            'sent_at' => $this->resource->sent_at ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Payments/PaymentResource.php b/app/Http/Resources/Payments/PaymentResource.php
new file mode 100644
index 00000000..3c0f43e8
--- /dev/null
+++ b/app/Http/Resources/Payments/PaymentResource.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Http\Resources\Payments;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class PaymentResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => (int) ($this->resource['id'] ?? 0),
+            'parent_id' => (int) ($this->resource['parent_id'] ?? 0),
+            'invoice_id' => isset($this->resource['invoice_id']) ? (int) $this->resource['invoice_id'] : null,
+            'total_amount' => (float) ($this->resource['total_amount'] ?? 0),
+            'paid_amount' => (float) ($this->resource['paid_amount'] ?? 0),
+            'balance' => (float) ($this->resource['balance'] ?? 0),
+            'number_of_installments' => (int) ($this->resource['number_of_installments'] ?? 0),
+            'transaction_id' => $this->resource['transaction_id'] ?? null,
+            'payment_method' => $this->resource['payment_method'] ?? null,
+            'payment_date' => $this->resource['payment_date'] ?? null,
+            'status' => $this->resource['status'] ?? null,
+            'semester' => $this->resource['semester'] ?? null,
+            'school_year' => $this->resource['school_year'] ?? null,
+            'created_at' => $this->resource['created_at'] ?? null,
+            'updated_at' => $this->resource['updated_at'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Payments/PaymentTransactionResource.php b/app/Http/Resources/Payments/PaymentTransactionResource.php
new file mode 100644
index 00000000..665dd45f
--- /dev/null
+++ b/app/Http/Resources/Payments/PaymentTransactionResource.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Http\Resources\Payments;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class PaymentTransactionResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'transaction_id' => $this->resource['transaction_id'] ?? null,
+            'payment_id' => (int) ($this->resource['payment_id'] ?? 0),
+            'transaction_date' => $this->resource['transaction_date'] ?? null,
+            'amount' => (float) ($this->resource['amount'] ?? 0),
+            'payment_method' => $this->resource['payment_method'] ?? null,
+            'payment_status' => $this->resource['payment_status'] ?? null,
+            'transaction_fee' => isset($this->resource['transaction_fee']) ? (float) $this->resource['transaction_fee'] : null,
+            'payment_reference' => $this->resource['payment_reference'] ?? null,
+            'is_full_payment' => isset($this->resource['is_full_payment']) ? (bool) $this->resource['is_full_payment'] : null,
+            'school_year' => $this->resource['school_year'] ?? null,
+            'semester' => $this->resource['semester'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Payments/PaypalTransactionResource.php b/app/Http/Resources/Payments/PaypalTransactionResource.php
new file mode 100644
index 00000000..1430155f
--- /dev/null
+++ b/app/Http/Resources/Payments/PaypalTransactionResource.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace App\Http\Resources\Payments;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class PaypalTransactionResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => (int) ($this->resource['id'] ?? 0),
+            'transaction_id' => $this->resource['transaction_id'] ?? null,
+            'order_id' => $this->resource['order_id'] ?? null,
+            'parent_school_id' => $this->resource['parent_school_id'] ?? null,
+            'payer_email' => $this->resource['payer_email'] ?? null,
+            'amount' => (float) ($this->resource['amount'] ?? 0),
+            'net_amount' => (float) ($this->resource['net_amount'] ?? 0),
+            'currency' => $this->resource['currency'] ?? null,
+            'status' => $this->resource['status'] ?? null,
+            'event_type' => $this->resource['event_type'] ?? null,
+            'created_at' => $this->resource['created_at'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Reimbursements/ReimbursementBatchResource.php b/app/Http/Resources/Reimbursements/ReimbursementBatchResource.php
new file mode 100644
index 00000000..20ea28be
--- /dev/null
+++ b/app/Http/Resources/Reimbursements/ReimbursementBatchResource.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Http\Resources\Reimbursements;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ReimbursementBatchResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'batchId' => (int) ($this->resource['batchId'] ?? 0),
+            'batchNumber' => (int) ($this->resource['batchNumber'] ?? 0),
+            'label' => $this->resource['label'] ?? null,
+            'sequence' => (int) ($this->resource['sequence'] ?? 0),
+            'yearly_batch_number' => (int) ($this->resource['yearly_batch_number'] ?? 0),
+            'slots' => $this->resource['slots'] ?? [],
+            'itemIds' => $this->resource['itemIds'] ?? [],
+            'status' => $this->resource['status'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Reimbursements/ReimbursementExpenseResource.php b/app/Http/Resources/Reimbursements/ReimbursementExpenseResource.php
new file mode 100644
index 00000000..04f61462
--- /dev/null
+++ b/app/Http/Resources/Reimbursements/ReimbursementExpenseResource.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Http\Resources\Reimbursements;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ReimbursementExpenseResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'expense_id' => (int) ($this->resource['id'] ?? $this->resource['expense_id'] ?? 0),
+            'amount' => (float) ($this->resource['amount'] ?? 0),
+            'category' => $this->resource['category'] ?? null,
+            'description' => $this->resource['description'] ?? null,
+            'retailor' => $this->resource['retailor'] ?? null,
+            'purchased_by' => $this->resource['purchased_by'] ?? null,
+            'expense_receipt_url' => $this->resource['expense_receipt_url'] ?? null,
+            'reimbursement_id' => $this->resource['reimb_id'] ?? null,
+            'reimbursement_amount' => isset($this->resource['reimb_amount']) ? (float) $this->resource['reimb_amount'] : null,
+            'reimbursement_method' => $this->resource['reimbursement_method'] ?? null,
+            'check_number' => $this->resource['check_number'] ?? null,
+            'reimb_receipt_url' => $this->resource['reimb_receipt_url'] ?? null,
+            'reimb_status' => $this->resource['reimb_status'] ?? null,
+            'reimbursed_to' => $this->resource['reimb_recipient_id'] ?? null,
+            'reimbursed_firstname' => $this->resource['reimb_firstname'] ?? null,
+            'reimbursed_lastname' => $this->resource['reimb_lastname'] ?? null,
+            'approver_firstname' => $this->resource['approver_firstname'] ?? null,
+            'approver_lastname' => $this->resource['approver_lastname'] ?? null,
+            'school_year' => $this->resource['school_year'] ?? null,
+            'semester' => $this->resource['semester'] ?? null,
+            'reimb_created_at' => $this->resource['reimb_created_at'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Reimbursements/ReimbursementRecipientResource.php b/app/Http/Resources/Reimbursements/ReimbursementRecipientResource.php
new file mode 100644
index 00000000..70f2bfd4
--- /dev/null
+++ b/app/Http/Resources/Reimbursements/ReimbursementRecipientResource.php
@@ -0,0 +1,24 @@
+<?php
+
+namespace App\Http\Resources\Reimbursements;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ReimbursementRecipientResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        $id = (int) ($this->resource['id'] ?? 0);
+        $first = $this->resource['firstname'] ?? '';
+        $last = $this->resource['lastname'] ?? '';
+        $name = trim($first . ' ' . $last);
+
+        return [
+            'id' => $id,
+            'firstname' => $first,
+            'lastname' => $last,
+            'name' => $name,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Reimbursements/ReimbursementResource.php b/app/Http/Resources/Reimbursements/ReimbursementResource.php
new file mode 100644
index 00000000..768264ab
--- /dev/null
+++ b/app/Http/Resources/Reimbursements/ReimbursementResource.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Http\Resources\Reimbursements;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ReimbursementResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => (int) ($this->resource['id'] ?? $this->resource->id ?? 0),
+            'expense_id' => isset($this->resource['expense_id']) ? (int) $this->resource['expense_id'] : (int) ($this->resource->expense_id ?? 0),
+            'amount' => (float) ($this->resource['amount'] ?? $this->resource->amount ?? 0),
+            'reimbursed_to' => isset($this->resource['reimbursed_to']) ? (int) $this->resource['reimbursed_to'] : (int) ($this->resource->reimbursed_to ?? 0),
+            'description' => $this->resource['description'] ?? $this->resource->description ?? null,
+            'status' => $this->resource['status'] ?? $this->resource->status ?? null,
+            'reimbursement_method' => $this->resource['reimbursement_method'] ?? $this->resource->reimbursement_method ?? null,
+            'check_number' => $this->resource['check_number'] ?? $this->resource->check_number ?? null,
+            'receipt_path' => $this->resource['receipt_path'] ?? $this->resource->receipt_path ?? null,
+            'receipt_url' => $this->resource['receipt_url'] ?? null,
+            'school_year' => $this->resource['school_year'] ?? $this->resource->school_year ?? null,
+            'semester' => $this->resource['semester'] ?? $this->resource->semester ?? null,
+            'batch_number' => isset($this->resource['batch_number']) ? (int) $this->resource['batch_number'] : (int) ($this->resource->batch_number ?? 0),
+            'created_at' => $this->resource['created_at'] ?? $this->resource->created_at ?? null,
+            'updated_at' => $this->resource['updated_at'] ?? $this->resource->updated_at ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Reimbursements/ReimbursementUnderProcessingItemResource.php b/app/Http/Resources/Reimbursements/ReimbursementUnderProcessingItemResource.php
new file mode 100644
index 00000000..2da43d0d
--- /dev/null
+++ b/app/Http/Resources/Reimbursements/ReimbursementUnderProcessingItemResource.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Http\Resources\Reimbursements;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ReimbursementUnderProcessingItemResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'id' => (int) ($this->resource['id'] ?? 0),
+            'expense_id' => (int) ($this->resource['expense_id'] ?? 0),
+            'reimbursement_id' => $this->resource['reimbursement_id'] ?? null,
+            'expense_amount' => (float) ($this->resource['expense_amount'] ?? 0),
+            'vendor' => $this->resource['vendor'] ?? null,
+            'description' => $this->resource['description'] ?? null,
+            'purchased_by' => $this->resource['purchased_by'] ?? null,
+            'receipt_url' => $this->resource['receipt_url'] ?? null,
+            'batch_id' => $this->resource['batch_id'] ?? null,
+            'batch_label' => $this->resource['batch_label'] ?? null,
+            'admin_id' => $this->resource['admin_id'] ?? null,
+            'admin_name' => $this->resource['admin_name'] ?? null,
+            'batch_number' => (int) ($this->resource['batch_number'] ?? 0),
+        ];
+    }
+}
diff --git a/app/Http/Resources/Scores/ScoreCommentResource.php b/app/Http/Resources/Scores/ScoreCommentResource.php
new file mode 100644
index 00000000..638f7601
--- /dev/null
+++ b/app/Http/Resources/Scores/ScoreCommentResource.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Resources\Scores;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ScoreCommentResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'student_id' => (int) ($this->resource['student_id'] ?? 0),
+            'firstname' => $this->resource['firstname'] ?? null,
+            'lastname' => $this->resource['lastname'] ?? null,
+            'school_id' => $this->resource['school_id'] ?? null,
+            'comments' => $this->resource['comments'] ?? [],
+        ];
+    }
+}
diff --git a/app/Http/Resources/Scores/ScorePredictorStudentResource.php b/app/Http/Resources/Scores/ScorePredictorStudentResource.php
new file mode 100644
index 00000000..c7073a8d
--- /dev/null
+++ b/app/Http/Resources/Scores/ScorePredictorStudentResource.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace App\Http\Resources\Scores;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ScorePredictorStudentResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'student_id' => (int) ($this->resource['student_id'] ?? 0),
+            'school_id' => $this->resource['school_id'] ?? null,
+            'firstname' => $this->resource['firstname'] ?? null,
+            'lastname' => $this->resource['lastname'] ?? null,
+            'class_section_id' => $this->resource['class_section_id'] ?? null,
+            'fall_score' => $this->resource['fall_score'] ?? null,
+            'spring_score' => $this->resource['spring_score'] ?? null,
+            'final_average' => $this->resource['final_average'] ?? null,
+            'required_spring_score' => $this->resource['required_spring_score'] ?? null,
+            'winning_risk' => $this->resource['winning_risk'] ?? null,
+            'required_spring_to_pass' => $this->resource['required_spring_to_pass'] ?? null,
+            'failure_risk' => $this->resource['failure_risk'] ?? null,
+            'status' => $this->resource['status'] ?? null,
+            'trophy_awarded' => (bool) ($this->resource['trophy_awarded'] ?? false),
+            'trophy_reason' => $this->resource['trophy_reason'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Scores/ScoreStudentResource.php b/app/Http/Resources/Scores/ScoreStudentResource.php
new file mode 100644
index 00000000..f1abac16
--- /dev/null
+++ b/app/Http/Resources/Scores/ScoreStudentResource.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Resources\Scores;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class ScoreStudentResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'student_id' => (int) ($this->resource['student_id'] ?? 0),
+            'firstname' => $this->resource['firstname'] ?? null,
+            'lastname' => $this->resource['lastname'] ?? null,
+            'school_id' => $this->resource['school_id'] ?? null,
+            'scores' => $this->resource['scores'] ?? [],
+            'comments' => $this->resource['comments'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Semesters/SemesterRangeResource.php b/app/Http/Resources/Semesters/SemesterRangeResource.php
new file mode 100644
index 00000000..54fcb49c
--- /dev/null
+++ b/app/Http/Resources/Semesters/SemesterRangeResource.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Resources\Semesters;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class SemesterRangeResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'start_date' => $this->resource['start_date'] ?? null,
+            'end_date' => $this->resource['end_date'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Semesters/SemesterResolveResource.php b/app/Http/Resources/Semesters/SemesterResolveResource.php
new file mode 100644
index 00000000..22b3bd9a
--- /dev/null
+++ b/app/Http/Resources/Semesters/SemesterResolveResource.php
@@ -0,0 +1,17 @@
+<?php
+
+namespace App\Http\Resources\Semesters;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class SemesterResolveResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'date' => $this->resource['date'] ?? null,
+            'semester' => $this->resource['semester'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Users/LoginActivityResource.php b/app/Http/Resources/Users/LoginActivityResource.php
new file mode 100644
index 00000000..43ead345
--- /dev/null
+++ b/app/Http/Resources/Users/LoginActivityResource.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace App\Http\Resources\Users;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class LoginActivityResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'user_id' => $this->resource['user_id'] ?? null,
+            'email' => $this->resource['email'] ?? null,
+            'login_time' => $this->resource['login_time'] ?? null,
+            'logout_time' => $this->resource['logout_time'] ?? null,
+            'ip_address' => $this->resource['ip_address'] ?? null,
+            'user_agent' => $this->resource['user_agent'] ?? null,
+        ];
+    }
+}
diff --git a/app/Http/Resources/Users/UserWithRolesResource.php b/app/Http/Resources/Users/UserWithRolesResource.php
new file mode 100644
index 00000000..551afe12
--- /dev/null
+++ b/app/Http/Resources/Users/UserWithRolesResource.php
@@ -0,0 +1,20 @@
+<?php
+
+namespace App\Http\Resources\Users;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\JsonResource;
+
+class UserWithRolesResource extends JsonResource
+{
+    public function toArray(Request $request): array
+    {
+        return [
+            'user' => $this->resource['user'] ?? null,
+            'roles' => $this->resource['roles'] ?? [],
+            'role_ids' => $this->resource['role_ids'] ?? [],
+            'parent_type' => $this->resource['parent_type'] ?? '',
+            'second_from_parents' => $this->resource['second_from_parents'] ?? '',
+        ];
+    }
+}
diff --git a/app/Interfaces/ScoreCalculatorInterface.php b/app/Interfaces/ScoreCalculatorInterface.php
new file mode 100644
index 00000000..f1ad6926
--- /dev/null
+++ b/app/Interfaces/ScoreCalculatorInterface.php
@@ -0,0 +1,11 @@
+<?php
+
+namespace App\Interfaces;
+
+interface ScoreCalculatorInterface
+{
+    /**
+     * @return array<string, mixed>
+     */
+    public function calculate(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): array;
+}
diff --git a/app/Models/CurrentIncident.php b/app/Models/CurrentIncident.php
new file mode 100644
index 00000000..736a79fc
--- /dev/null
+++ b/app/Models/CurrentIncident.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Models;
+
+use App\Models\BaseModel;
+
+class CurrentIncident extends BaseModel
+{
+    protected $table = 'current_incident';
+
+    public $timestamps = true;
+
+    protected $fillable = [
+        'student_id',
+        'student_name',
+        'grade',
+        'incident',
+        'incident_datetime',
+        'incident_state',
+        'updated_by_open',
+        'open_description',
+        'updated_by_closed',
+        'close_description',
+        'action_taken',
+        'updated_by_canceled',
+        'cancel_description',
+        'semester',
+        'school_year',
+        'created_at',
+        'updated_at',
+    ];
+
+    protected $casts = [
+        'student_id' => 'integer',
+        'updated_by_open' => 'integer',
+        'updated_by_closed' => 'integer',
+        'updated_by_canceled' => 'integer',
+        'incident_datetime' => 'datetime',
+    ];
+}
diff --git a/app/Models/Flag.php b/app/Models/Incident.php
similarity index 86%
rename from app/Models/Flag.php
rename to app/Models/Incident.php
index 2e8a7324..3ab7d922 100644
--- a/app/Models/Flag.php
+++ b/app/Models/Incident.php
@@ -4,9 +4,9 @@ namespace App\Models;
 
 use App\Models\BaseModel;
 
-class Flag extends BaseModel
+class Incident extends BaseModel
 {
-    protected $table = 'flag';
+    protected $table = 'incident';
 
     // Table contains created_at/updated_at; enable auto timestamps (recommended).
     public $timestamps = true;
@@ -15,9 +15,9 @@ class Flag extends BaseModel
         'student_id',
         'student_name',
         'grade',
-        'flag',
-        'flag_datetime',
-        'flag_state',
+        'incident',
+        'incident_datetime',
+        'incident_state',
         'updated_by_open',
         'open_description',
         'updated_by_closed',
@@ -36,7 +36,7 @@ class Flag extends BaseModel
         'updated_by_open'     => 'integer',
         'updated_by_closed'   => 'integer',
         'updated_by_canceled' => 'integer',
-        'flag_datetime'       => 'datetime',
+        'incident_datetime'   => 'datetime',
     ];
 
     /* Optional relationships */
@@ -59,4 +59,4 @@ class Flag extends BaseModel
     {
         return $this->belongsTo(User::class, 'updated_by_canceled');
     }
-}
\ No newline at end of file
+}
diff --git a/app/Models/PaymentTransaction.php b/app/Models/PaymentTransaction.php
index 4c053223..67e67e95 100644
--- a/app/Models/PaymentTransaction.php
+++ b/app/Models/PaymentTransaction.php
@@ -20,6 +20,8 @@ class PaymentTransaction extends BaseModel
         'payment_method',
         'payment_status',
         'transaction_fee',
+        'payment_reference',
+        'is_full_payment',
         'school_year',
         'semester',
     ];
@@ -91,4 +93,4 @@ class PaymentTransaction extends BaseModel
             ->orderByDesc('transaction_date')
             ->first();
     }
-}
\ No newline at end of file
+}
diff --git a/app/Services/Administrator/AdministratorEnrollmentStatusService.php b/app/Services/Administrator/AdministratorEnrollmentStatusService.php
index f111a93d..cda49b10 100644
--- a/app/Services/Administrator/AdministratorEnrollmentStatusService.php
+++ b/app/Services/Administrator/AdministratorEnrollmentStatusService.php
@@ -23,8 +23,6 @@ class AdministratorEnrollmentStatusService
         $schoolYear = $this->shared->getSchoolYear();
         $semester = $this->shared->getSemester();
 
-        DB::beginTransaction();
-
         try {
             if (empty($enrollmentStatuses)) {
                 return [
@@ -34,6 +32,8 @@ class AdministratorEnrollmentStatusService
                 ];
             }
 
+            DB::beginTransaction();
+
             $errors = [];
             $groupsByParentStatus = [];
             $parentInfo = [];
@@ -270,4 +270,4 @@ class AdministratorEnrollmentStatusService
             'lastname' => $parentData['lastname'] ?? '',
         ];
     }
-}
\ No newline at end of file
+}
diff --git a/app/Services/Assignment/AssignmentContextService.php b/app/Services/Assignment/AssignmentContextService.php
new file mode 100644
index 00000000..11f2c9ce
--- /dev/null
+++ b/app/Services/Assignment/AssignmentContextService.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Services\Assignment;
+
+use App\Models\Configuration;
+
+class AssignmentContextService
+{
+    public function __construct(private Configuration $configuration) {}
+
+    public function getCurrentSemester(): string
+    {
+        return (string) ($this->getConfigValue('semester') ?? '');
+    }
+
+    public function getCurrentSchoolYear(): string
+    {
+        return (string) ($this->getConfigValue('school_year') ?? '');
+    }
+
+    private function getConfigValue(string $key): mixed
+    {
+        return $this->configuration
+            ->newQuery()
+            ->where('config_key', $key)
+            ->value('config_value');
+    }
+}
diff --git a/app/Services/Assignment/AssignmentDataLoaderService.php b/app/Services/Assignment/AssignmentDataLoaderService.php
new file mode 100644
index 00000000..df8f5219
--- /dev/null
+++ b/app/Services/Assignment/AssignmentDataLoaderService.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Services\Assignment;
+
+use App\Models\StudentClass;
+use App\Models\TeacherClass;
+use Illuminate\Support\Collection;
+
+class AssignmentDataLoaderService
+{
+    public function __construct(
+        private TeacherClass $teacherClass,
+        private StudentClass $studentClass
+    ) {}
+
+    public function loadTeacherClasses(?string $schoolYear = null): Collection
+    {
+        return $this->teacherClass
+            ->newQuery()
+            ->with([
+                'teacher:id,firstname,lastname',
+            ])
+            ->when(filled($schoolYear), fn ($q) => $q->where('school_year', $schoolYear))
+            ->get()
+            ->map(function ($row) {
+                $row->teacher_full_name = trim(
+                    ((string) optional($row->teacher)->firstname) . ' ' .
+                    ((string) optional($row->teacher)->lastname)
+                );
+
+                return $row;
+            });
+    }
+
+    public function loadStudentClasses(?string $schoolYear = null): Collection
+    {
+        return $this->studentClass
+            ->newQuery()
+            ->with([
+                'student:id,firstname,lastname,age,gender,registration_grade,photo_consent,tuition_paid,school_id,is_active',
+            ])
+            ->whereHas('student', fn ($q) => $q->where('is_active', 1))
+            ->when(filled($schoolYear), fn ($q) => $q->where('school_year', $schoolYear))
+            ->get();
+    }
+}
diff --git a/app/Services/Assignment/AssignmentMetaService.php b/app/Services/Assignment/AssignmentMetaService.php
new file mode 100644
index 00000000..f06410dd
--- /dev/null
+++ b/app/Services/Assignment/AssignmentMetaService.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Services\Assignment;
+
+use Illuminate\Support\Facades\DB;
+
+class AssignmentMetaService
+{
+    public function getSchoolYears(string $fallbackYear = ''): array
+    {
+        $years = DB::table('teacher_class')
+            ->selectRaw('DISTINCT school_year')
+            ->whereNotNull('school_year')
+            ->orderByDesc('school_year')
+            ->pluck('school_year')
+            ->map(fn ($year) => (string) $year)
+            ->filter()
+            ->values()
+            ->all();
+
+        if (empty($years) && $fallbackYear !== '') {
+            $years[] = $fallbackYear;
+        }
+
+        return $years;
+    }
+
+    public function firstNonEmpty(array $values): mixed
+    {
+        foreach ($values as $value) {
+            if (filled($value)) {
+                return $value;
+            }
+        }
+
+        return null;
+    }
+}
diff --git a/app/Services/Assignment/AssignmentSectionService.php b/app/Services/Assignment/AssignmentSectionService.php
new file mode 100644
index 00000000..a30ef208
--- /dev/null
+++ b/app/Services/Assignment/AssignmentSectionService.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Services\Assignment;
+
+use App\Models\ClassSection;
+
+class AssignmentSectionService
+{
+    public function __construct(private ClassSection $classSection) {}
+
+    public function getSectionNamesMap(array $sectionIds): array
+    {
+        if (empty($sectionIds)) {
+            return [];
+        }
+
+        return $this->classSection
+            ->newQuery()
+            ->whereIn('id', $sectionIds)
+            ->get()
+            ->mapWithKeys(function ($section) {
+                $name = $section->class_section_name ?? $section->section_name ?? $section->name ?? '';
+                return [(int) $section->id => (string) $name];
+            })
+            ->all();
+    }
+}
diff --git a/app/Services/Assignment/AssignmentService.php b/app/Services/Assignment/AssignmentService.php
index 969abaf1..8e03f5a7 100644
--- a/app/Services/Assignment/AssignmentService.php
+++ b/app/Services/Assignment/AssignmentService.php
@@ -2,38 +2,26 @@
 
 namespace App\Services\Assignment;
 
-use App\Models\ClassSection;
-use App\Models\Configuration;
 use App\Models\StudentClass;
-use App\Models\TeacherClass;
-use Illuminate\Support\Collection;
-use Illuminate\Support\Facades\DB;
 
 class AssignmentService
 {
     public function __construct(
-        protected Configuration $configurationModel,
-        protected TeacherClass $teacherClassModel,
         protected StudentClass $studentClassModel,
-        protected ClassSection $classSectionModel,
+        protected AssignmentContextService $contextService,
+        protected AssignmentDataLoaderService $dataLoader,
+        protected AssignmentSectionService $sectionService,
+        protected AssignmentMetaService $metaService
     ) {}
 
     public function getCurrentSemester(): string
     {
-        return (string) ($this->getConfigValue('semester') ?? '');
+        return $this->contextService->getCurrentSemester();
     }
 
     public function getCurrentSchoolYear(): string
     {
-        return (string) ($this->getConfigValue('school_year') ?? '');
-    }
-
-    protected function getConfigValue(string $key): mixed
-    {
-        return $this->configurationModel
-            ->newQuery()
-            ->where('config_key', $key)
-            ->value('config_value');
+        return $this->contextService->getCurrentSchoolYear();
     }
 
     public function getAssignmentsOverview(?string $schoolYear = null, ?string $semester = null): array
@@ -44,8 +32,8 @@ class AssignmentService
         $selectedSemester = (string) ($semester ?? $currentSemester);
         $selectedYear = (string) ($schoolYear ?? $currentSchoolYear);
 
-        $teacherClasses = $this->loadTeacherClasses($selectedYear);
-        $studentClasses = $this->loadStudentClasses($selectedYear);
+        $teacherClasses = $this->dataLoader->loadTeacherClasses($selectedYear);
+        $studentClasses = $this->dataLoader->loadStudentClasses($selectedYear);
 
         $teacherBySection = $teacherClasses->groupBy('class_section_id');
         $studentBySection = $studentClasses->groupBy('class_section_id');
@@ -56,7 +44,7 @@ class AssignmentService
             ->filter()
             ->values();
 
-        $sectionNames = $this->getSectionNamesMap($allSectionIds->all());
+        $sectionNames = $this->sectionService->getSectionNamesMap($allSectionIds->all());
 
         $classSections = $allSectionIds->map(function ($sectionId) use (
             $teacherBySection,
@@ -86,19 +74,19 @@ class AssignmentService
                 ->unique()
                 ->values();
 
-            $semesterMeta = $this->firstNonEmpty([
+            $semesterMeta = $this->metaService->firstNonEmpty([
                 $teacherRows->pluck('semester')->first(fn ($v) => filled($v)),
                 $studentRows->pluck('semester')->first(fn ($v) => filled($v)),
                 $currentSemester,
             ]);
 
-            $schoolYearMeta = $this->firstNonEmpty([
+            $schoolYearMeta = $this->metaService->firstNonEmpty([
                 $teacherRows->pluck('school_year')->first(fn ($v) => filled($v)),
                 $studentRows->pluck('school_year')->first(fn ($v) => filled($v)),
                 $currentSchoolYear,
             ]);
 
-            $descriptionMeta = $this->firstNonEmpty([
+            $descriptionMeta = $this->metaService->firstNonEmpty([
                 $teacherRows->pluck('description')->first(fn ($v) => filled($v)),
                 $studentRows->pluck('description')->first(fn ($v) => filled($v)),
                 '',
@@ -141,7 +129,7 @@ class AssignmentService
 
         return [
             'classSections' => $classSections,
-            'schoolYears' => $this->getSchoolYears($currentSchoolYear),
+            'schoolYears' => $this->metaService->getSchoolYears($currentSchoolYear),
             'schoolYear' => $selectedYear,
             'selectedYear' => $selectedYear,
             'selectedSemester' => $selectedSemester,
@@ -171,8 +159,8 @@ class AssignmentService
         $currentSemester = $this->getCurrentSemester();
         $currentSchoolYear = $this->getCurrentSchoolYear();
 
-        $teacherClasses = $this->loadTeacherClasses();
-        $studentClasses = $this->loadStudentClasses();
+        $teacherClasses = $this->dataLoader->loadTeacherClasses();
+        $studentClasses = $this->dataLoader->loadStudentClasses();
 
         $teacherBySection = $teacherClasses->groupBy('class_section_id');
         $studentBySection = $studentClasses->groupBy('class_section_id');
@@ -183,7 +171,7 @@ class AssignmentService
             ->filter()
             ->values();
 
-        $sectionNames = $this->getSectionNamesMap($allSectionIds->all());
+        $sectionNames = $this->sectionService->getSectionNamesMap($allSectionIds->all());
 
         $classSections = $allSectionIds->map(function ($sectionId) use (
             $teacherBySection,
@@ -213,19 +201,19 @@ class AssignmentService
                 ->unique()
                 ->values();
 
-            $semesterMeta = $this->firstNonEmpty([
+            $semesterMeta = $this->metaService->firstNonEmpty([
                 $teacherRows->pluck('semester')->first(fn ($v) => filled($v)),
                 $studentRows->pluck('semester')->first(fn ($v) => filled($v)),
                 $currentSemester,
             ]);
 
-            $schoolYearMeta = $this->firstNonEmpty([
+            $schoolYearMeta = $this->metaService->firstNonEmpty([
                 $teacherRows->pluck('school_year')->first(fn ($v) => filled($v)),
                 $studentRows->pluck('school_year')->first(fn ($v) => filled($v)),
                 $currentSchoolYear,
             ]);
 
-            $descriptionMeta = $this->firstNonEmpty([
+            $descriptionMeta = $this->metaService->firstNonEmpty([
                 $teacherRows->pluck('description')->first(fn ($v) => filled($v)),
                 $studentRows->pluck('description')->first(fn ($v) => filled($v)),
                 '',
@@ -272,82 +260,4 @@ class AssignmentService
             'school_year' => $currentSchoolYear,
         ];
     }
-
-    protected function loadTeacherClasses(?string $schoolYear = null): Collection
-    {
-        return $this->teacherClassModel
-            ->newQuery()
-            ->with([
-                'teacher:id,firstname,lastname',
-            ])
-            ->when(filled($schoolYear), fn ($q) => $q->where('school_year', $schoolYear))
-            ->get()
-            ->map(function ($row) {
-                $row->teacher_full_name = trim(
-                    ((string) optional($row->teacher)->firstname) . ' ' .
-                    ((string) optional($row->teacher)->lastname)
-                );
-
-                return $row;
-            });
-    }
-
-    protected function loadStudentClasses(?string $schoolYear = null): Collection
-    {
-        return $this->studentClassModel
-            ->newQuery()
-            ->with([
-                'student:id,firstname,lastname,age,gender,registration_grade,photo_consent,tuition_paid,school_id,is_active',
-            ])
-            ->whereHas('student', fn ($q) => $q->where('is_active', 1))
-            ->when(filled($schoolYear), fn ($q) => $q->where('school_year', $schoolYear))
-            ->get();
-    }
-
-    protected function getSectionNamesMap(array $sectionIds): array
-    {
-        if (empty($sectionIds)) {
-            return [];
-        }
-
-        return $this->classSectionModel
-            ->newQuery()
-            ->whereIn('id', $sectionIds)
-            ->get()
-            ->mapWithKeys(function ($section) {
-                $name = $section->section_name ?? $section->name ?? '';
-                return [(int) $section->id => (string) $name];
-            })
-            ->all();
-    }
-
-    protected function getSchoolYears(string $fallbackYear = ''): array
-    {
-        $years = DB::table('teacher_class')
-            ->selectRaw('DISTINCT school_year')
-            ->whereNotNull('school_year')
-            ->orderByDesc('school_year')
-            ->pluck('school_year')
-            ->map(fn ($year) => (string) $year)
-            ->filter()
-            ->values()
-            ->all();
-
-        if (empty($years) && $fallbackYear !== '') {
-            $years[] = $fallbackYear;
-        }
-
-        return $years;
-    }
-
-    protected function firstNonEmpty(array $values): mixed
-    {
-        foreach ($values as $value) {
-            if (filled($value)) {
-                return $value;
-            }
-        }
-
-        return null;
-    }
 }
diff --git a/app/Services/AttendanceTracking/AttendanceTrackingService.php b/app/Services/AttendanceTracking/AttendanceTrackingService.php
index 07d27696..4995372b 100644
--- a/app/Services/AttendanceTracking/AttendanceTrackingService.php
+++ b/app/Services/AttendanceTracking/AttendanceTrackingService.php
@@ -2,179 +2,6 @@
 
 namespace App\Services\AttendanceTracking;
 
-use App\Models\AttendanceData;
-use App\Models\AttendanceTracking;
-use App\Models\Configuration;
-use App\Models\Student;
-use App\Models\StudentClass;
-use Carbon\Carbon;
-
 class AttendanceTrackingService
 {
-    protected string $semester;
-    protected string $schoolYear;
-
-    public function __construct(
-        protected Student $studentModel,
-        protected StudentClass $studentClassModel,
-        protected AttendanceData $attendanceDataModel,
-        protected AttendanceTracking $attendanceTrackingModel,
-        protected Configuration $configModel,
-        protected AttendanceMailerService $attendanceMailerService,
-        protected ViolationRuleEngineService $violationRuleEngine,
-        protected AttendanceParentLookupService $parentLookupService,
-        protected AttendanceEmailComposerService $emailComposerService,
-        protected AttendanceNotificationLogService $notificationLogService,
-        protected AttendanceViolationStudentResolverService $studentResolverService,
-        protected AttendanceCaseQueryService $attendanceCaseQueryService,
-        protected AttendanceNotificationWorkflowService $attendanceNotificationWorkflowService,
-        protected AttendanceCommunicationSupportService $attendanceCommunicationSupportService,
-        protected AttendancePendingViolationService $attendancePendingViolationService
-    ) {
-        $this->semester   = (string) ($this->configModel->getConfig('semester') ?? '');
-        $this->schoolYear = (string) ($this->configModel->getConfig('school_year') ?? '');
-    }
-
-    public function getPendingViolations(?string $schoolYearParam = null, ?string $semesterParam = null): array
-    {
-        return $this->attendancePendingViolationService->getPendingViolations(
-            $this->schoolYear,
-            $schoolYearParam,
-            $semesterParam
-        );
-    }
-
-    public function getStudentCase(
-        int $studentId,
-        ?string $codeParam = null,
-        ?string $incidentDate = null,
-        bool $includeNotified = false,
-        bool $pendingOnly = false,
-        ?string $schoolYearFilter = null,
-        ?string $semesterFilter = null
-    ): array {
-        return $this->attendanceCaseQueryService->getStudentCase(
-            $studentId,
-            $codeParam,
-            $incidentDate,
-            $includeNotified,
-            $pendingOnly,
-            $schoolYearFilter,
-            $semesterFilter,
-            $this->schoolYear,
-            $this->semester
-        );
-    }
-
-    public function getNotifiedViolations(?string $schoolYearParam = null, ?string $semesterParam = null): array
-    {
-        return $this->attendanceCaseQueryService->getNotifiedViolations(
-            $schoolYearParam,
-            $semesterParam,
-            $this->schoolYear,
-            $this->semester
-        );
-    }
-
-    public function compose(
-        int $studentId,
-        string $code = 'ABS_1',
-        string $variant = 'default',
-        ?string $incidentDate = null
-    ): array {
-        return $this->attendanceCommunicationSupportService->compose(
-            $studentId,
-            $code,
-            $variant,
-            $incidentDate
-        );
-    }
-
-    public function parentsInfo(int $studentId): array
-    {
-        return $this->attendanceCommunicationSupportService->parentsInfo($studentId);
-    }
-
-    public function record(array $data): array
-    {
-        return $this->attendanceNotificationWorkflowService->record($data);
-    }
-
-    public function sendAutoEmails(?string $variantOverride = null): array
-    {
-        $classStudentsQuery = $this->studentClassModel->query();
-        if (method_exists($this->studentClassModel, 'scopeActive')) {
-            $classStudentsQuery->active();
-        }
-
-        $classStudents = $classStudentsQuery
-            ->where('school_year', $this->schoolYear)
-            ->get()
-            ->toArray();
-
-        if (empty($classStudents)) {
-            return [
-                'success' => true,
-                'sent'    => 0,
-                'skipped' => 0,
-                'errors'  => 0,
-                'details' => [],
-            ];
-        }
-
-        $studentIds = array_column($classStudents, 'student_id');
-
-        $students = $this->studentModel->query()
-            ->whereIn('id', $studentIds)
-            ->where('is_active', 1)
-            ->get()
-            ->toArray();
-
-        $attendanceQuery = $this->attendanceDataModel->query()
-            ->whereIn('student_id', $studentIds)
-            ->where('school_year', $this->schoolYear)
-            ->where('date', '>=', Carbon::today()->subWeeks(5)->format('Y-m-d'));
-
-        $this->violationRuleEngine->applyUnreportedAttendanceFilter(
-            $attendanceQuery,
-            $this->attendanceDataModel->getTable()
-        );
-
-        $attendanceData = $attendanceQuery
-            ->whereRaw("LOWER(TRIM(status)) IN ('absent','late')")
-            ->orderByDesc('date')
-            ->get()
-            ->toArray();
-
-        $violations = $this->violationRuleEngine->computeViolations(
-            $students,
-            $attendanceData,
-            $this->schoolYear,
-            null,
-            $attendanceData
-        );
-
-        return $this->attendanceNotificationWorkflowService->sendAutoEmails($violations, $variantOverride);
-    }
-
-    public function sendEmailManual(array $data): array
-    {
-        $sid = (int) $data['student_id'];
-        $code = (string) $data['code'];
-        $ymdRaw = (string) ($data['incident_date'] ?? '');
-        $ymd = $ymdRaw !== '' ? substr($ymdRaw, 0, 10) : '';
-
-        $violationDates = $this->attendanceCommunicationSupportService->getViolationDatesForStudent(
-            $sid,
-            $code,
-            $ymd
-        );
-
-        return $this->attendanceNotificationWorkflowService->sendEmailManual($data, $violationDates);
-    }
-
-    public function saveNotificationNote(array $data): array
-    {
-        return $this->attendanceNotificationWorkflowService->saveNotificationNote($data);
-    }
-}
\ No newline at end of file
+}
diff --git a/app/Services/AttendanceTrackingService.php b/app/Services/AttendanceTrackingService.php
deleted file mode 100644
index d975e50e..00000000
--- a/app/Services/AttendanceTrackingService.php
+++ /dev/null
@@ -1,9 +0,0 @@
-<?php
-
-namespace App\Services;
-
-use App\Services\AttendanceTracking\AttendanceTrackingService as CoreService;
-
-class AttendanceTrackingService extends CoreService
-{
-}
diff --git a/app/Services/Auth/RegistrationCaptchaService.php b/app/Services/Auth/RegistrationCaptchaService.php
new file mode 100644
index 00000000..47c79924
--- /dev/null
+++ b/app/Services/Auth/RegistrationCaptchaService.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Services\Auth;
+
+class RegistrationCaptchaService
+{
+    public function generate(?int $length = null): string
+    {
+        $length = $length ?? random_int(4, 8);
+        $characters = 'ABCDEFGHJKLMNOPQRSTUVWXYZabcdefghjkmnopqrstuvwxyz0123456789';
+        $captchaText = '';
+
+        for ($i = 0; $i < $length; $i++) {
+            $captchaText .= $characters[random_int(0, strlen($characters) - 1)];
+        }
+
+        session()->put('captcha_answer', $captchaText);
+
+        return $captchaText;
+    }
+
+    public function verify(string $input): bool
+    {
+        $expected = (string) session()->get('captcha_answer', '');
+        if ($expected === '') {
+            return false;
+        }
+
+        return hash_equals($expected, $input);
+    }
+
+    public function clear(): void
+    {
+        session()->forget('captcha_answer');
+    }
+}
diff --git a/app/Services/Auth/RegistrationFormatterService.php b/app/Services/Auth/RegistrationFormatterService.php
new file mode 100644
index 00000000..3d00572e
--- /dev/null
+++ b/app/Services/Auth/RegistrationFormatterService.php
@@ -0,0 +1,84 @@
+<?php
+
+namespace App\Services\Auth;
+
+use App\Services\PhoneFormatterService;
+
+class RegistrationFormatterService
+{
+    public function __construct(private PhoneFormatterService $phoneFormatter)
+    {
+    }
+
+    public function format(array $payload): array
+    {
+        $g = static function (string $key) use ($payload): string {
+            return trim((string) ($payload[$key] ?? ''));
+        };
+
+        $data = [
+            'firstname' => $this->formatName($g('firstname')),
+            'lastname' => $this->formatName($g('lastname')),
+            'email' => $this->formatEmail($g('email')),
+            'gender' => $g('gender'),
+            'city' => $this->formatName($g('city')),
+            'cellphone' => $this->phoneFormatter->formatPhoneNumber($g('cellphone')),
+            'address_street' => $this->formatAddress($g('address_street')),
+            'apt' => strtoupper($g('apt')),
+            'state' => strtoupper($g('state')),
+            'zip' => $g('zip'),
+            'accept_school_policy' => (int) ($payload['accept_school_policy'] ?? 0),
+        ];
+
+        $noSecondInfo = !empty($payload['no_second_parent_info']);
+
+        $secondFirstname = $this->formatName($g('second_firstname'));
+        $secondLastname = $this->formatName($g('second_lastname'));
+        $secondGender = $g('second_gender');
+        $secondEmail = $this->formatEmail($g('second_email'));
+        $secondCellphone = $this->phoneFormatter->formatPhoneNumber($g('second_cellphone'));
+
+        $secondProvided = !$noSecondInfo && (
+            $secondFirstname !== '' ||
+            $secondLastname !== '' ||
+            $secondGender !== '' ||
+            $secondEmail !== '' ||
+            preg_replace('/\D/', '', (string) $secondCellphone) !== ''
+        );
+
+        if ($secondProvided) {
+            $data['second_firstname'] = $secondFirstname;
+            $data['second_lastname'] = $secondLastname;
+            $data['second_gender'] = $secondGender;
+            $data['second_email'] = $secondEmail;
+            $data['second_cellphone'] = $secondCellphone;
+        }
+
+        return $data;
+    }
+
+    private function formatName(string $name): string
+    {
+        $name = trim($name);
+        if ($name === '') {
+            return '';
+        }
+
+        return ucwords(strtolower($name), " -");
+    }
+
+    private function formatEmail(string $email): string
+    {
+        return strtolower(trim($email));
+    }
+
+    private function formatAddress(string $address): string
+    {
+        $address = trim($address);
+        if ($address === '') {
+            return '';
+        }
+
+        return ucwords(strtolower($address));
+    }
+}
diff --git a/app/Services/Auth/RegistrationService.php b/app/Services/Auth/RegistrationService.php
new file mode 100644
index 00000000..4db45a72
--- /dev/null
+++ b/app/Services/Auth/RegistrationService.php
@@ -0,0 +1,159 @@
+<?php
+
+namespace App\Services\Auth;
+
+use App\Models\Configuration;
+use App\Models\ParentModel;
+use App\Models\Role;
+use App\Models\User;
+use App\Models\UserRole;
+use App\Services\EmailService;
+use App\Services\SchoolIdService;
+use Illuminate\Support\Facades\DB;
+
+class RegistrationService
+{
+    public function __construct(
+        private EmailService $emailService,
+        private SchoolIdService $schoolIdService,
+        private RegistrationFormatterService $formatter,
+        private RegistrationCaptchaService $captchaService
+    ) {
+    }
+
+    public function register(array $payload): array
+    {
+        $captcha = (string) ($payload['captcha'] ?? '');
+        if (!$this->captchaService->verify($captcha)) {
+            return [
+                'ok' => false,
+                'code' => 'captcha_invalid',
+                'message' => 'Incorrect CAPTCHA answer. Please try again.',
+            ];
+        }
+
+        $isParent = !empty($payload['is_parent']);
+        $noSecondInfo = !empty($payload['no_second_parent_info']);
+
+        $formatted = $this->formatter->format($payload);
+        $email = (string) ($formatted['email'] ?? '');
+
+        $existing = User::query()->where('email', $email)->first();
+        if ($existing) {
+            $pending = !empty($existing->token) && (int) ($existing->is_verified ?? 0) === 0;
+            if ($pending) {
+                return [
+                    'ok' => false,
+                    'code' => 'pending_activation',
+                    'message' => 'This email address is already registered and pending activation.',
+                ];
+            }
+
+            return [
+                'ok' => false,
+                'code' => 'email_exists',
+                'message' => 'The email address you entered is already in use.',
+            ];
+        }
+
+        $roleName = $isParent ? 'parent' : 'guest';
+        $role = Role::query()->where('name', $roleName)->first();
+        if (!$role) {
+            return [
+                'ok' => false,
+                'code' => 'role_missing',
+                'message' => 'Role not found.',
+            ];
+        }
+
+        $token = bin2hex(random_bytes(48));
+        $schoolYear = Configuration::getConfig('school_year');
+        $semester = Configuration::getConfig('semester');
+
+        $userData = [
+            'firstname' => (string) ($formatted['firstname'] ?? ''),
+            'lastname' => (string) ($formatted['lastname'] ?? ''),
+            'gender' => (string) ($formatted['gender'] ?? ''),
+            'email' => $email,
+            'cellphone' => (string) ($formatted['cellphone'] ?? ($payload['cellphone'] ?? '')),
+            'address_street' => (string) ($formatted['address_street'] ?? ''),
+            'apt' => $formatted['apt'] ?? null,
+            'city' => (string) ($formatted['city'] ?? ''),
+            'state' => (string) ($formatted['state'] ?? ''),
+            'zip' => (string) ($formatted['zip'] ?? ''),
+            'token' => $token,
+            'is_verified' => 0,
+            'accept_school_policy' => (int) ($formatted['accept_school_policy'] ?? 0),
+            'status' => 'Inactive',
+            'school_id' => $this->schoolIdService->generateUserSchoolId(),
+            'semester' => (string) ($semester ?? ''),
+            'school_year' => $schoolYear,
+            'password' => pbkdf2_hash(bin2hex(random_bytes(8))),
+        ];
+
+        $user = null;
+
+        DB::transaction(function () use (
+            $userData,
+            $role,
+            $isParent,
+            $noSecondInfo,
+            $formatted,
+            $schoolYear,
+            $semester,
+            &$user
+        ) {
+            $user = User::query()->create($userData);
+
+            UserRole::query()->create([
+                'user_id' => (int) $user->id,
+                'role_id' => (int) $role->id,
+                'created_at' => now(),
+            ]);
+
+            if ($isParent && !$noSecondInfo && !empty($formatted['second_firstname'])) {
+                ParentModel::query()->create([
+                    'secondparent_firstname' => $formatted['second_firstname'] ?? null,
+                    'secondparent_lastname' => $formatted['second_lastname'] ?? null,
+                    'secondparent_gender' => $formatted['second_gender'] ?? null,
+                    'secondparent_email' => $formatted['second_email'] ?? null,
+                    'secondparent_phone' => $formatted['second_cellphone'] ?? null,
+                    'firstparent_id' => (int) $user->id,
+                    'semester' => $semester,
+                    'school_year' => $schoolYear,
+                ]);
+            }
+        });
+
+        $activationLink = url('/user/confirm/' . $token);
+        $recipientName = trim((string) ($formatted['firstname'] ?? '') . ' ' . (string) ($formatted['lastname'] ?? ''));
+
+        $emailData = [
+            'recipientName' => $recipientName,
+            'activationLink' => $activationLink,
+            'orgName' => 'Al Rahma Sunday School',
+            'contactInfo' => 'alrahma.isgl@gmail.com',
+            'logoUrl' => 'https://alrahmaisgl.org/assets/images/alrahma_logo.png',
+            'subject' => 'Email Confirmation',
+        ];
+
+        if (view()->exists($isParent ? 'emails.welcome_parent' : 'emails.welcome_staff')) {
+            $html = view($isParent ? 'emails.welcome_parent' : 'emails.welcome_staff', $emailData);
+        } else {
+            $html = '<p>Hello ' . e($recipientName !== '' ? $recipientName : 'there') . ',</p>'
+                . '<p>Please confirm your email by clicking the link below:</p>'
+                . '<p><a href="' . e($activationLink) . '">Activate your account</a></p>'
+                . '<p>Thank you.</p>';
+        }
+
+        $sent = $this->emailService->send($email, 'Email Confirmation', $html, 'general');
+        $this->captchaService->clear();
+
+        return [
+            'ok' => true,
+            'user' => $user,
+            'role' => $roleName,
+            'activation_sent' => $sent,
+        ];
+    }
+}
diff --git a/app/Services/BroadcastEmail/BroadcastEmailComposerService.php b/app/Services/BroadcastEmail/BroadcastEmailComposerService.php
new file mode 100644
index 00000000..538e2719
--- /dev/null
+++ b/app/Services/BroadcastEmail/BroadcastEmailComposerService.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Services\BroadcastEmail;
+
+use Illuminate\Support\Facades\View;
+
+class BroadcastEmailComposerService
+{
+    public function sanitizeHtml(string $html): string
+    {
+        $html = preg_replace('#<(script|iframe)[^>]*>.*?</\\1>#is', '', $html);
+        $html = preg_replace('/\\son\\w+="[^"]*"/i', '', $html);
+        $html = preg_replace("/\\son\\w+='[^']*'/i", '', $html);
+        return $html ?? '';
+    }
+
+    public function compose(
+        bool $wrapLayout,
+        string $subject,
+        string $body,
+        string $recipientName,
+        string $preheader = '',
+        string $ctaText = '',
+        string $ctaUrl = '',
+        bool $personalize = true
+    ): string {
+        $content = $personalize ? str_replace('{{name}}', $recipientName, $body) : $body;
+
+        if (!$wrapLayout) {
+            return $content;
+        }
+
+        if (!View::exists('emails.broadcast_wrapper')) {
+            return $content;
+        }
+
+        return view('emails.broadcast_wrapper', [
+            'subject' => $subject,
+            'content' => $content,
+            'preheader' => $preheader,
+            'cta_text' => $ctaText,
+            'cta_url' => $ctaUrl,
+        ])->render();
+    }
+}
diff --git a/app/Services/BroadcastEmail/BroadcastEmailDispatchService.php b/app/Services/BroadcastEmail/BroadcastEmailDispatchService.php
new file mode 100644
index 00000000..5962317c
--- /dev/null
+++ b/app/Services/BroadcastEmail/BroadcastEmailDispatchService.php
@@ -0,0 +1,81 @@
+<?php
+
+namespace App\Services\BroadcastEmail;
+
+use App\Services\EmailService;
+
+class BroadcastEmailDispatchService
+{
+    private EmailService $mailer;
+    private BroadcastEmailComposerService $composer;
+
+    public function __construct(EmailService $mailer, BroadcastEmailComposerService $composer)
+    {
+        $this->mailer = $mailer;
+        $this->composer = $composer;
+    }
+
+    public function sendTest(array $payload): array
+    {
+        $html = $this->composer->compose(
+            (bool) $payload['wrap_layout'],
+            $payload['subject'],
+            $payload['body_html'],
+            $payload['recipient_name'],
+            $payload['preheader'],
+            $payload['cta_text'],
+            $payload['cta_url'],
+            (bool) $payload['personalize']
+        );
+
+        $ok = $this->mailer->send(
+            $payload['test_email'],
+            '[TEST] ' . $payload['subject'],
+            $html,
+            $payload['from_key']
+        );
+
+        return [
+            'ok' => $ok,
+            'message' => $ok
+                ? "Test email sent to {$payload['test_email']}."
+                : 'Test email failed (mailer->send() returned false). Check logs.',
+        ];
+    }
+
+    public function sendBroadcast(array $payload, array $recipients): array
+    {
+        $stats = [
+            'attempted' => 0,
+            'sent' => 0,
+            'failed' => 0,
+            'mode' => $payload['mode'],
+        ];
+
+        foreach ($recipients as $recipient) {
+            $stats['attempted']++;
+            $recipientName = $recipient['name'] ?: 'Parent';
+            $html = $this->composer->compose(
+                (bool) $payload['wrap_layout'],
+                $payload['subject'],
+                $payload['body_html'],
+                $recipientName,
+                $payload['preheader'],
+                $payload['cta_text'],
+                $payload['cta_url'],
+                (bool) $payload['personalize']
+            );
+
+            $ok = $this->mailer->send(
+                (string) $recipient['email'],
+                $payload['subject'],
+                $html,
+                $payload['from_key']
+            );
+
+            $ok ? $stats['sent']++ : $stats['failed']++;
+        }
+
+        return $stats;
+    }
+}
diff --git a/app/Services/BroadcastEmail/BroadcastEmailImageService.php b/app/Services/BroadcastEmail/BroadcastEmailImageService.php
new file mode 100644
index 00000000..8e1a0b5f
--- /dev/null
+++ b/app/Services/BroadcastEmail/BroadcastEmailImageService.php
@@ -0,0 +1,51 @@
+<?php
+
+namespace App\Services\BroadcastEmail;
+
+use Illuminate\Http\UploadedFile;
+
+class BroadcastEmailImageService
+{
+    private const MAX_SIZE_BYTES = 5242880;
+
+    private array $allowedTypes = [
+        'image/jpeg' => 'jpg',
+        'image/png' => 'png',
+        'image/gif' => 'gif',
+        'image/webp' => 'webp',
+    ];
+
+    public function store(UploadedFile $file): array
+    {
+        $mime = strtolower((string) $file->getMimeType());
+        if (!isset($this->allowedTypes[$mime])) {
+            return [
+                'ok' => false,
+                'status' => 415,
+                'error' => 'Unsupported image type',
+            ];
+        }
+
+        if ($file->getSize() > self::MAX_SIZE_BYTES) {
+            return [
+                'ok' => false,
+                'status' => 413,
+                'error' => 'Image too large (max 5MB)',
+            ];
+        }
+
+        $targetDir = public_path('uploads/email');
+        if (!is_dir($targetDir)) {
+            @mkdir($targetDir, 0755, true);
+        }
+
+        $ext = $this->allowedTypes[$mime];
+        $newName = uniqid('em_', true) . '.' . $ext;
+        $file->move($targetDir, $newName);
+
+        return [
+            'ok' => true,
+            'url' => asset('uploads/email/' . $newName),
+        ];
+    }
+}
diff --git a/app/Services/BroadcastEmail/BroadcastEmailRecipientService.php b/app/Services/BroadcastEmail/BroadcastEmailRecipientService.php
new file mode 100644
index 00000000..0649ef0a
--- /dev/null
+++ b/app/Services/BroadcastEmail/BroadcastEmailRecipientService.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Services\BroadcastEmail;
+
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+
+class BroadcastEmailRecipientService
+{
+    public function parentsWithEmails(): array
+    {
+        $parents = User::getParents();
+
+        return array_values(array_filter($parents, static function ($parent) {
+            $email = $parent['email'] ?? '';
+            return is_string($email) && trim($email) !== '';
+        }));
+    }
+
+    public function recipientsByIds(array $ids): array
+    {
+        $ids = array_values(array_unique(array_filter(array_map('intval', $ids))));
+        if (empty($ids)) {
+            return [];
+        }
+
+        return DB::table('users')
+            ->select('users.id', 'users.email', DB::raw('CONCAT(users.firstname, " ", users.lastname) AS name'))
+            ->whereIn('users.id', $ids)
+            ->whereNotNull('users.email')
+            ->where('users.email', '!=', '')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+}
diff --git a/app/Services/BroadcastEmail/BroadcastEmailSenderOptionsService.php b/app/Services/BroadcastEmail/BroadcastEmailSenderOptionsService.php
new file mode 100644
index 00000000..0a39cae1
--- /dev/null
+++ b/app/Services/BroadcastEmail/BroadcastEmailSenderOptionsService.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace App\Services\BroadcastEmail;
+
+class BroadcastEmailSenderOptionsService
+{
+    public function listOptions(): array
+    {
+        $json = env('MAIL_SENDERS', '{}');
+        $arr = json_decode($json, true);
+
+        if (!is_array($arr) || empty($arr)) {
+            $smtpUser = getenv('SMTP_USER') ?: '';
+            $name = 'Al Rahma Sunday School';
+            return [[
+                'key' => 'general',
+                'label' => $name . ($smtpUser ? " <{$smtpUser}>" : ''),
+            ]];
+        }
+
+        $out = [];
+        foreach ($arr as $key => $info) {
+            $name = $info['name'] ?? 'Sender';
+            $email = $info['email'] ?? '';
+            $out[] = [
+                'key' => (string) $key,
+                'label' => trim($name . ($email ? " <{$email}>" : '')),
+            ];
+        }
+
+        return $out;
+    }
+}
diff --git a/app/Services/ClassPrep/ClassRosterService.php b/app/Services/ClassPrep/ClassRosterService.php
new file mode 100644
index 00000000..163ac3b4
--- /dev/null
+++ b/app/Services/ClassPrep/ClassRosterService.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Services\ClassPrep;
+
+use App\Models\Configuration;
+use Illuminate\Support\Facades\DB;
+
+class ClassRosterService
+{
+    public function listStudentsByClass(int $classSectionId, ?string $schoolYear = null): array
+    {
+        $schoolYear = $schoolYear && trim($schoolYear) !== ''
+            ? $schoolYear
+            : (string) Configuration::getConfig('school_year');
+
+        return DB::table('students')
+            ->select(
+                'students.id',
+                'students.firstname',
+                'students.lastname',
+                'students.gender',
+                'cs.class_section_name AS registration_grade'
+            )
+            ->join('student_class as sc', 'sc.student_id', '=', 'students.id')
+            ->join('classSection as cs', 'cs.class_section_id', '=', 'sc.class_section_id')
+            ->where('sc.school_year', $schoolYear)
+            ->where('sc.class_section_id', $classSectionId)
+            ->groupBy(
+                'students.id',
+                'students.firstname',
+                'students.lastname',
+                'students.gender',
+                'cs.class_section_name'
+            )
+            ->orderBy('students.firstname', 'ASC')
+            ->orderBy('students.lastname', 'ASC')
+            ->limit(1000)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->toArray();
+    }
+}
diff --git a/app/Services/ClassPrep/StickerCountService.php b/app/Services/ClassPrep/StickerCountService.php
new file mode 100644
index 00000000..288e58e5
--- /dev/null
+++ b/app/Services/ClassPrep/StickerCountService.php
@@ -0,0 +1,161 @@
+<?php
+
+namespace App\Services\ClassPrep;
+
+use App\Models\Configuration;
+use Illuminate\Support\Facades\DB;
+
+class StickerCountService
+{
+    public function listAll(?string $schoolYear = null, ?string $semester = null): array
+    {
+        $schoolYear = $this->resolveSchoolYear($schoolYear);
+        $semester = $this->resolveSemester($semester);
+
+        return $this->buildStickerCounts($schoolYear, $semester, null, $this->specialMapWithKg());
+    }
+
+    public function listForClass(?string $schoolYear, ?string $semester, int $classSectionId): array
+    {
+        $schoolYear = $this->resolveSchoolYear($schoolYear);
+        $semester = $this->resolveSemester($semester);
+
+        return $this->buildStickerCounts($schoolYear, $semester, $classSectionId, $this->specialMapWithoutKg());
+    }
+
+    private function resolveSchoolYear(?string $schoolYear): string
+    {
+        return $schoolYear && trim($schoolYear) !== ''
+            ? $schoolYear
+            : (string) Configuration::getConfig('school_year');
+    }
+
+    private function resolveSemester(?string $semester): string
+    {
+        return $semester && trim($semester) !== ''
+            ? $semester
+            : (string) Configuration::getConfig('semester');
+    }
+
+    private function buildStickerCounts(string $schoolYear, string $semester, ?int $classSectionId, array $specialMap): array
+    {
+        $builder = DB::table('student_class as sc')
+            ->select(
+                'sc.student_id',
+                's.firstname',
+                's.lastname',
+                's.is_new',
+                'cs.class_section_name AS grade_label'
+            )
+            ->join('students as s', 's.id', '=', 'sc.student_id')
+            ->join('classSection as cs', 'cs.class_section_id', '=', 'sc.class_section_id')
+            ->join('classes as c', 'c.id', '=', 'cs.class_id')
+            ->where('sc.school_year', $schoolYear);
+
+        if ($classSectionId !== null && $classSectionId > 0) {
+            $builder->where('sc.class_section_id', $classSectionId);
+        }
+
+        $rows = $builder->get()->toArray();
+
+        $students = [];
+        $totalPrimary = 0;
+        $totalSecondary = 0;
+
+        foreach ($rows as $row) {
+            $grade = trim((string) ($row->grade_label ?? ''));
+            if ($grade === '' || $this->isYouth($grade)) {
+                continue;
+            }
+
+            $isNew = (int) ($row->is_new ?? 0) === 1;
+            [$primary, $secondary] = $this->calculateStickerCounts($grade, $isNew, $specialMap);
+
+            $totalPrimary += $primary;
+            $totalSecondary += $secondary;
+
+            $students[] = [
+                'student_id' => (int) ($row->student_id ?? 0),
+                'firstname' => trim((string) ($row->firstname ?? '')),
+                'lastname' => trim((string) ($row->lastname ?? '')),
+                'grade_label' => $grade,
+                'primary_count' => $primary,
+                'secondary_count' => $secondary,
+            ];
+        }
+
+        return [
+            'schoolYear' => $schoolYear,
+            'semester' => $semester,
+            'classSectionId' => $classSectionId,
+            'students' => $students,
+            'totals' => [
+                'primary' => $totalPrimary,
+                'secondary' => $totalSecondary,
+                'students' => count($students),
+            ],
+        ];
+    }
+
+    private function calculateStickerCounts(string $grade, bool $isNew, array $specialMap): array
+    {
+        $primary = 0;
+        $secondary = 0;
+
+        if (array_key_exists($grade, $specialMap)) {
+            $primary = (int) $specialMap[$grade];
+            $secondary = 0;
+        } elseif ($this->isUpperBlock($grade)) {
+            if ($isNew) {
+                $primary = 4;
+                $secondary = 0;
+            } else {
+                $primary = $this->isGrade5($grade) ? 3 : 2;
+                $secondary = max(0, 4 - $primary);
+            }
+        } else {
+            $primary = 4;
+            $secondary = 0;
+        }
+
+        return [$primary, $secondary];
+    }
+
+    private function isUpperBlock(string $grade): bool
+    {
+        return (bool) preg_match('/^(3|4|5|6|7|8)(-[AB])?$/', trim($grade));
+    }
+
+    private function isGrade5(string $grade): bool
+    {
+        return (bool) preg_match('/^5(\-|$)/', trim($grade));
+    }
+
+    private function isYouth(string $grade): bool
+    {
+        return (bool) preg_match('/^youth(?:\b|-)/i', trim($grade));
+    }
+
+    private function specialMapWithKg(): array
+    {
+        return [
+            'KG' => 1,
+            '1-A' => 3,
+            '1-B' => 4,
+            '2-A' => 5,
+            '2-B' => 5,
+            '9' => 2,
+        ];
+    }
+
+    private function specialMapWithoutKg(): array
+    {
+        return [
+            '1-A' => 3,
+            '1-B' => 4,
+            '2-A' => 5,
+            '2-B' => 5,
+            '9' => 2,
+        ];
+    }
+}
diff --git a/app/Services/ClassPreparation/ClassPreparationAdjustmentService.php b/app/Services/ClassPreparation/ClassPreparationAdjustmentService.php
new file mode 100644
index 00000000..e2b2296e
--- /dev/null
+++ b/app/Services/ClassPreparation/ClassPreparationAdjustmentService.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace App\Services\ClassPreparation;
+
+use App\Models\ClassPrepAdjustment;
+
+class ClassPreparationAdjustmentService
+{
+    public function applyAdjustments(array $baseItems, string $classSectionId, string $schoolYear): array
+    {
+        $rawAdjustments = ClassPrepAdjustment::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('school_year', $schoolYear)
+            ->where('adjustable', 1)
+            ->get()
+            ->toArray();
+
+        $adjMap = ['Large Table' => 0, 'Small Table' => 0];
+        foreach ($rawAdjustments as $adjustment) {
+            $item = $adjustment['item_name'] ?? '';
+            $delta = (int) ($adjustment['adjustment'] ?? 0);
+            if (array_key_exists($item, $adjMap)) {
+                $adjMap[$item] = $delta;
+            }
+            if (isset($baseItems[$item])) {
+                $baseItems[$item] = max(0, (int) $baseItems[$item] + $delta);
+            }
+        }
+
+        return [$baseItems, $adjMap];
+    }
+}
diff --git a/app/Services/ClassPreparation/ClassPreparationCalculatorService.php b/app/Services/ClassPreparation/ClassPreparationCalculatorService.php
new file mode 100644
index 00000000..069cdbfc
--- /dev/null
+++ b/app/Services/ClassPreparation/ClassPreparationCalculatorService.php
@@ -0,0 +1,126 @@
+<?php
+
+namespace App\Services\ClassPreparation;
+
+use App\Models\ClassSection;
+use App\Models\Configuration;
+use Illuminate\Support\Facades\DB;
+
+class ClassPreparationCalculatorService
+{
+    private array $allowedPrepCategories = [
+        'Grade Box',
+        'Large Table',
+        'Regular Chair',
+        'Small Chair',
+        'Small Table',
+        'Teacher Chair',
+        'Trash Bin',
+        'White Board',
+    ];
+
+    public function getAllowedCategories(): array
+    {
+        return $this->allowedPrepCategories;
+    }
+
+    public function getClassLevelBySection(string $classSectionId): int
+    {
+        $sectionName = ClassSection::getClassSectionNameBySectionId($classSectionId);
+        $label = $sectionName !== null && $sectionName !== '' ? (string) $sectionName : $classSectionId;
+
+        if (preg_match('/^(kg|k)(\\b|[^a-z0-9])/i', $label)) {
+            return 1;
+        }
+
+        $numValue = (int) preg_replace('/\\D/', '', $label);
+
+        if ($numValue > 0 && $numValue < 30) {
+            $firstDigit = (int) substr((string) $numValue, 0, 1);
+            return $firstDigit === 1 ? 1 : ($firstDigit === 2 ? 2 : 3);
+        }
+
+        return 3;
+    }
+
+    public function calculatePrepItems(int $students, int $classLevel, string $classSectionId): array
+    {
+        $allowed = $this->allowedPrepCategories;
+        $items = array_fill_keys($allowed, 0);
+
+        $categories = DB::table('inventory_categories')
+            ->select('name', 'grade_min', 'grade_max')
+            ->where('type', 'classroom')
+            ->whereIn('name', $allowed)
+            ->orderBy('name')
+            ->get()
+            ->toArray();
+
+        $isLowerGrades = in_array($classLevel, [1, 2], true);
+        $teacherCount = $this->getTeacherCountForSection(
+            $classSectionId,
+            (string) Configuration::getConfig('school_year')
+        );
+
+        foreach ($categories as $cat) {
+            $name = (string) $cat->name;
+            $gradeMin = $cat->grade_min ?? null;
+            $gradeMax = $cat->grade_max ?? null;
+
+            if ($gradeMin !== null && $classLevel < (int) $gradeMin) {
+                $items[$name] = 0;
+                continue;
+            }
+            if ($gradeMax !== null && $classLevel > (int) $gradeMax) {
+                $items[$name] = 0;
+                continue;
+            }
+
+            $qty = 0;
+            switch (strtolower($name)) {
+                case 'small table':
+                    $qty = $isLowerGrades ? (int) ceil($students / 3) : 0;
+                    break;
+                case 'large table':
+                    $qty = $isLowerGrades ? 0 : (int) ceil($students / 4);
+                    break;
+                case 'small chair':
+                    $qty = $isLowerGrades ? $students : 0;
+                    break;
+                case 'regular chair':
+                    $qty = $isLowerGrades ? 0 : $students;
+                    break;
+                case 'teacher chair':
+                    $qty = (int) $teacherCount;
+                    break;
+                case 'trash bin':
+                case 'white board':
+                case 'grade box':
+                    $qty = 1;
+                    break;
+                default:
+                    $qty = 0;
+            }
+
+            if (array_key_exists($name, $items)) {
+                $items[$name] = $qty;
+            }
+        }
+
+        return $items;
+    }
+
+    private function getTeacherCountForSection(string $classSectionId, ?string $schoolYear = null): int
+    {
+        $schoolYear = $schoolYear ?: (string) Configuration::getConfig('school_year');
+
+        $row = DB::table('teacher_class')
+            ->select('COUNT(*) AS cnt')
+            ->where('class_section_id', $classSectionId)
+            ->whereIn('position', ['main', 'ta'])
+            ->where('school_year', $schoolYear)
+            ->first();
+
+        return (int) ($row->cnt ?? 0);
+    }
+}
diff --git a/app/Services/ClassPreparation/ClassPreparationContextService.php b/app/Services/ClassPreparation/ClassPreparationContextService.php
new file mode 100644
index 00000000..a3d80999
--- /dev/null
+++ b/app/Services/ClassPreparation/ClassPreparationContextService.php
@@ -0,0 +1,44 @@
+<?php
+
+namespace App\Services\ClassPreparation;
+
+use App\Models\Configuration;
+use Illuminate\Support\Facades\DB;
+
+class ClassPreparationContextService
+{
+    /** cache for roster presence per term */
+    private array $rosterPresenceCache = [];
+
+    public function getSchoolYear(): string
+    {
+        return (string) (Configuration::getConfig('school_year') ?? '');
+    }
+
+    public function getSemester(): string
+    {
+        return (string) (Configuration::getConfig('semester') ?? '');
+    }
+
+    public function hasRosterForSemester(string $schoolYear, string $semester): bool
+    {
+        $year = trim((string) $schoolYear);
+        $sem = trim((string) $semester);
+        if ($year === '' || $sem === '') {
+            return false;
+        }
+
+        $key = sprintf('sem:%s:%s', $year, $sem);
+        if (array_key_exists($key, $this->rosterPresenceCache)) {
+            return $this->rosterPresenceCache[$key];
+        }
+
+        $cnt = DB::table('student_class')
+            ->where('school_year', $year)
+            ->where('semester', $sem)
+            ->count();
+
+        $this->rosterPresenceCache[$key] = $cnt > 0;
+        return $this->rosterPresenceCache[$key];
+    }
+}
diff --git a/app/Services/ClassPreparation/ClassPreparationInventoryService.php b/app/Services/ClassPreparation/ClassPreparationInventoryService.php
new file mode 100644
index 00000000..f3d0f4fd
--- /dev/null
+++ b/app/Services/ClassPreparation/ClassPreparationInventoryService.php
@@ -0,0 +1,54 @@
+<?php
+
+namespace App\Services\ClassPreparation;
+
+use Illuminate\Support\Facades\DB;
+
+class ClassPreparationInventoryService
+{
+    public function buildAvailability(string $schoolYear, string $semester, bool $limitToSemester, array $allowed): array
+    {
+        $inventoryMap = array_fill_keys($allowed, 0);
+
+        $joinRows = DB::table('inventory_items as ii')
+            ->select('ic.name AS item_name, COALESCE(SUM(CASE WHEN ii.good_qty IS NOT NULL THEN ii.good_qty WHEN ii.`condition`=\"good\" THEN ii.quantity ELSE 0 END),0) AS available')
+            ->join('inventory_categories as ic', 'ic.id', '=', 'ii.category_id')
+            ->where('ii.type', 'classroom')
+            ->where('ii.school_year', $schoolYear)
+            ->whereIn('ic.name', $allowed);
+
+        if ($limitToSemester && $semester !== '') {
+            $joinRows->where('ii.semester', $semester);
+        }
+
+        $joinRows = $joinRows->groupBy('ic.name')->get()->toArray();
+
+        foreach ($joinRows as $r) {
+            $name = (string) ($r->item_name ?? '');
+            if ($name !== '' && isset($inventoryMap[$name])) {
+                $inventoryMap[$name] = max($inventoryMap[$name], (int) ($r->available ?? 0));
+            }
+        }
+
+        $nameRows = DB::table('inventory_items')
+            ->select('name AS item_name, COALESCE(SUM(CASE WHEN good_qty IS NOT NULL THEN good_qty WHEN `condition`=\"good\" THEN quantity ELSE 0 END),0) AS available')
+            ->where('type', 'classroom')
+            ->where('school_year', $schoolYear)
+            ->whereIn('name', $allowed);
+
+        if ($limitToSemester && $semester !== '') {
+            $nameRows->where('semester', $semester);
+        }
+
+        $nameRows = $nameRows->groupBy('name')->get()->toArray();
+
+        foreach ($nameRows as $r) {
+            $name = (string) ($r->item_name ?? '');
+            if ($name !== '' && isset($inventoryMap[$name])) {
+                $inventoryMap[$name] = max($inventoryMap[$name], (int) ($r->available ?? 0));
+            }
+        }
+
+        return $inventoryMap;
+    }
+}
diff --git a/app/Services/ClassPreparation/ClassPreparationLogService.php b/app/Services/ClassPreparation/ClassPreparationLogService.php
new file mode 100644
index 00000000..23d51b96
--- /dev/null
+++ b/app/Services/ClassPreparation/ClassPreparationLogService.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Services\ClassPreparation;
+
+use App\Models\ClassPreparationLog;
+
+class ClassPreparationLogService
+{
+    public function getLatestLog(string $classSectionId, string $schoolYear): ?ClassPreparationLog
+    {
+        return ClassPreparationLog::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('school_year', $schoolYear)
+            ->orderBy('created_at', 'DESC')
+            ->first();
+    }
+
+    public function hasPrepChanged(array $new, array $old): bool
+    {
+        ksort($new);
+        ksort($old);
+
+        return json_encode($new) !== json_encode($old);
+    }
+
+    public function createLog(string $classSectionId, string $className, string $schoolYear, array $items, string $createdAt): bool
+    {
+        try {
+            ClassPreparationLog::query()->create([
+                'class_section_id' => $classSectionId,
+                'class_section' => $className,
+                'school_year' => $schoolYear,
+                'prep_data' => json_encode($items),
+                'created_at' => $createdAt,
+            ]);
+            return true;
+        } catch (\Throwable $e) {
+            return false;
+        }
+    }
+}
diff --git a/app/Services/ClassPreparation/ClassPreparationRosterService.php b/app/Services/ClassPreparation/ClassPreparationRosterService.php
new file mode 100644
index 00000000..2439c178
--- /dev/null
+++ b/app/Services/ClassPreparation/ClassPreparationRosterService.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace App\Services\ClassPreparation;
+
+use Illuminate\Support\Facades\DB;
+
+class ClassPreparationRosterService
+{
+    public function getClassSectionStudentCounts(string $schoolYear, string $semester, bool $limitToSemester): array
+    {
+        $query = DB::table('student_class as sc')
+            ->select('sc.class_section_id, COUNT(DISTINCT sc.student_id) AS student_count', false)
+            ->join('students as s', 's.id', '=', 'sc.student_id')
+            ->where('s.is_active', 1)
+            ->where('sc.school_year', $schoolYear);
+
+        if ($limitToSemester && $semester !== '') {
+            $query->where('sc.semester', $semester);
+        }
+
+        return $query->groupBy('sc.class_section_id')->get()->toArray();
+    }
+
+    public function getStudentCountForSection(string $schoolYear, string $semester, bool $limitToSemester, string $classSectionId): int
+    {
+        $query = DB::table('student_class as sc')
+            ->select('COUNT(DISTINCT sc.student_id) AS cnt', false)
+            ->join('students as s', 's.id', '=', 'sc.student_id')
+            ->where('s.is_active', 1)
+            ->where('sc.class_section_id', $classSectionId)
+            ->where('sc.school_year', $schoolYear);
+
+        if ($limitToSemester && $semester !== '') {
+            $query->where('sc.semester', $semester);
+        }
+
+        $row = $query->first();
+        return (int) ($row->cnt ?? 0);
+    }
+}
diff --git a/app/Services/ClassPreparation/ClassPreparationService.php b/app/Services/ClassPreparation/ClassPreparationService.php
new file mode 100644
index 00000000..dc20a7f4
--- /dev/null
+++ b/app/Services/ClassPreparation/ClassPreparationService.php
@@ -0,0 +1,121 @@
+<?php
+
+namespace App\Services\ClassPreparation;
+
+use App\Models\ClassSection;
+
+class ClassPreparationService
+{
+    private ClassPreparationContextService $context;
+    private ClassPreparationRosterService $roster;
+    private ClassPreparationInventoryService $inventory;
+    private ClassPreparationCalculatorService $calculator;
+    private ClassPreparationAdjustmentService $adjustments;
+    private ClassPreparationLogService $logs;
+
+    public function __construct(
+        ClassPreparationContextService $context,
+        ClassPreparationRosterService $roster,
+        ClassPreparationInventoryService $inventory,
+        ClassPreparationCalculatorService $calculator,
+        ClassPreparationAdjustmentService $adjustments,
+        ClassPreparationLogService $logs
+    ) {
+        $this->context = $context;
+        $this->roster = $roster;
+        $this->inventory = $inventory;
+        $this->calculator = $calculator;
+        $this->adjustments = $adjustments;
+        $this->logs = $logs;
+    }
+
+    public function listPrep(?string $schoolYear = null, ?string $semester = null): array
+    {
+        $schoolYear = $schoolYear ?: $this->context->getSchoolYear();
+        $semester = $semester ?: $this->context->getSemester();
+        $allowed = $this->calculator->getAllowedCategories();
+        $limitToSemester = $this->context->hasRosterForSemester($schoolYear, $semester);
+
+        $classSections = $this->roster->getClassSectionStudentCounts($schoolYear, $semester, $limitToSemester);
+
+        $inventoryMap = $this->inventory->buildAvailability($schoolYear, $semester, $limitToSemester, $allowed);
+        $requiredTotals = array_fill_keys($allowed, 0);
+        $results = [];
+
+        foreach ($classSections as $row) {
+            $classSectionId = (string) $row->class_section_id;
+            $studentCount = (int) $row->student_count;
+            $classLevel = $this->calculator->getClassLevelBySection($classSectionId);
+            $className = ClassSection::getClassSectionNameBySectionId($classSectionId);
+
+            $baseItems = $this->calculator->calculatePrepItems($studentCount, $classLevel, $classSectionId);
+            [$baseItems, $adjMap] = $this->adjustments->applyAdjustments($baseItems, $classSectionId, $schoolYear);
+
+            foreach ($allowed as $cat) {
+                $requiredTotals[$cat] += (int) ($baseItems[$cat] ?? 0);
+            }
+
+            $oldSnap = $this->logs->getLatestLog($classSectionId, $schoolYear);
+            $oldPrep = $oldSnap ? (array) ($oldSnap->prep_data ?? []) : [];
+            $hasChanged = $this->logs->hasPrepChanged($baseItems, $oldPrep);
+
+            $results[] = [
+                'class_section'    => $className,
+                'class_section_id' => $classSectionId,
+                'student_count'    => $studentCount,
+                'class_level'      => $classLevel,
+                'prep_items'       => $baseItems,
+                'needs_print'      => $hasChanged,
+                'last_printed_at'  => $oldSnap?->created_at,
+                'adjustments'      => $adjMap,
+            ];
+        }
+
+        $shortages = [];
+        foreach ($requiredTotals as $item => $reqQty) {
+            $have = (int) ($inventoryMap[$item] ?? 0);
+            if ($have < (int) $reqQty) {
+                $shortages[$item] = (int) $reqQty - $have;
+            }
+        }
+
+        return [
+            'schoolYear' => $schoolYear,
+            'semester' => $semester,
+            'results' => $results,
+            'totals' => $requiredTotals,
+            'shortages' => $shortages,
+        ];
+    }
+
+    public function markPrinted(string $schoolYear, string $semester, array $classSectionIds): int
+    {
+        $limitToSemester = $this->context->hasRosterForSemester($schoolYear, $semester);
+        $ids = array_values(array_unique(array_filter(array_map('strval', $classSectionIds))));
+        $now = $this->utcNow();
+        $count = 0;
+
+        foreach ($ids as $classSectionId) {
+            $studentCount = $this->roster->getStudentCountForSection($schoolYear, $semester, $limitToSemester, $classSectionId);
+            $classLevel = $this->calculator->getClassLevelBySection($classSectionId);
+            $className = ClassSection::getClassSectionNameBySectionId($classSectionId) ?? $classSectionId;
+
+            $items = $this->calculator->calculatePrepItems($studentCount, $classLevel, $classSectionId);
+            [$items] = $this->adjustments->applyAdjustments($items, $classSectionId, $schoolYear);
+
+            if ($this->logs->createLog($classSectionId, $className, $schoolYear, $items, $now)) {
+                $count++;
+            }
+        }
+
+        return $count;
+    }
+
+    private function utcNow(): string
+    {
+        if (function_exists('utc_now')) {
+            return (string) utc_now();
+        }
+        return now('UTC')->toDateTimeString();
+    }
+}
diff --git a/app/Services/Communication/CommunicationFamilyService.php b/app/Services/Communication/CommunicationFamilyService.php
new file mode 100644
index 00000000..af849bb0
--- /dev/null
+++ b/app/Services/Communication/CommunicationFamilyService.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace App\Services\Communication;
+
+use App\Models\FamilyStudent;
+use Illuminate\Support\Facades\DB;
+
+class CommunicationFamilyService
+{
+    public function familiesForStudent(int $studentId): array
+    {
+        return FamilyStudent::getFamiliesForStudent($studentId);
+    }
+
+    public function guardiansForFamily(int $familyId): array
+    {
+        return DB::table('family_guardians as fg')
+            ->join('users as u', 'u.id', '=', 'fg.user_id')
+            ->where('fg.family_id', $familyId)
+            ->select(
+                'u.id as user_id',
+                'u.firstname',
+                'u.lastname',
+                'u.email',
+                'fg.relation',
+                'fg.is_primary',
+                'fg.receive_emails',
+                'fg.receive_sms'
+            )
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+
+    public function guardianSalutation(int $familyId): string
+    {
+        $rows = DB::table('family_guardians as fg')
+            ->join('users as u', 'u.id', '=', 'fg.user_id')
+            ->where('fg.family_id', $familyId)
+            ->where('fg.receive_emails', 1)
+            ->orderByDesc('fg.is_primary')
+            ->orderBy('u.lastname')
+            ->orderBy('u.firstname')
+            ->select('u.firstname', 'u.lastname')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        if (empty($rows)) {
+            return 'Parent/Guardian';
+        }
+
+        $names = array_map(static function ($row) {
+            return trim(($row['firstname'] ?? '') . ' ' . ($row['lastname'] ?? ''));
+        }, $rows);
+
+        return implode(' & ', $names);
+    }
+}
diff --git a/app/Services/Communication/CommunicationLogService.php b/app/Services/Communication/CommunicationLogService.php
new file mode 100644
index 00000000..f6bca614
--- /dev/null
+++ b/app/Services/Communication/CommunicationLogService.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\Communication;
+
+use App\Models\CommunicationLog;
+use Illuminate\Support\Facades\Schema;
+
+class CommunicationLogService
+{
+    public function log(array $payload): void
+    {
+        if (!Schema::hasTable('communication_logs')) {
+            return;
+        }
+
+        CommunicationLog::query()->create($payload);
+    }
+}
diff --git a/app/Services/Communication/CommunicationPreviewService.php b/app/Services/Communication/CommunicationPreviewService.php
new file mode 100644
index 00000000..0539b745
--- /dev/null
+++ b/app/Services/Communication/CommunicationPreviewService.php
@@ -0,0 +1,84 @@
+<?php
+
+namespace App\Services\Communication;
+
+class CommunicationPreviewService
+{
+    private CommunicationTemplateService $templates;
+    private CommunicationStudentService $students;
+    private CommunicationFamilyService $families;
+
+    public function __construct(
+        CommunicationTemplateService $templates,
+        CommunicationStudentService $students,
+        CommunicationFamilyService $families
+    ) {
+        $this->templates = $templates;
+        $this->students = $students;
+        $this->families = $families;
+    }
+
+    public function buildPreview(
+        string $templateKey,
+        int $studentId,
+        int $familyId,
+        array $vars,
+        string $teacherName
+    ): array {
+        $template = $this->templates->findTemplateByKey($templateKey);
+        if (!$template) {
+            return [
+                'ok' => false,
+                'status' => 404,
+                'message' => 'Template not found',
+            ];
+        }
+
+        $student = $this->students->getStudentBasic($studentId);
+        if (!$student) {
+            return [
+                'ok' => false,
+                'status' => 404,
+                'message' => 'Student not found',
+            ];
+        }
+
+        $salutation = $this->families->guardianSalutation($familyId);
+
+        $autoVars = [
+            'student_fullname' => trim(($student['firstname'] ?? '') . ' ' . ($student['lastname'] ?? '')),
+            'student_grade' => $student['grade'] ?? '',
+            'parent_salutation' => $salutation,
+            'date' => $this->formatLocalDate('Y-m-d'),
+            'school_name' => 'Al Rahma Sunday School',
+            'teacher_name' => $teacherName !== '' ? $teacherName : 'Teacher',
+        ];
+
+        $allVars = array_merge($autoVars, $vars);
+
+        $subject = $this->renderTwig($template['subject'], $allVars);
+        $body = $this->renderTwig($template['body'], $allVars);
+
+        return [
+            'ok' => true,
+            'subject' => $subject,
+            'html' => nl2br($body),
+        ];
+    }
+
+    private function renderTwig(string $template, array $vars): string
+    {
+        return (string) preg_replace_callback('/\\{\\{\\s*([a-zA-Z0-9_\\.]+)\\s*\\}\\}/', function ($m) use ($vars) {
+            $key = $m[1];
+            return htmlspecialchars((string) ($vars[$key] ?? ''), ENT_QUOTES, 'UTF-8');
+        }, $template);
+    }
+
+    private function formatLocalDate(string $format): string
+    {
+        if (function_exists('local_date') && function_exists('utc_now')) {
+            return (string) local_date(utc_now(), $format);
+        }
+        return now()->format($format);
+    }
+}
diff --git a/app/Services/Communication/CommunicationSendService.php b/app/Services/Communication/CommunicationSendService.php
new file mode 100644
index 00000000..c045a9a8
--- /dev/null
+++ b/app/Services/Communication/CommunicationSendService.php
@@ -0,0 +1,97 @@
+<?php
+
+namespace App\Services\Communication;
+
+use App\Services\EmailService;
+
+class CommunicationSendService
+{
+    private EmailService $mailer;
+    private CommunicationLogService $logService;
+
+    public function __construct(EmailService $mailer, CommunicationLogService $logService)
+    {
+        $this->mailer = $mailer;
+        $this->logService = $logService;
+    }
+
+    public function send(array $payload): array
+    {
+        $recipients = $this->normalizeEmails($payload['recipients'] ?? []);
+        $cc = $this->normalizeEmails($payload['cc'] ?? []);
+        $bcc = $this->normalizeEmails($payload['bcc'] ?? []);
+
+        if (empty($recipients)) {
+            $this->logService->log([
+                'student_id' => (int) $payload['student_id'],
+                'family_id' => (int) $payload['family_id'],
+                'student_name' => (string) $payload['student_name'],
+                'template_key' => (string) $payload['template_key'],
+                'subject' => (string) $payload['subject'],
+                'body' => (string) $payload['body'],
+                'recipients' => [],
+                'cc' => array_values($cc),
+                'bcc' => array_values($bcc),
+                'status' => 'failed',
+                'error_message' => 'No recipients provided',
+                'sent_by' => (int) ($payload['sent_by'] ?? 0),
+                'metadata' => null,
+            ]);
+
+            return [
+                'ok' => false,
+                'error' => 'No recipients provided',
+            ];
+        }
+
+        $sendOk = false;
+        $error = null;
+
+        try {
+            $sendOk = $this->mailer->send(
+                $recipients,
+                (string) $payload['subject'],
+                (string) $payload['body'],
+                'general',
+                $cc,
+                $bcc
+            );
+        } catch (\Throwable $t) {
+            $error = $t->getMessage();
+            $sendOk = false;
+        }
+
+        if (!$sendOk && $error === null) {
+            $error = 'Mailer returned false';
+        }
+
+        $this->logService->log([
+            'student_id' => (int) $payload['student_id'],
+            'family_id' => (int) $payload['family_id'],
+            'student_name' => (string) $payload['student_name'],
+            'template_key' => (string) $payload['template_key'],
+            'subject' => (string) $payload['subject'],
+            'body' => (string) $payload['body'],
+            'recipients' => array_values($recipients),
+            'cc' => array_values($cc),
+            'bcc' => array_values($bcc),
+            'status' => $sendOk ? 'sent' : 'failed',
+            'error_message' => $error,
+            'sent_by' => (int) ($payload['sent_by'] ?? 0),
+            'metadata' => null,
+        ]);
+
+        return [
+            'ok' => $sendOk,
+            'error' => $error,
+        ];
+    }
+
+    private function normalizeEmails(array $values): array
+    {
+        $out = array_values(array_unique(array_filter(array_map('strval', $values))));
+        return array_values(array_filter($out, static function ($email) {
+            return $email !== '';
+        }));
+    }
+}
diff --git a/app/Services/Communication/CommunicationStudentService.php b/app/Services/Communication/CommunicationStudentService.php
new file mode 100644
index 00000000..00c59790
--- /dev/null
+++ b/app/Services/Communication/CommunicationStudentService.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace App\Services\Communication;
+
+use Illuminate\Support\Facades\DB;
+
+class CommunicationStudentService
+{
+    public function listStudents(): array
+    {
+        return DB::table('students')
+            ->select('id', 'firstname', 'lastname', 'registration_grade')
+            ->orderBy('lastname', 'asc')
+            ->orderBy('firstname', 'asc')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+
+    public function getStudentBasic(int $studentId): ?array
+    {
+        $row = DB::table('students as s')
+            ->leftJoin('student_class as sc', 'sc.student_id', '=', 's.id')
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'sc.class_section_id')
+            ->select(
+                's.id',
+                's.firstname',
+                's.lastname',
+                's.registration_grade',
+                'cs.class_section_name as class_section_name'
+            )
+            ->where('s.id', $studentId)
+            ->orderBy('sc.id', 'desc')
+            ->first();
+
+        if (!$row) {
+            return null;
+        }
+
+        $row = (array) $row;
+        $grade = $row['registration_grade'] ?? '';
+        if (!$grade && !empty($row['class_section_name'])) {
+            $grade = $row['class_section_name'];
+        }
+
+        return [
+            'id' => (int) $row['id'],
+            'firstname' => (string) ($row['firstname'] ?? ''),
+            'lastname' => (string) ($row['lastname'] ?? ''),
+            'grade' => (string) ($grade ?? ''),
+        ];
+    }
+}
diff --git a/app/Services/Communication/CommunicationTemplateService.php b/app/Services/Communication/CommunicationTemplateService.php
new file mode 100644
index 00000000..372c8da6
--- /dev/null
+++ b/app/Services/Communication/CommunicationTemplateService.php
@@ -0,0 +1,57 @@
+<?php
+
+namespace App\Services\Communication;
+
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+class CommunicationTemplateService
+{
+    public function listActiveTemplates(): array
+    {
+        [$keyColumn, $bodyColumn] = $this->resolveTemplateColumns();
+
+        return DB::table('email_templates')
+            ->where('is_active', 1)
+            ->orderBy($keyColumn, 'asc')
+            ->get()
+            ->map(function ($row) use ($keyColumn, $bodyColumn) {
+                $row = (array) $row;
+                return [
+                    'template_key' => (string) ($row[$keyColumn] ?? ''),
+                    'subject' => (string) ($row['subject'] ?? ''),
+                    'body' => (string) ($row[$bodyColumn] ?? ''),
+                ];
+            })
+            ->all();
+    }
+
+    public function findTemplateByKey(string $key): ?array
+    {
+        [$keyColumn, $bodyColumn] = $this->resolveTemplateColumns();
+
+        $row = DB::table('email_templates')
+            ->where($keyColumn, $key)
+            ->where('is_active', 1)
+            ->first();
+
+        if (!$row) {
+            return null;
+        }
+
+        $row = (array) $row;
+
+        return [
+            'template_key' => (string) ($row[$keyColumn] ?? ''),
+            'subject' => (string) ($row['subject'] ?? ''),
+            'body' => (string) ($row[$bodyColumn] ?? ''),
+        ];
+    }
+
+    private function resolveTemplateColumns(): array
+    {
+        $keyColumn = Schema::hasColumn('email_templates', 'template_key') ? 'template_key' : 'code';
+        $bodyColumn = Schema::hasColumn('email_templates', 'body') ? 'body' : 'body_html';
+        return [$keyColumn, $bodyColumn];
+    }
+}
diff --git a/app/Services/CompetitionScores/CompetitionScoresContextService.php b/app/Services/CompetitionScores/CompetitionScoresContextService.php
new file mode 100644
index 00000000..f89f75d6
--- /dev/null
+++ b/app/Services/CompetitionScores/CompetitionScoresContextService.php
@@ -0,0 +1,73 @@
+<?php
+
+namespace App\Services\CompetitionScores;
+
+use App\Models\ClassSection;
+use App\Models\Configuration;
+use App\Models\TeacherClass;
+
+class CompetitionScoresContextService
+{
+    public function getTeacherContext(int $userId): array
+    {
+        $schoolYear = (string) (Configuration::getConfig('school_year') ?? '');
+        $semester = (string) (Configuration::getConfig('semester') ?? '');
+        $assignments = TeacherClass::getClassAssignmentsByUserId($userId, $schoolYear, $semester);
+
+        return [$assignments, $schoolYear, $semester];
+    }
+
+    public function getAllowedClassIds(array $assignments): array
+    {
+        $ids = array_map(static function ($row) {
+            return (int) ($row['class_section_id'] ?? 0);
+        }, $assignments);
+
+        return array_values(array_filter(array_unique($ids)));
+    }
+
+    public function resolveActiveClassId(array $assignments, int $requestedClassId = 0): int
+    {
+        $allowed = $this->getAllowedClassIds($assignments);
+        if ($requestedClassId > 0 && in_array($requestedClassId, $allowed, true)) {
+            return $requestedClassId;
+        }
+
+        return (int) ($allowed[0] ?? 0);
+    }
+
+    public function getActiveClassName(array $assignments, int $classSectionId): ?string
+    {
+        if ($classSectionId <= 0) {
+            return null;
+        }
+
+        foreach ($assignments as $row) {
+            if ((int) ($row['class_section_id'] ?? 0) === $classSectionId) {
+                return $row['class_section_name'] ?? null;
+            }
+        }
+
+        return ClassSection::getClassSectionNameBySectionId($classSectionId);
+    }
+
+    public function getClassSectionMap(): array
+    {
+        $sections = ClassSection::query()
+            ->select('class_section_id', 'class_section_name')
+            ->orderBy('class_section_name', 'ASC')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $map = [];
+        foreach ($sections as $section) {
+            $id = (int) ($section['class_section_id'] ?? 0);
+            if ($id > 0) {
+                $map[$id] = $section['class_section_name'] ?? (string) $id;
+            }
+        }
+
+        return $map;
+    }
+}
diff --git a/app/Services/CompetitionScores/CompetitionScoresQueryService.php b/app/Services/CompetitionScores/CompetitionScoresQueryService.php
new file mode 100644
index 00000000..e59d0adf
--- /dev/null
+++ b/app/Services/CompetitionScores/CompetitionScoresQueryService.php
@@ -0,0 +1,118 @@
+<?php
+
+namespace App\Services\CompetitionScores;
+
+use App\Models\Competition;
+use App\Models\CompetitionClassWinner;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+class CompetitionScoresQueryService
+{
+    public function getCompetitionsForClass(int $classSectionId, string $schoolYear, string $semester): array
+    {
+        $builder = Competition::query()->orderBy('id', 'DESC');
+
+        if ($classSectionId > 0) {
+            $builder->where(function ($q) use ($classSectionId) {
+                $q->where('class_section_id', $classSectionId)
+                    ->orWhere('class_section_id', 0)
+                    ->orWhereNull('class_section_id');
+            });
+        }
+
+        if ($schoolYear !== '') {
+            $builder->where(function ($q) use ($schoolYear) {
+                $q->where('school_year', $schoolYear)
+                    ->orWhere('school_year', '')
+                    ->orWhereNull('school_year');
+            });
+        }
+
+        if ($semester !== '') {
+            $builder->where(function ($q) use ($semester) {
+                $q->where('semester', $semester)
+                    ->orWhere('semester', '')
+                    ->orWhereNull('semester');
+            });
+        }
+
+        return $builder->get()->map(fn ($row) => (array) $row)->all();
+    }
+
+    public function getQuestionCounts(array $competitionIds, int $classSectionId): array
+    {
+        if (!$this->hasQuestionCount() || empty($competitionIds)) {
+            return [];
+        }
+
+        $rows = CompetitionClassWinner::query()
+            ->select('competition_id', 'question_count')
+            ->where('class_section_id', $classSectionId)
+            ->whereIn('competition_id', $competitionIds)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $out = [];
+        foreach ($rows as $row) {
+            $compId = (int) ($row['competition_id'] ?? 0);
+            if ($compId > 0 && $row['question_count'] !== null) {
+                $out[$compId] = (int) $row['question_count'];
+            }
+        }
+
+        return $out;
+    }
+
+    public function getScoreCounts(array $competitionIds, int $classSectionId): array
+    {
+        if (empty($competitionIds)) {
+            return [];
+        }
+
+        $rows = DB::table('competition_scores')
+            ->selectRaw('competition_id, COUNT(*) AS total')
+            ->where('class_section_id', $classSectionId)
+            ->whereIn('competition_id', $competitionIds)
+            ->groupBy('competition_id')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $out = [];
+        foreach ($rows as $row) {
+            $compId = (int) ($row['competition_id'] ?? 0);
+            if ($compId > 0) {
+                $out[$compId] = (int) ($row['total'] ?? 0);
+            }
+        }
+
+        return $out;
+    }
+
+    public function getQuestionCountForCompetition(int $competitionId, int $classSectionId): ?int
+    {
+        if (!$this->hasQuestionCount()) {
+            return null;
+        }
+
+        $row = CompetitionClassWinner::query()
+            ->select('question_count')
+            ->where('competition_id', $competitionId)
+            ->where('class_section_id', $classSectionId)
+            ->first();
+
+        if ($row && $row->question_count !== null) {
+            return (int) $row->question_count;
+        }
+
+        return null;
+    }
+
+    private function hasQuestionCount(): bool
+    {
+        return Schema::hasTable('competition_class_winners')
+            && Schema::hasColumn('competition_class_winners', 'question_count');
+    }
+}
diff --git a/app/Services/CompetitionScores/CompetitionScoresRosterService.php b/app/Services/CompetitionScores/CompetitionScoresRosterService.php
new file mode 100644
index 00000000..06727500
--- /dev/null
+++ b/app/Services/CompetitionScores/CompetitionScoresRosterService.php
@@ -0,0 +1,67 @@
+<?php
+
+namespace App\Services\CompetitionScores;
+
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+class CompetitionScoresRosterService
+{
+    private string $classStudentTable;
+
+    public function __construct()
+    {
+        if (Schema::hasTable('class_student')) {
+            $this->classStudentTable = 'class_student';
+        } elseif (Schema::hasTable('student_class')) {
+            $this->classStudentTable = 'student_class';
+        } else {
+            $this->classStudentTable = '';
+        }
+    }
+
+    public function getClassStudentCount(int $classSectionId, ?string $schoolYear): int
+    {
+        if ($classSectionId <= 0 || $this->classStudentTable === '') {
+            return 0;
+        }
+
+        $builder = DB::table($this->classStudentTable)
+            ->selectRaw('COUNT(*) AS total')
+            ->where('class_section_id', $classSectionId);
+
+        if ($schoolYear && Schema::hasColumn($this->classStudentTable, 'school_year')) {
+            $builder->where('school_year', $schoolYear);
+        }
+
+        $row = (array) $builder->first();
+        return (int) ($row['total'] ?? 0);
+    }
+
+    public function getStudentsForCompetition(array $competition, int $classSectionId): array
+    {
+        if ($classSectionId <= 0 || $this->classStudentTable === '') {
+            return [];
+        }
+
+        $builder = DB::table('students as s')
+            ->select('s.id', 's.school_id', 's.firstname', 's.lastname')
+            ->join($this->classStudentTable . ' as cs', 'cs.student_id', '=', 's.id')
+            ->where('cs.class_section_id', $classSectionId);
+
+        if (Schema::hasColumn($this->classStudentTable, 'school_year')) {
+            $schoolYear = (string) ($competition['school_year'] ?? '');
+            if ($schoolYear !== '') {
+                $builder->where('cs.school_year', $schoolYear);
+            }
+        }
+
+        return $builder
+            ->distinct()
+            ->orderBy('s.lastname', 'ASC')
+            ->orderBy('s.firstname', 'ASC')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+}
diff --git a/app/Services/CompetitionScores/CompetitionScoresSaveService.php b/app/Services/CompetitionScores/CompetitionScoresSaveService.php
new file mode 100644
index 00000000..ce9305fb
--- /dev/null
+++ b/app/Services/CompetitionScores/CompetitionScoresSaveService.php
@@ -0,0 +1,63 @@
+<?php
+
+namespace App\Services\CompetitionScores;
+
+use App\Models\CompetitionScore;
+
+class CompetitionScoresSaveService
+{
+    public function filterScores(array $scores): array
+    {
+        $cleanScores = [];
+        $invalidScores = [];
+
+        foreach ($scores as $studentId => $scoreValue) {
+            $scoreValue = trim((string) $scoreValue);
+            if ($scoreValue === '') {
+                continue;
+            }
+            if (!preg_match('/^\\d+$/', $scoreValue)) {
+                $invalidScores[] = (int) $studentId;
+                continue;
+            }
+            $cleanScores[(int) $studentId] = (int) $scoreValue;
+        }
+
+        return [$cleanScores, $invalidScores];
+    }
+
+    public function saveScores(int $competitionId, int $classSectionId, array $scores): void
+    {
+        foreach ($scores as $studentId => $scoreValue) {
+            CompetitionScore::query()->updateOrCreate(
+                [
+                    'competition_id' => $competitionId,
+                    'student_id' => (int) $studentId,
+                    'class_section_id' => $classSectionId,
+                ],
+                [
+                    'score' => (int) $scoreValue,
+                    'class_section_id' => $classSectionId,
+                ]
+            );
+        }
+    }
+
+    public function getScoreMap(int $competitionId, int $classSectionId): array
+    {
+        $rows = CompetitionScore::query()
+            ->select('student_id', 'score')
+            ->where('competition_id', $competitionId)
+            ->where('class_section_id', $classSectionId)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $map = [];
+        foreach ($rows as $row) {
+            $map[(int) $row['student_id']] = $row['score'];
+        }
+
+        return $map;
+    }
+}
diff --git a/app/Services/Discounts/DiscountApplyService.php b/app/Services/Discounts/DiscountApplyService.php
new file mode 100644
index 00000000..01c10c39
--- /dev/null
+++ b/app/Services/Discounts/DiscountApplyService.php
@@ -0,0 +1,294 @@
+<?php
+
+namespace App\Services\Discounts;
+
+use App\Models\DiscountVoucher;
+use App\Models\Invoice;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+
+class DiscountApplyService
+{
+    private DiscountContextService $context;
+    private DiscountInvoiceService $invoiceService;
+
+    public function __construct(DiscountContextService $context, DiscountInvoiceService $invoiceService)
+    {
+        $this->context = $context;
+        $this->invoiceService = $invoiceService;
+    }
+
+    public function applyVoucher(int $voucherId, array $parentIds, bool $allowAdditional, int $actorId): array
+    {
+        $schoolYear = $this->context->getSchoolYear();
+        $semester = $this->context->getSemester();
+
+        $voucher = DiscountVoucher::query()->find($voucherId);
+        if (!$voucher) {
+            return ['ok' => false, 'message' => 'Voucher not found.'];
+        }
+
+        $voucherDescription = trim((string) ($voucher->description ?? ''));
+        $voucherDescription = preg_replace(
+            '/^Auto-generated on \\d{4}-\\d{2}-\\d{2}\\s*[—-]\\s*reason:\\s*/i',
+            '',
+            $voucherDescription
+        );
+
+        $maxUsesRaw = $voucher->max_uses;
+        $maxUses = ($maxUsesRaw === null || $maxUsesRaw === '') ? null : (int) $maxUsesRaw;
+        $timesUsed = (int) ($voucher->times_used ?? 0);
+        $remainingUses = ($maxUses === null) ? PHP_INT_MAX : ($maxUses - $timesUsed);
+        if ($remainingUses <= 0) {
+            return ['ok' => false, 'message' => 'This voucher has reached its maximum allowed uses.'];
+        }
+
+        if (!$allowAdditional) {
+            $rows = DB::table('discount_usages as du')
+                ->select('i.parent_id')
+                ->join('invoices as i', 'i.id', '=', 'du.invoice_id')
+                ->whereIn('i.parent_id', $parentIds)
+                ->where('i.school_year', $schoolYear)
+                ->groupBy('i.parent_id')
+                ->get()
+                ->map(fn ($row) => (array) $row)
+                ->all();
+
+            $blockedParentIds = array_map(static fn ($r) => (int) ($r['parent_id'] ?? 0), $rows);
+            if (!empty($blockedParentIds)) {
+                $parentIds = array_values(array_diff(array_map('intval', $parentIds), $blockedParentIds));
+            }
+            if (empty($parentIds)) {
+                return [
+                    'ok' => false,
+                    'message' => 'All selected parents already have discounts. Enable "Allow additional discounts" to apply another.',
+                ];
+            }
+        }
+
+        $paymentDate = function_exists('utc_now') ? utc_now() : now('UTC')->toDateTimeString();
+        $fullyCoveredInvoiceIds = [];
+        $touchedInvoiceIds = [];
+        $appliedCount = 0;
+
+        DB::beginTransaction();
+
+        try {
+            foreach ($parentIds as $parentId) {
+                $invoices = Invoice::getInvoicesByUserId((int) $parentId, $schoolYear);
+                if (empty($invoices)) {
+                    Log::warning('Discount apply: parent has no invoices', [
+                        'parent_id' => (int) $parentId,
+                        'voucher_id' => $voucherId,
+                    ]);
+                    continue;
+                }
+
+                foreach ($invoices as $invoice) {
+                    if ($remainingUses <= 0) {
+                        break 2;
+                    }
+
+                    $invoiceId = (int) ($invoice['id'] ?? 0);
+                    if ($invoiceId <= 0) {
+                        continue;
+                    }
+
+                    $initialPreBalance = (float) $this->invoiceService->getCurrentInvoiceBalance($invoiceId, $schoolYear);
+                    if ($initialPreBalance <= 0) {
+                        continue;
+                    }
+
+                    if (!$allowAdditional) {
+                        $exists = DB::table('discount_usages as du')
+                            ->join('invoices as i', 'du.invoice_id', '=', 'i.id')
+                            ->where('du.voucher_id', $voucherId)
+                            ->where('du.invoice_id', $invoiceId)
+                            ->where('i.school_year', $schoolYear)
+                            ->count();
+                        if ($exists) {
+                            continue;
+                        }
+                    }
+
+                    $rawDiscount = $voucher->discount_type === 'percent'
+                        ? round(((float) ($invoice['total_amount'] ?? 0) * (float) $voucher->discount_value) / 100, 2)
+                        : (float) $voucher->discount_value;
+
+                    $discount = min($rawDiscount, $initialPreBalance);
+                    if ($discount <= 0) {
+                        continue;
+                    }
+
+                    $now = function_exists('utc_now') ? utc_now() : now('UTC')->toDateTimeString();
+                    DB::table('discount_usages')->insert([
+                        'voucher_id' => $voucherId,
+                        'invoice_id' => $invoiceId,
+                        'parent_id' => (int) $parentId,
+                        'discount_amount' => $discount,
+                        'description' => $voucherDescription,
+                        'school_year' => $schoolYear,
+                        'updated_by' => $actorId,
+                        'used_at' => $now,
+                        'created_at' => $now,
+                        'updated_at' => $now,
+                        'semester' => $semester,
+                    ]);
+
+                    $newBalance = max(0.0, round($initialPreBalance - $discount, 2));
+                    DB::table('invoices')
+                        ->where('id', $invoiceId)
+                        ->update([
+                            'balance' => $newBalance,
+                            'has_discount' => 1,
+                            'updated_at' => $now,
+                        ]);
+
+                    $postBalance = round($initialPreBalance - $discount, 2);
+                    if ($postBalance < 0) {
+                        $postBalance = 0.0;
+                    }
+
+                    $currentBalance = (float) $this->invoiceService->getCurrentInvoiceBalance($invoiceId, $schoolYear);
+
+                    DB::table('discount_vouchers')
+                        ->where('id', $voucherId)
+                        ->update([
+                            'times_used' => DB::raw('COALESCE(times_used,0) + 1'),
+                        ]);
+
+                    $this->triggerPaymentReceived(
+                        $invoiceId,
+                        (string) $voucherId,
+                        $discount,
+                        $paymentDate,
+                        $initialPreBalance,
+                        $postBalance,
+                        $schoolYear,
+                        $semester
+                    );
+
+                    $touchedInvoiceIds[] = $invoiceId;
+                    $appliedCount++;
+
+                    $epsilon = 0.01;
+                    $fullyCovered = (abs($discount - $initialPreBalance) <= $epsilon)
+                        || ($postBalance <= $epsilon)
+                        || ($currentBalance <= $epsilon);
+
+                    if ($fullyCovered) {
+                        $fullyCoveredInvoiceIds[] = $invoiceId;
+                    }
+
+                    $remainingUses--;
+
+                    if ($remainingUses <= 0 && $maxUses !== null) {
+                        DB::table('discount_vouchers')
+                            ->where('id', $voucherId)
+                            ->update([
+                                'is_active' => 0,
+                                'updated_at' => $now,
+                            ]);
+                        break 2;
+                    }
+                }
+            }
+
+            DB::commit();
+        } catch (\Throwable $e) {
+            DB::rollBack();
+            return ['ok' => false, 'message' => 'Voucher application failed. Transaction rolled back.'];
+        }
+
+        if ($appliedCount === 0) {
+            return [
+                'ok' => false,
+                'message' => 'No discounts were applied. The voucher may already be used for these invoices or balances are zero.',
+            ];
+        }
+
+        if ($maxUses !== null) {
+            $row = (array) DB::table('discount_vouchers')
+                ->select('times_used')
+                ->where('id', $voucherId)
+                ->first();
+            $usedNow = (int) ($row['times_used'] ?? 0);
+            if ($usedNow >= $maxUses) {
+                DB::table('discount_vouchers')
+                    ->where('id', $voucherId)
+                    ->update([
+                        'is_active' => 0,
+                        'updated_at' => function_exists('utc_now') ? utc_now() : now('UTC')->toDateTimeString(),
+                    ]);
+            }
+        }
+
+        foreach (array_unique($touchedInvoiceIds) as $iid) {
+            try {
+                $this->invoiceService->recalculateInvoice($iid, $schoolYear);
+            } catch (\Throwable $e) {
+                Log::error('recalculateInvoice failed for invoice {id}: {err}', [
+                    'id' => $iid,
+                    'err' => $e->getMessage(),
+                ]);
+            }
+        }
+
+        $updatedTotal = 0;
+        foreach (array_unique($fullyCoveredInvoiceIds) as $iid) {
+            try {
+                $updatedTotal += $this->invoiceService->updateEnrollmentStatusIfPaid($iid, $schoolYear);
+            } catch (\Throwable $e) {
+                Log::error('updateEnrollmentStatusIfPaid failed for invoice {id}: {err}', [
+                    'id' => $iid,
+                    'err' => $e->getMessage(),
+                ]);
+            }
+        }
+
+        return [
+            'ok' => true,
+            'message' => $updatedTotal > 0
+                ? 'Voucher applied successfully and enrollments updated.'
+                : 'Voucher applied successfully.',
+            'appliedCount' => $appliedCount,
+            'updatedEnrollments' => $updatedTotal,
+            'touchedInvoices' => array_values(array_unique($touchedInvoiceIds)),
+        ];
+    }
+
+    private function triggerPaymentReceived(
+        int $invoiceId,
+        string $voucherId,
+        float $amount,
+        string $paymentDate,
+        float $preBalance,
+        float $postBalance,
+        string $schoolYear,
+        string $semester
+    ): void {
+        try {
+            [$eventData, $studentData] = $this->invoiceService->buildPaymentEventData(
+                $invoiceId,
+                $voucherId,
+                $amount,
+                'discount',
+                $paymentDate,
+                '',
+                0,
+                $preBalance,
+                $postBalance,
+                $schoolYear,
+                $semester
+            );
+
+            if (class_exists(\CodeIgniter\Events\Events::class)) {
+                \CodeIgniter\Events\Events::trigger('paymentReceived', $eventData, $studentData);
+            } elseif (function_exists('event')) {
+                event('paymentReceived', [$eventData, $studentData]);
+            }
+        } catch (\Throwable $e) {
+            Log::warning('paymentReceived hook failed: ' . $e->getMessage());
+        }
+    }
+}
diff --git a/app/Services/Discounts/DiscountContextService.php b/app/Services/Discounts/DiscountContextService.php
new file mode 100644
index 00000000..b6327690
--- /dev/null
+++ b/app/Services/Discounts/DiscountContextService.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\Discounts;
+
+use App\Models\Configuration;
+
+class DiscountContextService
+{
+    public function getSchoolYear(): string
+    {
+        return (string) (Configuration::getConfig('school_year') ?? '');
+    }
+
+    public function getSemester(): string
+    {
+        return (string) (Configuration::getConfig('semester') ?? '');
+    }
+}
diff --git a/app/Services/Discounts/DiscountInvoiceService.php b/app/Services/Discounts/DiscountInvoiceService.php
new file mode 100644
index 00000000..4928794e
--- /dev/null
+++ b/app/Services/Discounts/DiscountInvoiceService.php
@@ -0,0 +1,394 @@
+<?php
+
+namespace App\Services\Discounts;
+
+use App\Models\AdditionalCharge;
+use App\Models\ClassSection;
+use App\Models\Configuration;
+use App\Models\Enrollment;
+use App\Models\EventCharges;
+use App\Models\Invoice;
+use App\Models\Payment;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+class DiscountInvoiceService
+{
+    public function getCurrentInvoiceBalance(int $invoiceId, string $schoolYear): float
+    {
+        $invoice = Invoice::query()->find($invoiceId);
+        if (!$invoice) {
+            return 0.0;
+        }
+
+        $paymentQuery = Payment::query()
+            ->selectRaw('COALESCE(SUM(paid_amount),0) AS total_paid')
+            ->where('invoice_id', $invoiceId)
+            ->where('school_year', $schoolYear);
+
+        if (Schema::hasColumn('payments', 'status')) {
+            $paymentQuery->where(function ($q) {
+                $q->whereNotIn('status', [
+                    'void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled',
+                ])->orWhereNull('status');
+            });
+        }
+
+        if (Schema::hasColumn('payments', 'is_void')) {
+            $paymentQuery->where(function ($q) {
+                $q->where('is_void', 0)->orWhereNull('is_void');
+            });
+        }
+
+        $rowPaid = (array) $paymentQuery->first();
+        $totalPaid = (float) ($rowPaid['total_paid'] ?? 0);
+
+        $rowDisc = (array) DB::table('discount_usages as du')
+            ->join('invoices as i', 'i.id', '=', 'du.invoice_id')
+            ->where('du.invoice_id', $invoiceId)
+            ->where('i.school_year', $schoolYear)
+            ->selectRaw('COALESCE(SUM(du.discount_amount),0) AS total_disc')
+            ->first();
+        $totalDisc = (float) ($rowDisc['total_disc'] ?? 0);
+
+        $rowRefund = (array) DB::table('refunds')
+            ->selectRaw('COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid')
+            ->where('invoice_id', $invoiceId)
+            ->where('school_year', $schoolYear)
+            ->whereIn('status', ['Partial', 'Paid'])
+            ->first();
+        $totalRefundPaid = (float) ($rowRefund['total_refund_paid'] ?? 0);
+
+        $total = (float) ($invoice->total_amount ?? 0);
+        return max(0.0, round($total - $totalPaid - $totalDisc - $totalRefundPaid, 2));
+    }
+
+    public function recalculateInvoice(int $invoiceId, string $schoolYear): void
+    {
+        $invoice = Invoice::query()->find($invoiceId);
+        if (!$invoice) {
+            return;
+        }
+
+        $parentId = (int) ($invoice->parent_id ?? 0);
+        if ($parentId <= 0) {
+            return;
+        }
+
+        $enrollments = Enrollment::query()
+            ->where('parent_id', $parentId)
+            ->where('school_year', $schoolYear)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $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;
+            }
+        }
+
+        $refundDeadline = (string) (Configuration::getConfig('refund_deadline') ?? '');
+        $refundAllowed = true;
+        if ($refundDeadline !== '') {
+            try {
+                $tzName = function_exists('user_timezone') ? (string) user_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);
+        }
+
+        $gradeFee = (int) (Configuration::getConfig('grade_fee') ?? 9);
+        $firstStudentFee = (float) (Configuration::getConfig('first_student_fee') ?? 350);
+        $secondStudentFee = (float) (Configuration::getConfig('second_student_fee') ?? 200);
+        $youthFee = (float) (Configuration::getConfig('youth_fee') ?? 180);
+
+        foreach ($tuitionStudents as &$s) {
+            $name = null;
+            if (!empty($s['class_section_id'])) {
+                $name = ClassSection::getClassSectionNameBySectionId($s['class_section_id']);
+            }
+            $s['grade_name'] = is_string($name) ? strtoupper(trim($name)) : 'N/A';
+        }
+        unset($s);
+
+        $regularCount = 0;
+        $youthCount = 0;
+        foreach ($tuitionStudents as $s) {
+            $lvl = $this->parseGradeLevel((string) ($s['grade_name'] ?? ''), $gradeFee);
+            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;
+        }
+
+        $eventSubtotal = 0.0;
+        $events = EventCharges::getChargesWithEventInfo($parentId, $schoolYear) ?? [];
+        foreach ($events as $ev) {
+            $eventSubtotal += (float) ($ev['charged'] ?? 0.0);
+        }
+
+        $additionalSubtotal = 0.0;
+        $rows = AdditionalCharge::query()
+            ->select('charge_type', 'amount')
+            ->where('invoice_id', $invoiceId)
+            ->where('status', 'applied')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        foreach ($rows as $r) {
+            $amt = (float) ($r['amount'] ?? 0);
+            $typ = strtolower((string) ($r['charge_type'] ?? 'add'));
+            $amt = $typ === 'deduct' ? -abs($amt) : abs($amt);
+            $additionalSubtotal += $amt;
+        }
+
+        $newTotal = round($tuitionSubtotal + $eventSubtotal + $additionalSubtotal, 2);
+
+        $paymentQuery = Payment::query()
+            ->where('invoice_id', $invoiceId)
+            ->where('school_year', $schoolYear);
+
+        if (Schema::hasColumn('payments', 'status')) {
+            $paymentQuery->where(function ($q) {
+                $q->whereNotIn('status', [
+                    'void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled',
+                ])->orWhereNull('status');
+            });
+        }
+        if (Schema::hasColumn('payments', 'is_void')) {
+            $paymentQuery->where(function ($q) {
+                $q->where('is_void', 0)->orWhereNull('is_void');
+            });
+        }
+
+        $payments = $paymentQuery->get()->map(fn ($row) => (array) $row)->all();
+        $totalPaid = 0.0;
+        foreach ($payments as $p) {
+            $totalPaid += (float) ($p['paid_amount'] ?? 0);
+        }
+
+        $discRow = (array) DB::table('discount_usages')
+            ->selectRaw('COALESCE(SUM(discount_amount),0) AS total_disc')
+            ->where('invoice_id', $invoiceId)
+            ->first();
+        $totalDisc = (float) ($discRow['total_disc'] ?? 0);
+
+        $refundRow = (array) DB::table('refunds')
+            ->selectRaw('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');
+
+        $updateData = [
+            'total_amount' => $newTotal,
+            'paid_amount' => $totalPaid,
+            'balance' => $newBalance,
+            'status' => $newStatus,
+            'has_discount' => $totalDisc > 0.0 ? 1 : 0,
+        ];
+
+        if (Schema::hasColumn('invoices', 'discount')) {
+            $updateData['discount'] = $totalDisc;
+        }
+
+        Invoice::query()->whereKey($invoiceId)->update($updateData);
+    }
+
+    public function updateEnrollmentStatusIfPaid(int $invoiceId, string $schoolYear): int
+    {
+        $invoice = Invoice::query()->find($invoiceId);
+        if (!$invoice) {
+            return 0;
+        }
+
+        $total = (float) ($invoice->total_amount ?? 0);
+        $balance = (float) ($invoice->balance ?? 0);
+        if (!($total > 0 && $balance < $total)) {
+            return 0;
+        }
+
+        $parentId = (int) ($invoice->parent_id ?? 0);
+        if ($parentId <= 0 || $schoolYear === '') {
+            return 0;
+        }
+
+        $paidEnrollmentIds = [];
+        if (Schema::hasTable('invoice_items') && Schema::hasColumn('invoice_items', 'enrollment_id')) {
+            $rows = DB::table('invoice_items')
+                ->select('enrollment_id')
+                ->where('invoice_id', $invoiceId)
+                ->whereNotNull('enrollment_id')
+                ->get()
+                ->map(fn ($row) => (array) $row)
+                ->all();
+
+            foreach ($rows as $r) {
+                $eid = (int) ($r['enrollment_id'] ?? 0);
+                if ($eid > 0) {
+                    $paidEnrollmentIds[] = $eid;
+                }
+            }
+        }
+
+        $query = Enrollment::query()
+            ->select('id')
+            ->where('parent_id', $parentId)
+            ->where('school_year', $schoolYear)
+            ->where(function ($q) {
+                $q->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'");
+            });
+
+        if (!empty($paidEnrollmentIds)) {
+            $query->whereIn('id', array_values(array_unique($paidEnrollmentIds)));
+        }
+
+        $toUpdateIds = $query->get()->pluck('id')->map(fn ($id) => (int) $id)->all();
+        if (empty($toUpdateIds)) {
+            return 0;
+        }
+
+        $affected = Enrollment::query()
+            ->whereIn('id', $toUpdateIds)
+            ->update([
+                'enrollment_status' => 'enrolled',
+                'enrollment_date' => $this->formatLocalDate('Y-m-d'),
+            ]);
+
+        return (int) $affected;
+    }
+
+    public function buildPaymentEventData(
+        int $invoiceId,
+        string $transactionIdOrRef,
+        float $amount,
+        string $paymentMethod,
+        string $paymentDate,
+        ?string $checkNumber,
+        int $installmentSeq,
+        float $preBalance,
+        float $postBalance,
+        string $schoolYear,
+        string $semester
+    ): array {
+        $invoice = Invoice::query()->find($invoiceId);
+        if (!$invoice) {
+            throw new \RuntimeException("Invoice {$invoiceId} not found");
+        }
+
+        $parentRow = (array) DB::table('users')
+            ->select('id', 'firstname', 'lastname', 'email')
+            ->where('id', $invoice->parent_id)
+            ->first();
+
+        if (empty($parentRow)) {
+            throw new \RuntimeException("Parent not found for invoice {$invoiceId}");
+        }
+
+        $studentRows = DB::table('students as s')
+            ->select('s.id', 's.firstname', 's.lastname', 'sc.class_section_id')
+            ->leftJoin('student_class as sc', 'sc.student_id', '=', 's.id')
+            ->where('s.parent_id', $invoice->parent_id)
+            ->where('sc.school_year', $schoolYear)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $data = [
+            'user_id' => (int) $parentRow['id'],
+            'email' => $parentRow['email'],
+            'firstname' => $parentRow['firstname'],
+            'lastname' => $parentRow['lastname'],
+            'school_year' => $schoolYear,
+            'semester' => $semester,
+            'invoice_id' => $invoiceId,
+            'transaction_id' => $transactionIdOrRef,
+            'payment_date' => $paymentDate,
+            'amount' => $amount,
+            'method' => $paymentMethod,
+            'check_number' => $checkNumber,
+            'installment_seq' => $installmentSeq,
+            'invoice_total' => (float) $invoice->total_amount,
+            'pre_balance' => $preBalance,
+            'post_balance' => $postBalance,
+            'portalLink' => url('parent/invoices/' . $invoiceId),
+        ];
+
+        return [$data, $studentRows];
+    }
+
+    private function parseGradeLevel(string $grade, int $gradeFee): int
+    {
+        if (is_numeric($grade)) {
+            return (int) $grade;
+        }
+        $g = strtoupper(trim($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;
+            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 formatLocalDate(string $format): string
+    {
+        if (function_exists('local_date') && function_exists('utc_now')) {
+            return (string) local_date(utc_now(), $format);
+        }
+        return now()->format($format);
+    }
+}
diff --git a/app/Services/Discounts/DiscountParentService.php b/app/Services/Discounts/DiscountParentService.php
new file mode 100644
index 00000000..959e8ab9
--- /dev/null
+++ b/app/Services/Discounts/DiscountParentService.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace App\Services\Discounts;
+
+use App\Models\DiscountUsage;
+use App\Models\User;
+
+class DiscountParentService
+{
+    public function listParentsWithDiscounts(string $schoolYear): array
+    {
+        $parents = User::getParents();
+
+        foreach ($parents as &$parent) {
+            $total = DiscountUsage::getTotalDiscountByParentIdAndSchoolYear(
+                (int) ($parent['id'] ?? 0),
+                $schoolYear
+            );
+
+            $parent['total_discount'] = $total;
+            $parent['has_discount'] = $total > 0 ? 1 : 0;
+        }
+        unset($parent);
+
+        return $parents;
+    }
+}
diff --git a/app/Services/Discounts/DiscountVoucherService.php b/app/Services/Discounts/DiscountVoucherService.php
new file mode 100644
index 00000000..068919f3
--- /dev/null
+++ b/app/Services/Discounts/DiscountVoucherService.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Services\Discounts;
+
+use App\Models\DiscountVoucher;
+
+class DiscountVoucherService
+{
+    public function listAll(): array
+    {
+        return DiscountVoucher::query()
+            ->orderByDesc('id')
+            ->get()
+            ->all();
+    }
+
+    public function listActive(): array
+    {
+        return DiscountVoucher::query()
+            ->where('is_active', 1)
+            ->orderByDesc('id')
+            ->get()
+            ->all();
+    }
+
+    public function create(array $payload): DiscountVoucher
+    {
+        return DiscountVoucher::query()->create($payload);
+    }
+
+    public function update(int $id, array $payload): DiscountVoucher
+    {
+        $voucher = DiscountVoucher::query()->findOrFail($id);
+        $voucher->fill($payload);
+        $voucher->save();
+        return $voucher;
+    }
+
+    public function find(int $id): DiscountVoucher
+    {
+        return DiscountVoucher::query()->findOrFail($id);
+    }
+
+    public function delete(int $id): void
+    {
+        DiscountVoucher::query()->whereKey($id)->delete();
+    }
+}
diff --git a/app/Services/EmailService.php b/app/Services/EmailService.php
new file mode 100644
index 00000000..6acf3238
--- /dev/null
+++ b/app/Services/EmailService.php
@@ -0,0 +1,63 @@
+<?php
+
+namespace App\Services;
+
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Mail;
+
+class EmailService
+{
+    public function send(
+        array|string $to,
+        string $subject,
+        string $html,
+        string $fromKey = 'general',
+        array $cc = [],
+        array $bcc = []
+    ): bool
+    {
+        $sender = $this->resolveSender($fromKey);
+
+        try {
+            Mail::html($html, function ($message) use ($to, $subject, $sender, $cc, $bcc) {
+                $message->to($to)->subject($subject);
+                if ($sender['email'] !== '') {
+                    $message->from($sender['email'], $sender['name']);
+                }
+                if (!empty($cc)) {
+                    $message->cc($cc);
+                }
+                if (!empty($bcc)) {
+                    $message->bcc($bcc);
+                }
+            });
+            return true;
+        } catch (\Throwable $e) {
+            Log::error('EmailService send failed: ' . $e->getMessage());
+            return false;
+        }
+    }
+
+    private function resolveSender(string $fromKey): array
+    {
+        $fromKey = $fromKey !== '' ? $fromKey : 'general';
+        $json = env('MAIL_SENDERS', '{}');
+        $senders = json_decode($json, true);
+
+        if (is_array($senders) && isset($senders[$fromKey])) {
+            $info = $senders[$fromKey];
+            return [
+                'name' => (string) ($info['name'] ?? 'Sender'),
+                'email' => (string) ($info['email'] ?? ''),
+            ];
+        }
+
+        $fallbackAddress = (string) (config('mail.from.address') ?: (getenv('SMTP_USER') ?: ''));
+        $fallbackName = (string) (config('mail.from.name') ?: 'Al Rahma Sunday School');
+
+        return [
+            'name' => $fallbackName,
+            'email' => $fallbackAddress,
+        ];
+    }
+}
diff --git a/app/Services/Expenses/ExpenseContextService.php b/app/Services/Expenses/ExpenseContextService.php
new file mode 100644
index 00000000..0d3ea360
--- /dev/null
+++ b/app/Services/Expenses/ExpenseContextService.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\Expenses;
+
+use App\Models\Configuration;
+
+class ExpenseContextService
+{
+    public function getSchoolYear(): string
+    {
+        return (string) (Configuration::getConfig('school_year') ?? '');
+    }
+
+    public function getSemester(): string
+    {
+        return (string) (Configuration::getConfig('semester') ?? '');
+    }
+}
diff --git a/app/Services/Expenses/ExpenseQueryService.php b/app/Services/Expenses/ExpenseQueryService.php
new file mode 100644
index 00000000..50804d96
--- /dev/null
+++ b/app/Services/Expenses/ExpenseQueryService.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Services\Expenses;
+
+use App\Models\Expense;
+use Illuminate\Support\Facades\DB;
+
+class ExpenseQueryService
+{
+    public function listAll(): array
+    {
+        return $this->baseQuery()
+            ->orderByDesc('expenses.created_at')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+
+    public function findById(int $id): ?array
+    {
+        $row = $this->baseQuery()
+            ->where('expenses.id', $id)
+            ->first();
+
+        return $row ? (array) $row : null;
+    }
+
+    private function baseQuery()
+    {
+        return Expense::query()
+            ->selectRaw('
+                expenses.*,
+                u.firstname AS purchaser_firstname,
+                u.lastname AS purchaser_lastname,
+                approver.firstname AS approver_firstname,
+                approver.lastname AS approver_lastname
+            ')
+            ->leftJoin('users as u', 'u.id', '=', 'expenses.purchased_by')
+            ->leftJoin('users as approver', 'approver.id', '=', 'expenses.approved_by');
+    }
+}
diff --git a/app/Services/Expenses/ExpenseReceiptService.php b/app/Services/Expenses/ExpenseReceiptService.php
new file mode 100644
index 00000000..d7e5e044
--- /dev/null
+++ b/app/Services/Expenses/ExpenseReceiptService.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Services\Expenses;
+
+use Illuminate\Http\UploadedFile;
+
+class ExpenseReceiptService
+{
+    public function storeReceipt(UploadedFile $file): string
+    {
+        $stored = $file->store('receipts');
+        return basename($stored);
+    }
+
+    public function receiptUrl(?string $filename): ?string
+    {
+        if (!$filename) {
+            return null;
+        }
+        return url('receipts/' . $filename);
+    }
+}
diff --git a/app/Services/Expenses/ExpenseRetailorService.php b/app/Services/Expenses/ExpenseRetailorService.php
new file mode 100644
index 00000000..a113d3fa
--- /dev/null
+++ b/app/Services/Expenses/ExpenseRetailorService.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace App\Services\Expenses;
+
+class ExpenseRetailorService
+{
+    public function listRetailors(): array
+    {
+        return [
+            'Amazon',
+            'Walmart',
+            'Costco',
+            "BJ's",
+            'Market Basket',
+            'Aldi',
+            'Hannaford',
+            "Sam's Club",
+            'HomeGoods',
+            'Hostinger',
+            'Wicked Cheesy',
+            'Shatila',
+            'Brothers Pizzeria',
+            'Paradise Biryani Pointe',
+            'Emad Leiman',
+            'Nova Trampoline Park',
+            "Lubin's Awards",
+            'Dollar Tree',
+            'Stop & Shop',
+            "Dunkin' Donuts",
+            "Giovanni's Pizza",
+            'Trader Joes',
+        ];
+    }
+}
diff --git a/app/Services/Expenses/ExpenseStaffService.php b/app/Services/Expenses/ExpenseStaffService.php
new file mode 100644
index 00000000..0a204b67
--- /dev/null
+++ b/app/Services/Expenses/ExpenseStaffService.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace App\Services\Expenses;
+
+use Illuminate\Support\Facades\DB;
+
+class ExpenseStaffService
+{
+    public function listStaffUsers(): array
+    {
+        $rows = DB::table('users')
+            ->select('users.id', 'users.firstname', 'users.lastname', 'roles.name AS role_name')
+            ->leftJoin('user_roles', 'user_roles.user_id', '=', 'users.id')
+            ->leftJoin('roles', 'roles.id', '=', 'user_roles.role_id')
+            ->whereNotNull('roles.name')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $excludedRoles = array_map('strtolower', ['parent', 'student', 'guest']);
+        $staff = [];
+
+        foreach ($rows as $row) {
+            $roleName = strtolower((string) ($row['role_name'] ?? ''));
+            $id = (int) ($row['id'] ?? 0);
+            if ($id <= 0 || in_array($roleName, $excludedRoles, true)) {
+                continue;
+            }
+            if (!isset($staff[$id])) {
+                $staff[$id] = [
+                    'id' => $id,
+                    'firstname' => $row['firstname'] ?? '',
+                    'lastname' => $row['lastname'] ?? '',
+                ];
+            }
+        }
+
+        uasort($staff, static function ($a, $b) {
+            $nameA = trim(($a['firstname'] ?? '') . ' ' . ($a['lastname'] ?? ''));
+            $nameB = trim(($b['firstname'] ?? '') . ' ' . ($b['lastname'] ?? ''));
+            return strcasecmp($nameA, $nameB);
+        });
+
+        return array_values($staff);
+    }
+}
diff --git a/app/Services/Expenses/ExpenseStatusService.php b/app/Services/Expenses/ExpenseStatusService.php
new file mode 100644
index 00000000..143ca2c3
--- /dev/null
+++ b/app/Services/Expenses/ExpenseStatusService.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Services\Expenses;
+
+use App\Models\Expense;
+
+class ExpenseStatusService
+{
+    public function updateStatus(Expense $expense, string $status, string $reason, int $userId): Expense
+    {
+        $expense->status = $status;
+        $expense->status_reason = $reason;
+        $expense->approved_by = $userId;
+        $expense->updated_by = $userId;
+        $expense->save();
+
+        return $expense;
+    }
+}
diff --git a/app/Services/Expenses/ExpenseWriteService.php b/app/Services/Expenses/ExpenseWriteService.php
new file mode 100644
index 00000000..0bea865d
--- /dev/null
+++ b/app/Services/Expenses/ExpenseWriteService.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Services\Expenses;
+
+use App\Models\Expense;
+
+class ExpenseWriteService
+{
+    public function __construct(private ExpenseContextService $context) {}
+
+    public function store(array $payload): Expense
+    {
+        $schoolYear = $payload['school_year'] ?? $this->context->getSchoolYear();
+        $semester = $payload['semester'] ?? $this->context->getSemester();
+
+        $data = [
+            'category' => $payload['category'],
+            'amount' => $payload['amount'],
+            'receipt_path' => $payload['receipt_path'] ?? null,
+            'description' => $payload['description'] ?? null,
+            'retailor' => $payload['retailor'] ?? null,
+            'date_of_purchase' => $payload['date_of_purchase'],
+            'purchased_by' => $payload['purchased_by'],
+            'added_by' => $payload['added_by'],
+            'status' => $payload['status'],
+            'status_reason' => $payload['status_reason'] ?? null,
+            'approved_by' => $payload['approved_by'] ?? null,
+            'school_year' => $schoolYear,
+            'semester' => $semester,
+        ];
+
+        return Expense::query()->create($data);
+    }
+
+    public function update(Expense $expense, array $payload): Expense
+    {
+        $expense->fill($payload);
+        $expense->save();
+        return $expense;
+    }
+}
diff --git a/app/Services/ExtraCharges/ExtraChargesChargeService.php b/app/Services/ExtraCharges/ExtraChargesChargeService.php
new file mode 100644
index 00000000..af80c2a0
--- /dev/null
+++ b/app/Services/ExtraCharges/ExtraChargesChargeService.php
@@ -0,0 +1,235 @@
+<?php
+
+namespace App\Services\ExtraCharges;
+
+use App\Models\AdditionalCharge;
+use App\Models\Invoice;
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+
+class ExtraChargesChargeService
+{
+    public function __construct(
+        private ExtraChargesContextService $context,
+        private ExtraChargesInvoiceService $invoiceService
+    ) {}
+
+    public function createCharge(array $payload): array
+    {
+        $invoiceId = $payload['invoice_id'] ?? null;
+        $chargeType = $payload['charge_type'];
+        $amountAbs = round(abs((float) $payload['amount']), 2);
+        $signedAmount = $chargeType === 'add' ? $amountAbs : -$amountAbs;
+        $schoolYear = $payload['school_year'] ?? $this->context->getSchoolYear();
+        $semester = $payload['semester'] ?? $this->context->getSemester();
+
+        $data = [
+            'parent_id' => (int) $payload['parent_id'],
+            'invoice_id' => $invoiceId,
+            'school_year' => $schoolYear,
+            'semester' => $semester,
+            'charge_type' => $chargeType,
+            'title' => trim($payload['title']),
+            'description' => trim((string) ($payload['description'] ?? '')),
+            'amount' => $signedAmount,
+            'due_date' => $payload['due_date'] ?? null,
+            'status' => $invoiceId ? 'applied' : 'pending',
+            'created_by' => (int) ($payload['created_by'] ?? 0),
+            'created_at' => $payload['created_at'] ?? $this->utcNow(),
+        ];
+
+        $invoiceBefore = $invoiceId ? Invoice::getInvoicesByParentId((int) $payload['parent_id'], $schoolYear) : [];
+        $invoiceAfter = [];
+
+        DB::beginTransaction();
+
+        try {
+            $chargeId = AdditionalCharge::query()->create($data)->id;
+
+            if ($invoiceId) {
+                $this->invoiceService->applyToInvoice((int) $invoiceId, $chargeType, $amountAbs);
+            }
+
+            $invoiceAfter = $invoiceId ? Invoice::getInvoicesByParentId((int) $payload['parent_id'], $schoolYear) : [];
+
+            DB::commit();
+        } catch (\Throwable $e) {
+            DB::rollBack();
+            Log::error('Extra charge create failed: ' . $e->getMessage());
+            return ['ok' => false, 'message' => 'Failed to save charge.'];
+        }
+
+        $parentUser = User::getUserInfoById((int) $payload['parent_id']);
+        $this->triggerExtraChargeEvent($parentUser, $data, (int) $chargeId, $invoiceId, $invoiceBefore, $invoiceAfter);
+
+        return [
+            'ok' => true,
+            'id' => (int) $chargeId,
+            'invoice_id' => $invoiceId ? (int) $invoiceId : null,
+            'parent_id' => (int) $payload['parent_id'],
+        ];
+    }
+
+    public function updateCharge(AdditionalCharge $charge, array $payload): bool
+    {
+        $chargeType = $payload['charge_type'] ?? $charge->charge_type ?? 'add';
+        $amountRaw = isset($payload['amount']) ? (float) $payload['amount'] : (float) $charge->amount;
+        $newAmount = $chargeType === 'add' ? abs($amountRaw) : -abs($amountRaw);
+        $delta = $newAmount - (float) $charge->amount;
+
+        DB::beginTransaction();
+
+        try {
+            $charge->title = trim($payload['title'] ?? $charge->title);
+            $charge->description = trim($payload['description'] ?? $charge->description);
+            $charge->amount = $newAmount;
+            $charge->due_date = $payload['due_date'] ?? $charge->due_date;
+            $charge->charge_type = $chargeType;
+            if (array_key_exists('updated_by', $payload)) {
+                $charge->updated_by = $payload['updated_by'];
+            }
+            $charge->save();
+
+            if ($charge->status === 'applied' && !empty($charge->invoice_id) && abs($delta) > 0.00001) {
+                $this->invoiceService->adjustDelta((int) $charge->invoice_id, $delta);
+            }
+
+            DB::commit();
+            return true;
+        } catch (\Throwable $e) {
+            DB::rollBack();
+            Log::error('Extra charge update failed: ' . $e->getMessage());
+            return false;
+        }
+    }
+
+    public function voidCharge(AdditionalCharge $charge): bool
+    {
+        DB::beginTransaction();
+
+        try {
+            $invoiceId = (int) ($charge->invoice_id ?? 0);
+            $amountAbs = round(abs((float) ($charge->amount ?? 0)), 2);
+            $chargeType = (string) ($charge->charge_type ?? 'add');
+            $status = (string) ($charge->status ?? 'pending');
+
+            if ($status === 'applied' && $invoiceId > 0 && $amountAbs > 0) {
+                $this->invoiceService->reverseOnInvoice($invoiceId, $chargeType, $amountAbs);
+            }
+
+            $charge->status = 'void';
+            $charge->save();
+
+            DB::commit();
+            return true;
+        } catch (\Throwable $e) {
+            DB::rollBack();
+            Log::error('Extra charge void failed: ' . $e->getMessage());
+            return false;
+        }
+    }
+
+    public function reverseCharge(AdditionalCharge $charge): bool
+    {
+        $invoiceId = (int) ($charge->invoice_id ?? 0);
+        $amountAbs = round(abs((float) ($charge->amount ?? 0)), 2);
+        $chargeType = (string) ($charge->charge_type ?? 'add');
+        $status = (string) ($charge->status ?? 'pending');
+
+        if ($status !== 'applied' || $invoiceId <= 0 || $amountAbs <= 0) {
+            return false;
+        }
+
+        DB::beginTransaction();
+
+        try {
+            $this->invoiceService->reverseOnInvoice($invoiceId, $chargeType, $amountAbs);
+
+            $charge->status = 'pending';
+            $charge->invoice_id = null;
+            $charge->save();
+
+            DB::commit();
+            return true;
+        } catch (\Throwable $e) {
+            DB::rollBack();
+            Log::error('Extra charge reverse failed: ' . $e->getMessage());
+            return false;
+        }
+    }
+
+    private function triggerExtraChargeEvent(?array $parentUser, array $payload, int $chargeId, ?int $invoiceId, array $invoiceBefore, array $invoiceAfter): void
+    {
+        if (!$parentUser) {
+            return;
+        }
+
+        $first = $parentUser['first_name'] ?? $parentUser['firstname'] ?? '';
+        $last = $parentUser['last_name'] ?? $parentUser['lastname'] ?? '';
+        $parentName = trim($first . ' ' . $last);
+
+        $before = $this->normalizeRow($invoiceBefore);
+        $after = $this->normalizeRow($invoiceAfter);
+
+        $invoiceTotal = $after ? (float) ($after['total_amount'] ?? 0) : 0.0;
+        $preBalance = $before ? (float) ($before['balance'] ?? 0) : 0.0;
+        $postBalance = $after ? (float) ($after['balance'] ?? 0) : 0.0;
+
+        $eventData = [
+            'user_id' => (int) ($parentUser['id'] ?? 0),
+            'email' => $parentUser['email'] ?? null,
+            'firstname' => $first,
+            'lastname' => $last,
+            'parentName' => $parentName,
+            'school_year' => $payload['school_year'],
+            'semester' => $payload['semester'],
+            'invoice_id' => $invoiceId,
+            'invoice_number' => $after['invoice_number'] ?? ($invoiceId ? 'INV-' . $invoiceId : null),
+            'charge_id' => $chargeId,
+            'charge_title' => $payload['title'],
+            'charge_desc' => $payload['description'],
+            'charge_type' => $payload['charge_type'],
+            'amount_signed' => $payload['amount'],
+            'amount_abs' => abs((float) $payload['amount']),
+            'due_date' => $payload['due_date'],
+            'created_at' => $payload['created_at'],
+            'pre_balance' => $preBalance,
+            'post_balance' => $postBalance,
+            'invoice_total' => $invoiceTotal,
+            'portal_link' => url('/login'),
+            'invoice_link' => $invoiceId ? url('parent/invoices/view/' . $invoiceId) : url('parent/invoices'),
+        ];
+
+        $students = [];
+
+        try {
+            if (class_exists(\CodeIgniter\Events\Events::class)) {
+                \CodeIgniter\Events\Events::trigger('extraCharge', $eventData, $students);
+            } elseif (function_exists('event')) {
+                event('extraCharge', [$eventData, $students]);
+            }
+        } catch (\Throwable $e) {
+            Log::warning('extraCharge event failed: ' . $e->getMessage());
+        }
+    }
+
+    private function normalizeRow($row): ?array
+    {
+        if (!$row) {
+            return null;
+        }
+        if (is_array($row) && isset($row[0]) && is_array($row[0])) {
+            return $row[0];
+        }
+        return is_array($row) ? $row : null;
+    }
+
+    private function utcNow(): string
+    {
+        if (function_exists('utc_now')) {
+            return (string) utc_now();
+        }
+        return now('UTC')->toDateTimeString();
+    }
+}
diff --git a/app/Services/ExtraCharges/ExtraChargesContextService.php b/app/Services/ExtraCharges/ExtraChargesContextService.php
new file mode 100644
index 00000000..00bc360a
--- /dev/null
+++ b/app/Services/ExtraCharges/ExtraChargesContextService.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\ExtraCharges;
+
+use App\Models\Configuration;
+
+class ExtraChargesContextService
+{
+    public function getSchoolYear(): string
+    {
+        return (string) (Configuration::getConfig('school_year') ?? '');
+    }
+
+    public function getSemester(): string
+    {
+        return (string) (Configuration::getConfig('semester') ?? '');
+    }
+}
diff --git a/app/Services/ExtraCharges/ExtraChargesInvoiceService.php b/app/Services/ExtraCharges/ExtraChargesInvoiceService.php
new file mode 100644
index 00000000..ddb6b12b
--- /dev/null
+++ b/app/Services/ExtraCharges/ExtraChargesInvoiceService.php
@@ -0,0 +1,75 @@
+<?php
+
+namespace App\Services\ExtraCharges;
+
+use App\Models\Invoice;
+
+class ExtraChargesInvoiceService
+{
+    public function listInvoicesForParent(int $parentId, string $schoolYear): array
+    {
+        if ($parentId <= 0) {
+            return [];
+        }
+
+        $rows = Invoice::getInvoicesByParentId($parentId, $schoolYear) ?? [];
+
+        return array_map(function ($inv) {
+            $id = (int) ($inv['id'] ?? 0);
+            $num = (string) ($inv['invoice_number'] ?? ('INV-' . $id));
+            $status = strtolower((string) ($inv['status'] ?? ''));
+            $balance = (float) ($inv['balance'] ?? 0);
+            $issue = $inv['issue_date'] ?? null;
+
+            return [
+                'id' => $id,
+                'invoice_number' => $num,
+                'status' => $status,
+                'balance' => $balance,
+                'issue_date' => $issue,
+                'text' => $num
+                    . ($status ? ' — ' . ucfirst($status) : '')
+                    . ' (Bal: $' . number_format($balance, 2) . ')',
+            ];
+        }, $rows);
+    }
+
+    public function applyToInvoice(int $invoiceId, string $chargeType, float $amountAbs): void
+    {
+        if ($invoiceId <= 0 || $amountAbs <= 0) {
+            return;
+        }
+
+        if ($chargeType === 'add') {
+            Invoice::applyAdditionalCharge($invoiceId, $amountAbs);
+        } else {
+            Invoice::deductAdditionalCharge($invoiceId, $amountAbs);
+        }
+    }
+
+    public function reverseOnInvoice(int $invoiceId, string $chargeType, float $amountAbs): void
+    {
+        if ($invoiceId <= 0 || $amountAbs <= 0) {
+            return;
+        }
+
+        if ($chargeType === 'add') {
+            Invoice::reverseAdditionalCharge($invoiceId, $amountAbs);
+        } else {
+            Invoice::applyAdditionalCharge($invoiceId, $amountAbs);
+        }
+    }
+
+    public function adjustDelta(int $invoiceId, float $delta): void
+    {
+        if ($invoiceId <= 0 || abs($delta) <= 0.00001) {
+            return;
+        }
+
+        if ($delta > 0) {
+            Invoice::applyAdditionalCharge($invoiceId, $delta);
+        } else {
+            Invoice::reverseAdditionalCharge($invoiceId, abs($delta));
+        }
+    }
+}
diff --git a/app/Services/ExtraCharges/ExtraChargesListService.php b/app/Services/ExtraCharges/ExtraChargesListService.php
new file mode 100644
index 00000000..17c6bd15
--- /dev/null
+++ b/app/Services/ExtraCharges/ExtraChargesListService.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Services\ExtraCharges;
+
+use App\Models\AdditionalCharge;
+
+class ExtraChargesListService
+{
+    public function listForTerm(string $schoolYear, string $semester, ?string $status, ?string $q, int $perPage): array
+    {
+        $rows = AdditionalCharge::listAllForTerm($schoolYear, $semester, $status, $q, $perPage);
+        $meta = [
+            'perPage' => method_exists($rows, 'perPage') ? $rows->perPage() : $perPage,
+            'page' => method_exists($rows, 'currentPage') ? $rows->currentPage() : null,
+            'total' => method_exists($rows, 'total') ? $rows->total() : null,
+            'pageCount' => method_exists($rows, 'lastPage') ? $rows->lastPage() : null,
+        ];
+
+        $items = method_exists($rows, 'items') ? $rows->items() : (array) $rows;
+
+        return [$items, $meta];
+    }
+}
diff --git a/app/Services/ExtraCharges/ExtraChargesMetaService.php b/app/Services/ExtraCharges/ExtraChargesMetaService.php
new file mode 100644
index 00000000..ae429e6a
--- /dev/null
+++ b/app/Services/ExtraCharges/ExtraChargesMetaService.php
@@ -0,0 +1,66 @@
+<?php
+
+namespace App\Services\ExtraCharges;
+
+use Illuminate\Support\Facades\DB;
+
+class ExtraChargesMetaService
+{
+    public function getSchoolYears(string $fallbackYear = ''): array
+    {
+        $schoolYears = [];
+
+        try {
+            $rows = DB::table('additional_charges')
+                ->selectRaw('DISTINCT school_year')
+                ->whereNotNull('school_year')
+                ->orderByDesc('school_year')
+                ->get()
+                ->map(fn ($row) => (array) $row)
+                ->all();
+
+            foreach ($rows as $row) {
+                $val = (string) ($row['school_year'] ?? '');
+                if ($val !== '' && !in_array($val, $schoolYears, true)) {
+                    $schoolYears[] = $val;
+                }
+            }
+        } catch (\Throwable $e) {
+        }
+
+        try {
+            $rows = DB::table('invoices')
+                ->selectRaw('DISTINCT school_year')
+                ->whereNotNull('school_year')
+                ->orderByDesc('school_year')
+                ->get()
+                ->map(fn ($row) => (array) $row)
+                ->all();
+
+            foreach ($rows as $row) {
+                $val = (string) ($row['school_year'] ?? '');
+                if ($val !== '' && !in_array($val, $schoolYears, true)) {
+                    $schoolYears[] = $val;
+                }
+            }
+        } catch (\Throwable $e) {
+        }
+
+        if (empty($schoolYears) && $fallbackYear !== '') {
+            $schoolYears[] = $fallbackYear;
+            if (str_contains($fallbackYear, '-')) {
+                [$start] = explode('-', $fallbackYear) + [0 => ''];
+                $start = (int) $start;
+                if ($start > 0) {
+                    for ($i = 1; $i <= 3; $i++) {
+                        $schoolYears[] = ($start - $i) . '-' . (($start - $i) + 1);
+                    }
+                }
+            }
+        }
+
+        rsort($schoolYears);
+
+        return array_values(array_unique($schoolYears));
+    }
+}
diff --git a/app/Services/ExtraCharges/ExtraChargesParentService.php b/app/Services/ExtraCharges/ExtraChargesParentService.php
new file mode 100644
index 00000000..d9b3ad37
--- /dev/null
+++ b/app/Services/ExtraCharges/ExtraChargesParentService.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace App\Services\ExtraCharges;
+
+use Illuminate\Support\Facades\DB;
+
+class ExtraChargesParentService
+{
+    public function searchParents(string $q = '', int $limit = 20): array
+    {
+        $builder = DB::table('users')
+            ->select('users.id', 'users.firstname', 'users.lastname', 'users.email')
+            ->join('user_roles', 'user_roles.user_id', '=', 'users.id')
+            ->join('roles', 'roles.id', '=', 'user_roles.role_id')
+            ->where('roles.name', 'parent')
+            ->whereNull('user_roles.deleted_at');
+
+        if ($q !== '') {
+            $builder->where(function ($query) use ($q) {
+                $query->where('users.firstname', 'like', "%{$q}%")
+                    ->orWhere('users.lastname', 'like', "%{$q}%")
+                    ->orWhere('users.email', 'like', "%{$q}%");
+            });
+        }
+
+        $rows = $builder
+            ->orderBy('users.lastname', 'ASC')
+            ->orderBy('users.firstname', 'ASC')
+            ->limit($limit)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        return array_map(function ($row) {
+            $name = trim(($row['lastname'] ?? '') . ', ' . ($row['firstname'] ?? ''));
+            $email = $row['email'] ?? '';
+            $label = $name !== ',' ? $name : ('User #' . $row['id']);
+            if ($email) {
+                $label .= ' — ' . $email;
+            }
+            $label .= ' (ID: ' . $row['id'] . ')';
+            return [
+                'id' => (int) $row['id'],
+                'text' => $label,
+            ];
+        }, $rows);
+    }
+}
diff --git a/app/Services/Files/ExamDraftDownloadNameService.php b/app/Services/Files/ExamDraftDownloadNameService.php
new file mode 100644
index 00000000..e08fd3a8
--- /dev/null
+++ b/app/Services/Files/ExamDraftDownloadNameService.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Services\Files;
+
+use Illuminate\Support\Facades\DB;
+
+class ExamDraftDownloadNameService
+{
+    public function build(string $filename, string $subdir): string
+    {
+        $column = $subdir === 'finals' ? 'final_file' : 'teacher_file';
+
+        $row = DB::table('exam_drafts as ed')
+            ->select('ed.version', 'ed.exam_type', 'ed.class_section_id', 'cs.class_section_name')
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'ed.class_section_id')
+            ->where('ed.' . $column, $filename)
+            ->limit(1)
+            ->first();
+
+        $row = $row ? (array) $row : [];
+
+        $classLabel = trim((string) ($row['class_section_name'] ?? ('Class' . ($row['class_section_id'] ?? '0'))));
+        $typeLabel = trim((string) ($row['exam_type'] ?? 'Exam'));
+        $version = 'v' . max(1, (int) ($row['version'] ?? 1));
+
+        $parts = array_filter([
+            $this->slugify($classLabel),
+            $this->slugify($typeLabel),
+            $version,
+        ]);
+
+        return implode('_', $parts);
+    }
+
+    private function slugify(string $value): string
+    {
+        $value = trim($value);
+        $value = preg_replace('/[^\p{L}\p{N}]+/u', '_', $value);
+        $value = trim($value, '_');
+        if ($value === '') {
+            return 'Exam';
+        }
+        return mb_strtolower($value);
+    }
+}
diff --git a/app/Services/Files/FileServeService.php b/app/Services/Files/FileServeService.php
new file mode 100644
index 00000000..735c82f3
--- /dev/null
+++ b/app/Services/Files/FileServeService.php
@@ -0,0 +1,112 @@
+<?php
+
+namespace App\Services\Files;
+
+use Illuminate\Http\Request;
+use Illuminate\Http\Response;
+use Symfony\Component\HttpKernel\Exception\HttpException;
+
+class FileServeService
+{
+    public function meta(string $baseDir, string $name, array $allowedExtensions, ?string $downloadName = null): array
+    {
+        return $this->resolveFile($baseDir, $name, $allowedExtensions, $downloadName);
+    }
+
+    public function serveInline(
+        string $baseDir,
+        string $name,
+        array $allowedExtensions,
+        Request $request,
+        ?string $downloadName = null,
+        bool $nosniff = false
+    ): Response {
+        $meta = $this->resolveFile($baseDir, $name, $allowedExtensions, $downloadName);
+
+        $ifNoneMatch = trim((string) $request->headers->get('If-None-Match', ''), '"');
+        $ifModifiedSince = (string) $request->headers->get('If-Modified-Since', '');
+        $imsTime = $ifModifiedSince !== '' ? strtotime($ifModifiedSince) : false;
+
+        if (($ifNoneMatch !== '' && $ifNoneMatch === $meta['etag']) ||
+            ($imsTime !== false && $imsTime >= $meta['mtime'])
+        ) {
+            return response('', 304, $this->notModifiedHeaders($meta));
+        }
+
+        $headers = [
+            'Content-Type' => $meta['mime'],
+            'Content-Disposition' => 'inline; filename="' . $meta['download_name'] . '"',
+            'Content-Length' => (string) $meta['size'],
+            'ETag' => $meta['etag'],
+            'Last-Modified' => $meta['last_modified'],
+            'Cache-Control' => 'public, max-age=86400',
+        ];
+
+        if ($nosniff) {
+            $headers['X-Content-Type-Options'] = 'nosniff';
+        }
+
+        return response(file_get_contents($meta['path']), 200, $headers);
+    }
+
+    private function resolveFile(string $baseDir, string $name, array $allowedExtensions, ?string $downloadName): array
+    {
+        if ($name !== basename($name)) {
+            throw new HttpException(400, 'Invalid filename');
+        }
+
+        $ext = strtolower(pathinfo($name, PATHINFO_EXTENSION));
+        if (!in_array($ext, $allowedExtensions, true)) {
+            throw new HttpException(404, 'File not found');
+        }
+
+        $path = rtrim($baseDir, DIRECTORY_SEPARATOR) . DIRECTORY_SEPARATOR . $name;
+        if (!is_file($path)) {
+            throw new HttpException(404, 'File not found');
+        }
+
+        $mime = $this->detectMime($path);
+        $mtime = filemtime($path) ?: time();
+        $size = filesize($path) ?: 0;
+        $etag = md5($name . '|' . $mtime . '|' . $size);
+        $downloadName = $downloadName ? $downloadName . '.' . $ext : $name;
+
+        return [
+            'name' => $name,
+            'path' => $path,
+            'mime' => $mime,
+            'mtime' => $mtime,
+            'size' => $size,
+            'etag' => $etag,
+            'download_name' => $downloadName,
+            'last_modified' => gmdate('D, d M Y H:i:s', $mtime) . ' GMT',
+        ];
+    }
+
+    private function detectMime(string $path): string
+    {
+        $mime = 'application/octet-stream';
+        if (function_exists('finfo_open')) {
+            $fi = finfo_open(FILEINFO_MIME_TYPE);
+            if ($fi) {
+                $detected = finfo_file($fi, $path);
+                if ($detected) {
+                    $mime = $detected;
+                }
+                finfo_close($fi);
+            }
+        } elseif (function_exists('mime_content_type')) {
+            $mime = mime_content_type($path) ?: $mime;
+        }
+
+        return $mime;
+    }
+
+    private function notModifiedHeaders(array $meta): array
+    {
+        return [
+            'ETag' => $meta['etag'],
+            'Last-Modified' => $meta['last_modified'],
+        ];
+    }
+}
diff --git a/app/Services/Finance/FinancialChartService.php b/app/Services/Finance/FinancialChartService.php
new file mode 100644
index 00000000..8beea7a1
--- /dev/null
+++ b/app/Services/Finance/FinancialChartService.php
@@ -0,0 +1,90 @@
+<?php
+
+namespace App\Services\Finance;
+
+class FinancialChartService
+{
+    public function generateBarChart(array $summary): ?string
+    {
+        if ($this->skipRemoteCharts()) {
+            return null;
+        }
+
+        $chartData = [
+            'type' => 'bar',
+            'data' => [
+                'labels' => ['Charges', 'Paid', 'Unpaid', 'Discounts', 'Refunds', 'Expenses', 'Reimbursements', 'Net'],
+                'datasets' => [[
+                    'label' => 'Amount (USD)',
+                    'data' => [
+                        $summary['totalCharges'] ?? 0,
+                        $summary['amountCollected'] ?? 0,
+                        $summary['totalUnpaid'] ?? 0,
+                        $summary['totalDiscounts'] ?? 0,
+                        $summary['totalRefunds'] ?? 0,
+                        $summary['totalExpenses'] ?? 0,
+                        $summary['totalReimbursements'] ?? 0,
+                        $summary['netAmount'] ?? 0,
+                    ],
+                    'backgroundColor' => 'rgba(54, 162, 235, 0.6)',
+                ]],
+            ],
+        ];
+
+        return $this->downloadChart($chartData, 'bar_chart.png');
+    }
+
+    public function generatePieChart(array $summary): ?string
+    {
+        if ($this->skipRemoteCharts()) {
+            return null;
+        }
+
+        $chartData = [
+            'type' => 'pie',
+            'data' => [
+                'labels' => ['Expenses', 'Reimbursements'],
+                'datasets' => [[
+                    'data' => [
+                        $summary['totalExpenses'] ?? 0,
+                        $summary['totalReimbursements'] ?? 0,
+                    ],
+                    'backgroundColor' => ['#e74c3c', '#8e44ad'],
+                ]],
+            ],
+        ];
+
+        return $this->downloadChart($chartData, 'pie_chart.png');
+    }
+
+    private function downloadChart(array $chartData, string $filename): ?string
+    {
+        $baseUrl = 'https://quickchart.io/chart?c=';
+        $url = $baseUrl . urlencode(json_encode($chartData));
+        $targetDir = storage_path('app/reports');
+        if (!is_dir($targetDir) && !mkdir($targetDir, 0775, true) && !is_dir($targetDir)) {
+            return null;
+        }
+
+        try {
+            $contents = @file_get_contents($url);
+            if ($contents === false) {
+                return null;
+            }
+            $path = $targetDir . DIRECTORY_SEPARATOR . $filename;
+            file_put_contents($path, $contents);
+            return $path;
+        } catch (\Throwable $e) {
+            return null;
+        }
+    }
+
+    private function skipRemoteCharts(): bool
+    {
+        if (app()->environment('testing')) {
+            return true;
+        }
+
+        return (bool) config('services.quickchart.disabled', false);
+    }
+}
diff --git a/app/Services/Finance/FinancialDonationRecipientService.php b/app/Services/Finance/FinancialDonationRecipientService.php
new file mode 100644
index 00000000..8178e02f
--- /dev/null
+++ b/app/Services/Finance/FinancialDonationRecipientService.php
@@ -0,0 +1,16 @@
+<?php
+
+namespace App\Services\Finance;
+
+class FinancialDonationRecipientService
+{
+    public const SPECIAL_RECIPIENTS = [
+        990001 => 'Masjid',
+        990002 => 'Donation',
+    ];
+
+    public function recipientIds(): array
+    {
+        return array_map('intval', array_keys(self::SPECIAL_RECIPIENTS));
+    }
+}
diff --git a/app/Services/Finance/FinancialPaymentService.php b/app/Services/Finance/FinancialPaymentService.php
new file mode 100644
index 00000000..5f55bdf7
--- /dev/null
+++ b/app/Services/Finance/FinancialPaymentService.php
@@ -0,0 +1,119 @@
+<?php
+
+namespace App\Services\Finance;
+
+use Illuminate\Database\Query\Builder;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+class FinancialPaymentService
+{
+    public function paymentsByInvoice(?string $schoolYear, ?string $dateFrom, ?string $dateTo): array
+    {
+        $query = $this->applyPaymentFilters($this->buildPaymentQuery($schoolYear, $dateFrom, $dateTo));
+
+        return $query
+            ->selectRaw('invoice_id, SUM(paid_amount) AS paid_amount')
+            ->whereNotNull('invoice_id')
+            ->groupBy('invoice_id')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+
+    public function paymentBreakdown(?string $schoolYear, ?string $dateFrom, ?string $dateTo): array
+    {
+        $query = $this->applyPaymentFilters($this->buildPaymentQuery($schoolYear, $dateFrom, $dateTo));
+
+        $rows = $query
+            ->selectRaw("
+                invoice_id,
+                CASE
+                    WHEN LOWER(TRIM(payment_method)) = 'cash' THEN 'cash'
+                    WHEN LOWER(TRIM(payment_method)) IN ('check','cheque') THEN 'check'
+                    WHEN LOWER(TRIM(payment_method)) IN ('credit','card','credit card','debit','debit card','visa','mastercard') THEN 'credit'
+                    ELSE 'other'
+                END AS method,
+                SUM(paid_amount) AS amount
+            ")
+            ->whereNotNull('invoice_id')
+            ->groupBy('invoice_id', 'method')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $breakdown = [];
+        foreach ($rows as $row) {
+            $invoiceId = (int) ($row['invoice_id'] ?? 0);
+            if ($invoiceId <= 0) {
+                continue;
+            }
+            $method = (string) ($row['method'] ?? '');
+            $amount = (float) ($row['amount'] ?? 0);
+            if (!isset($breakdown[$invoiceId])) {
+                $breakdown[$invoiceId] = [];
+            }
+            $breakdown[$invoiceId][$method] = $amount;
+        }
+
+        return $breakdown;
+    }
+
+    public function paymentTotals(?string $schoolYear, ?string $dateFrom, ?string $dateTo): array
+    {
+        $query = $this->applyPaymentFilters($this->buildPaymentQuery($schoolYear, $dateFrom, $dateTo));
+
+        $row = (array) $query
+            ->selectRaw("
+                SUM(paid_amount) AS total_all,
+                SUM(CASE WHEN LOWER(TRIM(payment_method)) = 'cash' THEN paid_amount ELSE 0 END) AS total_cash,
+                SUM(CASE WHEN LOWER(TRIM(payment_method)) IN ('check','cheque') THEN paid_amount ELSE 0 END) AS total_check,
+                SUM(CASE WHEN LOWER(TRIM(payment_method)) IN ('credit','card','credit card','debit','debit card','visa','mastercard') THEN paid_amount ELSE 0 END) AS total_credit
+            ")
+            ->whereNotNull('invoice_id')
+            ->first();
+
+        return [
+            'total_all' => (float) ($row['total_all'] ?? 0),
+            'total_cash' => (float) ($row['total_cash'] ?? 0),
+            'total_check' => (float) ($row['total_check'] ?? 0),
+            'total_credit' => (float) ($row['total_credit'] ?? 0),
+        ];
+    }
+
+    private function buildPaymentQuery(?string $schoolYear, ?string $dateFrom, ?string $dateTo): Builder
+    {
+        $query = DB::table('payments');
+
+        if (!empty($schoolYear)) {
+            $query->where('school_year', $schoolYear);
+        }
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(payment_date) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(payment_date) <= ?', [$dateTo]);
+        }
+
+        return $query;
+    }
+
+    private function applyPaymentFilters(Builder $query): Builder
+    {
+        $exclude = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
+
+        if (Schema::hasColumn('payments', 'status')) {
+            $query->where(function ($q) use ($exclude) {
+                $q->whereNotIn('status', $exclude)->orWhereNull('status');
+            });
+        }
+
+        if (Schema::hasColumn('payments', 'is_void')) {
+            $query->where(function ($q) {
+                $q->where('is_void', 0)->orWhereNull('is_void');
+            });
+        }
+
+        return $query;
+    }
+}
diff --git a/app/Services/Finance/FinancialPdfReportService.php b/app/Services/Finance/FinancialPdfReportService.php
new file mode 100644
index 00000000..0f7c28b1
--- /dev/null
+++ b/app/Services/Finance/FinancialPdfReportService.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace App\Services\Finance;
+
+class FinancialPdfReportService
+{
+    public function __construct(private FinancialChartService $charts)
+    {
+    }
+
+    public function buildPdf(array $summary): string
+    {
+        $pdf = new \FPDF();
+        $pdf->AddPage();
+        $pdf->SetFont('Arial', 'B', 16);
+        $pdf->Cell(0, 10, 'Financial Report for School Year: ' . ($summary['schoolYear'] ?? ''), 0, 1, 'C');
+
+        $pdf->Ln(10);
+        $pdf->SetFont('Arial', 'B', 12);
+        $pdf->Cell(130, 10, 'Description', 1);
+        $pdf->Cell(60, 10, 'Amount (USD)', 1);
+        $pdf->Ln();
+
+        $rows = [
+            'Total Charges' => $summary['totalCharges'] ?? 0,
+            'Total Extra Charges' => $summary['totalExtraCharges'] ?? 0,
+            'Total Discounts' => $summary['totalDiscounts'] ?? 0,
+            'Total Refunds' => $summary['totalRefunds'] ?? 0,
+            'Total Expenses' => $summary['totalExpenses'] ?? 0,
+            'Total Reimbursements' => $summary['totalReimbursements'] ?? 0,
+            'Donation to School (Masjid/Donation reimbursements)' => $summary['donationToSchool'] ?? 0,
+            'Net Amount (Earned Income)' => $summary['netAmount'] ?? 0,
+            'Amount Collected (Paid)' => $summary['amountCollected'] ?? 0,
+            'Amount Unpaid (Outstanding)' => $summary['totalUnpaid'] ?? 0,
+        ];
+
+        $pdf->SetFont('Arial', '', 11);
+        foreach ($rows as $label => $amount) {
+            $pdf->Cell(130, 10, $label, 1);
+            $pdf->Cell(60, 10, '$' . number_format((float) $amount, 2), 1);
+            $pdf->Ln();
+        }
+
+        $barChart = $this->charts->generateBarChart($summary);
+        if (!empty($barChart) && file_exists($barChart)) {
+            $pdf->Ln(10);
+            $pdf->SetFont('Arial', 'B', 12);
+            $pdf->Cell(0, 10, 'Summary Graph', 0, 1);
+            $pdf->Image($barChart, null, null, 180);
+        }
+
+        $pieChart = $this->charts->generatePieChart($summary);
+        if (!empty($pieChart) && file_exists($pieChart)) {
+            $pdf->Ln(10);
+            $pdf->SetFont('Arial', 'B', 12);
+            $pdf->Cell(0, 10, 'Expense Breakdown', 0, 1);
+            $pdf->Image($pieChart, null, null, 120);
+        }
+
+        return $pdf->Output('S');
+    }
+}
diff --git a/app/Services/Finance/FinancialReportService.php b/app/Services/Finance/FinancialReportService.php
new file mode 100644
index 00000000..16ab30ee
--- /dev/null
+++ b/app/Services/Finance/FinancialReportService.php
@@ -0,0 +1,104 @@
+<?php
+
+namespace App\Services\Finance;
+
+use Illuminate\Support\Facades\DB;
+
+class FinancialReportService
+{
+    public function __construct(
+        private FinancialPaymentService $payments,
+        private FinancialSchoolYearService $schoolYears
+    ) {
+    }
+
+    public function getReport(?string $dateFrom, ?string $dateTo, ?string $schoolYear): array
+    {
+        $invoiceQuery = DB::table('invoices')
+            ->selectRaw("invoices.*, CONCAT(users.firstname, ' ', users.lastname) AS parent_name")
+            ->join('users', 'users.id', '=', 'invoices.parent_id');
+
+        $refundQuery = DB::table('refunds');
+        $discountQuery = DB::table('discount_usages');
+        $expenseQuery = DB::table('expenses');
+        $reimbQuery = DB::table('reimbursements');
+
+        if (!empty($schoolYear)) {
+            $invoiceQuery->where('invoices.school_year', $schoolYear);
+            $refundQuery->where('school_year', $schoolYear);
+            $discountQuery->where('school_year', $schoolYear);
+            $expenseQuery->where('school_year', $schoolYear);
+            $reimbQuery->where('school_year', $schoolYear);
+        }
+
+        if (!empty($dateFrom)) {
+            $invoiceQuery->whereRaw('DATE(COALESCE(invoices.issue_date, invoices.created_at)) >= ?', [$dateFrom]);
+            $refundQuery->whereRaw('DATE(COALESCE(refunded_at, created_at)) >= ?', [$dateFrom]);
+            $discountQuery->whereRaw('DATE(COALESCE(used_at, created_at)) >= ?', [$dateFrom]);
+            $expenseQuery->whereRaw('DATE(created_at) >= ?', [$dateFrom]);
+            $reimbQuery->whereRaw('DATE(created_at) >= ?', [$dateFrom]);
+        }
+
+        if (!empty($dateTo)) {
+            $invoiceQuery->whereRaw('DATE(COALESCE(invoices.issue_date, invoices.created_at)) <= ?', [$dateTo]);
+            $refundQuery->whereRaw('DATE(COALESCE(refunded_at, created_at)) <= ?', [$dateTo]);
+            $discountQuery->whereRaw('DATE(COALESCE(used_at, created_at)) <= ?', [$dateTo]);
+            $expenseQuery->whereRaw('DATE(created_at) <= ?', [$dateTo]);
+            $reimbQuery->whereRaw('DATE(created_at) <= ?', [$dateTo]);
+        }
+
+        $invoices = $invoiceQuery->get()->map(fn ($row) => (array) $row)->all();
+
+        $payments = $this->payments->paymentsByInvoice($schoolYear, $dateFrom, $dateTo);
+        $paymentBreakdown = $this->payments->paymentBreakdown($schoolYear, $dateFrom, $dateTo);
+        $paymentTotals = $this->payments->paymentTotals($schoolYear, $dateFrom, $dateTo);
+
+        $refunds = $refundQuery
+            ->selectRaw('invoice_id, school_year, SUM(refund_paid_amount) AS total_refunded')
+            ->whereNotNull('invoice_id')
+            ->whereIn('status', ['Partial', 'Paid'])
+            ->groupBy('invoice_id', 'school_year')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $discounts = $discountQuery
+            ->selectRaw('invoice_id, school_year, SUM(discount_amount) AS discount_amount')
+            ->whereNotNull('invoice_id')
+            ->groupBy('invoice_id', 'school_year')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $expenses = $expenseQuery
+            ->selectRaw('category, SUM(amount) AS total_amount')
+            ->groupBy('category')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $reimbursements = $reimbQuery
+            ->selectRaw('status, SUM(amount) AS total_amount')
+            ->groupBy('status')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $schoolYears = $this->schoolYears->listYears($schoolYear);
+
+        return [
+            'selectedYear' => $schoolYear,
+            'dateFrom' => $dateFrom,
+            'dateTo' => $dateTo,
+            'schoolYears' => $schoolYears,
+            'invoices' => $invoices,
+            'payments' => $payments,
+            'paymentBreakdown' => $paymentBreakdown,
+            'paymentTotals' => $paymentTotals,
+            'refunds' => $refunds,
+            'expenses' => $expenses,
+            'reimbursements' => $reimbursements,
+            'discounts' => $discounts,
+        ];
+    }
+}
diff --git a/app/Services/Finance/FinancialSchoolYearService.php b/app/Services/Finance/FinancialSchoolYearService.php
new file mode 100644
index 00000000..2cb61a51
--- /dev/null
+++ b/app/Services/Finance/FinancialSchoolYearService.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace App\Services\Finance;
+
+use Illuminate\Support\Facades\DB;
+
+class FinancialSchoolYearService
+{
+    public function listYears(?string $fallbackYear = null): array
+    {
+        $years = DB::table('invoices')
+            ->select('school_year')
+            ->whereNotNull('school_year')
+            ->distinct()
+            ->orderBy('school_year', 'DESC')
+            ->pluck('school_year')
+            ->map(static fn ($val) => (string) $val)
+            ->filter(static fn ($val) => $val !== '')
+            ->values()
+            ->all();
+
+        if (empty($years) && !empty($fallbackYear)) {
+            $years[] = (string) $fallbackYear;
+        }
+
+        return $years;
+    }
+}
diff --git a/app/Services/Finance/FinancialSummaryService.php b/app/Services/Finance/FinancialSummaryService.php
new file mode 100644
index 00000000..3583ff8b
--- /dev/null
+++ b/app/Services/Finance/FinancialSummaryService.php
@@ -0,0 +1,479 @@
+<?php
+
+namespace App\Services\Finance;
+
+use App\Models\Configuration;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+class FinancialSummaryService
+{
+    public function __construct(
+        private FinancialDonationRecipientService $donationRecipients
+    ) {
+    }
+
+    public function getSummary(?string $dateFrom, ?string $dateTo, ?string $schoolYear): array
+    {
+        $schoolYear = $schoolYear ?: (Configuration::getConfig('school_year') ?? date('Y'));
+        $derivedDateFrom = null;
+        $derivedDateTo = null;
+
+        if (!empty($schoolYear) && empty($dateFrom) && empty($dateTo)) {
+            if (preg_match('/^(\\d{4})[^\\d]?(\\d{4})$/', $schoolYear, $m)) {
+                $derivedDateFrom = $m[1] . '-01-01';
+                $derivedDateTo = $m[2] . '-12-31';
+            }
+        }
+
+        $invoiceDateFrom = $dateFrom ?: $derivedDateFrom;
+        $invoiceDateTo = $dateTo ?: $derivedDateTo;
+
+        $invoiceQuery = DB::table('invoices')->where('school_year', $schoolYear);
+        if (!empty($invoiceDateFrom)) {
+            $invoiceQuery->whereRaw('DATE(COALESCE(issue_date, created_at)) >= ?', [$invoiceDateFrom]);
+        }
+        if (!empty($invoiceDateTo)) {
+            $invoiceQuery->whereRaw('DATE(COALESCE(issue_date, created_at)) <= ?', [$invoiceDateTo]);
+        }
+        $invoices = $invoiceQuery->get()->map(fn ($row) => (array) $row)->all();
+        $totalCharges = array_sum(array_map(static fn ($row) => (float) ($row['total_amount'] ?? 0), $invoices));
+
+        $invoiceIds = array_values(array_unique(array_filter(array_map(static function ($row) {
+            $id = (int) ($row['id'] ?? 0);
+            return $id > 0 ? $id : null;
+        }, $invoices))));
+
+        $totalExtraCharges = $this->sumAdditionalCharges($schoolYear, $dateFrom, $dateTo);
+        $extraByParent = $this->extraChargesByParent($schoolYear, $dateFrom, $dateTo);
+        $extraChargesUnapplied = array_sum($extraByParent);
+        $totalCharges += $extraChargesUnapplied;
+
+        $totalPaid = $this->sumPayments($schoolYear, $invoiceDateFrom, $invoiceDateTo);
+
+        $paidByInvoice = [];
+        $discountByInvoice = [];
+        $refundByInvoice = [];
+        if (!empty($invoiceIds)) {
+            $paidByInvoice = $this->paymentsByInvoiceIds($invoiceIds, $schoolYear, $invoiceDateFrom, $invoiceDateTo);
+            $discountByInvoice = $this->discountsByInvoiceIds($invoiceIds, $dateFrom, $dateTo);
+            $refundByInvoice = $this->refundsByInvoiceIds($invoiceIds, $dateFrom, $dateTo);
+        }
+
+        $totalExpenses = $this->sumExpenses($schoolYear, $invoiceDateFrom, $invoiceDateTo);
+        $totalReimbursements = $this->sumReimbursements($schoolYear, $invoiceDateFrom, $invoiceDateTo);
+
+        $donationToSchool = $this->sumDonationToSchool($schoolYear, $invoiceDateFrom, $invoiceDateTo);
+        $totalReimbursements = max(0.0, $totalReimbursements - $donationToSchool['donationReimb']);
+
+        $totalRefunds = $this->sumRefunds($schoolYear, $dateFrom, $dateTo);
+        $totalDiscounts = $this->sumDiscounts($schoolYear, $dateFrom, $dateTo);
+
+        $totalUnpaid = $this->sumUnpaidBalances($invoices, $paidByInvoice, $discountByInvoice, $refundByInvoice, $extraByParent);
+
+        $amountCollected = $totalPaid;
+        $netAmount = $totalCharges - $totalDiscounts - $totalRefunds;
+
+        return [
+            'schoolYear' => $schoolYear,
+            'dateFrom' => $dateFrom,
+            'dateTo' => $dateTo,
+            'totalCharges' => $totalCharges,
+            'totalExtraCharges' => $totalExtraCharges,
+            'totalDiscounts' => $totalDiscounts,
+            'totalRefunds' => $totalRefunds,
+            'totalExpenses' => $totalExpenses,
+            'totalReimbursements' => $totalReimbursements,
+            'donationToSchool' => $donationToSchool['donationToSchool'],
+            'totalPaid' => $totalPaid,
+            'amountCollected' => $amountCollected,
+            'totalUnpaid' => $totalUnpaid,
+            'netAmount' => $netAmount,
+        ];
+    }
+
+    private function sumAdditionalCharges(string $schoolYear, ?string $dateFrom, ?string $dateTo): float
+    {
+        $query = DB::table('additional_charges as ac')
+            ->selectRaw('COALESCE(SUM(ac.amount), 0) AS amount')
+            ->where('ac.school_year', $schoolYear)
+            ->where('ac.status !=', 'void');
+
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(ac.due_date) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(ac.due_date) <= ?', [$dateTo]);
+        }
+
+        $row = (array) $query->first();
+        return (float) ($row['amount'] ?? 0);
+    }
+
+    private function extraChargesByParent(string $schoolYear, ?string $dateFrom, ?string $dateTo): array
+    {
+        $query = DB::table('additional_charges as ac')
+            ->selectRaw('ac.parent_id, COALESCE(SUM(ac.amount), 0) AS amount')
+            ->where('ac.school_year', $schoolYear)
+            ->where('ac.status !=', 'void')
+            ->where(function ($q) {
+                $q->whereNull('ac.invoice_id')
+                    ->orWhere('ac.invoice_id', 0)
+                    ->orWhere('ac.status !=', 'applied');
+            })
+            ->groupBy('ac.parent_id');
+
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(ac.due_date) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(ac.due_date) <= ?', [$dateTo]);
+        }
+
+        $rows = $query->get()->map(fn ($row) => (array) $row)->all();
+        $extraByParent = [];
+        foreach ($rows as $row) {
+            $parentId = (int) ($row['parent_id'] ?? 0);
+            $amount = (float) ($row['amount'] ?? 0);
+            if ($parentId > 0 && abs($amount) > 0.00001) {
+                $extraByParent[$parentId] = $amount;
+            }
+        }
+
+        return $extraByParent;
+    }
+
+    private function sumPayments(string $schoolYear, ?string $dateFrom, ?string $dateTo): float
+    {
+        $query = DB::table('payments')->where('school_year', $schoolYear);
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(payment_date) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(payment_date) <= ?', [$dateTo]);
+        }
+
+        $exclude = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
+        if (Schema::hasColumn('payments', 'status')) {
+            $query->where(function ($q) use ($exclude) {
+                $q->whereNotIn('status', $exclude)->orWhereNull('status');
+            });
+        }
+        if (Schema::hasColumn('payments', 'is_void')) {
+            $query->where(function ($q) {
+                $q->where('is_void', 0)->orWhereNull('is_void');
+            });
+        }
+
+        $row = (array) $query->selectRaw('COALESCE(SUM(paid_amount), 0) AS paid_amount')->first();
+        return (float) ($row['paid_amount'] ?? 0);
+    }
+
+    private function paymentsByInvoiceIds(array $invoiceIds, string $schoolYear, ?string $dateFrom, ?string $dateTo): array
+    {
+        $query = DB::table('payments')
+            ->selectRaw('invoice_id, COALESCE(SUM(paid_amount), 0) AS total_paid')
+            ->whereIn('invoice_id', $invoiceIds)
+            ->where('school_year', $schoolYear);
+
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(payment_date) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(payment_date) <= ?', [$dateTo]);
+        }
+
+        $exclude = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
+        if (Schema::hasColumn('payments', 'status')) {
+            $query->where(function ($q) use ($exclude) {
+                $q->whereNotIn('status', $exclude)->orWhereNull('status');
+            });
+        }
+        if (Schema::hasColumn('payments', 'is_void')) {
+            $query->where(function ($q) {
+                $q->where('is_void', 0)->orWhereNull('is_void');
+            });
+        }
+
+        $rows = $query->groupBy('invoice_id')->get()->map(fn ($row) => (array) $row)->all();
+        $map = [];
+        foreach ($rows as $row) {
+            $invoiceId = (int) ($row['invoice_id'] ?? 0);
+            if ($invoiceId > 0) {
+                $map[$invoiceId] = (float) ($row['total_paid'] ?? 0);
+            }
+        }
+        return $map;
+    }
+
+    private function discountsByInvoiceIds(array $invoiceIds, ?string $dateFrom, ?string $dateTo): array
+    {
+        $query = DB::table('discount_usages')
+            ->selectRaw('invoice_id, COALESCE(SUM(discount_amount),0) AS total_disc')
+            ->whereIn('invoice_id', $invoiceIds);
+
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(COALESCE(used_at, created_at)) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(COALESCE(used_at, created_at)) <= ?', [$dateTo]);
+        }
+
+        $rows = $query->groupBy('invoice_id')->get()->map(fn ($row) => (array) $row)->all();
+        $map = [];
+        foreach ($rows as $row) {
+            $invoiceId = (int) ($row['invoice_id'] ?? 0);
+            if ($invoiceId > 0) {
+                $map[$invoiceId] = (float) ($row['total_disc'] ?? 0);
+            }
+        }
+        return $map;
+    }
+
+    private function refundsByInvoiceIds(array $invoiceIds, ?string $dateFrom, ?string $dateTo): array
+    {
+        $query = DB::table('refunds')
+            ->selectRaw('invoice_id, COALESCE(SUM(refund_paid_amount),0) AS total_refund')
+            ->whereIn('invoice_id', $invoiceIds)
+            ->whereIn('status', ['Partial', 'Paid']);
+
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(COALESCE(refunded_at, created_at)) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(COALESCE(refunded_at, created_at)) <= ?', [$dateTo]);
+        }
+
+        $rows = $query->groupBy('invoice_id')->get()->map(fn ($row) => (array) $row)->all();
+        $map = [];
+        foreach ($rows as $row) {
+            $invoiceId = (int) ($row['invoice_id'] ?? 0);
+            if ($invoiceId > 0) {
+                $map[$invoiceId] = (float) ($row['total_refund'] ?? 0);
+            }
+        }
+        return $map;
+    }
+
+    private function sumExpenses(string $schoolYear, ?string $dateFrom, ?string $dateTo): float
+    {
+        $query = DB::table('expenses')->where('school_year', $schoolYear);
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(created_at) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(created_at) <= ?', [$dateTo]);
+        }
+
+        $row = (array) $query->selectRaw('COALESCE(SUM(amount), 0) AS amount')->first();
+        return (float) ($row['amount'] ?? 0);
+    }
+
+    private function sumReimbursements(string $schoolYear, ?string $dateFrom, ?string $dateTo): float
+    {
+        $normalizedYear = preg_replace('/[^0-9]/', '', (string) $schoolYear);
+
+        $query = DB::table('reimbursements as r')
+            ->selectRaw('COALESCE(SUM(r.amount),0) AS amount')
+            ->leftJoin('expenses as e', 'e.id', '=', 'r.expense_id');
+
+        if (!empty($schoolYear)) {
+            $query->where(function ($q) use ($schoolYear, $normalizedYear) {
+                $q->where(function ($q2) use ($schoolYear, $normalizedYear) {
+                    $q2->where('r.school_year', $schoolYear)
+                        ->orWhereRaw(
+                            "REPLACE(REPLACE(REPLACE(REPLACE(r.school_year, ' ', ''), '-', ''), '/', ''), '\\\\', '') = ?",
+                            [$normalizedYear]
+                        );
+                })->orWhere(function ($q2) use ($schoolYear, $normalizedYear) {
+                    $q2->whereNull('r.school_year')
+                        ->where(function ($q3) use ($schoolYear, $normalizedYear) {
+                            $q3->where('e.school_year', $schoolYear)
+                                ->orWhereRaw(
+                                    "REPLACE(REPLACE(REPLACE(REPLACE(e.school_year, ' ', ''), '-', ''), '/', ''), '\\\\', '') = ?",
+                                    [$normalizedYear]
+                                );
+                        });
+                });
+            });
+        }
+
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(COALESCE(r.created_at, e.created_at)) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(COALESCE(r.created_at, e.created_at)) <= ?', [$dateTo]);
+        }
+
+        $row = (array) $query->first();
+        $total = (float) ($row['amount'] ?? 0);
+
+        $batchFallback = DB::table('reimbursement_batch_items as bi')
+            ->selectRaw('COALESCE(SUM(e.amount),0) AS amount')
+            ->join('reimbursement_batches as b', 'b.id', '=', 'bi.batch_id')
+            ->join('expenses as e', 'e.id', '=', 'bi.expense_id')
+            ->leftJoin('reimbursements as r', 'r.expense_id', '=', 'e.id')
+            ->where('b.status', 'closed')
+            ->whereNull('bi.unassigned_at')
+            ->whereNull('r.id');
+
+        if (!empty($schoolYear)) {
+            $batchFallback->where(function ($q) use ($schoolYear, $normalizedYear) {
+                $q->where('e.school_year', $schoolYear)
+                    ->orWhereRaw(
+                        "REPLACE(REPLACE(REPLACE(REPLACE(e.school_year, ' ', ''), '-', ''), '/', ''), '\\\\', '') = ?",
+                        [$normalizedYear]
+                    );
+            });
+        }
+
+        if (!empty($dateFrom)) {
+            $batchFallback->whereRaw('DATE(COALESCE(e.created_at, b.closed_at)) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $batchFallback->whereRaw('DATE(COALESCE(e.created_at, b.closed_at)) <= ?', [$dateTo]);
+        }
+
+        $fallbackRow = (array) $batchFallback->first();
+        $total += (float) ($fallbackRow['amount'] ?? 0);
+
+        return $total;
+    }
+
+    private function sumDonationToSchool(string $schoolYear, ?string $dateFrom, ?string $dateTo): array
+    {
+        $expenseQuery = DB::table('expenses')
+            ->where('school_year', $schoolYear)
+            ->where('category', 'Donation');
+
+        if (!empty($dateFrom)) {
+            $expenseQuery->whereRaw('DATE(created_at) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $expenseQuery->whereRaw('DATE(created_at) <= ?', [$dateTo]);
+        }
+
+        $expenseRow = (array) $expenseQuery->selectRaw('COALESCE(SUM(amount),0) AS amount')->first();
+        $donationExpense = (float) ($expenseRow['amount'] ?? 0);
+
+        $donationReimb = 0.0;
+        $recipientIds = $this->donationRecipients->recipientIds();
+        if (!empty($recipientIds)) {
+            $normalizedYear = preg_replace('/[^0-9]/', '', (string) $schoolYear);
+            $donationQuery = DB::table('reimbursements as r')
+                ->selectRaw('COALESCE(SUM(r.amount),0) AS amount')
+                ->leftJoin('expenses as e', 'e.id', '=', 'r.expense_id')
+                ->whereIn('r.reimbursed_to', $recipientIds);
+
+            if (!empty($schoolYear)) {
+                $donationQuery->where(function ($q) use ($schoolYear, $normalizedYear) {
+                    $q->where(function ($q2) use ($schoolYear, $normalizedYear) {
+                        $q2->where('r.school_year', $schoolYear)
+                            ->orWhereRaw(
+                                "REPLACE(REPLACE(REPLACE(REPLACE(r.school_year, ' ', ''), '-', ''), '/', ''), '\\\\', '') = ?",
+                                [$normalizedYear]
+                            );
+                    })->orWhere(function ($q2) use ($schoolYear, $normalizedYear) {
+                        $q2->whereNull('r.school_year')
+                            ->where(function ($q3) use ($schoolYear, $normalizedYear) {
+                                $q3->where('e.school_year', $schoolYear)
+                                    ->orWhereRaw(
+                                        "REPLACE(REPLACE(REPLACE(REPLACE(e.school_year, ' ', ''), '-', ''), '/', ''), '\\\\', '') = ?",
+                                        [$normalizedYear]
+                                    );
+                            });
+                    });
+                });
+            }
+
+            if (!empty($dateFrom)) {
+                $donationQuery->whereRaw('DATE(COALESCE(r.created_at, e.created_at)) >= ?', [$dateFrom]);
+            }
+            if (!empty($dateTo)) {
+                $donationQuery->whereRaw('DATE(COALESCE(r.created_at, e.created_at)) <= ?', [$dateTo]);
+            }
+
+            $donationRow = (array) $donationQuery->first();
+            $donationReimb = (float) ($donationRow['amount'] ?? 0);
+        }
+
+        return [
+            'donationToSchool' => $donationExpense + $donationReimb,
+            'donationReimb' => $donationReimb,
+        ];
+    }
+
+    private function sumRefunds(string $schoolYear, ?string $dateFrom, ?string $dateTo): float
+    {
+        $query = DB::table('refunds')
+            ->where('school_year', $schoolYear)
+            ->whereIn('status', ['Partial', 'Paid'])
+            ->whereNotNull('refund_paid_amount');
+
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(COALESCE(refunded_at, created_at)) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(COALESCE(refunded_at, created_at)) <= ?', [$dateTo]);
+        }
+
+        $row = (array) $query->selectRaw('COALESCE(SUM(refund_paid_amount),0) AS refund_paid_amount')->first();
+        return (float) ($row['refund_paid_amount'] ?? 0);
+    }
+
+    private function sumDiscounts(string $schoolYear, ?string $dateFrom, ?string $dateTo): float
+    {
+        $query = DB::table('discount_usages as du')
+            ->join('invoices as i', 'i.id', '=', 'du.invoice_id')
+            ->where('i.school_year', $schoolYear);
+
+        if (!empty($dateFrom)) {
+            $query->whereRaw('DATE(COALESCE(du.used_at, du.created_at)) >= ?', [$dateFrom]);
+        }
+        if (!empty($dateTo)) {
+            $query->whereRaw('DATE(COALESCE(du.used_at, du.created_at)) <= ?', [$dateTo]);
+        }
+
+        $row = (array) $query->selectRaw('COALESCE(SUM(du.discount_amount),0) AS discount_amount')->first();
+        return (float) ($row['discount_amount'] ?? 0);
+    }
+
+    private function sumUnpaidBalances(array $invoices, array $paidByInvoice, array $discountByInvoice, array $refundByInvoice, array $extraByParent): float
+    {
+        $parentBalances = [];
+
+        foreach ($invoices as $inv) {
+            $invoiceId = (int) ($inv['id'] ?? 0);
+            $parentId = (int) ($inv['parent_id'] ?? 0);
+            if ($invoiceId <= 0 || $parentId <= 0) {
+                continue;
+            }
+            $total = (float) ($inv['total_amount'] ?? 0);
+            $paid = (float) ($paidByInvoice[$invoiceId] ?? 0);
+            $disc = (float) ($discountByInvoice[$invoiceId] ?? 0);
+            $ref = (float) ($refundByInvoice[$invoiceId] ?? 0);
+            $balance = max(0.0, round($total - $disc - $paid - $ref, 2));
+
+            if (!isset($parentBalances[$parentId])) {
+                $parentBalances[$parentId] = 0.0;
+            }
+            $parentBalances[$parentId] += $balance;
+        }
+
+        foreach ($extraByParent as $parentId => $extra) {
+            if (!isset($parentBalances[$parentId])) {
+                $parentBalances[$parentId] = 0.0;
+            }
+            $parentBalances[$parentId] += (float) $extra;
+        }
+
+        $totalUnpaid = 0.0;
+        foreach ($parentBalances as $balance) {
+            if ($balance > 0.00001) {
+                $totalUnpaid += $balance;
+            }
+        }
+
+        return $totalUnpaid;
+    }
+}
diff --git a/app/Services/Finance/FinancialUnpaidParentsService.php b/app/Services/Finance/FinancialUnpaidParentsService.php
new file mode 100644
index 00000000..90f702b4
--- /dev/null
+++ b/app/Services/Finance/FinancialUnpaidParentsService.php
@@ -0,0 +1,247 @@
+<?php
+
+namespace App\Services\Finance;
+
+use App\Models\Configuration;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+class FinancialUnpaidParentsService
+{
+    public function __construct(private FinancialSchoolYearService $schoolYears)
+    {
+    }
+
+    public function getUnpaidParents(?string $schoolYear): array
+    {
+        $schoolYear = trim((string) ($schoolYear ?? ''));
+        if ($schoolYear === '') {
+            $schoolYear = (string) (Configuration::getConfig('school_year') ?? date('Y'));
+        }
+
+        $schoolYears = $this->schoolYears->listYears($schoolYear);
+
+        $invRows = DB::table('invoices as i')
+            ->select('i.id', 'i.parent_id', 'i.total_amount', 'u.firstname', 'u.lastname', 'u.email')
+            ->join('users as u', 'u.id', '=', 'i.parent_id')
+            ->where('i.school_year', $schoolYear)
+            ->orderBy('i.parent_id', 'ASC')
+            ->orderBy('i.id', 'ASC')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $byParent = [];
+        $hasStatus = Schema::hasColumn('payments', 'status');
+        $hasVoid = Schema::hasColumn('payments', 'is_void');
+
+        foreach ($invRows as $row) {
+            $invoiceId = (int) ($row['id'] ?? 0);
+            $parentId = (int) ($row['parent_id'] ?? 0);
+            if ($invoiceId <= 0 || $parentId <= 0) {
+                continue;
+            }
+
+            $paidQuery = DB::table('payments')
+                ->selectRaw('COALESCE(SUM(paid_amount),0) AS tot')
+                ->where('invoice_id', $invoiceId);
+            if ($hasStatus) {
+                $paidQuery->where(function ($q) {
+                    $q->whereNotIn('status', [
+                        'void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled',
+                    ])->orWhereNull('status');
+                });
+            }
+            if ($hasVoid) {
+                $paidQuery->where(function ($q) {
+                    $q->where('is_void', 0)->orWhereNull('is_void');
+                });
+            }
+            $paidRow = (array) $paidQuery->first();
+            $paidSum = (float) ($paidRow['tot'] ?? 0);
+
+            $discRow = (array) DB::table('discount_usages')
+                ->selectRaw('COALESCE(SUM(discount_amount),0) AS tot')
+                ->where('invoice_id', $invoiceId)
+                ->first();
+            $discSum = (float) ($discRow['tot'] ?? 0);
+
+            $refRow = (array) DB::table('refunds')
+                ->selectRaw('COALESCE(SUM(refund_paid_amount),0) AS tot')
+                ->where('invoice_id', $invoiceId)
+                ->whereIn('status', ['Partial', 'Paid'])
+                ->first();
+            $refSum = (float) ($refRow['tot'] ?? 0);
+
+            $total = (float) ($row['total_amount'] ?? 0);
+            $balance = max(0.0, round($total - $discSum - $paidSum - $refSum, 2));
+
+            if (!isset($byParent[$parentId])) {
+                $byParent[$parentId] = [
+                    'parent_id' => $parentId,
+                    'firstname' => (string) ($row['firstname'] ?? ''),
+                    'lastname' => (string) ($row['lastname'] ?? ''),
+                    'email' => (string) ($row['email'] ?? ''),
+                    'total_invoice' => 0.0,
+                    'total_balance' => 0.0,
+                    'total_paid' => 0.0,
+                    'total_discount' => 0.0,
+                ];
+            }
+
+            $byParent[$parentId]['total_invoice'] += $total;
+            $byParent[$parentId]['total_balance'] += $balance;
+            $byParent[$parentId]['total_paid'] += $paidSum;
+            $byParent[$parentId]['total_discount'] += $discSum;
+        }
+
+        $extraRows = DB::table('additional_charges as ac')
+            ->selectRaw(
+                "ac.parent_id, u.firstname, u.lastname, u.email, COALESCE(SUM(ac.amount), 0) AS total_extra",
+                false
+            )
+            ->leftJoin('users as u', 'u.id', '=', 'ac.parent_id')
+            ->where('ac.school_year', $schoolYear)
+            ->where('ac.status !=', 'void')
+            ->where(function ($q) {
+                $q->whereNull('ac.invoice_id')
+                    ->orWhere('ac.invoice_id', 0)
+                    ->orWhere('ac.status !=', 'applied');
+            })
+            ->groupBy('ac.parent_id')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        foreach ($extraRows as $row) {
+            $parentId = (int) ($row['parent_id'] ?? 0);
+            if ($parentId <= 0) {
+                continue;
+            }
+            $extra = (float) ($row['total_extra'] ?? 0);
+            if (abs($extra) < 0.00001) {
+                continue;
+            }
+            if (!isset($byParent[$parentId])) {
+                $byParent[$parentId] = [
+                    'parent_id' => $parentId,
+                    'firstname' => (string) ($row['firstname'] ?? ''),
+                    'lastname' => (string) ($row['lastname'] ?? ''),
+                    'email' => (string) ($row['email'] ?? ''),
+                    'total_invoice' => 0.0,
+                    'total_balance' => 0.0,
+                    'total_paid' => 0.0,
+                    'total_discount' => 0.0,
+                ];
+            }
+            $byParent[$parentId]['total_invoice'] += $extra;
+            $byParent[$parentId]['total_balance'] += $extra;
+        }
+
+        $rows = [];
+        $installmentEndRaw = (string) (Configuration::getConfig('installment_date') ?? '');
+        $tzName = function_exists('user_timezone') ? (string) user_timezone() : config('app.timezone', 'UTC');
+        $tz = new \DateTimeZone($tzName);
+        $today = new \DateTimeImmutable('today', $tz);
+
+        $endDate = null;
+        if ($installmentEndRaw !== '') {
+            try {
+                $endDate = new \DateTimeImmutable($installmentEndRaw, $tz);
+            } catch (\Throwable $e) {
+                $endDate = null;
+            }
+        }
+
+        $monthsUntil = static function (? \DateTimeImmutable $end) use ($today): int {
+            if (!$end) {
+                return 0;
+            }
+            $y = (int) $end->format('Y') - (int) $today->format('Y');
+            $m = (int) $end->format('n') - (int) $today->format('n');
+            $months = $y * 12 + $m;
+            if ((int) $end->format('j') > (int) $today->format('j')) {
+                $months += 1;
+            }
+            return max(0, $months);
+        };
+
+        foreach ($byParent as $agg) {
+            $balance = (float) ($agg['total_balance'] ?? 0);
+            if ($balance <= 0.00001) {
+                continue;
+            }
+            $remMonths = $monthsUntil($endDate);
+            $remainingInstallments = max(1, $remMonths);
+            $instAmount = round($balance / $remainingInstallments, 2);
+
+            $rows[] = [
+                'parent_id' => (int) ($agg['parent_id'] ?? 0),
+                'firstname' => (string) ($agg['firstname'] ?? ''),
+                'lastname' => (string) ($agg['lastname'] ?? ''),
+                'email' => (string) ($agg['email'] ?? ''),
+                'total_invoice' => (float) ($agg['total_invoice'] ?? 0),
+                'total_balance' => $balance,
+                'total_discount' => (float) ($agg['total_discount'] ?? 0),
+                'remaining_installments' => $remainingInstallments,
+                'installment_amount' => $instAmount,
+            ];
+        }
+
+        usort($rows, static fn ($a, $b) => $b['total_balance'] <=> $a['total_balance']);
+
+        $nextInstallment = (new \DateTime('now', $tz))
+            ->modify('first day of next month')
+            ->format('Y-m-d');
+
+        $parentIds = array_values(array_unique(array_map(static fn ($row) => (int) ($row['parent_id'] ?? 0), $rows)));
+        $hasPayments = [];
+        $paidTotals = [];
+        $paymentCounts = [];
+        if (!empty($parentIds)) {
+            $pRows = DB::table('payments')
+                ->selectRaw('parent_id, SUM(paid_amount) AS total_paid, COUNT(*) AS payment_count')
+                ->whereIn('parent_id', $parentIds)
+                ->where('school_year', $schoolYear)
+                ->groupBy('parent_id')
+                ->get()
+                ->map(fn ($row) => (array) $row)
+                ->all();
+
+            foreach ($pRows as $row) {
+                $parentId = (int) ($row['parent_id'] ?? 0);
+                if ($parentId > 0) {
+                    $hasPayments[$parentId] = true;
+                    $paidTotals[$parentId] = (float) ($row['total_paid'] ?? 0);
+                    $paymentCounts[$parentId] = (int) ($row['payment_count'] ?? 0);
+                }
+            }
+        }
+
+        $results = array_map(function (array $row) use ($hasPayments, $paidTotals, $paymentCounts, $nextInstallment) {
+            $parentId = (int) ($row['parent_id'] ?? 0);
+            $name = trim((string) ($row['firstname'] ?? '') . ' ' . (string) ($row['lastname'] ?? ''));
+            return [
+                'parent_id' => $parentId,
+                'parent_name' => $name,
+                'email' => (string) ($row['email'] ?? ''),
+                'total_invoice' => (float) ($row['total_invoice'] ?? 0),
+                'total_balance' => (float) ($row['total_balance'] ?? 0),
+                'total_discount' => (float) ($row['total_discount'] ?? 0),
+                'remaining_installments' => (int) ($row['remaining_installments'] ?? 0),
+                'installment_amount' => (float) ($row['installment_amount'] ?? 0),
+                'type' => isset($hasPayments[$parentId]) ? 'installment' : 'no_payment',
+                'total_paid' => isset($paidTotals[$parentId]) ? (float) $paidTotals[$parentId] : 0.0,
+                'payment_count' => isset($paymentCounts[$parentId]) ? (int) $paymentCounts[$parentId] : 0,
+                'has_installment' => isset($hasPayments[$parentId]) ? 1 : 0,
+                'next_installment' => $nextInstallment,
+            ];
+        }, $rows);
+
+        return [
+            'schoolYear' => $schoolYear,
+            'schoolYears' => $schoolYears,
+            'results' => $results,
+        ];
+    }
+}
diff --git a/app/Services/Grading/GradingBelowSixtyService.php b/app/Services/Grading/GradingBelowSixtyService.php
new file mode 100644
index 00000000..8c9cca94
--- /dev/null
+++ b/app/Services/Grading/GradingBelowSixtyService.php
@@ -0,0 +1,403 @@
+<?php
+
+namespace App\Services\Grading;
+
+use App\Models\CurrentFlag;
+use App\Models\ParentMeetingSchedule;
+use App\Models\ScoreComment;
+use App\Models\Student;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Event;
+use RuntimeException;
+
+class GradingBelowSixtyService
+{
+    public function listRows(string $schoolYear, string $semester): array
+    {
+        $semesterKey = strtolower(trim($semester));
+        $rows = DB::table('semester_scores as ss')
+            ->select([
+                's.id as student_id',
+                's.school_id',
+                's.firstname',
+                's.lastname',
+                'cs.class_section_name',
+                'ss.homework_avg',
+                'ss.project_avg',
+                'ss.participation_score',
+                DB::raw('COALESCE(ss.test_avg, ss.quiz_avg) as test_avg'),
+                'ss.ptap_score',
+                'ss.attendance_score',
+                'ss.midterm_exam_score',
+                'ss.final_exam_score',
+                'ss.semester_score',
+            ])
+            ->join('students as s', 's.id', '=', 'ss.student_id')
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'ss.class_section_id')
+            ->where('s.is_active', 1)
+            ->where('ss.school_year', $schoolYear)
+            ->whereRaw('LOWER(TRIM(ss.semester)) = ?', [$semesterKey])
+            ->whereNotNull('ss.semester_score')
+            ->where('ss.semester_score', '<', 60)
+            ->orderBy('s.lastname', 'ASC')
+            ->orderBy('s.firstname', 'ASC')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        if (empty($rows)) {
+            return [];
+        }
+
+        $studentIds = array_values(array_unique(array_map(
+            static fn ($r) => (int) ($r['student_id'] ?? 0),
+            $rows
+        )));
+        $studentIds = array_values(array_filter($studentIds, static fn ($id) => $id > 0));
+
+        $commentMap = [];
+        if (!empty($studentIds)) {
+            $commentRows = ScoreComment::query()
+                ->select('student_id', 'comment', 'created_at')
+                ->where('score_type', 'general')
+                ->where('school_year', $schoolYear)
+                ->whereRaw('LOWER(TRIM(semester)) = ?', [$semesterKey])
+                ->whereIn('student_id', $studentIds)
+                ->orderBy('created_at', 'DESC')
+                ->get();
+            foreach ($commentRows as $row) {
+                $sid = (int) $row->student_id;
+                if ($sid > 0 && !isset($commentMap[$sid])) {
+                    $commentMap[$sid] = (string) ($row->comment ?? '');
+                }
+            }
+        }
+
+        $statusMap = [];
+        if (!empty($studentIds)) {
+            $flagRows = CurrentFlag::query()
+                ->select('student_id', 'flag_state')
+                ->where('flag', 'grade')
+                ->where('school_year', $schoolYear)
+                ->whereRaw('LOWER(TRIM(semester)) = ?', [$semesterKey])
+                ->whereIn('student_id', $studentIds)
+                ->get();
+            foreach ($flagRows as $row) {
+                $sid = (int) $row->student_id;
+                if ($sid > 0) {
+                    $statusMap[$sid] = (string) ($row->flag_state ?? '');
+                }
+            }
+        }
+
+        foreach ($rows as &$row) {
+            $sid = (int) ($row['student_id'] ?? 0);
+            $row['comment'] = $commentMap[$sid] ?? '';
+            $flagState = strtolower(trim((string) ($statusMap[$sid] ?? '')));
+            $row['status'] = ($flagState === 'closed' || $flagState === 'canceled') ? 'Closed' : 'Open';
+        }
+        unset($row);
+
+        return $rows;
+    }
+
+    public function emailContext(int $studentId, string $schoolYear, string $semester): array
+    {
+        $row = $this->fetchBelowSixtyEmailRow($studentId, $schoolYear, $semester);
+        if (empty($row)) {
+            throw new RuntimeException('Student record not found for the selected term.');
+        }
+
+        $studentName = trim((string) ($row['firstname'] ?? '') . ' ' . (string) ($row['lastname'] ?? ''));
+        $subject = $this->buildBelowSixtySubject($studentName, $semester, $schoolYear);
+        $parentName = $this->fetchBelowSixtyParentName($studentId);
+
+        $scores = [
+            'homework_avg' => $row['homework_avg'] ?? null,
+            'project_avg' => $row['project_avg'] ?? null,
+            'participation_score' => $row['participation_score'] ?? null,
+            'test_avg' => $row['test_avg'] ?? null,
+            'ptap_score' => $row['ptap_score'] ?? null,
+            'attendance_score' => $row['attendance_score'] ?? null,
+            'midterm_exam_score' => $row['midterm_exam_score'] ?? null,
+            'semester_score' => $row['semester_score'] ?? null,
+        ];
+
+        return [
+            'student_id' => $studentId,
+            'student_name' => $studentName !== '' ? $studentName : 'Student',
+            'parent_name' => $parentName,
+            'class_section_name' => $row['class_section_name'] ?? '',
+            'semester' => $semester,
+            'school_year' => $schoolYear,
+            'scores' => $scores,
+            'comment' => $row['comment'] ?? '',
+            'subject' => $subject,
+        ];
+    }
+
+    public function sendEmail(array $payload): void
+    {
+        Event::dispatch('below60.email', $payload);
+    }
+
+    public function updateStatus(int $studentId, string $semester, string $schoolYear, string $status, string $note, ?int $userId): void
+    {
+        $status = ucfirst(strtolower($status));
+        if (!in_array($status, ['Open', 'Closed'], true)) {
+            throw new RuntimeException('Invalid status.');
+        }
+
+        $semesterKey = strtolower(trim($semester));
+        $existing = CurrentFlag::query()
+            ->where('student_id', $studentId)
+            ->where('flag', 'grade')
+            ->where('school_year', $schoolYear)
+            ->whereRaw('LOWER(TRIM(semester)) = ?', [$semesterKey])
+            ->first();
+
+        $now = now();
+
+        if ($existing) {
+            $data = [
+                'flag_state' => $status,
+                'flag_datetime' => $now,
+                'updated_at' => $now,
+            ];
+            if ($status === 'Open') {
+                $data['updated_by_open'] = $userId;
+                if ($note !== '') {
+                    $prev = (string) ($existing->open_description ?? '');
+                    $data['open_description'] = trim($prev . PHP_EOL . $note);
+                }
+            } else {
+                $data['updated_by_closed'] = $userId;
+                if ($note !== '') {
+                    $prev = (string) ($existing->close_description ?? '');
+                    $data['close_description'] = trim($prev . PHP_EOL . $note);
+                }
+            }
+            $existing->update($data);
+            return;
+        }
+
+        $row = $this->fetchBelowSixtyEmailRow($studentId, $schoolYear, $semester);
+        $studentName = trim((string) ($row['firstname'] ?? '') . ' ' . (string) ($row['lastname'] ?? ''));
+        $grade = (string) ($row['class_section_name'] ?? '');
+        $data = [
+            'student_id' => $studentId,
+            'student_name' => $studentName !== '' ? $studentName : 'Student',
+            'grade' => $grade,
+            'flag' => 'grade',
+            'flag_datetime' => $now,
+            'flag_state' => $status,
+            'semester' => $semester,
+            'school_year' => $schoolYear,
+            'updated_at' => $now,
+        ];
+        if ($status === 'Open') {
+            $data['updated_by_open'] = $userId;
+            if ($note !== '') {
+                $data['open_description'] = $note;
+            }
+        } else {
+            $data['updated_by_closed'] = $userId;
+            if ($note !== '') {
+                $data['close_description'] = $note;
+            }
+        }
+
+        CurrentFlag::query()->create($data);
+    }
+
+    public function meetingContext(int $studentId, string $schoolYear, string $semester): array
+    {
+        $context = $this->fetchBelowSixtyMeetingContext($studentId, $schoolYear, $semester);
+        if (empty($context)) {
+            throw new RuntimeException('Student record not found for the selected term.');
+        }
+
+        return $context + [
+            'student_id' => $studentId,
+            'semester' => $semester,
+            'school_year' => $schoolYear,
+        ];
+    }
+
+    public function saveMeeting(array $payload, ?int $userId): void
+    {
+        $studentId = (int) ($payload['student_id'] ?? 0);
+        $semester = (string) ($payload['semester'] ?? '');
+        $schoolYear = (string) ($payload['school_year'] ?? '');
+        $date = trim((string) ($payload['date'] ?? ''));
+        $time = trim((string) ($payload['time'] ?? ''));
+        $notes = trim((string) ($payload['notes'] ?? ''));
+
+        if ($studentId <= 0 || $semester === '' || $schoolYear === '' || $date === '') {
+            throw new RuntimeException('Missing required fields.');
+        }
+
+        $context = $this->fetchBelowSixtyMeetingContext($studentId, $schoolYear, $semester);
+        if (empty($context)) {
+            throw new RuntimeException('Student record not found for the selected term.');
+        }
+
+        ParentMeetingSchedule::query()->create([
+            'student_id' => $studentId,
+            'parent_user_id' => $context['parent_user_id'] ?? null,
+            'parent_name' => $context['parent_name'],
+            'student_name' => $context['student_name'],
+            'class_section_name' => $context['class_section_name'],
+            'date' => $date,
+            'time' => $time !== '' ? $time : null,
+            'notes' => $notes !== '' ? $notes : null,
+            'semester' => $semester,
+            'school_year' => $schoolYear,
+            'status' => 'scheduled',
+            'created_by' => $userId,
+        ]);
+    }
+
+    private function fetchBelowSixtyEmailRow(int $studentId, string $schoolYear, string $semester): array
+    {
+        $semesterKey = strtolower(trim($semester));
+        $row = DB::table('semester_scores as ss')
+            ->select([
+                's.id as student_id',
+                's.firstname',
+                's.lastname',
+                'cs.class_section_name',
+                'ss.homework_avg',
+                'ss.project_avg',
+                'ss.participation_score',
+                DB::raw('COALESCE(ss.test_avg, ss.quiz_avg) as test_avg'),
+                'ss.ptap_score',
+                'ss.attendance_score',
+                'ss.midterm_exam_score',
+                'ss.semester_score',
+            ])
+            ->join('students as s', 's.id', '=', 'ss.student_id')
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'ss.class_section_id')
+            ->where('ss.school_year', $schoolYear)
+            ->where('ss.student_id', $studentId)
+            ->where('s.is_active', 1)
+            ->whereRaw('LOWER(TRIM(ss.semester)) = ?', [$semesterKey])
+            ->first();
+
+        if (!$row) {
+            return [];
+        }
+
+        $commentRow = ScoreComment::query()
+            ->select('comment')
+            ->where('score_type', 'general')
+            ->where('school_year', $schoolYear)
+            ->whereRaw('LOWER(TRIM(semester)) = ?', [$semesterKey])
+            ->where('student_id', $studentId)
+            ->orderBy('created_at', 'DESC')
+            ->first();
+
+        $row = (array) $row;
+        $row['comment'] = (string) ($commentRow?->comment ?? '');
+
+        return $row;
+    }
+
+    private function fetchBelowSixtyParentName(int $studentId): string
+    {
+        $parentName = 'Parent/Guardian';
+        try {
+            $rows = DB::select(
+                "SELECT u.firstname, u.lastname
+                   FROM family_students fs
+                   JOIN family_guardians fg ON fg.family_id = fs.family_id
+                   JOIN users u ON u.id = fg.user_id
+                  WHERE fs.student_id = ?
+                  ORDER BY fg.is_primary DESC, u.lastname, u.firstname
+                  LIMIT 1",
+                [$studentId]
+            );
+            if (!empty($rows[0])) {
+                $candidate = trim((string) ($rows[0]->firstname ?? '') . ' ' . (string) ($rows[0]->lastname ?? ''));
+                if ($candidate !== '') {
+                    $parentName = $candidate;
+                }
+            }
+        } catch (\Throwable $e) {
+        }
+        return $parentName;
+    }
+
+    private function buildBelowSixtySubject(string $studentName, string $semester, string $schoolYear): string
+    {
+        $subject = 'Student Performance Alert';
+        if ($studentName !== '') {
+            $subject .= ' — ' . $studentName;
+        }
+        if ($semester !== '' || $schoolYear !== '') {
+            $subject .= ' (' . trim($semester . ' ' . $schoolYear) . ')';
+        }
+        return $subject;
+    }
+
+    private function fetchBelowSixtyMeetingContext(int $studentId, string $schoolYear, string $semester): array
+    {
+        $row = $this->fetchBelowSixtyEmailRow($studentId, $schoolYear, $semester);
+        if (empty($row)) {
+            return [];
+        }
+
+        $parentName = 'Parent/Guardian';
+        $parentUserId = null;
+        try {
+            $pRows = DB::select(
+                "SELECT u.id AS user_id, u.firstname, u.lastname
+                   FROM family_students fs
+                   JOIN family_guardians fg ON fg.family_id = fs.family_id
+                   JOIN users u ON u.id = fg.user_id
+                  WHERE fs.student_id = ?
+                  ORDER BY fg.is_primary DESC, u.lastname, u.firstname
+                  LIMIT 1",
+                [$studentId]
+            );
+            if (!empty($pRows[0])) {
+                $parentUserId = (int) ($pRows[0]->user_id ?? 0) ?: null;
+                $parentName = trim((string) ($pRows[0]->firstname ?? '') . ' ' . (string) ($pRows[0]->lastname ?? ''));
+                if ($parentName === '') {
+                    $parentName = 'Parent/Guardian';
+                }
+            }
+        } catch (\Throwable $e) {
+        }
+
+        if ($parentUserId === null) {
+            try {
+                $srow = DB::selectOne(
+                    "SELECT s.parent_id, u.firstname, u.lastname
+                       FROM students s
+                       LEFT JOIN users u ON u.id = s.parent_id
+                      WHERE s.id = ?
+                      LIMIT 1",
+                    [$studentId]
+                );
+                if (!empty($srow)) {
+                    $parentUserId = (int) ($srow->parent_id ?? 0) ?: null;
+                    $fallbackName = trim((string) ($srow->firstname ?? '') . ' ' . (string) ($srow->lastname ?? ''));
+                    if ($fallbackName !== '') {
+                        $parentName = $fallbackName;
+                    }
+                }
+            } catch (\Throwable $e) {
+            }
+        }
+
+        $studentName = trim((string) ($row['firstname'] ?? '') . ' ' . (string) ($row['lastname'] ?? ''));
+
+        return [
+            'student_name' => $studentName !== '' ? $studentName : 'Student',
+            'parent_name' => $parentName,
+            'parent_user_id' => $parentUserId,
+            'class_section_name' => (string) ($row['class_section_name'] ?? ''),
+        ];
+    }
+}
diff --git a/app/Services/Grading/GradingLockService.php b/app/Services/Grading/GradingLockService.php
new file mode 100644
index 00000000..9e5e1bbd
--- /dev/null
+++ b/app/Services/Grading/GradingLockService.php
@@ -0,0 +1,118 @@
+<?php
+
+namespace App\Services\Grading;
+
+use App\Models\GradingLock;
+use App\Models\ClassSection;
+use RuntimeException;
+
+class GradingLockService
+{
+    public function toggle(int $classSectionId, string $semester, string $schoolYear, ?int $userId): bool
+    {
+        if ($classSectionId <= 0 || $semester === '' || $schoolYear === '') {
+            throw new RuntimeException('Missing class section or term.');
+        }
+
+        $existing = GradingLock::getLock($classSectionId, $semester, $schoolYear);
+
+        if ($existing && $existing->is_locked) {
+            $existing->update([
+                'is_locked' => 0,
+                'locked_by' => null,
+                'locked_at' => null,
+            ]);
+            return false;
+        }
+
+        if ($existing) {
+            $existing->update([
+                'is_locked' => 1,
+                'locked_by' => $userId ?: null,
+                'locked_at' => now(),
+            ]);
+        } else {
+            GradingLock::query()->create([
+                'class_section_id' => $classSectionId,
+                'semester' => $semester,
+                'school_year' => $schoolYear,
+                'is_locked' => 1,
+                'locked_by' => $userId ?: null,
+                'locked_at' => now(),
+            ]);
+        }
+
+        return true;
+    }
+
+    public function lockAll(string $semester, string $schoolYear, ?int $userId): int
+    {
+        if ($semester === '' || $schoolYear === '') {
+            throw new RuntimeException('Missing semester or school year.');
+        }
+
+        $sectionIds = ClassSection::query()
+            ->select('class_section_id')
+            ->groupBy('class_section_id')
+            ->pluck('class_section_id')
+            ->map(fn ($v) => (int) $v)
+            ->filter(fn ($v) => $v > 0)
+            ->values()
+            ->all();
+
+        if (empty($sectionIds)) {
+            return 0;
+        }
+
+        $existingLocks = GradingLock::query()
+            ->whereIn('class_section_id', $sectionIds)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->get();
+
+        $existingBySection = [];
+        foreach ($existingLocks as $row) {
+            $sid = (int) $row->class_section_id;
+            if ($sid > 0) {
+                $existingBySection[$sid] = $row;
+            }
+        }
+
+        $now = now();
+        $insertRows = [];
+        $count = 0;
+
+        foreach ($sectionIds as $sid) {
+            if (!empty($existingBySection[$sid])) {
+                if ($existingBySection[$sid]->is_locked) {
+                    continue;
+                }
+                $existingBySection[$sid]->update([
+                    'is_locked' => 1,
+                    'locked_by' => $userId ?: null,
+                    'locked_at' => $now,
+                ]);
+                $count++;
+                continue;
+            }
+
+            $insertRows[] = [
+                'class_section_id' => $sid,
+                'semester' => $semester,
+                'school_year' => $schoolYear,
+                'is_locked' => 1,
+                'locked_by' => $userId ?: null,
+                'locked_at' => $now,
+                'created_at' => $now,
+                'updated_at' => $now,
+            ];
+            $count++;
+        }
+
+        if (!empty($insertRows)) {
+            GradingLock::query()->insert($insertRows);
+        }
+
+        return $count;
+    }
+}
diff --git a/app/Services/Grading/GradingOverviewService.php b/app/Services/Grading/GradingOverviewService.php
new file mode 100644
index 00000000..1fe2228a
--- /dev/null
+++ b/app/Services/Grading/GradingOverviewService.php
@@ -0,0 +1,439 @@
+<?php
+
+namespace App\Services\Grading;
+
+use App\Models\AttendanceRecord;
+use App\Models\CalendarEvent;
+use App\Models\Configuration;
+use App\Models\ClassSection;
+use App\Models\GradingLock;
+use App\Models\Student;
+use App\Services\Scores\AttendanceCalculator;
+use App\Services\Scores\SemesterScoreService;
+use Illuminate\Support\Facades\DB;
+
+class GradingOverviewService
+{
+    private AttendanceCalculator $attendanceCalculator;
+
+    public function __construct(private SemesterScoreService $semesterScoreService)
+    {
+        $this->attendanceCalculator = new AttendanceCalculator(
+            new AttendanceRecord(),
+            new Configuration(),
+            new CalendarEvent()
+        );
+    }
+
+    public function overview(?int $classId, ?string $semester, ?string $schoolYear): array
+    {
+        $schoolYear = $schoolYear ?: (string) (Configuration::getConfig('school_year') ?? '');
+        $configuredSemester = (string) (Configuration::getConfig('semester') ?? '');
+        $semesterOptions = $this->getSemestersForSchoolYear($schoolYear, $configuredSemester);
+        $semester = $this->resolveSemesterSelection($semester, $semesterOptions, $configuredSemester);
+
+        $this->ensureParentReleaseKeyExists('Fall');
+        $this->ensureParentReleaseKeyExists('Spring');
+        $scoresReleased = $this->getParentScoresReleasedForSemester($semester);
+        $scoresReleasedFall = $this->getParentScoresReleasedForSemester('Fall');
+        $scoresReleasedSpring = $this->getParentScoresReleasedForSemester('Spring');
+
+        if ($classId && $this->semesterScoreService) {
+            $sectionIds = ClassSection::query()
+                ->select('class_section_id')
+                ->where('class_id', $classId)
+                ->pluck('class_section_id')
+                ->map(fn ($v) => (int) $v)
+                ->all();
+            foreach ($sectionIds as $sectionId) {
+                $studentTeacherInfo = Student::getStudentInfoByClassSectionId(
+                    $sectionId,
+                    $semester,
+                    $schoolYear
+                );
+                if (empty($studentTeacherInfo)) {
+                    continue;
+                }
+                try {
+                    $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
+                } catch (\Throwable $e) {
+                }
+            }
+        }
+
+        $rows = $this->buildGradingRows($semester, $schoolYear);
+
+        $counts = $this->loadScoreCounts($rows, $semester, $schoolYear);
+
+        $sectionsNeedingRefresh = [];
+        foreach ($rows as $row) {
+            $sectionId = (int) ($row['section_id'] ?? 0);
+            if ($sectionId <= 0) {
+                continue;
+            }
+            if ($row['ss_ptap_score'] === null || $row['ss_semester_score'] === null) {
+                $sectionsNeedingRefresh[$sectionId] = true;
+            }
+        }
+
+        if (!empty($sectionsNeedingRefresh)) {
+            foreach (array_keys($sectionsNeedingRefresh) as $sectionId) {
+                $studentTeacherInfo = Student::getStudentInfoByClassSectionId(
+                    $sectionId,
+                    $semester,
+                    $schoolYear
+                );
+                if (empty($studentTeacherInfo)) {
+                    continue;
+                }
+                try {
+                    $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
+                } catch (\Throwable $e) {
+                }
+            }
+            $rows = $this->buildGradingRows($semester, $schoolYear);
+        }
+
+        $grades = [];
+        $studentsBySection = [];
+        foreach ($rows as $row) {
+            $sectionId = (int) ($row['section_id'] ?? 0);
+            $classIdValue = (int) ($row['class_id'] ?? 0);
+            $sectionName = (string) ($row['class_section_name'] ?? '');
+            if ($sectionId <= 0 || $classIdValue <= 0) {
+                continue;
+            }
+
+            if (!isset($grades[$classIdValue])) {
+                $grades[$classIdValue] = [];
+            }
+            $exists = false;
+            foreach ($grades[$classIdValue] as $section) {
+                if ((int) $section['class_section_id'] === $sectionId) {
+                    $exists = true;
+                    break;
+                }
+            }
+            if (!$exists) {
+                $grades[$classIdValue][] = [
+                    'class_section_id' => $sectionId,
+                    'class_section_name' => $sectionName,
+                ];
+            }
+
+            $studentId = (int) ($row['student_id'] ?? 0);
+            if ($studentId <= 0) {
+                continue;
+            }
+
+            $attendanceScore = $this->calculateAttendanceScoreForStudent(
+                $studentId,
+                $semester,
+                $schoolYear,
+                $sectionId
+            );
+            if ($attendanceScore === null) {
+                $rawAttendance = $row['ss_attendance_score'] ?? null;
+                if ($rawAttendance !== null && $rawAttendance !== '') {
+                    $attendanceScore = round((float) $rawAttendance, 2);
+                }
+            }
+
+            $studentRow = [
+                'id' => $studentId,
+                'school_id' => $row['school_id'] ?? null,
+                'firstname' => $row['firstname'] ?? null,
+                'lastname' => $row['lastname'] ?? null,
+                'class_id' => $classIdValue,
+                'ptap' => $this->normalizeScore($row['ss_ptap_score'] ?? null),
+                'semester_score' => $this->normalizeScore($row['ss_semester_score'] ?? null),
+                'attendance' => $attendanceScore,
+                'homework_avg' => $this->normalizeCountedScore($row['ss_homework_avg'] ?? null, $counts['homework'] ?? [], $sectionId, $studentId),
+                'project_avg' => $this->normalizeCountedScore($row['ss_project_avg'] ?? null, $counts['project'] ?? [], $sectionId, $studentId),
+                'quiz_avg' => $this->normalizeCountedScore($row['ss_quiz_avg'] ?? null, $counts['quiz'] ?? [], $sectionId, $studentId),
+                'participation' => $this->normalizeCountedScore($row['ss_participation_score'] ?? null, $counts['participation'] ?? [], $sectionId, $studentId),
+                'midterm_exam' => $this->normalizeCountedScore($row['ss_midterm_exam_score'] ?? null, $counts['midterm'] ?? [], $sectionId, $studentId),
+                'final_exam' => $this->normalizeScore($row['ss_final_exam_score'] ?? null),
+                'matched_biz_csid' => $row['matched_biz_csid'] ?? null,
+                'matched_pk_csid' => $row['matched_pk_csid'] ?? null,
+                'placement_level' => $row['placement_level'] ?? null,
+            ];
+
+            $studentsBySection[$sectionId][] = $studentRow;
+        }
+
+        $scoreLocks = $this->loadScoreLocks($grades, $semester, $schoolYear);
+
+        return [
+            'grades' => $grades,
+            'students_by_section' => $studentsBySection,
+            'semester' => $semester,
+            'school_year' => $schoolYear,
+            'requested_class_id' => $classId,
+            'semester_options' => $semesterOptions,
+            'scores_released' => $scoresReleased,
+            'scores_released_fall' => $scoresReleasedFall,
+            'scores_released_spring' => $scoresReleasedSpring,
+            'score_locks' => $scoreLocks,
+        ];
+    }
+
+    private function buildGradingRows(string $semester, string $schoolYear): array
+    {
+        $semLower = strtolower(trim($semester));
+
+        return DB::table('student_class as sc')
+            ->select([
+                'cs.id as section_pk',
+                'cs.class_section_id as section_id',
+                'cs.class_id as class_id',
+                'cs.class_section_name',
+                's.id as student_id',
+                's.school_id',
+                's.firstname',
+                's.lastname',
+                'pl.level as placement_level',
+                DB::raw('COALESCE(ss_b.ptap_score, ss_p.ptap_score) as ss_ptap_score'),
+                DB::raw('COALESCE(ss_b.semester_score, ss_p.semester_score) as ss_semester_score'),
+                DB::raw('COALESCE(ss_b.attendance_score, ss_p.attendance_score) as ss_attendance_score'),
+                DB::raw('COALESCE(ss_b.homework_avg, ss_p.homework_avg) as ss_homework_avg'),
+                DB::raw('COALESCE(ss_b.project_avg, ss_p.project_avg) as ss_project_avg'),
+                DB::raw('COALESCE(ss_b.quiz_avg, ss_p.quiz_avg) as ss_quiz_avg'),
+                DB::raw('COALESCE(ss_b.participation_score, ss_p.participation_score) as ss_participation_score'),
+                DB::raw('COALESCE(ss_b.midterm_exam_score, ss_p.midterm_exam_score) as ss_midterm_exam_score'),
+                DB::raw('COALESCE(ss_b.final_exam_score, ss_p.final_exam_score) as ss_final_exam_score'),
+                'ss_b.class_section_id as matched_biz_csid',
+                'ss_p.class_section_id as matched_pk_csid',
+            ])
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'sc.class_section_id')
+            ->join('students as s', 's.id', '=', 'sc.student_id')
+            ->leftJoin('placement_levels as pl', function ($join) use ($schoolYear) {
+                $join->on('pl.student_id', '=', 's.id')
+                    ->where('pl.school_year', '=', $schoolYear);
+            })
+            ->leftJoin('semester_scores as ss_b', function ($join) use ($semLower, $schoolYear) {
+                $join->on('ss_b.student_id', '=', 's.id')
+                    ->on('ss_b.class_section_id', '=', 'sc.class_section_id')
+                    ->whereRaw('LOWER(TRIM(ss_b.semester)) = ?', [$semLower])
+                    ->where('ss_b.school_year', '=', $schoolYear);
+            })
+            ->leftJoin('semester_scores as ss_p', function ($join) use ($semLower, $schoolYear) {
+                $join->on('ss_p.student_id', '=', 's.id')
+                    ->on('ss_p.class_section_id', '=', 'cs.id')
+                    ->whereRaw('LOWER(TRIM(ss_p.semester)) = ?', [$semLower])
+                    ->where('ss_p.school_year', '=', $schoolYear);
+            })
+            ->where('sc.school_year', $schoolYear)
+            ->where('s.is_active', 1)
+            ->orderBy('cs.class_id', 'ASC')
+            ->orderBy('cs.class_section_name', 'ASC')
+            ->orderBy('s.lastname', 'ASC')
+            ->orderBy('s.firstname', 'ASC')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+
+    private function loadScoreCounts(array $rows, string $semester, string $schoolYear): array
+    {
+        $sectionIds = [];
+        $studentIds = [];
+        foreach ($rows as $row) {
+            $studentId = (int) ($row['student_id'] ?? 0);
+            $sectionId = (int) ($row['section_id'] ?? 0);
+            if ($studentId > 0) {
+                $studentIds[$studentId] = true;
+            }
+            if ($sectionId > 0) {
+                $sectionIds[$sectionId] = true;
+            }
+        }
+
+        $sectionIds = array_keys($sectionIds);
+        $studentIds = array_keys($studentIds);
+        if (empty($sectionIds) || empty($studentIds)) {
+            return [
+                'quiz' => [],
+                'homework' => [],
+                'project' => [],
+                'participation' => [],
+                'midterm' => [],
+            ];
+        }
+
+        return [
+            'quiz' => $this->countScores('quiz', $sectionIds, $studentIds, $semester, $schoolYear),
+            'homework' => $this->countScores('homework', $sectionIds, $studentIds, $semester, $schoolYear),
+            'project' => $this->countScores('project', $sectionIds, $studentIds, $semester, $schoolYear),
+            'participation' => $this->countScores('participation', $sectionIds, $studentIds, $semester, $schoolYear),
+            'midterm' => $this->countScores('midterm_exam', $sectionIds, $studentIds, $semester, $schoolYear),
+        ];
+    }
+
+    private function countScores(string $table, array $sectionIds, array $studentIds, string $semester, string $schoolYear): array
+    {
+        $rows = DB::table($table)
+            ->select('student_id', 'class_section_id', DB::raw('COUNT(*) as cnt'))
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->whereIn('class_section_id', $sectionIds)
+            ->whereIn('student_id', $studentIds)
+            ->whereNotNull('score')
+            ->groupBy('student_id', 'class_section_id')
+            ->get();
+
+        $counts = [];
+        foreach ($rows as $row) {
+            $counts[(int) $row->class_section_id][(int) $row->student_id] = (int) $row->cnt;
+        }
+
+        return $counts;
+    }
+
+    private function loadScoreLocks(array $grades, string $semester, string $schoolYear): array
+    {
+        $sectionIds = [];
+        foreach ($grades as $sections) {
+            foreach ($sections as $section) {
+                $sid = (int) ($section['class_section_id'] ?? 0);
+                if ($sid > 0) {
+                    $sectionIds[$sid] = true;
+                }
+            }
+        }
+        $sectionIds = array_keys($sectionIds);
+        if (empty($sectionIds)) {
+            return [];
+        }
+
+        $locks = GradingLock::query()
+            ->whereIn('class_section_id', $sectionIds)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->get();
+
+        $map = [];
+        foreach ($locks as $lock) {
+            $map[(int) $lock->class_section_id] = (bool) $lock->is_locked;
+        }
+
+        return $map;
+    }
+
+    private function calculateAttendanceScoreForStudent(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): ?float
+    {
+        try {
+            $result = $this->attendanceCalculator->calculate($studentId, $semester, $schoolYear, $classSectionId);
+            $score = $result['attendance_score'] ?? null;
+            if ($score === null || $score === '') {
+                return null;
+            }
+            return round((float) $score, 2);
+        } catch (\Throwable $e) {
+        }
+
+        return null;
+    }
+
+    private function normalizeScore($value): ?float
+    {
+        if ($value === null || $value === '') {
+            return null;
+        }
+        return round((float) $value, 2);
+    }
+
+    private function normalizeCountedScore($value, array $countMap, int $sectionId, int $studentId): ?float
+    {
+        $score = $this->normalizeScore($value);
+        if ($score !== null && (float) $score === 0.0) {
+            $count = (int) ($countMap[$sectionId][$studentId] ?? 0);
+            if ($count === 0) {
+                return null;
+            }
+        }
+        return $score;
+    }
+
+    private function resolveSemesterSelection(?string $requestedSemester, array $semesterOptions, ?string $fallbackSemester): string
+    {
+        if ($requestedSemester !== null && $requestedSemester !== '') {
+            foreach ($semesterOptions as $option) {
+                if (strcasecmp($option, $requestedSemester) === 0) {
+                    return $option;
+                }
+            }
+            return $requestedSemester;
+        }
+        if ($fallbackSemester !== null && $fallbackSemester !== '') {
+            foreach ($semesterOptions as $option) {
+                if (strcasecmp($option, $fallbackSemester) === 0) {
+                    return $option;
+                }
+            }
+            return $fallbackSemester;
+        }
+        return $semesterOptions[0] ?? '';
+    }
+
+    private function getSemestersForSchoolYear(string $schoolYear, ?string $fallbackSemester = null): array
+    {
+        $rows = DB::table('semester_scores')
+            ->select(DB::raw('DISTINCT semester'))
+            ->whereNotNull('semester')
+            ->where('semester', '!=', '')
+            ->where('school_year', $schoolYear)
+            ->orderBy('semester', 'ASC')
+            ->get();
+
+        $semesters = [];
+        foreach ($rows as $row) {
+            $value = trim((string) $row->semester);
+            if ($value !== '') {
+                $semesters[] = $value;
+            }
+        }
+
+        if (empty($semesters)) {
+            $semesters = ['Fall', 'Spring'];
+        }
+
+        if ($fallbackSemester !== null && $fallbackSemester !== '' && !in_array($fallbackSemester, $semesters, true)) {
+            array_unshift($semesters, $fallbackSemester);
+        }
+
+        return array_values(array_unique($semesters));
+    }
+
+    private function getParentReleaseKey(string $semester): ?string
+    {
+        $norm = strtolower(trim($semester));
+        if ($norm === 'fall') {
+            return 'parent_scores_released_fall';
+        }
+        if ($norm === 'spring') {
+            return 'parent_scores_released_spring';
+        }
+        return null;
+    }
+
+    private function getParentScoresReleasedForSemester(string $semester): bool
+    {
+        $key = $this->getParentReleaseKey($semester);
+        $raw = $key ? Configuration::getConfig($key) : null;
+        $raw = (string) ($raw ?? '');
+        return in_array(strtolower(trim($raw)), ['1', 'true', 'yes', 'y', 'on'], true);
+    }
+
+    private function ensureParentReleaseKeyExists(string $semester): void
+    {
+        $key = $this->getParentReleaseKey($semester);
+        if (!$key) {
+            return;
+        }
+
+        if (Configuration::getConfigValueByKey($key) === null) {
+            Configuration::setConfigValueByKey($key, '0');
+        }
+    }
+}
diff --git a/app/Services/Grading/GradingPlacementService.php b/app/Services/Grading/GradingPlacementService.php
new file mode 100644
index 00000000..63a36d2f
--- /dev/null
+++ b/app/Services/Grading/GradingPlacementService.php
@@ -0,0 +1,372 @@
+<?php
+
+namespace App\Services\Grading;
+
+use App\Models\ClassSection;
+use App\Models\PlacementBatch;
+use App\Models\PlacementLevel;
+use App\Models\PlacementScore;
+use App\Models\Student;
+use Illuminate\Support\Facades\DB;
+use RuntimeException;
+
+class GradingPlacementService
+{
+    public function placementContext(?int $classSectionId, string $schoolYear, ?string $placementTest, ?string $open): array
+    {
+        if (!$classSectionId) {
+            $showStudents = ($placementTest !== '' && $open === '1');
+            $students = $showStudents ? $this->fetchActiveStudentsWithSection($schoolYear) : [];
+            $batches = $this->fetchPlacementBatches($schoolYear);
+            $batchDetails = $this->fetchPlacementBatchDetails($batches, $schoolYear);
+
+            return [
+                'school_year' => $schoolYear,
+                'students' => $students,
+                'batches' => $batches,
+                'batch_details' => $batchDetails,
+                'placement_test' => $placementTest,
+                'show_students' => $showStudents,
+            ];
+        }
+
+        $sectionName = ClassSection::query()->where('class_section_id', $classSectionId)->value('class_section_name');
+        $classId = ClassSection::query()->where('class_section_id', $classSectionId)->value('class_id');
+
+        $students = Student::getStudentInfoByClassSectionId($classSectionId, null, $schoolYear);
+        $studentIds = array_values(array_filter(array_map(
+            static fn ($row) => (int) ($row['student_id'] ?? 0),
+            $students
+        ), static fn ($id) => $id > 0));
+
+        $levels = [];
+        if (!empty($studentIds)) {
+            $rows = PlacementLevel::query()
+                ->whereIn('student_id', $studentIds)
+                ->where('school_year', $schoolYear)
+                ->get();
+            foreach ($rows as $row) {
+                $levels[(int) $row->student_id] = $row->level ?? null;
+            }
+        }
+
+        return [
+            'class_section_id' => $classSectionId,
+            'class_section_name' => $sectionName ?? '',
+            'class_id' => $classId,
+            'school_year' => $schoolYear,
+            'students' => $students,
+            'levels' => $levels,
+        ];
+    }
+
+    public function updatePlacementLevel(int $studentId, string $schoolYear, $level, ?int $userId): void
+    {
+        if ($studentId <= 0 || $schoolYear === '') {
+            throw new RuntimeException('Missing student or school year.');
+        }
+
+        $level = $level === '' || $level === null ? null : (int) $level;
+        if ($level !== null && !in_array($level, [1, 2, 3], true)) {
+            throw new RuntimeException('Invalid placement level.');
+        }
+
+        $existing = PlacementLevel::query()
+            ->where('student_id', $studentId)
+            ->where('school_year', $schoolYear)
+            ->first();
+
+        if ($level === null) {
+            if ($existing) {
+                $existing->delete();
+            }
+            return;
+        }
+
+        $payload = [
+            'student_id' => $studentId,
+            'school_year' => $schoolYear,
+            'level' => $level,
+            'updated_by' => $userId,
+        ];
+
+        if ($existing) {
+            $existing->update($payload);
+        } else {
+            $payload['created_by'] = $userId;
+            PlacementLevel::query()->create($payload);
+        }
+    }
+
+    public function updatePlacementLevels(int $classSectionId, string $schoolYear, array $levels, ?int $userId): void
+    {
+        if ($classSectionId <= 0 || $schoolYear === '') {
+            throw new RuntimeException('Missing class section or school year.');
+        }
+
+        $students = Student::getStudentInfoByClassSectionId($classSectionId, null, $schoolYear);
+        $validIds = array_values(array_filter(array_map(
+            static fn ($row) => (int) ($row['student_id'] ?? 0),
+            $students
+        ), static fn ($id) => $id > 0));
+
+        $validSet = array_flip($validIds);
+        $existingRows = [];
+        if (!empty($validIds)) {
+            $rows = PlacementLevel::query()
+                ->whereIn('student_id', $validIds)
+                ->where('school_year', $schoolYear)
+                ->get();
+            foreach ($rows as $row) {
+                $existingRows[(int) $row->student_id] = $row;
+            }
+        }
+
+        foreach ($levels as $studentIdRaw => $levelRaw) {
+            $studentId = (int) $studentIdRaw;
+            if (!isset($validSet[$studentId])) {
+                continue;
+            }
+            $levelRaw = trim((string) $levelRaw);
+            $level = $levelRaw === '' ? null : (int) $levelRaw;
+            if ($level !== null && !in_array($level, [1, 2, 3], true)) {
+                continue;
+            }
+
+            if ($level === null) {
+                if (isset($existingRows[$studentId])) {
+                    $existingRows[$studentId]->delete();
+                }
+                continue;
+            }
+
+            $payload = [
+                'student_id' => $studentId,
+                'school_year' => $schoolYear,
+                'level' => $level,
+                'updated_by' => $userId,
+            ];
+
+            if (isset($existingRows[$studentId])) {
+                $existingRows[$studentId]->update($payload);
+            } else {
+                $payload['created_by'] = $userId;
+                PlacementLevel::query()->create($payload);
+            }
+        }
+    }
+
+    public function createPlacementBatch(string $schoolYear, string $placementTest, array $levels, ?int $userId): int
+    {
+        if ($schoolYear === '' || $placementTest === '') {
+            throw new RuntimeException('Missing placement test or school year.');
+        }
+
+        $students = $this->fetchActiveStudentsWithSection($schoolYear);
+        $validIds = array_values(array_filter(array_map(
+            static fn ($row) => (int) ($row['student_id'] ?? 0),
+            $students
+        ), static fn ($id) => $id > 0));
+        $validSet = array_flip($validIds);
+
+        $batch = PlacementBatch::query()->create([
+            'placement_test' => $placementTest,
+            'school_year' => $schoolYear,
+            'created_by' => $userId,
+            'updated_by' => $userId,
+        ]);
+
+        $savedCount = 0;
+        foreach ($levels as $studentIdRaw => $levelRaw) {
+            $studentId = (int) $studentIdRaw;
+            if (!isset($validSet[$studentId])) {
+                continue;
+            }
+            $levelRaw = trim((string) $levelRaw);
+            if ($levelRaw === '') {
+                continue;
+            }
+            $score = (int) $levelRaw;
+            if ($score < 0 || $score > 100) {
+                continue;
+            }
+
+            PlacementScore::query()->create([
+                'batch_id' => (int) $batch->id,
+                'student_id' => $studentId,
+                'score' => $score,
+                'created_by' => $userId,
+                'updated_by' => $userId,
+            ]);
+            $savedCount++;
+        }
+
+        if ($savedCount === 0) {
+            $batch->delete();
+            throw new RuntimeException('No scores entered. Batch not saved.');
+        }
+
+        return (int) $batch->id;
+    }
+
+    public function getPlacementBatch(int $batchId): array
+    {
+        $batch = PlacementBatch::query()->find($batchId);
+        if (!$batch) {
+            throw new RuntimeException('Placement batch not found.');
+        }
+
+        $schoolYear = (string) ($batch->school_year ?? '');
+        $students = $this->fetchActiveStudentsWithSection($schoolYear);
+        $scores = $this->fetchPlacementScoresForBatch($batchId);
+
+        return [
+            'batch' => $batch,
+            'students' => $students,
+            'scores' => $scores,
+        ];
+    }
+
+    public function updatePlacementBatch(int $batchId, string $schoolYear, array $levels, ?int $userId): void
+    {
+        $batch = PlacementBatch::query()->find($batchId);
+        if (!$batch) {
+            throw new RuntimeException('Placement batch not found.');
+        }
+
+        $students = $this->fetchActiveStudentsWithSection($schoolYear);
+        $validIds = array_values(array_filter(array_map(
+            static fn ($row) => (int) ($row['student_id'] ?? 0),
+            $students
+        ), static fn ($id) => $id > 0));
+
+        $validSet = array_flip($validIds);
+        $existing = $this->fetchPlacementScoresForBatch($batchId);
+
+        foreach ($levels as $studentIdRaw => $scoreRaw) {
+            $studentId = (int) $studentIdRaw;
+            if (!isset($validSet[$studentId])) {
+                continue;
+            }
+            $scoreRaw = trim((string) $scoreRaw);
+            if ($scoreRaw === '') {
+                if (isset($existing[$studentId])) {
+                    PlacementScore::query()->whereKey($existing[$studentId]['id'])->delete();
+                }
+                continue;
+            }
+            $score = (int) $scoreRaw;
+            if ($score < 0 || $score > 100) {
+                continue;
+            }
+
+            if (isset($existing[$studentId])) {
+                PlacementScore::query()->whereKey($existing[$studentId]['id'])->update([
+                    'score' => $score,
+                    'updated_by' => $userId,
+                ]);
+            } else {
+                PlacementScore::query()->create([
+                    'batch_id' => $batchId,
+                    'student_id' => $studentId,
+                    'score' => $score,
+                    'created_by' => $userId,
+                    'updated_by' => $userId,
+                ]);
+            }
+        }
+
+        $batch->update([
+            'updated_by' => $userId,
+        ]);
+    }
+
+    private function fetchActiveStudentsWithSection(string $schoolYear): array
+    {
+        return DB::table('students as s')
+            ->select('s.id as student_id', 's.school_id', 's.firstname', 's.lastname', 'sc.class_section_id', 'cs.class_section_name', 'c.class_name')
+            ->leftJoin('student_class as sc', function ($join) use ($schoolYear) {
+                $join->on('sc.student_id', '=', 's.id')
+                    ->where('sc.school_year', '=', $schoolYear);
+            })
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'sc.class_section_id')
+            ->leftJoin('classes as c', 'c.id', '=', 'cs.class_id')
+            ->where('s.is_active', 1)
+            ->orderBy('s.lastname', 'ASC')
+            ->orderBy('s.firstname', 'ASC')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+
+    private function fetchPlacementBatches(string $schoolYear): array
+    {
+        return PlacementBatch::query()
+            ->where('school_year', $schoolYear)
+            ->orderBy('created_at', 'DESC')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+
+    private function fetchPlacementBatchDetails(array $batches, string $schoolYear): array
+    {
+        if (empty($batches)) {
+            return [];
+        }
+
+        $batchIds = array_values(array_filter(array_map(
+            static fn ($row) => (int) ($row['id'] ?? 0),
+            $batches
+        ), static fn ($id) => $id > 0));
+
+        if (empty($batchIds)) {
+            return [];
+        }
+
+        $rows = DB::table('placement_scores as ps')
+            ->select('ps.batch_id', 'ps.score', 's.school_id', 's.firstname', 's.lastname', 'cs.class_section_name', 'c.class_name')
+            ->join('students as s', 's.id', '=', 'ps.student_id')
+            ->leftJoin('student_class as sc', function ($join) use ($schoolYear) {
+                $join->on('sc.student_id', '=', 's.id')
+                    ->where('sc.school_year', '=', $schoolYear);
+            })
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'sc.class_section_id')
+            ->leftJoin('classes as c', 'c.id', '=', 'cs.class_id')
+            ->whereIn('ps.batch_id', $batchIds)
+            ->where('s.is_active', 1)
+            ->orderBy('ps.batch_id', 'ASC')
+            ->orderBy('s.lastname', 'ASC')
+            ->orderBy('s.firstname', 'ASC')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $details = [];
+        foreach ($rows as $row) {
+            $bid = (int) ($row['batch_id'] ?? 0);
+            if ($bid <= 0) {
+                continue;
+            }
+            $details[$bid][] = $row;
+        }
+
+        return $details;
+    }
+
+    private function fetchPlacementScoresForBatch(int $batchId): array
+    {
+        $rows = PlacementScore::query()
+            ->where('batch_id', $batchId)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $scores = [];
+        foreach ($rows as $row) {
+            $scores[(int) $row['student_id']] = $row;
+        }
+
+        return $scores;
+    }
+}
diff --git a/app/Services/Grading/GradingRefreshService.php b/app/Services/Grading/GradingRefreshService.php
new file mode 100644
index 00000000..d43c3589
--- /dev/null
+++ b/app/Services/Grading/GradingRefreshService.php
@@ -0,0 +1,111 @@
+<?php
+
+namespace App\Services\Grading;
+
+use App\Models\ScoreComment;
+use App\Models\SemesterScore;
+use App\Models\Student;
+use App\Services\Scores\SemesterScoreService;
+use RuntimeException;
+
+class GradingRefreshService
+{
+    public function __construct(private SemesterScoreService $semesterScoreService)
+    {
+    }
+
+    public function refreshSemesterScores(int $classSectionId, string $semester, string $schoolYear): void
+    {
+        if ($classSectionId <= 0) {
+            throw new RuntimeException('Missing class section.');
+        }
+
+        $studentTeacherInfo = Student::getStudentInfoByClassSectionId(
+            $classSectionId,
+            $semester,
+            $schoolYear
+        );
+        if (empty($studentTeacherInfo)) {
+            throw new RuntimeException('No students found for this class/term.');
+        }
+
+        $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
+        $this->refreshAttendanceComments($classSectionId, $semester, $schoolYear);
+    }
+
+    private function refreshAttendanceComments(int $classSectionId, string $semester, string $schoolYear): void
+    {
+        if (!function_exists('attendance_comment_from_score')) {
+            return;
+        }
+
+        $scoreRows = SemesterScore::query()
+            ->select(['student_id', 'attendance_score'])
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->get();
+
+        if ($scoreRows->isEmpty()) {
+            return;
+        }
+
+        $studentIds = $scoreRows->pluck('student_id')->map(fn ($v) => (int) $v)->unique()->values()->all();
+        if (empty($studentIds)) {
+            return;
+        }
+
+        $students = Student::query()
+            ->select(['id', 'firstname'])
+            ->whereIn('id', $studentIds)
+            ->get();
+        $nameMap = [];
+        foreach ($students as $student) {
+            $nameMap[(int) $student->id] = (string) ($student->firstname ?? '');
+        }
+
+        $existing = ScoreComment::query()
+            ->where('score_type', 'attendance')
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->whereIn('student_id', $studentIds)
+            ->get();
+        $existingByStudent = [];
+        foreach ($existing as $row) {
+            $existingByStudent[(int) $row->student_id] = $row;
+        }
+
+        foreach ($scoreRows as $row) {
+            $studentId = (int) $row->student_id;
+            if ($studentId <= 0) {
+                continue;
+            }
+            $score = $row->attendance_score !== null ? (float) $row->attendance_score : null;
+            if ($score === null) {
+                continue;
+            }
+            $auto = attendance_comment_from_score($score, $nameMap[$studentId] ?? '');
+            if ($auto === null) {
+                continue;
+            }
+
+            if (isset($existingByStudent[$studentId])) {
+                $existingByStudent[$studentId]->update([
+                    'comment' => $auto,
+                ]);
+            } else {
+                ScoreComment::query()->create([
+                    'student_id' => $studentId,
+                    'class_section_id' => $classSectionId,
+                    'score_type' => 'attendance',
+                    'semester' => $semester,
+                    'school_year' => $schoolYear,
+                    'comment' => $auto,
+                    'commented_by' => null,
+                    'created_at' => now(),
+                ]);
+            }
+        }
+    }
+}
diff --git a/app/Services/Grading/GradingScoreService.php b/app/Services/Grading/GradingScoreService.php
new file mode 100644
index 00000000..8fce936e
--- /dev/null
+++ b/app/Services/Grading/GradingScoreService.php
@@ -0,0 +1,189 @@
+<?php
+
+namespace App\Services\Grading;
+
+use App\Models\FinalExam;
+use App\Models\GradingLock;
+use App\Models\Homework;
+use App\Models\MidtermExam;
+use App\Models\Project;
+use App\Models\Quiz;
+use App\Models\ScoreComment;
+use App\Models\SemesterScore;
+use App\Models\Student;
+use App\Services\Scores\SemesterScoreService;
+use RuntimeException;
+
+class GradingScoreService
+{
+    public function __construct(private SemesterScoreService $semesterScoreService)
+    {
+    }
+
+    public function show(string $type, int $classSectionId, int $studentId, string $semester, string $schoolYear): array
+    {
+        $model = $this->resolveModel($type);
+        $student = Student::query()->find($studentId);
+
+        if (!$student) {
+            throw new RuntimeException('Student not found.');
+        }
+
+        $scores = $model->newQuery()
+            ->where('student_id', $studentId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->get();
+
+        $scoresLocked = $classSectionId > 0
+            ? GradingLock::isLocked($classSectionId, $semester, $schoolYear)
+            : false;
+
+        return [
+            'student' => $student,
+            'scores' => $scores,
+            'type' => $type,
+            'class_section_id' => $classSectionId,
+            'semester' => $semester,
+            'scores_locked' => $scoresLocked,
+        ];
+    }
+
+    public function update(array $payload, int $updatedBy): void
+    {
+        $type = (string) ($payload['type'] ?? '');
+        $studentId = (int) ($payload['student_id'] ?? 0);
+        $classSectionId = (int) ($payload['class_section_id'] ?? 0);
+        $semester = (string) ($payload['semester'] ?? '');
+        $schoolYear = (string) ($payload['school_year'] ?? '');
+
+        if ($classSectionId > 0 && GradingLock::isLocked($classSectionId, $semester, $schoolYear)) {
+            throw new RuntimeException('Scores are locked for this class. Unlock to edit.');
+        }
+
+        $model = $this->resolveModel($type);
+
+        if (in_array($type, ['homework', 'quiz', 'project'], true)) {
+            $scoreIds = $payload['score_ids'] ?? [];
+            $scores = $payload['scores'] ?? [];
+            $comments = $payload['comments'] ?? [];
+
+            foreach ($scoreIds as $i => $id) {
+                $model->newQuery()->whereKey($id)->update([
+                    'score' => $scores[$i] ?? null,
+                    'comment' => $comments[$i] ?? null,
+                    'updated_at' => now(),
+                ]);
+            }
+        } elseif (in_array($type, ['midterm', 'final', 'test'], true)) {
+            $score = $payload['score'] ?? null;
+
+            $data = [
+                'score' => $score,
+                'updated_at' => now(),
+            ];
+
+            $existing = $model->newQuery()
+                ->where('student_id', $studentId)
+                ->where('class_section_id', $classSectionId)
+                ->where('semester', $semester)
+                ->where('school_year', $schoolYear)
+                ->first();
+
+            if ($existing) {
+                $existing->update($data);
+            } else {
+                $model->newQuery()->create($data + [
+                    'student_id' => $studentId,
+                    'class_section_id' => $classSectionId,
+                    'semester' => $semester,
+                    'school_year' => $schoolYear,
+                    'created_at' => now(),
+                ]);
+            }
+        } elseif ($type === 'comments') {
+            $comment = (string) ($payload['comment'] ?? '');
+
+            $model->newQuery()
+                ->where('student_id', $studentId)
+                ->where('semester', $semester)
+                ->where('school_year', $schoolYear)
+                ->delete();
+
+            $model->newQuery()->create([
+                'student_id' => $studentId,
+                'score_type' => 'general',
+                'semester' => $semester,
+                'school_year' => $schoolYear,
+                'comment' => $comment,
+                'commented_by' => $updatedBy ?: null,
+                'created_at' => now(),
+            ]);
+        }
+
+        $studentTeacherInfo = Student::getStudentInfoByClassSectionId($classSectionId, $semester, $schoolYear, $updatedBy);
+        if (!empty($studentTeacherInfo)) {
+            try {
+                $this->semesterScoreService->updateScoresForStudents($studentTeacherInfo, $semester, $schoolYear);
+            } catch (RuntimeException $e) {
+            }
+        }
+    }
+
+    public function getScoreComments(string $semester, string $schoolYear): array
+    {
+        $studentIds = Student::query()
+            ->select('students.id')
+            ->join('student_class', 'student_class.student_id', '=', 'students.id')
+            ->where('student_class.semester', $semester)
+            ->where('student_class.school_year', $schoolYear)
+            ->pluck('students.id')
+            ->map(fn ($v) => (int) $v)
+            ->all();
+
+        if (empty($studentIds)) {
+            return [];
+        }
+
+        $scores = [];
+        $students = Student::query()
+            ->whereIn('id', $studentIds)
+            ->where('school_year', $schoolYear)
+            ->get();
+
+        foreach ($students as $student) {
+            $scores[$student->id] = [
+                'school_id' => $student->school_id,
+                'firstname' => $student->firstname,
+                'lastname' => $student->lastname,
+                'comments' => [],
+            ];
+        }
+
+        $commentRows = ScoreComment::query()
+            ->whereIn('student_id', $studentIds)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->get();
+
+        foreach ($commentRows as $comment) {
+            $scores[$comment->student_id]['comments'][] = $comment;
+        }
+
+        return $scores;
+    }
+
+    private function resolveModel(string $type)
+    {
+        return match ($type) {
+            'homework' => new Homework(),
+            'quiz' => new Quiz(),
+            'project' => new Project(),
+            'midterm' => new MidtermExam(),
+            'final' => new FinalExam(),
+            'test' => new SemesterScore(),
+            'comments' => new ScoreComment(),
+            default => throw new RuntimeException("Invalid type: {$type}"),
+        };
+    }
+}
diff --git a/app/Services/Grading/HomeworkTrackingCalendarService.php b/app/Services/Grading/HomeworkTrackingCalendarService.php
new file mode 100644
index 00000000..bc3568e1
--- /dev/null
+++ b/app/Services/Grading/HomeworkTrackingCalendarService.php
@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Services\Grading;
+
+use App\Models\CalendarEvent;
+use DateTime;
+
+class HomeworkTrackingCalendarService
+{
+    public function buildDateRange(string $schoolYear, string $semester): array
+    {
+        $startYear = null;
+        if (preg_match('/\b(20\d{2})\b/', $schoolYear, $m)) {
+            $startYear = (int) $m[1];
+        }
+        if ($startYear === null) {
+            $today = new DateTime('today');
+            return [$today, $today];
+        }
+
+        $nextYear = $startYear + 1;
+        $sem = strtolower(trim($semester));
+
+        try {
+            if ($sem === 'spring') {
+                $start = new DateTime("{$nextYear}-01-25");
+                $end = new DateTime("{$nextYear}-05-31");
+            } else {
+                $start = new DateTime("{$startYear}-09-21");
+                $end = new DateTime("{$nextYear}-01-18");
+            }
+        } catch (\Throwable $e) {
+            $today = new DateTime('today');
+            return [$today, $today];
+        }
+
+        return [$start, $end];
+    }
+
+    public function buildSundays(DateTime $start, DateTime $end): array
+    {
+        if ((int) $start->format('w') !== 0) {
+            $start = (clone $start)->modify('next sunday');
+        }
+
+        $sundays = [];
+        $d = clone $start;
+        while ($d <= $end) {
+            $sundays[] = $d->format('Y-m-d');
+            $d->modify('+7 days');
+        }
+
+        return $sundays;
+    }
+
+    public function eventDays(string $schoolYear): array
+    {
+        $events = CalendarEvent::getEventsBySchoolYear($schoolYear) ?? [];
+        $eventDays = [];
+        foreach ($events as $event) {
+            $ymd = substr((string) ($event['date'] ?? ''), 0, 10);
+            $no = (int) ($event['no_school'] ?? 0);
+            if ($ymd && $no === 1) {
+                $eventDays[$ymd] = true;
+            }
+        }
+
+        return $eventDays;
+    }
+
+    public function dateToIndex(array $sundays, array $eventDays): array
+    {
+        $dateToIndex = [];
+        $idx = 0;
+        foreach ($sundays as $ymd) {
+            if (!isset($eventDays[$ymd])) {
+                $idx++;
+                $dateToIndex[$ymd] = $idx;
+            } else {
+                $dateToIndex[$ymd] = null;
+            }
+        }
+
+        return $dateToIndex;
+    }
+}
diff --git a/app/Services/Grading/HomeworkTrackingService.php b/app/Services/Grading/HomeworkTrackingService.php
new file mode 100644
index 00000000..0c4c6471
--- /dev/null
+++ b/app/Services/Grading/HomeworkTrackingService.php
@@ -0,0 +1,219 @@
+<?php
+
+namespace App\Services\Grading;
+
+use App\Models\Configuration;
+use Illuminate\Support\Facades\DB;
+
+class HomeworkTrackingService
+{
+    private array $teacherAssignmentCache = [];
+
+    public function __construct(private HomeworkTrackingCalendarService $calendarService)
+    {
+    }
+
+    public function report(?string $semester = null, ?string $schoolYear = null, int $page = 1): array
+    {
+        $semester = $semester ?: (string) (Configuration::getConfig('semester') ?? '');
+        $schoolYear = $schoolYear ?: (string) (Configuration::getConfig('school_year') ?? '');
+
+        [$start, $end] = $this->calendarService->buildDateRange($schoolYear, $semester);
+        $sundays = $this->calendarService->buildSundays($start, $end);
+        $eventDays = $this->calendarService->eventDays($schoolYear);
+        $dateToIndex = $this->calendarService->dateToIndex($sundays, $eventDays);
+
+        $limitToSemester = $this->hasTeacherAssignments($schoolYear);
+
+        $homeworkByIndex = $this->loadHomeworkByIndex($schoolYear, $semester, $limitToSemester);
+        $homeworkByDate = $this->loadHomeworkByDate($schoolYear, $semester, $limitToSemester, $sundays, $eventDays);
+        $teachers = $this->loadTeachers($schoolYear);
+
+        $perPage = 8;
+        $totalRows = count($teachers);
+        $totalPages = max(1, (int) ceil($totalRows / $perPage));
+        $page = max(1, min($page, $totalPages));
+        $offset = ($page - 1) * $perPage;
+        $teachersPage = array_slice($teachers, $offset, $perPage);
+
+        return [
+            'semester' => $semester,
+            'school_year' => $schoolYear,
+            'sundays' => $sundays,
+            'event_days' => $eventDays,
+            'date_to_index' => $dateToIndex,
+            'teachers' => $teachersPage,
+            'has_homework' => $homeworkByIndex['has_homework'],
+            'hw_entered_at' => $homeworkByIndex['entered_at'],
+            'has_homework_by_date' => $homeworkByDate['has_homework'],
+            'hw_entered_at_by_date' => $homeworkByDate['entered_at'],
+            'page' => $page,
+            'total_pages' => $totalPages,
+            'per_page' => $perPage,
+            'total_rows' => $totalRows,
+        ];
+    }
+
+    private function hasTeacherAssignments(string $schoolYear): bool
+    {
+        $year = trim((string) $schoolYear);
+        if ($year === '') {
+            return false;
+        }
+
+        if (array_key_exists($year, $this->teacherAssignmentCache)) {
+            return $this->teacherAssignmentCache[$year];
+        }
+
+        $cnt = DB::table('teacher_class')->where('school_year', $year)->count();
+        $this->teacherAssignmentCache[$year] = $cnt > 0;
+
+        return $this->teacherAssignmentCache[$year];
+    }
+
+    private function loadHomeworkByIndex(string $schoolYear, string $semester, bool $limitToSemester): array
+    {
+        $query = DB::table('homework')
+            ->select('class_section_id', 'homework_index', DB::raw('MIN(created_at) as first_created'), DB::raw('COUNT(*) as cnt'))
+            ->where('school_year', $schoolYear);
+
+        if ($limitToSemester && $semester !== '') {
+            $query->where('semester', $semester);
+        }
+
+        $rows = $query->groupBy('class_section_id', 'homework_index')->get();
+
+        $hasHomework = [];
+        $enteredAt = [];
+        foreach ($rows as $row) {
+            $csid = (int) $row->class_section_id;
+            $hi = (int) $row->homework_index;
+            $cnt = (int) $row->cnt;
+            if ($csid > 0 && $hi > 0 && $cnt > 0) {
+                $hasHomework[$csid][$hi] = true;
+                $dateStr = substr((string) ($row->first_created ?? ''), 0, 10);
+                $enteredAt[$csid][$hi] = $dateStr ?: null;
+            }
+        }
+
+        return ['has_homework' => $hasHomework, 'entered_at' => $enteredAt];
+    }
+
+    private function loadHomeworkByDate(string $schoolYear, string $semester, bool $limitToSemester, array $sundays, array $eventDays): array
+    {
+        $query = DB::table('homework')
+            ->select(DB::raw('class_section_id, DATE(created_at) as hw_date, MIN(created_at) as first_created, COUNT(*) as cnt'))
+            ->where('school_year', $schoolYear);
+
+        if ($limitToSemester && $semester !== '') {
+            $query->where('semester', $semester);
+        }
+
+        $rows = $query
+            ->groupBy('class_section_id', DB::raw('DATE(created_at)'))
+            ->orderBy('hw_date', 'ASC')
+            ->get();
+
+        $hasHomework = [];
+        $enteredAt = [];
+
+        foreach ($rows as $row) {
+            $csid = (int) $row->class_section_id;
+            $date = substr((string) ($row->hw_date ?? ''), 0, 10);
+            $cnt = (int) $row->cnt;
+            $firstCreated = substr((string) ($row->first_created ?? ''), 0, 10);
+            if ($csid <= 0 || !$date || $cnt <= 0) {
+                continue;
+            }
+
+            $baseIndex = -1;
+            for ($i = count($sundays) - 1; $i >= 0; $i--) {
+                if ($sundays[$i] <= $date) {
+                    $baseIndex = $i;
+                    break;
+                }
+            }
+            if ($baseIndex < 0) {
+                continue;
+            }
+
+            $j = $baseIndex;
+            while ($j >= 0 && !empty($eventDays[$sundays[$j]])) {
+                $j--;
+            }
+            if ($j < 0) {
+                continue;
+            }
+            $sunday = $sundays[$j];
+
+            $hasHomework[$csid][$sunday] = true;
+            $candidate = $firstCreated ?: $date;
+            if (empty($enteredAt[$csid][$sunday]) || ($candidate && $candidate < $enteredAt[$csid][$sunday])) {
+                $enteredAt[$csid][$sunday] = $candidate;
+            }
+        }
+
+        return ['has_homework' => $hasHomework, 'entered_at' => $enteredAt];
+    }
+
+    private function loadTeachers(string $schoolYear): array
+    {
+        $rows = DB::table('teacher_class as tc')
+            ->select('tc.class_section_id', 'tc.position', 'cs.class_section_name', 'cs.class_id', 'u.firstname', 'u.lastname')
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'tc.class_section_id')
+            ->leftJoin('users as u', 'u.id', '=', 'tc.teacher_id')
+            ->where('tc.school_year', $schoolYear)
+            ->whereNotNull('tc.class_section_id')
+            ->whereIn('tc.position', ['main', 'ta'])
+            ->orderBy('cs.class_id', 'ASC')
+            ->orderBy('cs.class_section_name', 'ASC')
+            ->orderByRaw("FIELD(tc.position, 'main','ta')")
+            ->orderBy('u.firstname', 'ASC')
+            ->get();
+
+        $bySection = [];
+        foreach ($rows as $row) {
+            $sid = (int) $row->class_section_id;
+            if ($sid <= 0) {
+                continue;
+            }
+            if (!isset($bySection[$sid])) {
+                $bySection[$sid] = [
+                    'class_section_id' => $sid,
+                    'class_id' => (int) ($row->class_id ?? 0),
+                    'class_section_name' => (string) ($row->class_section_name ?? ''),
+                    'teachers' => [],
+                    'tas' => [],
+                ];
+            }
+            $name = trim((string) ($row->firstname ?? '') . ' ' . (string) ($row->lastname ?? ''));
+            $pos = strtolower((string) ($row->position ?? ''));
+            if ($name !== '') {
+                if ($pos === 'main') {
+                    $bySection[$sid]['teachers'][] = $name;
+                } elseif ($pos === 'ta') {
+                    $bySection[$sid]['tas'][] = $name;
+                }
+            }
+        }
+
+        $teachers = array_values($bySection);
+        usort($teachers, function ($a, $b) {
+            $ai = (int) ($a['class_id'] ?? 0);
+            $bi = (int) ($b['class_id'] ?? 0);
+            $order = function (int $cid): int {
+                if ($cid === 13) return 0;
+                if ($cid >= 1 && $cid <= 11) return $cid;
+                if ($cid === 12) return 99;
+                return 200 + $cid;
+            };
+            $cmp = $order($ai) <=> $order($bi);
+            if ($cmp !== 0) {
+                return $cmp;
+            }
+            return strnatcasecmp($a['class_section_name'] ?? '', $b['class_section_name'] ?? '');
+        });
+
+        return $teachers;
+    }
+}
diff --git a/app/Services/Incidents/CurrentIncidentService.php b/app/Services/Incidents/CurrentIncidentService.php
new file mode 100644
index 00000000..9d1261f6
--- /dev/null
+++ b/app/Services/Incidents/CurrentIncidentService.php
@@ -0,0 +1,233 @@
+<?php
+
+namespace App\Services\Incidents;
+
+use App\Models\Configuration;
+use App\Models\CurrentIncident;
+use App\Models\Incident;
+use App\Models\Student;
+use App\Models\StudentClass;
+use Illuminate\Support\Facades\DB;
+
+class CurrentIncidentService
+{
+    public function __construct(private IncidentLookupService $lookup)
+    {
+    }
+
+    public function listCurrent(): array
+    {
+        $incidents = CurrentIncident::query()->get()->map(fn ($row) => $row->toArray())->all();
+        $schoolYear = Configuration::getConfig('school_year');
+
+        $updaterIds = [];
+        foreach ($incidents as $incident) {
+            foreach (['updated_by_open', 'updated_by_closed', 'updated_by_canceled'] as $key) {
+                if (!empty($incident[$key])) {
+                    $updaterIds[] = (int) $incident[$key];
+                }
+            }
+        }
+
+        $updaterMap = $this->lookup->updaterNameMap($updaterIds);
+        foreach ($incidents as &$incident) {
+            foreach (['updated_by_open', 'updated_by_closed', 'updated_by_canceled'] as $key) {
+                $id = (int) ($incident[$key] ?? 0);
+                $incident[$key . '_name'] = $id > 0 ? ($updaterMap[$id] ?? null) : null;
+            }
+        }
+        unset($incident);
+
+        return [
+            'incidents' => $incidents,
+            'grades' => $this->lookup->gradeOptionsWithActiveStudents($schoolYear),
+        ];
+    }
+
+    public function studentsByGrade(int $gradeId): array
+    {
+        $studentIds = StudentClass::query()
+            ->active()
+            ->where('student_class.class_section_id', $gradeId)
+            ->pluck('student_id')
+            ->all();
+
+        if (empty($studentIds)) {
+            return [];
+        }
+
+        return Student::query()
+            ->whereIn('id', $studentIds)
+            ->where('is_active', 1)
+            ->get()
+            ->map(fn ($student) => [
+                'id' => (int) $student->id,
+                'name' => trim((string) $student->firstname . ' ' . (string) $student->lastname),
+            ])
+            ->all();
+    }
+
+    public function addIncident(array $payload, int $userId): array
+    {
+        $studentId = (int) $payload['student_id'];
+        $incidentType = (string) $payload['incident'];
+        $description = (string) ($payload['description'] ?? '');
+        $incidentState = (string) ($payload['incident_state'] ?? 'Open');
+        $stateDescription = (string) ($payload['state_description'] ?? '');
+        $grade = (string) $payload['grade'];
+
+        $student = Student::query()->find($studentId);
+        if (!$student) {
+            return [
+                'ok' => false,
+                'message' => 'Student not found.',
+            ];
+        }
+
+        $semester = Configuration::getConfig('semester');
+        $schoolYear = Configuration::getConfig('school_year');
+        $currentDateTime = function_exists('utc_now') ? utc_now() : now('UTC')->toDateTimeString();
+
+        $existingIncident = CurrentIncident::query()
+            ->where('student_id', $studentId)
+            ->where('incident', $incidentType)
+            ->first();
+
+        if ($existingIncident) {
+            $data = [
+                'incident_datetime' => $currentDateTime,
+                'updated_by_open' => $userId,
+            ];
+
+            if ($incidentState === 'Closed') {
+                $data['incident_state'] = 'Closed';
+                $data['close_description'] = $this->appendLine($existingIncident->close_description ?? '', $stateDescription);
+            } elseif ($incidentState === 'Canceled') {
+                $data['incident_state'] = 'Canceled';
+                $data['cancel_description'] = $this->appendLine($existingIncident->cancel_description ?? '', $stateDescription);
+            } else {
+                $data['open_description'] = $this->appendLine($existingIncident->open_description ?? '', $description);
+            }
+
+            $existingIncident->fill($data);
+            $existingIncident->save();
+
+            return [
+                'ok' => true,
+                'created' => false,
+                'incident_id' => (int) $existingIncident->id,
+            ];
+        }
+
+        $incident = CurrentIncident::query()->create([
+            'student_id' => $student->id,
+            'student_name' => trim((string) $student->firstname . ' ' . (string) $student->lastname),
+            'grade' => $grade,
+            'incident' => $incidentType,
+            'incident_datetime' => $currentDateTime,
+            'incident_state' => 'Open',
+            'updated_by_open' => $userId,
+            'open_description' => $description,
+            'semester' => $semester,
+            'school_year' => $schoolYear,
+        ]);
+
+        return [
+            'ok' => true,
+            'created' => true,
+            'incident_id' => (int) $incident->id,
+        ];
+    }
+
+    public function updateState(int $incidentId, string $newState): bool
+    {
+        return CurrentIncident::query()->whereKey($incidentId)->update([
+            'incident_state' => $newState,
+        ]) > 0;
+    }
+
+    public function closeIncident(int $incidentId, string $closeDescription, ?string $actionTaken, int $userId): array
+    {
+        $incident = CurrentIncident::query()->find($incidentId);
+        if (!$incident) {
+            return ['ok' => false, 'message' => 'Incident not found.'];
+        }
+
+        if ($incident->incident_state === 'Closed') {
+            return ['ok' => false, 'message' => 'Incident is already closed.'];
+        }
+
+        $incident->fill([
+            'incident_state' => 'Closed',
+            'updated_by_closed' => $userId,
+            'close_description' => $closeDescription,
+            'action_taken' => $actionTaken,
+        ]);
+        $incident->save();
+
+        return $this->moveToHistory($incident);
+    }
+
+    public function cancelIncident(int $incidentId, ?string $cancelDescription, ?string $actionTaken, int $userId): array
+    {
+        $incident = CurrentIncident::query()->find($incidentId);
+        if (!$incident) {
+            return ['ok' => false, 'message' => 'Incident not found.'];
+        }
+
+        if ($incident->incident_state === 'Canceled') {
+            return ['ok' => false, 'message' => 'Incident is already canceled.'];
+        }
+
+        $incident->fill([
+            'incident_state' => 'Canceled',
+            'updated_by_canceled' => $userId,
+            'cancel_description' => $cancelDescription,
+            'action_taken' => $actionTaken,
+        ]);
+        $incident->save();
+
+        return $this->moveToHistory($incident);
+    }
+
+    private function moveToHistory(CurrentIncident $incident): array
+    {
+        return DB::transaction(function () use ($incident) {
+            $history = Incident::query()->create([
+                'student_id' => $incident->student_id,
+                'student_name' => $incident->student_name,
+                'grade' => $incident->grade,
+                'incident' => $incident->incident,
+                'incident_datetime' => $incident->incident_datetime,
+                'incident_state' => $incident->incident_state,
+                'updated_by_open' => $incident->updated_by_open,
+                'open_description' => $incident->open_description,
+                'updated_by_closed' => $incident->updated_by_closed,
+                'close_description' => $incident->close_description,
+                'action_taken' => $incident->action_taken,
+                'updated_by_canceled' => $incident->updated_by_canceled,
+                'cancel_description' => $incident->cancel_description,
+                'semester' => $incident->semester,
+                'school_year' => $incident->school_year,
+                'created_at' => $incident->created_at,
+                'updated_at' => $incident->updated_at,
+            ]);
+
+            $incident->delete();
+
+            return [
+                'ok' => true,
+                'incident_id' => (int) $history->id,
+            ];
+        });
+    }
+
+    private function appendLine(string $existing, string $append): string
+    {
+        if ($existing === '') {
+            return $append;
+        }
+
+        return $existing . PHP_EOL . $append;
+    }
+}
diff --git a/app/Services/Incidents/IncidentAnalysisService.php b/app/Services/Incidents/IncidentAnalysisService.php
new file mode 100644
index 00000000..2f4ccc46
--- /dev/null
+++ b/app/Services/Incidents/IncidentAnalysisService.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace App\Services\Incidents;
+
+use App\Models\Incident;
+
+class IncidentAnalysisService
+{
+    public function __construct(private IncidentLookupService $lookup)
+    {
+    }
+
+    public function analyze(?string $schoolYear, ?string $semester): array
+    {
+        $builder = Incident::query()->orderBy('incident_datetime', 'DESC');
+        if ($schoolYear !== null && $schoolYear !== '') {
+            $builder->where('school_year', $schoolYear);
+        }
+        if ($semester !== null && $semester !== '') {
+            $builder->where('semester', $semester);
+        }
+
+        $incidents = $builder->get()->map(fn ($row) => $row->toArray())->all();
+        if (empty($incidents)) {
+            return [];
+        }
+
+        $gradeMap = $this->lookup->gradeNameMap(array_column($incidents, 'grade'));
+        $students = [];
+
+        foreach ($incidents as $incident) {
+            $studentId = (string) ($incident['student_id'] ?? '');
+            $studentName = (string) ($incident['student_name'] ?? '');
+            $studentKey = $studentId !== '' ? 'id:' . $studentId : 'name:' . strtolower(trim($studentName));
+
+            $gradeValue = $incident['grade'] ?? '';
+            $gradeLabel = $gradeValue;
+            if (is_numeric($gradeValue)) {
+                $gradeLabel = $gradeMap[(int) $gradeValue] ?? (string) $gradeValue;
+            }
+
+            if (!isset($students[$studentKey])) {
+                $students[$studentKey] = [
+                    'student_id' => $studentId,
+                    'student_name' => $studentName,
+                    'grade' => (string) $gradeLabel,
+                    'total' => 0,
+                    'open' => 0,
+                    'closed' => 0,
+                    'canceled' => 0,
+                    'last_incident' => null,
+                    'logs' => [],
+                ];
+            }
+
+            $students[$studentKey]['total'] += 1;
+
+            $state = (string) ($incident['incident_state'] ?? '');
+            if ($state === 'Open') {
+                $students[$studentKey]['open'] += 1;
+            } elseif ($state === 'Closed') {
+                $students[$studentKey]['closed'] += 1;
+            } elseif ($state === 'Canceled') {
+                $students[$studentKey]['canceled'] += 1;
+            }
+
+            if ($students[$studentKey]['last_incident'] === null) {
+                $students[$studentKey]['last_incident'] = $incident['incident_datetime'] ?? null;
+            }
+
+            $students[$studentKey]['logs'][] = [
+                'incident' => $incident['incident'] ?? '',
+                'incident_state' => $state,
+                'incident_datetime' => $incident['incident_datetime'] ?? null,
+                'open_description' => $incident['open_description'] ?? null,
+                'close_description' => $incident['close_description'] ?? null,
+                'cancel_description' => $incident['cancel_description'] ?? null,
+                'action_taken' => $incident['action_taken'] ?? null,
+            ];
+        }
+
+        $studentRows = array_values($students);
+        usort($studentRows, function ($a, $b) {
+            if ($a['total'] === $b['total']) {
+                return strcasecmp($a['student_name'], $b['student_name']);
+            }
+            return $b['total'] <=> $a['total'];
+        });
+
+        return $studentRows;
+    }
+}
diff --git a/app/Services/Incidents/IncidentHistoryService.php b/app/Services/Incidents/IncidentHistoryService.php
new file mode 100644
index 00000000..36af2499
--- /dev/null
+++ b/app/Services/Incidents/IncidentHistoryService.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace App\Services\Incidents;
+
+use App\Models\Incident;
+
+class IncidentHistoryService
+{
+    public function __construct(private IncidentLookupService $lookup)
+    {
+    }
+
+    public function history(?string $schoolYear, ?string $semester): array
+    {
+        $builder = Incident::query()->orderBy('incident_datetime', 'DESC');
+        if ($schoolYear !== null && $schoolYear !== '') {
+            $builder->where('school_year', $schoolYear);
+        }
+        if ($semester !== null && $semester !== '') {
+            $builder->where('semester', $semester);
+        }
+
+        return $builder->get()->map(fn ($row) => $row->toArray())->all();
+    }
+
+    public function processed(?string $schoolYear, ?string $semester): array
+    {
+        $incidents = $this->history($schoolYear, $semester);
+        if (empty($incidents)) {
+            return [];
+        }
+
+        $gradeMap = $this->lookup->gradeNameMap(array_column($incidents, 'grade'));
+
+        $updaterIds = [];
+        foreach ($incidents as $incident) {
+            foreach (['updated_by_open', 'updated_by_closed', 'updated_by_canceled'] as $key) {
+                if (!empty($incident[$key])) {
+                    $updaterIds[] = (int) $incident[$key];
+                }
+            }
+        }
+
+        $updaterMap = $this->lookup->updaterNameMap($updaterIds);
+
+        foreach ($incidents as &$incident) {
+            foreach (['updated_by_open', 'updated_by_closed', 'updated_by_canceled'] as $key) {
+                $id = (int) ($incident[$key] ?? 0);
+                $incident[$key . '_name'] = $id > 0 ? ($updaterMap[$id] ?? null) : null;
+            }
+
+            $gradeValue = $incident['grade'] ?? '';
+            if (is_numeric($gradeValue)) {
+                $incident['grade'] = $gradeMap[(int) $gradeValue] ?? (string) $gradeValue;
+            }
+        }
+        unset($incident);
+
+        return $incidents;
+    }
+}
diff --git a/app/Services/Incidents/IncidentLookupService.php b/app/Services/Incidents/IncidentLookupService.php
new file mode 100644
index 00000000..8031a372
--- /dev/null
+++ b/app/Services/Incidents/IncidentLookupService.php
@@ -0,0 +1,86 @@
+<?php
+
+namespace App\Services\Incidents;
+
+use App\Models\ClassSection;
+use App\Models\StudentClass;
+use Illuminate\Support\Facades\DB;
+
+class IncidentLookupService
+{
+    public function gradeOptionsWithActiveStudents(?string $schoolYear = null): array
+    {
+        $studentCounts = StudentClass::getStudentCountsBySection($schoolYear);
+        if (empty($studentCounts)) {
+            return [];
+        }
+
+        $classSections = ClassSection::query()
+            ->orderBy('class_section_name', 'ASC')
+            ->whereIn('class_section_id', array_keys($studentCounts))
+            ->get()
+            ->map(fn ($row) => $row->toArray())
+            ->all();
+
+        $grades = [];
+        foreach ($classSections as $section) {
+            $grades[] = [
+                'id' => $section['class_section_id'],
+                'name' => $section['class_section_name'],
+            ];
+        }
+
+        return $grades;
+    }
+
+    public function gradeNameMap(array $gradeValues): array
+    {
+        $gradeIds = [];
+        foreach ($gradeValues as $gradeValue) {
+            if (is_numeric($gradeValue)) {
+                $gradeIds[(int) $gradeValue] = true;
+            }
+        }
+
+        if (empty($gradeIds)) {
+            return [];
+        }
+
+        $rows = ClassSection::query()
+            ->select('class_section_id', 'class_section_name')
+            ->whereIn('class_section_id', array_keys($gradeIds))
+            ->get()
+            ->map(fn ($row) => $row->toArray())
+            ->all();
+
+        $gradeMap = [];
+        foreach ($rows as $row) {
+            $gradeMap[(int) $row['class_section_id']] = (string) ($row['class_section_name'] ?? '');
+        }
+
+        return $gradeMap;
+    }
+
+    public function updaterNameMap(array $userIds): array
+    {
+        $userIds = array_values(array_filter(array_unique(array_map('intval', $userIds))));
+        if (empty($userIds)) {
+            return [];
+        }
+
+        $rows = DB::table('users')
+            ->select('id, firstname, lastname')
+            ->whereIn('id', $userIds)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $map = [];
+        foreach ($rows as $row) {
+            $name = trim((string) ($row['firstname'] ?? '') . ' ' . (string) ($row['lastname'] ?? ''));
+            $map[(int) $row['id']] = $name !== '' ? $name : ('User #' . $row['id']);
+        }
+
+        return $map;
+    }
+}
diff --git a/app/Services/Invoices/InvoiceConfigService.php b/app/Services/Invoices/InvoiceConfigService.php
new file mode 100644
index 00000000..1ccb9cc7
--- /dev/null
+++ b/app/Services/Invoices/InvoiceConfigService.php
@@ -0,0 +1,63 @@
+<?php
+
+namespace App\Services\Invoices;
+
+use App\Models\Configuration;
+
+class InvoiceConfigService
+{
+    public function getSchoolYear(): string
+    {
+        return (string) (Configuration::getConfig('school_year') ?? date('Y'));
+    }
+
+    public function getSemester(): string
+    {
+        return (string) (Configuration::getConfig('semester') ?? 'Fall');
+    }
+
+    public function getDueDate(): ?string
+    {
+        $value = Configuration::getConfig('due_date');
+        return $value ? (string) $value : null;
+    }
+
+    public function getGradeFee(): int
+    {
+        return (int) (Configuration::getConfig('grade_fee') ?? 9);
+    }
+
+    public function getFirstStudentFee(): float
+    {
+        return (float) (Configuration::getConfig('first_student_fee') ?? 350);
+    }
+
+    public function getSecondStudentFee(): float
+    {
+        return (float) (Configuration::getConfig('second_student_fee') ?? 200);
+    }
+
+    public function getYouthFee(): float
+    {
+        return (float) (Configuration::getConfig('youth_fee') ?? 180);
+    }
+
+    public function getRefundDeadline(): ?string
+    {
+        $value = Configuration::getConfig('refund_deadline');
+        if (!$value) {
+            return null;
+        }
+
+        try {
+            return date('Y-m-d', strtotime((string) $value));
+        } catch (\Throwable $e) {
+            return null;
+        }
+    }
+
+    public function getTimezone(): string
+    {
+        return (string) (config('School')->attendance['timezone'] ?? user_timezone());
+    }
+}
diff --git a/app/Services/Invoices/InvoiceGenerationService.php b/app/Services/Invoices/InvoiceGenerationService.php
new file mode 100644
index 00000000..ab3b90b3
--- /dev/null
+++ b/app/Services/Invoices/InvoiceGenerationService.php
@@ -0,0 +1,264 @@
+<?php
+
+namespace App\Services\Invoices;
+
+use App\Models\Enrollment;
+use App\Models\EventCharges;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\Refund;
+use App\Models\StudentClass;
+use App\Models\User;
+use DateTime;
+use DateTimeZone;
+use Illuminate\Support\Facades\DB;
+
+class InvoiceGenerationService
+{
+    public function __construct(
+        private InvoiceConfigService $config,
+        private InvoiceTuitionService $tuitionService
+    ) {
+    }
+
+    public function generateInvoice(int $parentId, ?string $schoolYear = null): array
+    {
+        $schoolYear = $schoolYear ?: $this->config->getSchoolYear();
+        $semester = $this->config->getSemester();
+
+        $enrollments = Enrollment::query()
+            ->where('parent_id', $parentId)
+            ->where('school_year', $schoolYear)
+            ->get()
+            ->map(fn ($r) => (array) $r)
+            ->all();
+
+        if (empty($enrollments)) {
+            return [
+                'ok' => false,
+                'message' => 'No enrollment records found.',
+            ];
+        }
+
+        $registeredKids = [];
+        $withdrawnKids = [];
+
+        foreach ($enrollments as $enrollment) {
+            $student = [
+                'student_id' => $enrollment['student_id'],
+                'parent_id' => $enrollment['parent_id'],
+                'class_section_id' => $enrollment['class_section_id'],
+                'enrollment_status' => $enrollment['enrollment_status'],
+                'school_year' => $enrollment['school_year'],
+                'semester' => $enrollment['semester'],
+                'admission_status' => $enrollment['admission_status'],
+                'is_withdrawn' => $enrollment['is_withdrawn'],
+            ];
+
+            if (in_array($enrollment['enrollment_status'], ['enrolled', 'payment pending'], true)) {
+                $registeredKids[] = $student;
+            } elseif (in_array($enrollment['enrollment_status'], ['withdrawn', 'refund pending', 'withdraw under review'], true)) {
+                $withdrawnKids[] = $student;
+            }
+        }
+
+        $registeredKids = array_values(array_filter($registeredKids, function ($student) use ($schoolYear) {
+            $sid = (int) ($student['student_id'] ?? 0);
+            return $sid > 0 && StudentClass::hasNonEventAssignment($sid, $schoolYear);
+        }));
+
+        $withdrawnKids = array_values(array_filter($withdrawnKids, function ($student) use ($schoolYear) {
+            $sid = (int) ($student['student_id'] ?? 0);
+            return $sid > 0 && StudentClass::hasNonEventAssignment($sid, $schoolYear);
+        }));
+
+        $tuitionFee = $this->tuitionService->calculateTuitionFee(
+            $registeredKids,
+            $withdrawnKids,
+            $this->config->getRefundDeadline()
+        );
+
+        $eventsList = EventCharges::getChargesWithEventInfo($parentId, $schoolYear);
+        $eventChargeTotal = array_sum(array_column($eventsList, 'charged'));
+
+        $this->recalculateAndUpdateDiscount($parentId, $schoolYear, $tuitionFee, $enrollments);
+
+        $refundPaid = (new Refund())->getTotalApprovedRefundByParentIdAndSchoolYear($parentId, $schoolYear);
+        $totalPaid = Payment::getTotalPaidByParentId($parentId, $schoolYear);
+
+        $totalAmount = max(0.0, (float) $tuitionFee) + (float) $eventChargeTotal;
+
+        $existingInvoices = Invoice::getInvoicesByParentId($parentId, $schoolYear);
+        $updated = false;
+        $updatedIds = [];
+        $insertId = null;
+
+        if (!empty($existingInvoices)) {
+            foreach ($existingInvoices as $invoice) {
+                if (!isset($invoice['id'])) {
+                    continue;
+                }
+
+                $extrasSum = $this->sumInvoiceAdditionalCharges((int) $invoice['id'], $schoolYear);
+                $newTotal = round($totalAmount + $extrasSum, 2);
+
+                $invDiscount = $this->sumInvoiceDiscounts((int) $invoice['id']);
+                $invRefunds = $this->sumInvoiceRefunds((int) $invoice['id'], $schoolYear);
+                $paidOnInv = (float) ($invoice['paid_amount'] ?? 0.0);
+
+                $newBalance = $newTotal - $invDiscount - $invRefunds - $paidOnInv;
+                $newStatus = $newBalance <= 0.00001
+                    ? 'Paid'
+                    : ($paidOnInv > 0 ? 'Partially Paid' : 'Unpaid');
+
+                Invoice::query()
+                    ->whereKey($invoice['id'])
+                    ->update([
+                        'total_amount' => $newTotal,
+                        'paid_amount' => $paidOnInv,
+                        'balance' => $newBalance,
+                        'status' => $newStatus,
+                        'updated_at' => utc_now(),
+                    ]);
+
+                $updatedIds[] = (int) $invoice['id'];
+                $updated = true;
+            }
+        } else {
+            $schoolId = User::getSchoolIdByUserId($parentId);
+            $invoiceNumber = $schoolId
+                ? ('INV-' . $schoolId . '-' . uniqid())
+                : uniqid('INV-');
+
+            $issueUtc = (new DateTime('now', new DateTimeZone('UTC')))->format('Y-m-d H:i:s');
+            $dueUtc = null;
+            $dueDate = $this->config->getDueDate();
+            if (!empty($dueDate)) {
+                $dueLocal = new DateTime($dueDate . ' 19:59:59', new DateTimeZone($this->config->getTimezone()));
+                $dueLocal->setTimezone(new DateTimeZone('UTC'));
+                $dueUtc = $dueLocal->format('Y-m-d H:i:s');
+            }
+
+            $insertId = Invoice::query()->insertGetId([
+                'parent_id' => $parentId,
+                'invoice_number' => $invoiceNumber,
+                'total_amount' => $totalAmount,
+                'paid_amount' => 0,
+                'balance' => $totalAmount,
+                'status' => 'Unpaid',
+                'school_year' => $schoolYear,
+                'semester' => $semester,
+                'issue_date' => $issueUtc,
+                'due_date' => $dueUtc,
+                'created_at' => utc_now(),
+                'updated_at' => utc_now(),
+            ]);
+        }
+
+        return [
+            'ok' => true,
+            'updated' => $updated,
+            'updated_ids' => $updatedIds,
+            'insert_id' => $insertId ? (int) $insertId : null,
+            'total_paid' => $totalPaid,
+            'refund_paid' => $refundPaid,
+        ];
+    }
+
+    private function recalculateAndUpdateDiscount(int $parentId, string $schoolYear, float $tuitionFee, array $enrollments): void
+    {
+        $eventChargeTotal = 0.0;
+        try {
+            $eventsList = EventCharges::getChargesWithEventInfo($parentId, $schoolYear);
+            $eventChargeTotal = array_sum(array_column($eventsList, 'charged'));
+        } catch (\Throwable $e) {
+        }
+
+        $invoices = Invoice::getInvoicesByParentId($parentId, $schoolYear);
+        if (empty($invoices)) {
+            return;
+        }
+
+        foreach ($invoices as $invoice) {
+            if (!isset($invoice['id'])) {
+                continue;
+            }
+
+            $invoiceId = (int) $invoice['id'];
+            $discountUsage = DB::table('discount_usages as du')
+                ->select('du.id', 'dv.id as voucher_id', 'dv.discount_type', 'dv.discount_value')
+                ->join('discount_vouchers as dv', 'du.voucher_id', '=', 'dv.id')
+                ->join('invoices as i', 'du.invoice_id', '=', 'i.id')
+                ->where('du.invoice_id', $invoiceId)
+                ->where('i.school_year', $schoolYear)
+                ->first();
+
+            if (!$discountUsage) {
+                continue;
+            }
+
+            $extrasSum = $this->sumInvoiceAdditionalCharges($invoiceId, $schoolYear);
+            $baseTotal = round($tuitionFee + $eventChargeTotal + $extrasSum, 2);
+
+            if (($discountUsage->discount_type ?? '') === 'percent') {
+                $discountAmount = round(($baseTotal * (float) $discountUsage->discount_value) / 100, 2);
+            } else {
+                $discountAmount = min((float) $discountUsage->discount_value, $baseTotal);
+            }
+
+            DB::table('discount_usages')
+                ->where('id', $discountUsage->id)
+                ->update([
+                    'discount_amount' => $discountAmount,
+                    'updated_at' => utc_now(),
+                    'updated_by' => auth()->id(),
+                ]);
+        }
+    }
+
+    private function sumInvoiceAdditionalCharges(int $invoiceId, string $schoolYear): float
+    {
+        $extrasSum = 0.0;
+        $rows = DB::table('additional_charges')
+            ->select('charge_type', 'amount')
+            ->where('invoice_id', $invoiceId)
+            ->where('school_year', $schoolYear)
+            ->where('status', 'applied')
+            ->get();
+
+        foreach ($rows as $row) {
+            $amount = (float) ($row->amount ?? 0);
+            $type = strtolower((string) ($row->charge_type ?? 'add'));
+            if ($type === 'deduct') {
+                $amount = -abs($amount);
+            } else {
+                $amount = abs($amount);
+            }
+            $extrasSum += $amount;
+        }
+
+        return $extrasSum;
+    }
+
+    private function sumInvoiceDiscounts(int $invoiceId): float
+    {
+        $row = DB::table('discount_usages')
+            ->selectRaw('COALESCE(SUM(discount_amount),0) AS tot')
+            ->where('invoice_id', $invoiceId)
+            ->first();
+
+        return (float) ($row->tot ?? 0.0);
+    }
+
+    private function sumInvoiceRefunds(int $invoiceId, string $schoolYear): float
+    {
+        $row = DB::table('refunds')
+            ->selectRaw('COALESCE(SUM(refund_paid_amount),0) AS tot')
+            ->where('invoice_id', $invoiceId)
+            ->where('school_year', $schoolYear)
+            ->whereIn('status', ['Partial', 'Paid'])
+            ->first();
+
+        return (float) ($row->tot ?? 0.0);
+    }
+}
diff --git a/app/Services/Invoices/InvoiceGradeService.php b/app/Services/Invoices/InvoiceGradeService.php
new file mode 100644
index 00000000..41d54c1e
--- /dev/null
+++ b/app/Services/Invoices/InvoiceGradeService.php
@@ -0,0 +1,83 @@
+<?php
+
+namespace App\Services\Invoices;
+
+class InvoiceGradeService
+{
+    public function __construct(private int $gradeFee)
+    {
+    }
+
+    public function isKindergarten(string $grade): bool
+    {
+        $g = strtolower(trim($grade));
+        return in_array($g, ['KG', 'kg', 'k', 'kindergarten', 'k-g', 'k.g', 'k g'], true);
+    }
+
+    public function compareGrades(string $gradeA, string $gradeB): int
+    {
+        $valA = $this->getGradeLevel($gradeA);
+        $valB = $this->getGradeLevel($gradeB);
+
+        if ($valA['level'] !== $valB['level']) {
+            return $valA['level'] <=> $valB['level'];
+        }
+
+        return strcmp($valA['suffix'] ?? '', $valB['suffix'] ?? '');
+    }
+
+    public function gradeLevelInt(string $grade): int
+    {
+        $gl = $this->getGradeLevel($grade);
+        return (int) ($gl['level'] ?? 0);
+    }
+
+    public function getGradeLevel($grade): array
+    {
+        if (is_numeric($grade)) {
+            $num = (int) $grade;
+            if ($num === 13) {
+                return ['level' => 1, 'suffix' => '', 'classId' => 13];
+            }
+            return ['level' => $num, 'suffix' => '', 'classId' => null];
+        }
+
+        if (!is_string($grade)) {
+            return ['level' => 999, 'suffix' => '', 'classId' => null];
+        }
+
+        $g = strtoupper(trim($grade));
+        $g = preg_replace('/\s+/', ' ', $g);
+        $g = str_replace(['.', '_'], '', $g);
+        $g = str_replace('-', ' ', $g);
+
+        $kg = ['K', 'KG', 'K G', 'KINDER', 'KINDERGARTEN'];
+        if (in_array($g, $kg, true)) {
+            return ['level' => 1, 'suffix' => '', 'classId' => 13];
+        }
+
+        $pk = ['PK', 'P K', 'PREK', 'PRE K', 'PRE-K', 'PRE KINDER', 'PREKINDER'];
+        if (in_array($g, $pk, true)) {
+            return ['level' => -1, 'suffix' => '', 'classId' => null];
+        }
+
+        if (preg_match('/^Y(?:OUTH)?(?:\s*(\d+))?$/', $g, $m)) {
+            $n = isset($m[1]) && $m[1] !== '' ? max(1, (int) $m[1]) : 1;
+            return [
+                'level' => $this->gradeFee + $n,
+                'suffix' => '',
+                'classId' => null,
+            ];
+        }
+
+        if (preg_match('/^(?:GR?ADE\s*)?(\d{1,2})\s*([A-Z]*)$/', $g, $m)) {
+            return [
+                'level' => (int) $m[1],
+                'suffix' => $m[2] ?? '',
+                'classId' => null,
+            ];
+        }
+
+        return ['level' => 999, 'suffix' => '', 'classId' => null];
+    }
+}
diff --git a/app/Services/Invoices/InvoiceManagementService.php b/app/Services/Invoices/InvoiceManagementService.php
new file mode 100644
index 00000000..c6c05d5f
--- /dev/null
+++ b/app/Services/Invoices/InvoiceManagementService.php
@@ -0,0 +1,146 @@
+<?php
+
+namespace App\Services\Invoices;
+
+use App\Models\Enrollment;
+use App\Models\Invoice;
+use App\Models\Student;
+use App\Models\StudentClass;
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+
+class InvoiceManagementService
+{
+    public function __construct(private InvoiceConfigService $config)
+    {
+    }
+
+    public function getManagementData(?string $schoolYear): array
+    {
+        $schoolYear = trim((string) ($schoolYear ?? ''));
+        if ($schoolYear === '') {
+            $schoolYear = $this->config->getSchoolYear();
+        }
+
+        $schoolYears = DB::table('invoices')
+            ->select('school_year')
+            ->distinct()
+            ->orderBy('school_year', 'DESC')
+            ->pluck('school_year')
+            ->map(fn ($val) => (string) $val)
+            ->filter(fn ($val) => $val !== '')
+            ->values()
+            ->all();
+
+        if (empty($schoolYears)) {
+            $schoolYears = [$schoolYear];
+        }
+
+        $invoiceData = [];
+        $parents = User::getUsersByRoleAndSchoolYear('parent', $schoolYear);
+
+        foreach ($parents as $parent) {
+            $students = Student::query()->where('parent_id', $parent['id'])->get()->map(fn ($r) => (array) $r)->all();
+
+            $parentData = [
+                'parent_name' => trim(($parent['firstname'] ?? '') . ' ' . ($parent['lastname'] ?? '')),
+                'parent_id' => (int) $parent['id'],
+                'enrolledKids' => [],
+                'withdrawnKids' => [],
+                'invoice_amount' => 0,
+                'refund_amount' => 0,
+                'last_updated' => null,
+                'invoice_date' => null,
+                'invoice_id' => null,
+            ];
+
+            $invoices = Invoice::getInvoicesByParentId((int) $parent['id'], $schoolYear);
+            foreach ($invoices as $invoice) {
+                if (!$invoice) {
+                    continue;
+                }
+
+                $parentData['invoice_amount'] = (float) ($invoice['total_amount'] ?? 0);
+                $parentData['last_updated'] = $invoice['updated_at'] ?? null;
+                $parentData['invoice_id'] = $invoice['id'] ?? null;
+
+                if (!empty($invoice['issue_date'])) {
+                    $tzName = $this->config->getTimezone();
+                    $parentData['invoice_date'] = (new \DateTimeImmutable($invoice['issue_date'], new \DateTimeZone('UTC')))
+                        ->setTimezone(new \DateTimeZone($tzName))
+                        ->format('Y-m-d H:i:s');
+                } else {
+                    $parentData['invoice_date'] = !empty($invoice['updated_at'])
+                        ? date('Y-m-d H:i:s', strtotime($invoice['updated_at']))
+                        : null;
+                }
+
+                $refund = DB::table('refunds')
+                    ->selectRaw('COALESCE(SUM(refund_paid_amount),0) AS refund_paid_amount')
+                    ->where('parent_id', $parent['id'])
+                    ->where('school_year', $schoolYear)
+                    ->whereIn('status', ['Partial', 'Paid'])
+                    ->first();
+
+                $parentData['refund_amount'] = (float) ($refund->refund_paid_amount ?? 0.0);
+                break;
+            }
+
+            foreach ($students as $student) {
+                $grade = 'N/A';
+                $studentClass = DB::table('student_class')
+                    ->where('student_id', $student['id'])
+                    ->where('school_year', $schoolYear)
+                    ->first();
+
+                if ($studentClass && isset($studentClass->class_section_id)) {
+                    $classSection = DB::table('classSection')
+                        ->where('class_section_id', $studentClass->class_section_id)
+                        ->first();
+                    if ($classSection && isset($classSection->class_section_name)) {
+                        $grade = $classSection->class_section_name;
+                    }
+                }
+
+                $enrollments = Enrollment::query()
+                    ->where('student_id', $student['id'])
+                    ->where('school_year', $schoolYear)
+                    ->get()
+                    ->map(fn ($r) => (array) $r)
+                    ->all();
+
+                foreach ($enrollments as $enrollment) {
+                    $kid = [
+                        'name' => trim(($student['firstname'] ?? '') . ' ' . ($student['lastname'] ?? '')),
+                        'grade' => $grade,
+                        'tuition_fee' => (float) ($enrollment['tuition_fee'] ?? 0),
+                    ];
+
+                    switch ($enrollment['enrollment_status']) {
+                        case 'payment pending':
+                        case 'enrolled':
+                            $parentData['enrolledKids'][] = $kid;
+                            break;
+                        case 'withdraw under review':
+                        case 'withdrawn':
+                        case 'refund pending':
+                            $parentData['withdrawnKids'][] = $kid;
+                            break;
+                        default:
+                            break;
+                    }
+                }
+            }
+
+            if (!empty($parentData['enrolledKids']) || !empty($parentData['withdrawnKids'])) {
+                $invoiceData[] = $parentData;
+            }
+        }
+
+        return [
+            'schoolYear' => $schoolYear,
+            'schoolYears' => $schoolYears,
+            'invoices' => $invoiceData,
+        ];
+    }
+}
diff --git a/app/Services/Invoices/InvoicePaymentService.php b/app/Services/Invoices/InvoicePaymentService.php
new file mode 100644
index 00000000..ec1ad56c
--- /dev/null
+++ b/app/Services/Invoices/InvoicePaymentService.php
@@ -0,0 +1,82 @@
+<?php
+
+namespace App\Services\Invoices;
+
+use App\Models\Invoice;
+use App\Models\Payment;
+use Illuminate\Support\Facades\DB;
+
+class InvoicePaymentService
+{
+    public function __construct(private InvoiceConfigService $config)
+    {
+    }
+
+    public function getParentInvoiceSummary(int $parentId, ?string $schoolYear): array
+    {
+        $currentSchoolYear = $this->config->getSchoolYear();
+
+        $schoolYears = DB::table('invoices')
+            ->select('school_year')
+            ->distinct()
+            ->where('parent_id', $parentId)
+            ->orderBy('school_year', 'DESC')
+            ->get()
+            ->map(fn ($r) => (array) $r)
+            ->all();
+
+        $selectedYear = $schoolYear ?: null;
+        if (!$selectedYear) {
+            $hasCurrentYear = in_array($currentSchoolYear, array_column($schoolYears, 'school_year'), true);
+            $selectedYear = $hasCurrentYear ? $currentSchoolYear : (!empty($schoolYears) ? $schoolYears[0]['school_year'] : null);
+        }
+
+        $invoices = [];
+        if ($selectedYear) {
+            $invoices = Invoice::getInvoicesByParentId($parentId, $selectedYear);
+        }
+
+        $invoiceIds = array_column($invoices, 'id');
+        $refunds = [];
+        if (!empty($invoiceIds)) {
+            $refundResults = DB::table('refunds')
+                ->selectRaw('invoice_id, COALESCE(SUM(refund_paid_amount),0) as refund_paid_amount')
+                ->whereIn('invoice_id', $invoiceIds)
+                ->whereIn('status', ['Partial', 'Paid'])
+                ->groupBy('invoice_id')
+                ->get()
+                ->map(fn ($r) => (array) $r)
+                ->all();
+
+            foreach ($refundResults as $row) {
+                $refunds[$row['invoice_id']] = (float) ($row['refund_paid_amount'] ?? 0);
+            }
+        }
+
+        $lastPayments = [];
+        if (!empty($invoiceIds)) {
+            $paymentResults = Payment::getPaymentsByInvoice($invoiceIds);
+            foreach ($paymentResults as $payment) {
+                $lastPayments[$payment['invoice_id']] = [
+                    'last_paid_amount' => (float) ($payment['last_paid_amount'] ?? 0),
+                    'last_payment_date' => $payment['last_payment_date'] ?? null,
+                ];
+            }
+        }
+
+        foreach ($invoices as &$invoice) {
+            $invoice['refund_amount'] = $refunds[$invoice['id']] ?? 0.0;
+            $invoice['last_paid_amount'] = $lastPayments[$invoice['id']]['last_paid_amount'] ?? 0.0;
+            $invoice['last_payment_date'] = $lastPayments[$invoice['id']]['last_payment_date'] ?? null;
+        }
+        unset($invoice);
+
+        return [
+            'invoices' => $invoices,
+            'schoolYears' => $schoolYears,
+            'selectedYear' => $selectedYear,
+            'currentSchoolYear' => $currentSchoolYear,
+            'dueDate' => $this->config->getDueDate(),
+        ];
+    }
+}
diff --git a/app/Services/Invoices/InvoicePdfService.php b/app/Services/Invoices/InvoicePdfService.php
new file mode 100644
index 00000000..39c006e7
--- /dev/null
+++ b/app/Services/Invoices/InvoicePdfService.php
@@ -0,0 +1,445 @@
+<?php
+
+namespace App\Services\Invoices;
+
+use App\Models\AdditionalCharge;
+use App\Models\ClassSection;
+use App\Models\DiscountUsage;
+use App\Models\Enrollment;
+use App\Models\EventCharges;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\Refund;
+use App\Models\Student;
+use App\Models\StudentClass;
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+class InvoicePdfService
+{
+    public function __construct(
+        private InvoiceConfigService $config,
+        private InvoiceGradeService $grades
+    ) {
+    }
+
+    public function buildPdf(int $invoiceId): string
+    {
+        $data = $this->prepareInvoiceData($invoiceId);
+        if (isset($data['error'])) {
+            return $this->renderErrorPdf($data['error']);
+        }
+
+        return $this->renderPdfInvoice($data);
+    }
+
+    private function prepareInvoiceData(int $invoiceId): array
+    {
+        $invoice = Invoice::query()->find($invoiceId);
+        if (!$invoice) {
+            return ['error' => 'No invoice was generated. Please contact the school administration.'];
+        }
+
+        $parentId = (int) ($invoice->parent_id ?? 0);
+        $schoolYear = (string) ($invoice->school_year ?? $this->config->getSchoolYear());
+
+        $paymentsQuery = Payment::query()
+            ->where('parent_id', $parentId)
+            ->where('school_year', $schoolYear)
+            ->where('invoice_id', $invoiceId);
+
+        if (Schema::hasColumn('payments', 'status')) {
+            $exclude = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
+            $paymentsQuery->where(function ($q) use ($exclude) {
+                $q->whereNotIn('status', $exclude)->orWhereNull('status');
+            });
+        }
+        if (Schema::hasColumn('payments', 'is_void')) {
+            $paymentsQuery->where(function ($q) {
+                $q->where('is_void', 0)->orWhereNull('is_void');
+            });
+        }
+
+        $payments = $paymentsQuery->get()->map(fn ($r) => $r->toArray())->all();
+
+        $parent = User::query()->find($parentId);
+        if (!$parent) {
+            return ['error' => 'Parent associated with the invoice was not found.'];
+        }
+
+        $enrollments = Enrollment::query()
+            ->where('parent_id', $parentId)
+            ->where('school_year', $schoolYear)
+            ->get()
+            ->map(fn ($r) => $r->toArray())
+            ->all();
+
+        if (empty($enrollments)) {
+            return ['error' => 'No enrollments found for this invoice.'];
+        }
+
+        $registeredKids = [];
+        $withdrawnKids = [];
+
+        foreach ($enrollments as $enrollment) {
+            $student = Student::query()->find($enrollment['student_id']);
+            if (!$student) {
+                continue;
+            }
+
+            $grade = StudentClass::getStudentGrade((int) $student->id);
+            $studentData = [
+                'student_id' => (int) $student->id,
+                'student_firstname' => (string) ($student->firstname ?? ''),
+                'student_lastname' => (string) ($student->lastname ?? ''),
+                'grade' => $grade,
+                'tuition_fee' => $enrollment['tuition_fee'] ?? 0,
+                'enrollment_status' => $enrollment['enrollment_status'],
+            ];
+
+            if (in_array($enrollment['enrollment_status'], ['enrolled', 'payment pending'], true)) {
+                $registeredKids[] = $studentData;
+            } elseif (in_array($enrollment['enrollment_status'], ['withdrawn', 'withdraw under review', 'refund pending'], true)) {
+                $withdrawnKids[] = $studentData;
+            }
+        }
+
+        $registeredKids = array_values(array_filter($registeredKids, function ($student) use ($schoolYear) {
+            $sid = (int) ($student['student_id'] ?? 0);
+            return $sid > 0 && StudentClass::hasNonEventAssignment($sid, $schoolYear);
+        }));
+
+        $withdrawnKids = array_values(array_filter($withdrawnKids, function ($student) use ($schoolYear) {
+            $sid = (int) ($student['student_id'] ?? 0);
+            return $sid > 0 && StudentClass::hasNonEventAssignment($sid, $schoolYear);
+        }));
+
+        usort($registeredKids, fn ($a, $b) => $this->grades->compareGrades((string) $a['grade'], (string) $b['grade']));
+        usort($withdrawnKids, fn ($a, $b) => $this->grades->compareGrades((string) $a['grade'], (string) $b['grade']));
+
+        $refundAllowed = true;
+        $refundDeadline = $this->config->getRefundDeadline();
+        if ($refundDeadline) {
+            try {
+                $tz = new \DateTimeZone($this->config->getTimezone());
+                $today = new \DateTimeImmutable('today', $tz);
+                $deadline = new \DateTimeImmutable($refundDeadline, $tz);
+                $refundAllowed = $today <= $deadline;
+            } catch (\Throwable $e) {
+                $refundAllowed = true;
+            }
+        }
+
+        $studentCharges = [];
+        $regularCount = 0;
+        $gradeFee = $this->config->getGradeFee();
+        $firstFee = $this->config->getFirstStudentFee();
+        $secondFee = $this->config->getSecondStudentFee();
+        $youthFee = $this->config->getYouthFee();
+
+        $computeCharge = function (int $gradeLevel, string $gradeName) use (&$regularCount, $gradeFee, $firstFee, $secondFee, $youthFee) {
+            $isRegular = $this->grades->isKindergarten($gradeName) || ($gradeLevel > 0 && $gradeLevel <= $gradeFee);
+            if ($isRegular) {
+                $fee = $regularCount === 0 ? $firstFee : $secondFee;
+                $regularCount++;
+                return $fee;
+            }
+            return $youthFee;
+        };
+
+        foreach ($registeredKids as $student) {
+            $gradeName = (string) ($student['grade'] ?? '');
+            $gradeLevel = $this->grades->gradeLevelInt($gradeName);
+            $unitFee = $computeCharge($gradeLevel, $gradeName);
+            $studentCharges[$student['student_id']] = ['unit_fee' => $unitFee, 'refund' => 0];
+        }
+
+        if (!$refundAllowed) {
+            foreach ($withdrawnKids as $student) {
+                $gradeName = (string) ($student['grade'] ?? '');
+                $gradeLevel = $this->grades->gradeLevelInt($gradeName);
+                $unitFee = $computeCharge($gradeLevel, $gradeName);
+                $studentCharges[$student['student_id']] = ['unit_fee' => $unitFee, 'refund' => 0];
+            }
+        }
+
+        $eventsList = EventCharges::getChargesWithEventInfo($parentId, $schoolYear);
+
+        $studentIds = array_values(array_unique(array_map(static fn ($r) => (int) ($r['student_id'] ?? 0), array_merge($registeredKids, $withdrawnKids))));
+        $schoolIdMap = [];
+        if (!empty($studentIds)) {
+            $rows = Student::query()->whereIn('id', $studentIds)->get(['id', 'school_id'])->all();
+            foreach ($rows as $row) {
+                $schoolIdMap[(int) $row->id] = $row->school_id ?? 'N/A';
+            }
+        }
+
+        $students = array_merge($registeredKids, $withdrawnKids);
+        foreach ($students as $i => $s) {
+            $sid = (int) ($s['student_id'] ?? 0);
+            $students[$i]['student_school_id'] = $schoolIdMap[$sid] ?? 'N/A';
+        }
+
+        $discounts = DiscountUsage::query()
+            ->where('invoice_id', $invoiceId)
+            ->where('parent_id', $parentId)
+            ->where('school_year', $schoolYear)
+            ->get()
+            ->map(fn ($r) => $r->toArray())
+            ->all();
+
+        $refundsPaidTotal = (float) DB::table('refunds')
+            ->selectRaw('COALESCE(SUM(refund_paid_amount),0) AS tot')
+            ->where('invoice_id', $invoiceId)
+            ->where('school_year', $schoolYear)
+            ->whereIn('status', ['Partial', 'Paid'])
+            ->value('tot');
+
+        $acRows = AdditionalCharge::query()
+            ->select('id', 'charge_type', 'title', 'description', 'amount', 'due_date', 'status', 'created_at')
+            ->where('invoice_id', $invoiceId)
+            ->where('status', '!=', 'void')
+            ->orderBy('created_at')
+            ->orderBy('id')
+            ->get()
+            ->map(fn ($r) => $r->toArray())
+            ->all();
+
+        $additionalChargeLines = [];
+        $additionalChargesTotal = 0.0;
+        foreach ($acRows as $ac) {
+            $signed = (float) ($ac['amount'] ?? 0);
+            $ctype = strtolower((string) ($ac['charge_type'] ?? ''));
+            if ($ctype === 'deduct' && $signed > 0) {
+                $signed = -$signed;
+            } elseif ($ctype === 'add' && $signed < 0) {
+                $signed = abs($signed);
+            }
+
+            $lineDate = !empty($ac['created_at'])
+                ? date('Y-m-d', strtotime($ac['created_at']))
+                : (!empty($invoice->created_at) ? local_date($invoice->created_at, 'Y-m-d') : local_date(utc_now(), 'Y-m-d'));
+
+            $desc = $ac['description'] ?? '';
+            if ($desc === '') {
+                $desc = $ctype === 'deduct' ? 'Deduct' : 'Add';
+            }
+
+            $additionalChargesTotal += $signed;
+            $additionalChargeLines[] = [
+                'date' => $lineDate,
+                'description' => $desc,
+                'amount' => $signed,
+            ];
+        }
+
+        return [
+            'invoice' => $invoice->toArray(),
+            'parent' => $parent->toArray(),
+            'registeredKids' => $registeredKids,
+            'withdrawnKids' => $withdrawnKids,
+            'studentCharges' => $studentCharges,
+            'events' => $eventsList,
+            'students' => $students,
+            'payments' => $payments,
+            'discounts' => $discounts,
+            'additionalChargeLines' => $additionalChargeLines,
+            'additionalChargesTotal' => round($additionalChargesTotal, 2),
+            'refundsPaidTotal' => $refundsPaidTotal,
+        ];
+    }
+
+    private function renderPdfInvoice(array $data): string
+    {
+        $invoice = $data['invoice'];
+        $parent = $data['parent'];
+        $registeredKids = $data['registeredKids'] ?? [];
+        $withdrawnKids = $data['withdrawnKids'] ?? [];
+        $studentCharges = $data['studentCharges'] ?? [];
+        $events = $data['events'] ?? [];
+        $students = $data['students'] ?? [];
+        $payments = $data['payments'] ?? [];
+        $discounts = $data['discounts'] ?? [];
+        $additionalChargeLines = $data['additionalChargeLines'] ?? [];
+        $additionalChargesTotal = (float) ($data['additionalChargesTotal'] ?? 0);
+        $refundsPaidTotal = (float) ($data['refundsPaidTotal'] ?? 0);
+
+        $pdf = new \FPDF();
+        $pdf->AddPage();
+        $pdf->SetFont('Arial', 'B', 16);
+        $pdf->Cell(0, 10, 'Invoice', 0, 1, 'C');
+        $pdf->Ln(4);
+
+        $pdf->SetFont('Arial', 'B', 12);
+        $pdf->Cell(40, 6, 'Parent Name:', 0, 0, 'L');
+        $pdf->SetFont('Arial', '', 12);
+        $pdf->Cell(0, 6, ($parent['firstname'] ?? '') . ' ' . ($parent['lastname'] ?? ''), 0, 1, 'L');
+
+        $pdf->SetFont('Arial', 'B', 12);
+        $pdf->Cell(40, 6, 'Invoice Number:', 0, 0, 'L');
+        $pdf->SetFont('Arial', '', 12);
+        $pdf->Cell(0, 6, (string) ($invoice['invoice_number'] ?? ''), 0, 1, 'L');
+
+        $pdf->Ln(8);
+        $pdf->SetFont('Arial', 'B', 11);
+        $pdf->Cell(30, 7, 'Date', 1);
+        $pdf->Cell(130, 7, 'Description', 1);
+        $pdf->Cell(30, 7, 'Amount', 1, 1, 'R');
+
+        $transactions = [];
+        $seq = 0;
+        $push = function (\DateTimeImmutable $dt, string $desc, float $amount, string $cat) use (&$transactions, &$seq) {
+            $transactions[] = [
+                'dt' => $dt,
+                'description' => $desc,
+                'amount' => $amount,
+                'cat' => $cat,
+                'seq' => $seq++,
+            ];
+        };
+
+        $tz = new \DateTimeZone($this->config->getTimezone());
+        $toLocal = function (?string $raw) use ($tz): \DateTimeImmutable {
+            if (!$raw) {
+                return new \DateTimeImmutable('now', $tz);
+            }
+            try {
+                return new \DateTimeImmutable($raw, $tz);
+            } catch (\Throwable $e) {
+                return new \DateTimeImmutable('now', $tz);
+            }
+        };
+
+        foreach ($registeredKids as $student) {
+            $id = $student['student_id'];
+            $unit = (float) ($studentCharges[$id]['unit_fee'] ?? 0.0);
+            $name = $student['student_firstname'] . ' ' . $student['student_lastname'];
+            $gradeName = ClassSection::getClassSectionNameByClassId($student['grade']) ?? $student['grade'];
+            $push($toLocal($invoice['created_at'] ?? null), 'Registration of "' . $name . '" in ' . $gradeName, $unit, 'registration');
+        }
+
+        foreach ($events as $event) {
+            $studentName = 'N/A';
+            if (!empty($event['student_id'])) {
+                foreach ($students as $st) {
+                    if (($st['student_id'] ?? null) == $event['student_id']) {
+                        $studentName = $st['student_firstname'] . ' ' . $st['student_lastname'];
+                        break;
+                    }
+                }
+            }
+            $amount = (float) ($event['charged'] ?? 0.0);
+            $eventName = $event['event_name'] ?? 'Event';
+            $push($toLocal($event['created_at'] ?? null), 'Event ' . $eventName . ' for "' . $studentName . '"', $amount, 'event');
+        }
+
+        foreach ($additionalChargeLines as $line) {
+            $push($toLocal($line['date'] ?? null), (string) ($line['description'] ?? 'Additional Charge'), (float) ($line['amount'] ?? 0), 'additional');
+        }
+
+        $totalPaid = 0.0;
+        foreach ($payments as $payment) {
+            $amount = (float) ($payment['paid_amount'] ?? 0.0);
+            $totalPaid += $amount;
+            $push($toLocal($payment['payment_date'] ?? null), 'Payment (' . ($payment['payment_method'] ?? 'Payment') . ')', -$amount, 'payment');
+        }
+
+        $totalDiscount = 0.0;
+        foreach ($discounts as $discount) {
+            $amount = (float) ($discount['discount_amount'] ?? 0.0);
+            $totalDiscount += $amount;
+            $push($toLocal($discount['used_at'] ?? null), 'Discount applied', -$amount, 'discount');
+        }
+
+        usort($transactions, function ($a, $b) {
+            $dayA = $a['dt']->format('Y-m-d');
+            $dayB = $b['dt']->format('Y-m-d');
+            if ($dayA !== $dayB) {
+                return $a['dt'] <=> $b['dt'];
+            }
+            $pri = [
+                'registration' => 10,
+                'event' => 20,
+                'additional' => 25,
+                'discount' => 30,
+                'payment' => 90,
+                'other' => 50,
+            ];
+            $pa = $pri[$a['cat']] ?? 50;
+            $pb = $pri[$b['cat']] ?? 50;
+            if ($pa !== $pb) {
+                return $pa <=> $pb;
+            }
+            $cmp = $a['dt'] <=> $b['dt'];
+            return $cmp !== 0 ? $cmp : ($a['seq'] <=> $b['seq']);
+        });
+
+        $pdf->SetFont('Arial', '', 10);
+        foreach ($transactions as $t) {
+            $pdf->Cell(30, 7, $t['dt']->format('m-d-Y'), 1);
+            $pdf->Cell(130, 7, $t['description'], 1);
+            $pdf->Cell(30, 7, ($t['amount'] < 0 ? '-$' : '$') . number_format(abs($t['amount']), 2), 1, 1, 'R');
+        }
+
+        $tuitionSubtotal = 0.0;
+        foreach ($studentCharges as $sc) {
+            $tuitionSubtotal += (float) ($sc['unit_fee'] ?? 0.0);
+        }
+        $eventSubtotal = 0.0;
+        foreach ($events as $ev) {
+            $eventSubtotal += (float) ($ev['charged'] ?? 0.0);
+        }
+
+        $totalAmount = round($tuitionSubtotal + $eventSubtotal + $additionalChargesTotal, 2);
+        $balance = $totalAmount - $totalPaid - $totalDiscount - $refundsPaidTotal;
+        if ($balance < 0) {
+            $balance = 0.0;
+        }
+
+        $pdf->Ln(5);
+        $pdf->SetFont('Arial', 'B', 12);
+        $pdf->Cell(160, 7, 'Total Charges:', 0, 0, 'R');
+        $pdf->SetFont('Arial', '', 12);
+        $pdf->Cell(30, 7, '$' . number_format($totalAmount, 2), 0, 1, 'R');
+
+        $pdf->SetFont('Arial', 'B', 12);
+        $pdf->Cell(160, 7, 'Total Paid:', 0, 0, 'R');
+        $pdf->SetFont('Arial', '', 12);
+        $pdf->Cell(30, 7, '$' . number_format($totalPaid, 2), 0, 1, 'R');
+
+        if ($totalDiscount > 0) {
+            $pdf->SetFont('Arial', 'B', 12);
+            $pdf->Cell(160, 7, 'Total Discount:', 0, 0, 'R');
+            $pdf->SetFont('Arial', '', 12);
+            $pdf->Cell(30, 7, '$' . number_format($totalDiscount, 2), 0, 1, 'R');
+        }
+
+        if ($refundsPaidTotal > 0) {
+            $pdf->SetFont('Arial', 'B', 12);
+            $pdf->Cell(160, 7, 'Refunds Paid:', 0, 0, 'R');
+            $pdf->SetFont('Arial', '', 12);
+            $pdf->Cell(30, 7, '$' . number_format($refundsPaidTotal, 2), 0, 1, 'R');
+        }
+
+        $pdf->SetFont('Arial', 'B', 12);
+        $pdf->Cell(160, 7, 'Balance Due:', 0, 0, 'R');
+        $pdf->SetFont('Arial', '', 12);
+        $pdf->Cell(30, 7, '$' . number_format($balance, 2), 0, 1, 'R');
+
+        return $pdf->Output('S');
+    }
+
+    private function renderErrorPdf(string $message): string
+    {
+        $pdf = new \FPDF();
+        $pdf->AddPage();
+        $pdf->SetFont('Arial', 'B', 16);
+        $pdf->Cell(0, 10, 'Error', 0, 1, 'C');
+        $pdf->SetFont('Arial', '', 12);
+        $pdf->Ln(10);
+        $pdf->MultiCell(0, 10, $message);
+
+        return $pdf->Output('S');
+    }
+}
diff --git a/app/Services/Invoices/InvoiceTuitionService.php b/app/Services/Invoices/InvoiceTuitionService.php
new file mode 100644
index 00000000..967c579e
--- /dev/null
+++ b/app/Services/Invoices/InvoiceTuitionService.php
@@ -0,0 +1,77 @@
+<?php
+
+namespace App\Services\Invoices;
+
+use App\Models\ClassSection;
+
+class InvoiceTuitionService
+{
+    public function __construct(
+        private InvoiceGradeService $grades,
+        private int $gradeFee,
+        private float $firstStudentFee,
+        private float $secondStudentFee,
+        private float $youthFee,
+        private string $timezone
+    ) {
+    }
+
+    public function calculateTuitionFee(array $registeredKids, array $withdrawnKids, ?string $refundDeadline): float
+    {
+        $refundOk = $this->isRefundAllowed($refundDeadline);
+        $tuitionStudents = $refundOk ? $registeredKids : array_merge($registeredKids, $withdrawnKids);
+
+        return $this->calculateTotalTuitionFee($tuitionStudents);
+    }
+
+    public function calculateTotalTuitionFee(array $students): float
+    {
+        foreach ($students as &$student) {
+            $gradeName = ClassSection::getClassSectionNameBySectionId($student['class_section_id'] ?? null) ?? '';
+            $student['grade'] = strtoupper(trim($gradeName));
+        }
+        unset($student);
+
+        $regularCount = 0;
+        $youthCount = 0;
+
+        foreach ($students as $student) {
+            $levelInfo = $this->grades->getGradeLevel($student['grade'] ?? '');
+            $level = (int) ($levelInfo['level'] ?? 999);
+
+            if ($level > $this->gradeFee) {
+                $youthCount++;
+            } else {
+                $regularCount++;
+            }
+        }
+
+        $total = 0.0;
+        $total += $youthCount * $this->youthFee;
+
+        if ($regularCount >= 2) {
+            $total += $this->firstStudentFee;
+            $total += ($regularCount - 1) * $this->secondStudentFee;
+        } elseif ($regularCount === 1) {
+            $total += $this->firstStudentFee;
+        }
+
+        return $total;
+    }
+
+    private function isRefundAllowed(?string $refundDeadline): bool
+    {
+        if (!$refundDeadline) {
+            return true;
+        }
+
+        try {
+            $tz = new \DateTimeZone($this->timezone);
+            $today = new \DateTimeImmutable('today', $tz);
+            $deadline = new \DateTimeImmutable($refundDeadline, $tz);
+            return $today <= $deadline;
+        } catch (\Throwable $e) {
+            return true;
+        }
+    }
+}
diff --git a/app/Services/Payments/PaymentBalanceService.php b/app/Services/Payments/PaymentBalanceService.php
new file mode 100644
index 00000000..2dfcfc50
--- /dev/null
+++ b/app/Services/Payments/PaymentBalanceService.php
@@ -0,0 +1,13 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\Payment;
+
+class PaymentBalanceService
+{
+    public function updateBalance(int $paymentId, float $amountPaid): bool
+    {
+        return Payment::updateBalance($paymentId, $amountPaid);
+    }
+}
diff --git a/app/Services/Payments/PaymentEnrollmentEventService.php b/app/Services/Payments/PaymentEnrollmentEventService.php
new file mode 100644
index 00000000..fd2728ba
--- /dev/null
+++ b/app/Services/Payments/PaymentEnrollmentEventService.php
@@ -0,0 +1,131 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\Configuration;
+use Illuminate\Support\Facades\DB;
+
+class PaymentEnrollmentEventService
+{
+    public function buildEventData(
+        int $parentId,
+        array $studentIds,
+        ?string $schoolYear = null,
+        ?string $semester = null,
+        ?string $portalLink = null
+    ): array {
+        $schoolYear = $schoolYear ?: Configuration::getConfig('school_year');
+        $semester = $semester ?: Configuration::getConfig('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 = DB::table('students')
+                ->where('parent_id', $parentId)
+                ->pluck('id')
+                ->map(fn ($id) => (int) $id)
+                ->all();
+        }
+
+        if (empty($ids)) {
+            $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, []];
+        }
+
+        $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) {
+                $join->on('sc.student_id', '=', 's.id')
+                    ->where('sc.school_year', '=', $schoolYear);
+            })
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'sc.class_section_id')
+            ->leftJoin('teacher_class as tc', function ($join) use ($schoolYear) {
+                $join->on('tc.class_section_id', '=', 'sc.class_section_id')
+                    ->where('tc.position', '=', 'main')
+                    ->where('tc.school_year', '=', $schoolYear);
+            })
+            ->leftJoin('users as tu', 'tu.id', '=', 'tc.teacher_id')
+            ->where('s.parent_id', $parentId)
+            ->whereIn('s.id', $ids)
+            ->orderByDesc('sc.updated_at')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        if (empty($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')
+                ->where('s.parent_id', $parentId)
+                ->whereIn('s.id', $ids)
+                ->get()
+                ->map(fn ($row) => (array) $row)
+                ->all();
+        }
+
+        $students = [];
+        $seen = [];
+        foreach ($rows as $row) {
+            $sid = (int) ($row['student_id'] ?? 0);
+            if ($sid <= 0 || isset($seen[$sid])) {
+                continue;
+            }
+            $seen[$sid] = true;
+
+            $teacherFull = trim(trim((string) ($row['t_firstname'] ?? '')) . ' ' . trim((string) ($row['t_lastname'] ?? '')));
+            $teacherFull = $teacherFull !== '' ? $teacherFull : null;
+
+            $students[] = [
+                'id' => $sid,
+                'student_id' => $sid,
+                'firstname' => (string) ($row['s_firstname'] ?? ''),
+                'lastname' => (string) ($row['s_lastname'] ?? ''),
+                'name' => trim(((string) ($row['s_firstname'] ?? '')) . ' ' . ((string) ($row['s_lastname'] ?? ''))),
+                'registration_grade' => (string) ($row['registration_grade'] ?? ''),
+                'class_section_id' => isset($row['class_section_id']) ? (int) $row['class_section_id'] : null,
+                'class_section_name' => $row['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, $students];
+    }
+}
diff --git a/app/Services/Payments/PaymentEventChargesService.php b/app/Services/Payments/PaymentEventChargesService.php
new file mode 100644
index 00000000..5c0ccecf
--- /dev/null
+++ b/app/Services/Payments/PaymentEventChargesService.php
@@ -0,0 +1,98 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\Configuration;
+use App\Models\Enrollment;
+use App\Models\StudentClass;
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+
+class PaymentEventChargesService
+{
+    public function listCharges(?string $schoolYear, ?string $semester): array
+    {
+        $schoolYear = $schoolYear ?: Configuration::getConfig('school_year');
+        $semester = $semester ?: Configuration::getConfig('semester');
+
+        $charges = DB::table('event_charges')
+            ->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)
+            ->orderByDesc('event_charges.created_at')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        return [
+            'charges' => $charges,
+            'parents' => User::getParents(),
+            'school_year' => $schoolYear,
+            'semester' => $semester,
+        ];
+    }
+
+    public function addCharges(array $payload, int $userId): int
+    {
+        $studentIds = $payload['student_ids'] ?? [];
+        $parentId = (int) $payload['parent_id'];
+
+        $commonData = [
+            'parent_id' => $parentId,
+            'event_name' => $payload['event_name'],
+            'description' => $payload['description'] ?? null,
+            'amount' => (float) $payload['amount'],
+            'semester' => $payload['semester'],
+            'school_year' => $payload['school_year'],
+            'charged' => 0,
+            'updated_by' => $userId,
+            'created_at' => now(),
+            'updated_at' => now(),
+        ];
+
+        $count = 0;
+
+        if (!empty($studentIds)) {
+            foreach ($studentIds as $studentId) {
+                DB::table('event_charges')->insert(array_merge($commonData, [
+                    'student_id' => (int) $studentId,
+                ]));
+                $count++;
+            }
+        } elseif (!empty($payload['student_id'])) {
+            DB::table('event_charges')->insert(array_merge($commonData, [
+                'student_id' => (int) $payload['student_id'],
+            ]));
+            $count++;
+        }
+
+        return $count;
+    }
+
+    public function getEnrolledStudents(int $parentId, ?string $schoolYear): array
+    {
+        $schoolYear = $schoolYear ?: Configuration::getConfig('school_year');
+
+        $enrollments = Enrollment::getEnrolledStudents($parentId, $schoolYear);
+
+        $students = [];
+        foreach ($enrollments as $row) {
+            $students[] = [
+                'id' => (int) ($row->id ?? 0),
+                'firstname' => (string) ($row->firstname ?? ''),
+                'lastname' => (string) ($row->lastname ?? ''),
+                'grade' => StudentClass::getStudentGrade((int) ($row->id ?? 0)) ?: 'N/A',
+            ];
+        }
+
+        return $students;
+    }
+}
diff --git a/app/Services/Payments/PaymentLookupService.php b/app/Services/Payments/PaymentLookupService.php
new file mode 100644
index 00000000..c8afc495
--- /dev/null
+++ b/app/Services/Payments/PaymentLookupService.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\Payment;
+
+class PaymentLookupService
+{
+    public function getByParent(int $parentId, ?string $schoolYear = null): array
+    {
+        $query = Payment::query()->where('parent_id', $parentId);
+
+        if ($schoolYear) {
+            $query->where('school_year', $schoolYear);
+        }
+
+        return $query->orderByDesc('payment_date')->get()->toArray();
+    }
+}
diff --git a/app/Services/Payments/PaymentManualService.php b/app/Services/Payments/PaymentManualService.php
new file mode 100644
index 00000000..d56936af
--- /dev/null
+++ b/app/Services/Payments/PaymentManualService.php
@@ -0,0 +1,649 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\Configuration;
+use App\Models\Invoice;
+use App\Models\Payment;
+use App\Models\Student;
+use App\Services\Discounts\DiscountInvoiceService;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Schema;
+
+class PaymentManualService
+{
+    public function __construct(
+        private DiscountInvoiceService $invoiceService,
+        private PaymentEnrollmentEventService $enrollmentEventService
+    ) {
+    }
+
+    public function search(string $searchTerm, ?string $schoolYear = null): array
+    {
+        $searchTerm = trim($searchTerm);
+        $schoolYear = $schoolYear ?: Configuration::getConfig('school_year');
+        $installmentDateRaw = (string) (Configuration::getConfig('installment_date') ?? '');
+
+        $installmentEndYmd = '';
+        if ($installmentDateRaw !== '') {
+            $ts = strtotime($installmentDateRaw);
+            if ($ts !== false) {
+                $installmentEndYmd = date('Y-m-d', $ts);
+            }
+        }
+
+        $parentData = null;
+        $students = [];
+        $payments = [];
+        $invoices = [];
+        $pagination = null;
+
+        if ($searchTerm !== '') {
+            $searchClean = preg_replace('/\D/', '', $searchTerm);
+            $searchFormatted = $this->formatPhone($searchClean);
+
+            $builder = DB::table('users')->select('*');
+            $builder->where(function ($q) use ($searchTerm, $searchClean, $searchFormatted) {
+                $q->where('email', $searchTerm);
+
+                if (!empty($searchClean)) {
+                    if (strlen($searchClean) === 10) {
+                        $formattedPhone = substr($searchClean, 0, 3) . '-' . substr($searchClean, 3, 3) . '-' . substr($searchClean, 6, 4);
+                        $q->orWhere('cellphone', $formattedPhone);
+                    }
+
+                    $q->orWhereRaw(
+                        "REPLACE(REPLACE(REPLACE(REPLACE(cellphone, '(', ''), ')', ''), '-', ''), ' ', '') = ?",
+                        [$searchClean]
+                    );
+                }
+
+                if (!empty($searchFormatted)) {
+                    $q->orWhere('cellphone', $searchFormatted);
+                }
+            });
+
+            $parent = (array) $builder->first();
+            if (!empty($parent)) {
+                unset($parent['password']);
+                $parentData = $parent;
+                $parentId = (int) ($parent['id'] ?? 0);
+
+                if ($parentId > 0) {
+                    $students = Student::query()->where('parent_id', $parentId)->get()->toArray();
+
+                    $paymentPaginator = Payment::query()
+                        ->where('parent_id', $parentId)
+                        ->orderByDesc('payment_date')
+                        ->paginate(10);
+
+                    $payments = $paymentPaginator->items();
+                    $pagination = [
+                        'current_page' => $paymentPaginator->currentPage(),
+                        'per_page' => $paymentPaginator->perPage(),
+                        'total' => $paymentPaginator->total(),
+                        'last_page' => $paymentPaginator->lastPage(),
+                    ];
+
+                    $rawInvoices = Invoice::query()
+                        ->where('parent_id', $parentId)
+                        ->when($schoolYear, fn ($q) => $q->where('school_year', $schoolYear))
+                        ->orderByDesc('issue_date')
+                        ->get()
+                        ->toArray();
+
+                    $invoices = $this->normalizeInvoices($rawInvoices, $installmentEndYmd);
+                }
+            }
+        }
+
+        return [
+            'parent' => $parentData,
+            'students' => $students,
+            'payments' => $payments,
+            'invoices' => $invoices,
+            'pagination' => $pagination,
+            'search_term' => $searchTerm,
+            'today' => function_exists('utc_now') ? utc_now() : now()->toDateTimeString(),
+            'installment_end_ymd' => $installmentEndYmd,
+        ];
+    }
+
+    public function suggest(string $query): array
+    {
+        $q = trim($query);
+        if ($q === '') {
+            return [];
+        }
+
+        $digits = preg_replace('/\D/', '', $q);
+
+        $sql = "SELECT id, firstname, lastname, email, cellphone
+                FROM users
+                WHERE (
+                    CONCAT_WS(' ', firstname, lastname) LIKE ?
+                    OR email LIKE ?
+                    OR cellphone LIKE ?";
+
+        $params = ['%' . $q . '%', '%' . $q . '%', '%' . $q . '%'];
+
+        if ($digits !== '') {
+            $sql .= " OR REPLACE(REPLACE(REPLACE(REPLACE(cellphone, '(', ''), ')', ''), '-', ''), ' ', '') LIKE ?";
+            $params[] = '%' . $digits . '%';
+        }
+
+        $sql .= ") ORDER BY lastname, firstname LIMIT 20";
+
+        $rows = DB::select($sql, $params);
+
+        $items = [];
+        foreach ($rows as $row) {
+            $label = trim(($row->firstname ?? '') . ' ' . ($row->lastname ?? ''));
+            $email = trim((string) ($row->email ?? ''));
+            $phone = trim((string) ($row->cellphone ?? ''));
+            $sub = trim($email . ' ' . $phone);
+            $value = $email !== '' ? $email : ($phone !== '' ? $phone : $label);
+
+            $items[] = [
+                'id' => (int) ($row->id ?? 0),
+                'label' => $label,
+                'sub' => $sub,
+                'value' => $value,
+            ];
+        }
+
+        return $items;
+    }
+
+    public function recordPayment(
+        int $invoiceId,
+        float $amount,
+        string $paymentMethod,
+        ?string $paymentDate,
+        ?string $checkNumber,
+        ?string $paymentType,
+        ?UploadedFile $paymentFile,
+        ?string $schoolYear = null,
+        ?string $semester = null,
+        ?int $userId = null
+    ): array {
+        $paymentMethod = strtolower(trim($paymentMethod));
+        $allowedMethods = ['cash', 'check', 'card'];
+
+        if (!in_array($paymentMethod, $allowedMethods, true)) {
+            throw new \InvalidArgumentException('Invalid payment method.');
+        }
+
+        if ($paymentMethod === 'check' && ($checkNumber === null || $checkNumber === '')) {
+            throw new \InvalidArgumentException('Check number is required for check payments.');
+        }
+
+        if ($amount <= 0) {
+            throw new \InvalidArgumentException('Invalid amount.');
+        }
+
+        $invoice = Invoice::query()->find($invoiceId);
+        if (!$invoice) {
+            throw new \RuntimeException('Invoice not found.');
+        }
+
+        $schoolYear = $schoolYear ?: (string) ($invoice->school_year ?? Configuration::getConfig('school_year'));
+        $semester = $semester ?: (string) ($invoice->semester ?? Configuration::getConfig('semester'));
+
+        $initialPreBalance = $this->getCurrentInvoiceBalance($invoiceId, $schoolYear);
+
+        if ($paymentMethod === 'card' && round($amount, 2) !== round($initialPreBalance, 2)) {
+            throw new \InvalidArgumentException('Card payments must equal the full remaining balance.');
+        }
+
+        $checkFile = null;
+        if ($paymentFile) {
+            $checkFile = $this->storePaymentFile($paymentFile, $paymentMethod);
+        }
+
+        $paymentDate = $paymentDate ? date('Y-m-d H:i:s', strtotime($paymentDate)) : (function_exists('utc_now') ? utc_now() : now()->toDateTimeString());
+
+        DB::beginTransaction();
+
+        try {
+            $locked = DB::table('invoices')->where('id', $invoiceId)->lockForUpdate()->first();
+            if (!$locked) {
+                DB::rollBack();
+                throw new \RuntimeException('Invoice not found.');
+            }
+
+            $this->invoiceService->recalculateInvoice($invoiceId, $schoolYear);
+            $currentBalance = $this->getCurrentInvoiceBalance($invoiceId, $schoolYear);
+
+            if ($amount > $currentBalance + 0.00001) {
+                DB::rollBack();
+                throw new \InvalidArgumentException('Entered amount exceeds remaining balance.');
+            }
+
+            if ($paymentMethod === 'card' && round($amount, 2) !== round($currentBalance, 2)) {
+                DB::rollBack();
+                throw new \InvalidArgumentException('Card payments must equal the full remaining balance.');
+            }
+
+            $paidCount = $this->getSuccessfulPaymentCount($invoiceId);
+            $installmentSeq = $paidCount + 1;
+
+            $transactionId = 'INV-' . $invoiceId . '-' . str_replace('.', '', (string) microtime(true));
+
+            $ok = $this->processPayment(
+                $invoiceId,
+                $amount,
+                $paymentMethod,
+                $checkFile,
+                $transactionId,
+                $paymentDate,
+                $schoolYear,
+                $semester,
+                $checkNumber,
+                $installmentSeq,
+                $userId
+            );
+
+            if (!$ok) {
+                DB::rollBack();
+                throw new \RuntimeException('Failed to record payment.');
+            }
+
+            $this->invoiceService->recalculateInvoice($invoiceId, $schoolYear);
+
+            $postBalance = max(0.0, round($initialPreBalance - $amount, 2));
+
+            $enrollmentUpdated = $this->invoiceService->updateEnrollmentStatusIfPaid($invoiceId, $schoolYear);
+            if ($enrollmentUpdated > 0) {
+                $studentIds = Student::query()->where('parent_id', $invoice->parent_id)->pluck('id')->all();
+                [$eventDataEnroll, $studentDataEnroll] = $this->enrollmentEventService->buildEventData(
+                    (int) $invoice->parent_id,
+                    $studentIds,
+                    $schoolYear,
+                    $semester
+                );
+
+                $this->triggerEvent('studentEnrolled', [$eventDataEnroll, $studentDataEnroll]);
+            }
+
+            $invoiceDiscount = (float) (DB::table('discount_usages')
+                ->selectRaw('COALESCE(SUM(discount_amount),0) AS sum_disc')
+                ->where('invoice_id', $invoiceId)
+                ->value('sum_disc') ?? 0);
+
+            $parentYearDiscountTotal = (float) (DB::table('discount_usages')
+                ->selectRaw('COALESCE(SUM(discount_amount),0) AS sum_disc')
+                ->where('parent_id', $invoice->parent_id)
+                ->where('school_year', $schoolYear)
+                ->value('sum_disc') ?? 0);
+
+            DB::commit();
+
+            [$eventData, $studentData] = $this->invoiceService->buildPaymentEventData(
+                $invoiceId,
+                $transactionId,
+                $amount,
+                $paymentMethod,
+                $paymentDate,
+                $checkNumber,
+                $installmentSeq,
+                $initialPreBalance,
+                $postBalance,
+                $schoolYear,
+                $semester
+            );
+
+            $eventData['invoice_discount'] = $invoiceDiscount;
+            $eventData['parent_year_discount_total'] = $parentYearDiscountTotal;
+
+            $this->triggerEvent('paymentReceived', [$eventData, $studentData]);
+
+            return [
+                'transaction_id' => $transactionId,
+                'installment_seq' => $installmentSeq,
+                'pre_balance' => $initialPreBalance,
+                'post_balance' => $postBalance,
+            ];
+        } catch (\Throwable $e) {
+            DB::rollBack();
+            Log::error('[manualPayUpdate] ' . $e->getMessage());
+            throw $e;
+        }
+    }
+
+    public function editPayment(
+        int $paymentId,
+        float $paidAmount,
+        string $paymentMethod,
+        ?string $checkNumber,
+        ?UploadedFile $paymentFile,
+        ?int $userId = null
+    ): void {
+        $paymentMethod = strtolower(trim($paymentMethod));
+
+        if ($paidAmount <= 0) {
+            throw new \InvalidArgumentException('Invalid amount entered.');
+        }
+
+        $payment = Payment::query()->find($paymentId);
+        if (!$payment) {
+            throw new \RuntimeException('Original payment not found.');
+        }
+
+        $invoice = Invoice::query()->find((int) $payment->invoice_id);
+        if (!$invoice) {
+            throw new \RuntimeException('Linked invoice not found.');
+        }
+
+        $checkFile = $payment->check_file;
+        if ($paymentFile) {
+            $checkFile = $this->storePaymentFile($paymentFile, $paymentMethod);
+        }
+
+        $this->invoiceService->recalculateInvoice((int) $payment->invoice_id, (string) ($invoice->school_year ?? Configuration::getConfig('school_year')));
+
+        $currentBalance = $this->getCurrentInvoiceBalanceExcludingPayment((int) $payment->invoice_id, $paymentId);
+
+        if ($paidAmount > $currentBalance) {
+            throw new \InvalidArgumentException('Entered amount exceeds remaining balance.');
+        }
+
+        $updateData = [
+            'paid_amount' => $paidAmount,
+            'payment_method' => $paymentMethod,
+            'check_file' => $checkFile,
+            'updated_by' => $userId,
+            'check_number' => $paymentMethod === 'check' ? $checkNumber : null,
+        ];
+
+        Payment::query()->whereKey($paymentId)->update($updateData);
+
+        $this->invoiceService->recalculateInvoice((int) $payment->invoice_id, (string) ($invoice->school_year ?? Configuration::getConfig('school_year')));
+    }
+
+    public function serveCheckFile(string $filename, string $mode = 'download')
+    {
+        $filename = basename($filename);
+        $roots = [
+            storage_path('app/uploads/checks/' . $filename),
+            storage_path('app/uploads/cards/' . $filename),
+            storage_path('app/uploads/misc/' . $filename),
+            storage_path('app/uploads/' . $filename),
+        ];
+
+        $path = null;
+        foreach ($roots as $candidate) {
+            if (is_file($candidate)) {
+                $path = $candidate;
+                break;
+            }
+        }
+
+        if (!$path) {
+            abort(404, 'Payment file not found.');
+        }
+
+        if ($mode === 'inline') {
+            return response()->file($path, [
+                'Content-Type' => mime_content_type($path) ?: 'application/octet-stream',
+                'Content-Disposition' => 'inline; filename="' . $filename . '"',
+            ]);
+        }
+
+        return response()->download($path, $filename);
+    }
+
+    private function processPayment(
+        int $invoiceId,
+        float $amount,
+        string $paymentMethod,
+        ?string $checkFile,
+        string $transactionId,
+        string $paymentDate,
+        ?string $schoolYear,
+        ?string $semester,
+        ?string $checkNumber,
+        int $installmentSeq,
+        ?int $userId
+    ): bool {
+        $invoice = Invoice::query()->find($invoiceId);
+        if (!$invoice) {
+            return false;
+        }
+
+        $newPaid = (float) $invoice->paid_amount + $amount;
+        $newBalance = (float) $invoice->balance - $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' => $userId,
+        ];
+
+        if (!Invoice::query()->whereKey($invoiceId)->update($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' => $userId,
+            'school_year' => $schoolYear,
+            'semester' => $semester,
+        ];
+
+        return (bool) Payment::query()->create($paymentData);
+    }
+
+    private function getCurrentInvoiceBalance(int $invoiceId, string $schoolYear): float
+    {
+        return $this->invoiceService->getCurrentInvoiceBalance($invoiceId, $schoolYear);
+    }
+
+    private function getCurrentInvoiceBalanceExcludingPayment(int $invoiceId, int $excludePaymentId): float
+    {
+        $invoice = Invoice::query()->find($invoiceId);
+        if (!$invoice) {
+            return 0.0;
+        }
+
+        $paymentQuery = Payment::query()
+            ->selectRaw('COALESCE(SUM(paid_amount),0) AS total_paid')
+            ->where('invoice_id', $invoiceId)
+            ->where('id', '!=', $excludePaymentId);
+
+        if (Schema::hasColumn('payments', 'status')) {
+            $paymentQuery->where(function ($q) {
+                $q->whereNotIn('status', [
+                    'void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled',
+                ])->orWhereNull('status');
+            });
+        }
+
+        if (Schema::hasColumn('payments', 'is_void')) {
+            $paymentQuery->where(function ($q) {
+                $q->where('is_void', 0)->orWhereNull('is_void');
+            });
+        }
+
+        $row = (array) $paymentQuery->first();
+        $totalPaid = (float) ($row['total_paid'] ?? 0);
+
+        $totalDisc = (float) (DB::table('discount_usages')
+            ->selectRaw('COALESCE(SUM(discount_amount),0) AS total_disc')
+            ->where('invoice_id', $invoiceId)
+            ->value('total_disc') ?? 0);
+
+        $totalRefundPaid = (float) (DB::table('refunds')
+            ->selectRaw('COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid')
+            ->where('invoice_id', $invoiceId)
+            ->whereIn('status', ['Partial', 'Paid'])
+            ->value('total_refund_paid') ?? 0);
+
+        $total = (float) ($invoice->total_amount ?? 0);
+
+        return max(0.0, round($total - $totalPaid - $totalDisc - $totalRefundPaid, 2));
+    }
+
+    private function getSuccessfulPaymentCount(int $invoiceId): int
+    {
+        $exclude = ['void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled'];
+
+        return Payment::query()
+            ->where('invoice_id', $invoiceId)
+            ->where('paid_amount', '>', 0)
+            ->whereNotIn('status', $exclude)
+            ->count();
+    }
+
+    private function normalizeInvoices(array $rawInvoices, string $installmentEndYmd): array
+    {
+        if (empty($rawInvoices)) {
+            return [];
+        }
+
+        $invoiceIds = array_values(array_unique(array_map(static fn ($r) => (int) ($r['id'] ?? 0), $rawInvoices)));
+        $paidByInvoice = [];
+        $discountByInvoice = [];
+        $refundByInvoice = [];
+
+        if (!empty($invoiceIds)) {
+            $rows = Payment::query()
+                ->selectRaw('invoice_id, COALESCE(SUM(paid_amount),0) AS total_paid')
+                ->whereIn('invoice_id', $invoiceIds)
+                ->groupBy('invoice_id')
+                ->get()
+                ->map(fn ($row) => (array) $row)
+                ->all();
+
+            foreach ($rows as $row) {
+                $paidByInvoice[(int) ($row['invoice_id'] ?? 0)] = (float) ($row['total_paid'] ?? 0);
+            }
+
+            $discRows = DB::table('discount_usages')
+                ->selectRaw('invoice_id, COALESCE(SUM(discount_amount),0) AS total_disc')
+                ->whereIn('invoice_id', $invoiceIds)
+                ->groupBy('invoice_id')
+                ->get()
+                ->map(fn ($row) => (array) $row)
+                ->all();
+
+            foreach ($discRows as $row) {
+                $discountByInvoice[(int) ($row['invoice_id'] ?? 0)] = (float) ($row['total_disc'] ?? 0);
+            }
+
+            $refundRows = DB::table('refunds')
+                ->selectRaw('invoice_id, COALESCE(SUM(refund_paid_amount),0) AS total_refund_paid')
+                ->whereIn('invoice_id', $invoiceIds)
+                ->whereIn('status', ['Partial', 'Paid'])
+                ->groupBy('invoice_id')
+                ->get()
+                ->map(fn ($row) => (array) $row)
+                ->all();
+
+            foreach ($refundRows as $row) {
+                $refundByInvoice[(int) ($row['invoice_id'] ?? 0)] = (float) ($row['total_refund_paid'] ?? 0);
+            }
+        }
+
+        return 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 = $paidByInvoice[$iid] ?? null;
+            $inv['paid_amount'] = is_numeric($actualPaid) ? (float) $actualPaid : (float) ($inv['paid_amount'] ?? 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((string) $inv[$k]);
+                    if ($its !== false) {
+                        $issueYmd = date('Y-m-d', $its);
+                        break;
+                    }
+                }
+            }
+            $inv['issue_ymd'] = $issueYmd;
+
+            return $inv;
+        }, $rawInvoices);
+    }
+
+    private function formatPhone(string $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 storePaymentFile(UploadedFile $file, string $paymentMethod): string
+    {
+        $mime = $file->getMimeType();
+        $ext = strtolower($file->getClientOriginalExtension() ?: '');
+
+        $okTypes = ['image/jpeg', 'image/png', 'application/pdf'];
+        $okExts = ['jpg', 'jpeg', 'png', 'pdf'];
+
+        if (!in_array($mime, $okTypes, true) || !in_array($ext, $okExts, true)) {
+            throw new \InvalidArgumentException('Unsupported file type. Use JPG, PNG, or PDF.');
+        }
+
+        if ($file->getSize() > 5 * 1024 * 1024) {
+            throw new \InvalidArgumentException('File too large. Max 5MB.');
+        }
+
+        $fileName = $file->hashName();
+        $subdir = $paymentMethod === 'check' ? 'checks' : ($paymentMethod === 'card' ? 'cards' : 'misc');
+        $targetDir = storage_path('app/uploads/' . $subdir);
+
+        if (!is_dir($targetDir)) {
+            mkdir($targetDir, 0775, true);
+        }
+
+        $file->move($targetDir, $fileName);
+
+        return $fileName;
+    }
+
+    private function triggerEvent(string $name, array $payload): void
+    {
+        try {
+            if (class_exists(\CodeIgniter\Events\Events::class)) {
+                \CodeIgniter\Events\Events::trigger($name, ...$payload);
+            } elseif (function_exists('event')) {
+                event($name, $payload);
+            }
+        } catch (\Throwable $e) {
+            Log::warning($name . ' hook failed: ' . $e->getMessage());
+        }
+    }
+}
diff --git a/app/Services/Payments/PaymentNotificationDispatchService.php b/app/Services/Payments/PaymentNotificationDispatchService.php
new file mode 100644
index 00000000..a18d1a05
--- /dev/null
+++ b/app/Services/Payments/PaymentNotificationDispatchService.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\Notification;
+use App\Models\UserNotification;
+use App\Models\Configuration;
+
+class PaymentNotificationDispatchService
+{
+    public function notifyUser(int $userId, string $title, string $message, array $channels = ['in_app']): void
+    {
+        $schoolYear = Configuration::getConfig('school_year');
+        $semester = Configuration::getConfig('semester');
+
+        $notification = Notification::query()->create([
+            'title' => $title,
+            'message' => $message,
+            'target_group' => 'user',
+            'delivery_channels' => $channels,
+            'priority' => 'normal',
+            'status' => 'sent',
+            'scheduled_at' => now(),
+            'sent_at' => now(),
+            'school_year' => $schoolYear,
+            'semester' => $semester,
+        ]);
+
+        UserNotification::query()->create([
+            'notification_id' => (int) $notification->id,
+            'user_id' => $userId,
+            'is_read' => 0,
+            'delivered' => 1,
+            'delivered_at' => now(),
+            'school_year' => $schoolYear,
+            'semester' => $semester,
+        ]);
+    }
+}
diff --git a/app/Services/Payments/PaymentNotificationService.php b/app/Services/Payments/PaymentNotificationService.php
new file mode 100644
index 00000000..c9ad0fb7
--- /dev/null
+++ b/app/Services/Payments/PaymentNotificationService.php
@@ -0,0 +1,396 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\Configuration;
+use App\Models\PaymentNotificationLog;
+use App\Models\User;
+use App\Services\EmailService;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+
+class PaymentNotificationService
+{
+    public function __construct(
+        private EmailService $emailService,
+        private PaymentNotificationDispatchService $dispatchService
+    ) {
+    }
+
+    public function listLogs(?string $from, ?string $to, ?string $type): array
+    {
+        $query = PaymentNotificationLog::query()->with('parent')->orderByDesc('sent_at');
+
+        if (!empty($from)) {
+            $query->where('sent_at', '>=', $from);
+        }
+        if (!empty($to)) {
+            $query->where('sent_at', '<=', $to);
+        }
+        if (!empty($type)) {
+            $query->where('type', $type);
+        }
+
+        return $query->get()->all();
+    }
+
+    public function send(array $payload): array
+    {
+        $parentId = (int) ($payload['parent_id'] ?? 0);
+        $typeInput = (string) ($payload['type'] ?? '');
+        $force = (bool) ($payload['force'] ?? false);
+        $schoolYear = (string) ($payload['school_year'] ?? (Configuration::getConfig('school_year') ?? date('Y')));
+
+        $tzName = $this->getTimezone();
+        $tz = new \DateTimeZone($tzName);
+        $now = new \DateTime('now', $tz);
+        $year = (int) $now->format('Y');
+        $month = (int) $now->format('n');
+
+        $results = [
+            'sent' => 0,
+            'skipped' => 0,
+            'failed' => 0,
+            'details' => [],
+        ];
+
+        if ($parentId > 0) {
+            $result = $this->sendToParent($parentId, $typeInput, $schoolYear, $year, $month, $now, $force, false);
+            $results = $this->mergeResults($results, $result);
+        } else {
+            $parentIds = $this->getParentsWithInvoices($schoolYear);
+            foreach ($parentIds as $pid) {
+                $result = $this->sendToParent($pid, $typeInput, $schoolYear, $year, $month, $now, $force, true);
+                $results = $this->mergeResults($results, $result);
+            }
+        }
+
+        return $results;
+    }
+
+    private function sendToParent(
+        int $parentId,
+        string $typeInput,
+        string $schoolYear,
+        int $year,
+        int $month,
+        \DateTime $now,
+        bool $force,
+        bool $notifyHeads
+    ): array {
+        $results = ['sent' => 0, 'skipped' => 0, 'failed' => 0, 'details' => []];
+
+        [$balance, $latestInv] = $this->computeBalance($parentId, $schoolYear);
+
+        $type = $this->resolveType($parentId, $schoolYear, $typeInput);
+
+        if (!$force && PaymentNotificationLog::existsForPeriod($parentId, $year, $month, $type)) {
+            $results['skipped']++;
+            $results['details'][] = ['parent_id' => $parentId, 'result' => 'already_sent'];
+            return $results;
+        }
+
+        if ($balance <= 0 && !$force) {
+            $results['skipped']++;
+            $results['details'][] = ['parent_id' => $parentId, 'result' => 'no_balance'];
+            return $results;
+        }
+
+        [$subject, $body] = $this->composeMessage($parentId, $balance, $schoolYear, $now);
+        $installmentInfo = $this->computeInstallmentSuggestion($balance);
+
+        $toEmail = $this->getUserEmail($parentId);
+        $ccEmail = $this->getSecondaryGuardianEmail($parentId);
+
+        $ok = $toEmail ? $this->emailService->send($toEmail, $subject, $body, 'finance') : false;
+        if ($ok && $ccEmail && strcasecmp($ccEmail, (string) $toEmail) !== 0) {
+            $this->emailService->send($ccEmail, $subject, $body, 'finance');
+        }
+
+        PaymentNotificationLog::query()->create([
+            'parent_id' => $parentId,
+            'invoice_id' => $latestInv,
+            'school_year' => $schoolYear,
+            'period_year' => $year,
+            'period_month' => $month,
+            'type' => $type,
+            'to_email' => $toEmail,
+            'cc_email' => $ccEmail,
+            'head_fa_notified' => $notifyHeads ? 1 : 0,
+            'subject' => $subject,
+            'body' => $body,
+            'status' => $ok ? 'sent' : 'failed',
+            'error_message' => $ok ? null : 'Missing/invalid email or send failed',
+            'balance_snapshot' => $balance,
+            'sent_at' => $now->format('Y-m-d H:i:s'),
+        ]);
+
+        if ($ok) {
+            $results['sent']++;
+            $results['details'][] = [
+                'parent_id' => $parentId,
+                'result' => 'sent',
+                'balance' => $balance,
+                'installment_due' => $installmentInfo['installment_due'],
+                'remaining' => $installmentInfo['remaining_installments'],
+            ];
+        } else {
+            $results['failed']++;
+            $results['details'][] = ['parent_id' => $parentId, 'result' => 'failed'];
+        }
+
+        if ($notifyHeads) {
+            $this->notifyHeadsOfFinance($type, $parentId, $balance);
+        }
+
+        return $results;
+    }
+
+    private function computeBalance(int $parentId, string $schoolYear): array
+    {
+        $rows = DB::table('invoices')
+            ->select('id', 'total_amount')
+            ->where('parent_id', $parentId)
+            ->where('school_year', $schoolYear)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $hasStatus = DB::getSchemaBuilder()->hasColumn('payments', 'status');
+        $hasVoid = DB::getSchemaBuilder()->hasColumn('payments', 'is_void');
+
+        $sumBalance = 0.0;
+        $latestId = null;
+
+        foreach ($rows as $row) {
+            $invoiceId = (int) ($row['id'] ?? 0);
+            if ($invoiceId <= 0) {
+                continue;
+            }
+            if ($latestId === null) {
+                $latestId = $invoiceId;
+            }
+
+            $total = (float) ($row['total_amount'] ?? 0);
+
+            $qb = DB::table('payments')
+                ->selectRaw('COALESCE(SUM(paid_amount),0) AS total')
+                ->where('invoice_id', $invoiceId);
+
+            if ($hasStatus) {
+                $qb->where(function ($q) {
+                    $q->whereNotIn('status', [
+                        'void', 'voided', 'refunded', 'failed', 'chargeback', 'declined', 'reversed', 'canceled', 'cancelled',
+                    ])->orWhereNull('status');
+                });
+            }
+
+            if ($hasVoid) {
+                $qb->where(function ($q) {
+                    $q->where('is_void', 0)->orWhereNull('is_void');
+                });
+            }
+
+            $paid = (float) (optional($qb->first())->total ?? 0);
+
+            $disc = (float) (optional(DB::table('discount_usages')
+                ->selectRaw('COALESCE(SUM(discount_amount),0) AS total')
+                ->where('invoice_id', $invoiceId)
+                ->first())->total ?? 0);
+
+            $rfnd = (float) (optional(DB::table('refunds')
+                ->selectRaw('COALESCE(SUM(refund_paid_amount),0) AS total')
+                ->where('invoice_id', $invoiceId)
+                ->whereIn('status', ['Partial', 'Paid'])
+                ->first())->total ?? 0);
+
+            $sumBalance += max(0.0, round($total - $disc - $paid - $rfnd, 2));
+        }
+
+        return [$sumBalance, $latestId];
+    }
+
+    private function resolveType(int $parentId, string $schoolYear, string $typeInput): string
+    {
+        if (in_array($typeInput, ['no_payment', 'installment'], true)) {
+            return $typeInput;
+        }
+
+        $hasPayments = DB::table('payments')
+            ->where('parent_id', $parentId)
+            ->where('school_year', $schoolYear)
+            ->count() > 0;
+
+        return $hasPayments ? 'installment' : 'no_payment';
+    }
+
+    private function composeMessage(int $parentId, float $balance, string $schoolYear, \DateTime $now): array
+    {
+        $user = User::query()->find($parentId);
+        $parentName = $user ? trim(($user->firstname ?? '') . ' ' . ($user->lastname ?? '')) : '';
+        $greeting = $parentName !== '' ? "Dear {$parentName}," : 'Dear Parent,';
+
+        $monthYear = $now->format('F Y');
+        $subject = sprintf('Monthly Tuition Reminder — %s', $schoolYear);
+        $balanceFmt = '$' . number_format($balance, 2);
+        $intro = 'This is your monthly installment reminder for ' . $schoolYear . '.';
+
+        $installmentInfo = $this->computeInstallmentSuggestion($balance);
+
+        $bodyHtml = <<<HTML
+            <div style="font-family:Arial,Helvetica,sans-serif; font-size:14px; color:#212529; line-height:1.5;">
+              <h2 style="margin:0 0 10px; font-size:18px;">Monthly Tuition Reminder</h2>
+              <p>{$greeting}</p>
+              <p>{$intro}</p>
+              <p><strong>Current Outstanding Balance:</strong> {$balanceFmt}</p>
+              <ul>
+                <li><strong>Remaining installments:</strong> {$installmentInfo['remaining_installments']}</li>
+                <li><strong>Suggested installment this month:</strong> {$installmentInfo['installment_due_fmt']}</li>
+                <li><strong>Maximum installments available:</strong> {$installmentInfo['max_installments']}</li>
+              </ul>
+              <p>As a friendly reminder, our tuition installments are due at the beginning of each month.</p>
+              <p>You can review your invoice and payment options by logging in to your parent portal.</p>
+              <p>Thank you for your prompt attention.</p>
+              <p><em>Reminder Period:</em> {$monthYear}</p>
+            </div>
+        HTML;
+
+        if (view()->exists('emails._wrap_layout')) {
+            $body = view('emails._wrap_layout', [
+                'title' => 'Monthly Tuition Reminder',
+                'body_html' => $bodyHtml,
+            ], ['saveData' => true]);
+        } else {
+            $body = $bodyHtml;
+        }
+
+        return [$subject, $body];
+    }
+
+    private function computeInstallmentSuggestion(float $balance): array
+    {
+        $installmentEndRaw = (string) (Configuration::getConfig('installment_date') ?? '');
+        $tzName = $this->getTimezone();
+        $tz = new \DateTimeZone($tzName);
+        $today = new \DateTimeImmutable('today', $tz);
+
+        $end = null;
+        if ($installmentEndRaw !== '') {
+            try {
+                $end = new \DateTimeImmutable($installmentEndRaw, $tz);
+            } catch (\Throwable $e) {
+                $end = null;
+            }
+        }
+
+        $remMonths = 0;
+        if ($end) {
+            $y = (int) $end->format('Y') - (int) $today->format('Y');
+            $m = (int) $end->format('n') - (int) $today->format('n');
+            $remMonths = $y * 12 + $m;
+            if ((int) $end->format('j') > (int) $today->format('j')) {
+                $remMonths += 1;
+            }
+            if ($remMonths < 0) {
+                $remMonths = 0;
+            }
+        }
+
+        $remainingInstallments = max(1, $remMonths);
+        $maxInstallments = max($remMonths ?: 0, $balance > 0 ? 2 : 0);
+        $installmentDue = $remainingInstallments > 0 ? ($balance / $remainingInstallments) : 0;
+
+        return [
+            'remaining_installments' => $remainingInstallments,
+            'max_installments' => $maxInstallments,
+            'installment_due' => round($installmentDue, 2),
+            'installment_due_fmt' => '$' . number_format($installmentDue, 2),
+        ];
+    }
+
+    private function getSecondaryGuardianEmail(int $primaryUserId): ?string
+    {
+        $row = DB::table('family_guardians')->where('user_id', $primaryUserId)->first();
+        if (!$row || empty($row->family_id)) {
+            return null;
+        }
+
+        $others = DB::table('family_guardians')
+            ->where('family_id', (int) $row->family_id)
+            ->where('user_id', '!=', $primaryUserId)
+            ->where('receive_emails', 1)
+            ->get()
+            ->map(fn ($r) => (array) $r)
+            ->all();
+
+        foreach ($others as $g) {
+            $email = (string) (DB::table('users')->where('id', (int) ($g['user_id'] ?? 0))->value('email') ?? '');
+            if ($email !== '' && filter_var($email, FILTER_VALIDATE_EMAIL)) {
+                return $email;
+            }
+        }
+
+        return null;
+    }
+
+    private function getUserEmail(int $userId): ?string
+    {
+        $email = (string) (DB::table('users')->where('id', $userId)->value('email') ?? '');
+        if ($email === '' || !filter_var($email, FILTER_VALIDATE_EMAIL)) {
+            return null;
+        }
+        return $email;
+    }
+
+    private function notifyHeadsOfFinance(string $type, int $parentId, float $balance): void
+    {
+        try {
+            $heads = User::getUsersByRole('head of department (finance)');
+            if (empty($heads)) {
+                $heads = User::getUsersByRole('accountant');
+            }
+
+            foreach ($heads as $user) {
+                $this->dispatchService->notifyUser(
+                    (int) ($user['id'] ?? 0),
+                    'Payment Reminder Sent',
+                    sprintf('A %s reminder was sent to parent #%d (balance: $%0.2f).', $type, $parentId, $balance),
+                    ['in_app']
+                );
+            }
+        } catch (\Throwable $e) {
+            Log::warning('Unable to notify heads of finance: ' . $e->getMessage());
+        }
+    }
+
+    private function mergeResults(array $base, array $update): array
+    {
+        $base['sent'] += $update['sent'] ?? 0;
+        $base['skipped'] += $update['skipped'] ?? 0;
+        $base['failed'] += $update['failed'] ?? 0;
+        if (!empty($update['details'])) {
+            $base['details'] = array_merge($base['details'], $update['details']);
+        }
+        return $base;
+    }
+
+    private function getParentsWithInvoices(string $schoolYear): array
+    {
+        $rows = DB::table('invoices')
+            ->selectRaw('DISTINCT parent_id')
+            ->where('school_year', $schoolYear)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        return array_values(array_unique(array_map(static fn ($r) => (int) ($r['parent_id'] ?? 0), $rows)));
+    }
+
+    private function getTimezone(): string
+    {
+        if (function_exists('user_timezone')) {
+            return (string) user_timezone();
+        }
+        return (string) (config('app.timezone') ?: 'UTC');
+    }
+}
diff --git a/app/Services/Payments/PaymentPlanService.php b/app/Services/Payments/PaymentPlanService.php
new file mode 100644
index 00000000..2e769977
--- /dev/null
+++ b/app/Services/Payments/PaymentPlanService.php
@@ -0,0 +1,39 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\Configuration;
+use App\Models\Payment;
+use Illuminate\Support\Facades\Schema;
+
+class PaymentPlanService
+{
+    public function createPlan(array $payload): Payment
+    {
+        $schoolYear = $payload['school_year'] ?? Configuration::getConfig('school_year');
+        $semester = $payload['semester'] ?? Configuration::getConfig('semester');
+
+        $data = [
+            'parent_id' => (int) $payload['parent_id'],
+            'total_amount' => (float) $payload['total_amount'],
+            'number_of_installments' => (int) $payload['number_of_installments'],
+            'paid_amount' => 0,
+            'balance' => (float) $payload['total_amount'],
+            'payment_date' => $payload['payment_date'] ?? null,
+            'payment_method' => $payload['payment_method'] ?? null,
+            'status' => $payload['status'] ?? 'Pending',
+            'semester' => $semester,
+            'school_year' => $schoolYear,
+        ];
+
+        if (isset($payload['invoice_id']) && Schema::hasColumn('payments', 'invoice_id')) {
+            $data['invoice_id'] = (int) $payload['invoice_id'];
+        }
+
+        if (isset($payload['payment_type']) && Schema::hasColumn('payments', 'payment_type')) {
+            $data['payment_type'] = $payload['payment_type'];
+        }
+
+        return Payment::query()->create($data);
+    }
+}
diff --git a/app/Services/Payments/PaymentTransactionService.php b/app/Services/Payments/PaymentTransactionService.php
new file mode 100644
index 00000000..0c011e0e
--- /dev/null
+++ b/app/Services/Payments/PaymentTransactionService.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\PaymentTransaction;
+
+class PaymentTransactionService
+{
+    public function create(array $payload): PaymentTransaction
+    {
+        $data = [
+            'transaction_id' => $payload['transaction_id'],
+            'payment_id' => (int) $payload['payment_id'],
+            'transaction_date' => $payload['transaction_date'],
+            'amount' => (float) $payload['amount'],
+            'payment_method' => $payload['payment_method'],
+            'payment_status' => $payload['payment_status'] ?? 'Pending',
+            'transaction_fee' => $payload['transaction_fee'] ?? null,
+            'payment_reference' => $payload['payment_reference'] ?? null,
+            'is_full_payment' => !empty($payload['is_full_payment']),
+            'school_year' => $payload['school_year'] ?? null,
+            'semester' => $payload['semester'] ?? null,
+        ];
+
+        return PaymentTransaction::query()->create($data);
+    }
+
+    public function getByPayment(int $paymentId): array
+    {
+        return PaymentTransaction::getTransactionsByPaymentId($paymentId);
+    }
+
+    public function updateStatus(string $transactionId, string $status): bool
+    {
+        return PaymentTransaction::updateTransactionStatus($transactionId, $status);
+    }
+}
diff --git a/app/Services/Payments/PaypalPaymentService.php b/app/Services/Payments/PaypalPaymentService.php
new file mode 100644
index 00000000..0fdf387c
--- /dev/null
+++ b/app/Services/Payments/PaypalPaymentService.php
@@ -0,0 +1,123 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\Payment;
+use Illuminate\Support\Facades\Log;
+
+class PaypalPaymentService
+{
+    public function getRedirectUrl(): string
+    {
+        return (string) (config('services.paypal.payment_url')
+            ?: env('PAYPAL_PAYMENT_URL')
+            ?: 'https://www.paypal.com/ncp/payment/87FJL3EV8C7NE');
+    }
+
+    public function createPayment(int $paymentId): array
+    {
+        $payment = Payment::query()->find($paymentId);
+        if (!$payment) {
+            throw new \RuntimeException('Payment not found.');
+        }
+
+        if (!$this->sdkAvailable()) {
+            return [
+                'redirect_url' => $this->getRedirectUrl(),
+                'mode' => 'hosted',
+                'message' => 'PayPal SDK not installed; using hosted redirect URL.',
+            ];
+        }
+
+        try {
+            $apiContext = $this->buildApiContext();
+
+            $payer = new \PayPal\Api\Payer();
+            $payer->setPaymentMethod('paypal');
+
+            $amount = new \PayPal\Api\Amount();
+            $amount->setCurrency('USD')->setTotal($payment->balance ?? $payment->total_amount ?? 0);
+
+            $transaction = new \PayPal\Api\Transaction();
+            $transaction->setAmount($amount)
+                ->setDescription('Payment for school fees')
+                ->setInvoiceNumber(uniqid('inv_', true));
+
+            $paypalPayment = new \PayPal\Api\Payment();
+            $paypalPayment->setIntent('sale')
+                ->setPayer($payer)
+                ->setTransactions([$transaction]);
+
+            $redirectUrls = new \PayPal\Api\RedirectUrls();
+            $redirectUrls->setReturnUrl(url('/api/v1/finance/paypal/execute'))
+                ->setCancelUrl(url('/api/v1/finance/paypal/cancel'));
+
+            $paypalPayment->setRedirectUrls($redirectUrls);
+            $paypalPayment->create($apiContext);
+
+            session()->put('paypalPaymentId', $paypalPayment->getId());
+            session()->put('paymentId', $paymentId);
+
+            return [
+                'redirect_url' => $paypalPayment->getApprovalLink(),
+                'mode' => 'sdk',
+            ];
+        } catch (\Throwable $e) {
+            Log::error('PayPal create payment failed: ' . $e->getMessage());
+            throw new \RuntimeException('Unable to create PayPal payment.');
+        }
+    }
+
+    public function executePayment(string $payerId, ?string $paypalPaymentId = null): void
+    {
+        if (!$this->sdkAvailable()) {
+            throw new \RuntimeException('PayPal SDK not installed.');
+        }
+
+        $paymentId = $paypalPaymentId ?: (string) session()->get('paypalPaymentId');
+        if (!$paymentId) {
+            throw new \RuntimeException('Missing PayPal payment ID.');
+        }
+
+        $apiContext = $this->buildApiContext();
+        $payment = \PayPal\Api\Payment::get($paymentId, $apiContext);
+        $execution = new \PayPal\Api\PaymentExecution();
+        $execution->setPayerId($payerId);
+
+        $payment->execute($execution, $apiContext);
+
+        $internalPaymentId = (int) session()->get('paymentId');
+        if ($internalPaymentId) {
+            Payment::query()->whereKey($internalPaymentId)->update(['status' => 'Completed']);
+        }
+    }
+
+    public function cancelPayment(): void
+    {
+        // no-op (client handles redirect)
+    }
+
+    private function sdkAvailable(): bool
+    {
+        return class_exists(\PayPal\Rest\ApiContext::class)
+            && class_exists(\PayPal\Auth\OAuthTokenCredential::class);
+    }
+
+    private function buildApiContext(): \PayPal\Rest\ApiContext
+    {
+        $clientId = (string) (config('services.paypal.client_id') ?: env('PAYPAL_CLIENT_ID'));
+        $secret = (string) (config('services.paypal.secret') ?: env('PAYPAL_SECRET'));
+        $mode = (string) (config('services.paypal.mode') ?: env('PAYPAL_MODE') ?: 'sandbox');
+
+        $apiContext = new \PayPal\Rest\ApiContext(
+            new \PayPal\Auth\OAuthTokenCredential($clientId, $secret)
+        );
+
+        $apiContext->setConfig([
+            'mode' => $mode,
+            'http.headers' => ['Connection' => 'Close'],
+        ]);
+
+        return $apiContext;
+    }
+}
diff --git a/app/Services/Payments/PaypalTransactionsService.php b/app/Services/Payments/PaypalTransactionsService.php
new file mode 100644
index 00000000..096678a1
--- /dev/null
+++ b/app/Services/Payments/PaypalTransactionsService.php
@@ -0,0 +1,42 @@
+<?php
+
+namespace App\Services\Payments;
+
+use App\Models\PayPalPayment;
+
+class PaypalTransactionsService
+{
+    public function list(?string $keyword, int $perPage = 10)
+    {
+        $query = PayPalPayment::query()->orderByDesc('created_at');
+
+        if ($keyword) {
+            $query->where(function ($q) use ($keyword) {
+                $q->where('transaction_id', 'like', '%' . $keyword . '%')
+                    ->orWhere('payer_email', 'like', '%' . $keyword . '%')
+                    ->orWhere('event_type', 'like', '%' . $keyword . '%')
+                    ->orWhere('order_id', 'like', '%' . $keyword . '%')
+                    ->orWhere('parent_school_id', 'like', '%' . $keyword . '%');
+            });
+        }
+
+        return $query->paginate($perPage);
+    }
+
+    public function listAll(?string $keyword): array
+    {
+        $query = PayPalPayment::query()->orderByDesc('created_at');
+
+        if ($keyword) {
+            $query->where(function ($q) use ($keyword) {
+                $q->where('transaction_id', 'like', '%' . $keyword . '%')
+                    ->orWhere('payer_email', 'like', '%' . $keyword . '%')
+                    ->orWhere('event_type', 'like', '%' . $keyword . '%')
+                    ->orWhere('order_id', 'like', '%' . $keyword . '%')
+                    ->orWhere('parent_school_id', 'like', '%' . $keyword . '%');
+            });
+        }
+
+        return $query->get()->map(fn ($row) => (array) $row)->all();
+    }
+}
diff --git a/app/Services/PhoneFormatterService.php b/app/Services/PhoneFormatterService.php
new file mode 100644
index 00000000..fec9350b
--- /dev/null
+++ b/app/Services/PhoneFormatterService.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace App\Services;
+
+class PhoneFormatterService
+{
+    public function formatPhoneNumber(string $number): ?string
+    {
+        $digits = preg_replace('/\D/', '', $number);
+
+        if (strlen($digits) === 10) {
+            return sprintf(
+                '%s-%s-%s',
+                substr($digits, 0, 3),
+                substr($digits, 3, 3),
+                substr($digits, 6)
+            );
+        }
+
+        return null;
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementBatchAssignmentService.php b/app/Services/Reimbursements/ReimbursementBatchAssignmentService.php
new file mode 100644
index 00000000..a56d19fb
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementBatchAssignmentService.php
@@ -0,0 +1,121 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use App\Models\ReimbursementBatch;
+use App\Models\ReimbursementBatchItem;
+use Illuminate\Support\Facades\Log;
+use RuntimeException;
+
+class ReimbursementBatchAssignmentService
+{
+    public function __construct(private ReimbursementLookupService $lookupService)
+    {
+    }
+
+    public function updateAssignment(
+        int $expenseId,
+        int $batchId,
+        ?int $adminId,
+        ?int $reimbursementId,
+        string $schoolYear,
+        string $semester
+    ): array {
+        if ($expenseId <= 0) {
+            throw new RuntimeException('Invalid expense id.');
+        }
+
+        $now = now();
+
+        $activeItem = ReimbursementBatchItem::query()
+            ->where('expense_id', $expenseId)
+            ->whereNull('unassigned_at')
+            ->first();
+
+        if ($batchId <= 0) {
+            if ($activeItem) {
+                $activeItem->update(['unassigned_at' => $now]);
+                if (!$reimbursementId && !empty($activeItem->reimbursement_id)) {
+                    $reimbursementId = (int) $activeItem->reimbursement_id;
+                }
+            }
+
+            return [
+                'batch_id' => 0,
+                'admin_id' => null,
+                'reimbursement_id' => $reimbursementId,
+            ];
+        }
+
+        $batch = ReimbursementBatch::query()->find($batchId);
+        if (!$batch || strtolower((string) $batch->status) !== ReimbursementBatch::STATUS_OPEN) {
+            throw new RuntimeException('Batch not found or already closed.');
+        }
+
+        $currentAdmin = $activeItem ? (int) ($activeItem->admin_id ?? 0) : null;
+        $activeSameBatch = $activeItem && (int) ($activeItem->batch_id ?? 0) === $batchId;
+        if ($activeSameBatch && ($currentAdmin === ($adminId ?? 0))) {
+            return [
+                'batch_id' => $batchId,
+                'admin_id' => $adminId,
+                'reimbursement_id' => $activeItem->reimbursement_id ?? null,
+            ];
+        }
+
+        if ($activeSameBatch) {
+            if (!$reimbursementId) {
+                $reimbursementId = $activeItem->reimbursement_id
+                    ? (int) $activeItem->reimbursement_id
+                    : $this->lookupService->findReimbursementIdForExpense($expenseId);
+            }
+
+            $activeItem->update([
+                'admin_id' => $adminId,
+                'assigned_at' => $now,
+                'reimbursement_id' => $reimbursementId,
+                'unassigned_at' => $adminId === null ? $now : null,
+            ]);
+
+            return [
+                'batch_id' => $batchId,
+                'admin_id' => $adminId,
+                'reimbursement_id' => $reimbursementId,
+            ];
+        }
+
+        if ($activeItem) {
+            $activeItem->update(['unassigned_at' => $now]);
+            if (!$reimbursementId && !empty($activeItem->reimbursement_id)) {
+                $reimbursementId = (int) $activeItem->reimbursement_id;
+            }
+        }
+
+        if (!$reimbursementId) {
+            $reimbursementId = $this->lookupService->findReimbursementIdForExpense($expenseId);
+        }
+
+        try {
+            ReimbursementBatchItem::query()->create([
+                'batch_id' => $batchId,
+                'expense_id' => $expenseId,
+                'reimbursement_id' => $reimbursementId,
+                'admin_id' => $adminId,
+                'assigned_at' => $now,
+                'school_year' => $schoolYear,
+                'semester' => $semester,
+            ]);
+        } catch (\Throwable $e) {
+            Log::error('Failed to assign expense to batch: ' . $e->getMessage(), [
+                'expense_id' => $expenseId,
+                'batch_id' => $batchId,
+            ]);
+            throw new RuntimeException('Unable to update batch assignment right now.');
+        }
+
+        return [
+            'batch_id' => $batchId,
+            'admin_id' => $adminId,
+            'reimbursement_id' => $reimbursementId,
+        ];
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementBatchService.php b/app/Services/Reimbursements/ReimbursementBatchService.php
new file mode 100644
index 00000000..698db538
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementBatchService.php
@@ -0,0 +1,154 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use App\Models\Expense;
+use App\Models\Reimbursement;
+use App\Models\ReimbursementBatch;
+use App\Models\ReimbursementBatchAdminFile;
+use App\Models\ReimbursementBatchItem;
+use Illuminate\Support\Facades\DB;
+use RuntimeException;
+
+class ReimbursementBatchService
+{
+    public function __construct(private ReimbursementLookupService $lookupService)
+    {
+    }
+
+    public function createBatch(?string $title, int $userId, string $schoolYear, string $semester): array
+    {
+        $sequence = $this->nextYearlyBatchNumber($schoolYear);
+        $now = now();
+
+        $batch = ReimbursementBatch::query()->create([
+            'title' => $title !== null && trim($title) !== '' ? trim($title) : null,
+            'status' => ReimbursementBatch::STATUS_OPEN,
+            'created_by' => $userId ?: null,
+            'opened_at' => $now,
+            'school_year' => $schoolYear,
+            'semester' => $semester,
+            'yearly_batch_number' => $sequence,
+        ]);
+
+        $label = trim((string) $batch->title) !== '' ? (string) $batch->title : ('Batch #' . $sequence);
+        if (trim((string) $batch->title) === '') {
+            $batch->title = $label;
+            $batch->save();
+        }
+
+        return [
+            'batch_id' => (int) $batch->id,
+            'label' => $label,
+            'sequence' => $sequence,
+        ];
+    }
+
+    public function lockBatch(int $batchId, int $userId, string $schoolYear, string $semester): void
+    {
+        $batch = ReimbursementBatch::query()->find($batchId);
+        if (!$batch || strtolower((string) $batch->status) !== ReimbursementBatch::STATUS_OPEN) {
+            throw new RuntimeException('Batch not found or already closed.');
+        }
+
+        $adminRows = ReimbursementBatchItem::query()
+            ->selectRaw('DISTINCT COALESCE(admin_id, 0) AS admin_id')
+            ->where('batch_id', $batchId)
+            ->whereNull('unassigned_at')
+            ->get();
+
+        $adminIds = array_values(array_unique($adminRows->pluck('admin_id')->map(fn ($id) => (int) $id)->all()));
+        $requiredAdmins = array_values(array_filter($adminIds, static fn ($adminId) => $adminId > 0));
+
+        if (!empty($requiredAdmins)) {
+            $uploadedAdminIds = ReimbursementBatchAdminFile::query()
+                ->where('batch_id', $batchId)
+                ->whereIn('admin_id', $requiredAdmins)
+                ->pluck('admin_id')
+                ->map(fn ($id) => (int) $id)
+                ->unique()
+                ->values()
+                ->all();
+
+            foreach ($requiredAdmins as $adminId) {
+                if (!in_array($adminId, $uploadedAdminIds, true)) {
+                    throw new RuntimeException('All admin sections must have a check file before submitting the batch.');
+                }
+            }
+        }
+
+        DB::transaction(function () use ($batchId, $userId, $schoolYear, $semester) {
+            $items = DB::table('reimbursement_batch_items as bi')
+                ->selectRaw('bi.id as batch_item_id, bi.reimbursement_id as batch_reimb_id, bi.expense_id, e.amount, e.purchased_by, e.description, e.reimbursement_id as expense_reimb_id, e.school_year as expense_school_year, e.semester as expense_semester')
+                ->join('expenses as e', 'e.id', '=', 'bi.expense_id')
+                ->where('bi.batch_id', $batchId)
+                ->whereNull('bi.unassigned_at')
+                ->get();
+
+            foreach ($items as $item) {
+                $expenseId = (int) ($item->expense_id ?? 0);
+                $recipientId = (int) ($item->purchased_by ?? 0);
+                if ($expenseId <= 0 || $recipientId <= 0) {
+                    continue;
+                }
+
+                $reimbId = $item->batch_reimb_id ?: ($item->expense_reimb_id ?: $this->lookupService->findReimbursementIdForExpense($expenseId));
+
+                if (!$reimbId) {
+                    $payload = [
+                        'expense_id' => $expenseId,
+                        'amount' => (float) ($item->amount ?? 0),
+                        'reimbursed_to' => $recipientId,
+                        'approved_by' => $userId ?: null,
+                        'description' => trim((string) ($item->description ?? '')),
+                        'status' => 'Paid',
+                        'added_by' => $userId ?: null,
+                        'school_year' => $item->expense_school_year ?: $schoolYear,
+                        'semester' => $item->expense_semester ?: $semester,
+                        'reimbursement_method' => 'Check',
+                        'batch_number' => $batchId,
+                        'created_at' => now(),
+                        'updated_at' => now(),
+                    ];
+
+                    $reimbId = (int) Reimbursement::query()->create($payload)->id;
+                }
+
+                if ($reimbId) {
+                    Reimbursement::query()->where('id', $reimbId)->update([
+                        'batch_number' => $batchId,
+                        'approved_by' => $userId ?: null,
+                        'status' => 'Paid',
+                    ]);
+
+                    Expense::query()->where('id', $expenseId)->update(['reimbursement_id' => $reimbId]);
+                    if (!empty($item->batch_item_id)) {
+                        ReimbursementBatchItem::query()->where('id', (int) $item->batch_item_id)->update([
+                            'reimbursement_id' => $reimbId,
+                        ]);
+                    }
+                }
+            }
+
+            ReimbursementBatch::query()->where('id', $batchId)->update([
+                'status' => ReimbursementBatch::STATUS_CLOSED,
+                'closed_at' => now(),
+                'closed_by' => $userId ?: null,
+            ]);
+        });
+    }
+
+    private function nextYearlyBatchNumber(string $schoolYear): int
+    {
+        $year = trim($schoolYear);
+        if ($year === '') {
+            return 1;
+        }
+
+        $max = ReimbursementBatch::query()
+            ->where('school_year', $year)
+            ->max('yearly_batch_number');
+
+        return ((int) $max) + 1;
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementContextService.php b/app/Services/Reimbursements/ReimbursementContextService.php
new file mode 100644
index 00000000..08e2323b
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementContextService.php
@@ -0,0 +1,18 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use App\Models\Configuration;
+
+class ReimbursementContextService
+{
+    public function getSchoolYear(): string
+    {
+        return (string) (Configuration::getConfig('school_year') ?? date('Y'));
+    }
+
+    public function getSemester(): string
+    {
+        return (string) (Configuration::getConfig('semester') ?? 'Fall');
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementCrudService.php b/app/Services/Reimbursements/ReimbursementCrudService.php
new file mode 100644
index 00000000..7bbb6ca1
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementCrudService.php
@@ -0,0 +1,97 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use App\Models\Expense;
+use App\Models\Reimbursement;
+use RuntimeException;
+
+class ReimbursementCrudService
+{
+    public function store(array $payload, int $userId, string $schoolYear, string $semester, ?string $receiptName): Reimbursement
+    {
+        $expenseId = (int) ($payload['expense_id'] ?? 0);
+        if ($expenseId > 0) {
+            $expense = Expense::query()->find($expenseId);
+            if ($expense && strcasecmp((string) $expense->category, 'Donation') === 0) {
+                throw new RuntimeException('Donation expenses are tracked but should not be reimbursed.');
+            }
+        }
+
+        $methodRaw = (string) ($payload['reimbursement_method'] ?? '');
+        $method = ucfirst(strtolower($methodRaw));
+
+        $reimb = Reimbursement::query()->create([
+            'expense_id' => $expenseId ?: null,
+            'amount' => $payload['amount'],
+            'reimbursed_to' => (int) $payload['reimbursed_to'],
+            'description' => $payload['description'] ?? null,
+            'reimbursement_method' => $method,
+            'check_number' => $method === 'Check' ? ($payload['check_number'] ?? null) : null,
+            'receipt_path' => $receiptName,
+            'school_year' => $payload['school_year'] ?? $schoolYear,
+            'semester' => $payload['semester'] ?? $semester,
+            'added_by' => $userId ?: null,
+            'approved_by' => $userId ?: null,
+            'status' => 'Paid',
+        ]);
+
+        if ($expenseId > 0) {
+            Expense::query()->where('id', $expenseId)->update(['reimbursement_id' => $reimb->id]);
+        }
+
+        return $reimb;
+    }
+
+    public function process(array $payload, int $userId, string $schoolYear, string $semester, ?string $receiptName): Reimbursement
+    {
+        $expenseId = (int) ($payload['expense_id'] ?? 0);
+        if ($expenseId > 0) {
+            $expense = Expense::query()->find($expenseId);
+            if ($expense && strcasecmp((string) $expense->category, 'Donation') === 0) {
+                throw new RuntimeException('Donation expenses are tracked but should not be reimbursed.');
+            }
+        }
+
+        $reimb = Reimbursement::query()->create([
+            'expense_id' => $expenseId ?: null,
+            'amount' => $payload['amount'],
+            'reimbursed_to' => (int) $payload['reimbursed_to'],
+            'approved_by' => $userId ?: null,
+            'receipt_path' => $receiptName,
+            'description' => $payload['description'] ?? 'Expense reimbursement',
+            'status' => 'Paid',
+            'added_by' => $userId ?: null,
+            'school_year' => $payload['school_year'] ?? $schoolYear,
+            'semester' => $payload['semester'] ?? $semester,
+            'check_number' => $payload['check_number'] ?? null,
+            'reimbursement_method' => $payload['reimbursement_method'] ?? null,
+        ]);
+
+        if ($expenseId > 0) {
+            Expense::query()->where('id', $expenseId)->update(['reimbursement_id' => $reimb->id]);
+        }
+
+        return $reimb;
+    }
+
+    public function update(Reimbursement $reimb, array $payload, int $userId, ?string $receiptName): Reimbursement
+    {
+        $methodRaw = (string) ($payload['reimbursement_method'] ?? $reimb->reimbursement_method);
+        $method = ucfirst(strtolower($methodRaw));
+
+        $updateData = [
+            'amount' => $payload['amount'],
+            'reimbursed_to' => (int) $payload['reimbursed_to'],
+            'description' => $payload['description'] ?? null,
+            'reimbursement_method' => $method,
+            'check_number' => $method === 'Check' ? ($payload['check_number'] ?? null) : null,
+            'receipt_path' => $receiptName,
+            'updated_by' => $userId ?: null,
+        ];
+
+        $reimb->update($updateData);
+
+        return $reimb->refresh();
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementDonationService.php b/app/Services/Reimbursements/ReimbursementDonationService.php
new file mode 100644
index 00000000..6413fee3
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementDonationService.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use App\Models\Expense;
+use App\Models\ReimbursementBatchItem;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use RuntimeException;
+
+class ReimbursementDonationService
+{
+    public function markDonation(int $expenseId, int $userId): void
+    {
+        if ($expenseId <= 0) {
+            throw new RuntimeException('Invalid expense id.');
+        }
+
+        $expense = Expense::query()->find($expenseId);
+        if (!$expense) {
+            throw new RuntimeException('Expense not found.');
+        }
+
+        if (!empty($expense->reimbursement_id)) {
+            throw new RuntimeException('Expense is already tied to a reimbursement.');
+        }
+
+        $now = now();
+
+        DB::beginTransaction();
+        try {
+            ReimbursementBatchItem::query()
+                ->where('expense_id', $expenseId)
+                ->whereNull('unassigned_at')
+                ->update(['unassigned_at' => $now]);
+
+            $expense->update([
+                'category' => 'Donation',
+                'status' => 'approved',
+                'status_reason' => 'Marked as Donation (non-reimbursable).',
+                'approved_by' => $userId ?: null,
+                'updated_by' => $userId ?: null,
+                'reimbursement_id' => null,
+            ]);
+
+            DB::commit();
+        } catch (\Throwable $e) {
+            DB::rollBack();
+            Log::error('Failed to mark donation: ' . $e->getMessage(), ['expense_id' => $expenseId]);
+            throw new RuntimeException('Unable to mark donation right now.');
+        }
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementEmailService.php b/app/Services/Reimbursements/ReimbursementEmailService.php
new file mode 100644
index 00000000..31adbcf6
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementEmailService.php
@@ -0,0 +1,358 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use App\Models\ReimbursementBatch;
+use App\Models\ReimbursementBatchAdminFile;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Mail;
+use ZipArchive;
+
+class ReimbursementEmailService
+{
+    public function __construct(private ReimbursementRecipientService $recipients)
+    {
+    }
+
+    public function sendBatchEmail(
+        int $batchId,
+        string $recipientEmail,
+        string $message,
+        array $receiptIds,
+        array $checkIds
+    ): bool {
+        $batch = ReimbursementBatch::query()->find($batchId);
+        if (!$batch) {
+            throw new \RuntimeException('Requested batch was not found.');
+        }
+
+        $receiptRows = !empty($receiptIds) ? $this->fetchBatchReceiptRows($batchId, $receiptIds) : [];
+
+        $checkRows = [];
+        if (!empty($checkIds)) {
+            $checkRows = ReimbursementBatchAdminFile::query()
+                ->select('id as file_id', 'admin_id', 'filename', 'original_filename', 'uploaded_at')
+                ->where('batch_id', $batchId)
+                ->whereIn('id', $checkIds)
+                ->get()
+                ->toArray();
+
+            $adminLookup = [];
+            foreach ($this->recipients->adminRoster() as $admin) {
+                $adminLookup[(int) ($admin['id'] ?? 0)] = trim((string) (($admin['firstname'] ?? '') . ' ' . ($admin['lastname'] ?? '')));
+            }
+            foreach ($checkRows as &$row) {
+                $aid = (int) ($row['admin_id'] ?? 0);
+                $row['admin'] = $adminLookup[$aid] ?? ($aid > 0 ? 'Admin #' . $aid : 'Admin');
+            }
+            unset($row);
+        }
+
+        $tempDir = storage_path('tmp');
+        if (!is_dir($tempDir)) {
+            mkdir($tempDir, 0755, true);
+        }
+
+        $cleanupPaths = [];
+
+        $batchLabel = trim((string) ($batch->title ?? '')) ?: ('Batch #' . ((int) ($batch->yearly_batch_number ?? $batchId)));
+        $batchFileLabel = $this->sanitizeAttachmentComponent($batchLabel);
+
+        $csvPath = tempnam($tempDir, 'batch_csv_');
+        $cleanupPaths[] = $csvPath;
+        $csvHandle = fopen($csvPath, 'w');
+        if (!$csvHandle) {
+            if (is_file($csvPath)) {
+                @unlink($csvPath);
+            }
+            throw new \RuntimeException('Unable to create the summary file.');
+        }
+
+        $batchClosedDate = $this->formatCsvDate($batch->closed_at ?? null);
+        $this->writeBatchCsvMetadata($csvHandle, $batchLabel, $batch->toArray());
+        $this->writeBatchCsvSummary($csvHandle, $receiptRows, $batchClosedDate);
+        fclose($csvHandle);
+
+        $csvAttachmentName = $batchFileLabel . '_summary.csv';
+
+        $receiptsArchivePath = null;
+        $receiptZipCreated = false;
+        if (!empty($receiptRows)) {
+            $archivePath = $tempDir . '/batch_receipts_' . $batchId . '_' . date('Ymd_His') . '_' . bin2hex(random_bytes(4)) . '.zip';
+            $zip = new ZipArchive();
+            $added = 0;
+            $usedNames = [];
+            if ($zip->open($archivePath, ZipArchive::CREATE | ZipArchive::OVERWRITE) === true) {
+                foreach ($receiptRows as $row) {
+                    $sourcePath = storage_path('uploads/receipts/' . basename((string) ($row['receipt_filename'] ?? '')));
+                    if (!is_file($sourcePath)) {
+                        continue;
+                    }
+                    $firstName = $row['purchaser_firstname'] ?? '';
+                    if (trim($firstName) === '' && !empty($row['purchaser_lastname'] ?? '')) {
+                        $firstName = $row['purchaser_lastname'];
+                    }
+                    $firstName = $this->sanitizeAttachmentComponent($firstName);
+                    $vendorPart = $this->sanitizeAttachmentComponent($row['retailor'] ?? '');
+                    $datePart = $this->formatAttachmentDate($row['purchase_date'] ?? '');
+                    $extension = pathinfo($sourcePath, PATHINFO_EXTENSION);
+                    $extPart = $extension !== '' ? ('.' . strtolower($extension)) : '';
+                    $baseName = $firstName . '_' . $vendorPart . '_' . $datePart;
+                    $entryName = $this->uniqueZipEntryName($baseName, $extPart, $usedNames);
+                    if ($zip->addFile($sourcePath, $entryName)) {
+                        $added++;
+                    }
+                }
+                $zip->close();
+            }
+            if ($added > 0 && is_file($archivePath)) {
+                $receiptsArchivePath = $archivePath;
+                $cleanupPaths[] = $archivePath;
+                $receiptZipCreated = true;
+            } elseif (is_file($archivePath)) {
+                @unlink($archivePath);
+            }
+        }
+
+        $checksArchivePath = null;
+        $checksAdded = 0;
+        if (!empty($checkRows)) {
+            $archivePath = $tempDir . '/batch_checks_' . $batchId . '_' . date('Ymd_His') . '_' . bin2hex(random_bytes(4)) . '.zip';
+            $zip = new ZipArchive();
+            $usedNames = [];
+            if ($zip->open($archivePath, ZipArchive::CREATE | ZipArchive::OVERWRITE) === true) {
+                foreach ($checkRows as $row) {
+                    $sourcePath = storage_path('uploads/reimbursements/' . basename((string) ($row['filename'] ?? '')));
+                    if (!is_file($sourcePath)) {
+                        continue;
+                    }
+                    $adminLabel = $row['admin'] ?? 'Admin';
+                    $firstToken = strtok($adminLabel, ' ');
+                    $namePart = $this->sanitizeAttachmentComponent($firstToken ?: $adminLabel);
+                    $extension = pathinfo($sourcePath, PATHINFO_EXTENSION);
+                    $extPart = $extension !== '' ? ('.' . strtolower($extension)) : '';
+                    $entryName = $this->uniqueZipEntryName($namePart, $extPart, $usedNames);
+                    if ($zip->addFile($sourcePath, $entryName)) {
+                        $checksAdded++;
+                    }
+                }
+                $zip->close();
+            }
+            if ($checksAdded > 0 && is_file($archivePath)) {
+                $checksArchivePath = $archivePath;
+                $cleanupPaths[] = $archivePath;
+            } elseif (is_file($archivePath)) {
+                @unlink($archivePath);
+            }
+        }
+
+        $attachmentSummary = ['CSV Summary'];
+        if ($receiptZipCreated) {
+            $attachmentSummary[] = 'Receipt Files';
+        }
+        if ($checksArchivePath) {
+            $attachmentSummary[] = 'Check Scans';
+        }
+
+        $subject = 'Reimbursement Batch Export: ' . $batchLabel;
+        $bodyParts = [
+            '<p>Please find attached the export for <strong>' . htmlspecialchars($batchLabel, ENT_QUOTES, 'UTF-8') . '</strong>.</p>',
+        ];
+        if (trim($message) !== '') {
+            $bodyParts[] = '<p><strong>Message:</strong><br>' . nl2br(htmlspecialchars($message, ENT_QUOTES, 'UTF-8')) . '</p>';
+        }
+        $bodyParts[] = '<p>Attachments: ' . htmlspecialchars(implode(', ', $attachmentSummary), ENT_QUOTES, 'UTF-8') . '.</p>';
+        $bodyParts[] = '<p>Regards,<br>Al Rahma Sunday School</p>';
+        $htmlBody = implode("\n", $bodyParts);
+
+        $attachments = [
+            ['path' => $csvPath, 'name' => $csvAttachmentName],
+        ];
+        if ($receiptsArchivePath) {
+            $attachments[] = ['path' => $receiptsArchivePath, 'name' => $batchFileLabel . '_receipts.zip'];
+        }
+        if ($checksArchivePath) {
+            $attachments[] = ['path' => $checksArchivePath, 'name' => $batchFileLabel . '_checks.zip'];
+        }
+
+        $sender = $this->resolveSender('general');
+
+        try {
+            Mail::html($htmlBody, function ($message) use ($recipientEmail, $subject, $sender, $attachments) {
+                $message->to($recipientEmail)->subject($subject);
+                if (!empty($sender['email'])) {
+                    $message->from($sender['email'], $sender['name']);
+                }
+                foreach ($attachments as $file) {
+                    if (!empty($file['path']) && is_file($file['path'])) {
+                        $message->attach($file['path'], ['as' => $file['name'] ?? basename($file['path'])]);
+                    }
+                }
+            });
+
+            return true;
+        } catch (\Throwable $e) {
+            Log::error('Failed to send batch export email: ' . $e->getMessage());
+            return false;
+        } finally {
+            foreach ($cleanupPaths as $path) {
+                if ($path && is_file($path)) {
+                    @unlink($path);
+                }
+            }
+        }
+    }
+
+    private function fetchBatchReceiptRows(int $batchId, array $receiptIds = []): array
+    {
+        $builder = DB::table('reimbursement_batch_items as bi')
+            ->select('e.id as expense_id', 'e.retailor', 'e.amount', 'e.description', 'e.receipt_path as receipt_filename', 'e.date_of_purchase as purchase_date', 'u.firstname as purchaser_firstname', 'u.lastname as purchaser_lastname')
+            ->join('expenses as e', 'e.id', '=', 'bi.expense_id')
+            ->leftJoin('users as u', 'u.id', '=', 'e.purchased_by')
+            ->where('bi.batch_id', $batchId);
+
+        if (!empty($receiptIds)) {
+            $builder->whereIn('e.id', $receiptIds);
+        }
+
+        $rows = $builder->get()->toArray();
+
+        return array_values(array_filter(array_map(static function ($row) {
+            return [
+                'expense_id' => $row->expense_id ?? null,
+                'retailor' => $row->retailor ?? null,
+                'amount' => $row->amount ?? null,
+                'description' => $row->description ?? null,
+                'receipt_filename' => $row->receipt_filename ?? null,
+                'purchase_date' => $row->purchase_date ?? null,
+                'purchaser_firstname' => $row->purchaser_firstname ?? null,
+                'purchaser_lastname' => $row->purchaser_lastname ?? null,
+            ];
+        }, $rows), static function ($row) {
+            return !empty($row['receipt_filename']);
+        }));
+    }
+
+    private function writeBatchCsvMetadata($handle, string $batchLabel, array $batch): void
+    {
+        $closedAtRaw = $batch['closed_at'] ?? null;
+        fputcsv($handle, ['Batch Title', $batchLabel]);
+        fputcsv($handle, ['School Year', $batch['school_year'] ?? '', 'Semester', $batch['semester'] ?? '', 'Closed At', $this->formatCsvDate($closedAtRaw)]);
+        fputcsv($handle, []);
+        fputcsv($handle, ['Amount', 'Credit', 'Paid', 'Balance', 'Date', 'By Who', 'Vendor', 'Description']);
+    }
+
+    private function writeBatchCsvSummary($handle, array $receiptRows, string $totalsDate = ''): void
+    {
+        $receiptTotalsByRecipient = [];
+        foreach ($receiptRows as $row) {
+            $recipientName = trim(($row['purchaser_firstname'] ?? '') . ' ' . ($row['purchaser_lastname'] ?? ''));
+            if ($recipientName === '') {
+                $recipientName = 'Unknown';
+            }
+            $vendor = trim((string) ($row['retailor'] ?? ''));
+            if ($vendor === '') {
+                $vendor = 'Vendor N/A';
+            }
+            $dateText = $this->formatCsvDate($row['purchase_date'] ?? null);
+            $descriptionValue = trim((string) ($row['description'] ?? ''));
+            $descriptionParts = $descriptionValue !== '' ? [$descriptionValue] : ['Receipt'];
+            $amountValue = (float) ($row['amount'] ?? 0);
+            $receiptTotalsByRecipient[$recipientName] = ($receiptTotalsByRecipient[$recipientName] ?? 0.0) + $amountValue;
+            fputcsv($handle, [
+                number_format($amountValue, 2, '.', ''),
+                '',
+                number_format($amountValue, 2, '.', ''),
+                '0.00',
+                $dateText,
+                $recipientName,
+                $vendor,
+                implode(' | ', $descriptionParts),
+            ]);
+        }
+        if (!empty($receiptTotalsByRecipient)) {
+            fputcsv($handle, []);
+            fputcsv($handle, ['Totals by Recipient', '', '', '', '', '', '', '']);
+            foreach ($receiptTotalsByRecipient as $recipient => $total) {
+                $formatted = number_format($total, 2, '.', '');
+                fputcsv($handle, [
+                    $formatted,
+                    '',
+                    $formatted,
+                    '0.00',
+                    $totalsDate,
+                    $recipient,
+                    '',
+                    '',
+                ]);
+            }
+        }
+    }
+
+    private function sanitizeAttachmentComponent(string $value): string
+    {
+        $clean = preg_replace('/[^A-Za-z0-9]+/', '_', trim((string) $value));
+        $clean = trim($clean, '_');
+        return $clean === '' ? 'unknown' : $clean;
+    }
+
+    private function formatAttachmentDate(?string $value): string
+    {
+        if (!$value) {
+            return 'unknown';
+        }
+        $timestamp = strtotime($value);
+        if ($timestamp === false) {
+            return 'unknown';
+        }
+        return date('Ymd', $timestamp);
+    }
+
+    private function uniqueZipEntryName(string $base, string $extension, array &$used): string
+    {
+        $candidate = $base . $extension;
+        $counter = 1;
+        while (isset($used[$candidate])) {
+            $candidate = $base . '_' . $counter . $extension;
+            $counter++;
+        }
+        $used[$candidate] = true;
+        return $candidate;
+    }
+
+    private function formatCsvDate(?string $value): string
+    {
+        if (!$value) {
+            return '';
+        }
+        $timestamp = strtotime($value);
+        if ($timestamp === false) {
+            return '';
+        }
+        return date('m-d-Y', $timestamp);
+    }
+
+    private function resolveSender(string $fromKey): array
+    {
+        $fromKey = $fromKey !== '' ? $fromKey : 'general';
+        $json = env('MAIL_SENDERS', '{}');
+        $senders = json_decode($json, true);
+
+        if (is_array($senders) && isset($senders[$fromKey])) {
+            $info = $senders[$fromKey];
+            return [
+                'name' => (string) ($info['name'] ?? 'Sender'),
+                'email' => (string) ($info['email'] ?? ''),
+            ];
+        }
+
+        $fallbackAddress = (string) (config('mail.from.address') ?: (getenv('SMTP_USER') ?: ''));
+        $fallbackName = (string) (config('mail.from.name') ?: 'Al Rahma Sunday School');
+
+        return [
+            'name' => $fallbackName,
+            'email' => $fallbackAddress,
+        ];
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementExportService.php b/app/Services/Reimbursements/ReimbursementExportService.php
new file mode 100644
index 00000000..f2c4d8f6
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementExportService.php
@@ -0,0 +1,233 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use App\Models\ReimbursementBatch;
+use Illuminate\Support\Facades\DB;
+use RuntimeException;
+
+class ReimbursementExportService
+{
+    public function __construct(private ReimbursementRecipientService $recipients)
+    {
+    }
+
+    public function buildUnderProcessingCsv(): array
+    {
+        $builder = DB::table('expenses')
+            ->select('expenses.*', 'u.firstname as purchaser_firstname', 'u.lastname as purchaser_lastname')
+            ->leftJoin('users as u', 'u.id', '=', 'expenses.purchased_by')
+            ->where('expenses.status', 'approved')
+            ->whereNull('expenses.reimbursement_id')
+            ->where('expenses.category', '!=', 'Donation')
+            ->orderByDesc('expenses.created_at');
+
+        $records = $builder->get();
+        $grouped = [];
+
+        foreach ($records as $row) {
+            $personId = (int) ($row->purchased_by ?? 0);
+            $name = trim(($row->purchaser_firstname ?? '') . ' ' . ($row->purchaser_lastname ?? ''));
+            if ($name === '') {
+                $name = $row->purchaser_firstname ?? $row->purchaser_lastname ?? 'Unknown';
+            }
+            $key = $personId > 0 ? 'id_' . $personId : 'name_' . strtolower($name);
+            if (!isset($grouped[$key])) {
+                $grouped[$key] = [
+                    'name' => $name ?: 'Unknown',
+                    'total' => 0.0,
+                    'vendors' => [],
+                    'descriptions' => [],
+                ];
+            }
+
+            $amount = (float) ($row->amount ?? 0);
+            $grouped[$key]['total'] += $amount;
+
+            $vendor = trim((string) ($row->retailor ?? ''));
+            if ($vendor !== '' && !in_array($vendor, $grouped[$key]['vendors'], true)) {
+                $grouped[$key]['vendors'][] = $vendor;
+            }
+
+            $desc = trim((string) ($row->description ?? ''));
+            if ($desc !== '' && !in_array($desc, $grouped[$key]['descriptions'], true)) {
+                $grouped[$key]['descriptions'][] = $desc;
+            }
+        }
+
+        $rows = [];
+        $rows[] = ['Person', 'Total Amount', 'Vendors', 'Descriptions'];
+        foreach ($grouped as $entry) {
+            $rows[] = [
+                $entry['name'],
+                number_format($entry['total'], 2, '.', ''),
+                implode('; ', $entry['vendors']),
+                implode('; ', $entry['descriptions']),
+            ];
+        }
+
+        return [
+            'filename' => 'under_processing_expenses.csv',
+            'rows' => $rows,
+        ];
+    }
+
+    public function buildProcessedCsv(array $filters): array
+    {
+        $builder = DB::table('reimbursements')
+            ->select('reimbursements.*', 'u.firstname as reimb_firstname', 'u.lastname as reimb_lastname')
+            ->leftJoin('users as u', 'u.id', '=', 'reimbursements.reimbursed_to');
+
+        if (!empty($filters['semester'])) {
+            $builder->where('reimbursements.semester', $filters['semester']);
+        }
+        if (!empty($filters['status'])) {
+            $builder->where('reimbursements.status', $filters['status']);
+        }
+        if (!empty($filters['user_id'])) {
+            $builder->where('reimbursements.reimbursed_to', $filters['user_id']);
+        }
+        if (!empty($filters['school_year'])) {
+            $builder->where('reimbursements.school_year', $filters['school_year']);
+        }
+
+        $records = $builder->orderByDesc('reimbursements.created_at')->get();
+        $rows = [];
+        $rows[] = ['Amount', 'Reimbursed To', 'Status', 'Method', 'Check #', 'School Year', 'Semester', 'Date'];
+
+        foreach ($records as $row) {
+            $hasName = trim(($row->reimb_firstname ?? '') . ' ' . ($row->reimb_lastname ?? '')) !== '';
+            if (!$hasName) {
+                $label = $this->recipients->specialRecipientLabel($row->reimbursed_to ?? null);
+                if ($label !== null) {
+                    $row->reimb_firstname = $label;
+                    $row->reimb_lastname = '';
+                }
+            }
+
+            $rows[] = [
+                $row->amount,
+                trim(($row->reimb_firstname ?? '') . ' ' . ($row->reimb_lastname ?? '')),
+                $row->status,
+                $row->reimbursement_method ?? '-',
+                $row->check_number ?? '-',
+                $row->school_year ?? '-',
+                $row->semester ?? '-',
+                $row->created_at,
+            ];
+        }
+
+        return [
+            'filename' => 'reimbursements_export.csv',
+            'rows' => $rows,
+        ];
+    }
+
+    public function buildBatchCsv(int $batchId): array
+    {
+        $batch = ReimbursementBatch::query()->find($batchId);
+        if (!$batch) {
+            throw new RuntimeException('Batch not found.');
+        }
+
+        $batchLabel = trim((string) ($batch->title ?? '')) ?: ('Batch #' . $batchId);
+        $receiptRows = $this->fetchBatchReceiptRows($batchId);
+
+        $rows = [];
+        $this->writeBatchCsvMetadata($rows, $batchLabel, $batch->toArray());
+        $this->writeBatchCsvSummary($rows, $receiptRows, $this->formatCsvDate($batch->closed_at ?? null));
+
+        return [
+            'filename' => sprintf('batch_%d_items.csv', $batchId),
+            'rows' => $rows,
+        ];
+    }
+
+    private function fetchBatchReceiptRows(int $batchId, array $receiptIds = []): array
+    {
+        $builder = DB::table('reimbursement_batch_items as bi')
+            ->select('e.id as expense_id', 'e.retailor', 'e.amount', 'e.description', 'e.receipt_path as receipt_filename', 'e.date_of_purchase as purchase_date', 'u.firstname as purchaser_firstname', 'u.lastname as purchaser_lastname')
+            ->join('expenses as e', 'e.id', '=', 'bi.expense_id')
+            ->leftJoin('users as u', 'u.id', '=', 'e.purchased_by')
+            ->where('bi.batch_id', $batchId);
+
+        if (!empty($receiptIds)) {
+            $builder->whereIn('e.id', $receiptIds);
+        }
+
+        $rows = $builder->get()->toArray();
+
+        return array_values(array_filter($rows, static function ($row) {
+            return !empty($row->receipt_filename);
+        }));
+    }
+
+    private function writeBatchCsvMetadata(array &$rows, string $batchLabel, array $batch): void
+    {
+        $closedAtRaw = $batch['closed_at'] ?? null;
+        $rows[] = ['Batch Title', $batchLabel];
+        $rows[] = ['School Year', $batch['school_year'] ?? '', 'Semester', $batch['semester'] ?? '', 'Closed At', $this->formatCsvDate($closedAtRaw)];
+        $rows[] = [];
+        $rows[] = ['Amount', 'Credit', 'Paid', 'Balance', 'Date', 'By Who', 'Vendor', 'Description'];
+    }
+
+    private function writeBatchCsvSummary(array &$rows, array $receiptRows, string $totalsDate = ''): void
+    {
+        $receiptTotalsByRecipient = [];
+        foreach ($receiptRows as $row) {
+            $recipientName = trim(($row->purchaser_firstname ?? '') . ' ' . ($row->purchaser_lastname ?? ''));
+            if ($recipientName === '') {
+                $recipientName = 'Unknown';
+            }
+            $vendor = trim((string) ($row->retailor ?? ''));
+            if ($vendor === '') {
+                $vendor = 'Vendor N/A';
+            }
+            $dateText = $this->formatCsvDate($row->purchase_date ?? null);
+            $descriptionValue = trim((string) ($row->description ?? ''));
+            $descriptionParts = $descriptionValue !== '' ? [$descriptionValue] : ['Receipt'];
+            $amountValue = (float) ($row->amount ?? 0);
+            $receiptTotalsByRecipient[$recipientName] = ($receiptTotalsByRecipient[$recipientName] ?? 0.0) + $amountValue;
+            $rows[] = [
+                number_format($amountValue, 2, '.', ''),
+                '',
+                number_format($amountValue, 2, '.', ''),
+                '0.00',
+                $dateText,
+                $recipientName,
+                $vendor,
+                implode(' | ', $descriptionParts),
+            ];
+        }
+
+        if (!empty($receiptTotalsByRecipient)) {
+            $rows[] = [];
+            $rows[] = ['Totals by Recipient', '', '', '', '', '', '', ''];
+            foreach ($receiptTotalsByRecipient as $recipient => $total) {
+                $formatted = number_format($total, 2, '.', '');
+                $rows[] = [
+                    $formatted,
+                    '',
+                    $formatted,
+                    '0.00',
+                    $totalsDate,
+                    $recipient,
+                    '',
+                    '',
+                ];
+            }
+        }
+    }
+
+    private function formatCsvDate(?string $value): string
+    {
+        if (!$value) {
+            return '';
+        }
+        $timestamp = strtotime($value);
+        if ($timestamp === false) {
+            return '';
+        }
+        return date('m-d-Y', $timestamp);
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementFileService.php b/app/Services/Reimbursements/ReimbursementFileService.php
new file mode 100644
index 00000000..a99d60a7
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementFileService.php
@@ -0,0 +1,119 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use App\Models\ReimbursementBatchAdminFile;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Str;
+use RuntimeException;
+
+class ReimbursementFileService
+{
+    public function receiptUrl(?string $filename): ?string
+    {
+        if (!$filename) {
+            return null;
+        }
+        $safe = basename(trim($filename));
+        return $safe !== '' ? url('/api/v1/files/reimbursements/' . $safe) : null;
+    }
+
+    public function expenseReceiptUrl(?string $filename): ?string
+    {
+        if (!$filename) {
+            return null;
+        }
+        $safe = basename(trim($filename));
+        return $safe !== '' ? url('/api/v1/files/receipts/' . $safe) : null;
+    }
+
+    public function adminFileUrl(string $filename, string $mode = 'inline'): string
+    {
+        return url('/api/v1/finance/reimbursements/batches/admin-files/' . rawurlencode($filename) . '/' . $mode);
+    }
+
+    public function storeReceipt(?UploadedFile $file): ?string
+    {
+        if (!$file || !$file->isValid()) {
+            return null;
+        }
+
+        if (($file->getSize() ?? 0) <= 0) {
+            return null;
+        }
+
+        $dir = $this->ensureUploadDir();
+        $extension = $file->getClientOriginalExtension();
+        $extension = $extension !== '' ? '.' . strtolower($extension) : '';
+        $filename = 'reimb_' . date('Ymd_His') . '_' . Str::random(8) . $extension;
+
+        if (!$file->move($dir, $filename)) {
+            throw new RuntimeException('Unable to save uploaded file.');
+        }
+
+        return $filename;
+    }
+
+    public function storeAdminFile(int $batchId, int $adminId, UploadedFile $file, int $userId): array
+    {
+        $dir = $this->ensureUploadDir();
+        $extension = $file->getClientOriginalExtension();
+        $extension = $extension !== '' ? '.' . strtolower($extension) : '';
+        $filename = 'batch_check_' . date('Ymd_His') . '_' . Str::random(8) . $extension;
+
+        if (!$file->move($dir, $filename)) {
+            throw new RuntimeException('Unable to save uploaded file.');
+        }
+
+        $existing = ReimbursementBatchAdminFile::query()
+            ->where('batch_id', $batchId)
+            ->where('admin_id', $adminId)
+            ->first();
+
+        if ($existing && !empty($existing->filename)) {
+            $oldPath = $dir . DIRECTORY_SEPARATOR . $existing->filename;
+            if (is_file($oldPath)) {
+                @unlink($oldPath);
+            }
+        }
+
+        $payload = [
+            'batch_id' => $batchId,
+            'admin_id' => $adminId,
+            'filename' => $filename,
+            'original_filename' => $file->getClientOriginalName(),
+            'uploaded_at' => now(),
+            'uploaded_by' => $userId ?: null,
+        ];
+
+        if ($existing) {
+            $existing->fill($payload);
+            $existing->save();
+        } else {
+            ReimbursementBatchAdminFile::query()->create($payload);
+        }
+
+        return [
+            'filename' => $filename,
+            'original_filename' => $file->getClientOriginalName(),
+            'url' => $this->adminFileUrl($filename, 'inline'),
+        ];
+    }
+
+    private function ensureUploadDir(): string
+    {
+        $dir = storage_path('uploads/reimbursements');
+
+        if (!is_dir($dir)) {
+            if (!@mkdir($dir, 0755, true) && !is_dir($dir)) {
+                throw new RuntimeException('Upload directory is not available.');
+            }
+        }
+
+        if (!is_writable($dir)) {
+            throw new RuntimeException('Upload directory is not writable.');
+        }
+
+        return $dir;
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementLookupService.php b/app/Services/Reimbursements/ReimbursementLookupService.php
new file mode 100644
index 00000000..604120ad
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementLookupService.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use App\Models\Reimbursement;
+
+class ReimbursementLookupService
+{
+    public function findReimbursementIdForExpense(int $expenseId): ?int
+    {
+        if ($expenseId <= 0) {
+            return null;
+        }
+
+        $row = Reimbursement::query()
+            ->select('id')
+            ->where('expense_id', $expenseId)
+            ->orderByDesc('id')
+            ->first();
+
+        return $row ? (int) $row->id : null;
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementQueryService.php b/app/Services/Reimbursements/ReimbursementQueryService.php
new file mode 100644
index 00000000..66b2d40f
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementQueryService.php
@@ -0,0 +1,498 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use App\Models\Expense;
+use App\Models\ReimbursementBatchAdminFile;
+use Illuminate\Support\Facades\DB;
+
+class ReimbursementQueryService
+{
+    public function __construct(
+        private ReimbursementRecipientService $recipients,
+        private ReimbursementFileService $files
+    ) {
+    }
+
+    public function underProcessing(): array
+    {
+        $pendingQuery = DB::table('expenses as e')
+            ->selectRaw('e.id as expense_id, e.amount as expense_amount, e.description, e.receipt_path as expense_receipt, e.retailor, e.purchased_by, u.firstname as purchaser_firstname, u.lastname as purchaser_lastname')
+            ->leftJoin('users as u', 'u.id', '=', 'e.purchased_by')
+            ->leftJoin('reimbursement_batch_items as bi', function ($join) {
+                $join->on('bi.expense_id', '=', 'e.id');
+                $join->whereNull('bi.unassigned_at');
+            })
+            ->whereNull('e.reimbursement_id')
+            ->where('e.category', '!=', 'Donation')
+            ->where(function ($q) {
+                $q->where('e.status', 'approved')
+                    ->orWhere('e.status', 'Approved')
+                    ->orWhere('e.status', 'APPROVED');
+            })
+            ->whereNull('bi.id')
+            ->orderByDesc('e.created_at');
+
+        $pendingRows = $pendingQuery->get();
+
+        $pendingItems = [];
+        $itemsMap = [];
+
+        foreach ($pendingRows as $row) {
+            $expenseId = (int) ($row->expense_id ?? 0);
+            if ($expenseId <= 0) {
+                continue;
+            }
+
+            $receiptUrl = $this->files->expenseReceiptUrl($row->expense_receipt ?? null);
+            $fullName = trim(($row->purchaser_firstname ?? '') . ' ' . ($row->purchaser_lastname ?? '')) ?: 'Unknown';
+
+            $item = [
+                'id' => $expenseId,
+                'expense_id' => $expenseId,
+                'reimbursement_id' => null,
+                'expense_amount' => (float) ($row->expense_amount ?? 0),
+                'vendor' => (string) ($row->retailor ?? ''),
+                'description' => trim((string) ($row->description ?? '')),
+                'purchased_by' => $fullName,
+                'receipt_url' => $receiptUrl,
+                'batch_id' => null,
+                'batch_label' => null,
+                'admin_id' => null,
+                'admin_name' => null,
+                'batch_number' => 0,
+            ];
+
+            $pendingItems[] = $item;
+            $itemsMap[$expenseId] = $item;
+        }
+
+        $assignedQuery = DB::table('reimbursement_batch_items as bi')
+            ->selectRaw('bi.id as batch_item_id, bi.batch_id, bi.admin_id, bi.reimbursement_id, bi.expense_id, b.title as batch_title, b.status as batch_status, b.yearly_batch_number as batch_year_number, e.amount as expense_amount, e.description, e.receipt_path as expense_receipt, e.retailor, purchaser.firstname as purchaser_firstname, purchaser.lastname as purchaser_lastname, admin.firstname as admin_firstname, admin.lastname as admin_lastname')
+            ->join('reimbursement_batches as b', 'b.id', '=', 'bi.batch_id')
+            ->join('expenses as e', 'e.id', '=', 'bi.expense_id')
+            ->leftJoin('users as purchaser', 'purchaser.id', '=', 'e.purchased_by')
+            ->leftJoin('users as admin', 'admin.id', '=', 'bi.admin_id')
+            ->where('b.status', 'open')
+            ->whereNull('bi.unassigned_at')
+            ->whereNull('e.reimbursement_id')
+            ->where('e.category', '!=', 'Donation')
+            ->where(function ($q) {
+                $q->where('e.status', 'approved')
+                    ->orWhere('e.status', 'Approved')
+                    ->orWhere('e.status', 'APPROVED');
+            })
+            ->orderBy('b.opened_at', 'ASC')
+            ->orderBy('bi.assigned_at', 'ASC');
+
+        $assignedRows = $assignedQuery->get();
+        $batchStructures = [];
+
+        foreach ($assignedRows as $row) {
+            $expenseId = (int) ($row->expense_id ?? 0);
+            $batchId = (int) ($row->batch_id ?? 0);
+            if ($expenseId <= 0 || $batchId <= 0) {
+                continue;
+            }
+
+            $receiptUrl = $this->files->expenseReceiptUrl($row->expense_receipt ?? null);
+            $purchaser = trim(($row->purchaser_firstname ?? '') . ' ' . ($row->purchaser_lastname ?? '')) ?: 'Unknown';
+            $yearlyNumber = (int) ($row->batch_year_number ?? 0);
+            $batchLabel = trim((string) ($row->batch_title ?? ''));
+            if ($batchLabel === '') {
+                $fallbackNumber = $yearlyNumber > 0 ? $yearlyNumber : $batchId;
+                $batchLabel = 'Batch #' . $fallbackNumber;
+            }
+            $adminId = $row->admin_id ? (int) $row->admin_id : 0;
+            $adminName = $adminId > 0
+                ? (trim(($row->admin_firstname ?? '') . ' ' . ($row->admin_lastname ?? '')) ?: 'Admin')
+                : 'Unassigned';
+            $batchStatus = strtolower(trim((string) ($row->batch_status ?? ''))) ?: 'open';
+
+            $item = [
+                'id' => $expenseId,
+                'expense_id' => $expenseId,
+                'reimbursement_id' => $row->reimbursement_id ? (int) $row->reimbursement_id : null,
+                'expense_amount' => (float) ($row->expense_amount ?? 0),
+                'vendor' => (string) ($row->retailor ?? ''),
+                'description' => trim((string) ($row->description ?? '')),
+                'purchased_by' => $purchaser,
+                'receipt_url' => $receiptUrl,
+                'batch_id' => $batchId,
+                'batch_label' => $batchLabel,
+                'admin_id' => $adminId ?: null,
+                'admin_name' => $adminId > 0 ? $adminName : null,
+                'batch_number' => $batchId,
+            ];
+
+            $itemsMap[$expenseId] = $item;
+
+            if (!isset($batchStructures[$batchId])) {
+                $batchStructures[$batchId] = [
+                    'batchId' => $batchId,
+                    'label' => $batchLabel,
+                    'slots' => [],
+                    'status' => $batchStatus,
+                    'yearly_batch_number' => $yearlyNumber,
+                ];
+            } else {
+                $batchStructures[$batchId]['status'] = $batchStatus;
+                if ($yearlyNumber > 0) {
+                    $batchStructures[$batchId]['yearly_batch_number'] = $yearlyNumber;
+                }
+            }
+
+            $slotKey = $adminId ?: 0;
+            if (!isset($batchStructures[$batchId]['slots'][$slotKey])) {
+                $batchStructures[$batchId]['slots'][$slotKey] = [
+                    'admin_id' => $adminId ?: 0,
+                    'admin_name' => $adminId > 0 ? $adminName : 'Unassigned',
+                    'items' => [],
+                    'check_file' => null,
+                ];
+            }
+            $batchStructures[$batchId]['slots'][$slotKey]['items'][] = $expenseId;
+        }
+
+        $adminFileMap = [];
+        if (!empty($batchStructures)) {
+            $batchIds = array_keys($batchStructures);
+            $files = ReimbursementBatchAdminFile::query()
+                ->select('batch_id', 'admin_id', 'filename', 'original_filename')
+                ->whereIn('batch_id', $batchIds)
+                ->get();
+
+            foreach ($files as $file) {
+                $batchId = (int) ($file->batch_id ?? 0);
+                $adminId = (int) ($file->admin_id ?? 0);
+                if ($batchId <= 0) {
+                    continue;
+                }
+                $adminFileMap[$batchId][$adminId] = [
+                    'filename' => $file->filename,
+                    'original_filename' => $file->original_filename ?? null,
+                    'url' => $this->files->adminFileUrl($file->filename ?? '', 'inline'),
+                ];
+            }
+        }
+
+        foreach ($batchStructures as $batchId => &$batch) {
+            foreach ($batch['slots'] as $slotKey => &$slot) {
+                $adminId = $slot['admin_id'] ?? 0;
+                $slot['check_file'] = $adminFileMap[$batchId][$adminId] ?? null;
+            }
+            unset($slot);
+        }
+        unset($batch);
+
+        $existingBatches = array_map(static function (array $batch) {
+            $normalizedSlots = array_map(static function (array $slot) {
+                $slot['items'] = array_values(array_map('intval', $slot['items']));
+                return $slot;
+            }, array_values($batch['slots']));
+
+            $itemIds = [];
+            foreach ($normalizedSlots as $slot) {
+                $itemIds = array_merge($itemIds, $slot['items']);
+            }
+
+            return [
+                'batchId' => $batch['batchId'],
+                'batchNumber' => $batch['batchId'],
+                'label' => $batch['label'],
+                'sequence' => $batch['yearly_batch_number'] ?? 0,
+                'yearly_batch_number' => $batch['yearly_batch_number'] ?? 0,
+                'slots' => $normalizedSlots,
+                'itemIds' => array_values(array_unique($itemIds)),
+                'status' => $batch['status'] ?? 'open',
+            ];
+        }, array_values($batchStructures));
+
+        $admins = $this->recipients->adminRoster();
+
+        return [
+            'pendingItems' => $pendingItems,
+            'existingBatches' => $existingBatches,
+            'adminUsers' => $admins,
+            'itemsPayload' => array_values($itemsMap),
+        ];
+    }
+
+    public function index(array $filters): array
+    {
+        $expenses = Expense::getReimbursedExpensesWithDetails($filters)
+            ->get()
+            ->map(static fn ($row) => (array) $row)
+            ->all();
+
+        $batchSummaries = [];
+        $batchDetails = [];
+        $batchAttachments = [];
+
+        $batchQuery = DB::table('reimbursement_batches as b')
+            ->selectRaw('b.id as batch_id, b.title as batch_title, b.yearly_batch_number, b.closed_at, b.school_year as batch_school_year, e.id as expense_id, e.amount as expense_amount, e.description, e.retailor, e.receipt_path as expense_receipt, e.date_of_purchase as expense_date_of_purchase, e.purchased_by, u.firstname as purchaser_firstname, u.lastname as purchaser_lastname, r.amount as reimb_amount')
+            ->join('reimbursement_batch_items as bi', 'bi.batch_id', '=', 'b.id')
+            ->join('expenses as e', 'e.id', '=', 'bi.expense_id')
+            ->leftJoin('users as u', 'u.id', '=', 'e.purchased_by')
+            ->leftJoin('reimbursements as r', 'r.expense_id', '=', 'e.id')
+            ->where('b.status', 'closed')
+            ->whereNull('bi.unassigned_at');
+
+        if (!empty($filters['school_year'])) {
+            $batchQuery->where(function ($q) use ($filters) {
+                $q->where('b.school_year', $filters['school_year'])
+                    ->orWhere('e.school_year', $filters['school_year']);
+            });
+        }
+        if (!empty($filters['user_id'])) {
+            $batchQuery->where('e.purchased_by', $filters['user_id']);
+        }
+
+        $batchRows = $batchQuery->get();
+        foreach ($batchRows as $row) {
+            $bid = (int) ($row->batch_id ?? 0);
+            if ($bid <= 0) {
+                continue;
+            }
+            $labelNumber = (int) ($row->yearly_batch_number ?? $bid);
+            if (!isset($batchSummaries[$bid])) {
+                $batchSummaries[$bid] = [
+                    'batch_id' => $bid,
+                    'title' => trim((string) ($row->batch_title ?? '')) ?: ('Batch #' . $labelNumber),
+                    'sequence' => $labelNumber,
+                    'closed_at' => $row->closed_at ?? null,
+                    'amount' => 0.0,
+                    'items' => 0,
+                ];
+            }
+            $amount = $row->reimb_amount ?? $row->expense_amount ?? 0;
+            $batchSummaries[$bid]['amount'] += (float) $amount;
+            $batchSummaries[$bid]['items'] += 1;
+
+            if (!isset($batchDetails[$bid])) {
+                $batchDetails[$bid] = [
+                    'title' => $batchSummaries[$bid]['title'],
+                    'sequence' => $labelNumber,
+                    'closed_at' => $batchSummaries[$bid]['closed_at'],
+                    'items' => [],
+                    'checks' => [],
+                ];
+            }
+            if (!isset($batchAttachments[$bid])) {
+                $batchAttachments[$bid] = [
+                    'receipts' => [],
+                    'checks' => [],
+                ];
+            }
+
+            $batchDetails[$bid]['items'][] = [
+                'amount' => (float) $amount,
+                'description' => $row->description ?? '',
+                'vendor' => $row->retailor ?? '',
+                'purchased_by' => trim(($row->purchaser_firstname ?? '') . ' ' . ($row->purchaser_lastname ?? '')),
+                'receipt_url' => $this->files->expenseReceiptUrl($row->expense_receipt ?? null),
+            ];
+
+            $receiptFilename = trim((string) ($row->expense_receipt ?? ''));
+            if ($receiptFilename !== '') {
+                $batchAttachments[$bid]['receipts'][] = [
+                    'expense_id' => (int) ($row->expense_id ?? 0),
+                    'receipt_filename' => $receiptFilename,
+                    'receipt_url' => $this->files->expenseReceiptUrl($receiptFilename),
+                    'purchaser_firstname' => $row->purchaser_firstname ?? '',
+                    'purchaser_lastname' => $row->purchaser_lastname ?? '',
+                    'vendor' => $row->retailor ?? '',
+                    'description' => $row->description ?? '',
+                    'amount' => (float) ($row->expense_amount ?? 0),
+                    'date_of_purchase' => $row->expense_date_of_purchase ?? '',
+                ];
+            }
+        }
+
+        if (!empty($batchSummaries)) {
+            $batchIds = array_keys($batchSummaries);
+            $files = ReimbursementBatchAdminFile::query()
+                ->select('id as file_id', 'batch_id', 'admin_id', 'filename', 'original_filename', 'uploaded_at')
+                ->whereIn('batch_id', $batchIds)
+                ->get();
+
+            $adminNames = $this->recipients->adminRoster();
+            $adminNameMap = [];
+            foreach ($adminNames as $admin) {
+                $adminNameMap[(int) $admin['id']] = trim(($admin['firstname'] ?? '') . ' ' . ($admin['lastname'] ?? ''));
+            }
+
+            foreach ($files as $file) {
+                $bid = (int) ($file->batch_id ?? 0);
+                if ($bid <= 0 || !isset($batchDetails[$bid])) {
+                    continue;
+                }
+                $aid = (int) ($file->admin_id ?? 0);
+                $batchDetails[$bid]['checks'][] = [
+                    'admin' => $adminNameMap[$aid] ?? ($aid > 0 ? 'Admin #' . $aid : 'Unassigned'),
+                    'filename' => $file->filename,
+                    'original' => $file->original_filename ?? $file->filename,
+                    'url' => $this->files->adminFileUrl($file->filename ?? '', 'inline'),
+                ];
+                if (!isset($batchAttachments[$bid])) {
+                    $batchAttachments[$bid] = [
+                        'receipts' => [],
+                        'checks' => [],
+                    ];
+                }
+                $batchAttachments[$bid]['checks'][] = [
+                    'file_id' => (int) ($file->file_id ?? 0),
+                    'filename' => $file->filename,
+                    'original_filename' => $file->original_filename ?? $file->filename,
+                    'admin' => $adminNameMap[$aid] ?? ($aid > 0 ? 'Admin #' . $aid : 'Unassigned'),
+                    'url' => $this->files->adminFileUrl($file->filename ?? '', 'inline'),
+                    'uploaded_at' => $file->uploaded_at ?? null,
+                ];
+            }
+        }
+
+        if (!empty($batchSummaries)) {
+            $batchSummaries = array_values($batchSummaries);
+            usort($batchSummaries, static function ($a, $b) {
+                $aSeq = (int) ($a['sequence'] ?? 0);
+                $bSeq = (int) ($b['sequence'] ?? 0);
+                return $bSeq <=> $aSeq;
+            });
+        }
+
+        $donationBatch = null;
+        $donationDetails = [
+            'items' => [],
+            'checks' => [],
+        ];
+
+        $donationQuery = DB::table('expenses as e')
+            ->selectRaw('e.id as expense_id, e.amount as expense_amount, e.description, e.retailor, e.receipt_path as expense_receipt, e.purchased_by, e.school_year, e.semester, e.status, u.firstname as purchaser_firstname, u.lastname as purchaser_lastname')
+            ->leftJoin('users as u', 'u.id', '=', 'e.purchased_by')
+            ->where('e.category', 'Donation');
+
+        if (!empty($filters['school_year'])) {
+            $donationQuery->where('e.school_year', $filters['school_year']);
+        }
+        if (!empty($filters['semester'])) {
+            $donationQuery->where('e.semester', $filters['semester']);
+        }
+        if (!empty($filters['user_id'])) {
+            $donationQuery->where('e.purchased_by', $filters['user_id']);
+        }
+        if (!empty($filters['status'])) {
+            $donationQuery->where(function ($q) use ($filters) {
+                $q->where('e.status', $filters['status'])
+                    ->orWhere('e.status', strtolower((string) $filters['status']))
+                    ->orWhere('e.status', strtoupper((string) $filters['status']));
+            });
+        }
+
+        $donationRows = $donationQuery->orderByDesc('e.created_at')->get();
+        if ($donationRows->isNotEmpty()) {
+            $donationTotal = 0.0;
+            foreach ($donationRows as $row) {
+                $amount = (float) ($row->expense_amount ?? 0);
+                $donationTotal += $amount;
+                $purchaser = trim(($row->purchaser_firstname ?? '') . ' ' . ($row->purchaser_lastname ?? ''));
+                if ($purchaser === '') {
+                    $purchaser = 'Unknown';
+                }
+                $donationDetails['items'][] = [
+                    'amount' => $amount,
+                    'description' => $row->description ?? '',
+                    'vendor' => $row->retailor ?? '',
+                    'purchased_by' => $purchaser,
+                    'receipt_url' => $this->files->expenseReceiptUrl($row->expense_receipt ?? null),
+                ];
+            }
+
+            $donationBatch = [
+                'title' => 'Donations',
+                'items' => count($donationDetails['items']),
+                'amount' => $donationTotal,
+            ];
+        }
+
+        foreach ($expenses as &$e) {
+            if (array_key_exists('expense_receipt', $e)) {
+                $e['expense_receipt_url'] = $this->files->expenseReceiptUrl($e['expense_receipt']);
+            } elseif (array_key_exists('receipt_path', $e)) {
+                $e['expense_receipt_url'] = $this->files->expenseReceiptUrl($e['receipt_path']);
+            }
+
+            if (array_key_exists('reimb_receipt', $e)) {
+                $e['reimb_receipt_url'] = $this->files->receiptUrl($e['reimb_receipt']);
+            } elseif (array_key_exists('receipt_path_reimb', $e)) {
+                $e['reimb_receipt_url'] = $this->files->receiptUrl($e['receipt_path_reimb']);
+            }
+
+            $recipientId = $e['reimb_recipient_id'] ?? ($e['reimbursed_to'] ?? null);
+            $hasName = trim(($e['reimb_firstname'] ?? '') . ' ' . ($e['reimb_lastname'] ?? '')) !== '';
+            if (!$hasName) {
+                $label = $this->recipients->specialRecipientLabel($recipientId);
+                if ($label !== null) {
+                    $e['reimb_firstname'] = $label;
+                    $e['reimb_lastname'] = '';
+                }
+            }
+        }
+        unset($e);
+
+        $users = $this->recipients->recipientOptions();
+
+        $years = DB::table('reimbursements')
+            ->select('school_year')
+            ->distinct()
+            ->orderByDesc('school_year')
+            ->get();
+        $schoolYears = array_values(array_filter(array_map(static fn ($row) => $row->school_year ?? null, $years->all())));
+
+        return [
+            'expenses' => $expenses,
+            'users' => $users,
+            'schoolYears' => $schoolYears,
+            'batchSummaries' => $batchSummaries,
+            'batchDetails' => $batchDetails,
+            'batchAttachments' => $batchAttachments,
+            'donationBatch' => $donationBatch,
+            'donationDetails' => $donationDetails,
+        ];
+    }
+
+    public function reimbursedExpenses(): array
+    {
+        $rows = DB::table('reimbursements as r')
+            ->selectRaw('e.amount as expense_amount, e.category, e.description, e.receipt_path as expense_receipt, e.purchased_by, r.amount as reimb_amount, r.reimbursement_method, r.check_number, r.receipt_path as reimb_receipt, r.status as reimb_status, r.created_at, u.firstname as purchaser_firstname, u.lastname as purchaser_lastname, a.firstname as approver_firstname, a.lastname as approver_lastname')
+            ->join('expenses as e', 'e.id', '=', 'r.expense_id')
+            ->leftJoin('users as u', 'u.id', '=', 'e.purchased_by')
+            ->leftJoin('users as a', 'a.id', '=', 'r.approved_by')
+            ->orderByDesc('r.created_at')
+            ->get();
+
+        $expenses = [];
+        foreach ($rows as $row) {
+            $expenses[] = [
+                'expense_amount' => (float) ($row->expense_amount ?? 0),
+                'category' => $row->category ?? null,
+                'description' => $row->description ?? null,
+                'expense_receipt' => $row->expense_receipt ?? null,
+                'purchased_by' => $row->purchased_by ?? null,
+                'reimb_amount' => (float) ($row->reimb_amount ?? 0),
+                'reimbursement_method' => $row->reimbursement_method ?? null,
+                'check_number' => $row->check_number ?? null,
+                'reimb_receipt' => $row->reimb_receipt ?? null,
+                'reimb_status' => $row->reimb_status ?? null,
+                'created_at' => $row->created_at ?? null,
+                'purchaser_firstname' => $row->purchaser_firstname ?? null,
+                'purchaser_lastname' => $row->purchaser_lastname ?? null,
+                'approver_firstname' => $row->approver_firstname ?? null,
+                'approver_lastname' => $row->approver_lastname ?? null,
+                'expense_receipt_url' => $this->files->expenseReceiptUrl($row->expense_receipt ?? null),
+                'reimb_receipt_url' => $this->files->receiptUrl($row->reimb_receipt ?? null),
+            ];
+        }
+
+        return $expenses;
+    }
+}
diff --git a/app/Services/Reimbursements/ReimbursementRecipientService.php b/app/Services/Reimbursements/ReimbursementRecipientService.php
new file mode 100644
index 00000000..d614b514
--- /dev/null
+++ b/app/Services/Reimbursements/ReimbursementRecipientService.php
@@ -0,0 +1,93 @@
+<?php
+
+namespace App\Services\Reimbursements;
+
+use Illuminate\Support\Facades\DB;
+
+class ReimbursementRecipientService
+{
+    public const SPECIAL_RECIPIENTS = [
+        990001 => 'Masjid',
+        990002 => 'Donation',
+    ];
+
+    public function staffUsers(): array
+    {
+        $rows = DB::table('users')
+            ->select('users.id', 'users.firstname', 'users.lastname', 'roles.name as role_name')
+            ->leftJoin('user_roles', 'user_roles.user_id', '=', 'users.id')
+            ->leftJoin('roles', 'roles.id', '=', 'user_roles.role_id')
+            ->whereNotNull('roles.name')
+            ->get();
+
+        $excludedRoles = array_map('strtolower', ['parent', 'student', 'guest']);
+        $staff = [];
+
+        foreach ($rows as $row) {
+            $roleName = strtolower((string) ($row->role_name ?? ''));
+            $id = (int) ($row->id ?? 0);
+            if ($id <= 0 || in_array($roleName, $excludedRoles, true)) {
+                continue;
+            }
+            if (!isset($staff[$id])) {
+                $staff[$id] = [
+                    'id' => $id,
+                    'firstname' => $row->firstname ?? '',
+                    'lastname' => $row->lastname ?? '',
+                ];
+            }
+        }
+
+        uasort($staff, static function (array $a, array $b) {
+            $nameA = trim(($a['firstname'] ?? '') . ' ' . ($a['lastname'] ?? ''));
+            $nameB = trim(($b['firstname'] ?? '') . ' ' . ($b['lastname'] ?? ''));
+            return strcasecmp($nameA, $nameB);
+        });
+
+        return array_values($staff);
+    }
+
+    public function recipientOptions(): array
+    {
+        return $this->appendSpecialRecipients($this->staffUsers());
+    }
+
+    public function adminRoster(): array
+    {
+        $admins = $this->staffUsers();
+        if (!empty($admins)) {
+            return $admins;
+        }
+
+        return $this->recipientOptions();
+    }
+
+    public function specialRecipientLabel($value): ?string
+    {
+        if ($value === null || !is_numeric($value)) {
+            return null;
+        }
+
+        $id = (int) $value;
+        return self::SPECIAL_RECIPIENTS[$id] ?? null;
+    }
+
+    private function appendSpecialRecipients(array $users): array
+    {
+        $existingIds = array_map(static function ($row) {
+            return isset($row['id']) && is_numeric($row['id']) ? (int) $row['id'] : null;
+        }, $users);
+
+        foreach (self::SPECIAL_RECIPIENTS as $id => $label) {
+            if (!in_array($id, $existingIds, true)) {
+                $users[] = [
+                    'id' => $id,
+                    'firstname' => $label,
+                    'lastname' => '',
+                ];
+            }
+        }
+
+        return $users;
+    }
+}
diff --git a/app/Services/SchoolIdService.php b/app/Services/SchoolIdService.php
new file mode 100644
index 00000000..390f1233
--- /dev/null
+++ b/app/Services/SchoolIdService.php
@@ -0,0 +1,69 @@
+<?php
+
+namespace App\Services;
+
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+
+class SchoolIdService
+{
+    public function assignSchoolIdToUser(int $userId): ?string
+    {
+        $user = User::query()->find($userId);
+        if (!$user) {
+            return null;
+        }
+
+        $existing = (string) ($user->school_id ?? '');
+        if ($existing !== '') {
+            return $existing;
+        }
+
+        $schoolId = $this->generateUserSchoolId();
+        $user->school_id = $schoolId;
+        $user->save();
+
+        return $schoolId;
+    }
+
+    public function generateStudentSchoolId(): string
+    {
+        $year = date('y');
+        $maxId = 0;
+
+        $row = DB::table('students')
+            ->selectRaw('MAX(school_id) AS max_id')
+            ->where('school_id', 'like', "STU{$year}%")
+            ->first();
+
+        if (!empty($row?->max_id)) {
+            $numericPart = substr((string) $row->max_id, 5);
+            $maxId = (int) $numericPart;
+        }
+
+        $nextId = str_pad($maxId + 1, 5, '0', STR_PAD_LEFT);
+
+        return "STU{$year}{$nextId}";
+    }
+
+    public function generateUserSchoolId(): string
+    {
+        $year = date('y');
+        $maxId = 0;
+
+        $row = DB::table('users')
+            ->selectRaw('MAX(school_id) AS max_id')
+            ->where('school_id', 'not like', 'S%')
+            ->where('school_id', 'like', "{$year}%")
+            ->first();
+
+        if (!empty($row?->max_id)) {
+            $numericPart = substr((string) $row->max_id, 2);
+            $maxId = max($maxId, (int) $numericPart);
+        }
+
+        $nextId = str_pad($maxId + 1, 5, '0', STR_PAD_LEFT);
+
+        return "{$year}{$nextId}";
+    }
+}
diff --git a/app/Services/Scores/AttendanceCalculator.php b/app/Services/Scores/AttendanceCalculator.php
new file mode 100644
index 00000000..05579295
--- /dev/null
+++ b/app/Services/Scores/AttendanceCalculator.php
@@ -0,0 +1,146 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Interfaces\ScoreCalculatorInterface;
+use App\Models\AttendanceRecord;
+use App\Models\CalendarEvent;
+use App\Models\Configuration;
+use RuntimeException;
+
+class AttendanceCalculator implements ScoreCalculatorInterface
+{
+    public function __construct(
+        private AttendanceRecord $attendanceModel,
+        private Configuration $configModel,
+        private CalendarEvent $calendarModel
+    ) {
+    }
+
+    public function calculate(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): array
+    {
+        $absences = AttendanceRecord::getTotalAbsences($studentId, $semester, $schoolYear);
+
+        $totalDays = null;
+        $normSemester = $this->normalizeSemester($semester);
+        if ($schoolYear !== '' && $normSemester !== '') {
+            $semRange = $this->getSemesterRange($schoolYear, $normSemester);
+            if ($semRange) {
+                try {
+                    $events = CalendarEvent::getEventsBySchoolYearAndSemester($schoolYear, $normSemester);
+                    $noSchoolSundays = 0;
+                    foreach ($events as $event) {
+                        if (!empty($event['no_school'])) {
+                            $date = new \DateTime($event['date']);
+                            if ($date->format('N') == 7) {
+                                if ($date->format('Y-m-d') >= $semRange[0] && $date->format('Y-m-d') <= $semRange[1]) {
+                                    $noSchoolSundays++;
+                                }
+                            }
+                        }
+                    }
+                    $totalDays = $this->countSundays($semRange[0], $semRange[1]) - $noSchoolSundays;
+                } catch (\Throwable $e) {
+                    $totalDays = null;
+                }
+            }
+        }
+
+        if ($totalDays === null) {
+            $totalDays = $this->getConfiguredSemesterLength($semester);
+        } else {
+            $configuredDays = $this->getConfiguredSemesterLength($semester);
+            if ($configuredDays !== null) {
+                $totalDays = $configuredDays;
+            }
+        }
+
+        if ($totalDays === null || $totalDays < 0) {
+            throw new RuntimeException("Invalid attendance data: could not determine total days for student {$studentId}.");
+        }
+
+        if ($totalDays == 0) {
+            return ['attendance_score' => 100.0];
+        }
+
+        $attendanceRatio = ($totalDays + 1 - $absences) / $totalDays;
+        $score = min(100, max(0, $attendanceRatio * 100));
+
+        return ['attendance_score' => round($score, 2)];
+    }
+
+    protected function normalizeSemester(?string $input): string
+    {
+        $s = strtolower(trim((string) $input));
+        if ($s === 'fall' || str_contains($s, '1')) return 'fall';
+        if ($s === 'spring' || str_contains($s, '2')) return 'spring';
+        return '';
+    }
+
+    protected function getSemesterRange(string $schoolYear, string $semester): ?array
+    {
+        $norm = $this->normalizeSemester($semester);
+        if ($norm === '' || !preg_match('/^(\d{4})-(\d{4})$/', trim($schoolYear), $m)) {
+            if ($norm === '' || !preg_match('/^(\d{4})/', trim($schoolYear), $m)) {
+                return null;
+            }
+            $y1 = (int) $m[1];
+            $y2 = $y1 + 1;
+        } else {
+            $y1 = (int) $m[1];
+            $y2 = (int) $m[2];
+        }
+
+        $fallStartCfg = (string) (Configuration::getConfig('fall_semester_start') ?? '');
+        $fallEndCfg = (string) (Configuration::getConfig('fall_end_date') ?? '');
+        $springStartCfg = (string) (Configuration::getConfig('spring_semester_start') ?? '');
+        $springEndCfg = (string) (Configuration::getConfig('last_school_day') ?? '');
+
+        if ($norm === 'fall') {
+            $start = ($fallStartCfg !== '') ? sprintf('%04d-%s', $y1, date('m-d', strtotime($fallStartCfg))) : "{$y1}-09-01";
+            $end = ($fallEndCfg !== '') ? sprintf('%04d-%s', $y2, date('m-d', strtotime($fallEndCfg))) : "{$y2}-01-15";
+            return [$start, $end];
+        }
+
+        if ($norm === 'spring') {
+            $start = ($springStartCfg !== '') ? sprintf('%04d-%s', $y2, date('m-d', strtotime($springStartCfg))) : "{$y2}-01-16";
+            $end = ($springEndCfg !== '') ? sprintf('%04d-%s', $y2, date('m-d', strtotime($springEndCfg))) : "{$y2}-06-30";
+            return [$start, $end];
+        }
+
+        return null;
+    }
+
+    private function countSundays(string $startDate, string $endDate): int
+    {
+        $start = new \DateTime($startDate);
+        $end = new \DateTime($endDate);
+        $sundays = 0;
+        $interval = new \DateInterval('P1D');
+        $period = new \DatePeriod($start, $interval, $end->modify('+1 day'));
+
+        foreach ($period as $day) {
+            if ($day->format('N') == 7) {
+                $sundays++;
+            }
+        }
+        return $sundays;
+    }
+
+    private function getConfiguredSemesterLength(string $semester): ?int
+    {
+        $norm = $this->normalizeSemester($semester);
+        if ($norm === '') {
+            return null;
+        }
+
+        $configKey = $norm === 'fall' ? 'total_semester1_days' : 'total_semester2_days';
+        $value = Configuration::getConfig($configKey);
+        if (!is_numeric($value)) {
+            return null;
+        }
+
+        $length = (int) $value;
+        return $length > 0 ? $length : null;
+    }
+}
diff --git a/app/Services/Scores/ExamScoreService.php b/app/Services/Scores/ExamScoreService.php
new file mode 100644
index 00000000..06d7d2e4
--- /dev/null
+++ b/app/Services/Scores/ExamScoreService.php
@@ -0,0 +1,129 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Models\GradingLock;
+use App\Models\MissingScoreOverride;
+use App\Models\Student;
+use Illuminate\Support\Facades\DB;
+
+class ExamScoreService
+{
+    public function __construct(private ScoreTermService $term)
+    {
+    }
+
+    public function list(string $table, int $classSectionId, ?string $semester, ?string $schoolYear): array
+    {
+        $semester = $this->term->semesterLabel($semester);
+        $schoolYear = $this->term->schoolYear($schoolYear);
+
+        $latestSub = DB::table($table)
+            ->select('student_id', DB::raw('MAX(id) AS max_id'))
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->groupBy('student_id');
+
+        $rows = DB::table('students as s')
+            ->select([
+                's.id as student_id',
+                's.school_id',
+                's.firstname',
+                's.lastname',
+                'ex.score',
+            ])
+            ->join('student_class as sc', function ($join) use ($classSectionId, $schoolYear) {
+                $join->on('sc.student_id', '=', 's.id')
+                    ->where('sc.class_section_id', '=', $classSectionId)
+                    ->where('sc.school_year', '=', $schoolYear);
+            })
+            ->leftJoinSub($latestSub, 'latest', 'latest.student_id', '=', 's.id')
+            ->leftJoin($table . ' as ex', 'ex.id', '=', 'latest.max_id')
+            ->orderBy('s.lastname')
+            ->orderBy('s.firstname')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        return [
+            'students' => $rows,
+            'semester' => $semester,
+            'schoolYear' => $schoolYear,
+            'scoresLocked' => GradingLock::isLocked($classSectionId, $semester, $schoolYear),
+            'missingOkMap' => MissingScoreOverride::getOverridesMap(
+                $classSectionId,
+                $semester,
+                $schoolYear,
+                $table === 'midterm_exam' ? 'midterm_exam' : 'final_exam'
+            ),
+        ];
+    }
+
+    public function update(string $table, int $classSectionId, string $semester, string $schoolYear, array $scores, array $missingOk, int $updatedBy): int
+    {
+        if (GradingLock::isLocked($classSectionId, $semester, $schoolYear)) {
+            throw new \RuntimeException('Scores are locked for this class.');
+        }
+
+        $studentIds = array_keys($scores);
+        $checkedItems = [];
+        foreach ($missingOk as $studentId => $flags) {
+            $checkedItems[] = [
+                'student_id' => (int) $studentId,
+                'item_index' => null,
+            ];
+        }
+
+        MissingScoreOverride::replaceOverrides(
+            $classSectionId,
+            $semester,
+            $schoolYear,
+            $table === 'midterm_exam' ? 'midterm_exam' : 'final_exam',
+            $studentIds,
+            null,
+            $checkedItems,
+            $updatedBy,
+            true
+        );
+
+        $builder = DB::table($table);
+        $count = 0;
+
+        foreach ($scores as $studentId => $data) {
+            if (!is_numeric($studentId)) {
+                continue;
+            }
+            $rawScore = $data['score'] ?? null;
+            $normalizedScore = is_numeric($rawScore) ? (float) $rawScore : null;
+
+            $existing = $builder
+                ->where('student_id', $studentId)
+                ->where('class_section_id', $classSectionId)
+                ->where('semester', $semester)
+                ->where('school_year', $schoolYear)
+                ->first();
+
+            $payload = [
+                'student_id' => (int) $studentId,
+                'class_section_id' => $classSectionId,
+                'updated_by' => $updatedBy,
+                'score' => $normalizedScore,
+                'semester' => $semester,
+                'school_year' => $schoolYear,
+                'updated_at' => now(),
+            ];
+
+            if ($existing) {
+                $builder->where('id', $existing->id)->update($payload);
+            } else {
+                $payload['created_at'] = now();
+                $builder->insert($payload);
+            }
+
+            $count++;
+        }
+
+        return $count;
+    }
+}
diff --git a/app/Services/Scores/HomeworkCalculator.php b/app/Services/Scores/HomeworkCalculator.php
new file mode 100644
index 00000000..96a63d1d
--- /dev/null
+++ b/app/Services/Scores/HomeworkCalculator.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Interfaces\ScoreCalculatorInterface;
+use App\Models\Homework;
+
+class HomeworkCalculator implements ScoreCalculatorInterface
+{
+    public function __construct(private Homework $homeworkModel)
+    {
+    }
+
+    public function calculate(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): array
+    {
+        $average = Homework::getAverageHomeworkScore($studentId, $semester, $schoolYear, $classSectionId);
+        return ['homework_avg' => $average !== null ? (float) $average : null];
+    }
+}
diff --git a/app/Services/Scores/HomeworkScoreService.php b/app/Services/Scores/HomeworkScoreService.php
new file mode 100644
index 00000000..36590fd8
--- /dev/null
+++ b/app/Services/Scores/HomeworkScoreService.php
@@ -0,0 +1,226 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Models\GradingLock;
+use App\Models\Homework;
+use App\Models\MissingScoreOverride;
+use App\Models\Student;
+use App\Models\StudentClass;
+
+class HomeworkScoreService
+{
+    public function __construct(private ScoreTermService $term)
+    {
+    }
+
+    public function list(int $classSectionId, ?string $semester, ?string $schoolYear): array
+    {
+        $semester = $this->term->semesterLabel($semester);
+        $schoolYear = $this->term->schoolYear($schoolYear);
+        $semVariants = $this->term->semesterVariants($semester);
+
+        $headerRows = Homework::query()
+            ->select('homework_index')
+            ->where('class_section_id', $classSectionId)
+            ->whereIn('semester', $semVariants)
+            ->where('school_year', $schoolYear)
+            ->orderBy('homework_index')
+            ->get();
+
+        $headers = $headerRows->pluck('homework_index')->map(fn ($v) => (int) $v)->unique()->values()->all();
+
+        $studentIds = StudentClass::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('school_year', $schoolYear)
+            ->pluck('student_id')
+            ->map(fn ($v) => (int) $v)
+            ->all();
+
+        $students = Student::query()
+            ->whereIn('id', $studentIds)
+            ->where('is_active', 1)
+            ->orderBy('lastname')
+            ->orderBy('firstname')
+            ->get()
+            ->map(fn ($row) => [
+                'student_id' => (int) $row->id,
+                'firstname' => (string) $row->firstname,
+                'lastname' => (string) $row->lastname,
+                'scores' => [],
+            ])
+            ->all();
+
+        $scoresRows = Homework::query()
+            ->select('student_id', 'homework_index', 'score')
+            ->where('class_section_id', $classSectionId)
+            ->whereIn('semester', $semVariants)
+            ->where('school_year', $schoolYear)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $scoresMap = [];
+        foreach ($scoresRows as $row) {
+            $scoresMap[(int) $row['student_id']][(int) $row['homework_index']] = $row['score'];
+        }
+
+        foreach ($students as &$student) {
+            foreach ($headers as $index) {
+                $student['scores'][(int) $index] = $scoresMap[$student['student_id']][$index] ?? '';
+            }
+        }
+        unset($student);
+
+        return [
+            'students' => $students,
+            'headers' => $headers,
+            'semester' => $semester,
+            'schoolYear' => $schoolYear,
+            'scoresLocked' => GradingLock::isLocked($classSectionId, $semester, $schoolYear),
+            'missingOkMap' => MissingScoreOverride::getOverridesMap($classSectionId, $semester, $schoolYear, 'homework'),
+        ];
+    }
+
+    public function update(int $classSectionId, string $semester, string $schoolYear, array $scores, array $missingOk, int $updatedBy): int
+    {
+        if (GradingLock::isLocked($classSectionId, $semester, $schoolYear)) {
+            throw new \RuntimeException('Scores are locked for this class.');
+        }
+
+        $studentIds = array_keys($scores);
+        $indexSet = [];
+        foreach ($scores as $hwData) {
+            if (!is_array($hwData)) {
+                continue;
+            }
+            foreach ($hwData as $index => $_) {
+                if (is_numeric($index)) {
+                    $indexSet[(int) $index] = true;
+                }
+            }
+        }
+
+        $checkedItems = [];
+        foreach ($missingOk as $studentId => $indexes) {
+            if (!is_array($indexes)) {
+                continue;
+            }
+            foreach ($indexes as $index => $flag) {
+                if (!is_numeric($index)) {
+                    continue;
+                }
+                $checkedItems[] = [
+                    'student_id' => (int) $studentId,
+                    'item_index' => (int) $index,
+                ];
+            }
+        }
+
+        MissingScoreOverride::replaceOverrides(
+            $classSectionId,
+            $semester,
+            $schoolYear,
+            'homework',
+            $studentIds,
+            array_keys($indexSet),
+            $checkedItems,
+            $updatedBy
+        );
+
+        $count = 0;
+        foreach ($scores as $studentId => $hwData) {
+            if (!is_numeric($studentId) || !is_array($hwData)) {
+                continue;
+            }
+            $student = Student::query()->find((int) $studentId);
+            if (!$student) {
+                continue;
+            }
+
+            foreach ($hwData as $index => $score) {
+                if (!is_numeric($index)) {
+                    continue;
+                }
+                $rawScore = $score ?? null;
+                $isBlank = $rawScore === null || (is_string($rawScore) && trim($rawScore) === '');
+                $normalizedScore = (!$isBlank && is_numeric($rawScore)) ? (float) $rawScore : null;
+
+                $existing = Homework::query()
+                    ->where('student_id', $studentId)
+                    ->where('homework_index', $index)
+                    ->where('class_section_id', $classSectionId)
+                    ->where('semester', $semester)
+                    ->where('school_year', $schoolYear)
+                    ->first();
+
+                $payload = [
+                    'student_id' => (int) $studentId,
+                    'school_id' => $student->school_id ?? null,
+                    'class_section_id' => $classSectionId,
+                    'updated_by' => $updatedBy,
+                    'homework_index' => (int) $index,
+                    'score' => $normalizedScore,
+                    'semester' => $semester,
+                    'school_year' => $schoolYear,
+                    'updated_at' => now(),
+                ];
+
+                if ($existing) {
+                    $existing->update($payload);
+                } else {
+                    $payload['created_at'] = now();
+                    Homework::query()->create($payload);
+                }
+                $count++;
+            }
+        }
+
+        return $count;
+    }
+
+    public function addColumn(int $classSectionId, string $semester, string $schoolYear, int $updatedBy): int
+    {
+        $semVariants = $this->term->semesterVariants($semester);
+        $maxIndex = (int) Homework::query()
+            ->where('class_section_id', $classSectionId)
+            ->whereIn('semester', $semVariants)
+            ->where('school_year', $schoolYear)
+            ->max('homework_index');
+
+        $nextIndex = $maxIndex + 1;
+
+        $students = StudentClass::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('school_year', $schoolYear)
+            ->get();
+
+        foreach ($students as $student) {
+            $exists = Homework::query()
+                ->where('student_id', $student->student_id)
+                ->where('homework_index', $nextIndex)
+                ->where('class_section_id', $classSectionId)
+                ->whereIn('semester', $semVariants)
+                ->where('school_year', $schoolYear)
+                ->first();
+
+            if ($exists) {
+                continue;
+            }
+
+            Homework::query()->create([
+                'student_id' => (int) $student->student_id,
+                'class_section_id' => $classSectionId,
+                'updated_by' => $updatedBy,
+                'homework_index' => $nextIndex,
+                'score' => null,
+                'semester' => $semester,
+                'school_year' => $schoolYear,
+                'created_at' => now(),
+                'updated_at' => now(),
+            ]);
+        }
+
+        return $nextIndex;
+    }
+}
diff --git a/app/Services/Scores/ParticipationScoreService.php b/app/Services/Scores/ParticipationScoreService.php
new file mode 100644
index 00000000..e474a15a
--- /dev/null
+++ b/app/Services/Scores/ParticipationScoreService.php
@@ -0,0 +1,146 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Models\GradingLock;
+use App\Models\MissingScoreOverride;
+use App\Models\Participation;
+use App\Models\Student;
+use App\Models\StudentClass;
+
+class ParticipationScoreService
+{
+    public function __construct(private ScoreTermService $term)
+    {
+    }
+
+    public function list(int $classSectionId, ?string $semester, ?string $schoolYear): array
+    {
+        $semester = $this->term->semesterLabel($semester);
+        $schoolYear = $this->term->schoolYear($schoolYear);
+
+        $studentIds = StudentClass::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('school_year', $schoolYear)
+            ->pluck('student_id')
+            ->map(fn ($v) => (int) $v)
+            ->all();
+
+        $students = Student::query()
+            ->whereIn('id', $studentIds)
+            ->where('is_active', 1)
+            ->orderBy('lastname')
+            ->orderBy('firstname')
+            ->get()
+            ->map(fn ($row) => [
+                'student_id' => (int) $row->id,
+                'school_id' => $row->school_id,
+                'firstname' => (string) $row->firstname,
+                'lastname' => (string) $row->lastname,
+                'scores' => [],
+            ])
+            ->all();
+
+        $scoresRows = Participation::query()
+            ->select('student_id', 'score')
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->get();
+
+        $scoreMap = [];
+        foreach ($scoresRows as $row) {
+            $scoreMap[(int) $row->student_id] = $row->score;
+        }
+
+        foreach ($students as &$student) {
+            $student['scores'] = [
+                'score' => $scoreMap[$student['student_id']] ?? '',
+            ];
+        }
+        unset($student);
+
+        return [
+            'students' => $students,
+            'semester' => $semester,
+            'schoolYear' => $schoolYear,
+            'scoresLocked' => GradingLock::isLocked($classSectionId, $semester, $schoolYear),
+            'missingOkMap' => MissingScoreOverride::getOverridesMap($classSectionId, $semester, $schoolYear, 'participation'),
+        ];
+    }
+
+    public function update(int $classSectionId, string $semester, string $schoolYear, array $scores, array $missingOk, int $updatedBy): int
+    {
+        if (GradingLock::isLocked($classSectionId, $semester, $schoolYear)) {
+            throw new \RuntimeException('Scores are locked for this class.');
+        }
+
+        $studentIds = array_keys($scores);
+        $checkedItems = [];
+        foreach ($missingOk as $studentId => $flags) {
+            $checkedItems[] = [
+                'student_id' => (int) $studentId,
+                'item_index' => null,
+            ];
+        }
+
+        MissingScoreOverride::replaceOverrides(
+            $classSectionId,
+            $semester,
+            $schoolYear,
+            'participation',
+            $studentIds,
+            null,
+            $checkedItems,
+            $updatedBy,
+            true
+        );
+
+        $count = 0;
+        foreach ($scores as $studentId => $data) {
+            if (!is_numeric($studentId)) {
+                continue;
+            }
+            if (!is_array($data)) {
+                $data = ['score' => $data];
+            }
+
+            $student = Student::query()->find((int) $studentId);
+            if (!$student) {
+                continue;
+            }
+
+            $rawScore = $data['score'] ?? null;
+            $isBlank = $rawScore === null || (is_string($rawScore) && trim($rawScore) === '');
+            $normalizedScore = (!$isBlank && is_numeric($rawScore)) ? (float) $rawScore : null;
+
+            $existing = Participation::query()
+                ->where('student_id', $studentId)
+                ->where('class_section_id', $classSectionId)
+                ->where('semester', $semester)
+                ->where('school_year', $schoolYear)
+                ->first();
+
+            $payload = [
+                'student_id' => (int) $studentId,
+                'school_id' => $student->school_id,
+                'class_section_id' => $classSectionId,
+                'updated_by' => $updatedBy,
+                'score' => $normalizedScore,
+                'semester' => $semester,
+                'school_year' => $schoolYear,
+                'updated_at' => now(),
+            ];
+
+            if ($existing) {
+                $existing->update($payload);
+            } else {
+                $payload['created_at'] = now();
+                Participation::query()->create($payload);
+            }
+            $count++;
+        }
+
+        return $count;
+    }
+}
diff --git a/app/Services/Scores/ProjectCalculator.php b/app/Services/Scores/ProjectCalculator.php
new file mode 100644
index 00000000..b4c4da27
--- /dev/null
+++ b/app/Services/Scores/ProjectCalculator.php
@@ -0,0 +1,19 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Interfaces\ScoreCalculatorInterface;
+use App\Models\Project;
+
+class ProjectCalculator implements ScoreCalculatorInterface
+{
+    public function __construct(private Project $projectModel)
+    {
+    }
+
+    public function calculate(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): array
+    {
+        $average = Project::averageScore($studentId, $semester, $schoolYear, $classSectionId);
+        return ['project_avg' => $average !== null ? (float) $average : null];
+    }
+}
diff --git a/app/Services/Scores/ProjectScoreService.php b/app/Services/Scores/ProjectScoreService.php
new file mode 100644
index 00000000..85b43a2d
--- /dev/null
+++ b/app/Services/Scores/ProjectScoreService.php
@@ -0,0 +1,223 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Models\GradingLock;
+use App\Models\MissingScoreOverride;
+use App\Models\Project;
+use App\Models\Student;
+use App\Models\StudentClass;
+use Illuminate\Support\Facades\DB;
+
+class ProjectScoreService
+{
+    public function __construct(private ScoreTermService $term)
+    {
+    }
+
+    public function list(int $classSectionId, ?string $semester, ?string $schoolYear): array
+    {
+        $semester = $this->term->semesterLabel($semester);
+        $schoolYear = $this->term->schoolYear($schoolYear);
+
+        $headerRows = Project::query()
+            ->select('project_index')
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->orderBy('project_index')
+            ->get();
+
+        $headers = $headerRows->pluck('project_index')->map(fn ($v) => (int) $v)->unique()->values()->all();
+
+        $studentIds = StudentClass::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('school_year', $schoolYear)
+            ->pluck('student_id')
+            ->map(fn ($v) => (int) $v)
+            ->all();
+
+        $students = Student::query()
+            ->whereIn('id', $studentIds)
+            ->where('is_active', 1)
+            ->orderBy('lastname')
+            ->orderBy('firstname')
+            ->get()
+            ->map(fn ($row) => [
+                'student_id' => (int) $row->id,
+                'firstname' => (string) $row->firstname,
+                'lastname' => (string) $row->lastname,
+                'scores' => [],
+            ])
+            ->all();
+
+        $scoresRows = Project::query()
+            ->select('student_id', 'project_index', 'score')
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $scoresMap = [];
+        foreach ($scoresRows as $row) {
+            $scoresMap[(int) $row['student_id']][(int) $row['project_index']] = $row['score'];
+        }
+
+        foreach ($students as &$student) {
+            foreach ($headers as $index) {
+                $student['scores'][(int) $index] = $scoresMap[$student['student_id']][$index] ?? '';
+            }
+        }
+        unset($student);
+
+        return [
+            'students' => $students,
+            'headers' => $headers,
+            'semester' => $semester,
+            'schoolYear' => $schoolYear,
+            'scoresLocked' => GradingLock::isLocked($classSectionId, $semester, $schoolYear),
+            'missingOkMap' => MissingScoreOverride::getOverridesMap($classSectionId, $semester, $schoolYear, 'project'),
+        ];
+    }
+
+    public function update(int $classSectionId, string $semester, string $schoolYear, array $scores, array $missingOk, int $updatedBy): int
+    {
+        if (GradingLock::isLocked($classSectionId, $semester, $schoolYear)) {
+            throw new \RuntimeException('Scores are locked for this class.');
+        }
+
+        $studentIds = array_keys($scores);
+        $indexSet = [];
+        foreach ($scores as $projects) {
+            if (!is_array($projects)) {
+                continue;
+            }
+            foreach ($projects as $index => $_) {
+                if (is_numeric($index)) {
+                    $indexSet[(int) $index] = true;
+                }
+            }
+        }
+
+        $checkedItems = [];
+        foreach ($missingOk as $studentId => $indexes) {
+            if (!is_array($indexes)) {
+                continue;
+            }
+            foreach ($indexes as $index => $flag) {
+                if (!is_numeric($index)) {
+                    continue;
+                }
+                $checkedItems[] = [
+                    'student_id' => (int) $studentId,
+                    'item_index' => (int) $index,
+                ];
+            }
+        }
+
+        MissingScoreOverride::replaceOverrides(
+            $classSectionId,
+            $semester,
+            $schoolYear,
+            'project',
+            $studentIds,
+            array_keys($indexSet),
+            $checkedItems,
+            $updatedBy
+        );
+
+        $count = 0;
+        foreach ($scores as $studentId => $projects) {
+            if (!is_numeric($studentId) || !is_array($projects)) {
+                continue;
+            }
+            $student = Student::query()->find((int) $studentId);
+            if (!$student) {
+                continue;
+            }
+
+            foreach ($projects as $index => $score) {
+                if (!is_numeric($index)) {
+                    continue;
+                }
+                $normalizedScore = is_numeric($score) ? (float) $score : null;
+
+                $existing = Project::query()
+                    ->where('student_id', $studentId)
+                    ->where('project_index', $index)
+                    ->where('class_section_id', $classSectionId)
+                    ->where('semester', $semester)
+                    ->where('school_year', $schoolYear)
+                    ->first();
+
+                $payload = [
+                    'student_id' => (int) $studentId,
+                    'school_id' => $student->school_id,
+                    'class_section_id' => $classSectionId,
+                    'updated_by' => $updatedBy,
+                    'project_index' => (int) $index,
+                    'score' => $normalizedScore,
+                    'semester' => $semester,
+                    'school_year' => $schoolYear,
+                    'updated_at' => now(),
+                ];
+
+                if ($existing) {
+                    $existing->update($payload);
+                } else {
+                    $payload['created_at'] = now();
+                    Project::query()->create($payload);
+                }
+                $count++;
+            }
+        }
+
+        return $count;
+    }
+
+    public function addColumn(int $classSectionId, string $semester, string $schoolYear, int $updatedBy): int
+    {
+        $maxIndex = (int) Project::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->max('project_index');
+
+        $nextIndex = $maxIndex + 1;
+
+        $students = StudentClass::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('school_year', $schoolYear)
+            ->get();
+
+        foreach ($students as $student) {
+            $exists = Project::query()
+                ->where('student_id', $student->student_id)
+                ->where('project_index', $nextIndex)
+                ->where('class_section_id', $classSectionId)
+                ->where('semester', $semester)
+                ->where('school_year', $schoolYear)
+                ->first();
+
+            if ($exists) {
+                continue;
+            }
+
+            Project::query()->create([
+                'student_id' => (int) $student->student_id,
+                'class_section_id' => $classSectionId,
+                'updated_by' => $updatedBy,
+                'project_index' => $nextIndex,
+                'score' => null,
+                'semester' => $semester,
+                'school_year' => $schoolYear,
+                'created_at' => now(),
+                'updated_at' => now(),
+            ]);
+        }
+
+        return $nextIndex;
+    }
+}
diff --git a/app/Services/Scores/QuizCalculator.php b/app/Services/Scores/QuizCalculator.php
new file mode 100644
index 00000000..63708f75
--- /dev/null
+++ b/app/Services/Scores/QuizCalculator.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Interfaces\ScoreCalculatorInterface;
+use Illuminate\Support\Facades\DB;
+
+class QuizCalculator implements ScoreCalculatorInterface
+{
+    public function calculate(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): array
+    {
+        $q = DB::table('quiz')
+            ->select('score')
+            ->where('student_id', $studentId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear);
+
+        if ($classSectionId !== null) {
+            $q->where('class_section_id', $classSectionId);
+        }
+
+        $rows = $q->get();
+        $total = 0.0;
+        $count = 0;
+        foreach ($rows as $row) {
+            $score = $row->score ?? null;
+            if ($score === null || $score === '' || !is_numeric($score)) {
+                continue;
+            }
+            $total += (float) $score;
+            $count++;
+        }
+
+        $avg = $count > 0 ? round($total / $count, 2) : null;
+
+        return ['quiz_avg' => $avg !== null ? (float) $avg : null];
+    }
+}
diff --git a/app/Services/Scores/QuizScoreService.php b/app/Services/Scores/QuizScoreService.php
new file mode 100644
index 00000000..16989e3f
--- /dev/null
+++ b/app/Services/Scores/QuizScoreService.php
@@ -0,0 +1,220 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Models\GradingLock;
+use App\Models\MissingScoreOverride;
+use App\Models\Quiz;
+use App\Models\Student;
+use App\Models\StudentClass;
+
+class QuizScoreService
+{
+    public function __construct(private ScoreTermService $term)
+    {
+    }
+
+    public function list(int $classSectionId, ?string $semester, ?string $schoolYear): array
+    {
+        $semester = $this->term->semesterLabel($semester);
+        $schoolYear = $this->term->schoolYear($schoolYear);
+
+        $headerRows = Quiz::query()
+            ->select('quiz_index')
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->orderBy('quiz_index')
+            ->get();
+
+        $headers = $headerRows->pluck('quiz_index')->map(fn ($v) => (int) $v)->unique()->values()->all();
+
+        $studentIds = StudentClass::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('school_year', $schoolYear)
+            ->pluck('student_id')
+            ->map(fn ($v) => (int) $v)
+            ->all();
+
+        $students = Student::query()
+            ->whereIn('id', $studentIds)
+            ->where('is_active', 1)
+            ->orderBy('lastname')
+            ->orderBy('firstname')
+            ->get()
+            ->map(fn ($row) => [
+                'student_id' => (int) $row->id,
+                'firstname' => (string) $row->firstname,
+                'lastname' => (string) $row->lastname,
+                'scores' => [],
+            ])
+            ->all();
+
+        $scoresRows = Quiz::query()
+            ->select('student_id', 'quiz_index', 'score')
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $scoresMap = [];
+        foreach ($scoresRows as $row) {
+            $scoresMap[(int) $row['student_id']][(int) $row['quiz_index']] = $row['score'];
+        }
+
+        foreach ($students as &$student) {
+            foreach ($headers as $index) {
+                $student['scores'][(int) $index] = $scoresMap[$student['student_id']][$index] ?? '';
+            }
+        }
+        unset($student);
+
+        return [
+            'students' => $students,
+            'headers' => $headers,
+            'semester' => $semester,
+            'schoolYear' => $schoolYear,
+            'scoresLocked' => GradingLock::isLocked($classSectionId, $semester, $schoolYear),
+            'missingOkMap' => MissingScoreOverride::getOverridesMap($classSectionId, $semester, $schoolYear, 'quiz'),
+        ];
+    }
+
+    public function update(int $classSectionId, string $semester, string $schoolYear, array $scores, array $missingOk, int $updatedBy): int
+    {
+        if (GradingLock::isLocked($classSectionId, $semester, $schoolYear)) {
+            throw new \RuntimeException('Scores are locked for this class.');
+        }
+
+        $studentIds = array_keys($scores);
+        $indexSet = [];
+        foreach ($scores as $quizData) {
+            if (!is_array($quizData)) {
+                continue;
+            }
+            foreach ($quizData as $index => $_) {
+                if (is_numeric($index)) {
+                    $indexSet[(int) $index] = true;
+                }
+            }
+        }
+
+        $checkedItems = [];
+        foreach ($missingOk as $studentId => $indexes) {
+            if (!is_array($indexes)) {
+                continue;
+            }
+            foreach ($indexes as $index => $flag) {
+                if (!is_numeric($index)) {
+                    continue;
+                }
+                $checkedItems[] = [
+                    'student_id' => (int) $studentId,
+                    'item_index' => (int) $index,
+                ];
+            }
+        }
+
+        MissingScoreOverride::replaceOverrides(
+            $classSectionId,
+            $semester,
+            $schoolYear,
+            'quiz',
+            $studentIds,
+            array_keys($indexSet),
+            $checkedItems,
+            $updatedBy
+        );
+
+        $count = 0;
+        foreach ($scores as $studentId => $quizData) {
+            if (!is_numeric($studentId)) {
+                continue;
+            }
+            if (!is_array($quizData)) {
+                $quizData = [1 => $quizData];
+            }
+            foreach ($quizData as $quizNumber => $score) {
+                if (!is_numeric($quizNumber)) {
+                    continue;
+                }
+                $isBlank = $score === null || (is_string($score) && trim($score) === '');
+                $normalizedScore = (!$isBlank && is_numeric($score)) ? (float) $score : null;
+
+                $existing = Quiz::query()
+                    ->where('student_id', $studentId)
+                    ->where('quiz_index', $quizNumber)
+                    ->where('class_section_id', $classSectionId)
+                    ->where('semester', $semester)
+                    ->where('school_year', $schoolYear)
+                    ->first();
+
+                $payload = [
+                    'student_id' => (int) $studentId,
+                    'class_section_id' => $classSectionId,
+                    'updated_by' => $updatedBy,
+                    'quiz_index' => (int) $quizNumber,
+                    'score' => $normalizedScore,
+                    'semester' => $semester,
+                    'school_year' => $schoolYear,
+                    'updated_at' => now(),
+                ];
+
+                if ($existing) {
+                    $existing->update($payload);
+                } else {
+                    $payload['created_at'] = now();
+                    Quiz::query()->create($payload);
+                }
+                $count++;
+            }
+        }
+
+        return $count;
+    }
+
+    public function addColumn(int $classSectionId, string $semester, string $schoolYear, int $updatedBy): int
+    {
+        $maxIndex = (int) Quiz::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semester)
+            ->where('school_year', $schoolYear)
+            ->max('quiz_index');
+
+        $nextIndex = $maxIndex + 1;
+
+        $students = StudentClass::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('school_year', $schoolYear)
+            ->get();
+
+        foreach ($students as $student) {
+            $exists = Quiz::query()
+                ->where('student_id', $student->student_id)
+                ->where('quiz_index', $nextIndex)
+                ->where('class_section_id', $classSectionId)
+                ->where('semester', $semester)
+                ->where('school_year', $schoolYear)
+                ->first();
+
+            if ($exists) {
+                continue;
+            }
+
+            Quiz::query()->create([
+                'student_id' => (int) $student->student_id,
+                'class_section_id' => $classSectionId,
+                'updated_by' => $updatedBy,
+                'quiz_index' => $nextIndex,
+                'score' => null,
+                'semester' => $semester,
+                'school_year' => $schoolYear,
+                'created_at' => now(),
+                'updated_at' => now(),
+            ]);
+        }
+
+        return $nextIndex;
+    }
+}
diff --git a/app/Services/Scores/ScoreCommentService.php b/app/Services/Scores/ScoreCommentService.php
new file mode 100644
index 00000000..b4a91cf8
--- /dev/null
+++ b/app/Services/Scores/ScoreCommentService.php
@@ -0,0 +1,340 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Models\Configuration;
+use App\Models\GradingLock;
+use App\Models\MissingScoreOverride;
+use App\Models\ScoreComment;
+use App\Models\SemesterScore;
+use App\Models\Student;
+use App\Models\StudentClass;
+use Illuminate\Support\Facades\DB;
+
+class ScoreCommentService
+{
+    public function __construct(private ScoreTermService $term)
+    {
+    }
+
+    public function list(?string $classSectionId, ?string $semester, ?string $schoolYear): array
+    {
+        $schoolYear = $this->term->schoolYear($schoolYear);
+        $activeSemester = $this->term->semesterLabel($semester);
+        $isAllSections = is_string($classSectionId) && strtolower(trim($classSectionId)) === 'allsections';
+        $classSectionInt = $isAllSections ? null : (int) ($classSectionId ?? 0);
+
+        $builder = DB::table('student_class as sc')
+            ->select('s.id as student_id', 's.firstname', 's.lastname', 's.school_id')
+            ->join('students as s', 's.id', '=', 'sc.student_id')
+            ->where('sc.school_year', $schoolYear)
+            ->orderBy('s.lastname')
+            ->orderBy('s.firstname')
+            ->distinct();
+
+        if (!$isAllSections && $classSectionInt) {
+            $builder->where('sc.class_section_id', $classSectionInt);
+        }
+
+        $students = $builder->get()->map(fn ($row) => (array) $row)->all();
+
+        $comments = [];
+        if (!empty($students)) {
+            $studentIds = array_map(static fn ($r) => (int) $r['student_id'], $students);
+            $rawComments = ScoreComment::query()
+                ->whereIn('student_id', $studentIds)
+                ->whereIn('score_type', ['midterm', 'final', 'ptap', 'attendance'])
+                ->where('semester', $activeSemester)
+                ->where('school_year', $schoolYear)
+                ->when(!$isAllSections && $classSectionInt, function ($q) use ($classSectionInt) {
+                    $q->where(function ($w) use ($classSectionInt) {
+                        $w->where('class_section_id', $classSectionInt)
+                          ->orWhereNull('class_section_id');
+                    });
+                })
+                ->get();
+
+            foreach ($rawComments as $comment) {
+                $sid = (int) $comment->student_id;
+                $typ = (string) $comment->score_type;
+                $comments[$sid][$typ] = [
+                    'comment' => $comment->comment,
+                    'comment_review' => $comment->comment_review,
+                    'commented_by' => $comment->commented_by,
+                    'reviewed_by' => $comment->reviewed_by,
+                ];
+            }
+
+            $attendanceScores = [];
+            $scoreRows = SemesterScore::query()
+                ->select(['student_id', 'attendance_score'])
+                ->whereIn('student_id', $studentIds)
+                ->where('semester', $activeSemester)
+                ->where('school_year', $schoolYear)
+                ->get();
+
+            foreach ($scoreRows as $row) {
+                $attendanceScores[(int) $row->student_id] = $row->attendance_score !== null
+                    ? (float) $row->attendance_score
+                    : null;
+            }
+
+            foreach ($students as $student) {
+                $sid = (int) $student['student_id'];
+                $hasComment = isset($comments[$sid]['attendance']['comment'])
+                    && trim((string) $comments[$sid]['attendance']['comment']) !== '';
+                if ($hasComment) {
+                    continue;
+                }
+                if (!function_exists('attendance_comment_from_score')) {
+                    continue;
+                }
+                $score = $attendanceScores[$sid] ?? null;
+                if ($score === null) {
+                    continue;
+                }
+                $auto = attendance_comment_from_score($score, $student['firstname'] ?? '');
+                if ($auto !== null) {
+                    $comments[$sid]['attendance'] = [
+                        'comment' => $auto,
+                        'comment_review' => $comments[$sid]['attendance']['comment_review'] ?? null,
+                        'commented_by' => $comments[$sid]['attendance']['commented_by'] ?? null,
+                        'reviewed_by' => $comments[$sid]['attendance']['reviewed_by'] ?? null,
+                    ];
+                }
+            }
+        }
+
+        return [
+            'students' => $students,
+            'comments' => $comments,
+            'semester' => $activeSemester,
+            'schoolYear' => $schoolYear,
+            'classSectionId' => $isAllSections ? 'allsections' : $classSectionInt,
+            'scoresLocked' => (!$isAllSections && $classSectionInt)
+                ? GradingLock::isLocked($classSectionInt, $activeSemester, $schoolYear)
+                : false,
+        ];
+    }
+
+    public function save(int $classSectionId, string $semester, string $schoolYear, array $comments, array $missingOk, int $teacherId): array
+    {
+        if (GradingLock::isLocked($classSectionId, $semester, $schoolYear)) {
+            throw new \RuntimeException('Scores are locked for this class.');
+        }
+
+        $studentIds = array_map('intval', array_keys($comments));
+        $studentNames = $this->getStudentFirstNames($studentIds);
+
+        $isFall = strtolower($semester) === 'fall';
+        $isSpring = strtolower($semester) === 'spring';
+        $commentTypes = ['ptap_comment'];
+        if ($isFall) {
+            $commentTypes[] = 'midterm_comment';
+        }
+        if ($isSpring) {
+            $commentTypes[] = 'final_comment';
+        }
+
+        foreach ($commentTypes as $type) {
+            $checkedItems = [];
+            foreach ($missingOk as $studentId => $types) {
+                if (!is_array($types) || empty($types[$type])) {
+                    continue;
+                }
+                $checkedItems[] = [
+                    'student_id' => (int) $studentId,
+                    'item_index' => null,
+                ];
+            }
+            MissingScoreOverride::replaceOverrides(
+                $classSectionId,
+                $semester,
+                $schoolYear,
+                $type,
+                $studentIds,
+                null,
+                $checkedItems,
+                $teacherId,
+                true
+            );
+        }
+
+        $errors = [];
+        foreach ($comments as $studentId => $commentTypes) {
+            foreach ($commentTypes as $scoreType => $comment) {
+                $normalizedScoreType = strtolower((string) $scoreType);
+                $trimmedComment = trim((string) $comment);
+                if ($trimmedComment === '') {
+                    continue;
+                }
+                $validationError = $this->validateComment($trimmedComment, (int) $studentId, $normalizedScoreType, $studentNames);
+                if ($validationError !== null) {
+                    $errors[] = $validationError;
+                    continue;
+                }
+
+                $existing = ScoreComment::query()
+                    ->where('student_id', $studentId)
+                    ->where('score_type', $normalizedScoreType)
+                    ->where('semester', $semester)
+                    ->where('school_year', $schoolYear)
+                    ->where(function ($q) use ($classSectionId) {
+                        $q->where('class_section_id', $classSectionId)
+                          ->orWhereNull('class_section_id');
+                    })
+                    ->first();
+
+                $data = [
+                    'student_id' => $studentId,
+                    'class_section_id' => $classSectionId,
+                    'score_type' => $normalizedScoreType,
+                    'semester' => $semester,
+                    'school_year' => $schoolYear,
+                    'comment' => $trimmedComment,
+                    'commented_by' => $teacherId,
+                    'created_at' => now(),
+                ];
+
+                if ($existing) {
+                    $existing->update($data);
+                } else {
+                    ScoreComment::query()->create($data);
+                }
+            }
+        }
+
+        return ['errors' => $errors];
+    }
+
+    public function update(int $classSectionId, string $semester, string $schoolYear, array $comments, array $reviews, int $teacherId): array
+    {
+        if (GradingLock::isLocked($classSectionId, $semester, $schoolYear)) {
+            throw new \RuntimeException('Scores are locked for this class.');
+        }
+
+        $studentIds = array_unique(array_map('intval', array_merge(array_keys($comments), array_keys($reviews))));
+        $studentNames = $this->getStudentFirstNames($studentIds);
+        $isReviewer = $this->isReviewer();
+
+        $errors = [];
+        foreach ($comments as $studentId => $types) {
+            foreach ($types as $scoreType => $commentText) {
+                $normalizedScoreType = strtolower((string) $scoreType);
+                $commentText = trim((string) $commentText);
+
+                $reviewText = isset($reviews[$studentId][$scoreType])
+                    ? trim((string) $reviews[$studentId][$scoreType])
+                    : '';
+
+                if ($commentText === '' && $reviewText === '') {
+                    continue;
+                }
+
+                if ($commentText !== '') {
+                    $validationError = $this->validateComment($commentText, (int) $studentId, $normalizedScoreType, $studentNames);
+                    if ($validationError !== null) {
+                        $errors[] = $validationError;
+                        continue;
+                    }
+                }
+
+                $existing = ScoreComment::query()
+                    ->where('student_id', $studentId)
+                    ->where('score_type', $normalizedScoreType)
+                    ->where('semester', $semester)
+                    ->where('school_year', $schoolYear)
+                    ->where(function ($q) use ($classSectionId) {
+                        $q->where('class_section_id', $classSectionId)
+                          ->orWhereNull('class_section_id');
+                    })
+                    ->first();
+
+                $data = [
+                    'comment' => $commentText === '' ? null : $commentText,
+                    'commented_by' => $teacherId,
+                    'class_section_id' => $classSectionId,
+                ];
+
+                if ($isReviewer && $reviewText !== '') {
+                    $data['comment_review'] = $reviewText;
+                    $data['reviewed_by'] = $teacherId;
+                }
+
+                if ($existing) {
+                    $existing->update($data);
+                } else {
+                    ScoreComment::query()->create(array_merge([
+                        'student_id' => $studentId,
+                        'score_type' => $normalizedScoreType,
+                        'semester' => $semester,
+                        'school_year' => $schoolYear,
+                        'class_section_id' => $classSectionId,
+                    ], $data));
+                }
+            }
+        }
+
+        return ['errors' => $errors];
+    }
+
+    private function getStudentFirstNames(array $studentIds): array
+    {
+        $ids = array_values(array_filter(array_unique(array_map('intval', $studentIds)), static fn ($id) => $id > 0));
+        if (empty($ids)) {
+            return [];
+        }
+
+        $rows = Student::query()
+            ->select(['id', 'firstname'])
+            ->whereIn('id', $ids)
+            ->get();
+
+        $names = [];
+        foreach ($rows as $row) {
+            $names[(int) $row->id] = trim((string) $row->firstname);
+        }
+
+        return $names;
+    }
+
+    private function validateComment(string $comment, int $studentId, string $scoreType, array $studentNames): ?string
+    {
+        $trimmed = trim($comment);
+        if ($trimmed === '') {
+            return null;
+        }
+
+        $firstName = $studentNames[$studentId] ?? '';
+        if ($firstName === '') {
+            return "Missing student first name for student ID {$studentId}.";
+        }
+
+        $length = mb_strlen($trimmed, 'UTF-8');
+        if ($length < 100) {
+            return "{$firstName}'s {$scoreType} comment must be at least 100 characters.";
+        }
+        if ($length > 400) {
+            return "{$firstName}'s {$scoreType} comment must be at most 400 characters.";
+        }
+
+        $pattern = '/^' . preg_quote($firstName, '/') . '\\b/i';
+        if (!preg_match($pattern, $trimmed)) {
+            return "{$firstName}'s {$scoreType} comment must start with the student's first name.";
+        }
+
+        return null;
+    }
+
+    private function isReviewer(): bool
+    {
+        $currentUserRole = session()->get('role');
+        $reviewerRoles = (string) (Configuration::getConfig('comment_reviewer') ?? '');
+        if ($reviewerRoles === '') {
+            return false;
+        }
+
+        $allowedRoles = array_map('trim', explode(',', $reviewerRoles));
+        return in_array($currentUserRole, $allowedRoles, true);
+    }
+}
diff --git a/app/Services/Scores/ScoreDashboardService.php b/app/Services/Scores/ScoreDashboardService.php
new file mode 100644
index 00000000..c227e323
--- /dev/null
+++ b/app/Services/Scores/ScoreDashboardService.php
@@ -0,0 +1,243 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Models\ClassSection;
+use App\Models\Configuration;
+use App\Models\GradingLock;
+use App\Models\MissingScoreOverride;
+use App\Models\ScoreComment;
+use App\Models\SemesterScore;
+use App\Models\Student;
+use App\Models\StudentClass;
+use App\Models\TeacherClass;
+use Illuminate\Support\Facades\DB;
+
+class ScoreDashboardService
+{
+    public function __construct(private ScoreTermService $term)
+    {
+    }
+
+    public function overview(int $teacherId, ?int $classSectionId, ?string $semester, ?string $schoolYear): array
+    {
+        $schoolYear = $this->term->schoolYear($schoolYear);
+        $semesterLabel = $this->term->semesterLabel($semester, $semester);
+
+        $assignments = TeacherClass::query()
+            ->where('teacher_id', $teacherId)
+            ->when($schoolYear !== '', fn ($q) => $q->where('school_year', $schoolYear))
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        if (empty($assignments)) {
+            return ['students' => [], 'assignments' => [], 'class_section_id' => null];
+        }
+
+        $allowedIds = array_values(array_unique(array_map(static fn ($a) => (int) ($a['class_section_id'] ?? 0), $assignments)));
+        $classSectionId = $classSectionId && in_array($classSectionId, $allowedIds, true) ? $classSectionId : $allowedIds[0];
+
+        $studentIds = StudentClass::query()
+            ->where('class_section_id', $classSectionId)
+            ->when($schoolYear !== '', fn ($q) => $q->where('school_year', $schoolYear))
+            ->pluck('student_id')
+            ->map(fn ($v) => (int) $v)
+            ->all();
+
+        $students = Student::query()
+            ->whereIn('id', $studentIds)
+            ->where('is_active', 1)
+            ->orderBy('lastname')
+            ->orderBy('firstname')
+            ->get()
+            ->map(fn ($row) => [
+                'student_id' => (int) $row->id,
+                'firstname' => (string) $row->firstname,
+                'lastname' => (string) $row->lastname,
+                'school_id' => $row->school_id,
+            ])
+            ->all();
+
+        $scores = SemesterScore::query()
+            ->where('class_section_id', $classSectionId)
+            ->where('semester', $semesterLabel)
+            ->where('school_year', $schoolYear)
+            ->get()
+            ->keyBy('student_id');
+
+        $comments = ScoreComment::query()
+            ->where('semester', $semesterLabel)
+            ->where('school_year', $schoolYear)
+            ->whereIn('student_id', $studentIds)
+            ->get();
+
+        $commentMap = [];
+        foreach ($comments as $comment) {
+            $commentMap[(int) $comment->student_id][(string) $comment->score_type] = [
+                'comment' => $comment->comment,
+                'comment_review' => $comment->comment_review,
+            ];
+        }
+
+        foreach ($students as &$student) {
+            $sid = $student['student_id'];
+            $scoreRow = $scores[$sid] ?? null;
+            $student['scores'] = $scoreRow ? [
+                'homework' => $scoreRow->homework_avg,
+                'quiz' => $scoreRow->quiz_avg,
+                'project' => $scoreRow->project_avg,
+                'midterm_exam' => $scoreRow->midterm_exam_score,
+                'final_exam' => $scoreRow->final_exam_score,
+                'attendance' => $scoreRow->attendance_score,
+                'ptap' => $scoreRow->ptap_score,
+                'semester' => $scoreRow->semester_score,
+            ] : [];
+            $student['comments'] = $commentMap[$sid] ?? [];
+        }
+        unset($student);
+
+        $classSection = ClassSection::query()->where('class_section_id', $classSectionId)->first();
+
+        return [
+            'students' => $students,
+            'class_section_id' => $classSectionId,
+            'class_section_name' => $classSection?->class_section_name,
+            'semester' => $semesterLabel,
+            'school_year' => $schoolYear,
+            'scoresLocked' => GradingLock::isLocked($classSectionId, $semesterLabel, $schoolYear),
+        ];
+    }
+
+    public function submitScoresLock(int $classSectionId, string $semester, string $schoolYear, array $missingOk, int $teacherId): void
+    {
+        $isFall = strtolower($semester) === 'fall';
+        $isSpring = strtolower($semester) === 'spring';
+        $studentIds = array_keys((array) $missingOk);
+
+        $commentTypes = ['ptap_comment'];
+        if ($isFall) {
+            $commentTypes[] = 'midterm_comment';
+        }
+        if ($isSpring) {
+            $commentTypes[] = 'final_comment';
+        }
+
+        foreach ($commentTypes as $type) {
+            $checkedItems = [];
+            foreach ($missingOk as $studentId => $types) {
+                if (!is_array($types) || empty($types[$type])) {
+                    continue;
+                }
+                $checkedItems[] = [
+                    'student_id' => (int) $studentId,
+                    'item_index' => null,
+                ];
+            }
+            MissingScoreOverride::replaceOverrides(
+                $classSectionId,
+                $semester,
+                $schoolYear,
+                $type,
+                $studentIds,
+                null,
+                $checkedItems,
+                $teacherId,
+                true
+            );
+        }
+
+        $existing = GradingLock::getLock($classSectionId, $semester, $schoolYear);
+        if ($existing && $existing->is_locked) {
+            return;
+        }
+
+        if ($existing) {
+            $existing->update([
+                'is_locked' => 1,
+                'locked_by' => $teacherId > 0 ? $teacherId : null,
+                'locked_at' => now(),
+            ]);
+        } else {
+            GradingLock::query()->create([
+                'class_section_id' => $classSectionId,
+                'semester' => $semester,
+                'school_year' => $schoolYear,
+                'is_locked' => 1,
+                'locked_by' => $teacherId > 0 ? $teacherId : null,
+                'locked_at' => now(),
+            ]);
+        }
+    }
+
+    public function viewStudentScores(int $parentId, string $schoolYear): array
+    {
+        $students = DB::table('students')
+            ->select('students.id', 'students.school_id', 'students.firstname', 'students.lastname', 'classSection.class_section_name')
+            ->leftJoin('student_class', 'student_class.student_id', '=', 'students.id')
+            ->leftJoin('classSection', 'classSection.class_section_id', '=', 'student_class.class_section_id')
+            ->where('students.parent_id', $parentId)
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+
+        $scores = [];
+        if (!empty($students)) {
+            $studentIdList = array_column($students, 'id');
+            $semesterScores = DB::table('semester_scores')
+                ->whereIn('student_id', $studentIdList)
+                ->where('school_year', $schoolYear)
+                ->get()
+                ->map(fn ($row) => (array) $row)
+                ->all();
+
+            $scoresByStudent = [];
+            foreach ($semesterScores as $score) {
+                $studentIdKey = (int) ($score['student_id'] ?? 0);
+                $semesterName = trim((string) ($score['semester'] ?? ''));
+                if ($studentIdKey === 0 || $semesterName === '') {
+                    continue;
+                }
+                $normalizedSemester = ucfirst(strtolower($semesterName));
+                $scoresByStudent[$studentIdKey][$normalizedSemester] = $score;
+            }
+
+            foreach ($students as $student) {
+                $studentId = (int) $student['id'];
+                if (empty($scoresByStudent[$studentId])) {
+                    continue;
+                }
+                foreach ($scoresByStudent[$studentId] as $semester => $score) {
+                    $scores[$schoolYear][$semester][$studentId] = [
+                        'student_id' => $studentId,
+                        'school_id' => $student['school_id'],
+                        'student_firstname' => $student['firstname'],
+                        'student_lastname' => $student['lastname'],
+                        'class_section_name' => $student['class_section_name'] ?? 'Unknown Class',
+                        'comment' => $score['comment'] ?? null,
+                        'scores' => [
+                            'homework' => ['score' => $score['homework_avg'] ?? '-'],
+                            'quiz' => ['score' => $score['quiz_avg'] ?? '-'],
+                            'project' => ['score' => $score['project_avg'] ?? '-'],
+                            'attendance' => ['score' => $score['attendance_score'] ?? '-'],
+                            'participation_score' => ['score' => $score['participation_score'] ?? '-'],
+                            'ptap' => ['score' => $score['ptap_score'] ?? '-'],
+                            'midterm_exam' => ['score' => $score['midterm_exam_score'] ?? '-'],
+                            'final_exam' => ['score' => $score['final_exam_score'] ?? '-'],
+                            'semester' => ['score' => $score['semester_score'] ?? '-'],
+                        ],
+                    ];
+                }
+            }
+        }
+
+        $schoolYears = DB::table('semester_scores')->select('school_year')->distinct()->pluck('school_year')->all();
+        rsort($schoolYears);
+
+        return [
+            'scores' => $scores,
+            'schoolYears' => $schoolYears,
+            'selectedYear' => $schoolYear,
+        ];
+    }
+}
diff --git a/app/Services/Scores/ScorePredictorDataService.php b/app/Services/Scores/ScorePredictorDataService.php
new file mode 100644
index 00000000..297b7491
--- /dev/null
+++ b/app/Services/Scores/ScorePredictorDataService.php
@@ -0,0 +1,105 @@
+<?php
+
+namespace App\Services\Scores;
+
+use Illuminate\Support\Facades\DB;
+
+class ScorePredictorDataService
+{
+    public function classSections(string $schoolYear): array
+    {
+        return DB::table('classSection as cs')
+            ->select('cs.*')
+            ->join('student_class as sc', 'sc.class_section_id', '=', 'cs.class_section_id')
+            ->where('sc.school_year', $schoolYear)
+            ->notLike('cs.class_section_name', 'KG', 'after')
+            ->groupBy('cs.id')
+            ->orderBy('cs.class_section_name', 'ASC')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+
+    public function students(string $schoolYear, ?int $classSectionId = null): array
+    {
+        $builder = DB::table('students as s')
+            ->select([
+                's.id as student_id',
+                's.school_id',
+                's.firstname',
+                's.lastname',
+                'fall.semester_score as fall_score',
+                'spring.semester_score as spring_score',
+                'sc.class_section_id as class_section_id',
+            ])
+            ->leftJoin('student_class as sc', function ($join) use ($schoolYear) {
+                $join->on('sc.student_id', '=', 's.id')
+                    ->where('sc.school_year', '=', $schoolYear);
+            })
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'sc.class_section_id')
+            ->leftJoin('semester_scores as fall', function ($join) use ($schoolYear) {
+                $join->on('fall.student_id', '=', 's.id')
+                    ->where('fall.semester', '=', 'fall')
+                    ->where('fall.school_year', '=', $schoolYear);
+            })
+            ->leftJoin('semester_scores as spring', function ($join) use ($schoolYear) {
+                $join->on('spring.student_id', '=', 's.id')
+                    ->where('spring.semester', '=', 'spring')
+                    ->where('spring.school_year', '=', $schoolYear);
+            })
+            ->where('s.is_active', 1)
+            ->where(function ($q) {
+                $q->whereNull('cs.class_section_name')
+                    ->orWhere('cs.class_section_name', 'not like', 'KG%');
+            });
+
+        if (!empty($classSectionId)) {
+            $builder->where('sc.class_section_id', $classSectionId);
+        }
+
+        return $builder
+            ->groupBy('s.id')
+            ->get()
+            ->map(fn ($row) => (array) $row)
+            ->all();
+    }
+
+    public function springStats(string $schoolYear, ?int $classSectionId = null): array
+    {
+        $builder = DB::table('semester_scores')
+            ->select('semester_scores.semester_score')
+            ->join('student_class', 'student_class.student_id', '=', 'semester_scores.student_id')
+            ->leftJoin('classSection as cs', 'cs.class_section_id', '=', 'student_class.class_section_id')
+            ->where('semester_scores.semester', 'spring')
+            ->where('semester_scores.school_year', $schoolYear)
+            ->where('student_class.school_year', $schoolYear)
+            ->where(function ($q) {
+                $q->whereNull('cs.class_section_name')
+                    ->orWhere('cs.class_section_name', 'not like', 'KG%');
+            });
+
+        if (!empty($classSectionId)) {
+            $builder->where('student_class.class_section_id', $classSectionId);
+        }
+
+        $scores = $builder->pluck('semester_scores.semester_score')->filter(function ($v) {
+            return is_numeric($v);
+        })->map(fn ($v) => (float) $v)->all();
+
+        if (empty($scores)) {
+            return ['mean' => 70.0, 'std' => 0.0];
+        }
+
+        $mean = array_sum($scores) / count($scores);
+        $variance = 0.0;
+        foreach ($scores as $value) {
+            $variance += ($value - $mean) ** 2;
+        }
+        $variance = $variance / count($scores);
+
+        return [
+            'mean' => (float) $mean,
+            'std' => (float) sqrt($variance),
+        ];
+    }
+}
diff --git a/app/Services/Scores/ScorePredictorRiskService.php b/app/Services/Scores/ScorePredictorRiskService.php
new file mode 100644
index 00000000..cbb9ad1b
--- /dev/null
+++ b/app/Services/Scores/ScorePredictorRiskService.php
@@ -0,0 +1,143 @@
+<?php
+
+namespace App\Services\Scores;
+
+class ScorePredictorRiskService
+{
+    public function normalCdf(float $z): float
+    {
+        $t = 1 / (1 + 0.3275911 * abs($z));
+        $a1 = 0.254829592;
+        $a2 = -0.284496736;
+        $a3 = 1.421413741;
+        $a4 = -1.453152027;
+        $a5 = 1.061405429;
+        $erf = 1 - ((((($a5 * $t + $a4) * $t + $a3) * $t + $a2) * $t + $a1) * $t) * exp(-$z * $z);
+        $sign = $z < 0 ? -1 : 1;
+        return 0.5 * (1 + $sign * $erf);
+    }
+
+    public function evaluate(array $students, float $mean, float $std, float $trophyThreshold, float $targetLow): array
+    {
+        $results = [];
+
+        foreach ($students as $student) {
+            $fallScore = is_numeric($student['fall_score'] ?? null) ? (float) $student['fall_score'] : null;
+            $springScore = is_numeric($student['spring_score'] ?? null) ? (float) $student['spring_score'] : null;
+
+            $scoreParts = array_values(array_filter([$fallScore, $springScore], static fn ($v) => $v !== null));
+            $finalAvg = !empty($scoreParts) ? round(array_sum($scoreParts) / count($scoreParts), 1) : null;
+
+            $waitingForSpring = ($fallScore !== null && $springScore === null);
+
+            $requiredHigh = $waitingForSpring ? round(2 * $trophyThreshold - $fallScore, 2) : null;
+            $requiredLow = $waitingForSpring ? round(2 * $targetLow - $fallScore, 2) : null;
+
+            $zHigh = ($requiredHigh !== null && $std > 0) ? ($requiredHigh - $mean) / $std : null;
+            $zLow = ($requiredLow !== null && $std > 0) ? ($requiredLow - $mean) / $std : null;
+
+            $probHigh = $zHigh !== null ? 1 - $this->normalCdf($zHigh) : null;
+            $probLow = $zLow !== null ? $this->normalCdf($zLow) : null;
+
+            $riskHigh = match (true) {
+                $finalAvg !== null && !$waitingForSpring && $finalAvg >= $trophyThreshold => 'Achieved Trophy',
+                $finalAvg !== null && !$waitingForSpring => 'Unreachable',
+                $requiredHigh !== null && $requiredHigh > 100 => 'Unreachable',
+                is_null($probHigh) => 'New student',
+                $probHigh >= 0.66 => 'Low',
+                $probHigh >= 0.33 => 'Medium',
+                default => 'High',
+            };
+
+            $riskLow = match (true) {
+                $finalAvg !== null && !$waitingForSpring && $finalAvg < $targetLow => 'High',
+                $finalAvg !== null && !$waitingForSpring => 'Low',
+                $requiredLow !== null && $requiredLow > 100 => 'Unlikely to pass',
+                is_null($probLow) => 'New student',
+                $probLow >= 0.66 => 'High',
+                $probLow >= 0.33 => 'Medium',
+                default => 'Low',
+            };
+
+            if ($finalAvg === null) {
+                $status = 'Undetermined';
+            } elseif ($waitingForSpring) {
+                $status = in_array($riskLow, ['High', 'Unlikely to pass'], true) ? 'May fail' : 'Can pass';
+            } else {
+                $status = $finalAvg >= 60 ? 'Passed' : 'Failed';
+            }
+
+            $results[] = [
+                'student_id' => (int) ($student['student_id'] ?? 0),
+                'school_id' => $student['school_id'] ?? null,
+                'firstname' => $student['firstname'] ?? null,
+                'lastname' => $student['lastname'] ?? null,
+                'class_section_id' => $student['class_section_id'] ?? null,
+                'fall_score' => $student['fall_score'] ?? 'N/A',
+                'spring_score' => $student['spring_score'] ?? 'N/A',
+                'final_average' => $finalAvg ?? 'N/A',
+                'required_spring_score' => $requiredHigh ?? 'N/A',
+                'winning_risk' => $riskHigh,
+                'required_spring_to_pass' => $requiredLow ?? 'N/A',
+                'failure_risk' => $riskLow,
+                'status' => $status,
+                'trophy_awarded' => ($riskHigh === 'Achieved Trophy'),
+                'trophy_reason' => ($riskHigh === 'Achieved Trophy') ? 'threshold' : '',
+            ];
+        }
+
+        return $this->applyTop3Trophy($results);
+    }
+
+    private function applyTop3Trophy(array $results): array
+    {
+        $bySection = [];
+        $hasThresholdTrophy = [];
+
+        foreach ($results as $idx => $row) {
+            $cid = (string) ($row['class_section_id'] ?? '');
+            $bySection[$cid][] = $idx;
+            if (($row['trophy_reason'] ?? '') === 'threshold') {
+                $hasThresholdTrophy[$cid] = true;
+            }
+        }
+
+        foreach ($bySection as $cid => $indices) {
+            if (!empty($hasThresholdTrophy[$cid])) {
+                continue;
+            }
+            $candidates = [];
+            foreach ($indices as $idx) {
+                $val = $results[$idx]['final_average'] ?? null;
+                if (!is_numeric($val)) {
+                    $fall = $results[$idx]['fall_score'] ?? null;
+                    $spring = $results[$idx]['spring_score'] ?? null;
+                    $parts = [];
+                    if (is_numeric($fall)) $parts[] = (float) $fall;
+                    if (is_numeric($spring)) $parts[] = (float) $spring;
+                    if (!empty($parts)) {
+                        $val = array_sum($parts) / count($parts);
+                    }
+                }
+                if (is_numeric($val)) {
+                    $candidates[] = ['idx' => $idx, 'avg' => (float) $val];
+                }
+            }
+            if (empty($candidates)) {
+                continue;
+            }
+            usort($candidates, static fn ($a, $b) => $b['avg'] <=> $a['avg']);
+            $top = array_slice($candidates, 0, 3);
+            foreach ($top as $entry) {
+                $i = $entry['idx'];
+                $results[$i]['trophy_awarded'] = true;
+                $results[$i]['trophy_reason'] = 'top3';
+                $results[$i]['winning_risk'] = 'Top 3 Trophy';
+            }
+        }
+
+        usort($results, static fn ($a, $b) => ($b['final_average'] ?? 0) <=> ($a['final_average'] ?? 0));
+
+        return $results;
+    }
+}
diff --git a/app/Services/Scores/ScorePredictorService.php b/app/Services/Scores/ScorePredictorService.php
new file mode 100644
index 00000000..5f37be9f
--- /dev/null
+++ b/app/Services/Scores/ScorePredictorService.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Models\Configuration;
+
+class ScorePredictorService
+{
+    public function __construct(
+        private ScorePredictorDataService $dataService,
+        private ScorePredictorRiskService $riskService
+    ) {
+    }
+
+    public function report(?string $schoolYear, ?int $classSectionId = null): array
+    {
+        $currentSchoolYear = (string) (Configuration::getConfig('school_year') ?? '');
+        $semester = (string) (Configuration::getConfig('semester') ?? '');
+        $targetTrophy = (float) (Configuration::getConfig('trophy_score') ?? 94.0);
+        $targetLow = (float) (Configuration::getConfig('pass_score') ?? 60.0);
+
+        $selectedYear = $schoolYear ?: $currentSchoolYear;
+        $classSections = $this->dataService->classSections($selectedYear);
+        $students = $this->dataService->students($selectedYear, $classSectionId);
+
+        $stats = $this->dataService->springStats($selectedYear, $classSectionId);
+        $mean = (float) ($stats['mean'] ?? 70.0);
+        $std = (float) ($stats['std'] ?? 0.0);
+
+        $trophyThreshold = max(94.0, $targetTrophy);
+        $results = $this->riskService->evaluate($students, $mean, $std, $trophyThreshold, $targetLow);
+
+        return [
+            'students' => $results,
+            'school_year' => $selectedYear,
+            'class_sections' => $classSections,
+            'selected_class_section_id' => $classSectionId,
+            'semester' => $semester,
+        ];
+    }
+}
diff --git a/app/Services/Scores/ScoreTermService.php b/app/Services/Scores/ScoreTermService.php
new file mode 100644
index 00000000..d57d820f
--- /dev/null
+++ b/app/Services/Scores/ScoreTermService.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Models\Configuration;
+
+class ScoreTermService
+{
+    public function normalizeSemester(?string $input): string
+    {
+        $value = strtolower(trim((string) $input));
+        if ($value === 'fall' || str_contains($value, '1')) {
+            return 'fall';
+        }
+        if ($value === 'spring' || str_contains($value, '2')) {
+            return 'spring';
+        }
+        return '';
+    }
+
+    public function semesterLabel(?string $input, ?string $fallback = null): string
+    {
+        $normalized = $this->normalizeSemester($input);
+        if ($normalized !== '') {
+            return ucfirst($normalized);
+        }
+        if ($fallback && trim($fallback) !== '') {
+            return (string) $fallback;
+        }
+
+        return (string) (Configuration::getConfig('semester') ?? 'Fall');
+    }
+
+    public function schoolYear(?string $input, ?string $fallback = null): string
+    {
+        $value = trim((string) $input);
+        if ($value !== '') {
+            return $value;
+        }
+        if ($fallback && trim($fallback) !== '') {
+            return (string) $fallback;
+        }
+
+        return (string) (Configuration::getConfig('school_year') ?? '');
+    }
+
+    public function semesterVariants(?string $semester): array
+    {
+        $raw = trim((string) $semester);
+        $variants = [
+            $raw,
+            strtolower($raw),
+            ucfirst(strtolower($raw)),
+        ];
+        $normalized = $this->normalizeSemester($raw);
+        if ($normalized === 'fall') {
+            $variants[] = 'First Semester';
+            $variants[] = 'Semester 1';
+            $variants[] = '1st Semester';
+            $variants[] = 'Fall Semester';
+        } elseif ($normalized === 'spring') {
+            $variants[] = 'Second Semester';
+            $variants[] = 'Semester 2';
+            $variants[] = '2nd Semester';
+            $variants[] = 'Spring Semester';
+        }
+
+        return array_values(array_unique(array_filter($variants, static fn ($v) => $v !== '')));
+    }
+}
diff --git a/app/Services/Scores/SemesterScoreService.php b/app/Services/Scores/SemesterScoreService.php
new file mode 100644
index 00000000..ed3f35ed
--- /dev/null
+++ b/app/Services/Scores/SemesterScoreService.php
@@ -0,0 +1,227 @@
+<?php
+
+namespace App\Services\Scores;
+
+use App\Interfaces\ScoreCalculatorInterface;
+use App\Models\Configuration;
+use App\Models\FinalExam;
+use App\Models\MidtermExam;
+use App\Models\Participation;
+use App\Models\SemesterScore;
+use App\Services\Scores\AttendanceCalculator;
+use App\Services\Scores\HomeworkCalculator;
+use App\Services\Scores\ProjectCalculator;
+use App\Services\Scores\QuizCalculator;
+use App\Models\AttendanceRecord;
+use App\Models\CalendarEvent;
+use App\Models\Homework;
+use App\Models\Project;
+use RuntimeException;
+
+class SemesterScoreService
+{
+    /** @var array<string, ScoreCalculatorInterface> */
+    private array $scoreCalculators = [];
+
+    private string $semester;
+    private string $schoolYear;
+    private ?int $actorId;
+
+    public function __construct(
+        ?AttendanceCalculator $attendanceCalculator = null,
+        ?HomeworkCalculator $homeworkCalculator = null,
+        ?QuizCalculator $quizCalculator = null,
+        ?ProjectCalculator $projectCalculator = null
+    ) {
+        $this->semester = (string) (Configuration::getConfig('semester') ?? '');
+        $this->schoolYear = (string) (Configuration::getConfig('school_year') ?? '');
+        $this->actorId = (int) (auth()->id() ?? 0) ?: null;
+
+        $attendanceCalculator = $attendanceCalculator ?? new AttendanceCalculator(
+            new AttendanceRecord(),
+            new Configuration(),
+            new CalendarEvent()
+        );
+        $homeworkCalculator = $homeworkCalculator ?? new HomeworkCalculator(new Homework());
+        $quizCalculator = $quizCalculator ?? new QuizCalculator();
+        $projectCalculator = $projectCalculator ?? new ProjectCalculator(new Project());
+
+        $this->scoreCalculators = [
+            AttendanceCalculator::class => $attendanceCalculator,
+            HomeworkCalculator::class => $homeworkCalculator,
+            QuizCalculator::class => $quizCalculator,
+            ProjectCalculator::class => $projectCalculator,
+        ];
+    }
+
+    public function updateScoresForStudents(array $students, ?string $semester = null, ?string $schoolYear = null): void
+    {
+        $semester = $semester ?? $this->semester;
+        $schoolYear = $schoolYear ?? $this->schoolYear;
+
+        foreach ($students as $student) {
+            $this->updateStudentScores($student, $semester, $schoolYear);
+        }
+    }
+
+    public function updateStudentScores(array $student, string $semester, string $schoolYear): void
+    {
+        foreach (['student_id', 'school_id', 'class_section_id'] as $field) {
+            if (!isset($student[$field])) {
+                throw new RuntimeException("Missing required student field: {$field}");
+            }
+        }
+
+        $updatedBy = isset($student['updated_by'])
+            ? (int) $student['updated_by']
+            : ($this->actorId ?? null);
+
+        $scoreData = $this->calculateAllScores(
+            (int) $student['student_id'],
+            $semester,
+            $schoolYear,
+            (int) ($student['class_section_id'] ?? 0) ?: null
+        );
+
+        $this->saveStudentScores(
+            (int) $student['student_id'],
+            (string) $student['school_id'],
+            (int) $student['class_section_id'],
+            $updatedBy,
+            $semester,
+            $schoolYear,
+            $scoreData
+        );
+    }
+
+    private function calculateAllScores(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): array
+    {
+        $scoreData = [
+            'updated_at' => now(),
+        ];
+
+        foreach ($this->scoreCalculators as $calculator) {
+            try {
+                $scoreData = array_merge(
+                    $scoreData,
+                    $calculator->calculate($studentId, $semester, $schoolYear, $classSectionId)
+                );
+            } catch (\Throwable $e) {
+                // ignore calculator errors to keep scoring pipeline running
+            }
+        }
+
+        if (!isset($scoreData['participation_score'])) {
+            $participationScore = Participation::getParticipationScore($studentId, $semester, $schoolYear, $classSectionId);
+            $scoreData['participation_score'] = $participationScore !== null ? (float) $participationScore : null;
+        }
+
+        $scoreData['ptap_score'] = $this->calculatePTAPScore($scoreData);
+        $midfinal = $this->calculateSemesterScore($scoreData, $semester, $studentId, $schoolYear, $classSectionId);
+
+        return array_merge($scoreData, [
+            'semester_score' => $midfinal['semester_score'],
+            'midterm_exam_score' => $midfinal['midterm_score'],
+            'final_exam_score' => $midfinal['final_score'],
+            'participation_score' => $scoreData['participation_score'],
+        ]);
+    }
+
+    private function calculatePTAPScore(array $scores): ?float
+    {
+        $avgHomework = $scores['homework_avg'] ?? null;
+        $avgQuiz = $scores['quiz_avg'] ?? null;
+        $avgProject = $scores['project_avg'] ?? null;
+        $avgParticipation = $scores['participation_score'] ?? null;
+
+        $hasTests = $avgQuiz !== null;
+        $hasProjects = $avgProject !== null;
+
+        if (!$hasTests && !$hasProjects) {
+            if ($avgHomework === null || $avgParticipation === null) {
+                return null;
+            }
+            return round(($avgHomework * 0.5) + ($avgParticipation * 0.5), 1);
+        }
+
+        if (!$hasProjects) {
+            if ($avgHomework === null || $avgParticipation === null || $avgQuiz === null) {
+                return null;
+            }
+            return round(($avgHomework * 0.4) + ($avgParticipation * 0.4) + ($avgQuiz * 0.2), 1);
+        }
+
+        if (!$hasTests) {
+            if ($avgHomework === null || $avgParticipation === null || $avgProject === null) {
+                return null;
+            }
+            return round(($avgHomework * 0.34) + ($avgParticipation * 0.33) + ($avgProject * 0.33), 1);
+        }
+
+        if ($avgHomework === null || $avgParticipation === null || $avgProject === null || $avgQuiz === null) {
+            return null;
+        }
+
+        return round(
+            ($avgHomework * 0.3) + ($avgParticipation * 0.3) + ($avgProject * 0.3) + ($avgQuiz * 0.1),
+            1
+        );
+    }
+
+    private function calculateSemesterScore(array $scores, string $semester, int $studentId, string $schoolYear, ?int $classSectionId): array
+    {
+        $ptap = $scores['ptap_score'] ?? null;
+        $attendance = $scores['attendance_score'] ?? null;
+
+        $out = [
+            'midterm_score' => null,
+            'final_score' => null,
+            'semester_score' => null,
+        ];
+
+        if (strcasecmp($semester, 'Fall') === 0) {
+            $mid = $scores['midterm_exam_score'] ?? MidtermExam::getMidtermExamScore($studentId, $semester, $schoolYear, $classSectionId);
+            $out['midterm_score'] = $mid !== null ? round((float) $mid, 1) : null;
+            if ($ptap !== null && $attendance !== null && $out['midterm_score'] !== null) {
+                $out['semester_score'] = round(($attendance * 0.2) + ($ptap * 0.2) + ($out['midterm_score'] * 0.6), 1);
+            }
+            return $out;
+        }
+
+        if (strcasecmp($semester, 'Spring') === 0) {
+            $fin = $scores['final_exam_score'] ?? FinalExam::getFinalExamScore($studentId, $semester, $schoolYear, $classSectionId);
+            $out['final_score'] = $fin !== null ? round((float) $fin, 1) : null;
+            if ($ptap !== null && $attendance !== null && $out['final_score'] !== null) {
+                $out['semester_score'] = round(($attendance * 0.2) + ($ptap * 0.2) + ($out['final_score'] * 0.6), 1);
+            }
+            return $out;
+        }
+
+        return $out;
+    }
+
+    private function saveStudentScores(
+        int $studentId,
+        string $schoolId,
+        int $classSectionId,
+        ?int $updatedBy,
+        string $semester,
+        string $schoolYear,
+        array $scoreData
+    ): void {
+        $payload = array_merge([
+            'student_id' => $studentId,
+            'school_id' => $schoolId,
+            'class_section_id' => $classSectionId,
+            'semester' => $semester,
+            'school_year' => $schoolYear,
+            'updated_at' => now(),
+        ], $scoreData);
+
+        if ($updatedBy !== null) {
+            $payload['updated_by'] = $updatedBy;
+        }
+
+        SemesterScore::upsertScore($payload);
+    }
+}
diff --git a/app/Services/SemesterRangeService.php b/app/Services/SemesterRangeService.php
new file mode 100644
index 00000000..6247ccf1
--- /dev/null
+++ b/app/Services/SemesterRangeService.php
@@ -0,0 +1,113 @@
+<?php
+
+namespace App\Services;
+
+use App\Services\Semesters\SemesterConfigService;
+use DateTimeImmutable;
+
+class SemesterRangeService
+{
+    public function __construct(private SemesterConfigService $configService)
+    {
+    }
+
+    public function getSchoolYearRange(string $schoolYear): array
+    {
+        $start = $this->configService->getFallStart();
+        $end = $this->configService->getLastSchoolDay();
+
+        if ($start === null || $end === null) {
+            [$fallbackStart, $fallbackEnd] = $this->fallbackSchoolYearRange($schoolYear);
+            $start ??= $fallbackStart;
+            $end ??= $fallbackEnd;
+        }
+
+        if ($end < $start) {
+            [$start, $end] = [$end, $start];
+        }
+
+        return [$start->format('Y-m-d'), $end->format('Y-m-d')];
+    }
+
+    public function getSemesterRange(string $schoolYear, string $semester): ?array
+    {
+        if (!preg_match('/^(\\d{4})-(\\d{4})$/', $schoolYear, $m)) {
+            return null;
+        }
+        $y1 = (int) $m[1];
+        $y2 = (int) $m[2];
+
+        $normalized = ucfirst(strtolower(trim($semester)));
+        if ($normalized === 'Fall') {
+            return [sprintf('%04d-09-21', $y1), sprintf('%04d-01-18', $y2)];
+        }
+        if ($normalized === 'Spring') {
+            return [sprintf('%04d-01-25', $y2), sprintf('%04d-05-31', $y2)];
+        }
+
+        return null;
+    }
+
+    public function normalizeSemester(?string $semester): string
+    {
+        $value = strtolower(trim((string) ($semester ?? '')));
+        if ($value === 'fall') {
+            return 'Fall';
+        }
+        if ($value === 'spring') {
+            return 'Spring';
+        }
+        return '';
+    }
+
+    public function getSemesterForDate(?string $date = null): string
+    {
+        $fallStart = $this->configService->getFallStart();
+        $springStart = $this->configService->getSpringStart();
+        $lastDay = $this->configService->getLastSchoolDay();
+
+        try {
+            $target = new DateTimeImmutable($date ?: 'now');
+        } catch (\Throwable) {
+            return '';
+        }
+
+        if ($fallStart === null || $springStart === null || $lastDay === null) {
+            return '';
+        }
+
+        $target = $target->setTime(0, 0, 0);
+        $fallStart = $fallStart->setTime(0, 0, 0);
+        $springStart = $springStart->setTime(0, 0, 0);
+        $lastDay = $lastDay->setTime(0, 0, 0);
+
+        $nextFallStart = $fallStart <= $lastDay ? $fallStart->modify('+1 year') : $fallStart;
+
+        if (($fallStart <= $target && $target < $springStart)
+            || ($lastDay <= $target && $target < $nextFallStart)
+        ) {
+            return 'Fall';
+        }
+
+        if ($springStart <= $target && $target < $lastDay) {
+            return 'Spring';
+        }
+
+        return '';
+    }
+
+    private function fallbackSchoolYearRange(string $schoolYear): array
+    {
+        if (preg_match('/^(\\d{4})-(\\d{4})$/', $schoolYear, $m)) {
+            $y1 = (int) $m[1];
+            $y2 = (int) $m[2];
+            return [new DateTimeImmutable($y1 . '-09-01'), new DateTimeImmutable($y2 . '-06-30')];
+        }
+
+        $currentYear = (int) date('Y');
+        return [
+            new DateTimeImmutable($currentYear . '-09-01'),
+            new DateTimeImmutable(($currentYear + 1) . '-06-30'),
+        ];
+    }
+}
diff --git a/app/Services/Semesters/SemesterConfigService.php b/app/Services/Semesters/SemesterConfigService.php
new file mode 100644
index 00000000..574c01e3
--- /dev/null
+++ b/app/Services/Semesters/SemesterConfigService.php
@@ -0,0 +1,41 @@
+<?php
+
+namespace App\Services\Semesters;
+
+use App\Models\Configuration;
+use DateTimeImmutable;
+
+class SemesterConfigService
+{
+    public function getFallStart(): ?DateTimeImmutable
+    {
+        return $this->parseDate(Configuration::getConfigValueByKey('fall_semester_start'));
+    }
+
+    public function getSpringStart(): ?DateTimeImmutable
+    {
+        return $this->parseDate(Configuration::getConfigValueByKey('spring_semester_start'));
+    }
+
+    public function getLastSchoolDay(): ?DateTimeImmutable
+    {
+        $value = Configuration::getConfigValueByKey('last_school_day')
+            ?? Configuration::getConfigValueByKey('last_day_of_school');
+
+        return $this->parseDate($value);
+    }
+
+    private function parseDate(?string $value): ?DateTimeImmutable
+    {
+        $value = (string) ($value ?? '');
+        if ($value === '') {
+            return null;
+        }
+
+        try {
+            return new DateTimeImmutable($value);
+        } catch (\Throwable) {
+            return null;
+        }
+    }
+}
diff --git a/app/Services/Users/LoginActivityService.php b/app/Services/Users/LoginActivityService.php
new file mode 100644
index 00000000..1c62b4f9
--- /dev/null
+++ b/app/Services/Users/LoginActivityService.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace App\Services\Users;
+
+use App\Models\LoginActivity;
+
+class LoginActivityService
+{
+    public function list(int $perPage, int $page): array
+    {
+        $perPage = max(1, min($perPage, 200));
+        $page = max(1, $page);
+
+        $total = (int) LoginActivity::query()->count();
+        $pageCount = (int) max(1, ceil($total / $perPage));
+
+        $activities = LoginActivity::query()
+            ->orderByDesc('login_time')
+            ->forPage($page, $perPage)
+            ->get();
+
+        $normalized = $activities->map(static function (LoginActivity $activity) {
+            return [
+                'user_id' => $activity->user_id,
+                'email' => $activity->email,
+                'login_time' => optional($activity->login_time)->toDateTimeString(),
+                'logout_time' => optional($activity->logout_time)->toDateTimeString(),
+                'ip_address' => $activity->ip_address,
+                'user_agent' => $activity->user_agent,
+            ];
+        })->all();
+
+        return [
+            'activities' => $normalized,
+            'pagination' => [
+                'total' => $total,
+                'perPage' => $perPage,
+                'currentPage' => $page,
+                'pageCount' => $pageCount,
+                'hasNext' => $page < $pageCount,
+                'hasPrevious' => $page > 1,
+            ],
+        ];
+    }
+}
diff --git a/app/Services/Users/UserEventService.php b/app/Services/Users/UserEventService.php
new file mode 100644
index 00000000..d3c706ef
--- /dev/null
+++ b/app/Services/Users/UserEventService.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace App\Services\Users;
+
+use App\Services\EmailService;
+use Illuminate\Support\Facades\Log;
+
+class UserEventService
+{
+    public function __construct(private EmailService $emailService)
+    {
+    }
+
+    public function handleNewAccountAdded(array $userData): bool
+    {
+        $email = (string) ($userData['email'] ?? '');
+        if ($email === '') {
+            Log::warning('UserEventService: missing email for welcome message.');
+            return false;
+        }
+
+        $name = trim((string) (($userData['firstname'] ?? '') . ' ' . ($userData['lastname'] ?? '')));
+        $safeName = e($name !== '' ? $name : 'there');
+
+        $subject = 'Welcome to Al Rahma Sunday School!';
+        $message = '<p>Hello ' . $safeName . ',</p>'
+            . '<p>Your account has been created. Welcome to Al Rahma Sunday School.</p>';
+
+        return $this->emailService->send($email, $subject, $message, 'registration');
+    }
+}
diff --git a/app/Services/Users/UserListService.php b/app/Services/Users/UserListService.php
new file mode 100644
index 00000000..918773cc
--- /dev/null
+++ b/app/Services/Users/UserListService.php
@@ -0,0 +1,161 @@
+<?php
+
+namespace App\Services\Users;
+
+use App\Models\User;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+class UserListService
+{
+    private const SORT_FIELDS = [
+        'id',
+        'firstname',
+        'lastname',
+        'email',
+        'status',
+        'updated_at',
+    ];
+
+    public function list(?string $sort, ?string $order): array
+    {
+        $sort = in_array($sort, self::SORT_FIELDS, true) ? $sort : 'id';
+        $order = strtolower((string) $order) === 'desc' ? 'desc' : 'asc';
+
+        $users = User::query()
+            ->with('roles')
+            ->orderBy($sort, $order)
+            ->get();
+
+        $guardianMap = $this->guardianTypeMap();
+        [$secondByUserId, $secondByEmail] = $this->secondParentMaps();
+
+        $usersWithRoles = [];
+
+        foreach ($users as $user) {
+            $roles = $user->roles->map(fn ($role) => (string) $role->name)->values()->all();
+            $roleIds = $user->roles->map(fn ($role) => (int) $role->id)->values()->all();
+
+            $userId = (int) $user->id;
+            $parentType = $guardianMap[$userId] ?? '';
+
+            $isSecond = false;
+            if ($userId > 0 && !empty($secondByUserId[$userId])) {
+                $isSecond = true;
+            } else {
+                $email = trim(strtolower((string) $user->email));
+                if ($email !== '' && !empty($secondByEmail[$email])) {
+                    $isSecond = true;
+                }
+            }
+
+            $usersWithRoles[] = [
+                'user' => $user->toArray(),
+                'roles' => $roles,
+                'role_ids' => $roleIds,
+                'parent_type' => $parentType,
+                'second_from_parents' => $isSecond ? 'Yes' : '',
+            ];
+        }
+
+        return $usersWithRoles;
+    }
+
+    public function getUsersWithRoles(?string $sort = 'id', ?string $order = 'asc'): array
+    {
+        $sort = (string) ($sort ?? 'id');
+        $order = (string) ($order ?? 'asc');
+
+        $map = [
+            'id' => 'users.id',
+            'firstname' => 'users.firstname',
+            'lastname' => 'users.lastname',
+            'email' => 'users.email',
+            'role' => 'role',
+        ];
+
+        $sortField = $map[$sort] ?? 'users.id';
+
+        return User::getUsersWithRoles($sortField, $order);
+    }
+
+    public function getUnverifiedUsers(): array
+    {
+        return User::getUnverifiedUsers();
+    }
+
+    public function getUsersByRole(string $role): array
+    {
+        return User::getUsersByRole($role);
+    }
+
+    private function guardianTypeMap(): array
+    {
+        if (!Schema::hasTable('family_guardians')) {
+            return [];
+        }
+
+        $rows = DB::table('family_guardians')
+            ->selectRaw('user_id, MAX(is_primary) AS max_primary, COUNT(*) AS cnt')
+            ->groupBy('user_id')
+            ->get();
+
+        $map = [];
+        foreach ($rows as $row) {
+            $userId = (int) ($row->user_id ?? 0);
+            if ($userId <= 0) {
+                continue;
+            }
+            $count = (int) ($row->cnt ?? 0);
+            if ($count <= 0) {
+                continue;
+            }
+            $maxPrimary = (int) ($row->max_primary ?? 0);
+            $map[$userId] = $maxPrimary > 0 ? 'Primary' : 'Secondary';
+        }
+
+        return $map;
+    }
+
+    private function secondParentMaps(): array
+    {
+        if (!Schema::hasTable('parents')) {
+            return [[], []];
+        }
+
+        $byUserId = [];
+        $byEmail = [];
+
+        if (Schema::hasColumn('parents', 'secondparent_user_id')) {
+            $rows = DB::table('parents')
+                ->selectRaw('secondparent_user_id AS uid, COUNT(*) AS cnt')
+                ->where('secondparent_user_id', '!=', 0)
+                ->groupBy('secondparent_user_id')
+                ->get();
+
+            foreach ($rows as $row) {
+                $userId = (int) ($row->uid ?? 0);
+                if ($userId > 0) {
+                    $byUserId[$userId] = true;
+                }
+            }
+        }
+
+        if (Schema::hasColumn('parents', 'secondparent_email')) {
+            $rows = DB::table('parents')
+                ->selectRaw('LOWER(TRIM(secondparent_email)) AS em, COUNT(*) AS cnt')
+                ->where('secondparent_email', '!=', '')
+                ->groupBy('secondparent_email')
+                ->get();
+
+            foreach ($rows as $row) {
+                $email = trim(strtolower((string) ($row->em ?? '')));
+                if ($email !== '') {
+                    $byEmail[$email] = true;
+                }
+            }
+        }
+
+        return [$byUserId, $byEmail];
+    }
+}
diff --git a/app/Services/Users/UserManagementService.php b/app/Services/Users/UserManagementService.php
new file mode 100644
index 00000000..f7aaa4e7
--- /dev/null
+++ b/app/Services/Users/UserManagementService.php
@@ -0,0 +1,293 @@
+<?php
+
+namespace App\Services\Users;
+
+use App\Models\Role;
+use App\Models\User;
+use App\Models\UserRole;
+use Carbon\CarbonImmutable;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Log;
+use Illuminate\Support\Facades\Validator;
+
+class UserManagementService
+{
+    public function __construct(private UserEventService $eventService)
+    {
+    }
+
+    public function create(array $payload, ?int $actorId = null): array
+    {
+        $actorId = $actorId ?? (auth()->id() ?? null);
+
+        try {
+            $user = DB::transaction(function () use ($payload, $actorId) {
+                $data = $this->normalizeForCreate($payload);
+                $user = User::query()->create($data);
+
+                UserRole::query()->create([
+                    'user_id' => $user->id,
+                    'role_id' => (int) $payload['role_id'],
+                    'updated_by' => $actorId,
+                ]);
+
+                return $user;
+            });
+        } catch (\Throwable $e) {
+            return ['ok' => false, 'message' => 'Failed to create user.'];
+        }
+
+        $this->eventService->handleNewAccountAdded($user->toArray());
+
+        return ['ok' => true, 'user' => $user];
+    }
+
+    public function update(int $userId, array $payload): array
+    {
+        $user = User::query()->find($userId);
+        if (!$user) {
+            return ['ok' => false, 'message' => 'User not found.'];
+        }
+
+        $data = $this->normalizeForUpdate($payload);
+        if (empty($data)) {
+            return ['ok' => false, 'message' => 'No changes requested.'];
+        }
+
+        try {
+            $user->fill($data);
+            $user->save();
+        } catch (\Throwable $e) {
+            return ['ok' => false, 'message' => 'Failed to update user.'];
+        }
+
+        return ['ok' => true, 'user' => $user];
+    }
+
+    public function delete(int $userId): array
+    {
+        $user = User::query()->find($userId);
+        if (!$user) {
+            return ['ok' => false, 'message' => 'User not found.'];
+        }
+
+        try {
+            DB::transaction(function () use ($userId, $user) {
+                UserRole::query()->where('user_id', $userId)->delete();
+                $user->delete();
+            });
+        } catch (\Throwable $e) {
+            return ['ok' => false, 'message' => 'Failed to delete user.'];
+        }
+
+        return ['ok' => true];
+    }
+
+    public function assignRole(int $userId, int $roleId, ?int $actorId = null): bool
+    {
+        $actorId = $actorId ?? (auth()->id() ?? null);
+
+        if (!User::query()->whereKey($userId)->exists()) {
+            return false;
+        }
+
+        if (!Role::query()->whereKey($roleId)->exists()) {
+            return false;
+        }
+
+        return UserRole::updateOrInsertRole($userId, $roleId, $actorId);
+    }
+
+    public function cleanupUnverifiedUsers(int $olderThanMinutes = 15): int
+    {
+        $cutoff = now()->subMinutes(max(1, $olderThanMinutes));
+
+        $deleted = User::query()
+            ->where('is_verified', 0)
+            ->where('created_at', '<=', $cutoff)
+            ->delete();
+
+        Log::info(sprintf(
+            'Deleted %d unverified users created before %s.',
+            $deleted,
+            $cutoff->format('Y-m-d H:i:s')
+        ));
+
+        return $deleted;
+    }
+
+    public function validateRegistrationInput(array $data): array
+    {
+        $rules = [
+            'firstname' => ['required', 'regex:/^[a-zA-Z\\s-]+$/', 'min:2', 'max:30'],
+            'lastname' => ['required', 'regex:/^[a-zA-Z\\s-]+$/', 'min:2', 'max:30'],
+            'gender' => ['required', 'in:Male,Female'],
+            'email' => ['required', 'email', 'max:50'],
+            'confirm_email' => ['required', 'same:email'],
+            'cellphone' => ['required', 'regex:/^[\\d\\s\\-\\(\\)\\.]+$/', 'min:10', 'max:20'],
+            'address_street' => ['nullable', 'regex:/^[a-zA-Z0-9\\s\\-]+$/', 'max:150'],
+            'apt' => ['nullable', 'regex:/^[a-zA-Z0-9\\s-]+$/', 'max:10'],
+            'city' => ['required', 'regex:/^[a-zA-Z\\s]+$/', 'min:2', 'max:30'],
+            'state' => ['required', 'in:CT,ME,MA,NH,NY,RI,VT'],
+            'zip' => ['required', 'regex:/^\\d{5}$/'],
+            'accept_school_policy' => ['required'],
+        ];
+
+        $isParent = !empty($data['is_parent']);
+        $noSecondParent = !empty($data['no_second_parent_info']);
+
+        if ($isParent && !$noSecondParent) {
+            $rules += [
+                'second_firstname' => ['required', 'regex:/^[a-zA-Z\\s\\-]+$/', 'min:2', 'max:30'],
+                'second_lastname' => ['required', 'regex:/^[a-zA-Z\\s\\-]+$/', 'min:2', 'max:30'],
+                'second_gender' => ['required', 'in:Male,Female'],
+                'second_email' => ['required', 'email', 'max:50'],
+                'second_cellphone' => ['required', 'regex:/^[\\d\\s\\-\\(\\)\\.]+$/', 'min:10', 'max:20'],
+            ];
+        }
+
+        $validator = Validator::make($data, $rules);
+
+        if ($validator->fails()) {
+            return $validator->errors()->toArray();
+        }
+
+        return [];
+    }
+
+    private function normalizeForCreate(array $payload): array
+    {
+        return [
+            'school_id' => $payload['school_id'] ?? null,
+            'firstname' => $this->titleCase($payload['firstname'] ?? ''),
+            'lastname' => $this->titleCase($payload['lastname'] ?? ''),
+            'gender' => $this->normalizeGender($payload['gender'] ?? null),
+            'cellphone' => (string) ($payload['cellphone'] ?? ''),
+            'email' => strtolower((string) ($payload['email'] ?? '')),
+            'address_street' => (string) ($payload['address_street'] ?? ''),
+            'apt' => $payload['apt'] ?? null,
+            'city' => $this->titleCase($payload['city'] ?? ''),
+            'state' => (string) ($payload['state'] ?? ''),
+            'zip' => (string) ($payload['zip'] ?? ''),
+            'accept_school_policy' => (bool) ($payload['accept_school_policy'] ?? false),
+            'is_verified' => isset($payload['is_verified']) ? (bool) $payload['is_verified'] : 0,
+            'status' => $payload['status'] ?? 'Inactive',
+            'is_suspended' => isset($payload['is_suspended']) ? (bool) $payload['is_suspended'] : 0,
+            'failed_attempts' => $payload['failed_attempts'] ?? null,
+            'password' => pbkdf2_hash((string) ($payload['password'] ?? '')),
+            'token' => $payload['token'] ?? null,
+            'account_id' => $payload['account_id'] ?? null,
+            'user_type' => $payload['user_type'] ?? 'primary',
+            'semester' => (string) ($payload['semester'] ?? ''),
+            'school_year' => $payload['school_year'] ?? null,
+            'rfid_tag' => $payload['rfid_tag'] ?? null,
+            'last_failed_at' => $this->normalizeDateTime($payload['last_failed_at'] ?? null),
+        ];
+    }
+
+    private function normalizeForUpdate(array $payload): array
+    {
+        $data = [];
+        $map = [
+            'school_id',
+            'firstname',
+            'lastname',
+            'gender',
+            'cellphone',
+            'email',
+            'address_street',
+            'apt',
+            'city',
+            'state',
+            'zip',
+            'accept_school_policy',
+            'user_type',
+            'rfid_tag',
+            'failed_attempts',
+            'last_failed_at',
+            'semester',
+            'school_year',
+            'status',
+            'is_suspended',
+            'is_verified',
+            'token',
+            'account_id',
+        ];
+
+        foreach ($map as $field) {
+            if (!array_key_exists($field, $payload)) {
+                continue;
+            }
+
+            $value = $payload[$field];
+            switch ($field) {
+                case 'firstname':
+                case 'lastname':
+                case 'city':
+                    $data[$field] = $this->titleCase($value);
+                    break;
+                case 'email':
+                    $data[$field] = strtolower((string) $value);
+                    break;
+                case 'gender':
+                    $data[$field] = $this->normalizeGender($value);
+                    break;
+                case 'accept_school_policy':
+                case 'is_suspended':
+                case 'is_verified':
+                    $data[$field] = (bool) $value;
+                    break;
+                case 'last_failed_at':
+                    $data[$field] = $this->normalizeDateTime($value);
+                    break;
+                case 'failed_attempts':
+                case 'school_id':
+                    $data[$field] = $value === '' ? null : $value;
+                    break;
+                default:
+                    $data[$field] = $value;
+                    break;
+            }
+        }
+
+        return $data;
+    }
+
+    private function normalizeGender(?string $value): ?string
+    {
+        $value = strtolower(trim((string) $value));
+        if ($value === '') {
+            return null;
+        }
+        if ($value === 'male') {
+            return 'Male';
+        }
+        if ($value === 'female') {
+            return 'Female';
+        }
+        return null;
+    }
+
+    private function titleCase(?string $value): string
+    {
+        $value = trim((string) $value);
+        if ($value === '') {
+            return '';
+        }
+        return ucfirst($value);
+    }
+
+    private function normalizeDateTime($value): ?string
+    {
+        $value = trim((string) ($value ?? ''));
+        if ($value === '') {
+            return null;
+        }
+
+        try {
+            return CarbonImmutable::parse($value)->format('Y-m-d H:i:s');
+        } catch (\Throwable $e) {
+            return null;
+        }
+    }
+}
diff --git a/app/Support/SqliteCompat.php b/app/Support/SqliteCompat.php
index b9e0dcce..b5fcc5b9 100644
--- a/app/Support/SqliteCompat.php
+++ b/app/Support/SqliteCompat.php
@@ -56,6 +56,7 @@ class SqliteCompat
         // Replace MySQL-specific types.
         $sql = preg_replace('/int\\(\\d+\\)\\s+unsigned/i', 'integer', $sql);
         $sql = preg_replace('/int\\(\\d+\\)/i', 'integer', $sql);
+        $sql = preg_replace('/\\bint\\b/i', 'integer', $sql);
         $sql = preg_replace('/smallint\\(\\d+\\)/i', 'integer', $sql);
         $sql = preg_replace('/tinyint\\(\\d+\\)/i', 'integer', $sql);
         $sql = preg_replace('/decimal\\(\\d+\\s*,\\s*\\d+\\)/i', 'numeric', $sql);
diff --git a/composer.json b/composer.json
index 73e26fb9..dff1b6fe 100644
--- a/composer.json
+++ b/composer.json
@@ -8,6 +8,7 @@
     "require": {
         "php": "^8.2",
         "laravel/framework": "^12.0",
+        "laravel/sanctum": "^4.3",
         "laravel/tinker": "^2.10.1",
         "php-open-source-saver/jwt-auth": "^2.8",
         "setasign/fpdf": "*"
diff --git a/composer.lock b/composer.lock
index 9f20461a..a238a69b 100644
--- a/composer.lock
+++ b/composer.lock
@@ -4,7 +4,7 @@
         "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies",
         "This file is @generated automatically"
     ],
-    "content-hash": "c4518280521bc6de74776cbcc1e35f35",
+    "content-hash": "155e8c52495d21620105d90faabd1d17",
     "packages": [
         {
             "name": "brick/math",
@@ -1333,6 +1333,69 @@
             },
             "time": "2026-02-06T12:17:10+00:00"
         },
+        {
+            "name": "laravel/sanctum",
+            "version": "v4.3.1",
+            "source": {
+                "type": "git",
+                "url": "https://github.com/laravel/sanctum.git",
+                "reference": "e3b85d6e36ad00e5db2d1dcc27c81ffdf15cbf76"
+            },
+            "dist": {
+                "type": "zip",
+                "url": "https://api.github.com/repos/laravel/sanctum/zipball/e3b85d6e36ad00e5db2d1dcc27c81ffdf15cbf76",
+                "reference": "e3b85d6e36ad00e5db2d1dcc27c81ffdf15cbf76",
+                "shasum": ""
+            },
+            "require": {
+                "ext-json": "*",
+                "illuminate/console": "^11.0|^12.0|^13.0",
+                "illuminate/contracts": "^11.0|^12.0|^13.0",
+                "illuminate/database": "^11.0|^12.0|^13.0",
+                "illuminate/support": "^11.0|^12.0|^13.0",
+                "php": "^8.2",
+                "symfony/console": "^7.0|^8.0"
+            },
+            "require-dev": {
+                "mockery/mockery": "^1.6",
+                "orchestra/testbench": "^9.15|^10.8|^11.0",
+                "phpstan/phpstan": "^1.10"
+            },
+            "type": "library",
+            "extra": {
+                "laravel": {
+                    "providers": [
+                        "Laravel\\Sanctum\\SanctumServiceProvider"
+                    ]
+                }
+            },
+            "autoload": {
+                "psr-4": {
+                    "Laravel\\Sanctum\\": "src/"
+                }
+            },
+            "notification-url": "https://packagist.org/downloads/",
+            "license": [
+                "MIT"
+            ],
+            "authors": [
+                {
+                    "name": "Taylor Otwell",
+                    "email": "taylor@laravel.com"
+                }
+            ],
+            "description": "Laravel Sanctum provides a featherweight authentication system for SPAs and simple APIs.",
+            "keywords": [
+                "auth",
+                "laravel",
+                "sanctum"
+            ],
+            "support": {
+                "issues": "https://github.com/laravel/sanctum/issues",
+                "source": "https://github.com/laravel/sanctum"
+            },
+            "time": "2026-02-07T17:19:31+00:00"
+        },
         {
             "name": "laravel/serializable-closure",
             "version": "v2.0.9",
diff --git a/config/sanctum.php b/config/sanctum.php
new file mode 100644
index 00000000..44527d68
--- /dev/null
+++ b/config/sanctum.php
@@ -0,0 +1,84 @@
+<?php
+
+use Laravel\Sanctum\Sanctum;
+
+return [
+
+    /*
+    |--------------------------------------------------------------------------
+    | Stateful Domains
+    |--------------------------------------------------------------------------
+    |
+    | Requests from the following domains / hosts will receive stateful API
+    | authentication cookies. Typically, these should include your local
+    | and production domains which access your API via a frontend SPA.
+    |
+    */
+
+    'stateful' => explode(',', env('SANCTUM_STATEFUL_DOMAINS', sprintf(
+        '%s%s',
+        'localhost,localhost:3000,127.0.0.1,127.0.0.1:8000,::1',
+        Sanctum::currentApplicationUrlWithPort(),
+        // Sanctum::currentRequestHost(),
+    ))),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Sanctum Guards
+    |--------------------------------------------------------------------------
+    |
+    | This array contains the authentication guards that will be checked when
+    | Sanctum is trying to authenticate a request. If none of these guards
+    | are able to authenticate the request, Sanctum will use the bearer
+    | token that's present on an incoming request for authentication.
+    |
+    */
+
+    'guard' => ['web'],
+
+    /*
+    |--------------------------------------------------------------------------
+    | Expiration Minutes
+    |--------------------------------------------------------------------------
+    |
+    | This value controls the number of minutes until an issued token will be
+    | considered expired. This will override any values set in the token's
+    | "expires_at" attribute, but first-party sessions are not affected.
+    |
+    */
+
+    'expiration' => null,
+
+    /*
+    |--------------------------------------------------------------------------
+    | Token Prefix
+    |--------------------------------------------------------------------------
+    |
+    | Sanctum can prefix new tokens in order to take advantage of numerous
+    | security scanning initiatives maintained by open source platforms
+    | that notify developers if they commit tokens into repositories.
+    |
+    | See: https://docs.github.com/en/code-security/secret-scanning/about-secret-scanning
+    |
+    */
+
+    'token_prefix' => env('SANCTUM_TOKEN_PREFIX', ''),
+
+    /*
+    |--------------------------------------------------------------------------
+    | Sanctum Middleware
+    |--------------------------------------------------------------------------
+    |
+    | When authenticating your first-party SPA with Sanctum you may need to
+    | customize some of the middleware Sanctum uses while processing the
+    | request. You may change the middleware listed below as required.
+    |
+    */
+
+    'middleware' => [
+        'authenticate_session' => Laravel\Sanctum\Http\Middleware\AuthenticateSession::class,
+        'encrypt_cookies' => Illuminate\Cookie\Middleware\EncryptCookies::class,
+        'validate_csrf_token' => Illuminate\Foundation\Http\Middleware\ValidateCsrfToken::class,
+    ],
+
+];
diff --git a/database/migrations/2026_02_23_204035_create_current_incident_table.php b/database/migrations/2026_02_23_204035_create_current_incident_table.php
new file mode 100644
index 00000000..f039ff4c
--- /dev/null
+++ b/database/migrations/2026_02_23_204035_create_current_incident_table.php
@@ -0,0 +1,51 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        App\Support\SqliteCompat::statement(<<<'SQL'
+CREATE TABLE `current_incident` (
+`id` int UNSIGNED NOT NULL,
+  `student_id` int NOT NULL,
+  `student_name` varchar(255) COLLATE utf8mb4_general_ci NOT NULL,
+  `grade` varchar(50) COLLATE utf8mb4_general_ci NOT NULL,
+  `incident` enum('payment','attendance','grade','behavior','talking_off_task','calling_out','minor_disruption','minor_dress_code','forgetting_materials','repeated_defiance','disrespectful_tone','minor_profanity','repeated_tardiness','device_misuse','minor_conflict','bullying_harassment','fighting_aggression','threats','theft','vandalism','sexual_harassment','serious_cyber_incident','contraband','weapons_drugs','other') COLLATE utf8mb4_general_ci NOT NULL,
+  `incident_datetime` datetime NOT NULL,
+  `incident_state` enum('Open','Closed','Canceled') COLLATE utf8mb4_general_ci DEFAULT 'Open',
+  `updated_by_open` int DEFAULT NULL,
+  `open_description` text COLLATE utf8mb4_general_ci,
+  `updated_by_closed` int DEFAULT NULL,
+  `close_description` text COLLATE utf8mb4_general_ci,
+  `action_taken` text COLLATE utf8mb4_general_ci,
+  `updated_by_canceled` int DEFAULT NULL,
+  `cancel_description` text COLLATE utf8mb4_general_ci,
+  `semester` varchar(25) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci NOT NULL,
+  `school_year` varchar(9) CHARACTER SET utf8mb3 COLLATE utf8mb3_general_ci DEFAULT NULL,
+  `created_at` timestamp NULL DEFAULT CURRENT_TIMESTAMP,
+  `updated_at` timestamp NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
+SQL
+        );
+
+        App\Support\SqliteCompat::statement(<<<'SQL'
+ALTER TABLE `current_incident`
+  ADD PRIMARY KEY (`id`);
+SQL
+        );
+
+        App\Support\SqliteCompat::statement(<<<'SQL'
+ALTER TABLE `current_incident`
+  MODIFY `id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT;
+SQL
+        );
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('current_incident');
+    }
+};
diff --git a/database/migrations/2026_02_23_204036_create_flag_table.php b/database/migrations/2026_02_23_204036_create_incident_table.php
similarity index 67%
rename from database/migrations/2026_02_23_204036_create_flag_table.php
rename to database/migrations/2026_02_23_204036_create_incident_table.php
index 4dde9154..c9272069 100644
--- a/database/migrations/2026_02_23_204036_create_flag_table.php
+++ b/database/migrations/2026_02_23_204036_create_incident_table.php
@@ -9,14 +9,14 @@ return new class extends Migration
     public function up(): void
     {
         App\Support\SqliteCompat::statement(<<<'SQL'
-CREATE TABLE `flag` (
+CREATE TABLE `incident` (
 `id` int UNSIGNED NOT NULL,
   `student_id` int NOT NULL,
   `student_name` varchar(255) COLLATE utf8mb4_general_ci NOT NULL,
   `grade` varchar(50) COLLATE utf8mb4_general_ci NOT NULL,
-  `flag` enum('payment','attendance','grade','behavior','talking_off_task','calling_out','minor_disruption','minor_dress_code','forgetting_materials','repeated_defiance','disrespectful_tone','minor_profanity','repeated_tardiness','device_misuse','minor_conflict','bullying_harassment','fighting_aggression','threats','theft','vandalism','sexual_harassment','serious_cyber_incident','contraband','weapons_drugs','other') COLLATE utf8mb4_general_ci NOT NULL,
-  `flag_datetime` datetime NOT NULL,
-  `flag_state` enum('Closed','Canceled') COLLATE utf8mb4_general_ci NOT NULL,
+  `incident` enum('payment','attendance','grade','behavior','talking_off_task','calling_out','minor_disruption','minor_dress_code','forgetting_materials','repeated_defiance','disrespectful_tone','minor_profanity','repeated_tardiness','device_misuse','minor_conflict','bullying_harassment','fighting_aggression','threats','theft','vandalism','sexual_harassment','serious_cyber_incident','contraband','weapons_drugs','other') COLLATE utf8mb4_general_ci NOT NULL,
+  `incident_datetime` datetime NOT NULL,
+  `incident_state` enum('Closed','Canceled') COLLATE utf8mb4_general_ci NOT NULL,
   `updated_by_open` int DEFAULT NULL,
   `open_description` text COLLATE utf8mb4_general_ci,
   `updated_by_closed` int DEFAULT NULL,
@@ -33,13 +33,13 @@ SQL
         );
 
         App\Support\SqliteCompat::statement(<<<'SQL'
-ALTER TABLE `flag`
+ALTER TABLE `incident`
   ADD PRIMARY KEY (`id`);
 SQL
         );
 
         App\Support\SqliteCompat::statement(<<<'SQL'
-ALTER TABLE `flag`
+ALTER TABLE `incident`
   MODIFY `id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT;
 SQL
         );
@@ -48,6 +48,6 @@ SQL
 
     public function down(): void
     {
-        Schema::dropIfExists('flag');
+        Schema::dropIfExists('incident');
     }
 };
\ No newline at end of file
diff --git a/database/migrations/2026_02_23_900056_create_communication_logs_table.php b/database/migrations/2026_02_23_900056_create_communication_logs_table.php
new file mode 100644
index 00000000..d4083ca4
--- /dev/null
+++ b/database/migrations/2026_02_23_900056_create_communication_logs_table.php
@@ -0,0 +1,53 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    public function up(): void
+    {
+        App\Support\SqliteCompat::statement(<<<'SQL'
+CREATE TABLE `communication_logs` (
+`id` int UNSIGNED NOT NULL,
+  `student_id` int UNSIGNED NOT NULL,
+  `family_id` int UNSIGNED NOT NULL,
+  `student_name` varchar(255) DEFAULT NULL,
+  `template_key` varchar(100) DEFAULT NULL,
+  `subject` varchar(255) DEFAULT NULL,
+  `body` mediumtext DEFAULT NULL,
+  `recipients` text DEFAULT NULL,
+  `cc` text DEFAULT NULL,
+  `bcc` text DEFAULT NULL,
+  `attachments` text DEFAULT NULL,
+  `status` varchar(32) DEFAULT NULL,
+  `error_message` text DEFAULT NULL,
+  `sent_by` int UNSIGNED DEFAULT NULL,
+  `metadata` text DEFAULT NULL,
+  `created_at` datetime DEFAULT CURRENT_TIMESTAMP
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
+SQL
+        );
+
+        App\Support\SqliteCompat::statement(<<<'SQL'
+ALTER TABLE `communication_logs`
+  ADD PRIMARY KEY (`id`),
+  ADD KEY `communication_logs_student_id` (`student_id`),
+  ADD KEY `communication_logs_family_id` (`family_id`),
+  ADD KEY `communication_logs_sent_by` (`sent_by`);
+SQL
+        );
+
+        App\Support\SqliteCompat::statement(<<<'SQL'
+ALTER TABLE `communication_logs`
+  MODIFY `id` int(11) UNSIGNED NOT NULL AUTO_INCREMENT;
+SQL
+        );
+    }
+
+    public function down(): void
+    {
+        Schema::dropIfExists('communication_logs');
+    }
+};
diff --git a/database/migrations/2026_03_09_050312_create_personal_access_tokens_table.php b/database/migrations/2026_03_09_050312_create_personal_access_tokens_table.php
new file mode 100644
index 00000000..40ff706e
--- /dev/null
+++ b/database/migrations/2026_03_09_050312_create_personal_access_tokens_table.php
@@ -0,0 +1,33 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('personal_access_tokens', function (Blueprint $table) {
+            $table->id();
+            $table->morphs('tokenable');
+            $table->text('name');
+            $table->string('token', 64)->unique();
+            $table->text('abilities')->nullable();
+            $table->timestamp('last_used_at')->nullable();
+            $table->timestamp('expires_at')->nullable()->index();
+            $table->timestamps();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('personal_access_tokens');
+    }
+};
diff --git a/database/migrations/2026_03_09_064908_create_sessions_table.php b/database/migrations/2026_03_09_064908_create_sessions_table.php
new file mode 100644
index 00000000..f60625bb
--- /dev/null
+++ b/database/migrations/2026_03_09_064908_create_sessions_table.php
@@ -0,0 +1,31 @@
+<?php
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
+
+return new class extends Migration
+{
+    /**
+     * Run the migrations.
+     */
+    public function up(): void
+    {
+        Schema::create('sessions', function (Blueprint $table) {
+            $table->string('id')->primary();
+            $table->foreignId('user_id')->nullable()->index();
+            $table->string('ip_address', 45)->nullable();
+            $table->text('user_agent')->nullable();
+            $table->longText('payload');
+            $table->integer('last_activity')->index();
+        });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    public function down(): void
+    {
+        Schema::dropIfExists('sessions');
+    }
+};
diff --git a/routes/api.php b/routes/api.php
index 7e336996..0933be5e 100755
--- a/routes/api.php
+++ b/routes/api.php
@@ -18,15 +18,19 @@ use App\Http\Controllers\Api\Assignment\AssignmentApiController;
 use App\Http\Controllers\Api\Parents\AuthorizedUsersController;
 use App\Http\Controllers\Api\AttendanceTracking\AttendanceTrackingController;
 use App\Http\Controllers\Api\Email\BroadcastEmailController;
-use App\Http\Controllers\Api\Messaging\CommunicationController;
 use App\Http\Controllers\Api\Settings\ConfigurationController;
 use App\Http\Controllers\Api\Staff\ContactController;
-use App\Http\Controllers\Api\Classes\ClassPreparationController;
+use App\Http\Controllers\Api\ClassPreparation\ClassPreparationController;
+use App\Http\Controllers\Api\ClassPrep\ClassPrepController;
 use App\Http\Controllers\Api\Email\EmailController;
 use App\Http\Controllers\Api\Email\EmailExtractorController;
+use App\Http\Controllers\Api\Communication\CommunicationController;
+use App\Http\Controllers\Api\CompetitionScores\CompetitionScoresController;
+use App\Http\Controllers\Api\Discounts\DiscountController;
+use App\Http\Controllers\Api\Expenses\ExpenseController;
+use App\Http\Controllers\Api\ExtraCharges\ExtraChargesController;
 use App\Http\Controllers\Api\Parents\EmergencyContactController;
 use App\Http\Controllers\Api\Settings\EventController;
-use App\Http\Controllers\Api\Finance\ExtraChargesController;
 use App\Http\Controllers\Api\Family\FamilyAdminController;
 use App\Http\Controllers\Api\Family\FamilyController;
 use App\Http\Controllers\Api\Reports\FilesController;
@@ -35,14 +39,15 @@ use App\Http\Controllers\Api\Finance\FinancialController;
 use App\Http\Controllers\Api\System\FlagController;
 use App\Http\Controllers\Api\Scores\GradingController;
 use App\Http\Controllers\Api\System\HealthController;
+use App\Http\Controllers\Api\System\SemesterRangeController;
 use App\Http\Controllers\Api\Scores\HomeworkController;
-use App\Http\Controllers\Api\Scores\HomeworkTrackingController;
 use App\Http\Controllers\Api\Frontend\InfoIconController;
 use App\Http\Controllers\Api\Inventory\InventoryController;
 use App\Http\Controllers\Api\Auth\IpBanController;
 use App\Http\Controllers\Api\Frontend\LandingPageController;
 use App\Http\Controllers\Api\Attendance\LateSlipLogsController;
 use App\Http\Controllers\Api\Messaging\MessagesController;
+use App\Http\Controllers\Api\Incidents\IncidentController as IncidentApiController;
 use App\Http\Controllers\Api\Scores\MidtermController;
 use App\Http\Controllers\Api\System\NavBuilderController;
 use App\Http\Controllers\Api\Notifications\NotificationManagementController;
@@ -57,6 +62,10 @@ use App\Http\Controllers\Api\Finance\PaymentNotificationController;
 use App\Http\Controllers\Api\Finance\PaymentTransactionController;
 use App\Http\Controllers\Api\Finance\PaypalTransactionsController;
 use App\Http\Controllers\Api\Finance\PurchaseOrderController;
+use App\Http\Controllers\Api\Finance\ReimbursementController;
+use App\Http\Controllers\Api\Finance\PaymentEventChargesController;
+use App\Http\Controllers\Api\Finance\PaymentManualController;
+use App\Http\Controllers\Api\Finance\PaypalPaymentController;
 use App\Http\Controllers\Api\Auth\RegisterController;
 use App\Http\Controllers\Api\RolePermissionController;
 use App\Http\Controllers\Api\RoleSwitcherController;
@@ -71,6 +80,16 @@ use App\Http\Controllers\Api\Inventory\SupplierController;
 use App\Http\Controllers\Api\Staff\TeacherController;
 use App\Http\Controllers\Api\StatsController;
 use App\Http\Controllers\Api\Frontend\UiController;
+use App\Http\Controllers\Api\Scores\ProjectController as ProjectScoreController;
+use App\Http\Controllers\Api\Scores\MidtermController as MidtermScoreController;
+use App\Http\Controllers\Api\Scores\FinalController as FinalScoreController;
+use App\Http\Controllers\Api\Scores\QuizController as QuizScoreController;
+use App\Http\Controllers\Api\Scores\HomeworkController as HomeworkScoreController;
+use App\Http\Controllers\Api\Scores\ParticipationController as ParticipationScoreController;
+use App\Http\Controllers\Api\Scores\ScoreController as ScoreDashboardController;
+use App\Http\Controllers\Api\Grading\GradingController as GradingApiController;
+use App\Http\Controllers\Api\Grading\HomeworkTrackingController;
+use App\Http\Controllers\Api\Scores\ScoreCommentController as ScoreCommentApiController;
 use App\Http\Controllers\Api\Messaging\WhatsappController;
 
 use App\Http\Controllers\Api\Attendance\AdminAttendanceApiController;
@@ -79,6 +98,11 @@ use App\Http\Controllers\Api\Attendance\TeacherAttendanceApiController;
 use App\Http\Controllers\Api\Attendance\StaffAttendanceApiController;
 
 Route::prefix('v1')->group(function () {
+    Route::prefix('auth')->group(function () {
+        Route::get('register/captcha', [RegisterController::class, 'captcha']);
+        Route::post('register', [RegisterController::class, 'store']);
+    });
+
     Route::middleware('auth:sanctum')->prefix('administrator')->group(function () {
         Route::get('absence', [AdministratorAbsenceController::class, 'index']);
         Route::post('absence', [AdministratorAbsenceController::class, 'store']);
@@ -139,6 +163,250 @@ Route::prefix('v1')->group(function () {
     Route::middleware('auth:sanctum')->group(function () {
         Route::get('stats', [StatsController::class, 'index']);
 
+        Route::prefix('users')->group(function () {
+            Route::get('/', [UserController::class, 'index']);
+            Route::post('/', [UserController::class, 'store']);
+            Route::get('login-activity', [UserController::class, 'loginActivity']);
+            Route::put('{userId}', [UserController::class, 'update']);
+            Route::delete('{userId}', [UserController::class, 'destroy']);
+        });
+
+        Route::prefix('broadcast-email')->group(function () {
+            Route::get('options', [BroadcastEmailController::class, 'options']);
+            Route::post('send', [BroadcastEmailController::class, 'send']);
+            Route::post('upload-image', [BroadcastEmailController::class, 'uploadImage']);
+        });
+
+        Route::prefix('communications')->group(function () {
+            Route::get('options', [CommunicationController::class, 'options']);
+            Route::get('students/{studentId}/families', [CommunicationController::class, 'families']);
+            Route::get('families/{familyId}/guardians', [CommunicationController::class, 'guardians']);
+            Route::post('preview', [CommunicationController::class, 'preview']);
+            Route::post('send', [CommunicationController::class, 'send']);
+        });
+
+        Route::prefix('competition-scores')->group(function () {
+            Route::get('/', [CompetitionScoresController::class, 'index']);
+            Route::get('{id}', [CompetitionScoresController::class, 'edit']);
+            Route::post('{id}', [CompetitionScoresController::class, 'save']);
+        });
+
+        Route::prefix('discounts')->group(function () {
+            Route::get('options', [DiscountController::class, 'options']);
+            Route::post('apply', [DiscountController::class, 'apply']);
+            Route::get('vouchers', [DiscountController::class, 'listVouchers']);
+            Route::get('vouchers/{id}', [DiscountController::class, 'showVoucher']);
+            Route::post('vouchers', [DiscountController::class, 'storeVoucher']);
+            Route::put('vouchers/{id}', [DiscountController::class, 'updateVoucher']);
+            Route::delete('vouchers/{id}', [DiscountController::class, 'deleteVoucher']);
+        });
+
+        Route::prefix('expenses')->group(function () {
+            Route::get('/', [ExpenseController::class, 'index']);
+            Route::get('options', [ExpenseController::class, 'options']);
+            Route::get('{id}', [ExpenseController::class, 'show']);
+            Route::post('/', [ExpenseController::class, 'store']);
+            Route::put('{id}', [ExpenseController::class, 'update']);
+            Route::post('{id}/status', [ExpenseController::class, 'updateStatus']);
+        });
+
+        Route::prefix('finance')->group(function () {
+            Route::get('financial-report', [FinancialController::class, 'report']);
+            Route::get('financial-summary', [FinancialController::class, 'summary']);
+            Route::get('financial-report/csv', [FinancialController::class, 'downloadCsv']);
+            Route::get('financial-report/pdf', [FinancialController::class, 'downloadPdf']);
+            Route::get('unpaid-parents', [FinancialController::class, 'unpaidParents']);
+
+            Route::prefix('reimbursements')->group(function () {
+                Route::get('under-processing', [ReimbursementController::class, 'underProcessing']);
+                Route::post('mark-donation', [ReimbursementController::class, 'markDonation']);
+                Route::post('batches', [ReimbursementController::class, 'createBatch']);
+                Route::post('batches/assign', [ReimbursementController::class, 'updateBatchAssignment']);
+                Route::post('batches/lock', [ReimbursementController::class, 'lockBatch']);
+                Route::post('batches/admin-files', [ReimbursementController::class, 'uploadBatchAdminFile']);
+                Route::get('batches/admin-files/{name}/{mode?}', [ReimbursementController::class, 'serveAdminCheckFile']);
+                Route::post('batches/email', [ReimbursementController::class, 'sendBatchEmail']);
+                Route::get('export', [ReimbursementController::class, 'export']);
+                Route::get('batches/export', [ReimbursementController::class, 'exportBatch']);
+                Route::get('reimbursed-expenses', [ReimbursementController::class, 'reimbursedExpenses']);
+                Route::get('/', [ReimbursementController::class, 'index']);
+                Route::post('/', [ReimbursementController::class, 'store']);
+                Route::post('process', [ReimbursementController::class, 'process']);
+                Route::put('{id}', [ReimbursementController::class, 'update']);
+            });
+
+            Route::prefix('invoices')->group(function () {
+                Route::get('management', [InvoiceController::class, 'management']);
+                Route::post('generate', [InvoiceController::class, 'generate']);
+                Route::get('parent/{parentId}', [InvoiceController::class, 'byParent']);
+                Route::get('parent-payment', [InvoiceController::class, 'parentPayment']);
+                Route::post('{invoiceId}/status', [InvoiceController::class, 'updateStatus']);
+                Route::get('unpaid', [InvoiceController::class, 'unpaid']);
+                Route::get('{invoiceId}/pdf', [InvoiceController::class, 'pdf']);
+            });
+
+            Route::prefix('payments')->group(function () {
+                Route::post('/', [PaymentController::class, 'store']);
+                Route::get('parent/{parentId}', [PaymentController::class, 'byParent']);
+                Route::post('{paymentId}/balance', [PaymentController::class, 'updateBalance']);
+            });
+
+            Route::prefix('manual-pay')->group(function () {
+                Route::get('search', [PaymentManualController::class, 'search']);
+                Route::get('suggest', [PaymentManualController::class, 'suggest']);
+                Route::post('invoices/{invoiceId}/payments', [PaymentManualController::class, 'record']);
+                Route::put('payments/{paymentId}', [PaymentManualController::class, 'edit']);
+                Route::get('files/{filename}', [PaymentManualController::class, 'file']);
+            });
+
+            Route::prefix('event-charges')->group(function () {
+                Route::get('/', [PaymentEventChargesController::class, 'index']);
+                Route::post('/', [PaymentEventChargesController::class, 'store']);
+                Route::get('parents/{parentId}/students', [PaymentEventChargesController::class, 'enrolledStudents']);
+            });
+
+            Route::prefix('payment-notifications')->group(function () {
+                Route::get('/', [PaymentNotificationController::class, 'index']);
+                Route::post('send', [PaymentNotificationController::class, 'send']);
+            });
+
+            Route::prefix('payment-transactions')->group(function () {
+                Route::post('/', [PaymentTransactionController::class, 'store']);
+                Route::get('payment/{paymentId}', [PaymentTransactionController::class, 'byPayment']);
+                Route::post('{transactionId}/status', [PaymentTransactionController::class, 'updateStatus']);
+            });
+
+            Route::prefix('paypal-transactions')->group(function () {
+                Route::get('/', [PaypalTransactionsController::class, 'index']);
+                Route::get('csv', [PaypalTransactionsController::class, 'downloadCsv']);
+            });
+
+            Route::prefix('paypal')->group(function () {
+                Route::get('redirect', [PaypalPaymentController::class, 'redirect']);
+                Route::post('payments/{paymentId}/create', [PaypalPaymentController::class, 'create']);
+                Route::post('execute', [PaypalPaymentController::class, 'execute']);
+                Route::get('cancel', [PaypalPaymentController::class, 'cancel']);
+            });
+        });
+
+        Route::prefix('files')->group(function () {
+            Route::get('receipts/{name}', [FilesController::class, 'receipt']);
+            Route::get('reimbursements/{name}', [FilesController::class, 'reimb']);
+            Route::get('early-dismissal/{name}', [FilesController::class, 'earlyDismissalSignature']);
+            Route::get('exams/teacher/{name}', [FilesController::class, 'examDraftTeacher']);
+            Route::get('exams/final/{name}', [FilesController::class, 'examDraftFinal']);
+        });
+
+        Route::prefix('system')->group(function () {
+            Route::get('semester-range/school-year', [SemesterRangeController::class, 'schoolYearRange']);
+            Route::get('semester-range/semester', [SemesterRangeController::class, 'semesterRange']);
+            Route::get('semester-range/normalize', [SemesterRangeController::class, 'normalize']);
+            Route::get('semester-range/resolve', [SemesterRangeController::class, 'resolve']);
+        });
+
+        Route::prefix('incidents')->group(function () {
+            Route::get('current', [IncidentApiController::class, 'current']);
+            Route::get('history', [IncidentApiController::class, 'history']);
+            Route::get('processed', [IncidentApiController::class, 'processed']);
+            Route::get('analysis', [IncidentApiController::class, 'analysis']);
+            Route::get('grades/{gradeId}/students', [IncidentApiController::class, 'studentsByGrade']);
+            Route::post('/', [IncidentApiController::class, 'store']);
+            Route::post('{incidentId}/state', [IncidentApiController::class, 'updateState']);
+            Route::post('{incidentId}/close', [IncidentApiController::class, 'close']);
+            Route::post('{incidentId}/cancel', [IncidentApiController::class, 'cancel']);
+        });
+
+        Route::prefix('scores')->group(function () {
+            Route::get('overview', [ScoreDashboardController::class, 'overview']);
+            Route::post('lock', [ScoreDashboardController::class, 'lock']);
+            Route::get('student-scores', [ScoreDashboardController::class, 'studentScores']);
+
+            Route::prefix('projects')->group(function () {
+                Route::get('/', [ProjectScoreController::class, 'index']);
+                Route::post('/', [ProjectScoreController::class, 'update']);
+                Route::post('columns', [ProjectScoreController::class, 'addColumn']);
+            });
+
+            Route::prefix('quizzes')->group(function () {
+                Route::get('/', [QuizScoreController::class, 'index']);
+                Route::post('/', [QuizScoreController::class, 'update']);
+                Route::post('columns', [QuizScoreController::class, 'addColumn']);
+            });
+
+            Route::prefix('homework')->group(function () {
+                Route::get('/', [HomeworkScoreController::class, 'index']);
+                Route::post('/', [HomeworkScoreController::class, 'update']);
+                Route::post('columns', [HomeworkScoreController::class, 'addColumn']);
+            });
+
+            Route::prefix('midterm')->group(function () {
+                Route::get('/', [MidtermScoreController::class, 'index']);
+                Route::post('/', [MidtermScoreController::class, 'update']);
+            });
+
+            Route::prefix('final')->group(function () {
+                Route::get('/', [FinalScoreController::class, 'index']);
+                Route::post('/', [FinalScoreController::class, 'update']);
+            });
+
+            Route::prefix('participation')->group(function () {
+                Route::get('/', [ParticipationScoreController::class, 'index']);
+                Route::post('/', [ParticipationScoreController::class, 'update']);
+            });
+
+            Route::get('predictor', [ScorePredictorController::class, 'index']);
+
+            Route::prefix('comments')->group(function () {
+                Route::get('/', [ScoreCommentApiController::class, 'index']);
+                Route::post('/', [ScoreCommentApiController::class, 'store']);
+                Route::put('/', [ScoreCommentApiController::class, 'update']);
+            });
+        });
+
+        Route::prefix('grading')->group(function () {
+            Route::get('overview', [GradingApiController::class, 'overview']);
+            Route::get('scores/{type}/{classSectionId}/{studentId}', [GradingApiController::class, 'show']);
+            Route::put('scores', [GradingApiController::class, 'update']);
+
+            Route::post('locks/toggle', [GradingApiController::class, 'toggleLock']);
+            Route::post('locks/all', [GradingApiController::class, 'lockAll']);
+            Route::post('refresh', [GradingApiController::class, 'refresh']);
+
+            Route::get('placement', [GradingApiController::class, 'placement']);
+            Route::post('placement/level', [GradingApiController::class, 'updatePlacementLevel']);
+            Route::post('placement/levels', [GradingApiController::class, 'updatePlacementLevels']);
+            Route::post('placement/batch', [GradingApiController::class, 'createPlacementBatch']);
+            Route::get('placement/batch/{batchId}', [GradingApiController::class, 'showPlacementBatch']);
+            Route::put('placement/batch/{batchId}', [GradingApiController::class, 'updatePlacementBatch']);
+
+            Route::get('below-sixty', [GradingApiController::class, 'belowSixty']);
+            Route::get('below-sixty/email', [GradingApiController::class, 'belowSixtyEmail']);
+            Route::post('below-sixty/email', [GradingApiController::class, 'sendBelowSixtyEmail']);
+            Route::post('below-sixty/status', [GradingApiController::class, 'updateBelowSixtyStatus']);
+            Route::get('below-sixty/meeting', [GradingApiController::class, 'belowSixtyMeeting']);
+            Route::post('below-sixty/meeting', [GradingApiController::class, 'saveBelowSixtyMeeting']);
+
+            Route::get('homework-tracking', [HomeworkTrackingController::class, 'index']);
+        });
+
+        Route::prefix('extra-charges')->group(function () {
+            Route::get('/', [ExtraChargesController::class, 'list']);
+            Route::get('options', [ExtraChargesController::class, 'options']);
+            Route::get('parents', [ExtraChargesController::class, 'parentOptions']);
+            Route::get('invoices', [ExtraChargesController::class, 'invoicesForParent']);
+            Route::post('/', [ExtraChargesController::class, 'store']);
+            Route::put('{id}', [ExtraChargesController::class, 'update']);
+            Route::post('{id}/void', [ExtraChargesController::class, 'void']);
+            Route::post('{id}/reverse', [ExtraChargesController::class, 'reverse']);
+        });
+
+        Route::prefix('class-prep')->group(function () {
+            Route::get('/', [ClassPreparationController::class, 'index']);
+            Route::post('mark-printed', [ClassPreparationController::class, 'markPrinted']);
+            Route::get('sticker-counts', [ClassPrepController::class, 'stickerCounts']);
+            Route::get('classes/{classSectionId}/students', [ClassPrepController::class, 'studentsByClass']);
+        });
+
         Route::prefix('badges')->group(function () {
             Route::get('form-data', [BadgeController::class, 'formData']);
             Route::post('pdf', [BadgeController::class, 'generatePdf']);
@@ -182,4 +450,11 @@ Route::middleware('auth:sanctum')->group(function () {
         Route::get('print-status', [BadgeController::class, 'printStatus']);
         Route::post('log-print', [BadgeController::class, 'logPrint']);
     });
+
+    Route::prefix('class-prep')->group(function () {
+        Route::get('/', [ClassPreparationController::class, 'index']);
+        Route::post('mark-printed', [ClassPreparationController::class, 'markPrinted']);
+        Route::get('sticker-counts', [ClassPrepController::class, 'stickerCounts']);
+        Route::get('classes/{classSectionId}/students', [ClassPrepController::class, 'studentsByClass']);
+    });
 });
diff --git a/school_api b/school_api
new file mode 100644
index 0000000000000000000000000000000000000000..0b7194c90fc671c54dfa44868a02858d51090aea
GIT binary patch
literal 622592
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

literal 0
HcmV?d00001

diff --git a/storage/testing/files/cached.pdf b/storage/testing/files/cached.pdf
new file mode 100644
index 00000000..6fcd80f8
--- /dev/null
+++ b/storage/testing/files/cached.pdf
@@ -0,0 +1 @@
+PDFDATA
\ No newline at end of file
diff --git a/storage/testing/files/sample.exe b/storage/testing/files/sample.exe
new file mode 100644
index 00000000..418d6c38
--- /dev/null
+++ b/storage/testing/files/sample.exe
@@ -0,0 +1 @@
+DATA
\ No newline at end of file
diff --git a/storage/testing/files/sample.pdf b/storage/testing/files/sample.pdf
new file mode 100644
index 00000000..6fcd80f8
--- /dev/null
+++ b/storage/testing/files/sample.pdf
@@ -0,0 +1 @@
+PDFDATA
\ No newline at end of file
diff --git a/tests/Feature/Api/V1/AttendanceTracking/AttendanceTrackingControllerTest.php b/tests/Feature/Api/V1/AttendanceTracking/AttendanceTrackingControllerTest.php
index d36fd988..bfbc9683 100644
--- a/tests/Feature/Api/V1/AttendanceTracking/AttendanceTrackingControllerTest.php
+++ b/tests/Feature/Api/V1/AttendanceTracking/AttendanceTrackingControllerTest.php
@@ -2,7 +2,7 @@
 
 namespace Tests\Feature\Api\V1\AttendanceTracking;
 
-use App\Services\AttendanceTrackingService;
+use App\Services\AttendanceTracking\AttendanceTrackingService;
 use Mockery;
 use Tests\TestCase;
 
@@ -323,4 +323,4 @@ class AttendanceTrackingControllerTest extends TestCase
         $response->assertStatus(422)
             ->assertJsonValidationErrors(['student_id', 'code', 'note']);
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Feature/Api/V1/Auth/RegisterControllerTest.php b/tests/Feature/Api/V1/Auth/RegisterControllerTest.php
new file mode 100644
index 00000000..7d14bffc
--- /dev/null
+++ b/tests/Feature/Api/V1/Auth/RegisterControllerTest.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Auth;
+
+use App\Models\Role;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Mail;
+use Tests\TestCase;
+
+class RegisterControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_captcha_endpoint_returns_value(): void
+    {
+        $response = $this->getJson('/api/v1/auth/register/captcha');
+
+        $response->assertOk();
+        $response->assertJsonStructure(['ok', 'captcha']);
+        $this->assertNotEmpty($response->json('captcha'));
+    }
+
+    public function test_register_creates_user(): void
+    {
+        Mail::fake();
+
+        DB::table('configuration')->insert([
+            ['id' => 2001, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2002, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        Role::query()->create([
+            'id' => 1,
+            'name' => 'parent',
+            'slug' => 'parent',
+            'description' => 'Parent',
+            'priority' => 1,
+            'is_active' => 1,
+        ]);
+
+        $payload = [
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'gender' => 'Male',
+            'email' => 'parent@example.com',
+            'confirm_email' => 'parent@example.com',
+            'cellphone' => '5555555555',
+            'address_street' => '123 Main',
+            'apt' => 'A',
+            'city' => 'City',
+            'state' => 'CT',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'captcha' => 'ABCD',
+            'is_parent' => 1,
+            'no_second_parent_info' => 1,
+        ];
+
+        $response = $this->withSession(['captcha_answer' => 'ABCD'])
+            ->postJson('/api/v1/auth/register', $payload);
+
+        $response->assertCreated();
+        $response->assertJsonPath('ok', true);
+
+        $this->assertDatabaseHas('users', [
+            'email' => 'parent@example.com',
+            'status' => 'Inactive',
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Auth/RegisterPayloadDebugTest.php b/tests/Feature/Api/V1/Auth/RegisterPayloadDebugTest.php
new file mode 100644
index 00000000..d6081d22
--- /dev/null
+++ b/tests/Feature/Api/V1/Auth/RegisterPayloadDebugTest.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Auth;
+
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class RegisterPayloadDebugTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_debug_payload_shows_json_body(): void
+    {
+        $payload = [
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'gender' => 'Male',
+            'email' => 'parent@example.com',
+            'confirm_email' => 'parent@example.com',
+            'cellphone' => '5555555555',
+            'address_street' => '123 Main',
+            'apt' => 'A',
+            'city' => 'City',
+            'state' => 'CT',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'captcha' => 'ABCD',
+            'is_parent' => 1,
+            'no_second_parent_info' => 1,
+        ];
+
+        $response = $this->withHeaders(['X-Debug-Request' => '1'])
+            ->postJson('/api/v1/auth/register', $payload);
+
+        $response->assertOk();
+        $response->assertJsonPath('ok', true);
+        $response->assertJsonFragment(['email' => 'parent@example.com']);
+        $response->assertJsonPath('debug.json_all.email', 'parent@example.com');
+    }
+}
diff --git a/tests/Feature/Api/V1/BroadcastEmail/BroadcastEmailControllerTest.php b/tests/Feature/Api/V1/BroadcastEmail/BroadcastEmailControllerTest.php
new file mode 100644
index 00000000..33ddaf1a
--- /dev/null
+++ b/tests/Feature/Api/V1/BroadcastEmail/BroadcastEmailControllerTest.php
@@ -0,0 +1,134 @@
+<?php
+
+namespace Tests\Feature\Api\V1\BroadcastEmail;
+
+use App\Models\User;
+use App\Services\EmailService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class BroadcastEmailControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_options_returns_parents_and_senders(): void
+    {
+        $this->seedParentData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/broadcast-email/options');
+
+        $response->assertOk();
+        $this->assertNotEmpty($response->json('parents'));
+        $this->assertNotEmpty($response->json('fromOptions'));
+    }
+
+    public function test_send_test_only_dispatches_email(): void
+    {
+        $this->seedParentData();
+
+        $fake = new class extends EmailService {
+            public array $sent = [];
+
+            public function send(
+                array|string $to,
+                string $subject,
+                string $html,
+                string $fromKey = 'general',
+                array $cc = [],
+                array $bcc = []
+            ): bool
+            {
+                $this->sent[] = compact('to', 'subject', 'html', 'fromKey', 'cc', 'bcc');
+                return true;
+            }
+        };
+
+        $this->app->instance(EmailService::class, $fake);
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/broadcast-email/send', [
+            'mode' => 'personalized',
+            'subject' => 'Test Subject',
+            'from_key' => 'general',
+            'body_html' => '<p>Hello {{name}}</p>',
+            'send_test_only' => true,
+            'test_email' => 'parent@example.com',
+            'wrap_layout' => false,
+        ]);
+
+        $response->assertOk();
+        $response->assertJson([
+            'ok' => true,
+        ]);
+        $this->assertCount(1, $fake->sent);
+    }
+
+    private function seedParentData(): void
+    {
+        DB::table('roles')->insert([
+            'id' => 1,
+            'name' => 'parent',
+            'slug' => 'parent',
+            'is_active' => 1,
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 10,
+            'role_id' => 1,
+        ]);
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/ClassPrep/ClassPrepControllerTest.php b/tests/Feature/Api/V1/ClassPrep/ClassPrepControllerTest.php
new file mode 100644
index 00000000..db9c7103
--- /dev/null
+++ b/tests/Feature/Api/V1/ClassPrep/ClassPrepControllerTest.php
@@ -0,0 +1,203 @@
+<?php
+
+namespace Tests\Feature\Api\V1\ClassPrep;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class ClassPrepControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_sticker_counts_returns_payload(): void
+    {
+        $this->seedStickerData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/class-prep/sticker-counts?school_year=2025-2026&semester=Fall');
+
+        $response->assertOk();
+        $response->assertJson([
+            'ok' => true,
+            'data' => [
+                'totals' => [
+                    'primary' => 6,
+                    'secondary' => 1,
+                    'students' => 2,
+                ],
+            ],
+        ]);
+    }
+
+    public function test_students_by_class_returns_roster(): void
+    {
+        $this->seedStickerData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/class-prep/classes/101/students?school_year=2025-2026');
+
+        $response->assertOk();
+        $this->assertCount(1, $response->json('students'));
+        $this->assertSame('1-A', $response->json('students.0.registration_grade'));
+    }
+
+    private function seedStickerData(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('classes')->insert([
+            [
+                'id' => 1,
+                'class_name' => 'Class 1',
+                'schedule' => 'Sun',
+                'capacity' => 20,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 2,
+                'class_name' => 'Class 2',
+                'schedule' => 'Sun',
+                'capacity' => 20,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 3,
+                'class_name' => 'Class 3',
+                'schedule' => 'Sun',
+                'capacity' => 20,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('classSection')->insert([
+            [
+                'id' => 1,
+                'class_id' => 1,
+                'class_section_id' => 101,
+                'class_section_name' => '1-A',
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 2,
+                'class_id' => 2,
+                'class_section_id' => 102,
+                'class_section_name' => '5-B',
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 3,
+                'class_id' => 3,
+                'class_section_id' => 103,
+                'class_section_name' => 'Youth-1',
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('students')->insert([
+            [
+                'school_id' => 'S-1',
+                'firstname' => 'Student',
+                'lastname' => 'One',
+                'age' => 8,
+                'gender' => 'Male',
+                'photo_consent' => 1,
+                'parent_id' => 1,
+                'year_of_registration' => '2025',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'is_active' => 1,
+                'is_new' => 0,
+            ],
+            [
+                'school_id' => 'S-2',
+                'firstname' => 'Student',
+                'lastname' => 'Two',
+                'age' => 10,
+                'gender' => 'Female',
+                'photo_consent' => 1,
+                'parent_id' => 1,
+                'year_of_registration' => '2025',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'is_active' => 1,
+                'is_new' => 0,
+            ],
+            [
+                'school_id' => 'S-3',
+                'firstname' => 'Student',
+                'lastname' => 'Three',
+                'age' => 12,
+                'gender' => 'Female',
+                'photo_consent' => 1,
+                'parent_id' => 1,
+                'year_of_registration' => '2025',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'is_active' => 1,
+                'is_new' => 1,
+            ],
+        ]);
+
+        DB::table('student_class')->insert([
+            [
+                'student_id' => 1,
+                'class_section_id' => 101,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'student_id' => 2,
+                'class_section_id' => 102,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'student_id' => 3,
+                'class_section_id' => 103,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/ClassPreparation/ClassPreparationControllerTest.php b/tests/Feature/Api/V1/ClassPreparation/ClassPreparationControllerTest.php
new file mode 100644
index 00000000..f7b639f4
--- /dev/null
+++ b/tests/Feature/Api/V1/ClassPreparation/ClassPreparationControllerTest.php
@@ -0,0 +1,134 @@
+<?php
+
+namespace Tests\Feature\Api\V1\ClassPreparation;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class ClassPreparationControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_prep_payload(): void
+    {
+        $this->seedPrepData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/class-prep?school_year=2025-2026&semester=Fall');
+
+        $response->assertOk();
+        $response->assertJson([
+            'ok' => true,
+            'schoolYear' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+        $this->assertNotEmpty($response->json('results'));
+    }
+
+    public function test_mark_printed_creates_snapshots(): void
+    {
+        $this->seedPrepData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/class-prep/mark-printed', [
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'class_section_ids' => [101],
+        ]);
+
+        $response->assertOk();
+        $response->assertJson([
+            'ok' => true,
+        ]);
+
+        $this->assertDatabaseHas('class_preparation_log', [
+            'class_section_id' => 101,
+            'school_year' => '2025-2026',
+        ]);
+    }
+
+    private function seedPrepData(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 1,
+            'class_section_id' => 101,
+            'class_section_name' => '1-A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'school_id' => 'S-1',
+            'firstname' => 'Student',
+            'lastname' => 'One',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 1,
+            'class_section_id' => 101,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('inventory_categories')->insert([
+            'type' => 'classroom',
+            'name' => 'Small Table',
+        ]);
+
+        DB::table('inventory_items')->insert([
+            'type' => 'classroom',
+            'category_id' => 1,
+            'name' => 'Small Table',
+            'quantity' => 10,
+            'good_qty' => 10,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/Communication/CommunicationControllerTest.php b/tests/Feature/Api/V1/Communication/CommunicationControllerTest.php
new file mode 100644
index 00000000..dddf92bb
--- /dev/null
+++ b/tests/Feature/Api/V1/Communication/CommunicationControllerTest.php
@@ -0,0 +1,186 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Communication;
+
+use App\Models\User;
+use App\Services\EmailService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class CommunicationControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_options_returns_students_and_templates(): void
+    {
+        $this->seedCommunicationData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/communications/options');
+
+        $response->assertOk();
+        $this->assertNotEmpty($response->json('students'));
+        $this->assertNotEmpty($response->json('templates'));
+    }
+
+    public function test_preview_returns_rendered_subject_and_body(): void
+    {
+        $this->seedCommunicationData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/communications/preview', [
+            'template_key' => 'welcome',
+            'student_id' => 1,
+            'family_id' => 1,
+            'vars' => ['custom' => 'value'],
+        ]);
+
+        $response->assertOk();
+        $this->assertStringContainsString('Parent One', (string) $response->json('subject'));
+        $this->assertStringContainsString('Student One', (string) $response->json('html'));
+    }
+
+    public function test_send_dispatches_email(): void
+    {
+        $this->seedCommunicationData();
+
+        $fake = new class extends EmailService {
+            public array $sent = [];
+
+            public function send(
+                array|string $to,
+                string $subject,
+                string $html,
+                string $fromKey = 'general',
+                array $cc = [],
+                array $bcc = []
+            ): bool {
+                $this->sent[] = compact('to', 'subject', 'html', 'fromKey', 'cc', 'bcc');
+                return true;
+            }
+        };
+
+        $this->app->instance(EmailService::class, $fake);
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/communications/send', [
+            'student_id' => 1,
+            'family_id' => 1,
+            'template_key' => 'welcome',
+            'subject' => 'Hello',
+            'body' => '<p>Hi</p>',
+            'recipients' => ['parent1@example.com'],
+            'cc' => ['parent2@example.com'],
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertCount(1, $fake->sent);
+    }
+
+    private function seedCommunicationData(): void
+    {
+        DB::table('students')->insert([
+            'id' => 1,
+            'school_id' => 'S-1',
+            'firstname' => 'Student',
+            'lastname' => 'One',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'is_active' => 1,
+            'is_new' => 0,
+            'registration_grade' => '1-A',
+        ]);
+
+        DB::table('families')->insert([
+            'id' => 1,
+            'family_code' => 'F-1',
+            'household_name' => 'Family One',
+            'is_active' => 1,
+        ]);
+
+        DB::table('family_students')->insert([
+            'family_id' => 1,
+            'student_id' => 1,
+            'is_primary_home' => 1,
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 2,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'One',
+            'cellphone' => '5555555555',
+            'email' => 'parent1@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('family_guardians')->insert([
+            'family_id' => 1,
+            'user_id' => 2,
+            'relation' => 'parent',
+            'is_primary' => 1,
+            'receive_emails' => 1,
+            'receive_sms' => 0,
+        ]);
+
+        DB::table('email_templates')->insert([
+            'id' => 1,
+            'code' => 'welcome',
+            'variant' => 'default',
+            'subject' => 'Hello {{parent_salutation}}',
+            'body_html' => 'Hi {{student_fullname}}',
+            'is_active' => 1,
+        ]);
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/CompetitionScores/CompetitionScoresControllerTest.php b/tests/Feature/Api/V1/CompetitionScores/CompetitionScoresControllerTest.php
new file mode 100644
index 00000000..a1c418d9
--- /dev/null
+++ b/tests/Feature/Api/V1/CompetitionScores/CompetitionScoresControllerTest.php
@@ -0,0 +1,178 @@
+<?php
+
+namespace Tests\Feature\Api\V1\CompetitionScores;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class CompetitionScoresControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_competitions_and_counts(): void
+    {
+        $this->seedCompetitionData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/competition-scores');
+
+        $response->assertOk();
+        $response->assertJson([
+            'ok' => true,
+            'activeClassId' => 101,
+        ]);
+        $this->assertNotEmpty($response->json('competitions'));
+        $this->assertSame(1, $response->json('studentTotal'));
+    }
+
+    public function test_edit_returns_students_and_scores(): void
+    {
+        $this->seedCompetitionData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/competition-scores/1');
+
+        $response->assertOk();
+        $this->assertNotEmpty($response->json('students'));
+        $this->assertSame(5, $response->json('scoreMap.1'));
+        $this->assertSame(20, $response->json('questionCount'));
+    }
+
+    public function test_save_updates_scores(): void
+    {
+        $this->seedCompetitionData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/competition-scores/1', [
+            'class_section_id' => 101,
+            'scores' => [
+                1 => 10,
+            ],
+        ]);
+
+        $response->assertOk();
+        $response->assertJson([
+            'ok' => true,
+        ]);
+
+        $this->assertDatabaseHas('competition_scores', [
+            'competition_id' => 1,
+            'student_id' => 1,
+            'class_section_id' => 101,
+            'score' => 10,
+        ]);
+    }
+
+    private function seedCompetitionData(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('classes')->insert([
+            'id' => 1,
+            'class_name' => 'Class 1',
+            'schedule' => 'Sun',
+            'capacity' => 20,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 1,
+            'class_section_id' => 101,
+            'class_section_name' => '1-A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('teacher_class')->insert([
+            'class_section_id' => 101,
+            'teacher_id' => 1,
+            'position' => 'main',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 1,
+            'school_id' => 'S-1',
+            'firstname' => 'Student',
+            'lastname' => 'One',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 1,
+            'class_section_id' => 101,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('competitions')->insert([
+            'id' => 1,
+            'title' => 'Quiz',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'class_section_id' => 101,
+            'is_locked' => 0,
+        ]);
+
+        DB::table('competition_class_winners')->insert([
+            'competition_id' => 1,
+            'class_section_id' => 101,
+            'question_count' => 20,
+        ]);
+
+        DB::table('competition_scores')->insert([
+            'competition_id' => 1,
+            'student_id' => 1,
+            'class_section_id' => 101,
+            'score' => 5,
+        ]);
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/Discounts/DiscountControllerTest.php b/tests/Feature/Api/V1/Discounts/DiscountControllerTest.php
new file mode 100644
index 00000000..f7f4f07c
--- /dev/null
+++ b/tests/Feature/Api/V1/Discounts/DiscountControllerTest.php
@@ -0,0 +1,198 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Discounts;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class DiscountControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_options_returns_vouchers_and_parents(): void
+    {
+        $this->seedDiscountData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/discounts/options');
+
+        $response->assertOk();
+        $this->assertNotEmpty($response->json('vouchers'));
+        $this->assertNotEmpty($response->json('parents'));
+    }
+
+    public function test_apply_voucher_applies_discount(): void
+    {
+        $this->seedDiscountData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/discounts/apply', [
+            'voucher_id' => 1,
+            'parent_ids' => [10],
+            'allow_additional' => true,
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+
+        $this->assertDatabaseHas('discount_usages', [
+            'voucher_id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+        ]);
+    }
+
+    public function test_store_voucher_creates_row(): void
+    {
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/discounts/vouchers', [
+            'code' => 'NEW-10',
+            'discount_type' => 'percent',
+            'discount_value' => 10,
+            'is_active' => true,
+        ]);
+
+        $response->assertCreated();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('discount_vouchers', ['code' => 'NEW-10']);
+    }
+
+    public function test_show_voucher_returns_resource(): void
+    {
+        $this->seedDiscountData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/discounts/vouchers/1');
+
+        $response->assertOk();
+        $response->assertJson([
+            'ok' => true,
+            'voucher' => [
+                'id' => 1,
+                'code' => 'TEST-100',
+            ],
+        ]);
+    }
+
+    public function test_delete_voucher_removes_row(): void
+    {
+        $this->seedDiscountData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->deleteJson('/api/v1/discounts/vouchers/1');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseMissing('discount_vouchers', ['id' => 1]);
+    }
+
+    private function seedDiscountData(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'One',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('roles')->insert([
+            'id' => 1,
+            'name' => 'parent',
+            'slug' => 'parent',
+            'is_active' => 1,
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 10,
+            'role_id' => 1,
+        ]);
+
+        DB::table('discount_vouchers')->insert([
+            'id' => 1,
+            'code' => 'TEST-100',
+            'discount_type' => 'fixed',
+            'discount_value' => 100,
+            'max_uses' => 10,
+            'times_used' => 0,
+            'is_active' => 1,
+        ]);
+
+        DB::table('invoices')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_number' => 'INV-1',
+            'total_amount' => 100,
+            'balance' => 100,
+            'paid_amount' => 0,
+            'status' => 'Unpaid',
+            'issue_date' => '2025-09-01',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('enrollments')->insert([
+            'parent_id' => 10,
+            'student_id' => 1,
+            'school_year' => '2025-2026',
+            'enrollment_status' => 'payment pending',
+            'enrollment_date' => '2025-09-01',
+        ]);
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/Expenses/ExpenseControllerTest.php b/tests/Feature/Api/V1/Expenses/ExpenseControllerTest.php
new file mode 100644
index 00000000..2471a000
--- /dev/null
+++ b/tests/Feature/Api/V1/Expenses/ExpenseControllerTest.php
@@ -0,0 +1,236 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Expenses;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Storage;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class ExpenseControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_options_returns_staff_and_retailors(): void
+    {
+        $this->seedStaffUsers();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/expenses/options');
+
+        $response->assertOk();
+        $this->assertNotEmpty($response->json('staff'));
+        $this->assertNotEmpty($response->json('retailors'));
+    }
+
+    public function test_store_creates_expense(): void
+    {
+        $this->seedStaffUsers();
+
+        Storage::fake();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $file = UploadedFile::fake()->create('receipt.pdf', 10, 'application/pdf');
+
+        $response = $this->post('/api/v1/expenses', [
+            'category' => 'Expense',
+            'amount' => 25.5,
+            'purchased_by' => 2,
+            'retailor' => 'Amazon',
+            'date_of_purchase' => '2025-09-01',
+            'description' => 'Supplies',
+            'receipt' => $file,
+        ], ['Accept' => 'application/json']);
+
+        $response->assertCreated();
+        $response->assertJson(['ok' => true]);
+
+        $this->assertDatabaseHas('expenses', [
+            'category' => 'Expense',
+            'purchased_by' => 2,
+        ]);
+    }
+
+    public function test_index_lists_expenses(): void
+    {
+        $this->seedExpenseData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/expenses');
+
+        $response->assertOk();
+        $this->assertNotEmpty($response->json('expenses'));
+    }
+
+    public function test_show_returns_expense(): void
+    {
+        $this->seedExpenseData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/expenses/1');
+
+        $response->assertOk();
+        $response->assertJson([
+            'ok' => true,
+            'expense' => [
+                'id' => 1,
+                'category' => 'Expense',
+            ],
+        ]);
+    }
+
+    public function test_update_status_changes_status(): void
+    {
+        $this->seedExpenseData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/expenses/1/status', [
+            'status' => 'approved',
+            'reason' => 'Ok',
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+
+        $this->assertDatabaseHas('expenses', [
+            'id' => 1,
+            'status' => 'approved',
+        ]);
+    }
+
+    private function seedStaffUsers(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'administrator', 'slug' => 'administrator', 'is_active' => 1],
+            ['id' => 2, 'name' => 'parent', 'slug' => 'parent', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            [
+                'id' => 2,
+                'school_id' => 1,
+                'firstname' => 'Staff',
+                'lastname' => 'User',
+                'cellphone' => '5555555555',
+                'email' => 'staff@example.com',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 3,
+                'school_id' => 1,
+                'firstname' => 'Parent',
+                'lastname' => 'User',
+                'cellphone' => '5555555555',
+                'email' => 'parent@example.com',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('user_roles')->insert([
+            ['user_id' => 2, 'role_id' => 1],
+            ['user_id' => 3, 'role_id' => 2],
+        ]);
+    }
+
+    private function seedExpenseData(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 2,
+            'school_id' => 1,
+            'firstname' => 'Staff',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'staff@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('expenses')->insert([
+            'id' => 1,
+            'category' => 'Expense',
+            'amount' => 10,
+            'date_of_purchase' => '2025-09-01',
+            'purchased_by' => 2,
+            'added_by' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'status' => 'pending',
+        ]);
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/ExtraCharges/ExtraChargesControllerTest.php b/tests/Feature/Api/V1/ExtraCharges/ExtraChargesControllerTest.php
new file mode 100644
index 00000000..7a3d7ef2
--- /dev/null
+++ b/tests/Feature/Api/V1/ExtraCharges/ExtraChargesControllerTest.php
@@ -0,0 +1,261 @@
+<?php
+
+namespace Tests\Feature\Api\V1\ExtraCharges;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class ExtraChargesControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_returns_rows(): void
+    {
+        $this->seedBaseData();
+        $this->seedCharge();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/extra-charges');
+
+        $response->assertOk();
+        $this->assertNotEmpty($response->json('rows'));
+    }
+
+    public function test_options_returns_parent_options(): void
+    {
+        $this->seedBaseData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/extra-charges/options?q=Parent');
+
+        $response->assertOk();
+        $this->assertNotEmpty($response->json('parents'));
+    }
+
+    public function test_parent_options_returns_results(): void
+    {
+        $this->seedBaseData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/extra-charges/parents?q=Parent');
+
+        $response->assertOk();
+        $this->assertNotEmpty($response->json('results'));
+    }
+
+    public function test_invoices_for_parent_returns_results(): void
+    {
+        $this->seedBaseData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/extra-charges/invoices?parent_id=10&school_year=2025-2026');
+
+        $response->assertOk();
+        $this->assertNotEmpty($response->json('results'));
+    }
+
+    public function test_store_creates_charge_and_updates_invoice(): void
+    {
+        $this->seedBaseData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/extra-charges', [
+            'parent_id' => 10,
+            'title' => 'Books',
+            'amount' => 20,
+            'charge_type' => 'add',
+            'due_date' => '2025-09-01',
+            'invoice_id' => 1,
+            'description' => 'Extra books',
+        ]);
+
+        $response->assertCreated();
+        $response->assertJson(['ok' => true]);
+
+        $this->assertDatabaseHas('additional_charges', [
+            'parent_id' => 10,
+            'title' => 'Books',
+            'status' => 'applied',
+        ]);
+
+        $this->assertDatabaseHas('invoices', [
+            'id' => 1,
+            'total_amount' => 120,
+            'balance' => 120,
+        ]);
+    }
+
+    public function test_update_adjusts_charge(): void
+    {
+        $this->seedBaseData();
+        $this->seedCharge();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->putJson('/api/v1/extra-charges/1', [
+            'title' => 'Books Updated',
+            'amount' => 15,
+            'charge_type' => 'add',
+            'due_date' => '2025-09-01',
+            'description' => 'Updated',
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+
+        $this->assertDatabaseHas('additional_charges', [
+            'id' => 1,
+            'title' => 'Books Updated',
+        ]);
+    }
+
+    public function test_void_changes_status(): void
+    {
+        $this->seedBaseData();
+        $this->seedCharge();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/extra-charges/1/void');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('additional_charges', [
+            'id' => 1,
+            'status' => 'void',
+        ]);
+    }
+
+    public function test_reverse_changes_status(): void
+    {
+        $this->seedBaseData();
+        $this->seedCharge();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/extra-charges/1/reverse');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('additional_charges', [
+            'id' => 1,
+            'status' => 'pending',
+        ]);
+    }
+
+    private function seedBaseData(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'parent', 'slug' => 'parent', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 10,
+            'role_id' => 1,
+        ]);
+
+        DB::table('invoices')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_number' => 'INV-1',
+            'total_amount' => 100,
+            'balance' => 100,
+            'paid_amount' => 0,
+            'issue_date' => '2025-09-01',
+            'school_year' => '2025-2026',
+            'status' => 'Unpaid',
+        ]);
+    }
+
+    private function seedCharge(): void
+    {
+        DB::table('additional_charges')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'charge_type' => 'add',
+            'title' => 'Books',
+            'description' => 'Extra books',
+            'amount' => 10,
+            'due_date' => '2025-09-01',
+            'status' => 'applied',
+            'created_by' => 1,
+            'created_at' => '2025-09-01 00:00:00',
+        ]);
+
+        DB::table('invoices')->where('id', 1)->update([
+            'total_amount' => 110,
+            'balance' => 110,
+        ]);
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/Finance/FinancialControllerTest.php b/tests/Feature/Api/V1/Finance/FinancialControllerTest.php
new file mode 100644
index 00000000..19077ce3
--- /dev/null
+++ b/tests/Feature/Api/V1/Finance/FinancialControllerTest.php
@@ -0,0 +1,193 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Finance;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class FinancialControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_report_returns_financial_report(): void
+    {
+        $this->seedFinancialData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/finance/financial-report?school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('report.invoices'));
+    }
+
+    public function test_summary_returns_totals(): void
+    {
+        $this->seedFinancialData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/finance/financial-summary?school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertGreaterThan(0, (float) $response->json('summary.totalCharges'));
+    }
+
+    public function test_unpaid_parents_lists_balances(): void
+    {
+        $this->seedFinancialData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/finance/unpaid-parents?school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('results'));
+    }
+
+    private function seedFinancialData(): void
+    {
+        DB::table('users')->insert([
+            [
+                'id' => 2,
+                'school_id' => 1,
+                'firstname' => 'Parent',
+                'lastname' => 'User',
+                'cellphone' => '5555555555',
+                'email' => 'parent@example.com',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('invoices')->insert([
+            [
+                'id' => 1,
+                'parent_id' => 2,
+                'invoice_number' => 'INV-001',
+                'total_amount' => 100,
+                'balance' => 40,
+                'paid_amount' => 60,
+                'has_discount' => 1,
+                'issue_date' => '2025-01-10',
+                'due_date' => '2025-02-10',
+                'status' => 'unpaid',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 2,
+                'parent_id' => 2,
+                'invoice_number' => 'INV-002',
+                'total_amount' => 50,
+                'balance' => 50,
+                'paid_amount' => 0,
+                'has_discount' => 0,
+                'issue_date' => '2025-02-01',
+                'due_date' => '2025-03-01',
+                'status' => 'unpaid',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 2,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 60,
+            'balance' => 40,
+            'number_of_installments' => 1,
+            'payment_method' => 'Cash',
+            'payment_date' => '2025-01-15',
+            'school_year' => '2025-2026',
+            'status' => 'Paid',
+        ]);
+
+        DB::table('discount_usages')->insert([
+            'id' => 1,
+            'voucher_id' => 1,
+            'invoice_id' => 1,
+            'parent_id' => 2,
+            'discount_amount' => 10,
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('refunds')->insert([
+            'id' => 1,
+            'parent_id' => 2,
+            'school_year' => '2025-2026',
+            'invoice_id' => 1,
+            'refund_amount' => 5,
+            'status' => 'Paid',
+            'refund_paid_amount' => 5,
+        ]);
+
+        DB::table('expenses')->insert([
+            'id' => 1,
+            'category' => 'Expense',
+            'amount' => 20,
+            'date_of_purchase' => '2025-01-05',
+            'purchased_by' => 2,
+            'added_by' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'status' => 'approved',
+        ]);
+
+        DB::table('reimbursements')->insert([
+            'id' => 1,
+            'expense_id' => 1,
+            'amount' => 15,
+            'reimbursed_to' => 2,
+            'added_by' => 1,
+            'status' => 'Paid',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/Finance/InvoiceControllerTest.php b/tests/Feature/Api/V1/Finance/InvoiceControllerTest.php
new file mode 100644
index 00000000..3dd376c5
--- /dev/null
+++ b/tests/Feature/Api/V1/Finance/InvoiceControllerTest.php
@@ -0,0 +1,166 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Finance;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class InvoiceControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_management_returns_parent_invoice_data(): void
+    {
+        $this->seedBaseData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/finance/invoices/management?school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('invoices'));
+    }
+
+    public function test_generate_creates_invoice(): void
+    {
+        $this->seedBaseData(false);
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->postJson('/api/v1/finance/invoices/generate', [
+            'parent_id' => 10,
+            'school_year' => '2025-2026',
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('invoices', [
+            'parent_id' => 10,
+            'school_year' => '2025-2026',
+        ]);
+    }
+
+    public function test_by_parent_returns_invoices(): void
+    {
+        $this->seedBaseData();
+
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/finance/invoices/parent/10?school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('invoices'));
+    }
+
+    private function seedBaseData(bool $withInvoice = true): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'parent', 'slug' => 'parent', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 10,
+            'role_id' => 1,
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+        ]);
+
+        DB::table('enrollments')->insert([
+            'student_id' => 100,
+            'parent_id' => 10,
+            'class_section_id' => 1,
+            'enrollment_status' => 'enrolled',
+            'school_year' => '2025-2026',
+        ]);
+
+        if ($withInvoice) {
+            DB::table('invoices')->insert([
+                'id' => 1,
+                'parent_id' => 10,
+                'invoice_number' => 'INV-001',
+                'total_amount' => 100,
+                'balance' => 100,
+                'paid_amount' => 0,
+                'has_discount' => 0,
+                'issue_date' => '2025-01-10',
+                'status' => 'unpaid',
+                'school_year' => '2025-2026',
+            ]);
+        }
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/Finance/PaymentControllerTest.php b/tests/Feature/Api/V1/Finance/PaymentControllerTest.php
new file mode 100644
index 00000000..29ef9aef
--- /dev/null
+++ b/tests/Feature/Api/V1/Finance/PaymentControllerTest.php
@@ -0,0 +1,153 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Finance;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class PaymentControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_store_creates_payment_plan(): void
+    {
+        $this->seedUsers();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->postJson('/api/v1/finance/payments', [
+            'parent_id' => 10,
+            'total_amount' => 250,
+            'number_of_installments' => 2,
+            'payment_date' => '2025-01-05',
+            'payment_method' => 'cash',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $response->assertStatus(201);
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('payments', [
+            'parent_id' => 10,
+            'total_amount' => 250,
+            'number_of_installments' => 2,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+    }
+
+    public function test_by_parent_returns_payments(): void
+    {
+        $this->seedUsers();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 25,
+            'balance' => 75,
+            'number_of_installments' => 1,
+            'payment_method' => 'cash',
+            'payment_date' => '2025-01-01',
+            'school_year' => '2025-2026',
+            'status' => 'Partially Paid',
+        ]);
+
+        $response = $this->getJson('/api/v1/finance/payments/parent/10?school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('payments'));
+    }
+
+    public function test_update_balance_updates_payment(): void
+    {
+        $this->seedUsers();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 0,
+            'balance' => 100,
+            'number_of_installments' => 1,
+            'payment_method' => 'cash',
+            'payment_date' => '2025-01-01',
+            'school_year' => '2025-2026',
+            'status' => 'Pending',
+        ]);
+
+        $response = $this->postJson('/api/v1/finance/payments/1/balance', [
+            'paid_amount' => 25,
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('payments', [
+            'id' => 1,
+            'paid_amount' => 25,
+            'balance' => 75,
+        ]);
+    }
+
+    private function seedUsers(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'admin', 'slug' => 'admin', 'is_active' => 1],
+            ['id' => 2, 'name' => 'parent', 'slug' => 'parent', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            ['user_id' => 1, 'role_id' => 1],
+            ['user_id' => 10, 'role_id' => 2],
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Finance/PaymentEventChargesControllerTest.php b/tests/Feature/Api/V1/Finance/PaymentEventChargesControllerTest.php
new file mode 100644
index 00000000..e5a84398
--- /dev/null
+++ b/tests/Feature/Api/V1/Finance/PaymentEventChargesControllerTest.php
@@ -0,0 +1,108 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Finance;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class PaymentEventChargesControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_store_creates_event_charges(): void
+    {
+        $this->seedUsers();
+        $this->seedStudents();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->postJson('/api/v1/finance/event-charges', [
+            'parent_id' => 10,
+            'event_name' => 'Field Trip',
+            'description' => 'Bus fee',
+            'amount' => 25,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'student_ids' => [100],
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('event_charges', [
+            'parent_id' => 10,
+            'student_id' => 100,
+            'event_name' => 'Field Trip',
+            'amount' => 25,
+            'school_year' => '2025-2026',
+        ]);
+    }
+
+    private function seedUsers(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'admin', 'slug' => 'admin', 'is_active' => 1],
+            ['id' => 2, 'name' => 'parent', 'slug' => 'parent', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            ['user_id' => 1, 'role_id' => 1],
+            ['user_id' => 10, 'role_id' => 2],
+        ]);
+    }
+
+    private function seedStudents(): void
+    {
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Finance/PaymentManualControllerTest.php b/tests/Feature/Api/V1/Finance/PaymentManualControllerTest.php
new file mode 100644
index 00000000..a893d554
--- /dev/null
+++ b/tests/Feature/Api/V1/Finance/PaymentManualControllerTest.php
@@ -0,0 +1,132 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Finance;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class PaymentManualControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_search_returns_parent_data(): void
+    {
+        $this->seedUsers();
+        $this->seedConfig();
+        $this->seedStudent();
+        $this->seedInvoice();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->getJson('/api/v1/finance/manual-pay/search?search_term=parent@example.com');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertSame(10, $response->json('parent.id'));
+    }
+
+    public function test_suggest_returns_items(): void
+    {
+        $this->seedUsers();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->getJson('/api/v1/finance/manual-pay/suggest?q=parent');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('items'));
+    }
+
+    private function seedUsers(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'admin', 'slug' => 'admin', 'is_active' => 1],
+            ['id' => 2, 'name' => 'parent', 'slug' => 'parent', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            ['user_id' => 1, 'role_id' => 1],
+            ['user_id' => 10, 'role_id' => 2],
+        ]);
+    }
+
+    private function seedConfig(): void
+    {
+        DB::table('configuration')->insert([
+            ['config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['config_key' => 'semester', 'config_value' => 'Fall'],
+            ['config_key' => 'installment_date', 'config_value' => '2025-06-01'],
+        ]);
+    }
+
+    private function seedStudent(): void
+    {
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+    }
+
+    private function seedInvoice(): void
+    {
+        DB::table('invoices')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_number' => 'INV-001',
+            'total_amount' => 100,
+            'balance' => 100,
+            'paid_amount' => 0,
+            'status' => 'unpaid',
+            'school_year' => '2025-2026',
+            'issue_date' => '2025-01-01',
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Finance/PaymentNotificationControllerTest.php b/tests/Feature/Api/V1/Finance/PaymentNotificationControllerTest.php
new file mode 100644
index 00000000..80e51779
--- /dev/null
+++ b/tests/Feature/Api/V1/Finance/PaymentNotificationControllerTest.php
@@ -0,0 +1,141 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Finance;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Mail;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class PaymentNotificationControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_send_creates_log(): void
+    {
+        Mail::fake();
+        $this->seedUsers();
+        $this->seedConfig();
+        $this->seedInvoice();
+
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->postJson('/api/v1/finance/payment-notifications/send', [
+            'parent_id' => 10,
+            'school_year' => '2025-2026',
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('payment_notification_logs', [
+            'parent_id' => 10,
+            'school_year' => '2025-2026',
+        ]);
+    }
+
+    public function test_index_lists_logs(): void
+    {
+        $this->seedUsers();
+
+        DB::table('payment_notification_logs')->insert([
+            'parent_id' => 10,
+            'school_year' => '2025-2026',
+            'period_year' => 2025,
+            'period_month' => 1,
+            'type' => 'installment',
+            'to_email' => 'parent@example.com',
+            'status' => 'sent',
+            'balance_snapshot' => 100,
+            'sent_at' => '2025-01-01 10:00:00',
+        ]);
+
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->getJson('/api/v1/finance/payment-notifications');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('logs'));
+    }
+
+    private function seedUsers(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'admin', 'slug' => 'admin', 'is_active' => 1],
+            ['id' => 2, 'name' => 'parent', 'slug' => 'parent', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            ['user_id' => 1, 'role_id' => 1],
+            ['user_id' => 10, 'role_id' => 2],
+        ]);
+    }
+
+    private function seedConfig(): void
+    {
+        DB::table('configuration')->insert([
+            ['config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['config_key' => 'semester', 'config_value' => 'Fall'],
+            ['config_key' => 'installment_date', 'config_value' => '2025-06-01'],
+        ]);
+    }
+
+    private function seedInvoice(): void
+    {
+        DB::table('invoices')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_number' => 'INV-001',
+            'total_amount' => 200,
+            'balance' => 200,
+            'paid_amount' => 0,
+            'status' => 'unpaid',
+            'school_year' => '2025-2026',
+            'issue_date' => '2025-01-01',
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Finance/PaymentTransactionControllerTest.php b/tests/Feature/Api/V1/Finance/PaymentTransactionControllerTest.php
new file mode 100644
index 00000000..036c005f
--- /dev/null
+++ b/tests/Feature/Api/V1/Finance/PaymentTransactionControllerTest.php
@@ -0,0 +1,136 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Finance;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class PaymentTransactionControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_store_creates_transaction(): void
+    {
+        $this->seedUsers();
+        $this->seedPayment();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->postJson('/api/v1/finance/payment-transactions', [
+            'transaction_id' => 'TXN-1001',
+            'payment_id' => 1,
+            'transaction_date' => '2025-01-10',
+            'amount' => 25,
+            'payment_method' => 'cash',
+        ]);
+
+        $response->assertStatus(201);
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('payment_transactions', [
+            'transaction_id' => 'TXN-1001',
+            'payment_id' => 1,
+            'amount' => 25,
+        ]);
+    }
+
+    public function test_by_payment_returns_transactions(): void
+    {
+        $this->seedUsers();
+        $this->seedPayment();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('payment_transactions')->insert([
+            'transaction_id' => 'TXN-1002',
+            'payment_id' => 1,
+            'transaction_date' => '2025-01-11',
+            'amount' => 40,
+            'payment_method' => 'cash',
+            'payment_status' => 'Pending',
+        ]);
+
+        $response = $this->getJson('/api/v1/finance/payment-transactions/payment/1');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('transactions'));
+    }
+
+    public function test_update_status_updates_transaction(): void
+    {
+        $this->seedUsers();
+        $this->seedPayment();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('payment_transactions')->insert([
+            'transaction_id' => 'TXN-1003',
+            'payment_id' => 1,
+            'transaction_date' => '2025-01-11',
+            'amount' => 40,
+            'payment_method' => 'cash',
+            'payment_status' => 'Pending',
+        ]);
+
+        $response = $this->postJson('/api/v1/finance/payment-transactions/TXN-1003/status', [
+            'status' => 'Completed',
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('payment_transactions', [
+            'transaction_id' => 'TXN-1003',
+            'payment_status' => 'Completed',
+        ]);
+    }
+
+    private function seedUsers(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'admin', 'slug' => 'admin', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+    }
+
+    private function seedPayment(): void
+    {
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 0,
+            'balance' => 100,
+            'number_of_installments' => 1,
+            'payment_method' => 'cash',
+            'payment_date' => '2025-01-01',
+            'school_year' => '2025-2026',
+            'status' => 'Pending',
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Finance/PaypalTransactionsControllerTest.php b/tests/Feature/Api/V1/Finance/PaypalTransactionsControllerTest.php
new file mode 100644
index 00000000..1c3ee1c5
--- /dev/null
+++ b/tests/Feature/Api/V1/Finance/PaypalTransactionsControllerTest.php
@@ -0,0 +1,98 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Finance;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class PaypalTransactionsControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_transactions(): void
+    {
+        $this->seedUsers();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('paypal_payments')->insert([
+            'id' => 1,
+            'transaction_id' => 'PP-1001',
+            'order_id' => 'ORDER-1',
+            'parent_school_id' => 10,
+            'payer_email' => 'payer@example.com',
+            'amount' => 50,
+            'net_amount' => 48,
+            'currency' => 'USD',
+            'status' => 'COMPLETED',
+            'event_type' => 'PAYMENT.SALE.COMPLETED',
+            'created_at' => '2025-01-01 10:00:00',
+        ]);
+
+        $response = $this->getJson('/api/v1/finance/paypal-transactions');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('transactions'));
+    }
+
+    public function test_csv_download(): void
+    {
+        $this->seedUsers();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('paypal_payments')->insert([
+            'id' => 1,
+            'transaction_id' => 'PP-1002',
+            'order_id' => 'ORDER-2',
+            'parent_school_id' => 10,
+            'payer_email' => 'payer@example.com',
+            'amount' => 60,
+            'net_amount' => 58,
+            'currency' => 'USD',
+            'status' => 'COMPLETED',
+            'event_type' => 'PAYMENT.SALE.COMPLETED',
+            'created_at' => '2025-01-01 10:00:00',
+        ]);
+
+        $response = $this->get('/api/v1/finance/paypal-transactions/csv');
+
+        $response->assertOk();
+        $response->assertHeader('Content-Type', 'text/csv');
+    }
+
+    private function seedUsers(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'admin', 'slug' => 'admin', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Finance/ReimbursementControllerTest.php b/tests/Feature/Api/V1/Finance/ReimbursementControllerTest.php
new file mode 100644
index 00000000..9950f880
--- /dev/null
+++ b/tests/Feature/Api/V1/Finance/ReimbursementControllerTest.php
@@ -0,0 +1,185 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Finance;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class ReimbursementControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_create_batch_creates_open_batch(): void
+    {
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        DB::table('configuration')->insert([
+            ['config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        $response = $this->postJson('/api/v1/finance/reimbursements/batches', [
+            'title' => 'Test Batch',
+        ]);
+
+        $response->assertCreated();
+        $response->assertJsonPath('ok', true);
+
+        $this->assertDatabaseHas('reimbursement_batches', [
+            'title' => 'Test Batch',
+            'status' => 'open',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+    }
+
+    public function test_mark_donation_updates_expense(): void
+    {
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        DB::table('expenses')->insert([
+            'id' => 1,
+            'category' => 'Expense',
+            'amount' => 12.00,
+            'date_of_purchase' => '2025-02-01',
+            'added_by' => $user->id,
+            'purchased_by' => $user->id,
+            'status' => 'approved',
+        ]);
+
+        $response = $this->postJson('/api/v1/finance/reimbursements/mark-donation', [
+            'expense_id' => 1,
+        ]);
+
+        $response->assertOk();
+        $response->assertJsonPath('ok', true);
+
+        $this->assertDatabaseHas('expenses', [
+            'id' => 1,
+            'category' => 'Donation',
+            'status' => 'approved',
+        ]);
+    }
+
+    public function test_store_reimbursement_creates_record_and_updates_expense(): void
+    {
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        DB::table('users')->insert([
+            'id' => 2,
+            'school_id' => 1,
+            'firstname' => 'Recipient',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'recipient@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('expenses')->insert([
+            'id' => 2,
+            'category' => 'Expense',
+            'amount' => 50.00,
+            'date_of_purchase' => '2025-02-05',
+            'added_by' => $user->id,
+            'purchased_by' => $user->id,
+            'status' => 'approved',
+        ]);
+
+        $response = $this->postJson('/api/v1/finance/reimbursements', [
+            'expense_id' => 2,
+            'amount' => 50.00,
+            'reimbursed_to' => 2,
+            'reimbursement_method' => 'Cash',
+            'description' => 'Test reimbursement',
+        ]);
+
+        $response->assertCreated();
+        $response->assertJsonPath('ok', true);
+
+        $this->assertDatabaseHas('reimbursements', [
+            'expense_id' => 2,
+            'amount' => 50.00,
+            'reimbursed_to' => 2,
+            'status' => 'Paid',
+        ]);
+
+        $this->assertDatabaseMissing('expenses', [
+            'id' => 2,
+            'reimbursement_id' => null,
+        ]);
+    }
+
+    public function test_update_reimbursement_updates_fields(): void
+    {
+        $user = $this->createUser();
+        Sanctum::actingAs($user);
+
+        DB::table('reimbursements')->insert([
+            'id' => 10,
+            'amount' => 25.00,
+            'reimbursed_to' => $user->id,
+            'added_by' => $user->id,
+            'status' => 'Paid',
+            'reimbursement_method' => 'Cash',
+        ]);
+
+        $response = $this->putJson('/api/v1/finance/reimbursements/10', [
+            'amount' => 30.00,
+            'reimbursed_to' => $user->id,
+            'reimbursement_method' => 'Cash',
+            'description' => 'Updated',
+        ]);
+
+        $response->assertOk();
+        $response->assertJsonPath('ok', true);
+
+        $this->assertDatabaseHas('reimbursements', [
+            'id' => 10,
+            'amount' => 30.00,
+            'description' => 'Updated',
+        ]);
+    }
+
+    private function createUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/Grading/GradingControllerTest.php b/tests/Feature/Api/V1/Grading/GradingControllerTest.php
new file mode 100644
index 00000000..2fa850d1
--- /dev/null
+++ b/tests/Feature/Api/V1/Grading/GradingControllerTest.php
@@ -0,0 +1,129 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Grading;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class GradingControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_overview_returns_grading_data(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->getJson('/api/v1/grading/overview?school_year=2025-2026&semester=Fall&class_id=1');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('grades'));
+    }
+
+    public function test_toggle_lock_locks_section(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->postJson('/api/v1/grading/locks/toggle', [
+            'class_section_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('grading_locks', [
+            'class_section_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'is_locked' => 1,
+        ]);
+    }
+
+    private function seedBase(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+            ['id' => 3, 'config_key' => 'parent_scores_released_fall', 'config_value' => '0'],
+            ['id' => 4, 'config_key' => 'parent_scores_released_spring', 'config_value' => '0'],
+        ]);
+
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'id' => 1,
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'age' => 10,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'id' => 1,
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+
+        DB::table('semester_scores')->insert([
+            'id' => 1,
+            'student_id' => 100,
+            'school_id' => 1,
+            'class_section_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'semester_score' => 88,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Grading/HomeworkTrackingControllerTest.php b/tests/Feature/Api/V1/Grading/HomeworkTrackingControllerTest.php
new file mode 100644
index 00000000..439c5633
--- /dev/null
+++ b/tests/Feature/Api/V1/Grading/HomeworkTrackingControllerTest.php
@@ -0,0 +1,79 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Grading;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class HomeworkTrackingControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_tracking_payload(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'id' => 1,
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('teacher_class')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'teacher_id' => 1,
+            'position' => 'main',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->getJson('/api/v1/grading/homework-tracking?school_year=2025-2026&semester=Fall');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('teachers'));
+    }
+}
diff --git a/tests/Feature/Api/V1/Incidents/IncidentControllerTest.php b/tests/Feature/Api/V1/Incidents/IncidentControllerTest.php
new file mode 100644
index 00000000..9f001c79
--- /dev/null
+++ b/tests/Feature/Api/V1/Incidents/IncidentControllerTest.php
@@ -0,0 +1,158 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Incidents;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class IncidentControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_current_returns_incidents_and_grades(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        $user = $this->seedUser();
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 10,
+            'parent_id' => 99,
+            'firstname' => 'Kid',
+            'lastname' => 'Tester',
+            'school_id' => '1',
+            'age' => 10,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'id' => 1,
+            'student_id' => 10,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+
+        DB::table('current_incident')->insert([
+            'id' => 1,
+            'student_id' => 10,
+            'student_name' => 'Kid Tester',
+            'grade' => '1',
+            'incident' => 'behavior',
+            'incident_datetime' => '2025-01-01 10:00:00',
+            'incident_state' => 'Open',
+            'updated_by_open' => $user->id,
+            'open_description' => 'Initial',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        Sanctum::actingAs($user);
+
+        $response = $this->getJson('/api/v1/incidents/current');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $response->assertJsonCount(1, 'incidents');
+        $response->assertJsonCount(1, 'grades');
+        $response->assertJsonPath('incidents.0.updated_by_open_name', 'Test User');
+    }
+
+    public function test_store_and_close_moves_incident_to_history(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        $user = $this->seedUser();
+
+        DB::table('students')->insert([
+            'id' => 11,
+            'parent_id' => 99,
+            'firstname' => 'Kid',
+            'lastname' => 'Closer',
+            'school_id' => '1',
+            'age' => 11,
+            'gender' => 'F',
+            'photo_consent' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+
+        Sanctum::actingAs($user);
+
+        $storeResponse = $this->postJson('/api/v1/incidents', [
+            'student_id' => 11,
+            'grade' => '1',
+            'incident' => 'behavior',
+            'description' => 'Needs attention',
+        ]);
+
+        $storeResponse->assertOk();
+        $storeResponse->assertJson(['ok' => true, 'created' => true]);
+        $currentId = $storeResponse->json('incident_id');
+
+        $closeResponse = $this->postJson('/api/v1/incidents/' . $currentId . '/close', [
+            'state_description' => 'Resolved',
+            'action_taken' => 'Spoke with student',
+        ]);
+
+        $closeResponse->assertOk();
+        $closeResponse->assertJson(['ok' => true]);
+
+        $historyId = $closeResponse->json('incident_id');
+
+        $this->assertDatabaseHas('incident', [
+            'id' => $historyId,
+            'student_id' => 11,
+            'incident_state' => 'Closed',
+        ]);
+        $this->assertDatabaseMissing('current_incident', ['id' => $currentId]);
+    }
+
+    private function seedUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Test',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'test@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/Reports/FilesControllerTest.php b/tests/Feature/Api/V1/Reports/FilesControllerTest.php
new file mode 100644
index 00000000..978613d2
--- /dev/null
+++ b/tests/Feature/Api/V1/Reports/FilesControllerTest.php
@@ -0,0 +1,100 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Reports;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class FilesControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_receipt_meta_returns_file_payload(): void
+    {
+        $user = $this->seedUser();
+        Sanctum::actingAs($user);
+
+        $dir = storage_path('uploads/receipts');
+        if (!is_dir($dir)) {
+            mkdir($dir, 0777, true);
+        }
+        $path = $dir . DIRECTORY_SEPARATOR . 'sample.pdf';
+        file_put_contents($path, 'PDFDATA');
+
+        $response = $this->getJson('/api/v1/files/receipts/sample.pdf?meta=1');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $response->assertJsonPath('file.name', 'sample.pdf');
+        $response->assertJsonPath('file.size', 7);
+    }
+
+    public function test_exam_draft_teacher_streams_with_download_name(): void
+    {
+        $user = $this->seedUser();
+        Sanctum::actingAs($user);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('exam_drafts')->insert([
+            'id' => 1,
+            'teacher_id' => 1,
+            'class_section_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'exam_type' => 'Midterm',
+            'draft_title' => 'Draft',
+            'teacher_file' => 'draft1.pdf',
+            'version' => 2,
+            'status' => 'draft',
+        ]);
+
+        $dir = storage_path('uploads/exams/drafts');
+        if (!is_dir($dir)) {
+            mkdir($dir, 0777, true);
+        }
+        $path = $dir . DIRECTORY_SEPARATOR . 'draft1.pdf';
+        file_put_contents($path, 'PDFDATA');
+
+        $response = $this->get('/api/v1/files/exams/teacher/draft1.pdf');
+
+        $response->assertOk();
+        $response->assertHeader('Content-Disposition', 'inline; filename="1a_midterm_v2.pdf"');
+    }
+
+    private function seedUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Test',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'test@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/Scores/FinalControllerTest.php b/tests/Feature/Api/V1/Scores/FinalControllerTest.php
new file mode 100644
index 00000000..314eb79f
--- /dev/null
+++ b/tests/Feature/Api/V1/Scores/FinalControllerTest.php
@@ -0,0 +1,91 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Scores;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class FinalControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_final_scores(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('final_exam')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'score' => 90,
+            'semester' => 'Spring',
+            'school_year' => '2025-2026',
+            'created_at' => now(),
+            'updated_at' => now(),
+        ]);
+
+        $response = $this->getJson('/api/v1/scores/final?class_section_id=1&semester=Spring&school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('students'));
+    }
+
+    private function seedBase(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Spring',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Scores/HomeworkControllerTest.php b/tests/Feature/Api/V1/Scores/HomeworkControllerTest.php
new file mode 100644
index 00000000..877706e0
--- /dev/null
+++ b/tests/Feature/Api/V1/Scores/HomeworkControllerTest.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Scores;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class HomeworkControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_homework_scores(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('homework')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'homework_index' => 1,
+            'score' => 90,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'created_at' => now(),
+            'updated_at' => now(),
+        ]);
+
+        $response = $this->getJson('/api/v1/scores/homework?class_section_id=1&semester=Fall&school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('students'));
+    }
+
+    private function seedBase(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Scores/MidtermControllerTest.php b/tests/Feature/Api/V1/Scores/MidtermControllerTest.php
new file mode 100644
index 00000000..59a18db7
--- /dev/null
+++ b/tests/Feature/Api/V1/Scores/MidtermControllerTest.php
@@ -0,0 +1,91 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Scores;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class MidtermControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_midterm_scores(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('midterm_exam')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'score' => 85,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'created_at' => now(),
+            'updated_at' => now(),
+        ]);
+
+        $response = $this->getJson('/api/v1/scores/midterm?class_section_id=1&semester=Fall&school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('students'));
+    }
+
+    private function seedBase(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Scores/ParticipationControllerTest.php b/tests/Feature/Api/V1/Scores/ParticipationControllerTest.php
new file mode 100644
index 00000000..b0a7b5e1
--- /dev/null
+++ b/tests/Feature/Api/V1/Scores/ParticipationControllerTest.php
@@ -0,0 +1,104 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Scores;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class ParticipationControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_participation_scores(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('participation')->insert([
+            'id' => 1,
+            'student_id' => 100,
+            'school_id' => 1,
+            'class_section_id' => 1,
+            'updated_by' => 1,
+            'score' => 93,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'created_at' => now(),
+            'updated_at' => now(),
+        ]);
+
+        $response = $this->getJson('/api/v1/scores/participation?class_section_id=1&semester=Fall&school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('students'));
+    }
+
+    private function seedBase(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'id' => 1,
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'age' => 10,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'id' => 1,
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Scores/ProjectControllerTest.php b/tests/Feature/Api/V1/Scores/ProjectControllerTest.php
new file mode 100644
index 00000000..cf188e50
--- /dev/null
+++ b/tests/Feature/Api/V1/Scores/ProjectControllerTest.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Scores;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class ProjectControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_project_scores(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('project')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'project_index' => 1,
+            'score' => 95,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'created_at' => now(),
+            'updated_at' => now(),
+        ]);
+
+        $response = $this->getJson('/api/v1/scores/projects?class_section_id=1&semester=Fall&school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('students'));
+    }
+
+    private function seedBase(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Scores/QuizControllerTest.php b/tests/Feature/Api/V1/Scores/QuizControllerTest.php
new file mode 100644
index 00000000..c1f6e22b
--- /dev/null
+++ b/tests/Feature/Api/V1/Scores/QuizControllerTest.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Scores;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class QuizControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_quiz_scores(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('quiz')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'quiz_index' => 1,
+            'score' => 88,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'created_at' => now(),
+            'updated_at' => now(),
+        ]);
+
+        $response = $this->getJson('/api/v1/scores/quizzes?class_section_id=1&semester=Fall&school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('students'));
+    }
+
+    private function seedBase(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Scores/ScoreCommentControllerTest.php b/tests/Feature/Api/V1/Scores/ScoreCommentControllerTest.php
new file mode 100644
index 00000000..81e2ce21
--- /dev/null
+++ b/tests/Feature/Api/V1/Scores/ScoreCommentControllerTest.php
@@ -0,0 +1,111 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Scores;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class ScoreCommentControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_store_rejects_short_comment(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->postJson('/api/v1/scores/comments', [
+            'class_section_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'comments' => [
+                100 => [
+                    'ptap' => 'Too short',
+                ],
+            ],
+        ]);
+
+        $response->assertStatus(422);
+    }
+
+    public function test_index_returns_comments(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('score_comments')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'score_type' => 'ptap',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'comment' => 'Kid is doing great in class and shows effort and focus in every session.',
+            'commented_by' => 1,
+            'created_at' => now(),
+        ]);
+
+        $response = $this->getJson('/api/v1/scores/comments?class_section_id=1&semester=Fall&school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('students'));
+    }
+
+    private function seedBase(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Scores/ScoreControllerTest.php b/tests/Feature/Api/V1/Scores/ScoreControllerTest.php
new file mode 100644
index 00000000..30a16353
--- /dev/null
+++ b/tests/Feature/Api/V1/Scores/ScoreControllerTest.php
@@ -0,0 +1,117 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Scores;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class ScoreControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_overview_returns_students(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('teacher_class')->insert([
+            'teacher_id' => 1,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+
+        $response = $this->getJson('/api/v1/scores/overview?class_section_id=1&semester=Fall&school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('students'));
+    }
+
+    public function test_lock_creates_grading_lock(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        $response = $this->postJson('/api/v1/scores/lock', [
+            'class_section_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'missing_ok' => [],
+        ]);
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertDatabaseHas('grading_locks', [
+            'class_section_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'is_locked' => 1,
+        ]);
+    }
+
+    private function seedBase(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'age' => 10,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+            'semester' => 'Fall',
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/Scores/ScorePredictorControllerTest.php b/tests/Feature/Api/V1/Scores/ScorePredictorControllerTest.php
new file mode 100644
index 00000000..60ab3365
--- /dev/null
+++ b/tests/Feature/Api/V1/Scores/ScorePredictorControllerTest.php
@@ -0,0 +1,108 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Scores;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class ScorePredictorControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_index_returns_predictions(): void
+    {
+        $this->seedBase();
+        Sanctum::actingAs(User::query()->findOrFail(1));
+
+        DB::table('semester_scores')->insert([
+            'id' => 1,
+            'student_id' => 100,
+            'school_id' => 1,
+            'class_section_id' => 1,
+            'semester' => 'spring',
+            'school_year' => '2025-2026',
+            'semester_score' => 90,
+        ]);
+
+        $response = $this->getJson('/api/v1/scores/predictor?school_year=2025-2026&class_section_id=1');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $this->assertNotEmpty($response->json('students'));
+    }
+
+    private function seedBase(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+            ['id' => 3, 'config_key' => 'trophy_score', 'config_value' => '94'],
+            ['id' => 4, 'config_key' => 'pass_score', 'config_value' => '60'],
+        ]);
+
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'teacher', 'slug' => 'teacher', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'id' => 1,
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'age' => 10,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'id' => 1,
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Feature/Api/V1/System/SemesterRangeControllerTest.php b/tests/Feature/Api/V1/System/SemesterRangeControllerTest.php
new file mode 100644
index 00000000..da2577fc
--- /dev/null
+++ b/tests/Feature/Api/V1/System/SemesterRangeControllerTest.php
@@ -0,0 +1,74 @@
+<?php
+
+namespace Tests\Feature\Api\V1\System;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class SemesterRangeControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_school_year_range_uses_config_dates(): void
+    {
+        $user = $this->seedUser();
+        Sanctum::actingAs($user);
+
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'fall_semester_start', 'config_value' => '2025-09-05'],
+            ['id' => 2, 'config_key' => 'last_school_day', 'config_value' => '2026-06-15'],
+        ]);
+
+        $response = $this->getJson('/api/v1/system/semester-range/school-year?school_year=2025-2026');
+
+        $response->assertOk();
+        $response->assertJsonPath('range.start_date', '2025-09-05');
+        $response->assertJsonPath('range.end_date', '2026-06-15');
+    }
+
+    public function test_resolve_returns_semester_for_date(): void
+    {
+        $user = $this->seedUser();
+        Sanctum::actingAs($user);
+
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'fall_semester_start', 'config_value' => '2025-09-01'],
+            ['id' => 2, 'config_key' => 'spring_semester_start', 'config_value' => '2026-01-20'],
+            ['id' => 3, 'config_key' => 'last_school_day', 'config_value' => '2026-06-01'],
+        ]);
+
+        $response = $this->getJson('/api/v1/system/semester-range/resolve?date=2025-10-01');
+
+        $response->assertOk();
+        $response->assertJsonPath('resolution.semester', 'Fall');
+    }
+
+    private function seedUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Test',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'test@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Feature/Api/V1/Users/UserControllerTest.php b/tests/Feature/Api/V1/Users/UserControllerTest.php
new file mode 100644
index 00000000..bb2f1f73
--- /dev/null
+++ b/tests/Feature/Api/V1/Users/UserControllerTest.php
@@ -0,0 +1,153 @@
+<?php
+
+namespace Tests\Feature\Api\V1\Users;
+
+use App\Models\User;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Laravel\Sanctum\Sanctum;
+use Tests\TestCase;
+
+class UserControllerTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_user_list_returns_users_with_roles(): void
+    {
+        $admin = $this->seedUser(1, 'admin@example.com');
+        Sanctum::actingAs($admin);
+
+        DB::table('roles')->insert([
+            'id' => 10,
+            'name' => 'Teacher',
+            'slug' => 'teacher',
+            'description' => 'Teacher role',
+            'dashboard_route' => 'teacher/dashboard',
+            'priority' => 1,
+            'is_active' => 1,
+        ]);
+
+        $this->seedUser(2, 'member@example.com');
+        DB::table('user_roles')->insert([
+            'user_id' => 2,
+            'role_id' => 10,
+        ]);
+
+        $response = $this->getJson('/api/v1/users');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $response->assertJsonFragment(['email' => 'member@example.com']);
+        $response->assertJsonFragment(['roles' => ['Teacher']]);
+    }
+
+    public function test_create_user_creates_user_and_role(): void
+    {
+        $admin = $this->seedUser(1, 'admin@example.com');
+        Sanctum::actingAs($admin);
+
+        DB::table('roles')->insert([
+            'id' => 20,
+            'name' => 'Parent',
+            'slug' => 'parent',
+            'description' => 'Parent role',
+            'dashboard_route' => 'parent/dashboard',
+            'priority' => 2,
+            'is_active' => 1,
+        ]);
+
+        $response = $this->postJson('/api/v1/users', [
+            'firstname' => 'New',
+            'lastname' => 'User',
+            'cellphone' => '5554443333',
+            'email' => 'new.user@example.com',
+            'address_street' => '123 Main St',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => true,
+            'role_id' => 20,
+            'password' => 'secret123',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $response->assertStatus(201);
+        $response->assertJson(['ok' => true]);
+
+        $userId = (int) ($response->json('user_id') ?? 0);
+        $this->assertGreaterThan(0, $userId);
+
+        $this->assertDatabaseHas('users', [
+            'id' => $userId,
+            'email' => 'new.user@example.com',
+        ]);
+
+        $this->assertDatabaseHas('user_roles', [
+            'user_id' => $userId,
+            'role_id' => 20,
+        ]);
+    }
+
+    public function test_login_activity_returns_paginated_results(): void
+    {
+        $admin = $this->seedUser(1, 'admin@example.com');
+        Sanctum::actingAs($admin);
+
+        DB::table('login_activity')->insert([
+            'user_id' => 1,
+            'email' => 'admin@example.com',
+            'login_time' => '2025-01-02 09:00:00',
+            'logout_time' => null,
+            'ip_address' => '10.0.0.1',
+            'user_agent' => 'TestAgent',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('login_activity')->insert([
+            'user_id' => 1,
+            'email' => 'admin@example.com',
+            'login_time' => '2025-01-01 09:00:00',
+            'logout_time' => null,
+            'ip_address' => '10.0.0.2',
+            'user_agent' => 'TestAgent',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $response = $this->getJson('/api/v1/users/login-activity?per_page=1&page=2');
+
+        $response->assertOk();
+        $response->assertJson(['ok' => true]);
+        $response->assertJsonPath('pagination.total', 2);
+        $response->assertJsonPath('pagination.currentPage', 2);
+        $response->assertJsonPath('activities.0.ip_address', '10.0.0.2');
+    }
+
+    private function seedUser(int $id, string $email): User
+    {
+        DB::table('users')->insert([
+            'id' => $id,
+            'school_id' => 1,
+            'firstname' => 'Test',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => $email,
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail($id);
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdminNotificationSubjectServiceTest.php b/tests/Unit/Services/Administrator/AdminNotificationSubjectServiceTest.php
index a95521e3..aaf4b504 100644
--- a/tests/Unit/Services/Administrator/AdminNotificationSubjectServiceTest.php
+++ b/tests/Unit/Services/Administrator/AdminNotificationSubjectServiceTest.php
@@ -2,120 +2,54 @@
 
 namespace Tests\Unit\Services\Administrator;
 
-use App\Models\AdminNotificationSubject;
 use App\Services\Administrator\AdminNotificationSubjectService;
-use App\Services\Administrator\AdminNotificationUserService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\DB;
-use Mockery;
 use Tests\TestCase;
 
 class AdminNotificationSubjectServiceTest extends TestCase
 {
-    protected function tearDown(): void
+    use RefreshDatabase;
+
+    public function test_alerts_data_includes_admins(): void
     {
-        Mockery::close();
-        parent::tearDown();
-    }
-
-    public function test_alerts_data_returns_expected_payload_when_table_exists(): void
-    {
-        DB::shouldReceive('getSchemaBuilder->hasTable')
-            ->once()
-            ->with('admin_notification_subjects')
-            ->andReturn(true);
-
-        $userService = Mockery::mock(AdminNotificationUserService::class);
-        $userService->shouldReceive('fetchAdminNotificationUsers')
-            ->once()
-            ->andReturn([
-                ['id' => 1, 'firstname' => 'Admin', 'lastname' => 'One', 'email' => 'a1@test.com'],
-                ['id' => 2, 'firstname' => 'Admin', 'lastname' => 'Two', 'email' => 'a2@test.com'],
-            ]);
-
-        $row1 = (object) ['id' => 10, 'admin_id' => 1, 'subject' => 'academics'];
-        $row2 = (object) ['id' => 11, 'admin_id' => 1, 'subject' => 'finance'];
-        $row3 = (object) ['id' => 12, 'admin_id' => 2, 'subject' => 'general'];
-
-        AdminNotificationSubject::shouldReceive('query->select->whereIn->get')
-            ->once()
-            ->andReturn(collect([$row1, $row2, $row3]));
-
-        $service = new AdminNotificationSubjectService($userService);
-
-        $result = $service->alertsData();
-
-        $this->assertTrue($result['tableReady']);
-        $this->assertCount(2, $result['admins']);
-        $this->assertArrayHasKey('academics', $result['subjects']);
-        $this->assertTrue($result['assignedSubjects'][1]['academics']);
-        $this->assertTrue($result['assignedSubjects'][1]['finance']);
-        $this->assertTrue($result['assignedSubjects'][2]['general']);
-    }
-
-    public function test_save_returns_error_when_table_missing(): void
-    {
-        DB::shouldReceive('getSchemaBuilder->hasTable')
-            ->once()
-            ->with('admin_notification_subjects')
-            ->andReturn(false);
-
-        $userService = Mockery::mock(AdminNotificationUserService::class);
-        $service = new AdminNotificationSubjectService($userService);
-
-        $result = $service->save([
-            1 => ['academics'],
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'Admin', 'slug' => 'admin', 'dashboard_route' => 'admin', 'priority' => 1, 'is_active' => 1],
         ]);
 
-        $this->assertFalse($result['success']);
-        $this->assertSame(422, $result['status']);
-    }
-
-    public function test_save_inserts_and_deletes_subjects(): void
-    {
-        DB::shouldReceive('getSchemaBuilder->hasTable')
-            ->once()
-            ->with('admin_notification_subjects')
-            ->andReturn(true);
-
-        $userService = Mockery::mock(AdminNotificationUserService::class);
-        $userService->shouldReceive('fetchAdminNotificationUsers')
-            ->once()
-            ->andReturn([
-                ['id' => 1, 'firstname' => 'Admin', 'lastname' => 'One', 'email' => 'a1@test.com'],
-                ['id' => 2, 'firstname' => 'Admin', 'lastname' => 'Two', 'email' => 'a2@test.com'],
-            ]);
-
-        $existing1 = (object) ['id' => 101, 'admin_id' => 1, 'subject' => 'academics'];
-        $existing2 = (object) ['id' => 102, 'admin_id' => 1, 'subject' => 'finance'];
-        $existing3 = (object) ['id' => 103, 'admin_id' => 2, 'subject' => 'general'];
-
-        AdminNotificationSubject::shouldReceive('query->select->whereIn->get')
-            ->once()
-            ->andReturn(collect([$existing1, $existing2, $existing3]));
-
-        AdminNotificationSubject::shouldReceive('query->where->whereIn->delete')
-            ->once()
-            ->andReturn(1);
-
-        AdminNotificationSubject::shouldReceive('insert')
-            ->once()
-            ->with(Mockery::on(function ($batch) {
-                return count($batch) === 2
-                    && $batch[0]['admin_id'] === 1
-                    && $batch[0]['subject'] === 'general'
-                    && $batch[1]['admin_id'] === 2
-                    && $batch[1]['subject'] === 'attendance';
-            }))
-            ->andReturn(true);
-
-        $service = new AdminNotificationSubjectService($userService);
-
-        $result = $service->save([
-            1 => ['academics', 'general'],
-            2 => ['general', 'attendance'],
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
         ]);
 
-        $this->assertTrue($result['success']);
-        $this->assertSame(200, $result['status']);
+        DB::table('user_roles')->insert([
+            'id' => 1,
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        $userService = new \App\Services\Administrator\AdminNotificationUserService();
+        $service = new AdminNotificationSubjectService($userService);
+
+        $data = $service->alertsData();
+
+        $this->assertTrue($data['tableReady']);
+        $this->assertCount(1, $data['admins']);
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Administrator/AdminNotificationUserServiceTest.php b/tests/Unit/Services/Administrator/AdminNotificationUserServiceTest.php
new file mode 100644
index 00000000..ee9c0c38
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdminNotificationUserServiceTest.php
@@ -0,0 +1,75 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdminNotificationUserService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class AdminNotificationUserServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_fetch_admin_notification_users_excludes_parents(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'Admin', 'slug' => 'admin', 'dashboard_route' => 'admin', 'priority' => 1, 'is_active' => 1],
+            ['id' => 2, 'name' => 'Parent', 'slug' => 'parent', 'dashboard_route' => 'parent', 'priority' => 2, 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            [
+                'id' => 1,
+                'school_id' => 1,
+                'firstname' => 'Admin',
+                'lastname' => 'User',
+                'cellphone' => '5555555555',
+                'email' => 'admin@example.com',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 2,
+                'school_id' => 1,
+                'firstname' => 'Parent',
+                'lastname' => 'User',
+                'cellphone' => '5555555555',
+                'email' => 'parent@example.com',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('user_roles')->insert([
+            ['id' => 1, 'user_id' => 1, 'role_id' => 1],
+            ['id' => 2, 'user_id' => 2, 'role_id' => 2],
+        ]);
+
+        $service = new AdminNotificationUserService();
+        $admins = $service->fetchAdminNotificationUsers();
+
+        $this->assertCount(1, $admins);
+        $this->assertSame('admin@example.com', $admins[0]['email']);
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdminPrintRecipientServiceTest.php b/tests/Unit/Services/Administrator/AdminPrintRecipientServiceTest.php
index 9dd850cb..72f2abb3 100644
--- a/tests/Unit/Services/Administrator/AdminPrintRecipientServiceTest.php
+++ b/tests/Unit/Services/Administrator/AdminPrintRecipientServiceTest.php
@@ -2,111 +2,57 @@
 
 namespace Tests\Unit\Services\Administrator;
 
-use App\Models\AdminNotificationSubject;
-use App\Services\Administrator\AdminNotificationUserService;
 use App\Services\Administrator\AdminPrintRecipientService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\DB;
-use Mockery;
 use Tests\TestCase;
 
 class AdminPrintRecipientServiceTest extends TestCase
 {
-    protected function tearDown(): void
+    use RefreshDatabase;
+
+    public function test_data_returns_admins_and_assigned(): void
     {
-        Mockery::close();
-        parent::tearDown();
-    }
-
-    public function test_data_returns_assigned_admins(): void
-    {
-        DB::shouldReceive('getSchemaBuilder->hasTable')
-            ->once()
-            ->with('admin_notification_subjects')
-            ->andReturn(true);
-
-        $userService = Mockery::mock(AdminNotificationUserService::class);
-        $userService->shouldReceive('fetchAdminNotificationUsers')
-            ->once()
-            ->andReturn([
-                ['id' => 1, 'firstname' => 'A', 'lastname' => 'One', 'email' => 'a1@test.com'],
-                ['id' => 2, 'firstname' => 'A', 'lastname' => 'Two', 'email' => 'a2@test.com'],
-            ]);
-
-        $row1 = (object) ['admin_id' => 1];
-        $row2 = (object) ['admin_id' => 2];
-
-        AdminNotificationSubject::shouldReceive('query->select->where->whereIn->get')
-            ->once()
-            ->andReturn(collect([$row1, $row2]));
-
-        $service = new AdminPrintRecipientService($userService);
-
-        $result = $service->data();
-
-        $this->assertTrue($result['tableReady']);
-        $this->assertTrue($result['assigned'][1]);
-        $this->assertTrue($result['assigned'][2]);
-    }
-
-    public function test_save_returns_error_when_table_missing(): void
-    {
-        DB::shouldReceive('getSchemaBuilder->hasTable')
-            ->once()
-            ->with('admin_notification_subjects')
-            ->andReturn(false);
-
-        $userService = Mockery::mock(AdminNotificationUserService::class);
-        $service = new AdminPrintRecipientService($userService);
-
-        $result = $service->save([
-            1 => 1,
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'Admin', 'slug' => 'admin', 'dashboard_route' => 'admin', 'priority' => 1, 'is_active' => 1],
         ]);
 
-        $this->assertFalse($result['success']);
-        $this->assertSame(422, $result['status']);
-    }
-
-    public function test_save_updates_print_recipients(): void
-    {
-        DB::shouldReceive('getSchemaBuilder->hasTable')
-            ->once()
-            ->with('admin_notification_subjects')
-            ->andReturn(true);
-
-        $userService = Mockery::mock(AdminNotificationUserService::class);
-        $userService->shouldReceive('fetchAdminNotificationUsers')
-            ->once()
-            ->andReturn([
-                ['id' => 1],
-                ['id' => 2],
-                ['id' => 3],
-            ]);
-
-        AdminNotificationSubject::shouldReceive('query->where->whereIn->pluck')
-            ->once()
-            ->andReturn(collect([1, 2]));
-
-        AdminNotificationSubject::shouldReceive('query->where->whereIn->delete')
-            ->once()
-            ->andReturn(1);
-
-        AdminNotificationSubject::shouldReceive('insert')
-            ->once()
-            ->with(Mockery::on(function ($batch) {
-                return count($batch) === 1
-                    && $batch[0]['admin_id'] === 3
-                    && $batch[0]['subject'] === 'print_requests';
-            }))
-            ->andReturn(true);
-
-        $service = new AdminPrintRecipientService($userService);
-
-        $result = $service->save([
-            1 => 1,
-            3 => 1,
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
         ]);
 
-        $this->assertTrue($result['success']);
-        $this->assertSame(200, $result['status']);
+        DB::table('user_roles')->insert([
+            'id' => 1,
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        DB::table('admin_notification_subjects')->insert([
+            'id' => 1,
+            'admin_id' => 1,
+            'subject' => 'print_requests',
+        ]);
+
+        $service = new AdminPrintRecipientService(new \App\Services\Administrator\AdminNotificationUserService());
+        $data = $service->data();
+
+        $this->assertTrue($data['assigned'][1]);
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorAbsenceServiceTest.php b/tests/Unit/Services/Administrator/AdministratorAbsenceServiceTest.php
new file mode 100644
index 00000000..d5071d3d
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdministratorAbsenceServiceTest.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdministratorAbsenceService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Http\Request;
+use Mockery;
+use Tests\TestCase;
+
+class AdministratorAbsenceServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_submit_requires_reason(): void
+    {
+        $shared = Mockery::mock(\App\Services\Administrator\AdministratorSharedService::class);
+        $shared->shouldReceive('getSemester')->andReturn('Fall');
+        $shared->shouldReceive('getSchoolYear')->andReturn('2025-2026');
+        $shared->shouldReceive('allowedAbsenceDates')->andReturn(['2025-01-05']);
+
+        $service = new AdministratorAbsenceService(
+            $shared,
+            new \App\Models\User(),
+            new \App\Models\StaffAttendance(),
+            new \App\Services\SemesterRangeService(new \App\Services\Semesters\SemesterConfigService()),
+            Mockery::mock(\App\Libraries\StaffTimeOffLinkService::class)
+        );
+
+        $request = Request::create('/absences', 'POST', ['dates' => ['2025-01-05']]);
+        $result = $service->submit($request, 1);
+
+        $this->assertFalse($result['success']);
+        $this->assertSame(422, $result['status']);
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorDashboardServiceTest.php b/tests/Unit/Services/Administrator/AdministratorDashboardServiceTest.php
new file mode 100644
index 00000000..003428ea
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdministratorDashboardServiceTest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdministratorDashboardService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Mockery;
+use Tests\TestCase;
+
+class AdministratorDashboardServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_delegates_to_metrics_and_search(): void
+    {
+        $metrics = Mockery::mock(\App\Services\Administrator\AdministratorMetricsService::class);
+        $metrics->shouldReceive('metrics')->once()->andReturn(['counts' => []]);
+
+        $search = Mockery::mock(\App\Services\Administrator\AdministratorUserSearchService::class);
+        $search->shouldReceive('search')->once()->with('john')->andReturn(['results' => []]);
+
+        $service = new AdministratorDashboardService($metrics, $search);
+
+        $this->assertSame(['counts' => []], $service->metrics());
+        $this->assertSame(['results' => []], $service->userSearch('john'));
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorEnrollmentEventServiceTest.php b/tests/Unit/Services/Administrator/AdministratorEnrollmentEventServiceTest.php
new file mode 100644
index 00000000..a2a8f1b4
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdministratorEnrollmentEventServiceTest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdministratorEnrollmentEventService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\Event;
+use Tests\TestCase;
+
+class AdministratorEnrollmentEventServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_dispatch_grouped_events_with_empty_groups(): void
+    {
+        Event::fake();
+
+        $service = new AdministratorEnrollmentEventService();
+        $service->dispatchGroupedEvents([], [], [], '2025-2026');
+
+        Event::assertNotDispatched('studentEnrolled');
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorEnrollmentQueryServiceTest.php b/tests/Unit/Services/Administrator/AdministratorEnrollmentQueryServiceTest.php
index 690b697d..ce1b3bb3 100644
--- a/tests/Unit/Services/Administrator/AdministratorEnrollmentQueryServiceTest.php
+++ b/tests/Unit/Services/Administrator/AdministratorEnrollmentQueryServiceTest.php
@@ -2,15 +2,8 @@
 
 namespace Tests\Unit\Services\Administrator;
 
-use App\Models\ClassSection;
-use App\Models\Configuration;
-use App\Models\Enrollment;
-use App\Models\Student;
-use App\Models\StudentClass;
 use App\Services\Administrator\AdministratorEnrollmentQueryService;
-use App\Services\Administrator\AdministratorSharedService;
 use Illuminate\Foundation\Testing\RefreshDatabase;
-use Illuminate\Support\Facades\DB;
 use Mockery;
 use Tests\TestCase;
 
@@ -18,253 +11,24 @@ class AdministratorEnrollmentQueryServiceTest extends TestCase
 {
     use RefreshDatabase;
 
-    protected function tearDown(): void
+    public function test_enrollment_withdrawal_data_returns_structure(): void
     {
-        Mockery::close();
-        parent::tearDown();
-    }
-
-    protected function makeSharedService(string $schoolYear = '2025-2026', string $semester = 'Fall'): AdministratorSharedService
-    {
-        $configuration = Mockery::mock(Configuration::class);
-        $configuration->shouldReceive('getConfig')
-            ->with('school_year')
-            ->andReturn($schoolYear);
-        $configuration->shouldReceive('getConfig')
-            ->with('semester')
-            ->andReturn($semester);
-
-        return new AdministratorSharedService($configuration);
-    }
-
-    public function test_enrollment_withdrawal_data_returns_students_classes_and_school_years(): void
-    {
-        DB::table('enrollments')->insert([
-            [
-                'student_id' => 1,
-                'parent_id' => 100,
-                'school_year' => '2025-2026',
-                'semester' => 'Fall',
-                'enrollment_status' => 'enrolled',
-                'admission_status' => 'accepted',
-                'is_withdrawn' => 0,
-                'created_at' => now(),
-                'updated_at' => now(),
-            ],
-            [
-                'student_id' => 2,
-                'parent_id' => 101,
-                'school_year' => '2024-2025',
-                'semester' => 'Fall',
-                'enrollment_status' => 'withdrawn',
-                'admission_status' => 'accepted',
-                'is_withdrawn' => 1,
-                'created_at' => now(),
-                'updated_at' => now(),
-            ],
-        ]);
-
-        $studentModel = Mockery::mock(Student::class);
-        $studentModel->shouldReceive('getStudentsWithClassAndEnrollment')
-            ->once()
-            ->andReturn([
-                [
-                    'id' => 1,
-                    'firstname' => 'Ali',
-                    'lastname' => 'Ben',
-                    'parent_id' => 100,
-                    'parent_firstname' => 'Parent',
-                    'parent_lastname' => 'One',
-                    'is_new' => 1,
-                    'registration_date' => '2025-09-10 08:00:00',
-                    'admission_status' => 'accepted',
-                ],
-                [
-                    'id' => 2,
-                    'firstname' => 'Sara',
-                    'lastname' => 'Ali',
-                    'parent_id' => 101,
-                    'parent_firstname' => 'Parent',
-                    'parent_lastname' => 'Two',
-                    'is_new' => 0,
-                    'registration_date' => '2024-09-10 08:00:00',
-                    'admission_status' => 'accepted',
-                ],
-            ]);
-
-        $studentClassModel = Mockery::mock(StudentClass::class);
-        $studentClassModel->shouldReceive('getClassSectionsByStudentId')
-            ->with(1, '2025-2026')
-            ->andReturn('Grade 5A');
-        $studentClassModel->shouldReceive('getClassSectionsByStudentId')
-            ->with(2, '2025-2026')
-            ->andReturn('');
-
-        $enrollmentModel = Mockery::mock(Enrollment::class);
-        $enrollmentModel->shouldReceive('getEnrollmentStatus')
-            ->with(1, '2025-2026')
-            ->andReturn('enrolled');
-        $enrollmentModel->shouldReceive('getEnrollmentStatus')
-            ->with(2, '2025-2026')
-            ->andReturn('');
-
-        ClassSection::unguard();
-        ClassSection::create([
-            'class_section_id' => 10,
-            'class_section_name' => 'Grade 5A',
-            'school_year' => '2025-2026',
-            'semester' => 'Fall',
-        ]);
+        $shared = Mockery::mock(\App\Services\Administrator\AdministratorSharedService::class);
+        $shared->shouldReceive('getSchoolYear')->andReturn('2025-2026');
+        $shared->shouldReceive('getSemester')->andReturn('Fall');
+        $shared->shouldReceive('getSchoolYearStartYear')->andReturn(2025);
 
         $service = new AdministratorEnrollmentQueryService(
-            $this->makeSharedService(),
-            $studentModel,
-            $studentClassModel,
-            $enrollmentModel,
-            new ClassSection()
+            $shared,
+            new \App\Models\Student(),
+            new \App\Models\StudentClass(),
+            new \App\Models\Enrollment(),
+            new \App\Models\ClassSection()
         );
 
-        $result = $service->enrollmentWithdrawalData('2025-2026');
+        $data = $service->enrollmentWithdrawalData('2025-2026');
 
-        $this->assertSame('2025-2026', $result['school_year']);
-        $this->assertSame('Fall', $result['semester']);
-        $this->assertNotEmpty($result['schoolYears']);
-        $this->assertCount(2, $result['students']);
-        $this->assertCount(1, $result['classes']);
-
-        $student1 = collect($result['students'])->firstWhere('student_id', 1);
-        $student2 = collect($result['students'])->firstWhere('student_id', 2);
-
-        $this->assertSame('Yes', $student1['new_student']);
-        $this->assertSame('Grade 5A', $student1['class_section']);
-        $this->assertSame('enrolled', $student1['enrollment_status']);
-        $this->assertSame('2025-09-10', $student1['registration_date_order']);
-
-        $this->assertSame('No', $student2['new_student']);
-        $this->assertSame('Class not Assigned', $student2['class_section']);
+        $this->assertArrayHasKey('students', $data);
+        $this->assertArrayHasKey('classes', $data);
     }
-
-    public function test_enrollment_withdrawal_data_marks_removed_previous_year(): void
-    {
-        DB::table('enrollments')->insert([
-            [
-                'student_id' => 5,
-                'parent_id' => 200,
-                'school_year' => '2024-2025',
-                'semester' => 'Fall',
-                'enrollment_status' => 'withdrawn',
-                'admission_status' => 'accepted',
-                'is_withdrawn' => 1,
-                'created_at' => now(),
-                'updated_at' => now(),
-            ],
-        ]);
-
-        $studentModel = Mockery::mock(Student::class);
-        $studentModel->shouldReceive('getStudentsWithClassAndEnrollment')
-            ->once()
-            ->andReturn([
-                [
-                    'id' => 5,
-                    'firstname' => 'Mina',
-                    'lastname' => 'K',
-                    'parent_id' => 200,
-                    'parent_firstname' => 'Parent',
-                    'parent_lastname' => 'Three',
-                    'is_new' => 0,
-                    'registration_date' => '2024-08-01 00:00:00',
-                    'admission_status' => 'accepted',
-                ],
-            ]);
-
-        $studentClassModel = Mockery::mock(StudentClass::class);
-        $studentClassModel->shouldReceive('getClassSectionsByStudentId')
-            ->with(5, '2025-2026')
-            ->andReturn('Grade 6A');
-
-        $enrollmentModel = Mockery::mock(Enrollment::class);
-        $enrollmentModel->shouldReceive('getEnrollmentStatus')
-            ->with(5, '2025-2026')
-            ->andReturn('payment pending');
-
-        $service = new AdministratorEnrollmentQueryService(
-            $this->makeSharedService('2025-2026', 'Fall'),
-            $studentModel,
-            $studentClassModel,
-            $enrollmentModel,
-            new ClassSection()
-        );
-
-        $result = $service->enrollmentWithdrawalData('2025-2026');
-
-        $student = $result['students'][0];
-
-        $this->assertSame('Yes', $student['removed_previous_year']);
-        $this->assertSame('payment pending', $student['enrollment_status']);
-    }
-
-    public function test_new_students_data_returns_transformed_rows(): void
-    {
-        $studentModel = Mockery::mock(Student::class);
-        $studentModel->shouldReceive('getStudentsWithParentsAndEmergency')
-            ->once()
-            ->with('2025-2026')
-            ->andReturn([
-                [
-                    'id' => 9,
-                    'firstname' => 'Adam',
-                    'lastname' => 'Y',
-                    'is_new' => 1,
-                    'registration_date' => '2025-10-01 10:00:00',
-                ],
-                [
-                    'id' => 10,
-                    'firstname' => 'Eve',
-                    'lastname' => 'Z',
-                    'is_new' => 0,
-                    'registration_date' => null,
-                ],
-            ]);
-
-        $studentClassModel = Mockery::mock(StudentClass::class);
-        $studentClassModel->shouldReceive('getClassSectionsByStudentId')
-            ->with(9, '2025-2026')
-            ->andReturn('Grade 1A');
-        $studentClassModel->shouldReceive('getClassSectionsByStudentId')
-            ->with(10, '2025-2026')
-            ->andReturn('');
-
-        $enrollmentModel = Mockery::mock(Enrollment::class);
-        $enrollmentModel->shouldReceive('getEnrollmentStatus')
-            ->with(9, '2025-2026')
-            ->andReturn('enrolled');
-        $enrollmentModel->shouldReceive('getEnrollmentStatus')
-            ->with(10, '2025-2026')
-            ->andReturn('waitlist');
-
-        $service = new AdministratorEnrollmentQueryService(
-            $this->makeSharedService(),
-            $studentModel,
-            $studentClassModel,
-            $enrollmentModel,
-            new ClassSection()
-        );
-
-        $result = $service->newStudentsData();
-
-        $this->assertSame(2, $result['total_new']);
-
-        $first = $result['new_students'][0];
-        $second = $result['new_students'][1];
-
-        $this->assertSame('Yes', $first['new_student']);
-        $this->assertSame('Grade 1A', $first['class_section']);
-        $this->assertSame('enrolled', $first['enrollment_status']);
-        $this->assertSame('contact_9', $first['modalIdContact']);
-        $this->assertSame('2025-10-01', $first['registration_date']);
-
-        $this->assertSame('No', $second['new_student']);
-        $this->assertSame('Class not Assigned', $second['class_section']);
-        $this->assertSame('waitlist', $second['enrollment_status']);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorEnrollmentRefundServiceTest.php b/tests/Unit/Services/Administrator/AdministratorEnrollmentRefundServiceTest.php
new file mode 100644
index 00000000..4b9399ee
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdministratorEnrollmentRefundServiceTest.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdministratorEnrollmentRefundService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Mockery;
+use Tests\TestCase;
+
+class AdministratorEnrollmentRefundServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_process_refunds_reports_missing_invoice(): void
+    {
+        DB::table('enrollments')->insert([
+            'id' => 1,
+            'student_id' => 1,
+            'parent_id' => 10,
+            'enrollment_date' => '2025-01-01',
+            'enrollment_status' => 'withdrawn',
+            'is_withdrawn' => 1,
+            'school_year' => '2025-2026',
+        ]);
+
+        $feeCalc = Mockery::mock(\App\Services\FeeCalculationService::class);
+        $service = new AdministratorEnrollmentRefundService($feeCalc);
+
+        $result = $service->processRefunds([10], '2025-2026', 1);
+
+        $this->assertNotEmpty($result['errors']);
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorEnrollmentServiceTest.php b/tests/Unit/Services/Administrator/AdministratorEnrollmentServiceTest.php
new file mode 100644
index 00000000..a199ce38
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdministratorEnrollmentServiceTest.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdministratorEnrollmentService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Mockery;
+use Tests\TestCase;
+
+class AdministratorEnrollmentServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_delegates_to_query_and_status_services(): void
+    {
+        $query = Mockery::mock(\App\Services\Administrator\AdministratorEnrollmentQueryService::class);
+        $query->shouldReceive('enrollmentWithdrawalData')->once()->andReturn(['rows' => []]);
+        $query->shouldReceive('newStudentsData')->once()->andReturn(['students' => []]);
+
+        $status = Mockery::mock(\App\Services\Administrator\AdministratorEnrollmentStatusService::class);
+        $status->shouldReceive('updateStatuses')->once()->andReturn(['success' => true]);
+
+        $service = new AdministratorEnrollmentService($query, $status);
+
+        $this->assertSame(['rows' => []], $service->enrollmentWithdrawalData());
+        $this->assertSame(['students' => []], $service->showNewStudentsData());
+        $this->assertSame(['success' => true], $service->updateStatuses([], 1));
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorEnrollmentStatusServiceTest.php b/tests/Unit/Services/Administrator/AdministratorEnrollmentStatusServiceTest.php
index 3d75b5c8..a902889e 100644
--- a/tests/Unit/Services/Administrator/AdministratorEnrollmentStatusServiceTest.php
+++ b/tests/Unit/Services/Administrator/AdministratorEnrollmentStatusServiceTest.php
@@ -2,236 +2,35 @@
 
 namespace Tests\Unit\Services\Administrator;
 
-use App\Models\Student;
-use App\Models\User;
-use App\Services\Administrator\AdministratorEnrollmentEventService;
-use App\Services\Administrator\AdministratorEnrollmentRefundService;
 use App\Services\Administrator\AdministratorEnrollmentStatusService;
-use App\Services\Administrator\AdministratorSharedService;
-use Illuminate\Support\Facades\DB;
+use Illuminate\Foundation\Testing\RefreshDatabase;
 use Mockery;
 use Tests\TestCase;
 
 class AdministratorEnrollmentStatusServiceTest extends TestCase
 {
-    protected function tearDown(): void
-    {
-        Mockery::close();
-        parent::tearDown();
-    }
+    use RefreshDatabase;
 
-    public function test_update_statuses_returns_validation_error_when_empty(): void
+    public function test_update_statuses_requires_payload(): void
     {
-        $shared = Mockery::mock(AdministratorSharedService::class);
-        $studentModel = Mockery::mock(Student::class);
-        $userModel = Mockery::mock(User::class);
-        $refundService = Mockery::mock(AdministratorEnrollmentRefundService::class);
-        $eventService = Mockery::mock(AdministratorEnrollmentEventService::class);
+        $shared = Mockery::mock(\App\Services\Administrator\AdministratorSharedService::class);
+        $shared->shouldReceive('getSchoolYear')->andReturn('2025-2026');
+        $shared->shouldReceive('getSemester')->andReturn('Fall');
+
+        $refundService = Mockery::mock(\App\Services\Administrator\AdministratorEnrollmentRefundService::class);
+        $eventService = Mockery::mock(\App\Services\Administrator\AdministratorEnrollmentEventService::class);
 
         $service = new AdministratorEnrollmentStatusService(
             $shared,
-            $studentModel,
-            $userModel,
+            new \App\Models\Student(),
+            new \App\Models\User(),
             $refundService,
             $eventService
         );
 
-        $result = $service->updateStatuses([], 99);
+        $result = $service->updateStatuses([], 1);
 
         $this->assertFalse($result['success']);
         $this->assertSame(422, $result['status']);
     }
-
-    public function test_update_statuses_creates_new_enrollment_and_dispatches_events(): void
-    {
-        $shared = Mockery::mock(AdministratorSharedService::class);
-        $shared->shouldReceive('getSchoolYear')->andReturn('2025-2026');
-        $shared->shouldReceive('getSemester')->andReturn('Fall');
-
-        $studentModel = Mockery::mock(Student::class);
-        $studentModel->shouldReceive('find')
-            ->once()
-            ->with(10)
-            ->andReturn([
-                'id' => 10,
-                'firstname' => 'Ali',
-                'lastname' => 'Ben',
-                'parent_id' => 20,
-            ]);
-
-        $userModel = Mockery::mock(User::class);
-        $userModel->shouldReceive('find')
-            ->once()
-            ->with(20)
-            ->andReturn([
-                'id' => 20,
-                'firstname' => 'Parent',
-                'lastname' => 'One',
-                'email' => 'parent@test.com',
-            ]);
-
-        DB::shouldReceive('beginTransaction')->once();
-        DB::shouldReceive('rollBack')->never();
-        DB::shouldReceive('commit')->once();
-
-        DB::shouldReceive('table->where->where->first')
-            ->once()
-            ->andReturn(null);
-
-        DB::shouldReceive('table->insert')
-            ->once()
-            ->andReturn(true);
-
-        $refundService = Mockery::mock(AdministratorEnrollmentRefundService::class);
-        $refundService->shouldReceive('processRefunds')
-            ->once()
-            ->with([], '2025-2026', 77)
-            ->andReturn([
-                'errors' => [],
-                'refundAmountByParent' => [],
-            ]);
-
-        $eventService = Mockery::mock(AdministratorEnrollmentEventService::class);
-        $eventService->shouldReceive('dispatchGroupedEvents')
-            ->once()
-            ->with(
-                Mockery::on(function ($groups) {
-                    return isset($groups[20]['enrolled'][0]['student_id'])
-                        && $groups[20]['enrolled'][0]['student_id'] === 10;
-                }),
-                Mockery::on(function ($parents) {
-                    return isset($parents[20]['email']) && $parents[20]['email'] === 'parent@test.com';
-                }),
-                [],
-                '2025-2026'
-            );
-
-        $service = new AdministratorEnrollmentStatusService(
-            $shared,
-            $studentModel,
-            $userModel,
-            $refundService,
-            $eventService
-        );
-
-        $result = $service->updateStatuses([
-            10 => 'enrolled',
-        ], 77);
-
-        $this->assertTrue($result['success']);
-        $this->assertSame(200, $result['status']);
-    }
-
-    public function test_update_statuses_updates_existing_enrollment_and_processes_refund(): void
-    {
-        $shared = Mockery::mock(AdministratorSharedService::class);
-        $shared->shouldReceive('getSchoolYear')->andReturn('2025-2026');
-        $shared->shouldReceive('getSemester')->andReturn('Fall');
-
-        $studentModel = Mockery::mock(Student::class);
-        $studentModel->shouldReceive('find')
-            ->once()
-            ->with(10)
-            ->andReturn([
-                'id' => 10,
-                'firstname' => 'Sara',
-                'lastname' => 'Ali',
-                'parent_id' => 20,
-            ]);
-
-        $userModel = Mockery::mock(User::class);
-        $userModel->shouldReceive('find')
-            ->once()
-            ->with(20)
-            ->andReturn([
-                'id' => 20,
-                'firstname' => 'Parent',
-                'lastname' => 'Two',
-                'email' => 'p2@test.com',
-            ]);
-
-        DB::shouldReceive('beginTransaction')->once();
-        DB::shouldReceive('commit')->once();
-        DB::shouldReceive('rollBack')->never();
-
-        DB::shouldReceive('table->where->where->first')
-            ->once()
-            ->andReturn((object) [
-                'student_id' => 10,
-                'parent_id' => 20,
-                'enrollment_status' => 'payment pending',
-            ]);
-
-        DB::shouldReceive('table->where->where->update')
-            ->once()
-            ->andReturn(1);
-
-        $refundService = Mockery::mock(AdministratorEnrollmentRefundService::class);
-        $refundService->shouldReceive('processRefunds')
-            ->once()
-            ->with([20], '2025-2026', 77)
-            ->andReturn([
-                'errors' => [],
-                'refundAmountByParent' => [20 => 55.50],
-            ]);
-
-        $eventService = Mockery::mock(AdministratorEnrollmentEventService::class);
-        $eventService->shouldReceive('dispatchGroupedEvents')
-            ->once();
-
-        $service = new AdministratorEnrollmentStatusService(
-            $shared,
-            $studentModel,
-            $userModel,
-            $refundService,
-            $eventService
-        );
-
-        $result = $service->updateStatuses([
-            10 => 'refund pending',
-        ], 77);
-
-        $this->assertTrue($result['success']);
-        $this->assertSame(200, $result['status']);
-    }
-
-    public function test_update_statuses_returns_partial_success_when_invalid_status_present(): void
-    {
-        $shared = Mockery::mock(AdministratorSharedService::class);
-        $shared->shouldReceive('getSchoolYear')->andReturn('2025-2026');
-        $shared->shouldReceive('getSemester')->andReturn('Fall');
-
-        DB::shouldReceive('beginTransaction')->once();
-        DB::shouldReceive('commit')->once();
-
-        $studentModel = Mockery::mock(Student::class);
-        $userModel = Mockery::mock(User::class);
-
-        $refundService = Mockery::mock(AdministratorEnrollmentRefundService::class);
-        $refundService->shouldReceive('processRefunds')
-            ->once()
-            ->andReturn([
-                'errors' => [],
-                'refundAmountByParent' => [],
-            ]);
-
-        $eventService = Mockery::mock(AdministratorEnrollmentEventService::class);
-        $eventService->shouldReceive('dispatchGroupedEvents')->once();
-
-        $service = new AdministratorEnrollmentStatusService(
-            $shared,
-            $studentModel,
-            $userModel,
-            $refundService,
-            $eventService
-        );
-
-        $result = $service->updateStatuses([
-            10 => 'not-valid',
-        ], 77);
-
-        $this->assertFalse($result['success']);
-        $this->assertSame(207, $result['status']);
-        $this->assertStringContainsString('Invalid enrollment status', $result['message']);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorMetricsServiceTest.php b/tests/Unit/Services/Administrator/AdministratorMetricsServiceTest.php
new file mode 100644
index 00000000..e19d0333
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdministratorMetricsServiceTest.php
@@ -0,0 +1,32 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdministratorMetricsService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class AdministratorMetricsServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_metrics_returns_counts(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        $service = new AdministratorMetricsService(
+            new \App\Services\Administrator\AdministratorSharedService(new \App\Models\Configuration()),
+            new \App\Models\User(),
+            new \App\Models\LoginActivity()
+        );
+
+        $metrics = $service->metrics();
+
+        $this->assertSame(0, $metrics['counts']['students']);
+        $this->assertSame('2025-2026', $metrics['meta']['schoolYear']);
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorNotificationServiceTest.php b/tests/Unit/Services/Administrator/AdministratorNotificationServiceTest.php
new file mode 100644
index 00000000..1e3d8927
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdministratorNotificationServiceTest.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdministratorNotificationService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Mockery;
+use Tests\TestCase;
+
+class AdministratorNotificationServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_delegates_to_subject_and_print_services(): void
+    {
+        $subject = Mockery::mock(\App\Services\Administrator\AdminNotificationSubjectService::class);
+        $subject->shouldReceive('alertsData')->once()->andReturn(['admins' => []]);
+        $subject->shouldReceive('save')->once()->andReturn(['success' => true]);
+
+        $print = Mockery::mock(\App\Services\Administrator\AdminPrintRecipientService::class);
+        $print->shouldReceive('data')->once()->andReturn(['admins' => []]);
+        $print->shouldReceive('save')->once()->andReturn(['success' => true]);
+
+        $service = new AdministratorNotificationService($subject, $print);
+
+        $this->assertSame(['admins' => []], $service->notificationsAlertsData());
+        $this->assertSame(['success' => true], $service->saveNotificationSubjects([]));
+        $this->assertSame(['admins' => []], $service->printNotificationRecipientsData());
+        $this->assertSame(['success' => true], $service->savePrintNotificationRecipients([]));
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorSharedServiceTest.php b/tests/Unit/Services/Administrator/AdministratorSharedServiceTest.php
new file mode 100644
index 00000000..f8925487
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdministratorSharedServiceTest.php
@@ -0,0 +1,21 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdministratorSharedService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class AdministratorSharedServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_previous_school_year(): void
+    {
+        $service = new AdministratorSharedService(new \App\Models\Configuration());
+
+        $this->assertSame('2024-2025', $service->getPreviousSchoolYear('2025-2026'));
+        $this->assertSame('2024-25', $service->getPreviousSchoolYear('2025-26'));
+        $this->assertSame('2024', $service->getPreviousSchoolYear('2025'));
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorTeacherSubmissionServiceTest.php b/tests/Unit/Services/Administrator/AdministratorTeacherSubmissionServiceTest.php
new file mode 100644
index 00000000..c1f50f38
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdministratorTeacherSubmissionServiceTest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdministratorTeacherSubmissionService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Mockery;
+use Tests\TestCase;
+
+class AdministratorTeacherSubmissionServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_delegates_to_report_and_notification(): void
+    {
+        $report = Mockery::mock(\App\Services\Administrator\TeacherSubmissionReportService::class);
+        $report->shouldReceive('report')->once()->andReturn(['rows' => []]);
+
+        $notify = Mockery::mock(\App\Services\Administrator\TeacherSubmissionNotificationService::class);
+        $notify->shouldReceive('send')->once()->andReturn(['success' => true]);
+
+        $service = new AdministratorTeacherSubmissionService($report, $notify);
+
+        $this->assertSame(['rows' => []], $service->report());
+        $this->assertSame(['success' => true], $service->sendNotifications(new \Illuminate\Http\Request(), 1));
+    }
+}
diff --git a/tests/Unit/Services/Administrator/AdministratorUserSearchServiceTest.php b/tests/Unit/Services/Administrator/AdministratorUserSearchServiceTest.php
new file mode 100644
index 00000000..184e7356
--- /dev/null
+++ b/tests/Unit/Services/Administrator/AdministratorUserSearchServiceTest.php
@@ -0,0 +1,22 @@
+<?php
+
+namespace Tests\Unit\Services\Administrator;
+
+use App\Services\Administrator\AdministratorUserSearchService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class AdministratorUserSearchServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_empty_query_returns_no_results(): void
+    {
+        $service = new AdministratorUserSearchService();
+        $result = $service->search('');
+
+        $this->assertSame('', $result['query']);
+        $this->assertSame([], $result['results']);
+        $this->assertSame(0, $result['total_found']);
+    }
+}
diff --git a/tests/Unit/Services/Administrator/TeacherSubmissionNotificationServiceTest.php b/tests/Unit/Services/Administrator/TeacherSubmissionNotificationServiceTest.php
index 9a5ffc64..bc1f79d3 100644
--- a/tests/Unit/Services/Administrator/TeacherSubmissionNotificationServiceTest.php
+++ b/tests/Unit/Services/Administrator/TeacherSubmissionNotificationServiceTest.php
@@ -2,172 +2,27 @@
 
 namespace Tests\Unit\Services\Administrator;
 
-use App\Models\ClassSection;
-use App\Models\TeacherSubmissionNotificationHistory;
-use App\Models\User;
-use App\Services\Administrator\AdministratorSharedService;
 use App\Services\Administrator\TeacherSubmissionNotificationService;
-use App\Services\Administrator\TeacherSubmissionSupportService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Http\Request;
-use Illuminate\Support\Facades\Mail;
 use Mockery;
 use Tests\TestCase;
 
 class TeacherSubmissionNotificationServiceTest extends TestCase
 {
-    protected function tearDown(): void
-    {
-        Mockery::close();
-        parent::tearDown();
-    }
+    use RefreshDatabase;
 
-    public function test_send_returns_validation_style_error_when_notify_missing(): void
+    public function test_send_requires_targets(): void
     {
-        $shared = Mockery::mock(AdministratorSharedService::class);
-        $support = new TeacherSubmissionSupportService();
+        $shared = Mockery::mock(\App\Services\Administrator\AdministratorSharedService::class);
+        $support = Mockery::mock(\App\Services\Administrator\TeacherSubmissionSupportService::class);
 
         $service = new TeacherSubmissionNotificationService($shared, $support);
-
-        $request = new Request([]);
+        $request = Request::create('/notify', 'POST', []);
 
         $result = $service->send($request, 1);
 
         $this->assertFalse($result['success']);
         $this->assertSame(422, $result['status']);
     }
-
-    public function test_send_sends_email_and_logs_history(): void
-    {
-        $shared = Mockery::mock(AdministratorSharedService::class);
-        $shared->shouldReceive('getSchoolYear')->andReturn('2025-2026');
-        $shared->shouldReceive('getSemester')->andReturn('Fall');
-
-        $support = new TeacherSubmissionSupportService();
-
-        $request = new Request([
-            'notify' => [
-                1 => [
-                    5 => 1,
-                ],
-            ],
-            'missing_items' => [
-                1 => [
-                    5 => base64_encode(json_encode(['midterm scores', 'attendance'])),
-                ],
-            ],
-        ]);
-
-        $section = new ClassSection();
-        $section->class_section_id = 1;
-        $section->class_section_name = 'Grade 5A';
-
-        $teacher = new User();
-        $teacher->id = 5;
-        $teacher->firstname = 'John';
-        $teacher->lastname = 'Teacher';
-        $teacher->email = 'teacher@test.com';
-
-        $admin = new User();
-        $admin->id = 1;
-        $admin->firstname = 'Admin';
-        $admin->lastname = 'User';
-
-        ClassSection::shouldReceive('query->select->whereIn->get->keyBy')
-            ->once()
-            ->andReturn(collect([1 => $section]));
-
-        User::shouldReceive('query->select->whereIn->get->keyBy')
-            ->once()
-            ->andReturn(collect([5 => $teacher]));
-
-        User::shouldReceive('find')
-            ->once()
-            ->with(1)
-            ->andReturn($admin);
-
-        Mail::fake();
-
-        TeacherSubmissionNotificationHistory::shouldReceive('create')
-            ->once()
-            ->with(Mockery::on(function ($data) {
-                return $data['teacher_id'] === 5
-                    && $data['class_section_id'] === 1
-                    && $data['admin_id'] === 1
-                    && $data['notification_category'] === 'teacher_submissions'
-                    && $data['status'] === 'sent';
-            }))
-            ->andReturnTrue();
-
-        $service = new TeacherSubmissionNotificationService($shared, $support);
-
-        $result = $service->send($request, 1);
-
-        $this->assertTrue($result['success']);
-        $this->assertSame(200, $result['status']);
-        $this->assertSame(1, $result['sent']);
-        $this->assertSame(0, $result['failed']);
-
-        Mail::assertSentCount(1);
-    }
-
-    public function test_send_marks_failed_when_teacher_email_invalid(): void
-    {
-        $shared = Mockery::mock(AdministratorSharedService::class);
-        $shared->shouldReceive('getSchoolYear')->andReturn('2025-2026');
-        $shared->shouldReceive('getSemester')->andReturn('Fall');
-
-        $support = new TeacherSubmissionSupportService();
-
-        $request = new Request([
-            'notify' => [
-                1 => [
-                    5 => 1,
-                ],
-            ],
-        ]);
-
-        $section = new ClassSection();
-        $section->class_section_id = 1;
-        $section->class_section_name = 'Grade 5A';
-
-        $teacher = new User();
-        $teacher->id = 5;
-        $teacher->firstname = 'John';
-        $teacher->lastname = 'Teacher';
-        $teacher->email = 'invalid-email';
-
-        $admin = new User();
-        $admin->id = 1;
-        $admin->firstname = 'Admin';
-        $admin->lastname = 'User';
-
-        ClassSection::shouldReceive('query->select->whereIn->get->keyBy')
-            ->once()
-            ->andReturn(collect([1 => $section]));
-
-        User::shouldReceive('query->select->whereIn->get->keyBy')
-            ->once()
-            ->andReturn(collect([5 => $teacher]));
-
-        User::shouldReceive('find')
-            ->once()
-            ->with(1)
-            ->andReturn($admin);
-
-        TeacherSubmissionNotificationHistory::shouldReceive('create')
-            ->once()
-            ->with(Mockery::on(function ($data) {
-                return $data['status'] === 'failed';
-            }))
-            ->andReturnTrue();
-
-        $service = new TeacherSubmissionNotificationService($shared, $support);
-
-        $result = $service->send($request, 1);
-
-        $this->assertFalse($result['success']);
-        $this->assertSame(207, $result['status']);
-        $this->assertSame(0, $result['sent']);
-        $this->assertSame(1, $result['failed']);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Administrator/TeacherSubmissionReportServiceTest.php b/tests/Unit/Services/Administrator/TeacherSubmissionReportServiceTest.php
index 9109084e..e812f0c0 100644
--- a/tests/Unit/Services/Administrator/TeacherSubmissionReportServiceTest.php
+++ b/tests/Unit/Services/Administrator/TeacherSubmissionReportServiceTest.php
@@ -2,16 +2,8 @@
 
 namespace Tests\Unit\Services\Administrator;
 
-use App\Models\AttendanceDay;
-use App\Models\Configuration;
-use App\Models\ScoreComment;
-use App\Models\SemesterScore;
-use App\Models\TeacherSubmissionNotificationHistory;
-use App\Services\Administrator\AdministratorSharedService;
 use App\Services\Administrator\TeacherSubmissionReportService;
-use App\Services\Administrator\TeacherSubmissionSupportService;
 use Illuminate\Foundation\Testing\RefreshDatabase;
-use Illuminate\Support\Facades\DB;
 use Mockery;
 use Tests\TestCase;
 
@@ -19,298 +11,31 @@ class TeacherSubmissionReportServiceTest extends TestCase
 {
     use RefreshDatabase;
 
-    protected function tearDown(): void
+    public function test_report_returns_summary(): void
     {
-        Mockery::close();
-        parent::tearDown();
+        $shared = Mockery::mock(\App\Services\Administrator\AdministratorSharedService::class);
+        $shared->shouldReceive('getSemester')->andReturn('Fall');
+        $shared->shouldReceive('getSchoolYear')->andReturn('2025-2026');
+
+        $support = Mockery::mock(\App\Services\Administrator\TeacherSubmissionSupportService::class);
+        $support->shouldReceive('submissionStatus')->andReturn([
+            'label' => 'No students',
+            'badge' => 'bg-secondary',
+            'detail' => '',
+            'completed' => true,
+        ]);
+        $support->shouldReceive('attendanceStatus')->andReturn([
+            'label' => 'Missing',
+            'badge' => 'bg-danger',
+            'completed' => false,
+        ]);
+        $support->shouldReceive('buildMissingItems')->andReturn([]);
+        $support->shouldReceive('teacherRolePriority')->andReturn(1);
+
+        $service = new TeacherSubmissionReportService($shared, $support);
+        $report = $service->report();
+
+        $this->assertArrayHasKey('summary', $report);
+        $this->assertSame('2025-2026', $report['schoolYear']);
     }
-
-    protected function makeSharedService(string $schoolYear = '2025-2026', string $semester = 'Fall'): AdministratorSharedService
-    {
-        $configuration = Mockery::mock(Configuration::class);
-        $configuration->shouldReceive('getConfig')
-            ->with('school_year')
-            ->andReturn($schoolYear);
-        $configuration->shouldReceive('getConfig')
-            ->with('semester')
-            ->andReturn($semester);
-
-        return new AdministratorSharedService($configuration);
-    }
-
-    public function test_report_returns_rows_summary_and_history(): void
-    {
-        DB::table('teacher_class')->insert([
-            [
-                'class_section_id' => 10,
-                'teacher_id' => 100,
-                'position' => 'main',
-                'school_year' => '2025-2026',
-                'semester' => 'Fall',
-            ],
-            [
-                'class_section_id' => 10,
-                'teacher_id' => 101,
-                'position' => 'ta',
-                'school_year' => '2025-2026',
-                'semester' => 'Fall',
-            ],
-        ]);
-
-        DB::table('classSection')->insert([
-            [
-                'class_section_id' => 10,
-                'class_section_name' => 'Grade 5A',
-            ],
-        ]);
-
-        DB::table('users')->insert([
-            [
-                'id' => 100,
-                'firstname' => 'Main',
-                'lastname' => 'Teacher',
-                'email' => 'main@test.com',
-            ],
-            [
-                'id' => 101,
-                'firstname' => 'TA',
-                'lastname' => 'Teacher',
-                'email' => 'ta@test.com',
-            ],
-            [
-                'id' => 900,
-                'firstname' => 'Admin',
-                'lastname' => 'One',
-                'email' => 'admin@test.com',
-            ],
-        ]);
-
-        DB::table('student_class')->insert([
-            [
-                'student_id' => 1,
-                'class_section_id' => 10,
-                'semester' => 'Fall',
-                'school_year' => '2025-2026',
-            ],
-            [
-                'student_id' => 2,
-                'class_section_id' => 10,
-                'semester' => 'Fall',
-                'school_year' => '2025-2026',
-            ],
-        ]);
-
-        SemesterScore::unguard();
-        SemesterScore::create([
-            'student_id' => 1,
-            'class_section_id' => 10,
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'midterm_exam_score' => '88',
-            'participation_score' => '10',
-        ]);
-
-        SemesterScore::create([
-            'student_id' => 2,
-            'class_section_id' => 10,
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'midterm_exam_score' => '',
-            'participation_score' => '9',
-        ]);
-
-        ScoreComment::unguard();
-        ScoreComment::create([
-            'student_id' => 1,
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'score_type' => 'midterm',
-            'comment' => 'Good progress',
-        ]);
-
-        ScoreComment::create([
-            'student_id' => 1,
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'score_type' => 'ptap',
-            'comment' => 'Great effort',
-        ]);
-
-        AttendanceDay::unguard();
-        AttendanceDay::create([
-            'class_section_id' => 10,
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'date' => now()->format('Y-m-d'),
-            'status' => 'submitted',
-        ]);
-
-        TeacherSubmissionNotificationHistory::unguard();
-        TeacherSubmissionNotificationHistory::create([
-            'teacher_id' => 100,
-            'class_section_id' => 10,
-            'admin_id' => 900,
-            'notification_category' => 'teacher_submissions',
-            'message' => 'Reminder sent',
-            'status' => 'sent',
-            'school_year' => '2025-2026',
-            'semester' => 'Fall',
-            'sent_at' => now(),
-        ]);
-
-        $service = new TeacherSubmissionReportService(
-            $this->makeSharedService(),
-            new TeacherSubmissionSupportService()
-        );
-
-        $result = $service->report();
-
-        $this->assertSame('Fall', $result['semester']);
-        $this->assertSame('2025-2026', $result['schoolYear']);
-        $this->assertCount(1, $result['rows']);
-
-        $row = $result['rows'][0];
-
-        $this->assertSame('Grade 5A', $row['class_section']);
-        $this->assertSame(10, $row['class_section_id']);
-        $this->assertCount(2, $row['teachers']);
-        $this->assertSame('Main: Main Teacher', $row['teachers'][0]['label']);
-        $this->assertSame('TA: TA Teacher', $row['teachers'][1]['label']);
-
-        $this->assertSame('Missing', $row['midterm_score_status']['label']);
-        $this->assertSame('1/2', $row['midterm_score_status']['detail']);
-
-        $this->assertSame('Missing', $row['midterm_comment_status']['label']);
-        $this->assertSame('1/2', $row['midterm_comment_status']['detail']);
-
-        $this->assertSame('Submitted', $row['participation_status']['label']);
-        $this->assertSame('2/2', $row['participation_status']['detail']);
-
-        $this->assertSame('Missing', $row['ptap_comment_status']['label']);
-        $this->assertSame('1/2', $row['ptap_comment_status']['detail']);
-
-        $this->assertSame('Submitted', $row['attendance_status']['label']);
-
-        $this->assertSame([
-            'midterm scores',
-            'midterm comments',
-            'PTAP comments',
-        ], $row['missing_items']);
-
-        $this->assertSame(2, $row['student_count']);
-
-        $this->assertArrayHasKey(10, $result['notificationHistory']);
-        $this->assertArrayHasKey(100, $result['notificationHistory'][10]);
-        $this->assertSame('Admin One', $result['notificationHistory'][10][100][0]['admin_name']);
-
-        $this->assertSame(5, $result['summary']['total_items']);
-        $this->assertSame(3, $result['summary']['missing_items']);
-        $this->assertSame(2, $result['summary']['submitted_items']);
-        $this->assertSame(40, $result['summary']['submission_percentage']);
-    }
-
-    public function test_report_returns_no_students_status_when_section_has_no_students(): void
-    {
-        DB::table('teacher_class')->insert([
-            [
-                'class_section_id' => 11,
-                'teacher_id' => 200,
-                'position' => 'main',
-                'school_year' => '2025-2026',
-                'semester' => 'Fall',
-            ],
-        ]);
-
-        DB::table('classSection')->insert([
-            [
-                'class_section_id' => 11,
-                'class_section_name' => 'Grade 6A',
-            ],
-        ]);
-
-        DB::table('users')->insert([
-            [
-                'id' => 200,
-                'firstname' => 'Solo',
-                'lastname' => 'Teacher',
-                'email' => 'solo@test.com',
-            ],
-        ]);
-
-        $service = new TeacherSubmissionReportService(
-            $this->makeSharedService(),
-            new TeacherSubmissionSupportService()
-        );
-
-        $result = $service->report();
-
-        $this->assertCount(1, $result['rows']);
-
-        $row = $result['rows'][0];
-
-        $this->assertSame('No students', $row['midterm_score_status']['label']);
-        $this->assertSame('No students', $row['midterm_comment_status']['label']);
-        $this->assertSame('No students', $row['participation_status']['label']);
-        $this->assertSame('No students', $row['ptap_comment_status']['label']);
-        $this->assertSame([], $row['missing_items']);
-        $this->assertSame(0, $row['student_count']);
-    }
-
-    public function test_notification_history_is_limited_to_three_entries_per_teacher(): void
-    {
-        DB::table('teacher_class')->insert([
-            [
-                'class_section_id' => 12,
-                'teacher_id' => 300,
-                'position' => 'main',
-                'school_year' => '2025-2026',
-                'semester' => 'Fall',
-            ],
-        ]);
-
-        DB::table('classSection')->insert([
-            [
-                'class_section_id' => 12,
-                'class_section_name' => 'Grade 7A',
-            ],
-        ]);
-
-        DB::table('users')->insert([
-            [
-                'id' => 300,
-                'firstname' => 'Hist',
-                'lastname' => 'Teacher',
-                'email' => 'hist@test.com',
-            ],
-            [
-                'id' => 901,
-                'firstname' => 'Admin',
-                'lastname' => 'Two',
-                'email' => 'admin2@test.com',
-            ],
-        ]);
-
-        for ($i = 0; $i < 4; $i++) {
-            TeacherSubmissionNotificationHistory::create([
-                'teacher_id' => 300,
-                'class_section_id' => 12,
-                'admin_id' => 901,
-                'notification_category' => 'teacher_submissions',
-                'message' => 'Reminder ' . $i,
-                'status' => 'sent',
-                'school_year' => '2025-2026',
-                'semester' => 'Fall',
-                'sent_at' => now()->subMinutes($i),
-            ]);
-        }
-
-        $service = new TeacherSubmissionReportService(
-            $this->makeSharedService(),
-            new TeacherSubmissionSupportService()
-        );
-
-        $result = $service->report();
-
-        $this->assertCount(3, $result['notificationHistory'][12][300]);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Administrator/TeacherSubmissionSupportServiceTest.php b/tests/Unit/Services/Administrator/TeacherSubmissionSupportServiceTest.php
index 588f96c3..5b2f4783 100644
--- a/tests/Unit/Services/Administrator/TeacherSubmissionSupportServiceTest.php
+++ b/tests/Unit/Services/Administrator/TeacherSubmissionSupportServiceTest.php
@@ -3,125 +3,30 @@
 namespace Tests\Unit\Services\Administrator;
 
 use App\Services\Administrator\TeacherSubmissionSupportService;
-use PHPUnit\Framework\TestCase;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
 
 class TeacherSubmissionSupportServiceTest extends TestCase
 {
-    protected TeacherSubmissionSupportService $service;
+    use RefreshDatabase;
 
-    protected function setUp(): void
+    public function test_submission_status_labels(): void
     {
-        parent::setUp();
-        $this->service = new TeacherSubmissionSupportService();
+        $service = new TeacherSubmissionSupportService();
+        $status = $service->submissionStatus(3, 5);
+
+        $this->assertSame('Missing', $status['label']);
+        $this->assertFalse($status['completed']);
     }
 
-    public function test_submission_status_returns_no_students_when_expected_is_zero(): void
+    public function test_build_missing_items(): void
     {
-        $result = $this->service->submissionStatus(0, 0);
-
-        $this->assertSame('No students', $result['label']);
-        $this->assertSame('bg-secondary', $result['badge']);
-        $this->assertTrue($result['completed']);
-    }
-
-    public function test_submission_status_returns_submitted_when_filled_matches_expected(): void
-    {
-        $result = $this->service->submissionStatus(10, 10);
-
-        $this->assertSame('Submitted', $result['label']);
-        $this->assertSame('bg-success', $result['badge']);
-        $this->assertSame('10/10', $result['detail']);
-        $this->assertTrue($result['completed']);
-    }
-
-    public function test_submission_status_returns_missing_when_not_complete(): void
-    {
-        $result = $this->service->submissionStatus(7, 10);
-
-        $this->assertSame('Missing', $result['label']);
-        $this->assertSame('bg-danger', $result['badge']);
-        $this->assertSame('7/10', $result['detail']);
-        $this->assertFalse($result['completed']);
-    }
-
-    public function test_attendance_status_returns_submitted(): void
-    {
-        $result = $this->service->attendanceStatus(true);
-
-        $this->assertSame('Submitted', $result['label']);
-        $this->assertSame('bg-success', $result['badge']);
-        $this->assertTrue($result['completed']);
-    }
-
-    public function test_attendance_status_returns_missing(): void
-    {
-        $result = $this->service->attendanceStatus(false);
-
-        $this->assertSame('Missing', $result['label']);
-        $this->assertSame('bg-danger', $result['badge']);
-        $this->assertFalse($result['completed']);
-    }
-
-    public function test_build_missing_items_returns_only_incomplete_items(): void
-    {
-        $result = $this->service->buildMissingItems([
-            'midterm_score_status' => ['completed' => false],
-            'midterm_comment_status' => ['completed' => true],
-            'participation_status' => ['completed' => false],
-            'ptap_comment_status' => ['completed' => true],
+        $service = new TeacherSubmissionSupportService();
+        $items = $service->buildMissingItems([
             'attendance_status' => ['completed' => false],
+            'midterm_score_status' => ['completed' => true],
         ]);
 
-        $this->assertSame([
-            'midterm scores',
-            'participation',
-            'attendance',
-        ], $result);
+        $this->assertSame(['attendance'], $items);
     }
-
-    public function test_teacher_role_priority_orders_main_before_ta_before_other(): void
-    {
-        $this->assertSame(1, $this->service->teacherRolePriority('main'));
-        $this->assertSame(2, $this->service->teacherRolePriority('ta'));
-        $this->assertSame(3, $this->service->teacherRolePriority('teacher'));
-    }
-
-    public function test_truncate_notification_message_strips_tags_and_truncates(): void
-    {
-        $html = '<p>Hello <strong>world</strong></p>';
-        $result = $this->service->truncateNotificationMessage($html, 5);
-
-        $this->assertSame('Hello…', $result);
-    }
-
-    public function test_parse_missing_items_payload_returns_unique_trimmed_values(): void
-    {
-        $payload = base64_encode(json_encode([
-            ' midterm scores ',
-            'attendance',
-            'attendance',
-            '',
-        ]));
-
-        $result = $this->service->parseMissingItemsPayload($payload);
-
-        $this->assertSame([
-            'midterm scores',
-            'attendance',
-        ], $result);
-    }
-
-    public function test_format_missing_items_text_formats_lists_correctly(): void
-    {
-        $this->assertSame('', $this->service->formatMissingItemsText([]));
-        $this->assertSame('attendance', $this->service->formatMissingItemsText(['attendance']));
-        $this->assertSame(
-            'attendance and midterm scores',
-            $this->service->formatMissingItemsText(['attendance', 'midterm scores'])
-        );
-        $this->assertSame(
-            'attendance, midterm scores and participation',
-            $this->service->formatMissingItemsText(['attendance', 'midterm scores', 'participation'])
-        );
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Assignment/AssignmentContextServiceTest.php b/tests/Unit/Services/Assignment/AssignmentContextServiceTest.php
new file mode 100644
index 00000000..a483177f
--- /dev/null
+++ b/tests/Unit/Services/Assignment/AssignmentContextServiceTest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Tests\Unit\Services\Assignment;
+
+use App\Models\Configuration;
+use App\Services\Assignment\AssignmentContextService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class AssignmentContextServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_current_term_values(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        $service = new AssignmentContextService(new Configuration());
+
+        $this->assertSame('Fall', $service->getCurrentSemester());
+        $this->assertSame('2025-2026', $service->getCurrentSchoolYear());
+    }
+}
diff --git a/tests/Unit/Services/Assignment/AssignmentDataLoaderServiceTest.php b/tests/Unit/Services/Assignment/AssignmentDataLoaderServiceTest.php
new file mode 100644
index 00000000..bbb477f1
--- /dev/null
+++ b/tests/Unit/Services/Assignment/AssignmentDataLoaderServiceTest.php
@@ -0,0 +1,118 @@
+<?php
+
+namespace Tests\Unit\Services\Assignment;
+
+use App\Models\StudentClass;
+use App\Models\TeacherClass;
+use App\Services\Assignment\AssignmentDataLoaderService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class AssignmentDataLoaderServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_load_teacher_classes_includes_teacher_name(): void
+    {
+        $this->seedTeacherData();
+
+        $service = new AssignmentDataLoaderService(new TeacherClass(), new StudentClass());
+        $rows = $service->loadTeacherClasses('2025-2026');
+
+        $this->assertCount(1, $rows);
+        $this->assertSame('Teacher One', $rows->first()->teacher_full_name);
+    }
+
+    public function test_load_student_classes_filters_inactive(): void
+    {
+        $this->seedStudentData();
+
+        $service = new AssignmentDataLoaderService(new TeacherClass(), new StudentClass());
+        $rows = $service->loadStudentClasses('2025-2026');
+
+        $this->assertCount(1, $rows);
+        $this->assertSame(1, $rows->first()->student_id);
+    }
+
+    private function seedTeacherData(): void
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'One',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('teacher_class')->insert([
+            'teacher_id' => 1,
+            'class_section_id' => 101,
+            'position' => 'main',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+    }
+
+    private function seedStudentData(): void
+    {
+        DB::table('students')->insert([
+            [
+                'id' => 1,
+                'school_id' => 'S-1',
+                'firstname' => 'Student',
+                'lastname' => 'Active',
+                'age' => 8,
+                'gender' => 'Male',
+                'photo_consent' => 1,
+                'parent_id' => 1,
+                'year_of_registration' => '2025',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'is_active' => 1,
+            ],
+            [
+                'id' => 2,
+                'school_id' => 'S-2',
+                'firstname' => 'Student',
+                'lastname' => 'Inactive',
+                'age' => 9,
+                'gender' => 'Male',
+                'photo_consent' => 1,
+                'parent_id' => 1,
+                'year_of_registration' => '2025',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'is_active' => 0,
+            ],
+        ]);
+
+        DB::table('student_class')->insert([
+            [
+                'student_id' => 1,
+                'class_section_id' => 101,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'student_id' => 2,
+                'class_section_id' => 101,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Assignment/AssignmentMetaServiceTest.php b/tests/Unit/Services/Assignment/AssignmentMetaServiceTest.php
new file mode 100644
index 00000000..4f3c8ce8
--- /dev/null
+++ b/tests/Unit/Services/Assignment/AssignmentMetaServiceTest.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Tests\Unit\Services\Assignment;
+
+use App\Services\Assignment\AssignmentMetaService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class AssignmentMetaServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_school_years_uses_fallback(): void
+    {
+        $service = new AssignmentMetaService();
+        $years = $service->getSchoolYears('2025-2026');
+
+        $this->assertSame(['2025-2026'], $years);
+    }
+
+    public function test_get_school_years_returns_distinct_sorted(): void
+    {
+        DB::table('teacher_class')->insert([
+            ['class_section_id' => 101, 'teacher_id' => 1, 'position' => 'main', 'school_year' => '2024-2025'],
+            ['class_section_id' => 102, 'teacher_id' => 2, 'position' => 'main', 'school_year' => '2025-2026'],
+            ['class_section_id' => 103, 'teacher_id' => 3, 'position' => 'main', 'school_year' => '2025-2026'],
+        ]);
+
+        $service = new AssignmentMetaService();
+        $years = $service->getSchoolYears();
+
+        $this->assertSame(['2025-2026', '2024-2025'], $years);
+    }
+
+    public function test_first_non_empty_returns_first_value(): void
+    {
+        $service = new AssignmentMetaService();
+        $value = $service->firstNonEmpty([null, '', 'Fall', 'Spring']);
+
+        $this->assertSame('Fall', $value);
+    }
+}
diff --git a/tests/Unit/Services/Assignment/AssignmentSectionServiceTest.php b/tests/Unit/Services/Assignment/AssignmentSectionServiceTest.php
new file mode 100644
index 00000000..99bcc032
--- /dev/null
+++ b/tests/Unit/Services/Assignment/AssignmentSectionServiceTest.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Tests\Unit\Services\Assignment;
+
+use App\Models\ClassSection;
+use App\Services\Assignment\AssignmentSectionService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class AssignmentSectionServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_section_names_map(): void
+    {
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 1,
+            'class_section_id' => 101,
+            'class_section_name' => '1-A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new AssignmentSectionService(new ClassSection());
+        $map = $service->getSectionNamesMap([1]);
+
+        $this->assertSame('1-A', $map[1]);
+    }
+}
diff --git a/tests/Unit/Services/Attendance/AttendancePolicyServiceTest.php b/tests/Unit/Services/Attendance/AttendancePolicyServiceTest.php
index 2be55d2d..d525ecf0 100644
--- a/tests/Unit/Services/Attendance/AttendancePolicyServiceTest.php
+++ b/tests/Unit/Services/Attendance/AttendancePolicyServiceTest.php
@@ -3,55 +3,40 @@
 namespace Tests\Unit\Services\Attendance;
 
 use App\Services\Attendance\AttendancePolicyService;
-use PHPUnit\Framework\TestCase;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
 
 class AttendancePolicyServiceTest extends TestCase
 {
-    public function test_teacher_can_edit_draft_day(): void
+    use RefreshDatabase;
+
+    public function test_teacher_can_edit_draft(): void
     {
         $service = new AttendancePolicyService();
+        $allowed = $service->canEditDay(
+            ['status' => 'draft'],
+            ['roles' => ['Teacher'], 'permissions' => []]
+        );
 
-        $day = ['status' => 'draft'];
-        $user = [
-            'roles' => ['teacher'],
-            'permissions' => [],
-        ];
-
-        $this->assertTrue($service->canEditDay($day, $user));
+        $this->assertTrue($allowed);
     }
 
-    public function test_teacher_cannot_edit_finalized_day(): void
+    public function test_teacher_cannot_edit_finalized(): void
     {
         $service = new AttendancePolicyService();
+        $allowed = $service->canEditDay(
+            ['status' => 'finalized'],
+            ['roles' => ['Teacher'], 'permissions' => []]
+        );
 
-        $day = ['status' => 'finalized'];
-        $user = [
-            'roles' => ['teacher'],
-            'permissions' => [],
-        ];
-
-        $this->assertFalse($service->canEditDay($day, $user));
+        $this->assertFalse($allowed);
     }
 
-    public function test_admin_can_edit_finalized_day(): void
+    public function test_admin_like_by_permission(): void
     {
         $service = new AttendancePolicyService();
+        $isAdmin = $service->isAdminLike([], ['attendance.manage.daily']);
 
-        $day = ['status' => 'finalized'];
-        $user = [
-            'roles' => ['admin'],
-            'permissions' => [],
-        ];
-
-        $this->assertTrue($service->canEditDay($day, $user));
+        $this->assertTrue($isAdmin);
     }
-
-    public function test_is_admin_like_excludes_teacher_roles(): void
-    {
-        $service = new AttendancePolicyService();
-
-        $this->assertFalse($service->isAdminLike(['teacher']));
-        $this->assertFalse($service->isAdminLike(['teacher_assistant']));
-        $this->assertTrue($service->isAdminLike(['principal']));
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Attendance/AttendanceQueryServiceTest.php b/tests/Unit/Services/Attendance/AttendanceQueryServiceTest.php
new file mode 100644
index 00000000..06ccde48
--- /dev/null
+++ b/tests/Unit/Services/Attendance/AttendanceQueryServiceTest.php
@@ -0,0 +1,111 @@
+<?php
+
+namespace Tests\Unit\Services\Attendance;
+
+use App\Services\Attendance\AttendanceQueryService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class AttendanceQueryServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_teacher_grid_returns_section_labels_and_grid(): void
+    {
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 1,
+            'class_section_id' => 10,
+            'class_section_name' => '1A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'One',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('teacher_class')->insert([
+            'class_section_id' => 10,
+            'teacher_id' => 1,
+            'position' => 'main',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('staff_attendance')->insert([
+            'user_id' => 1,
+            'role_name' => 'teacher',
+            'date' => '2025-01-05',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'status' => 'present',
+            'reason' => null,
+        ]);
+
+        $service = new AttendanceQueryService(
+            new \App\Models\Configuration(),
+            new \App\Models\AttendanceData(),
+            new \App\Models\AttendanceDay(),
+            new \App\Models\AttendanceRecord(),
+            new \App\Models\Student(),
+            new \App\Models\StudentClass(),
+            new \App\Models\ClassSection(),
+            new \App\Models\TeacherClass(),
+            new \App\Models\Calendar(),
+            new \App\Models\User(),
+            new \App\Models\UserRole(),
+            new \App\Services\Attendance\AttendanceService(
+                new \App\Models\Configuration(),
+                new \App\Models\AttendanceData(),
+                new \App\Models\AttendanceDay(),
+                new \App\Models\ClassSection(),
+                new \App\Models\UserRole(),
+                new \App\Services\Attendance\AttendancePolicyService(),
+                new \App\Services\Attendance\StudentAttendanceWriterService(
+                    new \App\Models\AttendanceData(),
+                    new \App\Models\Student(),
+                    new \App\Services\Attendance\AttendanceRecordSyncService(new \App\Models\AttendanceRecord())
+                ),
+                new \App\Services\Attendance\TeacherAttendanceSubmissionService(
+                    new \App\Models\AttendanceDay(),
+                    new \App\Models\AttendanceData(),
+                    new \App\Models\TeacherClass(),
+                    new \App\Models\Student(),
+                    new \App\Services\Attendance\AttendancePolicyService(),
+                    new \App\Services\Attendance\StudentAttendanceWriterService(
+                        new \App\Models\AttendanceData(),
+                        new \App\Models\Student(),
+                        new \App\Services\Attendance\AttendanceRecordSyncService(new \App\Models\AttendanceRecord())
+                    )
+                ),
+                new \App\Services\Attendance\AttendanceRecordSyncService(new \App\Models\AttendanceRecord())
+            ),
+            new \App\Services\Attendance\SemesterRangeService()
+        );
+
+        $grid = $service->teacherGrid('Fall', '2025-2026', '2025-01-05', 10);
+
+        $this->assertSame('1A', $grid['sections'][10]);
+        $this->assertSame(1, count($grid['grid']));
+        $this->assertSame('present', $grid['grid'][0]['status']);
+    }
+}
diff --git a/tests/Unit/Services/Attendance/AttendanceRecordSyncServiceTest.php b/tests/Unit/Services/Attendance/AttendanceRecordSyncServiceTest.php
index 8b917e0b..5b6fb40f 100644
--- a/tests/Unit/Services/Attendance/AttendanceRecordSyncServiceTest.php
+++ b/tests/Unit/Services/Attendance/AttendanceRecordSyncServiceTest.php
@@ -2,266 +2,46 @@
 
 namespace Tests\Unit\Services\Attendance;
 
-use App\Models\AttendanceRecord;
 use App\Services\Attendance\AttendanceRecordSyncService;
 use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
 use Tests\TestCase;
 
 class AttendanceRecordSyncServiceTest extends TestCase
 {
     use RefreshDatabase;
 
-    protected AttendanceRecordSyncService $service;
-
-    protected function setUp(): void
+    public function test_update_attendance_record_adjusts_totals(): void
     {
-        parent::setUp();
-
-        $this->service = app(AttendanceRecordSyncService::class);
-    }
-
-    public function test_update_attendance_record_increments_and_decrements_counters(): void
-    {
-        $record = AttendanceRecord::query()->create([
-            'class_section_id' => 10,
-            'student_id' => 200,
-            'school_id' => 'SCH-200',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
+        DB::table('attendance_record')->insert([
+            'class_section_id' => 1,
+            'student_id' => 10,
+            'school_id' => 'S1',
             'total_presence' => 5,
-            'total_absence' => 2,
-            'total_late' => 1,
+            'total_absence' => 1,
+            'total_late' => 2,
             'total_attendance' => 8,
-            'modified_by' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $this->service->updateAttendanceRecord(
-            studentId: 200,
-            schoolId: 'SCH-200',
-            newStatus: 'absent',
-            semester: 'Fall',
-            schoolYear: '2025-2026',
-            oldStatus: 'present',
-            modifiedBy: 99
-        );
-
-        $record->refresh();
-
-        $this->assertSame(4, (int)$record->total_presence);
-        $this->assertSame(3, (int)$record->total_absence);
-        $this->assertSame(1, (int)$record->total_late);
-        $this->assertSame(99, (int)$record->modified_by);
-    }
-
-    public function test_update_attendance_record_does_nothing_when_record_missing(): void
-    {
-        $this->service->updateAttendanceRecord(
-            studentId: 999,
-            schoolId: 'SCH-999',
-            newStatus: 'late',
-            semester: 'Fall',
-            schoolYear: '2025-2026',
-            oldStatus: 'present',
-            modifiedBy: 10
-        );
-
-        $this->assertDatabaseMissing('attendance_record', [
-            'student_id' => 999,
             'semester' => 'Fall',
             'school_year' => '2025-2026',
         ]);
+
+        $service = new AttendanceRecordSyncService(new \App\Models\AttendanceRecord());
+        $service->updateAttendanceRecord(10, 'S1', 'absent', 'Fall', '2025-2026', 'present', 1);
+
+        $row = DB::table('attendance_record')->where('student_id', 10)->first();
+        $this->assertSame(4, (int) $row->total_presence);
+        $this->assertSame(2, (int) $row->total_absence);
     }
 
-    public function test_update_attendance_record_never_goes_below_zero(): void
+    public function test_add_new_attendance_record_creates_row(): void
     {
-        $record = AttendanceRecord::query()->create([
-            'class_section_id' => 11,
-            'student_id' => 201,
-            'school_id' => 'SCH-201',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'total_presence' => 0,
-            'total_absence' => 0,
-            'total_late' => 0,
-            'total_attendance' => 0,
-            'modified_by' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $this->service->updateAttendanceRecord(
-            studentId: 201,
-            schoolId: 'SCH-201',
-            newStatus: 'present',
-            semester: 'Fall',
-            schoolYear: '2025-2026',
-            oldStatus: 'absent',
-            modifiedBy: 5
-        );
-
-        $record->refresh();
-
-        $this->assertSame(1, (int)$record->total_presence);
-        $this->assertSame(0, (int)$record->total_absence);
-        $this->assertSame(0, (int)$record->total_late);
-    }
-
-    public function test_add_new_attendance_record_creates_record_when_missing(): void
-    {
-        $this->service->addNewAttendanceRecord(
-            classSectionId: 20,
-            studentId: 300,
-            schoolId: 'SCH-300',
-            status: 'late',
-            semester: 'Spring',
-            schoolYear: '2025-2026',
-            modifiedBy: 88
-        );
+        $service = new AttendanceRecordSyncService(new \App\Models\AttendanceRecord());
+        $service->addNewAttendanceRecord(1, 10, 'S1', 'present', 'Fall', '2025-2026', 1);
 
         $this->assertDatabaseHas('attendance_record', [
-            'class_section_id' => 20,
-            'student_id' => 300,
-            'school_id' => 'SCH-300',
-            'semester' => 'Spring',
-            'school_year' => '2025-2026',
-            'total_presence' => 0,
-            'total_absence' => 0,
-            'total_late' => 1,
-            'total_attendance' => 1,
-            'modified_by' => 88,
-        ]);
-    }
-
-    public function test_add_new_attendance_record_updates_existing_record(): void
-    {
-        $record = AttendanceRecord::query()->create([
-            'class_section_id' => 21,
-            'student_id' => 301,
-            'school_id' => 'SCH-301',
-            'semester' => 'Spring',
-            'school_year' => '2025-2026',
+            'student_id' => 10,
             'total_presence' => 1,
-            'total_absence' => 2,
-            'total_late' => 3,
-            'total_attendance' => 6,
-            'modified_by' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $this->service->addNewAttendanceRecord(
-            classSectionId: 21,
-            studentId: 301,
-            schoolId: 'SCH-301',
-            status: 'present',
-            semester: 'Spring',
-            schoolYear: '2025-2026',
-            modifiedBy: 77
-        );
-
-        $record->refresh();
-
-        $this->assertSame(2, (int)$record->total_presence);
-        $this->assertSame(2, (int)$record->total_absence);
-        $this->assertSame(3, (int)$record->total_late);
-        $this->assertSame(7, (int)$record->total_attendance);
-        $this->assertSame(77, (int)$record->modified_by);
-    }
-
-    public function test_upsert_attendance_record_totals_updates_existing_record(): void
-    {
-        $record = AttendanceRecord::query()->create([
-            'class_section_id' => 30,
-            'student_id' => 400,
-            'school_id' => 'SCH-400',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'total_presence' => 0,
-            'total_absence' => 0,
-            'total_late' => 0,
-            'total_attendance' => 0,
-            'modified_by' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $result = $this->service->upsertAttendanceRecordTotals(
-            studentId: 400,
-            classSectionId: '30',
-            schoolId: 'SCH-400',
-            semester: 'Fall',
-            schoolYear: '2025-2026',
-            totalPresence: 7,
-            totalLate: 2,
-            totalAbsence: 1,
-            totalAttendance: 10,
-            modifiedBy: 44
-        );
-
-        $this->assertTrue($result);
-
-        $record->refresh();
-
-        $this->assertSame(7, (int)$record->total_presence);
-        $this->assertSame(2, (int)$record->total_late);
-        $this->assertSame(1, (int)$record->total_absence);
-        $this->assertSame(10, (int)$record->total_attendance);
-        $this->assertSame(44, (int)$record->modified_by);
-    }
-
-    public function test_upsert_attendance_record_totals_creates_new_record(): void
-    {
-        $result = $this->service->upsertAttendanceRecordTotals(
-            studentId: 401,
-            classSectionId: '31',
-            schoolId: 'SCH-401',
-            semester: 'Fall',
-            schoolYear: '2025-2026',
-            totalPresence: 3,
-            totalLate: 1,
-            totalAbsence: 2,
-            totalAttendance: 6,
-            modifiedBy: 55
-        );
-
-        $this->assertTrue($result);
-
-        $this->assertDatabaseHas('attendance_record', [
-            'student_id' => 401,
-            'class_section_id' => 31,
-            'school_id' => 'SCH-401',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'total_presence' => 3,
-            'total_late' => 1,
-            'total_absence' => 2,
-            'total_attendance' => 6,
-            'modified_by' => 55,
+            'total_attendance' => 1,
         ]);
     }
-
-    public function test_upsert_attendance_record_totals_returns_false_when_semester_or_school_year_missing(): void
-    {
-        $result = $this->service->upsertAttendanceRecordTotals(
-            studentId: 402,
-            classSectionId: '32',
-            schoolId: 'SCH-402',
-            semester: '',
-            schoolYear: '',
-            totalPresence: 1,
-            totalLate: 1,
-            totalAbsence: 1,
-            totalAttendance: 3,
-            modifiedBy: 1
-        );
-
-        $this->assertFalse($result);
-
-        $this->assertDatabaseMissing('attendance_record', [
-            'student_id' => 402,
-            'school_id' => 'SCH-402',
-        ]);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Attendance/AttendanceSemesterRangeServiceTest.php b/tests/Unit/Services/Attendance/AttendanceSemesterRangeServiceTest.php
new file mode 100644
index 00000000..7c6d6a15
--- /dev/null
+++ b/tests/Unit/Services/Attendance/AttendanceSemesterRangeServiceTest.php
@@ -0,0 +1,29 @@
+<?php
+
+namespace Tests\Unit\Services\Attendance;
+
+use App\Services\Attendance\SemesterRangeService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class AttendanceSemesterRangeServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_semester_range(): void
+    {
+        $service = new SemesterRangeService();
+        $range = $service->getSemesterRange('2025-2026', 'fall');
+
+        $this->assertSame(['2025-09-21', '2026-01-18'], $range);
+    }
+
+    public function test_build_sunday_list_returns_sundays(): void
+    {
+        $service = new SemesterRangeService();
+        $dates = $service->buildSundayList('2025-09-01', '2025-09-30');
+
+        $this->assertContains('2025-09-07', $dates);
+        $this->assertContains('2025-09-14', $dates);
+    }
+}
diff --git a/tests/Unit/Services/Attendance/AttendanceServiceTest.php b/tests/Unit/Services/Attendance/AttendanceServiceTest.php
new file mode 100644
index 00000000..11d9aefa
--- /dev/null
+++ b/tests/Unit/Services/Attendance/AttendanceServiceTest.php
@@ -0,0 +1,128 @@
+<?php
+
+namespace Tests\Unit\Services\Attendance;
+
+use App\Models\AttendanceData;
+use App\Models\AttendanceDay;
+use App\Models\ClassSection;
+use App\Models\Configuration;
+use App\Models\User;
+use App\Models\UserRole;
+use App\Services\Attendance\AttendancePolicyService;
+use App\Services\Attendance\AttendanceRecordSyncService;
+use App\Services\Attendance\AttendanceService;
+use App\Services\Attendance\StudentAttendanceWriterService;
+use App\Services\Attendance\TeacherAttendanceSubmissionService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Mockery;
+use Tests\TestCase;
+
+class AttendanceServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_update_attendance_management_throws_when_locked(): void
+    {
+        $user = $this->seedUser();
+
+        $policy = Mockery::mock(AttendancePolicyService::class);
+        $policy->shouldReceive('canEditDay')->andReturn(false);
+
+        $writer = Mockery::mock(StudentAttendanceWriterService::class);
+        $teacherSubmission = Mockery::mock(TeacherAttendanceSubmissionService::class);
+        $recordSync = Mockery::mock(AttendanceRecordSyncService::class);
+
+        $service = new AttendanceService(
+            new Configuration(),
+            new AttendanceData(),
+            new AttendanceDay(),
+            new ClassSection(),
+            new UserRole(),
+            $policy,
+            $writer,
+            $teacherSubmission,
+            $recordSync
+        );
+
+        $this->expectException(\RuntimeException::class);
+        $service->updateAttendanceManagement($user, [
+            'class_section_id' => 1,
+            'student_id' => 1,
+            'status' => 'present',
+            'date' => '2025-01-01',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+    }
+
+    public function test_update_attendance_management_saves_row(): void
+    {
+        $user = $this->seedUser();
+
+        $policy = Mockery::mock(AttendancePolicyService::class);
+        $policy->shouldReceive('canEditDay')->andReturn(true);
+
+        $writer = Mockery::mock(StudentAttendanceWriterService::class);
+        $writer->shouldReceive('saveOrUpdateStudentAttendance')->once();
+
+        $teacherSubmission = Mockery::mock(TeacherAttendanceSubmissionService::class);
+        $recordSync = Mockery::mock(AttendanceRecordSyncService::class);
+
+        $service = new AttendanceService(
+            new Configuration(),
+            new AttendanceData(),
+            new AttendanceDay(),
+            new ClassSection(),
+            new UserRole(),
+            $policy,
+            $writer,
+            $teacherSubmission,
+            $recordSync
+        );
+
+        $result = $service->updateAttendanceManagement($user, [
+            'class_section_id' => 1,
+            'student_id' => 1,
+            'status' => 'present',
+            'date' => '2025-01-01',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'class_id' => 1,
+        ]);
+
+        $this->assertTrue($result['ok']);
+        $this->assertDatabaseHas('attendance_day', [
+            'class_section_id' => 1,
+            'date' => '2025-01-01',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+    }
+
+    private function seedUser(): User
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Test',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'test@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        return User::query()->findOrFail(1);
+    }
+}
diff --git a/tests/Unit/Services/Attendance/StaffAttendanceServiceTest.php b/tests/Unit/Services/Attendance/StaffAttendanceServiceTest.php
new file mode 100644
index 00000000..748191c6
--- /dev/null
+++ b/tests/Unit/Services/Attendance/StaffAttendanceServiceTest.php
@@ -0,0 +1,90 @@
+<?php
+
+namespace Tests\Unit\Services\Attendance;
+
+use App\Services\Attendance\StaffAttendanceService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class StaffAttendanceServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_month_data_returns_sections_and_days(): void
+    {
+        DB::table('configuration')->insert([
+            ['config_key' => 'semester', 'config_value' => 'Fall'],
+            ['config_key' => 'school_year', 'config_value' => '2025-2026'],
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 1,
+            'class_section_id' => 10,
+            'class_section_name' => '1A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'One',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('teacher_class')->insert([
+            'class_section_id' => 10,
+            'teacher_id' => 1,
+            'position' => 'main',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('staff_attendance')->insert([
+            'user_id' => 1,
+            'role_name' => 'teacher',
+            'date' => '2025-09-07',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'status' => 'present',
+            'reason' => null,
+        ]);
+
+        DB::table('calendar_events')->insert([
+            'title' => 'No School',
+            'date' => '2025-09-14',
+            'no_school' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new StaffAttendanceService(
+            new \App\Models\Configuration(),
+            new \App\Models\StaffAttendance(),
+            new \App\Models\TeacherClass(),
+            new \App\Models\ClassSection(),
+            new \App\Services\Attendance\SemesterRangeService()
+        );
+
+        $payload = $service->monthData('Fall', '2025-2026');
+
+        $this->assertNotEmpty($payload['sections']);
+        $this->assertContains('2025-09-14', $payload['noSchoolDays']);
+    }
+}
diff --git a/tests/Unit/Services/Attendance/StudentAttendanceWriterServiceTest.php b/tests/Unit/Services/Attendance/StudentAttendanceWriterServiceTest.php
index ce925874..55012fea 100644
--- a/tests/Unit/Services/Attendance/StudentAttendanceWriterServiceTest.php
+++ b/tests/Unit/Services/Attendance/StudentAttendanceWriterServiceTest.php
@@ -2,321 +2,90 @@
 
 namespace Tests\Unit\Services\Attendance;
 
-use App\Models\AttendanceData;
-use App\Models\AttendanceRecord;
-use App\Models\Student;
 use App\Services\Attendance\AttendanceRecordSyncService;
 use App\Services\Attendance\StudentAttendanceWriterService;
 use Illuminate\Foundation\Testing\RefreshDatabase;
-use RuntimeException;
+use Illuminate\Support\Facades\DB;
+use Mockery;
 use Tests\TestCase;
 
 class StudentAttendanceWriterServiceTest extends TestCase
 {
     use RefreshDatabase;
 
-    protected StudentAttendanceWriterService $service;
-
-    protected function setUp(): void
+    public function test_resolve_student_school_id_from_student(): void
     {
-        parent::setUp();
-
-        $this->service = app(StudentAttendanceWriterService::class);
-    }
-
-    public function test_resolve_student_school_id_returns_passed_value_when_present(): void
-    {
-        $result = $this->service->resolveStudentSchoolId(100, 'SCH-100');
-
-        $this->assertSame('SCH-100', $result);
-    }
-
-    public function test_resolve_student_school_id_fetches_from_database_when_missing(): void
-    {
-        Student::query()->create([
-            'id' => 101,
-            'firstname' => 'John',
-            'lastname' => 'Doe',
-            'school_id' => 'SCH-101',
-            'is_active' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
+        DB::table('students')->insert([
+            'id' => 1,
+            'school_id' => 'S1',
+            'firstname' => 'Test',
+            'lastname' => 'Student',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
         ]);
 
-        $result = $this->service->resolveStudentSchoolId(101, null);
+        $sync = Mockery::mock(AttendanceRecordSyncService::class);
+        $service = new StudentAttendanceWriterService(new \App\Models\AttendanceData(), new \App\Models\Student(), $sync);
 
-        $this->assertSame('SCH-101', $result);
+        $this->assertSame('S1', $service->resolveStudentSchoolId(1, null));
     }
 
-    public function test_resolve_student_school_id_throws_when_student_missing(): void
+    public function test_save_or_update_updates_existing_and_syncs_record(): void
     {
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Student school ID not found.');
+        DB::table('students')->insert([
+            'id' => 1,
+            'school_id' => 'S1',
+            'firstname' => 'Test',
+            'lastname' => 'Student',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
+        ]);
 
-        $this->service->resolveStudentSchoolId(9999, null);
-    }
+        DB::table('attendance_data')->insert([
+            'class_id' => 1,
+            'class_section_id' => 1,
+            'student_id' => 1,
+            'school_id' => 'S1',
+            'date' => '2025-01-01',
+            'status' => 'present',
+            'is_reported' => 'no',
+            'is_notified' => 'no',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
 
-    public function test_insert_attendance_data_creates_new_row(): void
-    {
-        $this->service->insertAttendanceData(
-            classSectionId: 10,
-            studentId: 200,
-            studentSchoolId: 'SCH-200',
-            status: 'Absent',
-            reason: 'Sick',
-            reported: 'yes',
-            semester: 'Fall',
-            schoolYear: '2025-2026',
-            date: '2025-10-05',
-            classId: 5,
-            userId: 22
-        );
+        $sync = Mockery::mock(AttendanceRecordSyncService::class);
+        $sync->shouldReceive('updateAttendanceRecord')->once();
 
-        $this->assertDatabaseHas('attendance_data', [
-            'class_id' => 5,
-            'class_section_id' => 10,
-            'student_id' => 200,
-            'school_id' => 'SCH-200',
+        $service = new StudentAttendanceWriterService(new \App\Models\AttendanceData(), new \App\Models\Student(), $sync);
+
+        $service->saveOrUpdateStudentAttendance([
+            'class_section_id' => 1,
+            'student_id' => 1,
+            'school_id' => null,
             'status' => 'absent',
             'reason' => 'Sick',
             'is_reported' => 'yes',
-            'is_notified' => 'no',
             'semester' => 'Fall',
             'school_year' => '2025-2026',
-            'date' => '2025-10-05',
-            'modified_by' => 22,
+            'date' => '2025-01-01',
+            'class_id' => 1,
+            'user_id' => 1,
         ]);
-    }
-
-    public function test_update_attendance_data_updates_existing_row(): void
-    {
-        $row = AttendanceData::query()->create([
-            'class_id' => 6,
-            'class_section_id' => 12,
-            'student_id' => 201,
-            'school_id' => 'SCH-201',
-            'status' => 'present',
-            'reason' => null,
-            'is_reported' => 'no',
-            'is_notified' => 'no',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'date' => '2025-10-12',
-            'modified_by' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $this->service->updateAttendanceData(
-            attendanceId: $row->id,
-            newStatus: 'late',
-            newReason: 'Traffic',
-            reported: 'yes',
-            userId: 99
-        );
-
-        $row->refresh();
-
-        $this->assertSame('late', $row->status);
-        $this->assertSame('Traffic', $row->reason);
-        $this->assertSame('yes', $row->is_reported);
-        $this->assertSame(99, (int)$row->modified_by);
-    }
-
-    public function test_save_or_update_student_attendance_creates_new_attendance_and_record(): void
-    {
-        Student::query()->create([
-            'id' => 300,
-            'firstname' => 'Sara',
-            'lastname' => 'Smith',
-            'school_id' => 'SCH-300',
-            'is_active' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $result = $this->service->saveOrUpdateStudentAttendance([
-            'class_section_id' => 15,
-            'student_id' => 300,
-            'school_id' => null,
-            'status' => 'present',
-            'reason' => 'On time',
-            'is_reported' => 'no',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'date' => '2025-10-19',
-            'class_id' => 9,
-            'user_id' => 88,
-        ]);
-
-        $this->assertSame('created', $result['mode']);
-        $this->assertSame('present', $result['new_status']);
-        $this->assertSame('SCH-300', $result['school_id']);
 
         $this->assertDatabaseHas('attendance_data', [
-            'student_id' => 300,
-            'school_id' => 'SCH-300',
-            'status' => 'present',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'date' => '2025-10-19',
-        ]);
-
-        $this->assertDatabaseHas('attendance_record', [
-            'student_id' => 300,
-            'school_id' => 'SCH-300',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'total_presence' => 1,
-            'total_absence' => 0,
-            'total_late' => 0,
-            'total_attendance' => 1,
-            'modified_by' => 88,
-        ]);
-    }
-
-    public function test_save_or_update_student_attendance_updates_existing_attendance_and_record(): void
-    {
-        Student::query()->create([
-            'id' => 301,
-            'firstname' => 'Ali',
-            'lastname' => 'Khan',
-            'school_id' => 'SCH-301',
-            'is_active' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        AttendanceRecord::query()->create([
-            'class_section_id' => 16,
-            'student_id' => 301,
-            'school_id' => 'SCH-301',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'total_presence' => 2,
-            'total_absence' => 0,
-            'total_late' => 0,
-            'total_attendance' => 2,
-            'modified_by' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $attendance = AttendanceData::query()->create([
-            'class_id' => 10,
-            'class_section_id' => 16,
-            'student_id' => 301,
-            'school_id' => 'SCH-301',
-            'status' => 'present',
-            'reason' => null,
-            'is_reported' => 'no',
-            'is_notified' => 'no',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'date' => '2025-10-26',
-            'modified_by' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $result = $this->service->saveOrUpdateStudentAttendance([
-            'class_section_id' => 16,
-            'student_id' => 301,
-            'school_id' => 'SCH-301',
+            'student_id' => 1,
             'status' => 'absent',
-            'reason' => 'Family trip',
+            'reason' => 'Sick',
             'is_reported' => 'yes',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'date' => '2025-10-26',
-            'class_id' => 10,
-            'user_id' => 77,
-        ]);
-
-        $this->assertSame('updated', $result['mode']);
-        $this->assertSame('present', $result['old_status']);
-        $this->assertSame('absent', $result['new_status']);
-
-        $attendance->refresh();
-
-        $this->assertSame('absent', $attendance->status);
-        $this->assertSame('Family trip', $attendance->reason);
-        $this->assertSame('yes', $attendance->is_reported);
-        $this->assertSame(77, (int)$attendance->modified_by);
-
-        $this->assertDatabaseHas('attendance_record', [
-            'student_id' => 301,
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'total_presence' => 1,
-            'total_absence' => 1,
-            'total_late' => 0,
         ]);
     }
-
-    public function test_save_or_update_student_attendance_updates_existing_without_counter_change_when_status_same(): void
-    {
-        Student::query()->create([
-            'id' => 302,
-            'firstname' => 'Mona',
-            'lastname' => 'Lee',
-            'school_id' => 'SCH-302',
-            'is_active' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $record = AttendanceRecord::query()->create([
-            'class_section_id' => 17,
-            'student_id' => 302,
-            'school_id' => 'SCH-302',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'total_presence' => 4,
-            'total_absence' => 1,
-            'total_late' => 0,
-            'total_attendance' => 5,
-            'modified_by' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        AttendanceData::query()->create([
-            'class_id' => 11,
-            'class_section_id' => 17,
-            'student_id' => 302,
-            'school_id' => 'SCH-302',
-            'status' => 'present',
-            'reason' => null,
-            'is_reported' => 'no',
-            'is_notified' => 'no',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'date' => '2025-11-02',
-            'modified_by' => 1,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $this->service->saveOrUpdateStudentAttendance([
-            'class_section_id' => 17,
-            'student_id' => 302,
-            'school_id' => 'SCH-302',
-            'status' => 'present',
-            'reason' => 'Still present',
-            'is_reported' => 'no',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'date' => '2025-11-02',
-            'class_id' => 11,
-            'user_id' => 66,
-        ]);
-
-        $record->refresh();
-
-        $this->assertSame(4, (int)$record->total_presence);
-        $this->assertSame(1, (int)$record->total_absence);
-        $this->assertSame(0, (int)$record->total_late);
-        $this->assertSame(5, (int)$record->total_attendance);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Attendance/TeacherAttendanceSubmissionServiceTest.php b/tests/Unit/Services/Attendance/TeacherAttendanceSubmissionServiceTest.php
index 6cb5b593..fcf4f6db 100644
--- a/tests/Unit/Services/Attendance/TeacherAttendanceSubmissionServiceTest.php
+++ b/tests/Unit/Services/Attendance/TeacherAttendanceSubmissionServiceTest.php
@@ -2,544 +2,80 @@
 
 namespace Tests\Unit\Services\Attendance;
 
-use App\Models\AttendanceData;
-use App\Models\AttendanceDay;
-use App\Models\Student;
-use App\Models\TeacherClass;
 use App\Models\User;
-use App\Services\Attendance\AttendancePolicyService;
-use App\Services\Attendance\StudentAttendanceWriterService;
 use App\Services\Attendance\TeacherAttendanceSubmissionService;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\DB;
 use Mockery;
-use RuntimeException;
 use Tests\TestCase;
 
 class TeacherAttendanceSubmissionServiceTest extends TestCase
 {
     use RefreshDatabase;
 
-    protected function tearDown(): void
-    {
-        Mockery::close();
-        parent::tearDown();
-    }
-
-    protected function makeService(
-        ?AttendanceDay $attendanceDay = null,
-        ?AttendanceData $attendanceData = null,
-        mixed $teacherClass = null,
-        ?Student $student = null,
-        mixed $attendancePolicyService = null,
-        mixed $studentAttendanceWriterService = null
-    ): TeacherAttendanceSubmissionService {
-        return new TeacherAttendanceSubmissionService(
-            $attendanceDay ?? app(AttendanceDay::class),
-            $attendanceData ?? app(AttendanceData::class),
-            $teacherClass ?? app(TeacherClass::class),
-            $student ?? app(Student::class),
-            $attendancePolicyService ?? app(AttendancePolicyService::class),
-            $studentAttendanceWriterService ?? app(StudentAttendanceWriterService::class),
-        );
-    }
-
-    public function test_submit_throws_when_class_section_missing(): void
-    {
-        $service = $this->makeService();
-
-        $user = User::factory()->create();
-
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Missing or invalid class section.');
-
-        $service->submit(
-            user: $user,
-            data: [
-                'class_section_id' => '',
-                'attendance' => [],
-                'teachers' => [],
-            ],
-            detectExternalSubmission: fn (?array $row) => ['locked' => false, 'source' => null],
-            currentSemester: fn () => 'Fall',
-            currentSchoolYear: fn () => '2025-2026'
-        );
-    }
-
-    public function test_submit_throws_when_section_not_found(): void
-    {
-        $service = $this->makeService();
-        $user = User::factory()->create();
-
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Invalid class section.');
-
-        $service->submit(
-            user: $user,
-            data: [
-                'class_section_id' => '999999',
-                'attendance' => [['student_id' => 1, 'status' => 'present']],
-                'teachers' => [1 => ['status' => 'present']],
-            ],
-            detectExternalSubmission: fn (?array $row) => ['locked' => false, 'source' => null],
-            currentSemester: fn () => 'Fall',
-            currentSchoolYear: fn () => '2025-2026'
-        );
-    }
-
-    public function test_submit_throws_when_student_attendance_missing(): void
+    public function test_submit_requires_attendance_data(): void
     {
         DB::table('classSection')->insert([
             'id' => 1,
-            'class_id' => 5,
-            'class_section_id' => 100,
+            'class_id' => 1,
+            'class_section_id' => 10,
+            'class_section_name' => '1A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
         ]);
 
-        $teacherClassMock = Mockery::mock(TeacherClass::class);
-        $teacherClassMock->shouldReceive('assignedForSectionTerm')
-            ->once()
-            ->andReturn([
-                [
-                    'teacher_id' => 55,
-                    'position' => 'main',
-                    'firstname' => 'Main',
-                    'lastname' => 'Teacher',
-                ],
-            ]);
+        $user = $this->seedUser();
 
-        $policyMock = Mockery::mock(AttendancePolicyService::class);
-        $policyMock->shouldReceive('canEditDay')->once()->andReturnTrue();
+        $policy = Mockery::mock(\App\Services\Attendance\AttendancePolicyService::class);
+        $policy->shouldReceive('canEditDay')->andReturn(true);
 
-        $writerMock = Mockery::mock(StudentAttendanceWriterService::class);
-
-        $service = $this->makeService(
-            teacherClass: $teacherClassMock,
-            attendancePolicyService: $policyMock,
-            studentAttendanceWriterService: $writerMock
+        $service = new TeacherAttendanceSubmissionService(
+            new \App\Models\AttendanceDay(),
+            new \App\Models\AttendanceData(),
+            new \App\Models\TeacherClass(),
+            new \App\Models\Student(),
+            $policy,
+            new \App\Services\Attendance\StudentAttendanceWriterService(
+                new \App\Models\AttendanceData(),
+                new \App\Models\Student(),
+                new \App\Services\Attendance\AttendanceRecordSyncService(new \App\Models\AttendanceRecord())
+            )
         );
 
-        $user = User::factory()->create();
-
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('No student attendance data provided.');
+        $this->expectException(\RuntimeException::class);
 
         $service->submit(
-            user: $user,
-            data: [
-                'class_section_id' => '100',
-                'attendance' => [],
-                'teachers' => [55 => ['status' => 'present']],
-            ],
-            detectExternalSubmission: fn (?array $row) => ['locked' => false, 'source' => null],
-            currentSemester: fn () => 'Fall',
-            currentSchoolYear: fn () => '2025-2026'
+            $user,
+            ['class_section_id' => 10],
+            fn () => false,
+            fn () => 'Fall',
+            fn () => '2025-2026'
         );
     }
 
-    public function test_submit_throws_when_teacher_attendance_missing(): void
+    private function seedUser(): User
     {
-        DB::table('classSection')->insert([
-            'id' => 2,
-            'class_id' => 6,
-            'class_section_id' => 101,
-        ]);
-
-        $service = $this->makeService();
-        $user = User::factory()->create();
-
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('No teacher attendance data provided.');
-
-        $service->submit(
-            user: $user,
-            data: [
-                'class_section_id' => '101',
-                'attendance' => [
-                    ['student_id' => 1, 'status' => 'present'],
-                ],
-                'teachers' => [],
-            ],
-            detectExternalSubmission: fn (?array $row) => ['locked' => false, 'source' => null],
-            currentSemester: fn () => 'Fall',
-            currentSchoolYear: fn () => '2025-2026'
-        );
-    }
-
-    public function test_submit_throws_when_policy_denies_edit(): void
-    {
-        DB::table('classSection')->insert([
-            'id' => 3,
-            'class_id' => 7,
-            'class_section_id' => 102,
-        ]);
-
-        $teacherClassMock = Mockery::mock(TeacherClass::class);
-        $teacherClassMock->shouldReceive('assignedForSectionTerm')->never();
-
-        $policyMock = Mockery::mock(AttendancePolicyService::class);
-        $policyMock->shouldReceive('canEditDay')->once()->andReturnFalse();
-
-        $writerMock = Mockery::mock(StudentAttendanceWriterService::class);
-
-        $service = $this->makeService(
-            teacherClass: $teacherClassMock,
-            attendancePolicyService: $policyMock,
-            studentAttendanceWriterService: $writerMock
-        );
-
-        $user = User::factory()->create();
-
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Attendance is locked for your role.');
-
-        $service->submit(
-            user: $user,
-            data: [
-                'class_section_id' => '102',
-                'attendance' => [
-                    ['student_id' => 1, 'status' => 'present'],
-                ],
-                'teachers' => [
-                    55 => ['status' => 'present'],
-                ],
-            ],
-            detectExternalSubmission: fn (?array $row) => ['locked' => false, 'source' => null],
-            currentSemester: fn () => 'Fall',
-            currentSchoolYear: fn () => '2025-2026'
-        );
-    }
-
-    public function test_submit_throws_when_assigned_teacher_status_missing_or_invalid(): void
-    {
-        DB::table('classSection')->insert([
-            'id' => 4,
-            'class_id' => 8,
-            'class_section_id' => 103,
-        ]);
-
-        $teacherClassMock = Mockery::mock(TeacherClass::class);
-        $teacherClassMock->shouldReceive('assignedForSectionTerm')
-            ->once()
-            ->andReturn([
-                [
-                    'teacher_id' => 77,
-                    'position' => 'main',
-                    'firstname' => 'Main',
-                    'lastname' => 'Teacher',
-                ],
-            ]);
-
-        $policyMock = Mockery::mock(AttendancePolicyService::class);
-        $policyMock->shouldReceive('canEditDay')->once()->andReturnTrue();
-
-        $writerMock = Mockery::mock(StudentAttendanceWriterService::class);
-
-        $service = $this->makeService(
-            teacherClass: $teacherClassMock,
-            attendancePolicyService: $policyMock,
-            studentAttendanceWriterService: $writerMock
-        );
-
-        $user = User::factory()->create();
-
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Please fill teacher attendance for all assigned teachers.');
-
-        $service->submit(
-            user: $user,
-            data: [
-                'class_section_id' => '103',
-                'attendance' => [
-                    ['student_id' => 1, 'status' => 'present'],
-                ],
-                'teachers' => [
-                    77 => ['status' => ''],
-                ],
-            ],
-            detectExternalSubmission: fn (?array $row) => ['locked' => false, 'source' => null],
-            currentSemester: fn () => 'Fall',
-            currentSchoolYear: fn () => '2025-2026'
-        );
-    }
-
-    public function test_submit_saves_teacher_staff_attendance_and_student_rows(): void
-    {
-        DB::table('classSection')->insert([
-            'id' => 5,
-            'class_id' => 9,
-            'class_section_id' => 104,
-        ]);
-
-        $teacherClassMock = Mockery::mock(TeacherClass::class);
-        $teacherClassMock->shouldReceive('assignedForSectionTerm')
-            ->once()
-            ->andReturn([
-                [
-                    'teacher_id' => 88,
-                    'position' => 'main',
-                    'firstname' => 'Lead',
-                    'lastname' => 'Teacher',
-                ],
-                [
-                    'teacher_id' => 89,
-                    'position' => 'ta',
-                    'firstname' => 'Assist',
-                    'lastname' => 'Teacher',
-                ],
-            ]);
-
-        $policyMock = Mockery::mock(AttendancePolicyService::class);
-        $policyMock->shouldReceive('canEditDay')->once()->andReturnTrue();
-        $policyMock->shouldReceive('isTeacher')->once()->andReturnTrue();
-
-        $writerMock = Mockery::mock(StudentAttendanceWriterService::class);
-        $writerMock->shouldReceive('saveOrUpdateStudentAttendance')
-            ->twice()
-            ->withArgs(function (array $payload) {
-                return in_array($payload['student_id'], [501, 502], true)
-                    && $payload['class_section_id'] === 104
-                    && $payload['class_id'] === 9
-                    && $payload['semester'] === 'Fall'
-                    && $payload['school_year'] === '2025-2026';
-            })
-            ->andReturn(['mode' => 'created']);
-
-        $service = $this->makeService(
-            teacherClass: $teacherClassMock,
-            attendancePolicyService: $policyMock,
-            studentAttendanceWriterService: $writerMock
-        );
-
-        $user = User::factory()->create();
-
-        $result = $service->submit(
-            user: $user,
-            data: [
-                'class_section_id' => '104',
-                'date' => '2025-10-05',
-                'attendance' => [
-                    [
-                        'student_id' => 501,
-                        'school_id' => 'SCH-501',
-                        'status' => 'present',
-                        'reason' => '',
-                    ],
-                    [
-                        'student_id' => 502,
-                        'school_id' => 'SCH-502',
-                        'status' => 'late',
-                        'reason' => 'Bus delay',
-                    ],
-                ],
-                'teachers' => [
-                    88 => ['status' => 'present', 'reason' => null],
-                    89 => ['status' => 'late', 'reason' => 'Traffic'],
-                ],
-            ],
-            detectExternalSubmission: fn (?array $row) => ['locked' => false, 'source' => null],
-            currentSemester: fn () => 'Fall',
-            currentSchoolYear: fn () => '2025-2026'
-        );
-
-        $this->assertSame(['ok' => true, 'message' => 'Attendance submitted successfully.'], $result);
-
-        $this->assertDatabaseHas('staff_attendance', [
-            'user_id' => 88,
-            'date' => '2025-10-05',
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'One',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
             'semester' => 'Fall',
             'school_year' => '2025-2026',
-            'class_section_id' => 104,
-            'position' => 'main',
-            'status' => 'present',
         ]);
 
-        $this->assertDatabaseHas('staff_attendance', [
-            'user_id' => 89,
-            'date' => '2025-10-05',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'class_section_id' => 104,
-            'position' => 'ta',
-            'status' => 'late',
-            'reason' => 'Traffic',
-        ]);
-
-        $this->assertDatabaseHas('attendance_day', [
-            'class_section_id' => 104,
-            'date' => '2025-10-05',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'status' => 'submitted',
-            'submitted_by' => $user->id,
-        ]);
+        return User::query()->findOrFail(1);
     }
-
-    public function test_submit_skips_locked_existing_student_rows_for_teacher(): void
-    {
-        DB::table('classSection')->insert([
-            'id' => 6,
-            'class_id' => 10,
-            'class_section_id' => 105,
-        ]);
-
-        AttendanceData::query()->create([
-            'class_id' => 10,
-            'class_section_id' => 105,
-            'student_id' => 601,
-            'school_id' => 'SCH-601',
-            'status' => 'absent',
-            'reason' => 'Parent reported',
-            'is_reported' => 'yes',
-            'is_notified' => 'no',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'date' => '2025-10-12',
-            'modified_by' => 2,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $teacherClassMock = Mockery::mock(TeacherClass::class);
-        $teacherClassMock->shouldReceive('assignedForSectionTerm')
-            ->once()
-            ->andReturn([
-                [
-                    'teacher_id' => 90,
-                    'position' => 'main',
-                    'firstname' => 'Lead',
-                    'lastname' => 'Teacher',
-                ],
-            ]);
-
-        $policyMock = Mockery::mock(AttendancePolicyService::class);
-        $policyMock->shouldReceive('canEditDay')->once()->andReturnTrue();
-        $policyMock->shouldReceive('isTeacher')->once()->andReturnTrue();
-
-        $writerMock = Mockery::mock(StudentAttendanceWriterService::class);
-        $writerMock->shouldNotReceive('saveOrUpdateStudentAttendance');
-
-        $service = $this->makeService(
-            teacherClass: $teacherClassMock,
-            attendancePolicyService: $policyMock,
-            studentAttendanceWriterService: $writerMock
-        );
-
-        $user = User::factory()->create();
-
-        $result = $service->submit(
-            user: $user,
-            data: [
-                'class_section_id' => '105',
-                'date' => '2025-10-12',
-                'attendance' => [
-                    [
-                        'student_id' => 601,
-                        'school_id' => 'SCH-601',
-                        'status' => 'present',
-                        'reason' => '',
-                    ],
-                ],
-                'teachers' => [
-                    90 => ['status' => 'present', 'reason' => null],
-                ],
-            ],
-            detectExternalSubmission: fn (?array $row) => ['locked' => true, 'source' => 'parent'],
-            currentSemester: fn () => 'Fall',
-            currentSchoolYear: fn () => '2025-2026'
-        );
-
-        $this->assertTrue($result['ok']);
-
-        $this->assertDatabaseHas('attendance_day', [
-            'class_section_id' => 105,
-            'date' => '2025-10-12',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'status' => 'submitted',
-        ]);
-    }
-
-    public function test_submit_allows_non_teacher_context_to_write_existing_rows(): void
-    {
-        DB::table('classSection')->insert([
-            'id' => 7,
-            'class_id' => 11,
-            'class_section_id' => 106,
-        ]);
-
-        AttendanceData::query()->create([
-            'class_id' => 11,
-            'class_section_id' => 106,
-            'student_id' => 701,
-            'school_id' => 'SCH-701',
-            'status' => 'absent',
-            'reason' => 'Parent reported',
-            'is_reported' => 'yes',
-            'is_notified' => 'no',
-            'semester' => 'Fall',
-            'school_year' => '2025-2026',
-            'date' => '2025-10-19',
-            'modified_by' => 2,
-            'created_at' => now(),
-            'updated_at' => now(),
-        ]);
-
-        $teacherClassMock = Mockery::mock(TeacherClass::class);
-        $teacherClassMock->shouldReceive('assignedForSectionTerm')
-            ->once()
-            ->andReturn([
-                [
-                    'teacher_id' => 91,
-                    'position' => 'main',
-                    'firstname' => 'Lead',
-                    'lastname' => 'Teacher',
-                ],
-            ]);
-
-        $policyMock = Mockery::mock(AttendancePolicyService::class);
-        $policyMock->shouldReceive('canEditDay')->once()->andReturnTrue();
-        $policyMock->shouldReceive('isTeacher')->once()->andReturnFalse();
-
-        $writerMock = Mockery::mock(StudentAttendanceWriterService::class);
-        $writerMock->shouldReceive('saveOrUpdateStudentAttendance')
-            ->once()
-            ->withArgs(function (array $payload) {
-                return $payload['student_id'] === 701
-                    && $payload['class_section_id'] === 106
-                    && $payload['class_id'] === 11;
-            })
-            ->andReturn(['mode' => 'updated']);
-
-        $service = $this->makeService(
-            teacherClass: $teacherClassMock,
-            attendancePolicyService: $policyMock,
-            studentAttendanceWriterService: $writerMock
-        );
-
-        $user = User::factory()->create();
-
-        $result = $service->submit(
-            user: $user,
-            data: [
-                'class_section_id' => '106',
-                'date' => '2025-10-19',
-                'attendance' => [
-                    [
-                        'student_id' => 701,
-                        'school_id' => 'SCH-701',
-                        'status' => 'present',
-                        'reason' => '',
-                    ],
-                ],
-                'teachers' => [
-                    91 => ['status' => 'present', 'reason' => null],
-                ],
-            ],
-            detectExternalSubmission: fn (?array $row) => ['locked' => true, 'source' => 'parent'],
-            currentSemester: fn () => 'Fall',
-            currentSchoolYear: fn () => '2025-2026'
-        );
-
-        $this->assertTrue($result['ok']);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/AttendanceTracking/AttendanceCaseQueryServiceTest.php b/tests/Unit/Services/AttendanceTracking/AttendanceCaseQueryServiceTest.php
index e8cc8e35..ec522757 100644
--- a/tests/Unit/Services/AttendanceTracking/AttendanceCaseQueryServiceTest.php
+++ b/tests/Unit/Services/AttendanceTracking/AttendanceCaseQueryServiceTest.php
@@ -2,44 +2,28 @@
 
 namespace Tests\Unit\Services\AttendanceTracking;
 
-use App\Models\AttendanceData;
-use App\Models\AttendanceTracking;
-use App\Models\Student;
-use App\Services\AttendanceCaseQueryService;
-use App\Services\AttendanceParentLookupService;
-use App\Services\ViolationRuleEngineService;
+use App\Services\AttendanceTracking\AttendanceCaseQueryService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
 use Mockery;
 use Tests\TestCase;
 
 class AttendanceCaseQueryServiceTest extends TestCase
 {
-    protected function tearDown(): void
+    use RefreshDatabase;
+
+    public function test_returns_not_found_when_student_missing(): void
     {
-        Mockery::close();
-        parent::tearDown();
-    }
-
-    public function test_get_student_case_returns_404_when_student_not_found(): void
-    {
-        $student = Mockery::mock(Student::class);
-        $student->shouldReceive('query->find')->with(99)->andReturn(null);
-
-        $attendanceData = Mockery::mock(AttendanceData::class);
-        $tracking = Mockery::mock(AttendanceTracking::class);
-        $rules = Mockery::mock(ViolationRuleEngineService::class);
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
-
         $service = new AttendanceCaseQueryService(
-            $student,
-            $attendanceData,
-            $tracking,
-            $rules,
-            $parents
+            new \App\Models\Student(),
+            new \App\Models\AttendanceData(),
+            new \App\Models\AttendanceTracking(),
+            Mockery::mock(\App\Services\AttendanceTracking\ViolationRuleEngineService::class),
+            Mockery::mock(\App\Services\AttendanceTracking\AttendanceParentLookupService::class)
         );
 
-        $result = $service->getStudentCase(99);
+        $result = $service->getStudentCase(999);
 
         $this->assertFalse($result['success']);
         $this->assertSame(404, $result['status']);
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/AttendanceTracking/AttendanceCommunicationSupportServiceTest.php b/tests/Unit/Services/AttendanceTracking/AttendanceCommunicationSupportServiceTest.php
index 68aad4cc..81ca8b92 100644
--- a/tests/Unit/Services/AttendanceTracking/AttendanceCommunicationSupportServiceTest.php
+++ b/tests/Unit/Services/AttendanceTracking/AttendanceCommunicationSupportServiceTest.php
@@ -2,72 +2,62 @@
 
 namespace Tests\Unit\Services\AttendanceTracking;
 
-use App\Models\AttendanceData;
-use App\Models\Configuration;
-use App\Models\Student;
-use App\Services\AttendanceCommunicationSupportService;
-use App\Services\AttendanceEmailComposerService;
-use App\Services\AttendanceParentLookupService;
+use App\Services\AttendanceTracking\AttendanceCommunicationSupportService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
 use Mockery;
 use Tests\TestCase;
 
 class AttendanceCommunicationSupportServiceTest extends TestCase
 {
-    protected function tearDown(): void
-    {
-        Mockery::close();
-        parent::tearDown();
-    }
+    use RefreshDatabase;
 
-    protected function makeService(
-        ?Student $student = null,
-        ?AttendanceData $attendanceData = null,
-        ?Configuration $config = null,
-        ?AttendanceParentLookupService $parents = null,
-        ?AttendanceEmailComposerService $composer = null
-    ): AttendanceCommunicationSupportService {
-        $student ??= Mockery::mock(Student::class);
-        $attendanceData ??= Mockery::mock(AttendanceData::class);
-        $config ??= Mockery::mock(Configuration::class);
-        $parents ??= Mockery::mock(AttendanceParentLookupService::class);
-        $composer ??= Mockery::mock(AttendanceEmailComposerService::class);
-
-        $config->shouldReceive('getConfig')->with('semester')->andReturn('Fall');
-        $config->shouldReceive('getConfig')->with('school_year')->andReturn('2025-2026');
-
-        return new AttendanceCommunicationSupportService(
-            $student,
-            $attendanceData,
-            $config,
-            $parents,
-            $composer
-        );
-    }
-
-    public function test_compose_returns_422_when_student_id_missing(): void
+    public function test_compose_requires_student_id(): void
     {
         $service = $this->makeService();
-
         $result = $service->compose(0);
 
         $this->assertFalse($result['success']);
         $this->assertSame(422, $result['status']);
     }
 
-    public function test_parents_info_delegates_to_parent_lookup_service(): void
+    public function test_get_violation_dates_for_student(): void
     {
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
-        $parents->shouldReceive('parentsInfo')
-            ->once()
-            ->with(20, '2025-2026')
-            ->andReturn(['success' => true, 'data' => ['primary' => [], 'secondary' => []]]);
+        DB::table('configuration')->insert([
+            ['config_key' => 'semester', 'config_value' => 'Fall'],
+            ['config_key' => 'school_year', 'config_value' => '2025-2026'],
+        ]);
 
-        $service = $this->makeService(
-            parents: $parents
-        );
+        DB::table('attendance_data')->insert([
+            'class_id' => 1,
+            'class_section_id' => 1,
+            'student_id' => 1,
+            'school_id' => 'S1',
+            'date' => '2025-01-01',
+            'status' => 'absent',
+            'is_reported' => 'no',
+            'is_notified' => 'no',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
 
-        $result = $service->parentsInfo(20);
+        $service = $this->makeService();
+        $dates = $service->getViolationDatesForStudent(1, 'ABS_1');
 
-        $this->assertTrue($result['success']);
+        $this->assertSame(['2025-01-01'], $dates);
     }
-}
\ No newline at end of file
+
+    private function makeService(): AttendanceCommunicationSupportService
+    {
+        $parentLookup = Mockery::mock(\App\Services\AttendanceTracking\AttendanceParentLookupService::class);
+        $emailComposer = Mockery::mock(\App\Services\AttendanceTracking\AttendanceEmailComposerService::class);
+
+        return new AttendanceCommunicationSupportService(
+            new \App\Models\Student(),
+            new \App\Models\AttendanceData(),
+            new \App\Models\Configuration(),
+            $parentLookup,
+            $emailComposer
+        );
+    }
+}
diff --git a/tests/Unit/Services/AttendanceTracking/AttendanceEmailComposerServiceTest.php b/tests/Unit/Services/AttendanceTracking/AttendanceEmailComposerServiceTest.php
index 55e2de69..ca5eb145 100644
--- a/tests/Unit/Services/AttendanceTracking/AttendanceEmailComposerServiceTest.php
+++ b/tests/Unit/Services/AttendanceTracking/AttendanceEmailComposerServiceTest.php
@@ -2,124 +2,37 @@
 
 namespace Tests\Unit\Services\AttendanceTracking;
 
-use App\Models\AttendanceEmailTemplate;
-use App\Services\AttendanceEmailComposerService;
-use Mockery;
+use App\Services\AttendanceTracking\AttendanceEmailComposerService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
 use Tests\TestCase;
 
 class AttendanceEmailComposerServiceTest extends TestCase
 {
-    protected function tearDown(): void
+    use RefreshDatabase;
+
+    public function test_render_template_replaces_tokens(): void
     {
-        Mockery::close();
-        parent::tearDown();
-    }
-
-    public function test_build_template_context_returns_expected_placeholders(): void
-    {
-        $model = Mockery::mock(AttendanceEmailTemplate::class);
-        $service = new AttendanceEmailComposerService($model);
-
-        $context = $service->buildTemplateContext(
-            [
-                'name' => 'John Doe',
-                'last_date' => '2026-03-01',
-            ],
-            [
-                'parent_name' => 'Jane Doe',
-                'phone' => '555-1212',
-            ]
-        );
-
-        $this->assertSame('Jane Doe', $context['{{parent_name}}']);
-        $this->assertSame('John Doe', $context['{{student_name}}']);
-        $this->assertSame('2026-03-01', $context['{{incident_date}}']);
-        $this->assertSame('555-1212', $context['{{voicemail_phone}}']);
-    }
-
-    public function test_render_template_uses_model_get_template(): void
-    {
-        $model = Mockery::mock(AttendanceEmailTemplate::class);
-        $model->shouldReceive('getTemplate')
-            ->once()
-            ->with('ABS_1', 'default')
-            ->andReturn([
-                'subject' => 'Notice for {{student_name}}',
-                'body_html' => '<p>Date: {{incident_date}}</p>',
-            ]);
-
-        $service = new AttendanceEmailComposerService($model);
-
-        $rendered = $service->renderTemplate('ABS_1', 'default', [
-            '{{student_name}}' => 'John Doe',
-            '{{incident_date}}' => '2026-03-01',
+        DB::table('email_templates')->insert([
+            'code' => 'ABS_1',
+            'variant' => 'default',
+            'subject' => 'Notice for {{student_name}}',
+            'body_html' => '<p>{{parent_name}}</p>',
+            'is_active' => 1,
         ]);
 
-        $this->assertSame(
-            ['Notice for John Doe', '<p>Date: 2026-03-01</p>'],
-            $rendered
-        );
+        $service = new AttendanceEmailComposerService(new \App\Models\AttendanceEmailTemplate());
+        $context = ['{{student_name}}' => 'Student A', '{{parent_name}}' => 'Parent A'];
+        $rendered = $service->renderTemplate('ABS_1', 'default', $context);
+
+        $this->assertSame('Notice for Student A', $rendered[0]);
+        $this->assertSame('<p>Parent A</p>', $rendered[1]);
     }
 
-    public function test_pick_variant_returns_override_when_present(): void
+    public function test_pick_variant_fallback(): void
     {
-        $model = Mockery::mock(AttendanceEmailTemplate::class);
-        $service = new AttendanceEmailComposerService($model);
-
-        $this->assertSame('custom_variant', $service->pickVariant('ABS_2', 'custom_variant'));
-    }
-
-    public function test_pick_variant_returns_no_answer_for_abs_2(): void
-    {
-        $model = Mockery::mock(AttendanceEmailTemplate::class);
-        $service = new AttendanceEmailComposerService($model);
-
+        $service = new AttendanceEmailComposerService(new \App\Models\AttendanceEmailTemplate());
         $this->assertSame('no_answer', $service->pickVariant('ABS_2'));
-    }
-
-    public function test_pick_variant_returns_default_for_other_codes(): void
-    {
-        $model = Mockery::mock(AttendanceEmailTemplate::class);
-        $service = new AttendanceEmailComposerService($model);
-
         $this->assertSame('default', $service->pickVariant('ABS_1'));
     }
-
-    public function test_normalize_body_to_html_keeps_html_when_tags_present(): void
-    {
-        $model = Mockery::mock(AttendanceEmailTemplate::class);
-        $service = new AttendanceEmailComposerService($model);
-
-        $body = '<p>Hello</p>';
-        $this->assertSame($body, $service->normalizeBodyToHtml($body));
-    }
-
-    public function test_normalize_body_to_html_converts_plain_text_to_br_html(): void
-    {
-        $model = Mockery::mock(AttendanceEmailTemplate::class);
-        $service = new AttendanceEmailComposerService($model);
-
-        $result = $service->normalizeBodyToHtml("Hello\nWorld");
-
-        $this->assertStringContainsString('Hello', $result);
-        $this->assertStringContainsString('<br', $result);
-        $this->assertStringContainsString('World', $result);
-    }
-
-    public function test_build_fallback_auto_email_returns_subject_and_body(): void
-    {
-        $model = Mockery::mock(AttendanceEmailTemplate::class);
-        $service = new AttendanceEmailComposerService($model);
-
-        [$subject, $body] = $service->buildFallbackAutoEmail('ABS_1', [
-            'name' => 'John Doe',
-            'violation' => '1 Unreported Absence',
-            'last_date' => '2026-03-01',
-        ], 'Jane Doe');
-
-        $this->assertSame('Attendance Notice: Unreported Absence', $subject);
-        $this->assertStringContainsString('John Doe', $body);
-        $this->assertStringContainsString('2026-03-01', $body);
-        $this->assertStringContainsString('Jane Doe', $body);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/AttendanceTracking/AttendanceNotificationLogServiceTest.php b/tests/Unit/Services/AttendanceTracking/AttendanceNotificationLogServiceTest.php
index e405bb5c..7efdb6f3 100644
--- a/tests/Unit/Services/AttendanceTracking/AttendanceNotificationLogServiceTest.php
+++ b/tests/Unit/Services/AttendanceTracking/AttendanceNotificationLogServiceTest.php
@@ -2,45 +2,32 @@
 
 namespace Tests\Unit\Services\AttendanceTracking;
 
-use App\Models\ParentNotification;
-use App\Services\AttendanceNotificationLogService;
-use Mockery;
+use App\Services\AttendanceTracking\AttendanceNotificationLogService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
 use Tests\TestCase;
 
 class AttendanceNotificationLogServiceTest extends TestCase
 {
-    protected function tearDown(): void
+    use RefreshDatabase;
+
+    public function test_log_notification_creates_and_updates(): void
     {
-        Mockery::close();
-        parent::tearDown();
+        $service = new AttendanceNotificationLogService(new \App\Models\ParentNotification());
+
+        $service->logNotification(1, 'ABS_1', '2025-01-01', 'email', 'parent@example.com', 'Subject', 'sent');
+        $this->assertDatabaseHas('parent_notifications', [
+            'student_id' => 1,
+            'code' => 'ABS_1',
+            'incident_date' => '2025-01-01',
+            'channel' => 'email',
+            'to_address' => 'parent@example.com',
+            'status' => 'sent',
+        ]);
+
+        $service->logNotification(1, 'ABS_1', '2025-01-01', 'email', 'parent@example.com', 'Updated', 'failed');
+        $row = DB::table('parent_notifications')->where('student_id', 1)->first();
+        $this->assertSame('Updated', $row->subject);
+        $this->assertSame('failed', $row->status);
     }
-
-    public function test_notification_already_sent_returns_true_when_model_has_sent_returns_true(): void
-    {
-        $model = Mockery::mock(ParentNotification::class);
-        $model->shouldReceive('hasSent')
-            ->once()
-            ->with(10, 'ABS_1', '2026-03-01', 'email', 'parent@example.com')
-            ->andReturn(true);
-
-        $service = new AttendanceNotificationLogService($model);
-
-        $this->assertTrue(
-            $service->notificationAlreadySent(10, 'ABS_1', '2026-03-01', 'email', 'parent@example.com')
-        );
-    }
-
-    public function test_notification_already_sent_returns_false_when_model_has_sent_returns_false(): void
-    {
-        $model = Mockery::mock(ParentNotification::class);
-        $model->shouldReceive('hasSent')
-            ->once()
-            ->andReturn(false);
-
-        $service = new AttendanceNotificationLogService($model);
-
-        $this->assertFalse(
-            $service->notificationAlreadySent(10, 'ABS_1', '2026-03-01', 'email', 'parent@example.com')
-        );
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/AttendanceTracking/AttendanceNotificationWorkflowServiceTest.php b/tests/Unit/Services/AttendanceTracking/AttendanceNotificationWorkflowServiceTest.php
index 4e8e6c10..7bfefd21 100644
--- a/tests/Unit/Services/AttendanceTracking/AttendanceNotificationWorkflowServiceTest.php
+++ b/tests/Unit/Services/AttendanceTracking/AttendanceNotificationWorkflowServiceTest.php
@@ -2,114 +2,50 @@
 
 namespace Tests\Unit\Services\AttendanceTracking;
 
-use App\Models\AttendanceData;
-use App\Models\AttendanceTracking;
-use App\Models\Configuration;
-use App\Models\Student;
-use App\Models\StudentClass;
-use App\Services\AttendanceEmailComposerService;
-use App\Services\AttendanceMailerService;
-use App\Services\AttendanceNotificationLogService;
-use App\Services\AttendanceNotificationWorkflowService;
-use App\Services\AttendanceParentLookupService;
-use App\Services\ViolationRuleEngineService;
+use App\Services\AttendanceTracking\AttendanceNotificationWorkflowService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
 use Mockery;
 use Tests\TestCase;
 
 class AttendanceNotificationWorkflowServiceTest extends TestCase
 {
-    protected function tearDown(): void
+    use RefreshDatabase;
+
+    public function test_record_requires_parent_email(): void
     {
-        Mockery::close();
-        parent::tearDown();
-    }
-
-    protected function makeService(
-        ?Student $student = null,
-        ?StudentClass $studentClass = null,
-        ?AttendanceData $attendanceData = null,
-        ?AttendanceTracking $tracking = null,
-        ?Configuration $config = null,
-        ?AttendanceMailerService $mailer = null,
-        ?ViolationRuleEngineService $rules = null,
-        ?AttendanceParentLookupService $parents = null,
-        ?AttendanceEmailComposerService $composer = null,
-        ?AttendanceNotificationLogService $log = null
-    ): AttendanceNotificationWorkflowService {
-        $student ??= Mockery::mock(Student::class);
-        $studentClass ??= Mockery::mock(StudentClass::class);
-        $attendanceData ??= Mockery::mock(AttendanceData::class);
-        $tracking ??= Mockery::mock(AttendanceTracking::class);
-        $config ??= Mockery::mock(Configuration::class);
-        $mailer ??= Mockery::mock(AttendanceMailerService::class);
-        $rules ??= Mockery::mock(ViolationRuleEngineService::class);
-        $parents ??= Mockery::mock(AttendanceParentLookupService::class);
-        $composer ??= Mockery::mock(AttendanceEmailComposerService::class);
-        $log ??= Mockery::mock(AttendanceNotificationLogService::class);
-
-        $config->shouldReceive('getConfig')->with('semester')->andReturn('Fall');
-        $config->shouldReceive('getConfig')->with('school_year')->andReturn('2025-2026');
-
-        return new AttendanceNotificationWorkflowService(
-            $student,
-            $studentClass,
-            $attendanceData,
-            $tracking,
-            $config,
-            $mailer,
-            $rules,
-            $parents,
-            $composer,
-            $log
-        );
-    }
-
-    public function test_send_auto_emails_returns_empty_summary_when_no_auto_email_violations(): void
-    {
-        $service = $this->makeService();
-
-        $result = $service->sendAutoEmails([
-            ['action' => 'team_notify'],
+        DB::table('students')->insert([
+            'id' => 1,
+            'school_id' => 'S1',
+            'firstname' => 'Student',
+            'lastname' => 'One',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
         ]);
 
-        $this->assertTrue($result['success']);
-        $this->assertSame(0, $result['sent']);
-        $this->assertSame(0, $result['skipped']);
-        $this->assertSame(0, $result['errors']);
-    }
-
-    public function test_send_email_manual_returns_failure_when_all_sends_fail(): void
-    {
-        $mailer = Mockery::mock(AttendanceMailerService::class);
-        $mailer->shouldReceive('send')->andReturn(false);
-
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
-        $parents->shouldReceive('getSecondaryParentForStudent')->andReturn(null);
-
-        $composer = Mockery::mock(AttendanceEmailComposerService::class);
-        $composer->shouldReceive('normalizeBodyToHtml')->andReturn('<p>Hello</p>');
-        $composer->shouldReceive('renderWithEmailLayout')->andReturn('<html>Hello</html>');
-
-        $log = Mockery::mock(AttendanceNotificationLogService::class);
-        $log->shouldReceive('logNotification')->atLeast()->once();
-
-        $service = $this->makeService(
-            mailer: $mailer,
-            parents: $parents,
-            composer: $composer,
-            log: $log
+        $service = new AttendanceNotificationWorkflowService(
+            new \App\Models\Student(),
+            new \App\Models\StudentClass(),
+            new \App\Models\AttendanceData(),
+            new \App\Models\AttendanceTracking(),
+            new \App\Models\Configuration(),
+            Mockery::mock(\App\Services\AttendanceTracking\AttendanceMailerService::class),
+            Mockery::mock(\App\Services\AttendanceTracking\ViolationRuleEngineService::class),
+            Mockery::mock(\App\Services\AttendanceTracking\AttendanceParentLookupService::class),
+            Mockery::mock(\App\Services\AttendanceTracking\AttendanceEmailComposerService::class),
+            Mockery::mock(\App\Services\AttendanceTracking\AttendanceNotificationLogService::class)
         );
 
-        $result = $service->sendEmailManual([
-            'student_id' => 10,
-            'to' => 'parent@example.com',
-            'subject' => 'Test',
-            'body_html' => 'Hello',
-            'code' => 'ABS_1',
-            'incident_date' => '2026-03-01',
-        ], ['2026-03-01']);
+        $result = $service->record([
+            'student_id' => 1,
+            'date' => '2025-01-01',
+        ]);
 
         $this->assertFalse($result['success']);
-        $this->assertSame(500, $result['status']);
+        $this->assertSame(422, $result['status']);
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/AttendanceTracking/AttendanceParentLookupServiceTest.php b/tests/Unit/Services/AttendanceTracking/AttendanceParentLookupServiceTest.php
index 4254ba9e..30f585d1 100644
--- a/tests/Unit/Services/AttendanceTracking/AttendanceParentLookupServiceTest.php
+++ b/tests/Unit/Services/AttendanceTracking/AttendanceParentLookupServiceTest.php
@@ -2,7 +2,7 @@
 
 namespace Tests\Unit\Services\AttendanceTracking;
 
-use App\Services\AttendanceParentLookupService;
+use App\Services\AttendanceTracking\AttendanceParentLookupService;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\DB;
 use Tests\TestCase;
@@ -11,86 +11,78 @@ class AttendanceParentLookupServiceTest extends TestCase
 {
     use RefreshDatabase;
 
-    public function test_get_primary_parent_for_student_returns_parent_info(): void
+    public function test_get_primary_parent_for_student(): void
     {
         DB::table('users')->insert([
-            'id' => 100,
-            'firstname' => 'Jane',
-            'lastname' => 'Doe',
-            'email' => 'jane@example.com',
-            'cellphone' => '555-1111',
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'One',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
         ]);
 
         DB::table('students')->insert([
-            'id' => 200,
-            'parent_id' => 100,
+            'id' => 1,
+            'school_id' => 'S1',
+            'firstname' => 'Student',
+            'lastname' => 'One',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
         ]);
 
         $service = new AttendanceParentLookupService();
+        $parent = $service->getPrimaryParentForStudent(1);
 
-        $result = $service->getPrimaryParentForStudent(200);
-
-        $this->assertNotNull($result);
-        $this->assertSame(100, $result['user_id']);
-        $this->assertSame('jane@example.com', $result['email']);
-        $this->assertSame('Jane Doe', $result['parent_name']);
+        $this->assertSame('parent@example.com', $parent['email']);
     }
 
-    public function test_get_secondary_parent_for_student_returns_secondary_user_when_present(): void
+    public function test_get_secondary_parent_falls_back_to_parent_row(): void
     {
-        DB::table('users')->insert([
-            ['id' => 100, 'firstname' => 'Jane', 'lastname' => 'Doe', 'email' => 'jane@example.com', 'cellphone' => '555-1111'],
-            ['id' => 101, 'firstname' => 'John', 'lastname' => 'Doe', 'email' => 'john@example.com', 'cellphone' => '555-2222'],
-        ]);
-
         DB::table('students')->insert([
-            'id' => 200,
-            'parent_id' => 100,
+            'id' => 1,
+            'school_id' => 'S1',
+            'firstname' => 'Student',
+            'lastname' => 'One',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 11,
+            'year_of_registration' => '2025',
             'school_year' => '2025-2026',
         ]);
 
         DB::table('parents')->insert([
-            'firstparent_id' => 100,
-            'secondparent_id' => 101,
+            'secondparent_firstname' => 'Second',
+            'secondparent_lastname' => 'Parent',
+            'secondparent_gender' => 'Female',
+            'secondparent_email' => 'second@example.com',
+            'secondparent_phone' => '5551112222',
+            'firstparent_id' => 11,
+            'secondparent_id' => 0,
+            'semester' => 'Fall',
             'school_year' => '2025-2026',
-            'updated_at' => now(),
         ]);
 
         $service = new AttendanceParentLookupService();
+        $parent = $service->getSecondaryParentForStudent(1, '2025-2026');
 
-        $result = $service->getSecondaryParentForStudent(200, '2025-2026');
-
-        $this->assertNotNull($result);
-        $this->assertSame(101, $result['user_id']);
-        $this->assertSame('john@example.com', $result['email']);
+        $this->assertSame('second@example.com', $parent['email']);
     }
-
-    public function test_parents_info_returns_primary_and_secondary_data(): void
-    {
-        DB::table('users')->insert([
-            ['id' => 100, 'firstname' => 'Jane', 'lastname' => 'Doe', 'email' => 'jane@example.com', 'cellphone' => '555-1111'],
-            ['id' => 101, 'firstname' => 'John', 'lastname' => 'Doe', 'email' => 'john@example.com', 'cellphone' => '555-2222'],
-        ]);
-
-        DB::table('students')->insert([
-            'id' => 200,
-            'parent_id' => 100,
-            'school_year' => '2025-2026',
-        ]);
-
-        DB::table('parents')->insert([
-            'firstparent_id' => 100,
-            'secondparent_id' => 101,
-            'school_year' => '2025-2026',
-            'updated_at' => now(),
-        ]);
-
-        $service = new AttendanceParentLookupService();
-
-        $result = $service->parentsInfo(200, '2025-2026');
-
-        $this->assertTrue($result['success']);
-        $this->assertSame('jane@example.com', $result['data']['primary']['email']);
-        $this->assertSame('john@example.com', $result['data']['secondary']['email']);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/AttendanceTracking/AttendancePendingViolationServiceTest.php b/tests/Unit/Services/AttendanceTracking/AttendancePendingViolationServiceTest.php
index aae260c1..48cab1a1 100644
--- a/tests/Unit/Services/AttendanceTracking/AttendancePendingViolationServiceTest.php
+++ b/tests/Unit/Services/AttendanceTracking/AttendancePendingViolationServiceTest.php
@@ -2,49 +2,39 @@
 
 namespace Tests\Unit\Services\AttendanceTracking;
 
-use App\Models\AttendanceData;
-use App\Services\AttendancePendingViolationService;
-use App\Services\AttendanceViolationStudentResolverService;
-use App\Services\ViolationRuleEngineService;
+use App\Services\AttendanceTracking\AttendancePendingViolationService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
 use Mockery;
 use Tests\TestCase;
 
 class AttendancePendingViolationServiceTest extends TestCase
 {
-    protected function tearDown(): void
+    use RefreshDatabase;
+
+    public function test_returns_error_when_no_students(): void
     {
-        Mockery::close();
-        parent::tearDown();
-    }
+        $resolver = Mockery::mock(\App\Services\AttendanceTracking\AttendanceViolationStudentResolverService::class);
+        $resolver->shouldReceive('resolveForSchoolYear')->andReturn([
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'student_ids' => [],
+            'student_codes' => [],
+            'students' => [],
+            'student_code_to_id' => [],
+            'existing_ids' => [],
+            'debug' => [],
+        ]);
 
-    public function test_get_pending_violations_returns_error_when_no_student_identifiers_found(): void
-    {
-        $attendanceData = Mockery::mock(AttendanceData::class);
-        $rules = Mockery::mock(ViolationRuleEngineService::class);
-        $resolver = Mockery::mock(AttendanceViolationStudentResolverService::class);
+        $engine = Mockery::mock(\App\Services\AttendanceTracking\ViolationRuleEngineService::class);
 
-        $resolver->shouldReceive('resolveForSchoolYear')
-            ->once()
-            ->with('2025-2026', null)
-            ->andReturn([
-                'school_year' => '2025-2026',
-                'semester' => null,
-                'student_ids' => [],
-                'student_codes' => [],
-                'students' => [],
-                'student_code_to_id' => [],
-                'existing_ids' => [],
-                'debug' => [
-                    'class_students' => 0,
-                    'student_ids' => 0,
-                ],
-            ]);
+        $service = new AttendancePendingViolationService(
+            new \App\Models\AttendanceData(),
+            $engine,
+            $resolver
+        );
 
-        $service = new AttendancePendingViolationService($attendanceData, $rules, $resolver);
+        $result = $service->getPendingViolations('2025-2026', null, null);
 
-        $result = $service->getPendingViolations('2025-2026');
-
-        $this->assertSame([], $result['students']);
         $this->assertSame('No student identifiers found for the current school year.', $result['error']);
     }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/AttendanceTracking/AttendanceTrackingServiceTest.php b/tests/Unit/Services/AttendanceTracking/AttendanceTrackingServiceTest.php
index 8b9c7af8..6341d5ec 100644
--- a/tests/Unit/Services/AttendanceTracking/AttendanceTrackingServiceTest.php
+++ b/tests/Unit/Services/AttendanceTracking/AttendanceTrackingServiceTest.php
@@ -2,134 +2,17 @@
 
 namespace Tests\Unit\Services\AttendanceTracking;
 
-use App\Models\AttendanceData;
-use App\Models\AttendanceTracking;
-use App\Models\Configuration;
-use App\Models\Student;
-use App\Models\StudentClass;
-use App\Services\AttendanceCaseQueryService;
-use App\Services\AttendanceCommunicationSupportService;
-use App\Services\AttendanceEmailComposerService;
-use App\Services\AttendanceMailerService;
-use App\Services\AttendanceNotificationLogService;
-use App\Services\AttendanceNotificationWorkflowService;
-use App\Services\AttendanceParentLookupService;
-use App\Services\AttendancePendingViolationService;
-use App\Services\AttendanceTrackingService;
-use App\Services\AttendanceViolationStudentResolverService;
-use App\Services\ViolationRuleEngineService;
-use Mockery;
+use App\Services\AttendanceTracking\AttendanceTrackingService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
 use Tests\TestCase;
 
 class AttendanceTrackingServiceTest extends TestCase
 {
-    protected function tearDown(): void
+    use RefreshDatabase;
+
+    public function test_service_instantiates(): void
     {
-        Mockery::close();
-        parent::tearDown();
+        $service = new AttendanceTrackingService();
+        $this->assertInstanceOf(AttendanceTrackingService::class, $service);
     }
-
-    protected function makeService(
-        ?AttendancePendingViolationService $pending = null,
-        ?AttendanceCaseQueryService $caseQuery = null,
-        ?AttendanceNotificationWorkflowService $workflow = null,
-        ?AttendanceCommunicationSupportService $support = null
-    ): AttendanceTrackingService {
-        $student = Mockery::mock(Student::class);
-        $studentClass = Mockery::mock(StudentClass::class);
-        $attendanceData = Mockery::mock(AttendanceData::class);
-        $tracking = Mockery::mock(AttendanceTracking::class);
-        $config = Mockery::mock(Configuration::class);
-        $mailer = Mockery::mock(AttendanceMailerService::class);
-        $rules = Mockery::mock(ViolationRuleEngineService::class);
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
-        $composer = Mockery::mock(AttendanceEmailComposerService::class);
-        $log = Mockery::mock(AttendanceNotificationLogService::class);
-        $resolver = Mockery::mock(AttendanceViolationStudentResolverService::class);
-
-        $pending ??= Mockery::mock(AttendancePendingViolationService::class);
-        $caseQuery ??= Mockery::mock(AttendanceCaseQueryService::class);
-        $workflow ??= Mockery::mock(AttendanceNotificationWorkflowService::class);
-        $support ??= Mockery::mock(AttendanceCommunicationSupportService::class);
-
-        $config->shouldReceive('getConfig')->with('semester')->andReturn('Fall');
-        $config->shouldReceive('getConfig')->with('school_year')->andReturn('2025-2026');
-
-        return new AttendanceTrackingService(
-            $student,
-            $studentClass,
-            $attendanceData,
-            $tracking,
-            $config,
-            $mailer,
-            $rules,
-            $parents,
-            $composer,
-            $log,
-            $resolver,
-            $caseQuery,
-            $workflow,
-            $support,
-            $pending
-        );
-    }
-
-    public function test_get_pending_violations_delegates_to_pending_service(): void
-    {
-        $pending = Mockery::mock(AttendancePendingViolationService::class);
-        $pending->shouldReceive('getPendingViolations')
-            ->once()
-            ->with('2025-2026', null, null)
-            ->andReturn(['students' => []]);
-
-        $service = $this->makeService(pending: $pending);
-
-        $result = $service->getPendingViolations();
-
-        $this->assertSame(['students' => []], $result);
-    }
-
-    public function test_get_student_case_delegates_to_case_query_service(): void
-    {
-        $caseQuery = Mockery::mock(AttendanceCaseQueryService::class);
-        $caseQuery->shouldReceive('getStudentCase')
-            ->once()
-            ->andReturn(['success' => true]);
-
-        $service = $this->makeService(caseQuery: $caseQuery);
-
-        $result = $service->getStudentCase(1);
-
-        $this->assertTrue($result['success']);
-    }
-
-    public function test_record_delegates_to_workflow_service(): void
-    {
-        $workflow = Mockery::mock(AttendanceNotificationWorkflowService::class);
-        $workflow->shouldReceive('record')
-            ->once()
-            ->with(['student_id' => 10])
-            ->andReturn(['success' => true]);
-
-        $service = $this->makeService(workflow: $workflow);
-
-        $result = $service->record(['student_id' => 10]);
-
-        $this->assertTrue($result['success']);
-    }
-
-    public function test_compose_delegates_to_support_service(): void
-    {
-        $support = Mockery::mock(AttendanceCommunicationSupportService::class);
-        $support->shouldReceive('compose')
-            ->once()
-            ->with(10, 'ABS_1', 'default', null)
-            ->andReturn(['success' => true]);
-
-        $service = $this->makeService(support: $support);
-
-        $result = $service->compose(10);
-
-        $this->assertTrue($result['success']);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/AttendanceTracking/AttendanceViolationStudentResolverServiceTest.php b/tests/Unit/Services/AttendanceTracking/AttendanceViolationStudentResolverServiceTest.php
index ec709b9c..5a8bd45b 100644
--- a/tests/Unit/Services/AttendanceTracking/AttendanceViolationStudentResolverServiceTest.php
+++ b/tests/Unit/Services/AttendanceTracking/AttendanceViolationStudentResolverServiceTest.php
@@ -2,67 +2,46 @@
 
 namespace Tests\Unit\Services\AttendanceTracking;
 
-use App\Models\AttendanceData;
-use App\Models\Student;
-use App\Models\StudentClass;
-use App\Services\AttendanceViolationStudentResolverService;
-use Mockery;
+use App\Services\AttendanceTracking\AttendanceViolationStudentResolverService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
 use Tests\TestCase;
 
 class AttendanceViolationStudentResolverServiceTest extends TestCase
 {
-    protected function tearDown(): void
+    use RefreshDatabase;
+
+    public function test_resolve_for_school_year_returns_students(): void
     {
-        Mockery::close();
-        parent::tearDown();
-    }
+        DB::table('students')->insert([
+            'id' => 1,
+            'school_id' => 'S1',
+            'firstname' => 'Student',
+            'lastname' => 'One',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
+        ]);
 
-    public function test_ensure_attendance_student_exists_keeps_numeric_student(): void
-    {
-        $student = Mockery::mock(Student::class);
-        $studentClass = Mockery::mock(StudentClass::class);
-        $attendanceData = Mockery::mock(AttendanceData::class);
+        DB::table('student_class')->insert([
+            'student_id' => 1,
+            'class_section_id' => 10,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
 
-        $service = new AttendanceViolationStudentResolverService($student, $studentClass, $attendanceData);
-
-        $students = [];
-        $studentCodeToId = [];
-        $existingIds = [];
-
-        $sid = $service->ensureAttendanceStudentExists(
-            $students,
-            $studentCodeToId,
-            $existingIds,
-            123
+        $service = new AttendanceViolationStudentResolverService(
+            new \App\Models\Student(),
+            new \App\Models\StudentClass(),
+            new \App\Models\AttendanceData()
         );
 
-        $this->assertSame(123, $sid);
-        $this->assertCount(1, $students);
-        $this->assertSame(123, $students[0]['id']);
+        $result = $service->resolveForSchoolYear('2025-2026', 'Fall');
+
+        $this->assertContains(1, $result['student_ids']);
+        $this->assertNotEmpty($result['students']);
     }
-
-    public function test_ensure_attendance_student_exists_creates_placeholder_for_code(): void
-    {
-        $student = Mockery::mock(Student::class);
-        $studentClass = Mockery::mock(StudentClass::class);
-        $attendanceData = Mockery::mock(AttendanceData::class);
-
-        $service = new AttendanceViolationStudentResolverService($student, $studentClass, $attendanceData);
-
-        $students = [];
-        $studentCodeToId = [];
-        $existingIds = [];
-
-        $sid = $service->ensureAttendanceStudentExists(
-            $students,
-            $studentCodeToId,
-            $existingIds,
-            'SCH-001'
-        );
-
-        $this->assertNotNull($sid);
-        $this->assertCount(1, $students);
-        $this->assertSame('SCH-001', $students[0]['school_id']);
-        $this->assertArrayHasKey('SCH-001', $studentCodeToId);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/AttendanceTracking/ViolationRuleEngineServiceTest.php b/tests/Unit/Services/AttendanceTracking/ViolationRuleEngineServiceTest.php
index 50250fa4..74387c4c 100644
--- a/tests/Unit/Services/AttendanceTracking/ViolationRuleEngineServiceTest.php
+++ b/tests/Unit/Services/AttendanceTracking/ViolationRuleEngineServiceTest.php
@@ -2,111 +2,37 @@
 
 namespace Tests\Unit\Services\AttendanceTracking;
 
-use App\Models\AttendanceTracking;
-use App\Services\AttendanceParentLookupService;
-use App\Services\ViolationRuleEngineService;
+use App\Services\AttendanceTracking\ViolationRuleEngineService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
 use Mockery;
 use Tests\TestCase;
 
 class ViolationRuleEngineServiceTest extends TestCase
 {
-    protected function tearDown(): void
+    use RefreshDatabase;
+
+    public function test_school_year_helpers(): void
     {
-        Mockery::close();
-        parent::tearDown();
+        $service = $this->makeService();
+
+        $this->assertSame(['2025-08-01', '2026-07-31'], $service->deriveSchoolYearBounds('2025-2026'));
+        $this->assertSame('2025-2026', $service->schoolYearForDate('2025-09-01'));
     }
 
-    public function test_choose_higher_severity_returns_higher_severity_rule(): void
+    public function test_window_weeks_for_violation_code(): void
     {
-        $tracking = Mockery::mock(AttendanceTracking::class);
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
-
-        $service = new ViolationRuleEngineService($tracking, $parents);
-
-        $result = $service->chooseHigherSeverity(
-            ['severity' => 2, 'action' => 'team_notify'],
-            ['severity' => 4, 'action' => 'auto_email']
-        );
-
-        $this->assertSame(4, $result['severity']);
-    }
-
-    public function test_choose_higher_severity_breaks_ties_by_action_priority(): void
-    {
-        $tracking = Mockery::mock(AttendanceTracking::class);
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
-
-        $service = new ViolationRuleEngineService($tracking, $parents);
-
-        $result = $service->chooseHigherSeverity(
-            ['severity' => 3, 'action' => 'team_notify'],
-            ['severity' => 3, 'action' => 'auto_email']
-        );
-
-        $this->assertSame('team_notify', $result['action']);
-    }
-
-    public function test_window_weeks_for_violation_code_returns_expected_values(): void
-    {
-        $tracking = Mockery::mock(AttendanceTracking::class);
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
-
-        $service = new ViolationRuleEngineService($tracking, $parents);
+        $service = $this->makeService();
 
         $this->assertSame(3, $service->windowWeeksForViolationCode('ABS_2'));
-        $this->assertSame(4, $service->windowWeeksForViolationCode('ABS_3'));
+        $this->assertSame(4, $service->windowWeeksForViolationCode('MIX'));
         $this->assertSame(5, $service->windowWeeksForViolationCode('ABS_4'));
-        $this->assertSame(4, $service->windowWeeksForViolationCode('LATE_4'));
     }
 
-    public function test_has_n_consecutive_items_detects_weekly_sequence(): void
+    private function makeService(): ViolationRuleEngineService
     {
-        $tracking = Mockery::mock(AttendanceTracking::class);
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
+        $tracking = new \App\Models\AttendanceTracking();
+        $parentLookup = Mockery::mock(\App\Services\AttendanceTracking\AttendanceParentLookupService::class);
 
-        $service = new ViolationRuleEngineService($tracking, $parents);
-
-        $result = $service->hasNConsecutiveItems(
-            ['2026-03-15', '2026-03-08', '2026-03-01'],
-            3,
-            7
-        );
-
-        $this->assertTrue($result);
+        return new ViolationRuleEngineService($tracking, $parentLookup);
     }
-
-    public function test_has_n_in_w_active_weeks_detects_window_match(): void
-    {
-        $tracking = Mockery::mock(AttendanceTracking::class);
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
-
-        $service = new ViolationRuleEngineService($tracking, $parents);
-
-        $this->assertTrue($service->hasNInWActiveWeeks([0, 1], 2, 3));
-        $this->assertFalse($service->hasNInWActiveWeeks([0], 2, 3));
-    }
-
-    public function test_two_lates_one_abs_in_w_weeks_detects_mix_rule(): void
-    {
-        $tracking = Mockery::mock(AttendanceTracking::class);
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
-
-        $service = new ViolationRuleEngineService($tracking, $parents);
-
-        $this->assertTrue($service->twoLatesOneAbsInWWeeks([1, 2], [3], 4));
-        $this->assertFalse($service->twoLatesOneAbsInWWeeks([1], [3], 4));
-    }
-
-    public function test_derive_school_year_bounds_returns_expected_dates(): void
-    {
-        $tracking = Mockery::mock(AttendanceTracking::class);
-        $parents = Mockery::mock(AttendanceParentLookupService::class);
-
-        $service = new ViolationRuleEngineService($tracking, $parents);
-
-        [$start, $end] = $service->deriveSchoolYearBounds('2025-2026');
-
-        $this->assertSame('2025-08-01', $start);
-        $this->assertSame('2026-07-31', $end);
-    }
-}
\ No newline at end of file
+}
diff --git a/tests/Unit/Services/Auth/RegistrationCaptchaServiceTest.php b/tests/Unit/Services/Auth/RegistrationCaptchaServiceTest.php
new file mode 100644
index 00000000..7580bc4e
--- /dev/null
+++ b/tests/Unit/Services/Auth/RegistrationCaptchaServiceTest.php
@@ -0,0 +1,33 @@
+<?php
+
+namespace Tests\Unit\Services\Auth;
+
+use App\Services\Auth\RegistrationCaptchaService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class RegistrationCaptchaServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_generate_sets_session_value(): void
+    {
+        $service = new RegistrationCaptchaService();
+        $value = $service->generate(6);
+
+        $this->assertNotEmpty($value);
+        $this->assertSame($value, session()->get('captcha_answer'));
+    }
+
+    public function test_verify_and_clear(): void
+    {
+        $service = new RegistrationCaptchaService();
+        session()->put('captcha_answer', 'ABC123');
+
+        $this->assertTrue($service->verify('ABC123'));
+        $this->assertFalse($service->verify('WRONG'));
+
+        $service->clear();
+        $this->assertNull(session()->get('captcha_answer'));
+    }
+}
diff --git a/tests/Unit/Services/Auth/RegistrationFormatterServiceTest.php b/tests/Unit/Services/Auth/RegistrationFormatterServiceTest.php
new file mode 100644
index 00000000..b26561c8
--- /dev/null
+++ b/tests/Unit/Services/Auth/RegistrationFormatterServiceTest.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace Tests\Unit\Services\Auth;
+
+use App\Services\Auth\RegistrationFormatterService;
+use App\Services\PhoneFormatterService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class RegistrationFormatterServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_format_normalizes_parent_fields(): void
+    {
+        $formatter = new RegistrationFormatterService(new PhoneFormatterService());
+
+        $result = $formatter->format([
+            'firstname' => 'john',
+            'lastname' => 'doe',
+            'email' => 'USER@EXAMPLE.COM',
+            'gender' => 'Male',
+            'city' => 'new haven',
+            'cellphone' => '(203) 555-1234',
+            'address_street' => '123 main st',
+            'apt' => 'a1',
+            'state' => 'ct',
+            'zip' => '06510',
+            'accept_school_policy' => 1,
+            'no_second_parent_info' => 1,
+        ]);
+
+        $this->assertSame('John', $result['firstname']);
+        $this->assertSame('Doe', $result['lastname']);
+        $this->assertSame('user@example.com', $result['email']);
+        $this->assertSame('New Haven', $result['city']);
+        $this->assertSame('203-555-1234', $result['cellphone']);
+        $this->assertSame('CT', $result['state']);
+        $this->assertArrayNotHasKey('second_firstname', $result);
+    }
+
+    public function test_format_includes_second_parent_when_present(): void
+    {
+        $formatter = new RegistrationFormatterService(new PhoneFormatterService());
+
+        $result = $formatter->format([
+            'firstname' => 'john',
+            'lastname' => 'doe',
+            'email' => 'user@example.com',
+            'gender' => 'Male',
+            'city' => 'new haven',
+            'cellphone' => '2035551234',
+            'address_street' => '123 main st',
+            'apt' => 'a1',
+            'state' => 'ct',
+            'zip' => '06510',
+            'accept_school_policy' => 1,
+            'second_firstname' => 'jane',
+            'second_lastname' => 'doe',
+            'second_gender' => 'Female',
+            'second_email' => 'jane@example.com',
+            'second_cellphone' => '2035559876',
+        ]);
+
+        $this->assertSame('Jane', $result['second_firstname']);
+        $this->assertSame('Doe', $result['second_lastname']);
+        $this->assertSame('jane@example.com', $result['second_email']);
+        $this->assertSame('203-555-9876', $result['second_cellphone']);
+    }
+}
diff --git a/tests/Unit/Services/Auth/RegistrationServiceTest.php b/tests/Unit/Services/Auth/RegistrationServiceTest.php
new file mode 100644
index 00000000..798ac59e
--- /dev/null
+++ b/tests/Unit/Services/Auth/RegistrationServiceTest.php
@@ -0,0 +1,150 @@
+<?php
+
+namespace Tests\Unit\Services\Auth;
+
+use App\Models\Role;
+use App\Models\User;
+use App\Services\Auth\RegistrationCaptchaService;
+use App\Services\Auth\RegistrationFormatterService;
+use App\Services\Auth\RegistrationService;
+use App\Services\EmailService;
+use App\Services\PhoneFormatterService;
+use App\Services\SchoolIdService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Mockery;
+use Tests\TestCase;
+
+class RegistrationServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_register_creates_parent_user(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 2001, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2002, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        Role::query()->create([
+            'id' => 1,
+            'name' => 'parent',
+            'slug' => 'parent',
+            'description' => 'Parent',
+            'priority' => 1,
+            'is_active' => 1,
+        ]);
+
+        session()->put('captcha_answer', 'ABCD');
+
+        $emailService = Mockery::mock(EmailService::class);
+        $emailService->shouldReceive('send')->once()->andReturn(true);
+
+        $service = new RegistrationService(
+            $emailService,
+            new SchoolIdService(),
+            new RegistrationFormatterService(new PhoneFormatterService()),
+            new RegistrationCaptchaService()
+        );
+
+        $result = $service->register([
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'gender' => 'Male',
+            'email' => 'parent@example.com',
+            'confirm_email' => 'parent@example.com',
+            'cellphone' => '5555555555',
+            'address_street' => '123 Main',
+            'apt' => 'A',
+            'city' => 'City',
+            'state' => 'CT',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'captcha' => 'ABCD',
+            'is_parent' => 1,
+            'no_second_parent_info' => 1,
+        ]);
+
+        $this->assertTrue($result['ok']);
+        $this->assertDatabaseHas('users', [
+            'email' => 'parent@example.com',
+            'status' => 'Inactive',
+        ]);
+        $this->assertDatabaseHas('user_roles', [
+            'user_id' => $result['user']->id,
+            'role_id' => 1,
+        ]);
+    }
+
+    public function test_register_rejects_pending_activation(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 2001, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2002, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        Role::query()->create([
+            'id' => 1,
+            'name' => 'parent',
+            'slug' => 'parent',
+            'description' => 'Parent',
+            'priority' => 1,
+            'is_active' => 1,
+        ]);
+
+        User::query()->create([
+            'school_id' => '2500001',
+            'firstname' => 'Existing',
+            'lastname' => 'User',
+            'gender' => 'Male',
+            'cellphone' => '555-555-5555',
+            'email' => 'existing@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'CT',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 0,
+            'status' => 'Inactive',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => pbkdf2_hash('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'token' => 'token',
+        ]);
+
+        session()->put('captcha_answer', 'ABCD');
+
+        $emailService = Mockery::mock(EmailService::class);
+        $emailService->shouldNotReceive('send');
+
+        $service = new RegistrationService(
+            $emailService,
+            new SchoolIdService(),
+            new RegistrationFormatterService(new PhoneFormatterService()),
+            new RegistrationCaptchaService()
+        );
+
+        $result = $service->register([
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'gender' => 'Male',
+            'email' => 'existing@example.com',
+            'confirm_email' => 'existing@example.com',
+            'cellphone' => '5555555555',
+            'address_street' => '123 Main',
+            'apt' => 'A',
+            'city' => 'City',
+            'state' => 'CT',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'captcha' => 'ABCD',
+            'is_parent' => 1,
+            'no_second_parent_info' => 1,
+        ]);
+
+        $this->assertFalse($result['ok']);
+        $this->assertSame('pending_activation', $result['code']);
+    }
+}
diff --git a/tests/Unit/Services/BroadcastEmail/BroadcastEmailComposerServiceTest.php b/tests/Unit/Services/BroadcastEmail/BroadcastEmailComposerServiceTest.php
new file mode 100644
index 00000000..6566ef87
--- /dev/null
+++ b/tests/Unit/Services/BroadcastEmail/BroadcastEmailComposerServiceTest.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Tests\Unit\Services\BroadcastEmail;
+
+use App\Services\BroadcastEmail\BroadcastEmailComposerService;
+use Tests\TestCase;
+
+class BroadcastEmailComposerServiceTest extends TestCase
+{
+    public function test_sanitize_removes_script_and_events(): void
+    {
+        $service = new BroadcastEmailComposerService();
+        $html = '<p onclick="alert(1)">Hi</p><script>alert(2)</script>';
+
+        $clean = $service->sanitizeHtml($html);
+
+        $this->assertStringNotContainsString('script', $clean);
+        $this->assertStringNotContainsString('onclick', $clean);
+    }
+
+    public function test_compose_replaces_name_when_personalized(): void
+    {
+        $service = new BroadcastEmailComposerService();
+        $html = '<p>Hello {{name}}</p>';
+
+        $rendered = $service->compose(false, 'Subject', $html, 'Parent', '', '', '', true);
+
+        $this->assertSame('<p>Hello Parent</p>', $rendered);
+    }
+}
diff --git a/tests/Unit/Services/BroadcastEmail/BroadcastEmailRecipientServiceTest.php b/tests/Unit/Services/BroadcastEmail/BroadcastEmailRecipientServiceTest.php
new file mode 100644
index 00000000..2465c4db
--- /dev/null
+++ b/tests/Unit/Services/BroadcastEmail/BroadcastEmailRecipientServiceTest.php
@@ -0,0 +1,93 @@
+<?php
+
+namespace Tests\Unit\Services\BroadcastEmail;
+
+use App\Services\BroadcastEmail\BroadcastEmailRecipientService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class BroadcastEmailRecipientServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_parents_with_emails_filters_missing_email(): void
+    {
+        $this->seedParentData();
+
+        $service = new BroadcastEmailRecipientService();
+        $parents = $service->parentsWithEmails();
+
+        $this->assertCount(1, $parents);
+        $this->assertSame('parent@example.com', $parents[0]['email']);
+    }
+
+    public function test_recipients_by_ids_returns_names(): void
+    {
+        $this->seedParentData();
+
+        $service = new BroadcastEmailRecipientService();
+        $recipients = $service->recipientsByIds([10]);
+
+        $this->assertCount(1, $recipients);
+        $this->assertSame('Parent User', $recipients[0]['name']);
+    }
+
+    private function seedParentData(): void
+    {
+        DB::table('roles')->insert([
+            'id' => 1,
+            'name' => 'parent',
+            'slug' => 'parent',
+            'is_active' => 1,
+        ]);
+
+        DB::table('users')->insert([
+            [
+                'id' => 10,
+                'school_id' => 1,
+                'firstname' => 'Parent',
+                'lastname' => 'User',
+                'cellphone' => '5555555555',
+                'email' => 'parent@example.com',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 11,
+                'school_id' => 1,
+                'firstname' => 'No',
+                'lastname' => 'Email',
+                'cellphone' => '5555555555',
+                'email' => '',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('user_roles')->insert([
+            ['user_id' => 10, 'role_id' => 1],
+            ['user_id' => 11, 'role_id' => 1],
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/BroadcastEmail/BroadcastEmailSenderOptionsServiceTest.php b/tests/Unit/Services/BroadcastEmail/BroadcastEmailSenderOptionsServiceTest.php
new file mode 100644
index 00000000..7627c1ea
--- /dev/null
+++ b/tests/Unit/Services/BroadcastEmail/BroadcastEmailSenderOptionsServiceTest.php
@@ -0,0 +1,23 @@
+<?php
+
+namespace Tests\Unit\Services\BroadcastEmail;
+
+use App\Services\BroadcastEmail\BroadcastEmailSenderOptionsService;
+use Tests\TestCase;
+
+class BroadcastEmailSenderOptionsServiceTest extends TestCase
+{
+    public function test_list_options_from_env(): void
+    {
+        $old = getenv('MAIL_SENDERS') ?: '';
+        putenv('MAIL_SENDERS={"general":{"name":"Office","email":"office@example.com"}}');
+
+        $service = new BroadcastEmailSenderOptionsService();
+        $options = $service->listOptions();
+
+        $this->assertSame('general', $options[0]['key']);
+        $this->assertSame('Office <office@example.com>', $options[0]['label']);
+
+        putenv('MAIL_SENDERS=' . $old);
+    }
+}
diff --git a/tests/Unit/Services/ClassPrep/ClassRosterServiceTest.php b/tests/Unit/Services/ClassPrep/ClassRosterServiceTest.php
new file mode 100644
index 00000000..fea21717
--- /dev/null
+++ b/tests/Unit/Services/ClassPrep/ClassRosterServiceTest.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace Tests\Unit\Services\ClassPrep;
+
+use App\Services\ClassPrep\ClassRosterService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ClassRosterServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_students_by_class(): void
+    {
+        $this->seedRosterData();
+
+        $service = new ClassRosterService();
+        $students = $service->listStudentsByClass(101, '2025-2026');
+
+        $this->assertCount(1, $students);
+        $this->assertSame('1-A', $students[0]['registration_grade']);
+    }
+
+    private function seedRosterData(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+        ]);
+
+        DB::table('classes')->insert([
+            'id' => 1,
+            'class_name' => 'Class 1',
+            'schedule' => 'Sun',
+            'capacity' => 20,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 1,
+            'class_section_id' => 101,
+            'class_section_name' => '1-A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'school_id' => 'S-1',
+            'firstname' => 'Student',
+            'lastname' => 'One',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'is_active' => 1,
+            'is_new' => 0,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 1,
+            'class_section_id' => 101,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/ClassPrep/StickerCountServiceTest.php b/tests/Unit/Services/ClassPrep/StickerCountServiceTest.php
new file mode 100644
index 00000000..e68a646a
--- /dev/null
+++ b/tests/Unit/Services/ClassPrep/StickerCountServiceTest.php
@@ -0,0 +1,165 @@
+<?php
+
+namespace Tests\Unit\Services\ClassPrep;
+
+use App\Services\ClassPrep\StickerCountService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class StickerCountServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_all_returns_totals_excluding_youth(): void
+    {
+        $this->seedStickerData();
+
+        $service = new StickerCountService();
+        $payload = $service->listAll('2025-2026', 'Fall');
+
+        $this->assertSame(2, $payload['totals']['students']);
+        $this->assertSame(6, $payload['totals']['primary']);
+        $this->assertSame(1, $payload['totals']['secondary']);
+    }
+
+    public function test_list_for_class_limits_results(): void
+    {
+        $this->seedStickerData();
+
+        $service = new StickerCountService();
+        $payload = $service->listForClass('2025-2026', 'Fall', 101);
+
+        $this->assertSame(1, $payload['totals']['students']);
+        $this->assertSame(3, $payload['totals']['primary']);
+        $this->assertSame(0, $payload['totals']['secondary']);
+    }
+
+    private function seedStickerData(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('classes')->insert([
+            [
+                'id' => 1,
+                'class_name' => 'Class 1',
+                'schedule' => 'Sun',
+                'capacity' => 20,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 2,
+                'class_name' => 'Class 2',
+                'schedule' => 'Sun',
+                'capacity' => 20,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 3,
+                'class_name' => 'Class 3',
+                'schedule' => 'Sun',
+                'capacity' => 20,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('classSection')->insert([
+            [
+                'id' => 1,
+                'class_id' => 1,
+                'class_section_id' => 101,
+                'class_section_name' => '1-A',
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 2,
+                'class_id' => 2,
+                'class_section_id' => 102,
+                'class_section_name' => '5-B',
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 3,
+                'class_id' => 3,
+                'class_section_id' => 103,
+                'class_section_name' => 'Youth-1',
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('students')->insert([
+            [
+                'school_id' => 'S-1',
+                'firstname' => 'Student',
+                'lastname' => 'One',
+                'age' => 8,
+                'gender' => 'Male',
+                'photo_consent' => 1,
+                'parent_id' => 1,
+                'year_of_registration' => '2025',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'is_active' => 1,
+                'is_new' => 0,
+            ],
+            [
+                'school_id' => 'S-2',
+                'firstname' => 'Student',
+                'lastname' => 'Two',
+                'age' => 10,
+                'gender' => 'Female',
+                'photo_consent' => 1,
+                'parent_id' => 1,
+                'year_of_registration' => '2025',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'is_active' => 1,
+                'is_new' => 0,
+            ],
+            [
+                'school_id' => 'S-3',
+                'firstname' => 'Student',
+                'lastname' => 'Three',
+                'age' => 12,
+                'gender' => 'Female',
+                'photo_consent' => 1,
+                'parent_id' => 1,
+                'year_of_registration' => '2025',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'is_active' => 1,
+                'is_new' => 1,
+            ],
+        ]);
+
+        DB::table('student_class')->insert([
+            [
+                'student_id' => 1,
+                'class_section_id' => 101,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'student_id' => 2,
+                'class_section_id' => 102,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'student_id' => 3,
+                'class_section_id' => 103,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/ClassPreparation/ClassPreparationAdjustmentServiceTest.php b/tests/Unit/Services/ClassPreparation/ClassPreparationAdjustmentServiceTest.php
new file mode 100644
index 00000000..8cc02f54
--- /dev/null
+++ b/tests/Unit/Services/ClassPreparation/ClassPreparationAdjustmentServiceTest.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Tests\Unit\Services\ClassPreparation;
+
+use App\Services\ClassPreparation\ClassPreparationAdjustmentService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ClassPreparationAdjustmentServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_apply_adjustments_updates_counts(): void
+    {
+        DB::table('class_prep_adjustments')->insert([
+            'class_section_id' => 101,
+            'item_name' => 'Small Table',
+            'adjustment' => 2,
+            'school_year' => '2025-2026',
+            'adjustable' => 1,
+        ]);
+
+        $service = new ClassPreparationAdjustmentService();
+        [$items, $adjMap] = $service->applyAdjustments(['Small Table' => 1], '101', '2025-2026');
+
+        $this->assertSame(3, $items['Small Table']);
+        $this->assertSame(2, $adjMap['Small Table']);
+    }
+}
diff --git a/tests/Unit/Services/ClassPreparation/ClassPreparationCalculatorServiceTest.php b/tests/Unit/Services/ClassPreparation/ClassPreparationCalculatorServiceTest.php
new file mode 100644
index 00000000..c3096037
--- /dev/null
+++ b/tests/Unit/Services/ClassPreparation/ClassPreparationCalculatorServiceTest.php
@@ -0,0 +1,59 @@
+<?php
+
+namespace Tests\Unit\Services\ClassPreparation;
+
+use App\Services\ClassPreparation\ClassPreparationCalculatorService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ClassPreparationCalculatorServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_class_level_by_section(): void
+    {
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 1,
+            'class_section_id' => 101,
+            'class_section_name' => '2-A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new ClassPreparationCalculatorService();
+
+        $this->assertSame(2, $service->getClassLevelBySection('101'));
+        $this->assertSame(1, $service->getClassLevelBySection('KG'));
+    }
+
+    public function test_calculate_prep_items_for_lower_grades(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+        ]);
+
+        DB::table('inventory_categories')->insert([
+            ['name' => 'Small Table', 'grade_min' => null, 'grade_max' => null, 'type' => 'classroom'],
+            ['name' => 'Small Chair', 'grade_min' => null, 'grade_max' => null, 'type' => 'classroom'],
+            ['name' => 'Teacher Chair', 'grade_min' => null, 'grade_max' => null, 'type' => 'classroom'],
+            ['name' => 'Grade Box', 'grade_min' => null, 'grade_max' => null, 'type' => 'classroom'],
+        ]);
+
+        DB::table('teacher_class')->insert([
+            'class_section_id' => 101,
+            'teacher_id' => 1,
+            'position' => 'main',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new ClassPreparationCalculatorService();
+        $items = $service->calculatePrepItems(6, 1, '101');
+
+        $this->assertSame(2, $items['Small Table']);
+        $this->assertSame(6, $items['Small Chair']);
+        $this->assertSame(1, $items['Teacher Chair']);
+        $this->assertSame(1, $items['Grade Box']);
+    }
+}
diff --git a/tests/Unit/Services/ClassPreparation/ClassPreparationContextServiceTest.php b/tests/Unit/Services/ClassPreparation/ClassPreparationContextServiceTest.php
new file mode 100644
index 00000000..6da0be6f
--- /dev/null
+++ b/tests/Unit/Services/ClassPreparation/ClassPreparationContextServiceTest.php
@@ -0,0 +1,28 @@
+<?php
+
+namespace Tests\Unit\Services\ClassPreparation;
+
+use App\Services\ClassPreparation\ClassPreparationContextService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ClassPreparationContextServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_has_roster_for_semester(): void
+    {
+        DB::table('student_class')->insert([
+            'student_id' => 1,
+            'class_section_id' => 101,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new ClassPreparationContextService();
+
+        $this->assertTrue($service->hasRosterForSemester('2025-2026', 'Fall'));
+        $this->assertFalse($service->hasRosterForSemester('2025-2026', 'Spring'));
+    }
+}
diff --git a/tests/Unit/Services/ClassPreparation/ClassPreparationInventoryServiceTest.php b/tests/Unit/Services/ClassPreparation/ClassPreparationInventoryServiceTest.php
new file mode 100644
index 00000000..c6b9af3b
--- /dev/null
+++ b/tests/Unit/Services/ClassPreparation/ClassPreparationInventoryServiceTest.php
@@ -0,0 +1,48 @@
+<?php
+
+namespace Tests\Unit\Services\ClassPreparation;
+
+use App\Services\ClassPreparation\ClassPreparationInventoryService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ClassPreparationInventoryServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_build_availability_uses_max_value(): void
+    {
+        DB::table('inventory_categories')->insert([
+            'id' => 1,
+            'type' => 'classroom',
+            'name' => 'Small Table',
+        ]);
+
+        DB::table('inventory_items')->insert([
+            [
+                'type' => 'classroom',
+                'category_id' => 1,
+                'name' => 'Small Table',
+                'quantity' => 5,
+                'good_qty' => 5,
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+            ],
+            [
+                'type' => 'classroom',
+                'category_id' => 1,
+                'name' => 'Small Table',
+                'quantity' => 3,
+                'good_qty' => 3,
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+            ],
+        ]);
+
+        $service = new ClassPreparationInventoryService();
+        $map = $service->buildAvailability('2025-2026', 'Fall', true, ['Small Table']);
+
+        $this->assertSame(8, $map['Small Table']);
+    }
+}
diff --git a/tests/Unit/Services/ClassPreparation/ClassPreparationLogServiceTest.php b/tests/Unit/Services/ClassPreparation/ClassPreparationLogServiceTest.php
new file mode 100644
index 00000000..158868d5
--- /dev/null
+++ b/tests/Unit/Services/ClassPreparation/ClassPreparationLogServiceTest.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace Tests\Unit\Services\ClassPreparation;
+
+use App\Services\ClassPreparation\ClassPreparationLogService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ClassPreparationLogServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_has_prep_changed_detects_diff(): void
+    {
+        $service = new ClassPreparationLogService();
+
+        $this->assertTrue($service->hasPrepChanged(['a' => 1], ['a' => 2]));
+        $this->assertFalse($service->hasPrepChanged(['a' => 1], ['a' => 1]));
+    }
+
+    public function test_create_log_and_get_latest(): void
+    {
+        $service = new ClassPreparationLogService();
+        $created = $service->createLog('101', '1-A', '2025-2026', ['Small Table' => 2], '2025-09-01 00:00:00');
+
+        $this->assertTrue($created);
+        $this->assertDatabaseHas('class_preparation_log', [
+            'class_section_id' => 101,
+            'school_year' => '2025-2026',
+        ]);
+
+        $log = $service->getLatestLog('101', '2025-2026');
+        $this->assertNotNull($log);
+    }
+}
diff --git a/tests/Unit/Services/ClassPreparation/ClassPreparationRosterServiceTest.php b/tests/Unit/Services/ClassPreparation/ClassPreparationRosterServiceTest.php
new file mode 100644
index 00000000..c3c1db0a
--- /dev/null
+++ b/tests/Unit/Services/ClassPreparation/ClassPreparationRosterServiceTest.php
@@ -0,0 +1,84 @@
+<?php
+
+namespace Tests\Unit\Services\ClassPreparation;
+
+use App\Services\ClassPreparation\ClassPreparationRosterService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ClassPreparationRosterServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_class_section_student_counts(): void
+    {
+        $this->seedRoster();
+
+        $service = new ClassPreparationRosterService();
+        $rows = $service->getClassSectionStudentCounts('2025-2026', 'Fall', true);
+
+        $this->assertCount(1, $rows);
+        $this->assertSame(101, (int) $rows[0]->class_section_id);
+        $this->assertSame(2, (int) $rows[0]->student_count);
+    }
+
+    public function test_get_student_count_for_section(): void
+    {
+        $this->seedRoster();
+
+        $service = new ClassPreparationRosterService();
+        $count = $service->getStudentCountForSection('2025-2026', 'Fall', true, '101');
+
+        $this->assertSame(2, $count);
+    }
+
+    private function seedRoster(): void
+    {
+        DB::table('students')->insert([
+            [
+                'id' => 1,
+                'school_id' => 'S-1',
+                'firstname' => 'Student',
+                'lastname' => 'One',
+                'age' => 8,
+                'gender' => 'Male',
+                'photo_consent' => 1,
+                'parent_id' => 1,
+                'year_of_registration' => '2025',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'is_active' => 1,
+            ],
+            [
+                'id' => 2,
+                'school_id' => 'S-2',
+                'firstname' => 'Student',
+                'lastname' => 'Two',
+                'age' => 9,
+                'gender' => 'Female',
+                'photo_consent' => 1,
+                'parent_id' => 1,
+                'year_of_registration' => '2025',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'is_active' => 1,
+            ],
+        ]);
+
+        DB::table('student_class')->insert([
+            [
+                'student_id' => 1,
+                'class_section_id' => 101,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'student_id' => 2,
+                'class_section_id' => 101,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/ClassPreparation/ClassPreparationServiceTest.php b/tests/Unit/Services/ClassPreparation/ClassPreparationServiceTest.php
new file mode 100644
index 00000000..853f8209
--- /dev/null
+++ b/tests/Unit/Services/ClassPreparation/ClassPreparationServiceTest.php
@@ -0,0 +1,93 @@
+<?php
+
+namespace Tests\Unit\Services\ClassPreparation;
+
+use App\Services\ClassPreparation\ClassPreparationService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ClassPreparationServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_prep_returns_sections_and_totals(): void
+    {
+        $this->seedPrepData();
+
+        $service = new ClassPreparationService();
+        $payload = $service->listPrep('2025-2026', 'Fall');
+
+        $this->assertSame('2025-2026', $payload['schoolYear']);
+        $this->assertSame('Fall', $payload['semester']);
+        $this->assertNotEmpty($payload['results']);
+        $this->assertArrayHasKey('Small Table', $payload['totals']);
+    }
+
+    public function test_mark_printed_creates_logs(): void
+    {
+        $this->seedPrepData();
+
+        $service = new ClassPreparationService();
+        $count = $service->markPrinted('2025-2026', 'Fall', [101]);
+
+        $this->assertSame(1, $count);
+        $this->assertDatabaseHas('class_preparation_log', [
+            'class_section_id' => 101,
+            'school_year' => '2025-2026',
+        ]);
+    }
+
+    private function seedPrepData(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 1,
+            'class_section_id' => 101,
+            'class_section_name' => '1-A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'school_id' => 'S-1',
+            'firstname' => 'Student',
+            'lastname' => 'One',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 1,
+            'class_section_id' => 101,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('inventory_categories')->insert([
+            'type' => 'classroom',
+            'name' => 'Small Table',
+        ]);
+
+        DB::table('inventory_items')->insert([
+            'type' => 'classroom',
+            'category_id' => 1,
+            'name' => 'Small Table',
+            'quantity' => 10,
+            'good_qty' => 10,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Communication/CommunicationTemplateServiceTest.php b/tests/Unit/Services/Communication/CommunicationTemplateServiceTest.php
new file mode 100644
index 00000000..4c1fab86
--- /dev/null
+++ b/tests/Unit/Services/Communication/CommunicationTemplateServiceTest.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Tests\Unit\Services\Communication;
+
+use App\Services\Communication\CommunicationTemplateService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class CommunicationTemplateServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_active_templates_maps_columns(): void
+    {
+        DB::table('email_templates')->insert([
+            'id' => 1,
+            'code' => 'welcome',
+            'variant' => 'default',
+            'subject' => 'Hello',
+            'body_html' => 'Body',
+            'is_active' => 1,
+        ]);
+
+        $service = new CommunicationTemplateService();
+        $templates = $service->listActiveTemplates();
+
+        $this->assertSame('welcome', $templates[0]['template_key']);
+        $this->assertSame('Body', $templates[0]['body']);
+    }
+}
diff --git a/tests/Unit/Services/CompetitionScores/CompetitionScoresSaveServiceTest.php b/tests/Unit/Services/CompetitionScores/CompetitionScoresSaveServiceTest.php
new file mode 100644
index 00000000..cf550815
--- /dev/null
+++ b/tests/Unit/Services/CompetitionScores/CompetitionScoresSaveServiceTest.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace Tests\Unit\Services\CompetitionScores;
+
+use App\Models\CompetitionScore;
+use App\Services\CompetitionScores\CompetitionScoresSaveService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class CompetitionScoresSaveServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_filter_scores_rejects_non_integers(): void
+    {
+        $service = new CompetitionScoresSaveService();
+        [$clean, $invalid] = $service->filterScores([
+            1 => '10',
+            2 => '4.5',
+        ]);
+
+        $this->assertSame([1 => 10], $clean);
+        $this->assertSame([2], $invalid);
+    }
+
+    public function test_save_scores_upserts(): void
+    {
+        DB::table('competition_scores')->insert([
+            'competition_id' => 1,
+            'student_id' => 1,
+            'class_section_id' => 101,
+            'score' => 2,
+        ]);
+
+        $service = new CompetitionScoresSaveService();
+        $service->saveScores(1, 101, [1 => 7]);
+
+        $this->assertDatabaseHas('competition_scores', [
+            'competition_id' => 1,
+            'student_id' => 1,
+            'class_section_id' => 101,
+            'score' => 7,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Discounts/DiscountApplyServiceTest.php b/tests/Unit/Services/Discounts/DiscountApplyServiceTest.php
new file mode 100644
index 00000000..22db9a0c
--- /dev/null
+++ b/tests/Unit/Services/Discounts/DiscountApplyServiceTest.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Tests\Unit\Services\Discounts;
+
+use App\Services\Discounts\DiscountApplyService;
+use App\Services\Discounts\DiscountContextService;
+use App\Services\Discounts\DiscountInvoiceService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class DiscountApplyServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_apply_voucher_returns_error_when_no_remaining_uses(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('discount_vouchers')->insert([
+            'id' => 1,
+            'code' => 'USED-OUT',
+            'discount_type' => 'fixed',
+            'discount_value' => 10,
+            'max_uses' => 1,
+            'times_used' => 1,
+            'is_active' => 1,
+        ]);
+
+        $service = new DiscountApplyService(new DiscountContextService(), new DiscountInvoiceService());
+        $result = $service->applyVoucher(1, [10], true, 1);
+
+        $this->assertFalse($result['ok']);
+    }
+}
diff --git a/tests/Unit/Services/Expenses/ExpenseReceiptServiceTest.php b/tests/Unit/Services/Expenses/ExpenseReceiptServiceTest.php
new file mode 100644
index 00000000..7a374401
--- /dev/null
+++ b/tests/Unit/Services/Expenses/ExpenseReceiptServiceTest.php
@@ -0,0 +1,26 @@
+<?php
+
+namespace Tests\Unit\Services\Expenses;
+
+use App\Services\Expenses\ExpenseReceiptService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Http\UploadedFile;
+use Illuminate\Support\Facades\Storage;
+use Tests\TestCase;
+
+class ExpenseReceiptServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_store_receipt_returns_filename_and_url(): void
+    {
+        Storage::fake();
+
+        $service = new ExpenseReceiptService();
+        $file = UploadedFile::fake()->create('receipt.pdf', 10, 'application/pdf');
+        $filename = $service->storeReceipt($file);
+
+        $this->assertNotEmpty($filename);
+        $this->assertSame(url('receipts/' . $filename), $service->receiptUrl($filename));
+    }
+}
diff --git a/tests/Unit/Services/Expenses/ExpenseStaffServiceTest.php b/tests/Unit/Services/Expenses/ExpenseStaffServiceTest.php
new file mode 100644
index 00000000..32874564
--- /dev/null
+++ b/tests/Unit/Services/Expenses/ExpenseStaffServiceTest.php
@@ -0,0 +1,75 @@
+<?php
+
+namespace Tests\Unit\Services\Expenses;
+
+use App\Services\Expenses\ExpenseStaffService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ExpenseStaffServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_staff_users_excludes_parents(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'administrator', 'slug' => 'administrator', 'is_active' => 1],
+            ['id' => 2, 'name' => 'parent', 'slug' => 'parent', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            [
+                'id' => 10,
+                'school_id' => 1,
+                'firstname' => 'Staff',
+                'lastname' => 'User',
+                'cellphone' => '5555555555',
+                'email' => 'staff@example.com',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 11,
+                'school_id' => 1,
+                'firstname' => 'Parent',
+                'lastname' => 'User',
+                'cellphone' => '5555555555',
+                'email' => 'parent@example.com',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('user_roles')->insert([
+            ['user_id' => 10, 'role_id' => 1],
+            ['user_id' => 11, 'role_id' => 2],
+        ]);
+
+        $service = new ExpenseStaffService();
+        $staff = $service->listStaffUsers();
+
+        $this->assertCount(1, $staff);
+        $this->assertSame(10, $staff[0]['id']);
+    }
+}
diff --git a/tests/Unit/Services/ExtraCharges/ExtraChargesMetaServiceTest.php b/tests/Unit/Services/ExtraCharges/ExtraChargesMetaServiceTest.php
new file mode 100644
index 00000000..e4b41d7d
--- /dev/null
+++ b/tests/Unit/Services/ExtraCharges/ExtraChargesMetaServiceTest.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Tests\Unit\Services\ExtraCharges;
+
+use App\Services\ExtraCharges\ExtraChargesMetaService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ExtraChargesMetaServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_school_years_uses_fallback(): void
+    {
+        $service = new ExtraChargesMetaService();
+        $years = $service->getSchoolYears('2025-2026');
+
+        $this->assertSame(['2025-2026', '2024-2025', '2023-2024', '2022-2023'], $years);
+    }
+
+    public function test_get_school_years_merges_sources(): void
+    {
+        DB::table('additional_charges')->insert([
+            [
+                'parent_id' => 1,
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'charge_type' => 'add',
+                'title' => 'Test',
+                'amount' => 1,
+            ],
+            [
+                'parent_id' => 1,
+                'school_year' => '2024-2025',
+                'semester' => 'Fall',
+                'charge_type' => 'add',
+                'title' => 'Test',
+                'amount' => 1,
+            ],
+        ]);
+
+        DB::table('invoices')->insert([
+            [
+                'parent_id' => 1,
+                'invoice_number' => 'INV-1',
+                'total_amount' => 10,
+                'balance' => 10,
+                'paid_amount' => 0,
+                'issue_date' => '2025-09-01',
+                'status' => 'Unpaid',
+                'school_year' => '2023-2024',
+            ],
+        ]);
+
+        $service = new ExtraChargesMetaService();
+        $years = $service->getSchoolYears();
+
+        $this->assertSame(['2025-2026', '2024-2025', '2023-2024'], $years);
+    }
+}
diff --git a/tests/Unit/Services/Files/ExamDraftDownloadNameServiceTest.php b/tests/Unit/Services/Files/ExamDraftDownloadNameServiceTest.php
new file mode 100644
index 00000000..3ced4307
--- /dev/null
+++ b/tests/Unit/Services/Files/ExamDraftDownloadNameServiceTest.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Tests\Unit\Services\Files;
+
+use App\Services\Files\ExamDraftDownloadNameService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ExamDraftDownloadNameServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_build_returns_slugified_name(): void
+    {
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '2B',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('exam_drafts')->insert([
+            'id' => 1,
+            'teacher_id' => 1,
+            'class_section_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'exam_type' => 'Final Exam',
+            'draft_title' => 'Draft',
+            'teacher_file' => 'draft2.pdf',
+            'version' => 3,
+            'status' => 'draft',
+        ]);
+
+        $service = new ExamDraftDownloadNameService();
+        $name = $service->build('draft2.pdf', 'drafts');
+
+        $this->assertSame('2b_final_exam_v3', $name);
+    }
+}
diff --git a/tests/Unit/Services/Files/FileServeServiceTest.php b/tests/Unit/Services/Files/FileServeServiceTest.php
new file mode 100644
index 00000000..b28f1297
--- /dev/null
+++ b/tests/Unit/Services/Files/FileServeServiceTest.php
@@ -0,0 +1,69 @@
+<?php
+
+namespace Tests\Unit\Services\Files;
+
+use App\Services\Files\FileServeService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Http\Request;
+use Symfony\Component\HttpKernel\Exception\HttpException;
+use Tests\TestCase;
+
+class FileServeServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_meta_returns_file_metadata(): void
+    {
+        $dir = storage_path('testing/files');
+        if (!is_dir($dir)) {
+            mkdir($dir, 0777, true);
+        }
+        $path = $dir . DIRECTORY_SEPARATOR . 'sample.pdf';
+        file_put_contents($path, 'PDFDATA');
+
+        $service = new FileServeService();
+        $meta = $service->meta($dir, 'sample.pdf', ['pdf'], 'download');
+
+        $this->assertSame('sample.pdf', $meta['name']);
+        $this->assertSame('download.pdf', $meta['download_name']);
+        $this->assertSame(7, $meta['size']);
+        $this->assertNotEmpty($meta['etag']);
+    }
+
+    public function test_serve_inline_returns_304_when_etag_matches(): void
+    {
+        $dir = storage_path('testing/files');
+        if (!is_dir($dir)) {
+            mkdir($dir, 0777, true);
+        }
+        $path = $dir . DIRECTORY_SEPARATOR . 'cached.pdf';
+        file_put_contents($path, 'PDFDATA');
+
+        $service = new FileServeService();
+        $meta = $service->meta($dir, 'cached.pdf', ['pdf']);
+
+        $request = Request::create('/files/cached.pdf', 'GET', [], [], [], [
+            'HTTP_IF_NONE_MATCH' => $meta['etag'],
+        ]);
+
+        $response = $service->serveInline($dir, 'cached.pdf', ['pdf'], $request);
+
+        $this->assertSame(304, $response->getStatusCode());
+        $this->assertSame($meta['etag'], $response->headers->get('ETag'));
+    }
+
+    public function test_serve_inline_rejects_invalid_extension(): void
+    {
+        $this->expectException(HttpException::class);
+
+        $dir = storage_path('testing/files');
+        if (!is_dir($dir)) {
+            mkdir($dir, 0777, true);
+        }
+        $path = $dir . DIRECTORY_SEPARATOR . 'sample.exe';
+        file_put_contents($path, 'DATA');
+
+        $service = new FileServeService();
+        $service->meta($dir, 'sample.exe', ['pdf']);
+    }
+}
diff --git a/tests/Unit/Services/Finance/FinancialChartServiceTest.php b/tests/Unit/Services/Finance/FinancialChartServiceTest.php
new file mode 100644
index 00000000..e6b863ba
--- /dev/null
+++ b/tests/Unit/Services/Finance/FinancialChartServiceTest.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace Tests\Unit\Services\Finance;
+
+use App\Services\Finance\FinancialChartService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class FinancialChartServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_generate_charts_returns_null_in_tests(): void
+    {
+        $service = new FinancialChartService();
+
+        $summary = [
+            'totalCharges' => 100,
+            'amountCollected' => 80,
+            'totalUnpaid' => 20,
+            'totalDiscounts' => 5,
+            'totalRefunds' => 2,
+            'totalExpenses' => 10,
+            'totalReimbursements' => 4,
+            'netAmount' => 93,
+        ];
+
+        $this->assertNull($service->generateBarChart($summary));
+        $this->assertNull($service->generatePieChart($summary));
+    }
+}
diff --git a/tests/Unit/Services/Finance/FinancialPaymentServiceTest.php b/tests/Unit/Services/Finance/FinancialPaymentServiceTest.php
new file mode 100644
index 00000000..491c43b2
--- /dev/null
+++ b/tests/Unit/Services/Finance/FinancialPaymentServiceTest.php
@@ -0,0 +1,94 @@
+<?php
+
+namespace Tests\Unit\Services\Finance;
+
+use App\Services\Finance\FinancialPaymentService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class FinancialPaymentServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_payment_aggregates_exclude_void_statuses(): void
+    {
+        DB::table('payments')->insert([
+            [
+                'id' => 1,
+                'parent_id' => 10,
+                'invoice_id' => 1,
+                'total_amount' => 100,
+                'paid_amount' => 30,
+                'balance' => 70,
+                'number_of_installments' => 1,
+                'payment_method' => 'Cash',
+                'payment_date' => '2025-01-05',
+                'school_year' => '2025-2026',
+                'status' => 'Paid',
+            ],
+            [
+                'id' => 2,
+                'parent_id' => 10,
+                'invoice_id' => 1,
+                'total_amount' => 100,
+                'paid_amount' => 20,
+                'balance' => 50,
+                'number_of_installments' => 1,
+                'payment_method' => 'Credit Card',
+                'payment_date' => '2025-01-06',
+                'school_year' => '2025-2026',
+                'status' => 'Paid',
+            ],
+            [
+                'id' => 3,
+                'parent_id' => 10,
+                'invoice_id' => 1,
+                'total_amount' => 100,
+                'paid_amount' => 50,
+                'balance' => 0,
+                'number_of_installments' => 1,
+                'payment_method' => 'Cash',
+                'payment_date' => '2025-01-07',
+                'school_year' => '2025-2026',
+                'status' => 'void',
+            ],
+            [
+                'id' => 4,
+                'parent_id' => 11,
+                'invoice_id' => 2,
+                'total_amount' => 40,
+                'paid_amount' => 10,
+                'balance' => 30,
+                'number_of_installments' => 1,
+                'payment_method' => 'Check',
+                'payment_date' => '2025-01-08',
+                'school_year' => '2025-2026',
+                'status' => 'Paid',
+            ],
+        ]);
+
+        $service = new FinancialPaymentService();
+
+        $payments = $service->paymentsByInvoice('2025-2026', '2025-01-01', '2025-01-31');
+        $breakdown = $service->paymentBreakdown('2025-2026', '2025-01-01', '2025-01-31');
+        $totals = $service->paymentTotals('2025-2026', '2025-01-01', '2025-01-31');
+
+        $map = [];
+        foreach ($payments as $row) {
+            $map[(int) $row['invoice_id']] = (float) $row['paid_amount'];
+        }
+
+        $this->assertSame(50.0, $map[1]);
+        $this->assertSame(10.0, $map[2]);
+
+        $this->assertSame(30.0, (float) ($breakdown[1]['cash'] ?? 0));
+        $this->assertSame(20.0, (float) ($breakdown[1]['credit'] ?? 0));
+        $this->assertSame(10.0, (float) ($breakdown[2]['check'] ?? 0));
+
+        $this->assertSame(60.0, $totals['total_all']);
+        $this->assertSame(30.0, $totals['total_cash']);
+        $this->assertSame(20.0, $totals['total_credit']);
+        $this->assertSame(10.0, $totals['total_check']);
+    }
+}
diff --git a/tests/Unit/Services/Finance/FinancialPdfReportServiceTest.php b/tests/Unit/Services/Finance/FinancialPdfReportServiceTest.php
new file mode 100644
index 00000000..021c05ad
--- /dev/null
+++ b/tests/Unit/Services/Finance/FinancialPdfReportServiceTest.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Tests\Unit\Services\Finance;
+
+use App\Services\Finance\FinancialChartService;
+use App\Services\Finance\FinancialPdfReportService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class FinancialPdfReportServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_build_pdf_returns_bytes(): void
+    {
+        $service = new FinancialPdfReportService(new FinancialChartService());
+
+        $summary = [
+            'schoolYear' => '2025-2026',
+            'totalCharges' => 100,
+            'totalExtraCharges' => 20,
+            'totalDiscounts' => 10,
+            'totalRefunds' => 5,
+            'totalExpenses' => 15,
+            'totalReimbursements' => 8,
+            'donationToSchool' => 3,
+            'netAmount' => 85,
+            'amountCollected' => 60,
+            'totalUnpaid' => 40,
+        ];
+
+        $pdf = $service->buildPdf($summary);
+
+        $this->assertIsString($pdf);
+        $this->assertNotSame('', $pdf);
+    }
+}
diff --git a/tests/Unit/Services/Finance/FinancialReportServiceTest.php b/tests/Unit/Services/Finance/FinancialReportServiceTest.php
new file mode 100644
index 00000000..4b92f0d4
--- /dev/null
+++ b/tests/Unit/Services/Finance/FinancialReportServiceTest.php
@@ -0,0 +1,126 @@
+<?php
+
+namespace Tests\Unit\Services\Finance;
+
+use App\Services\Finance\FinancialPaymentService;
+use App\Services\Finance\FinancialReportService;
+use App\Services\Finance\FinancialSchoolYearService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class FinancialReportServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_report_returns_grouped_data(): void
+    {
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('invoices')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_number' => 'INV-001',
+            'total_amount' => 100,
+            'balance' => 40,
+            'paid_amount' => 60,
+            'has_discount' => 1,
+            'issue_date' => '2025-01-01',
+            'due_date' => '2025-02-01',
+            'status' => 'unpaid',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 60,
+            'balance' => 40,
+            'number_of_installments' => 1,
+            'payment_method' => 'Cash',
+            'payment_date' => '2025-01-02',
+            'school_year' => '2025-2026',
+            'status' => 'Paid',
+        ]);
+
+        DB::table('refunds')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'school_year' => '2025-2026',
+            'invoice_id' => 1,
+            'refund_amount' => 5,
+            'status' => 'Paid',
+            'refund_paid_amount' => 5,
+        ]);
+
+        DB::table('discount_usages')->insert([
+            'id' => 1,
+            'voucher_id' => 1,
+            'invoice_id' => 1,
+            'parent_id' => 10,
+            'discount_amount' => 10,
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('expenses')->insert([
+            'id' => 1,
+            'category' => 'Expense',
+            'amount' => 20,
+            'date_of_purchase' => '2025-01-05',
+            'purchased_by' => 10,
+            'added_by' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'status' => 'approved',
+        ]);
+
+        DB::table('reimbursements')->insert([
+            'id' => 1,
+            'expense_id' => 1,
+            'amount' => 15,
+            'reimbursed_to' => 10,
+            'added_by' => 1,
+            'status' => 'Paid',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+
+        $service = new FinancialReportService(
+            new FinancialPaymentService(),
+            new FinancialSchoolYearService()
+        );
+
+        $report = $service->getReport('2025-01-01', '2025-12-31', '2025-2026');
+
+        $this->assertSame('2025-2026', $report['selectedYear']);
+        $this->assertSame(['2025-2026'], $report['schoolYears']);
+        $this->assertCount(1, $report['invoices']);
+        $this->assertCount(1, $report['payments']);
+        $this->assertCount(1, $report['refunds']);
+        $this->assertCount(1, $report['discounts']);
+        $this->assertCount(1, $report['expenses']);
+        $this->assertCount(1, $report['reimbursements']);
+        $this->assertSame(60.0, $report['paymentTotals']['total_all']);
+    }
+}
diff --git a/tests/Unit/Services/Finance/FinancialSchoolYearServiceTest.php b/tests/Unit/Services/Finance/FinancialSchoolYearServiceTest.php
new file mode 100644
index 00000000..af82841c
--- /dev/null
+++ b/tests/Unit/Services/Finance/FinancialSchoolYearServiceTest.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Tests\Unit\Services\Finance;
+
+use App\Services\Finance\FinancialSchoolYearService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class FinancialSchoolYearServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_years_returns_distinct_sorted_years(): void
+    {
+        DB::table('invoices')->insert([
+            [
+                'id' => 1,
+                'parent_id' => 1,
+                'invoice_number' => 'INV-100',
+                'total_amount' => 10,
+                'balance' => 10,
+                'paid_amount' => 0,
+                'has_discount' => 0,
+                'issue_date' => '2024-01-01',
+                'due_date' => '2024-02-01',
+                'status' => 'unpaid',
+                'school_year' => '2024-2025',
+            ],
+            [
+                'id' => 2,
+                'parent_id' => 1,
+                'invoice_number' => 'INV-101',
+                'total_amount' => 10,
+                'balance' => 10,
+                'paid_amount' => 0,
+                'has_discount' => 0,
+                'issue_date' => '2025-01-01',
+                'due_date' => '2025-02-01',
+                'status' => 'unpaid',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        $service = new FinancialSchoolYearService();
+        $years = $service->listYears();
+
+        $this->assertSame(['2025-2026', '2024-2025'], $years);
+    }
+}
diff --git a/tests/Unit/Services/Finance/FinancialSummaryServiceTest.php b/tests/Unit/Services/Finance/FinancialSummaryServiceTest.php
new file mode 100644
index 00000000..ef01e209
--- /dev/null
+++ b/tests/Unit/Services/Finance/FinancialSummaryServiceTest.php
@@ -0,0 +1,165 @@
+<?php
+
+namespace Tests\Unit\Services\Finance;
+
+use App\Services\Finance\FinancialDonationRecipientService;
+use App\Services\Finance\FinancialSummaryService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class FinancialSummaryServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_summary_calculates_totals(): void
+    {
+        DB::table('users')->insert([
+            'id' => 2,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('invoices')->insert([
+            'id' => 1,
+            'parent_id' => 2,
+            'invoice_number' => 'INV-001',
+            'total_amount' => 100,
+            'balance' => 40,
+            'paid_amount' => 60,
+            'has_discount' => 1,
+            'issue_date' => '2025-01-10',
+            'due_date' => '2025-02-10',
+            'status' => 'unpaid',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 2,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 60,
+            'balance' => 40,
+            'number_of_installments' => 1,
+            'payment_method' => 'Cash',
+            'payment_date' => '2025-01-15',
+            'school_year' => '2025-2026',
+            'status' => 'Paid',
+        ]);
+
+        DB::table('discount_usages')->insert([
+            'id' => 1,
+            'voucher_id' => 1,
+            'invoice_id' => 1,
+            'parent_id' => 2,
+            'discount_amount' => 10,
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('refunds')->insert([
+            'id' => 1,
+            'parent_id' => 2,
+            'school_year' => '2025-2026',
+            'invoice_id' => 1,
+            'refund_amount' => 5,
+            'status' => 'Paid',
+            'refund_paid_amount' => 5,
+        ]);
+
+        DB::table('additional_charges')->insert([
+            [
+                'id' => 1,
+                'parent_id' => 2,
+                'amount' => 20,
+                'school_year' => '2025-2026',
+                'status' => 'pending',
+            ],
+            [
+                'id' => 2,
+                'parent_id' => 2,
+                'amount' => 30,
+                'invoice_id' => 1,
+                'school_year' => '2025-2026',
+                'status' => 'applied',
+            ],
+        ]);
+
+        DB::table('expenses')->insert([
+            [
+                'id' => 1,
+                'category' => 'Donation',
+                'amount' => 12,
+                'date_of_purchase' => '2025-01-05',
+                'purchased_by' => 2,
+                'added_by' => 1,
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'status' => 'approved',
+            ],
+            [
+                'id' => 2,
+                'category' => 'Expense',
+                'amount' => 8,
+                'date_of_purchase' => '2025-01-06',
+                'purchased_by' => 2,
+                'added_by' => 1,
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+                'status' => 'approved',
+            ],
+        ]);
+
+        DB::table('reimbursements')->insert([
+            [
+                'id' => 1,
+                'expense_id' => 2,
+                'amount' => 15,
+                'reimbursed_to' => 2,
+                'added_by' => 1,
+                'status' => 'Paid',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+            ],
+            [
+                'id' => 2,
+                'expense_id' => 1,
+                'amount' => 7,
+                'reimbursed_to' => 990002,
+                'added_by' => 1,
+                'status' => 'Paid',
+                'school_year' => '2025-2026',
+                'semester' => 'Fall',
+            ],
+        ]);
+
+        $service = new FinancialSummaryService(new FinancialDonationRecipientService());
+        $summary = $service->getSummary('2025-01-01', '2025-12-31', '2025-2026');
+
+        $this->assertSame(120.0, $summary['totalCharges']);
+        $this->assertSame(50.0, $summary['totalExtraCharges']);
+        $this->assertSame(10.0, $summary['totalDiscounts']);
+        $this->assertSame(5.0, $summary['totalRefunds']);
+        $this->assertSame(20.0, $summary['totalExpenses']);
+        $this->assertSame(15.0, $summary['totalReimbursements']);
+        $this->assertSame(19.0, $summary['donationToSchool']);
+        $this->assertSame(60.0, $summary['totalPaid']);
+        $this->assertSame(45.0, $summary['totalUnpaid']);
+        $this->assertSame(105.0, $summary['netAmount']);
+    }
+}
diff --git a/tests/Unit/Services/Finance/FinancialUnpaidParentsServiceTest.php b/tests/Unit/Services/Finance/FinancialUnpaidParentsServiceTest.php
new file mode 100644
index 00000000..42ae9a36
--- /dev/null
+++ b/tests/Unit/Services/Finance/FinancialUnpaidParentsServiceTest.php
@@ -0,0 +1,110 @@
+<?php
+
+namespace Tests\Unit\Services\Finance;
+
+use App\Services\Finance\FinancialSchoolYearService;
+use App\Services\Finance\FinancialUnpaidParentsService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class FinancialUnpaidParentsServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_unpaid_parents_returns_installment_data(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'installment_date', 'config_value' => date('Y-m-t')],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 2,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('invoices')->insert([
+            [
+                'id' => 1,
+                'parent_id' => 2,
+                'invoice_number' => 'INV-001',
+                'total_amount' => 100,
+                'balance' => 40,
+                'paid_amount' => 60,
+                'has_discount' => 1,
+                'issue_date' => '2025-01-10',
+                'due_date' => '2025-02-10',
+                'status' => 'unpaid',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 2,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 60,
+            'balance' => 40,
+            'number_of_installments' => 1,
+            'payment_method' => 'Cash',
+            'payment_date' => '2025-01-15',
+            'school_year' => '2025-2026',
+            'status' => 'Paid',
+        ]);
+
+        DB::table('discount_usages')->insert([
+            'id' => 1,
+            'voucher_id' => 1,
+            'invoice_id' => 1,
+            'parent_id' => 2,
+            'discount_amount' => 10,
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('refunds')->insert([
+            'id' => 1,
+            'parent_id' => 2,
+            'school_year' => '2025-2026',
+            'invoice_id' => 1,
+            'refund_amount' => 5,
+            'status' => 'Paid',
+            'refund_paid_amount' => 5,
+        ]);
+
+        DB::table('additional_charges')->insert([
+            'id' => 1,
+            'parent_id' => 2,
+            'amount' => 20,
+            'school_year' => '2025-2026',
+            'status' => 'pending',
+        ]);
+
+        $service = new FinancialUnpaidParentsService(new FinancialSchoolYearService());
+        $result = $service->getUnpaidParents('2025-2026');
+
+        $this->assertSame('2025-2026', $result['schoolYear']);
+        $this->assertCount(1, $result['results']);
+
+        $row = $result['results'][0];
+        $this->assertSame(45.0, $row['total_balance']);
+        $this->assertSame('installment', $row['type']);
+        $this->assertSame(1, $row['has_installment']);
+    }
+}
diff --git a/tests/Unit/Services/Grading/GradingBelowSixtyServiceTest.php b/tests/Unit/Services/Grading/GradingBelowSixtyServiceTest.php
new file mode 100644
index 00000000..1981b4f8
--- /dev/null
+++ b/tests/Unit/Services/Grading/GradingBelowSixtyServiceTest.php
@@ -0,0 +1,55 @@
+<?php
+
+namespace Tests\Unit\Services\Grading;
+
+use App\Services\Grading\GradingBelowSixtyService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class GradingBelowSixtyServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_rows_returns_students_below_sixty(): void
+    {
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'age' => 10,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('semester_scores')->insert([
+            'id' => 1,
+            'student_id' => 100,
+            'school_id' => 1,
+            'class_section_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'semester_score' => 55,
+        ]);
+
+        $service = new GradingBelowSixtyService();
+        $rows = $service->listRows('2025-2026', 'Fall');
+
+        $this->assertCount(1, $rows);
+        $this->assertSame(100, (int) $rows[0]['student_id']);
+        $this->assertSame('Open', $rows[0]['status']);
+    }
+}
diff --git a/tests/Unit/Services/Grading/GradingLockServiceTest.php b/tests/Unit/Services/Grading/GradingLockServiceTest.php
new file mode 100644
index 00000000..2cf59bb0
--- /dev/null
+++ b/tests/Unit/Services/Grading/GradingLockServiceTest.php
@@ -0,0 +1,69 @@
+<?php
+
+namespace Tests\Unit\Services\Grading;
+
+use App\Services\Grading\GradingLockService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class GradingLockServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_toggle_creates_lock(): void
+    {
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new GradingLockService();
+        $locked = $service->toggle(1, 'Fall', '2025-2026', 99);
+
+        $this->assertTrue($locked);
+        $this->assertDatabaseHas('grading_locks', [
+            'class_section_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'is_locked' => 1,
+        ]);
+    }
+
+    public function test_lock_all_locks_sections(): void
+    {
+        DB::table('classSection')->insert([
+            [
+                'id' => 1,
+                'class_section_id' => 1,
+                'class_section_name' => '1A',
+                'class_id' => 1,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 2,
+                'class_section_id' => 2,
+                'class_section_name' => '1B',
+                'class_id' => 1,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        $service = new GradingLockService();
+        $count = $service->lockAll('Fall', '2025-2026', 99);
+
+        $this->assertSame(2, $count);
+        $this->assertDatabaseHas('grading_locks', [
+            'class_section_id' => 2,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'is_locked' => 1,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Grading/HomeworkTrackingServiceTest.php b/tests/Unit/Services/Grading/HomeworkTrackingServiceTest.php
new file mode 100644
index 00000000..88ffb099
--- /dev/null
+++ b/tests/Unit/Services/Grading/HomeworkTrackingServiceTest.php
@@ -0,0 +1,81 @@
+<?php
+
+namespace Tests\Unit\Services\Grading;
+
+use App\Services\Grading\HomeworkTrackingCalendarService;
+use App\Services\Grading\HomeworkTrackingService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class HomeworkTrackingServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_report_returns_teacher_rows(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Teacher',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'teacher@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('teacher_class')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'teacher_id' => 1,
+            'position' => 'main',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('homework')->insert([
+            'id' => 1,
+            'student_id' => 100,
+            'school_id' => 1,
+            'class_section_id' => 1,
+            'updated_by' => 1,
+            'homework_index' => 1,
+            'score' => 90,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'created_at' => now(),
+            'updated_at' => now(),
+        ]);
+
+        $service = new HomeworkTrackingService(new HomeworkTrackingCalendarService());
+        $result = $service->report('Fall', '2025-2026', 1);
+
+        $this->assertNotEmpty($result['teachers']);
+        $this->assertSame(1, $result['teachers'][0]['class_section_id']);
+    }
+}
diff --git a/tests/Unit/Services/Incidents/IncidentAnalysisServiceTest.php b/tests/Unit/Services/Incidents/IncidentAnalysisServiceTest.php
new file mode 100644
index 00000000..36f98db5
--- /dev/null
+++ b/tests/Unit/Services/Incidents/IncidentAnalysisServiceTest.php
@@ -0,0 +1,62 @@
+<?php
+
+namespace Tests\Unit\Services\Incidents;
+
+use App\Services\Incidents\IncidentAnalysisService;
+use App\Services\Incidents\IncidentLookupService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class IncidentAnalysisServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_analyze_groups_incidents_by_student(): void
+    {
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('incident')->insert([
+            [
+                'id' => 1,
+                'student_id' => 10,
+                'student_name' => 'Kid Tester',
+                'grade' => '1',
+                'incident' => 'behavior',
+                'incident_datetime' => '2025-01-02 10:00:00',
+                'incident_state' => 'Closed',
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 2,
+                'student_id' => 10,
+                'student_name' => 'Kid Tester',
+                'grade' => '1',
+                'incident' => 'behavior',
+                'incident_datetime' => '2025-01-01 10:00:00',
+                'incident_state' => 'Canceled',
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        $service = new IncidentAnalysisService(new IncidentLookupService());
+        $result = $service->analyze('2025-2026', 'Fall');
+
+        $this->assertCount(1, $result);
+        $this->assertSame('Kid Tester', $result[0]['student_name']);
+        $this->assertSame('1A', $result[0]['grade']);
+        $this->assertSame(2, $result[0]['total']);
+        $this->assertSame(1, $result[0]['closed']);
+        $this->assertSame(1, $result[0]['canceled']);
+        $this->assertSame('2025-01-02 10:00:00', $result[0]['last_incident']);
+    }
+}
diff --git a/tests/Unit/Services/Incidents/IncidentHistoryServiceTest.php b/tests/Unit/Services/Incidents/IncidentHistoryServiceTest.php
new file mode 100644
index 00000000..f4a0e8dd
--- /dev/null
+++ b/tests/Unit/Services/Incidents/IncidentHistoryServiceTest.php
@@ -0,0 +1,66 @@
+<?php
+
+namespace Tests\Unit\Services\Incidents;
+
+use App\Services\Incidents\IncidentHistoryService;
+use App\Services\Incidents\IncidentLookupService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class IncidentHistoryServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_processed_enriches_grade_and_updater_names(): void
+    {
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 1,
+            'class_section_id' => 5,
+            'class_section_name' => '5A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 3,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('incident')->insert([
+            'student_id' => 1,
+            'student_name' => 'Student One',
+            'grade' => 5,
+            'incident' => 'Test incident',
+            'incident_datetime' => '2025-01-01 10:00:00',
+            'incident_state' => 'open',
+            'updated_by_open' => 3,
+            'open_description' => 'Opened',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new IncidentHistoryService(new IncidentLookupService());
+        $rows = $service->processed('2025-2026', 'Fall');
+
+        $this->assertSame('5A', $rows[0]['grade']);
+        $this->assertSame('Admin User', $rows[0]['updated_by_open_name']);
+    }
+}
diff --git a/tests/Unit/Services/Incidents/IncidentLookupServiceTest.php b/tests/Unit/Services/Incidents/IncidentLookupServiceTest.php
new file mode 100644
index 00000000..20332c33
--- /dev/null
+++ b/tests/Unit/Services/Incidents/IncidentLookupServiceTest.php
@@ -0,0 +1,79 @@
+<?php
+
+namespace Tests\Unit\Services\Incidents;
+
+use App\Services\Incidents\IncidentLookupService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class IncidentLookupServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_grade_options_with_active_students(): void
+    {
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 1,
+            'class_section_id' => 10,
+            'class_section_name' => '1A',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 1,
+            'school_id' => 'S1',
+            'firstname' => 'Test',
+            'lastname' => 'Student',
+            'age' => 8,
+            'gender' => 'Male',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 1,
+            'class_section_id' => 10,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new IncidentLookupService();
+        $grades = $service->gradeOptionsWithActiveStudents('2025-2026');
+
+        $this->assertSame([['id' => 10, 'name' => '1A']], $grades);
+    }
+
+    public function test_updater_name_map(): void
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Jane',
+            'lastname' => 'Doe',
+            'cellphone' => '5555555555',
+            'email' => 'jane@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new IncidentLookupService();
+        $map = $service->updaterNameMap([1]);
+
+        $this->assertSame('Jane Doe', $map[1]);
+    }
+}
diff --git a/tests/Unit/Services/Invoices/InvoiceConfigServiceTest.php b/tests/Unit/Services/Invoices/InvoiceConfigServiceTest.php
new file mode 100644
index 00000000..4e5631f8
--- /dev/null
+++ b/tests/Unit/Services/Invoices/InvoiceConfigServiceTest.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Tests\Unit\Services\Invoices;
+
+use App\Services\Invoices\InvoiceConfigService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class InvoiceConfigServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_config_service_reads_values(): void
+    {
+        DB::table('configuration')->insert([
+            ['config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['config_key' => 'semester', 'config_value' => 'Fall'],
+            ['config_key' => 'due_date', 'config_value' => '2025-09-01'],
+            ['config_key' => 'grade_fee', 'config_value' => '9'],
+            ['config_key' => 'first_student_fee', 'config_value' => '350'],
+            ['config_key' => 'second_student_fee', 'config_value' => '200'],
+            ['config_key' => 'youth_fee', 'config_value' => '180'],
+            ['config_key' => 'refund_deadline', 'config_value' => '2025-10-01'],
+        ]);
+
+        $service = new InvoiceConfigService();
+
+        $this->assertSame('2025-2026', $service->getSchoolYear());
+        $this->assertSame('Fall', $service->getSemester());
+        $this->assertSame('2025-09-01', $service->getDueDate());
+        $this->assertSame(9, $service->getGradeFee());
+        $this->assertSame(350.0, $service->getFirstStudentFee());
+        $this->assertSame(200.0, $service->getSecondStudentFee());
+        $this->assertSame(180.0, $service->getYouthFee());
+        $this->assertSame('2025-10-01', $service->getRefundDeadline());
+    }
+}
diff --git a/tests/Unit/Services/Invoices/InvoiceGenerationServiceTest.php b/tests/Unit/Services/Invoices/InvoiceGenerationServiceTest.php
new file mode 100644
index 00000000..3c37a14e
--- /dev/null
+++ b/tests/Unit/Services/Invoices/InvoiceGenerationServiceTest.php
@@ -0,0 +1,92 @@
+<?php
+
+namespace Tests\Unit\Services\Invoices;
+
+use App\Services\Invoices\InvoiceConfigService;
+use App\Services\Invoices\InvoiceGenerationService;
+use App\Services\Invoices\InvoiceGradeService;
+use App\Services\Invoices\InvoiceTuitionService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class InvoiceGenerationServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_generate_invoice_creates_new_invoice(): void
+    {
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+        ]);
+
+        DB::table('enrollments')->insert([
+            'student_id' => 100,
+            'parent_id' => 10,
+            'class_section_id' => 1,
+            'enrollment_status' => 'enrolled',
+            'school_year' => '2025-2026',
+        ]);
+
+        $config = new InvoiceConfigService();
+        $grades = new InvoiceGradeService($config->getGradeFee());
+        $tuition = new InvoiceTuitionService(
+            $grades,
+            $config->getGradeFee(),
+            $config->getFirstStudentFee(),
+            $config->getSecondStudentFee(),
+            $config->getYouthFee(),
+            $config->getTimezone()
+        );
+        $service = new InvoiceGenerationService($config, $tuition);
+
+        $result = $service->generateInvoice(10, '2025-2026');
+
+        $this->assertTrue($result['ok']);
+        $this->assertNotNull($result['insert_id']);
+        $this->assertDatabaseHas('invoices', [
+            'id' => $result['insert_id'],
+            'parent_id' => 10,
+            'school_year' => '2025-2026',
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Invoices/InvoiceGradeServiceTest.php b/tests/Unit/Services/Invoices/InvoiceGradeServiceTest.php
new file mode 100644
index 00000000..039b8225
--- /dev/null
+++ b/tests/Unit/Services/Invoices/InvoiceGradeServiceTest.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Tests\Unit\Services\Invoices;
+
+use App\Services\Invoices\InvoiceGradeService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class InvoiceGradeServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_grade_parsing_handles_common_cases(): void
+    {
+        $service = new InvoiceGradeService(9);
+
+        $this->assertTrue($service->isKindergarten('KG'));
+        $this->assertSame(1, $service->gradeLevelInt('K'));
+        $this->assertSame(-1, $service->gradeLevelInt('PK'));
+        $this->assertSame(10, $service->gradeLevelInt('Youth'));
+        $this->assertSame(5, $service->gradeLevelInt('Grade 5'));
+
+        $info = $service->getGradeLevel('5A');
+        $this->assertSame(5, $info['level']);
+        $this->assertSame('A', $info['suffix']);
+    }
+
+    public function test_compare_grades_orders_numeric_then_suffix(): void
+    {
+        $service = new InvoiceGradeService(9);
+
+        $this->assertSame(-1, $service->compareGrades('1', '2'));
+        $this->assertSame(1, $service->compareGrades('2', '1'));
+        $this->assertSame(-1, $service->compareGrades('2A', '2B'));
+        $this->assertSame(0, $service->compareGrades('K', 'K'));
+    }
+}
diff --git a/tests/Unit/Services/Invoices/InvoiceManagementServiceTest.php b/tests/Unit/Services/Invoices/InvoiceManagementServiceTest.php
new file mode 100644
index 00000000..7c3ff7bf
--- /dev/null
+++ b/tests/Unit/Services/Invoices/InvoiceManagementServiceTest.php
@@ -0,0 +1,107 @@
+<?php
+
+namespace Tests\Unit\Services\Invoices;
+
+use App\Services\Invoices\InvoiceConfigService;
+use App\Services\Invoices\InvoiceManagementService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class InvoiceManagementServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_management_data_returns_parent_invoice_summary(): void
+    {
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'parent', 'slug' => 'parent', 'is_active' => 1],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 10,
+            'role_id' => 1,
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+        ]);
+
+        DB::table('enrollments')->insert([
+            'student_id' => 100,
+            'parent_id' => 10,
+            'class_section_id' => 1,
+            'enrollment_status' => 'enrolled',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('invoices')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_number' => 'INV-001',
+            'total_amount' => 100,
+            'balance' => 100,
+            'paid_amount' => 0,
+            'has_discount' => 0,
+            'issue_date' => '2025-01-10',
+            'status' => 'unpaid',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('refunds')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'school_year' => '2025-2026',
+            'invoice_id' => 1,
+            'refund_amount' => 5,
+            'status' => 'Paid',
+            'refund_paid_amount' => 5,
+        ]);
+
+        $service = new InvoiceManagementService(new InvoiceConfigService());
+        $data = $service->getManagementData('2025-2026');
+
+        $this->assertSame('2025-2026', $data['schoolYear']);
+        $this->assertCount(1, $data['invoices']);
+        $this->assertSame(5.0, $data['invoices'][0]['refund_amount']);
+    }
+}
diff --git a/tests/Unit/Services/Invoices/InvoicePaymentServiceTest.php b/tests/Unit/Services/Invoices/InvoicePaymentServiceTest.php
new file mode 100644
index 00000000..801c7160
--- /dev/null
+++ b/tests/Unit/Services/Invoices/InvoicePaymentServiceTest.php
@@ -0,0 +1,63 @@
+<?php
+
+namespace Tests\Unit\Services\Invoices;
+
+use App\Services\Invoices\InvoiceConfigService;
+use App\Services\Invoices\InvoicePaymentService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class InvoicePaymentServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_parent_invoice_summary_includes_refunds_and_last_payment(): void
+    {
+        DB::table('invoices')->insert([
+            [
+                'id' => 1,
+                'parent_id' => 10,
+                'invoice_number' => 'INV-001',
+                'total_amount' => 100,
+                'balance' => 40,
+                'paid_amount' => 60,
+                'has_discount' => 0,
+                'issue_date' => '2025-01-10',
+                'status' => 'unpaid',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 60,
+            'balance' => 40,
+            'number_of_installments' => 1,
+            'payment_method' => 'Cash',
+            'payment_date' => '2025-01-15',
+            'school_year' => '2025-2026',
+            'status' => 'Paid',
+        ]);
+
+        DB::table('refunds')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'school_year' => '2025-2026',
+            'invoice_id' => 1,
+            'refund_amount' => 5,
+            'status' => 'Paid',
+            'refund_paid_amount' => 5,
+        ]);
+
+        $service = new InvoicePaymentService(new InvoiceConfigService());
+        $data = $service->getParentInvoiceSummary(10, '2025-2026');
+
+        $this->assertSame('2025-2026', $data['selectedYear']);
+        $this->assertSame(5.0, $data['invoices'][0]['refund_amount']);
+        $this->assertSame(60.0, $data['invoices'][0]['last_paid_amount']);
+    }
+}
diff --git a/tests/Unit/Services/Invoices/InvoicePdfServiceTest.php b/tests/Unit/Services/Invoices/InvoicePdfServiceTest.php
new file mode 100644
index 00000000..637c1f24
--- /dev/null
+++ b/tests/Unit/Services/Invoices/InvoicePdfServiceTest.php
@@ -0,0 +1,91 @@
+<?php
+
+namespace Tests\Unit\Services\Invoices;
+
+use App\Services\Invoices\InvoiceConfigService;
+use App\Services\Invoices\InvoiceGradeService;
+use App\Services\Invoices\InvoicePdfService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class InvoicePdfServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_build_pdf_returns_bytes(): void
+    {
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('classSection')->insert([
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'is_event_only' => 0,
+        ]);
+
+        DB::table('enrollments')->insert([
+            'student_id' => 100,
+            'parent_id' => 10,
+            'class_section_id' => 1,
+            'enrollment_status' => 'enrolled',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('invoices')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_number' => 'INV-001',
+            'total_amount' => 100,
+            'balance' => 100,
+            'paid_amount' => 0,
+            'has_discount' => 0,
+            'issue_date' => '2025-01-10',
+            'status' => 'unpaid',
+            'school_year' => '2025-2026',
+        ]);
+
+        $config = new InvoiceConfigService();
+        $grades = new InvoiceGradeService($config->getGradeFee());
+        $service = new InvoicePdfService($config, $grades);
+
+        $pdf = $service->buildPdf(1);
+
+        $this->assertIsString($pdf);
+        $this->assertNotSame('', $pdf);
+    }
+}
diff --git a/tests/Unit/Services/Invoices/InvoiceTuitionServiceTest.php b/tests/Unit/Services/Invoices/InvoiceTuitionServiceTest.php
new file mode 100644
index 00000000..ebedc709
--- /dev/null
+++ b/tests/Unit/Services/Invoices/InvoiceTuitionServiceTest.php
@@ -0,0 +1,60 @@
+<?php
+
+namespace Tests\Unit\Services\Invoices;
+
+use App\Services\Invoices\InvoiceGradeService;
+use App\Services\Invoices\InvoiceTuitionService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class InvoiceTuitionServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_calculate_tuition_fee_counts_regular_and_youth(): void
+    {
+        DB::table('classSection')->insert([
+            ['class_section_id' => 1, 'class_section_name' => '1', 'class_id' => 1],
+            ['class_section_id' => 2, 'class_section_name' => '2', 'class_id' => 2],
+            ['class_section_id' => 3, 'class_section_name' => '10', 'class_id' => 10],
+        ]);
+
+        $grades = new InvoiceGradeService(9);
+        $service = new InvoiceTuitionService($grades, 9, 350.0, 200.0, 180.0, 'UTC');
+
+        $registeredKids = [
+            ['class_section_id' => 1],
+            ['class_section_id' => 2],
+            ['class_section_id' => 3],
+        ];
+
+        $total = $service->calculateTuitionFee($registeredKids, [], date('Y-m-d', strtotime('+10 days')));
+
+        $this->assertSame(730.0, $total);
+    }
+
+    public function test_refund_deadline_includes_withdrawn_when_passed(): void
+    {
+        DB::table('classSection')->insert([
+            ['class_section_id' => 1, 'class_section_name' => '1', 'class_id' => 1],
+            ['class_section_id' => 2, 'class_section_name' => '2', 'class_id' => 2],
+        ]);
+
+        $grades = new InvoiceGradeService(9);
+        $service = new InvoiceTuitionService($grades, 9, 350.0, 200.0, 180.0, 'UTC');
+
+        $registeredKids = [
+            ['class_section_id' => 1],
+        ];
+        $withdrawnKids = [
+            ['class_section_id' => 2],
+        ];
+
+        $totalAllowed = $service->calculateTuitionFee($registeredKids, $withdrawnKids, date('Y-m-d', strtotime('+10 days')));
+        $totalBlocked = $service->calculateTuitionFee($registeredKids, $withdrawnKids, date('Y-m-d', strtotime('-10 days')));
+
+        $this->assertSame(350.0, $totalAllowed);
+        $this->assertSame(550.0, $totalBlocked);
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaymentBalanceServiceTest.php b/tests/Unit/Services/Payments/PaymentBalanceServiceTest.php
new file mode 100644
index 00000000..5fa4e6d7
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaymentBalanceServiceTest.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\Payments\PaymentBalanceService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class PaymentBalanceServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_update_balance_adjusts_payment_totals(): void
+    {
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 0,
+            'balance' => 100,
+            'number_of_installments' => 1,
+            'payment_method' => 'cash',
+            'payment_date' => '2025-01-01',
+            'school_year' => '2025-2026',
+            'status' => 'Pending',
+        ]);
+
+        $service = new PaymentBalanceService();
+        $updated = $service->updateBalance(1, 40);
+
+        $this->assertTrue($updated);
+        $this->assertDatabaseHas('payments', [
+            'id' => 1,
+            'paid_amount' => 40,
+            'balance' => 60,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaymentEnrollmentEventServiceTest.php b/tests/Unit/Services/Payments/PaymentEnrollmentEventServiceTest.php
new file mode 100644
index 00000000..6917bbba
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaymentEnrollmentEventServiceTest.php
@@ -0,0 +1,53 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\Payments\PaymentEnrollmentEventService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class PaymentEnrollmentEventServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_build_event_data_requires_parent(): void
+    {
+        $service = new PaymentEnrollmentEventService();
+
+        $this->expectException(\RuntimeException::class);
+
+        $service->buildEventData(999, [], '2025-2026', 'Fall');
+    }
+
+    public function test_build_event_data_returns_parent_payload_when_no_students(): void
+    {
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '555-555-5555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new PaymentEnrollmentEventService();
+        [$parent, $students] = $service->buildEventData(10, [], '2025-2026', 'Fall', 'https://example.test/login');
+
+        $this->assertSame(10, $parent['user_id']);
+        $this->assertSame('parent@example.com', $parent['email']);
+        $this->assertSame([], $students);
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaymentEventChargesServiceTest.php b/tests/Unit/Services/Payments/PaymentEventChargesServiceTest.php
new file mode 100644
index 00000000..c11f82ca
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaymentEventChargesServiceTest.php
@@ -0,0 +1,82 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\Payments\PaymentEventChargesService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class PaymentEventChargesServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_enrolled_students_returns_grade(): void
+    {
+        DB::table('students')->insert([
+            'id' => 1,
+            'school_id' => 'S1',
+            'firstname' => 'Student',
+            'lastname' => 'One',
+            'dob' => '2010-01-01',
+            'age' => 14,
+            'gender' => 'Male',
+            'is_active' => 1,
+            'registration_grade' => '5',
+            'is_new' => 1,
+            'photo_consent' => 1,
+            'parent_id' => 10,
+            'registration_date' => '2025-01-01',
+            'tuition_paid' => 0,
+            'rfid_tag' => null,
+            'semester' => 'Fall',
+            'year_of_registration' => '2025',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('enrollments')->insert([
+            'id' => 1,
+            'student_id' => 1,
+            'class_section_id' => 100,
+            'parent_id' => 10,
+            'enrollment_date' => '2025-09-01',
+            'enrollment_status' => 'enrolled',
+            'withdrawal_date' => null,
+            'is_withdrawn' => 0,
+            'admission_status' => 'accepted',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_id' => 9,
+            'class_section_id' => 100,
+            'class_section_name' => 'Section A',
+            'created_at' => null,
+            'updated_at' => null,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('student_class')->insert([
+            'id' => 1,
+            'student_id' => 1,
+            'class_section_id' => 100,
+            'is_event_only' => 0,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'description' => null,
+            'created_at' => '2025-09-01 00:00:00',
+            'updated_at' => '2025-09-01 00:00:00',
+            'updated_by' => null,
+        ]);
+
+        $service = new PaymentEventChargesService();
+        $students = $service->getEnrolledStudents(10, '2025-2026');
+
+        $this->assertCount(1, $students);
+        $this->assertSame(1, $students[0]['id']);
+        $this->assertSame('9', (string) $students[0]['grade']);
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaymentLookupServiceTest.php b/tests/Unit/Services/Payments/PaymentLookupServiceTest.php
new file mode 100644
index 00000000..a47e0fd1
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaymentLookupServiceTest.php
@@ -0,0 +1,50 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\Payments\PaymentLookupService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class PaymentLookupServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_by_parent_filters_school_year(): void
+    {
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 20,
+            'balance' => 80,
+            'number_of_installments' => 1,
+            'payment_method' => 'cash',
+            'payment_date' => '2025-01-01',
+            'school_year' => '2025-2026',
+            'status' => 'Pending',
+        ]);
+
+        DB::table('payments')->insert([
+            'id' => 2,
+            'parent_id' => 10,
+            'invoice_id' => 2,
+            'total_amount' => 100,
+            'paid_amount' => 20,
+            'balance' => 80,
+            'number_of_installments' => 1,
+            'payment_method' => 'cash',
+            'payment_date' => '2024-01-01',
+            'school_year' => '2024-2025',
+            'status' => 'Pending',
+        ]);
+
+        $service = new PaymentLookupService();
+        $results = $service->getByParent(10, '2025-2026');
+
+        $this->assertCount(1, $results);
+        $this->assertSame(1, $results[0]['id']);
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaymentManualServiceTest.php b/tests/Unit/Services/Payments/PaymentManualServiceTest.php
new file mode 100644
index 00000000..3f80961c
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaymentManualServiceTest.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\Discounts\DiscountInvoiceService;
+use App\Services\Payments\PaymentEnrollmentEventService;
+use App\Services\Payments\PaymentManualService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Mockery;
+use Tests\TestCase;
+
+class PaymentManualServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_record_payment_rejects_invalid_method(): void
+    {
+        $invoiceService = Mockery::mock(DiscountInvoiceService::class);
+        $enrollmentService = Mockery::mock(PaymentEnrollmentEventService::class);
+
+        $service = new PaymentManualService($invoiceService, $enrollmentService);
+
+        $this->expectException(\InvalidArgumentException::class);
+
+        $service->recordPayment(1, 10.0, 'wire', null, null, null, null);
+    }
+
+    public function test_suggest_returns_matches(): void
+    {
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '555-555-5555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $invoiceService = Mockery::mock(DiscountInvoiceService::class);
+        $enrollmentService = Mockery::mock(PaymentEnrollmentEventService::class);
+
+        $service = new PaymentManualService($invoiceService, $enrollmentService);
+        $results = $service->suggest('parent@example.com');
+
+        $this->assertCount(1, $results);
+        $this->assertSame('parent@example.com', $results[0]['value']);
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaymentNotificationDispatchServiceTest.php b/tests/Unit/Services/Payments/PaymentNotificationDispatchServiceTest.php
new file mode 100644
index 00000000..d27d7dc6
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaymentNotificationDispatchServiceTest.php
@@ -0,0 +1,40 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\Payments\PaymentNotificationDispatchService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class PaymentNotificationDispatchServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_notify_user_creates_notification_records(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 2001, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2002, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        $service = new PaymentNotificationDispatchService();
+        $service->notifyUser(10, 'Payment Reminder', 'Reminder body', ['in_app']);
+
+        $this->assertDatabaseHas('notifications', [
+            'title' => 'Payment Reminder',
+            'message' => 'Reminder body',
+            'target_group' => 'user',
+            'status' => 'sent',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+
+        $this->assertDatabaseHas('user_notifications', [
+            'user_id' => 10,
+            'delivered' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaymentNotificationServiceTest.php b/tests/Unit/Services/Payments/PaymentNotificationServiceTest.php
new file mode 100644
index 00000000..4618093e
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaymentNotificationServiceTest.php
@@ -0,0 +1,134 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\EmailService;
+use App\Services\Payments\PaymentNotificationDispatchService;
+use App\Services\Payments\PaymentNotificationService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Mockery;
+use Tests\TestCase;
+
+class PaymentNotificationServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_send_records_log_and_returns_sent_count(): void
+    {
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '555-555-5555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('invoices')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_number' => 'INV-1',
+            'total_amount' => 100,
+            'balance' => 100,
+            'paid_amount' => 0,
+            'has_discount' => 0,
+            'issue_date' => '2025-01-01',
+            'status' => 'unpaid',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+
+        $emailService = Mockery::mock(EmailService::class);
+        $emailService->shouldReceive('send')
+            ->once()
+            ->with(
+                'parent@example.com',
+                Mockery::type('string'),
+                Mockery::type('string'),
+                'finance'
+            )
+            ->andReturn(true);
+
+        $dispatchService = Mockery::mock(PaymentNotificationDispatchService::class);
+        $dispatchService->shouldNotReceive('notifyUser');
+
+        $service = new PaymentNotificationService($emailService, $dispatchService);
+        $result = $service->send([
+            'parent_id' => 10,
+            'type' => 'installment',
+            'school_year' => '2025-2026',
+        ]);
+
+        $this->assertSame(1, $result['sent']);
+        $this->assertDatabaseHas('payment_notification_logs', [
+            'parent_id' => 10,
+            'status' => 'sent',
+            'type' => 'installment',
+        ]);
+    }
+
+    public function test_list_logs_filters_by_type(): void
+    {
+        DB::table('users')->insert([
+            'id' => 11,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'Two',
+            'cellphone' => '555-555-5556',
+            'email' => 'parent2@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('payment_notification_logs')->insert([
+            'id' => 1,
+            'parent_id' => 11,
+            'invoice_id' => null,
+            'school_year' => '2025-2026',
+            'period_year' => 2025,
+            'period_month' => 9,
+            'type' => 'installment',
+            'to_email' => 'parent2@example.com',
+            'cc_email' => null,
+            'head_fa_notified' => 0,
+            'subject' => 'Reminder',
+            'body' => 'Body',
+            'status' => 'sent',
+            'error_message' => null,
+            'balance_snapshot' => 50,
+            'sent_at' => '2025-09-01 00:00:00',
+        ]);
+
+        $emailService = Mockery::mock(EmailService::class);
+        $dispatchService = Mockery::mock(PaymentNotificationDispatchService::class);
+        $service = new PaymentNotificationService($emailService, $dispatchService);
+
+        $logs = $service->listLogs(null, null, 'installment');
+
+        $this->assertCount(1, $logs);
+        $this->assertSame(11, $logs[0]->parent_id);
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaymentPlanServiceTest.php b/tests/Unit/Services/Payments/PaymentPlanServiceTest.php
new file mode 100644
index 00000000..119ffa30
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaymentPlanServiceTest.php
@@ -0,0 +1,70 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\Payments\PaymentPlanService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class PaymentPlanServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_create_plan_uses_defaults_when_missing(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 2001, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2002, 'config_key' => 'semester', 'config_value' => 'Fall'],
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 10,
+            'school_id' => 1,
+            'firstname' => 'Parent',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('invoices')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_number' => 'INV-1',
+            'total_amount' => 200,
+            'balance' => 200,
+            'paid_amount' => 0,
+            'has_discount' => 0,
+            'issue_date' => '2025-01-01',
+            'status' => 'unpaid',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+
+        $service = new PaymentPlanService();
+        $payment = $service->createPlan([
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'total_amount' => 200,
+            'number_of_installments' => 2,
+            'payment_date' => '2025-01-01',
+            'payment_method' => 'cash',
+        ]);
+
+        $this->assertSame('2025-2026', $payment->school_year);
+        $this->assertSame('Fall', $payment->semester);
+        $this->assertSame(200.0, (float) $payment->total_amount);
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaymentTransactionServiceTest.php b/tests/Unit/Services/Payments/PaymentTransactionServiceTest.php
new file mode 100644
index 00000000..aaf648ea
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaymentTransactionServiceTest.php
@@ -0,0 +1,67 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\Payments\PaymentTransactionService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\DB;
+use Illuminate\Support\Facades\Schema;
+use Tests\TestCase;
+
+class PaymentTransactionServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_create_and_update_transaction(): void
+    {
+        if (!Schema::hasColumn('payment_transactions', 'payment_reference')) {
+            Schema::table('payment_transactions', function (Blueprint $table) {
+                $table->string('payment_reference')->nullable();
+            });
+        }
+
+        if (!Schema::hasColumn('payment_transactions', 'is_full_payment')) {
+            Schema::table('payment_transactions', function (Blueprint $table) {
+                $table->boolean('is_full_payment')->default(0);
+            });
+        }
+
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 0,
+            'balance' => 100,
+            'number_of_installments' => 1,
+            'payment_method' => 'card',
+            'payment_date' => '2025-01-01',
+            'school_year' => '2025-2026',
+            'status' => 'Pending',
+        ]);
+
+        $service = new PaymentTransactionService();
+        $transaction = $service->create([
+            'transaction_id' => 'TXN-1',
+            'payment_id' => 1,
+            'transaction_date' => '2025-01-02 00:00:00',
+            'amount' => 50,
+            'payment_method' => 'card',
+            'payment_status' => 'Pending',
+            'transaction_fee' => 1.25,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+
+        $this->assertSame('TXN-1', $transaction->transaction_id);
+
+        $updated = $service->updateStatus('TXN-1', 'Completed');
+
+        $this->assertTrue($updated);
+        $this->assertDatabaseHas('payment_transactions', [
+            'transaction_id' => 'TXN-1',
+            'payment_status' => 'Completed',
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaypalPaymentServiceTest.php b/tests/Unit/Services/Payments/PaypalPaymentServiceTest.php
new file mode 100644
index 00000000..9bb032cc
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaypalPaymentServiceTest.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\Payments\PaypalPaymentService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class PaypalPaymentServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_create_payment_falls_back_to_hosted_when_sdk_missing(): void
+    {
+        DB::table('payments')->insert([
+            'id' => 1,
+            'parent_id' => 10,
+            'invoice_id' => 1,
+            'total_amount' => 100,
+            'paid_amount' => 0,
+            'balance' => 100,
+            'number_of_installments' => 1,
+            'payment_method' => 'card',
+            'payment_date' => '2025-01-01',
+            'school_year' => '2025-2026',
+            'status' => 'Pending',
+        ]);
+
+        $service = new PaypalPaymentService();
+        $result = $service->createPayment(1);
+
+        $this->assertSame('hosted', $result['mode']);
+        $this->assertSame($service->getRedirectUrl(), $result['redirect_url']);
+    }
+
+    public function test_execute_payment_throws_when_sdk_missing(): void
+    {
+        $service = new PaypalPaymentService();
+
+        $this->expectException(\RuntimeException::class);
+
+        $service->executePayment('payer');
+    }
+}
diff --git a/tests/Unit/Services/Payments/PaypalTransactionsServiceTest.php b/tests/Unit/Services/Payments/PaypalTransactionsServiceTest.php
new file mode 100644
index 00000000..2e2759fb
--- /dev/null
+++ b/tests/Unit/Services/Payments/PaypalTransactionsServiceTest.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace Tests\Unit\Services\Payments;
+
+use App\Services\Payments\PaypalTransactionsService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class PaypalTransactionsServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_all_filters_by_keyword(): void
+    {
+        DB::table('paypal_payments')->insert([
+            'id' => 1,
+            'transaction_id' => 'TXN-ABC',
+            'payer_email' => 'payer@example.com',
+            'event_type' => 'PAYMENT',
+            'order_id' => 'ORDER-1',
+            'parent_school_id' => 'P1',
+            'amount' => 50,
+            'currency' => 'USD',
+            'created_at' => '2025-01-01 00:00:00',
+        ]);
+
+        DB::table('paypal_payments')->insert([
+            'id' => 2,
+            'transaction_id' => 'TXN-DEF',
+            'payer_email' => 'other@example.com',
+            'event_type' => 'REFUND',
+            'order_id' => 'ORDER-2',
+            'parent_school_id' => 'P2',
+            'amount' => 75,
+            'currency' => 'USD',
+            'created_at' => '2025-01-02 00:00:00',
+        ]);
+
+        $service = new PaypalTransactionsService();
+        $results = $service->listAll('ABC');
+
+        $this->assertCount(1, $results);
+        $this->assertStringContainsString('TXN-ABC', json_encode($results));
+    }
+}
diff --git a/tests/Unit/Services/Reimbursements/ReimbursementBatchAssignmentServiceTest.php b/tests/Unit/Services/Reimbursements/ReimbursementBatchAssignmentServiceTest.php
new file mode 100644
index 00000000..7d4e2ee5
--- /dev/null
+++ b/tests/Unit/Services/Reimbursements/ReimbursementBatchAssignmentServiceTest.php
@@ -0,0 +1,83 @@
+<?php
+
+namespace Tests\Unit\Services\Reimbursements;
+
+use App\Services\Reimbursements\ReimbursementBatchAssignmentService;
+use App\Services\Reimbursements\ReimbursementLookupService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ReimbursementBatchAssignmentServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_assign_and_unassign_batch_item(): void
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('reimbursement_batches')->insert([
+            'id' => 10,
+            'title' => 'Batch 10',
+            'status' => 'open',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'opened_at' => now(),
+        ]);
+
+        DB::table('expenses')->insert([
+            'id' => 100,
+            'category' => 'Expense',
+            'amount' => 25.00,
+            'date_of_purchase' => '2025-01-01',
+            'added_by' => 1,
+            'purchased_by' => 1,
+            'status' => 'approved',
+        ]);
+
+        $service = new ReimbursementBatchAssignmentService(new ReimbursementLookupService());
+
+        $result = $service->updateAssignment(100, 10, 1, null, '2025-2026', 'Fall');
+        $this->assertSame(10, $result['batch_id']);
+
+        $this->assertDatabaseHas('reimbursement_batch_items', [
+            'batch_id' => 10,
+            'expense_id' => 100,
+            'admin_id' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+
+        $service->updateAssignment(100, 0, null, null, '2025-2026', 'Fall');
+
+        $this->assertDatabaseHas('reimbursement_batch_items', [
+            'batch_id' => 10,
+            'expense_id' => 100,
+        ]);
+
+        $this->assertDatabaseMissing('reimbursement_batch_items', [
+            'batch_id' => 10,
+            'expense_id' => 100,
+            'unassigned_at' => null,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Reimbursements/ReimbursementBatchServiceTest.php b/tests/Unit/Services/Reimbursements/ReimbursementBatchServiceTest.php
new file mode 100644
index 00000000..632d2bed
--- /dev/null
+++ b/tests/Unit/Services/Reimbursements/ReimbursementBatchServiceTest.php
@@ -0,0 +1,30 @@
+<?php
+
+namespace Tests\Unit\Services\Reimbursements;
+
+use App\Services\Reimbursements\ReimbursementBatchService;
+use App\Services\Reimbursements\ReimbursementLookupService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Tests\TestCase;
+
+class ReimbursementBatchServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_create_batch_assigns_sequence_and_title(): void
+    {
+        $service = new ReimbursementBatchService(new ReimbursementLookupService());
+
+        $batch = $service->createBatch(null, 1, '2025-2026', 'Fall');
+
+        $this->assertSame(1, $batch['sequence']);
+        $this->assertStringContainsString('Batch', $batch['label']);
+
+        $this->assertDatabaseHas('reimbursement_batches', [
+            'id' => $batch['batch_id'],
+            'status' => 'open',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Reimbursements/ReimbursementDonationServiceTest.php b/tests/Unit/Services/Reimbursements/ReimbursementDonationServiceTest.php
new file mode 100644
index 00000000..a6a1cbcc
--- /dev/null
+++ b/tests/Unit/Services/Reimbursements/ReimbursementDonationServiceTest.php
@@ -0,0 +1,77 @@
+<?php
+
+namespace Tests\Unit\Services\Reimbursements;
+
+use App\Services\Reimbursements\ReimbursementDonationService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ReimbursementDonationServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_mark_donation_updates_expense_and_unassigns(): void
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Admin',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'admin@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('expenses')->insert([
+            'id' => 200,
+            'category' => 'Expense',
+            'amount' => 40.00,
+            'date_of_purchase' => '2025-02-01',
+            'added_by' => 1,
+            'purchased_by' => 1,
+            'status' => 'approved',
+        ]);
+
+        DB::table('reimbursement_batches')->insert([
+            'id' => 5,
+            'title' => 'Batch 5',
+            'status' => 'open',
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'opened_at' => now(),
+        ]);
+
+        DB::table('reimbursement_batch_items')->insert([
+            'batch_id' => 5,
+            'expense_id' => 200,
+            'assigned_at' => now(),
+        ]);
+
+        $service = new ReimbursementDonationService();
+        $service->markDonation(200, 1);
+
+        $this->assertDatabaseHas('expenses', [
+            'id' => 200,
+            'category' => 'Donation',
+            'status' => 'approved',
+        ]);
+
+        $this->assertDatabaseMissing('reimbursement_batch_items', [
+            'batch_id' => 5,
+            'expense_id' => 200,
+            'unassigned_at' => null,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Reimbursements/ReimbursementRecipientServiceTest.php b/tests/Unit/Services/Reimbursements/ReimbursementRecipientServiceTest.php
new file mode 100644
index 00000000..a9665b59
--- /dev/null
+++ b/tests/Unit/Services/Reimbursements/ReimbursementRecipientServiceTest.php
@@ -0,0 +1,79 @@
+<?php
+
+namespace Tests\Unit\Services\Reimbursements;
+
+use App\Services\Reimbursements\ReimbursementRecipientService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ReimbursementRecipientServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_recipient_options_include_staff_and_specials(): void
+    {
+        DB::table('users')->insert([
+            [
+                'id' => 1,
+                'school_id' => 1,
+                'firstname' => 'Admin',
+                'lastname' => 'User',
+                'cellphone' => '5555555555',
+                'email' => 'admin@example.com',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'id' => 2,
+                'school_id' => 1,
+                'firstname' => 'Parent',
+                'lastname' => 'User',
+                'cellphone' => '5555555555',
+                'email' => 'parent@example.com',
+                'address_street' => '123 Main',
+                'city' => 'City',
+                'state' => 'ST',
+                'zip' => '12345',
+                'accept_school_policy' => 1,
+                'is_verified' => 1,
+                'status' => 'Active',
+                'is_suspended' => 0,
+                'failed_attempts' => 0,
+                'password' => bcrypt('secret'),
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        DB::table('roles')->insert([
+            ['id' => 1, 'name' => 'admin'],
+            ['id' => 2, 'name' => 'parent'],
+        ]);
+
+        DB::table('user_roles')->insert([
+            ['user_id' => 1, 'role_id' => 1],
+            ['user_id' => 2, 'role_id' => 2],
+        ]);
+
+        $service = new ReimbursementRecipientService();
+        $recipients = $service->recipientOptions();
+
+        $ids = array_map(static fn ($row) => (int) ($row['id'] ?? 0), $recipients);
+
+        $this->assertContains(1, $ids);
+        $this->assertNotContains(2, $ids);
+        $this->assertContains(990001, $ids);
+        $this->assertContains(990002, $ids);
+    }
+}
diff --git a/tests/Unit/Services/Scores/ExamScoreServiceTest.php b/tests/Unit/Services/Scores/ExamScoreServiceTest.php
new file mode 100644
index 00000000..991e58a1
--- /dev/null
+++ b/tests/Unit/Services/Scores/ExamScoreServiceTest.php
@@ -0,0 +1,106 @@
+<?php
+
+namespace Tests\Unit\Services\Scores;
+
+use App\Services\Scores\ExamScoreService;
+use App\Services\Scores\ScoreTermService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ExamScoreServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_returns_latest_exam_score(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Leo', 'Park');
+        $this->seedStudentClass(1, 3, '2025-2026');
+
+        DB::table('midterm_exam')->insert([
+            [
+                'student_id' => 1,
+                'school_id' => 'SCH1',
+                'class_section_id' => 3,
+                'updated_by' => 99,
+                'score' => 70,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+            [
+                'student_id' => 1,
+                'school_id' => 'SCH1',
+                'class_section_id' => 3,
+                'updated_by' => 99,
+                'score' => 80,
+                'semester' => 'Fall',
+                'school_year' => '2025-2026',
+            ],
+        ]);
+
+        $service = new ExamScoreService(new ScoreTermService());
+        $result = $service->list('midterm_exam', 3, 'Fall', '2025-2026');
+
+        $this->assertCount(1, $result['students']);
+        $this->assertSame(80.0, $result['students'][0]['score']);
+    }
+
+    public function test_update_creates_exam_score_and_missing_override(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Leo', 'Park');
+        $this->seedStudentClass(1, 3, '2025-2026');
+
+        $service = new ExamScoreService(new ScoreTermService());
+
+        $count = $service->update(
+            'midterm_exam',
+            3,
+            'Fall',
+            '2025-2026',
+            [1 => ['score' => 95]],
+            [1 => true],
+            99
+        );
+
+        $this->assertSame(1, $count);
+        $this->assertDatabaseHas('midterm_exam', [
+            'student_id' => 1,
+            'class_section_id' => 3,
+            'score' => 95.0,
+        ]);
+        $this->assertDatabaseHas('missing_score_overrides', [
+            'student_id' => 1,
+            'class_section_id' => 3,
+            'item_type' => 'midterm_exam',
+            'item_index' => null,
+            'is_allowed' => 1,
+        ]);
+    }
+
+    private function seedStudent(int $id, string $schoolId, string $first, string $last): void
+    {
+        DB::table('students')->insert([
+            'id' => $id,
+            'school_id' => $schoolId,
+            'firstname' => $first,
+            'lastname' => $last,
+            'age' => 11,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+    }
+
+    private function seedStudentClass(int $studentId, int $classSectionId, string $schoolYear): void
+    {
+        DB::table('student_class')->insert([
+            'student_id' => $studentId,
+            'class_section_id' => $classSectionId,
+            'school_year' => $schoolYear,
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Scores/HomeworkScoreServiceTest.php b/tests/Unit/Services/Scores/HomeworkScoreServiceTest.php
new file mode 100644
index 00000000..95bba07d
--- /dev/null
+++ b/tests/Unit/Services/Scores/HomeworkScoreServiceTest.php
@@ -0,0 +1,81 @@
+<?php
+
+namespace Tests\Unit\Services\Scores;
+
+use App\Services\Scores\HomeworkScoreService;
+use App\Services\Scores\ScoreTermService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class HomeworkScoreServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_includes_semester_variants(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Eli', 'Page');
+        $this->seedStudentClass(1, 8, '2025-2026');
+
+        DB::table('homework')->insert([
+            'student_id' => 1,
+            'school_id' => 'SCH1',
+            'class_section_id' => 8,
+            'updated_by' => 99,
+            'homework_index' => 1,
+            'score' => 91,
+            'semester' => 'First Semester',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new HomeworkScoreService(new ScoreTermService());
+        $result = $service->list(8, 'Fall', '2025-2026');
+
+        $this->assertSame([1], $result['headers']);
+        $this->assertSame(91.0, $result['students'][0]['scores'][1]);
+    }
+
+    public function test_add_column_inserts_next_index(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Eli', 'Page');
+        $this->seedStudentClass(1, 8, '2025-2026');
+
+        $service = new HomeworkScoreService(new ScoreTermService());
+
+        $nextIndex = $service->addColumn(8, 'Fall', '2025-2026', 99);
+
+        $this->assertSame(1, $nextIndex);
+        $this->assertDatabaseHas('homework', [
+            'student_id' => 1,
+            'class_section_id' => 8,
+            'homework_index' => 1,
+        ]);
+    }
+
+    private function seedStudent(int $id, string $schoolId, string $first, string $last): void
+    {
+        DB::table('students')->insert([
+            'id' => $id,
+            'school_id' => $schoolId,
+            'firstname' => $first,
+            'lastname' => $last,
+            'age' => 10,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+    }
+
+    private function seedStudentClass(int $studentId, int $classSectionId, string $schoolYear): void
+    {
+        DB::table('student_class')->insert([
+            'student_id' => $studentId,
+            'class_section_id' => $classSectionId,
+            'school_year' => $schoolYear,
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Scores/ParticipationScoreServiceTest.php b/tests/Unit/Services/Scores/ParticipationScoreServiceTest.php
new file mode 100644
index 00000000..56829a8b
--- /dev/null
+++ b/tests/Unit/Services/Scores/ParticipationScoreServiceTest.php
@@ -0,0 +1,98 @@
+<?php
+
+namespace Tests\Unit\Services\Scores;
+
+use App\Services\Scores\ParticipationScoreService;
+use App\Services\Scores\ScoreTermService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ParticipationScoreServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_returns_participation_scores(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Owen', 'Hall');
+        $this->seedStudentClass(1, 9, '2025-2026');
+
+        DB::table('participation')->insert([
+            'id' => 1,
+            'student_id' => 1,
+            'school_id' => 'SCH1',
+            'class_section_id' => 9,
+            'updated_by' => 99,
+            'score' => 87,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new ParticipationScoreService(new ScoreTermService());
+        $result = $service->list(9, 'Fall', '2025-2026');
+
+        $this->assertSame(87.0, $result['students'][0]['scores']['score']);
+    }
+
+    public function test_update_updates_existing_scores(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Owen', 'Hall');
+        $this->seedStudentClass(1, 9, '2025-2026');
+
+        DB::table('participation')->insert([
+            'id' => 1,
+            'student_id' => 1,
+            'school_id' => 'SCH1',
+            'class_section_id' => 9,
+            'updated_by' => 99,
+            'score' => 70,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new ParticipationScoreService(new ScoreTermService());
+        $count = $service->update(
+            9,
+            'Fall',
+            '2025-2026',
+            [1 => ['score' => 92]],
+            [],
+            99
+        );
+
+        $this->assertSame(1, $count);
+        $this->assertDatabaseHas('participation', [
+            'id' => 1,
+            'student_id' => 1,
+            'score' => 92.0,
+        ]);
+    }
+
+    private function seedStudent(int $id, string $schoolId, string $first, string $last): void
+    {
+        DB::table('students')->insert([
+            'id' => $id,
+            'school_id' => $schoolId,
+            'firstname' => $first,
+            'lastname' => $last,
+            'age' => 10,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+    }
+
+    private function seedStudentClass(int $studentId, int $classSectionId, string $schoolYear): void
+    {
+        DB::table('student_class')->insert([
+            'id' => 1,
+            'student_id' => $studentId,
+            'class_section_id' => $classSectionId,
+            'school_year' => $schoolYear,
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Scores/ProjectScoreServiceTest.php b/tests/Unit/Services/Scores/ProjectScoreServiceTest.php
new file mode 100644
index 00000000..b27c8f7b
--- /dev/null
+++ b/tests/Unit/Services/Scores/ProjectScoreServiceTest.php
@@ -0,0 +1,114 @@
+<?php
+
+namespace Tests\Unit\Services\Scores;
+
+use App\Services\Scores\ProjectScoreService;
+use App\Services\Scores\ScoreTermService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ProjectScoreServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_returns_headers_and_scores(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Maya', 'Stone');
+        $this->seedStudentClass(1, 10, '2025-2026');
+
+        DB::table('project')->insert([
+            'student_id' => 1,
+            'school_id' => 'SCH1',
+            'class_section_id' => 10,
+            'updated_by' => 99,
+            'project_index' => 1,
+            'score' => 88,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new ProjectScoreService(new ScoreTermService());
+        $result = $service->list(10, 'Fall', '2025-2026');
+
+        $this->assertSame([1], $result['headers']);
+        $this->assertCount(1, $result['students']);
+        $this->assertSame(88.0, $result['students'][0]['scores'][1]);
+    }
+
+    public function test_update_creates_scores_and_missing_overrides(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Maya', 'Stone');
+        $this->seedStudentClass(1, 10, '2025-2026');
+
+        $service = new ProjectScoreService(new ScoreTermService());
+
+        $count = $service->update(
+            10,
+            'Fall',
+            '2025-2026',
+            [1 => [1 => '92']],
+            [1 => [1 => true]],
+            99
+        );
+
+        $this->assertSame(1, $count);
+        $this->assertDatabaseHas('project', [
+            'student_id' => 1,
+            'class_section_id' => 10,
+            'project_index' => 1,
+            'score' => 92.0,
+        ]);
+        $this->assertDatabaseHas('missing_score_overrides', [
+            'student_id' => 1,
+            'class_section_id' => 10,
+            'item_type' => 'project',
+            'item_index' => 1,
+            'is_allowed' => 1,
+        ]);
+    }
+
+    public function test_add_column_inserts_next_index(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Maya', 'Stone');
+        $this->seedStudentClass(1, 10, '2025-2026');
+
+        $service = new ProjectScoreService(new ScoreTermService());
+
+        $nextIndex = $service->addColumn(10, 'Fall', '2025-2026', 99);
+
+        $this->assertSame(1, $nextIndex);
+        $this->assertDatabaseHas('project', [
+            'student_id' => 1,
+            'class_section_id' => 10,
+            'project_index' => 1,
+        ]);
+    }
+
+    private function seedStudent(int $id, string $schoolId, string $first, string $last): void
+    {
+        DB::table('students')->insert([
+            'id' => $id,
+            'school_id' => $schoolId,
+            'firstname' => $first,
+            'lastname' => $last,
+            'age' => 10,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+    }
+
+    private function seedStudentClass(int $studentId, int $classSectionId, string $schoolYear): void
+    {
+        DB::table('student_class')->insert([
+            'student_id' => $studentId,
+            'class_section_id' => $classSectionId,
+            'school_year' => $schoolYear,
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Scores/QuizScoreServiceTest.php b/tests/Unit/Services/Scores/QuizScoreServiceTest.php
new file mode 100644
index 00000000..2be158e8
--- /dev/null
+++ b/tests/Unit/Services/Scores/QuizScoreServiceTest.php
@@ -0,0 +1,114 @@
+<?php
+
+namespace Tests\Unit\Services\Scores;
+
+use App\Services\Scores\QuizScoreService;
+use App\Services\Scores\ScoreTermService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class QuizScoreServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_returns_headers_and_scores(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Nina', 'Kim');
+        $this->seedStudentClass(1, 5, '2025-2026');
+
+        DB::table('quiz')->insert([
+            'student_id' => 1,
+            'school_id' => 'SCH1',
+            'class_section_id' => 5,
+            'updated_by' => 99,
+            'quiz_index' => 2,
+            'score' => 77,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new QuizScoreService(new ScoreTermService());
+        $result = $service->list(5, 'Fall', '2025-2026');
+
+        $this->assertSame([2], $result['headers']);
+        $this->assertCount(1, $result['students']);
+        $this->assertSame(77.0, $result['students'][0]['scores'][2]);
+    }
+
+    public function test_update_creates_scores_and_missing_overrides(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Nina', 'Kim');
+        $this->seedStudentClass(1, 5, '2025-2026');
+
+        $service = new QuizScoreService(new ScoreTermService());
+
+        $count = $service->update(
+            5,
+            'Fall',
+            '2025-2026',
+            [1 => [1 => '85']],
+            [1 => [1 => true]],
+            99
+        );
+
+        $this->assertSame(1, $count);
+        $this->assertDatabaseHas('quiz', [
+            'student_id' => 1,
+            'class_section_id' => 5,
+            'quiz_index' => 1,
+            'score' => 85.0,
+        ]);
+        $this->assertDatabaseHas('missing_score_overrides', [
+            'student_id' => 1,
+            'class_section_id' => 5,
+            'item_type' => 'quiz',
+            'item_index' => 1,
+            'is_allowed' => 1,
+        ]);
+    }
+
+    public function test_add_column_inserts_next_index(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Nina', 'Kim');
+        $this->seedStudentClass(1, 5, '2025-2026');
+
+        $service = new QuizScoreService(new ScoreTermService());
+
+        $nextIndex = $service->addColumn(5, 'Fall', '2025-2026', 99);
+
+        $this->assertSame(1, $nextIndex);
+        $this->assertDatabaseHas('quiz', [
+            'student_id' => 1,
+            'class_section_id' => 5,
+            'quiz_index' => 1,
+        ]);
+    }
+
+    private function seedStudent(int $id, string $schoolId, string $first, string $last): void
+    {
+        DB::table('students')->insert([
+            'id' => $id,
+            'school_id' => $schoolId,
+            'firstname' => $first,
+            'lastname' => $last,
+            'age' => 10,
+            'gender' => 'F',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+    }
+
+    private function seedStudentClass(int $studentId, int $classSectionId, string $schoolYear): void
+    {
+        DB::table('student_class')->insert([
+            'student_id' => $studentId,
+            'class_section_id' => $classSectionId,
+            'school_year' => $schoolYear,
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Scores/ScoreCommentServiceTest.php b/tests/Unit/Services/Scores/ScoreCommentServiceTest.php
new file mode 100644
index 00000000..63a13f20
--- /dev/null
+++ b/tests/Unit/Services/Scores/ScoreCommentServiceTest.php
@@ -0,0 +1,80 @@
+<?php
+
+namespace Tests\Unit\Services\Scores;
+
+use App\Services\Scores\ScoreCommentService;
+use App\Services\Scores\ScoreTermService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ScoreCommentServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_returns_comments_for_students(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Ava', 'Lane');
+        $this->seedStudentClass(1, 2, '2025-2026');
+
+        DB::table('score_comments')->insert([
+            'student_id' => 1,
+            'class_section_id' => 2,
+            'score_type' => 'midterm',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+            'comment' => 'Ava has shown consistent improvement and strong effort across assignments.',
+        ]);
+
+        $service = new ScoreCommentService(new ScoreTermService());
+        $result = $service->list('2', 'Fall', '2025-2026');
+
+        $this->assertCount(1, $result['students']);
+        $this->assertSame('Ava', $result['students'][0]['firstname']);
+        $this->assertSame('midterm', array_key_first($result['comments'][1]));
+    }
+
+    public function test_save_returns_validation_errors_for_short_comment(): void
+    {
+        $this->seedStudent(1, 'SCH1', 'Ava', 'Lane');
+
+        $service = new ScoreCommentService(new ScoreTermService());
+        $result = $service->save(
+            2,
+            'Fall',
+            '2025-2026',
+            [1 => ['midterm' => 'Too short']],
+            [],
+            99
+        );
+
+        $this->assertNotEmpty($result['errors']);
+    }
+
+    private function seedStudent(int $id, string $schoolId, string $first, string $last): void
+    {
+        DB::table('students')->insert([
+            'id' => $id,
+            'school_id' => $schoolId,
+            'firstname' => $first,
+            'lastname' => $last,
+            'age' => 10,
+            'gender' => 'F',
+            'photo_consent' => 1,
+            'parent_id' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+    }
+
+    private function seedStudentClass(int $studentId, int $classSectionId, string $schoolYear): void
+    {
+        DB::table('student_class')->insert([
+            'student_id' => $studentId,
+            'class_section_id' => $classSectionId,
+            'school_year' => $schoolYear,
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Scores/ScoreDashboardServiceTest.php b/tests/Unit/Services/Scores/ScoreDashboardServiceTest.php
new file mode 100644
index 00000000..bc773bcc
--- /dev/null
+++ b/tests/Unit/Services/Scores/ScoreDashboardServiceTest.php
@@ -0,0 +1,110 @@
+<?php
+
+namespace Tests\Unit\Services\Scores;
+
+use App\Services\Scores\ScoreDashboardService;
+use App\Services\Scores\ScoreTermService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ScoreDashboardServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_overview_returns_students_and_scores(): void
+    {
+        $this->seedClassSection(10, '1A');
+        $this->seedStudent(1, 'SCH1', 'Noah', 'West', 5);
+        $this->seedStudentClass(1, 10, '2025-2026');
+
+        DB::table('teacher_class')->insert([
+            'teacher_id' => 1,
+            'class_section_id' => 10,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('semester_scores')->insert([
+            'student_id' => 1,
+            'school_id' => 'SCH1',
+            'class_section_id' => 10,
+            'homework_avg' => 85,
+            'quiz_avg' => 90,
+            'project_avg' => 92,
+            'attendance_score' => 95,
+            'ptap_score' => 90,
+            'semester_score' => 91,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new ScoreDashboardService(new ScoreTermService());
+        $result = $service->overview(1, null, 'Fall', '2025-2026');
+
+        $this->assertSame(10, $result['class_section_id']);
+        $this->assertSame('1A', $result['class_section_name']);
+        $this->assertSame(85.0, $result['students'][0]['scores']['homework']);
+    }
+
+    public function test_view_student_scores_groups_by_year_and_semester(): void
+    {
+        $this->seedClassSection(10, '1A');
+        $this->seedStudent(2, 'SCH2', 'Mia', 'Clark', 7);
+        $this->seedStudentClass(2, 10, '2025-2026');
+
+        DB::table('semester_scores')->insert([
+            'student_id' => 2,
+            'school_id' => 'SCH2',
+            'class_section_id' => 10,
+            'homework_avg' => 80,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new ScoreDashboardService(new ScoreTermService());
+        $result = $service->viewStudentScores(7, '2025-2026');
+
+        $this->assertArrayHasKey('2025-2026', $result['scores']);
+        $this->assertArrayHasKey('Fall', $result['scores']['2025-2026']);
+        $this->assertArrayHasKey(2, $result['scores']['2025-2026']['Fall']);
+    }
+
+    private function seedStudent(int $id, string $schoolId, string $first, string $last, int $parentId): void
+    {
+        DB::table('students')->insert([
+            'id' => $id,
+            'school_id' => $schoolId,
+            'firstname' => $first,
+            'lastname' => $last,
+            'age' => 12,
+            'gender' => 'F',
+            'photo_consent' => 1,
+            'parent_id' => $parentId,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+    }
+
+    private function seedStudentClass(int $studentId, int $classSectionId, string $schoolYear): void
+    {
+        DB::table('student_class')->insert([
+            'student_id' => $studentId,
+            'class_section_id' => $classSectionId,
+            'school_year' => $schoolYear,
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+    }
+
+    private function seedClassSection(int $classSectionId, string $name): void
+    {
+        DB::table('classSection')->insert([
+            'class_section_id' => $classSectionId,
+            'class_section_name' => $name,
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+    }
+}
diff --git a/tests/Unit/Services/Scores/ScorePredictorServiceTest.php b/tests/Unit/Services/Scores/ScorePredictorServiceTest.php
new file mode 100644
index 00000000..fca60523
--- /dev/null
+++ b/tests/Unit/Services/Scores/ScorePredictorServiceTest.php
@@ -0,0 +1,77 @@
+<?php
+
+namespace Tests\Unit\Services\Scores;
+
+use App\Services\Scores\ScorePredictorDataService;
+use App\Services\Scores\ScorePredictorRiskService;
+use App\Services\Scores\ScorePredictorService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ScorePredictorServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_report_builds_predictions(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'school_year', 'config_value' => '2025-2026'],
+            ['id' => 2, 'config_key' => 'semester', 'config_value' => 'Fall'],
+            ['id' => 3, 'config_key' => 'trophy_score', 'config_value' => '94'],
+            ['id' => 4, 'config_key' => 'pass_score', 'config_value' => '60'],
+        ]);
+
+        DB::table('classSection')->insert([
+            'id' => 1,
+            'class_section_id' => 1,
+            'class_section_name' => '1A',
+            'class_id' => 1,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('students')->insert([
+            'id' => 100,
+            'parent_id' => 10,
+            'firstname' => 'Kid',
+            'lastname' => 'User',
+            'school_id' => 1,
+            'age' => 10,
+            'gender' => 'M',
+            'photo_consent' => 1,
+            'year_of_registration' => '2025',
+            'is_active' => 1,
+        ]);
+
+        DB::table('student_class')->insert([
+            'id' => 1,
+            'student_id' => 100,
+            'class_section_id' => 1,
+            'school_year' => '2025-2026',
+            'semester' => 'Fall',
+            'is_event_only' => 0,
+        ]);
+
+        DB::table('semester_scores')->insert([
+            'id' => 1,
+            'student_id' => 100,
+            'school_id' => 1,
+            'class_section_id' => 1,
+            'semester' => 'fall',
+            'school_year' => '2025-2026',
+            'semester_score' => 92,
+        ]);
+
+        $service = new ScorePredictorService(
+            new ScorePredictorDataService(),
+            new ScorePredictorRiskService()
+        );
+
+        $result = $service->report('2025-2026', 1);
+
+        $this->assertSame('2025-2026', $result['school_year']);
+        $this->assertCount(1, $result['students']);
+        $this->assertSame(100, $result['students'][0]['student_id']);
+    }
+}
diff --git a/tests/Unit/Services/Scores/ScoreTermServiceTest.php b/tests/Unit/Services/Scores/ScoreTermServiceTest.php
new file mode 100644
index 00000000..8c3a6093
--- /dev/null
+++ b/tests/Unit/Services/Scores/ScoreTermServiceTest.php
@@ -0,0 +1,38 @@
+<?php
+
+namespace Tests\Unit\Services\Scores;
+
+use App\Services\Scores\ScoreTermService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class ScoreTermServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_semester_and_school_year_fallback_to_configuration(): void
+    {
+        DB::table('configuration')->insert([
+            ['config_key' => 'semester', 'config_value' => 'Fall'],
+            ['config_key' => 'school_year', 'config_value' => '2025-2026'],
+        ]);
+
+        $service = new ScoreTermService();
+
+        $this->assertSame('Fall', $service->semesterLabel(null));
+        $this->assertSame('2025-2026', $service->schoolYear(null));
+    }
+
+    public function test_normalize_and_variants(): void
+    {
+        $service = new ScoreTermService();
+
+        $this->assertSame('fall', $service->normalizeSemester('Semester 1'));
+        $this->assertSame('spring', $service->normalizeSemester('2nd Semester'));
+
+        $variants = $service->semesterVariants('Fall');
+        $this->assertContains('First Semester', $variants);
+        $this->assertContains('Semester 1', $variants);
+    }
+}
diff --git a/tests/Unit/Services/Scores/SemesterScoreServiceTest.php b/tests/Unit/Services/Scores/SemesterScoreServiceTest.php
new file mode 100644
index 00000000..c699cf76
--- /dev/null
+++ b/tests/Unit/Services/Scores/SemesterScoreServiceTest.php
@@ -0,0 +1,107 @@
+<?php
+
+namespace Tests\Unit\Services\Scores;
+
+use App\Services\Scores\SemesterScoreService;
+use App\Services\Scores\AttendanceCalculator;
+use App\Services\Scores\HomeworkCalculator;
+use App\Services\Scores\ProjectCalculator;
+use App\Services\Scores\QuizCalculator;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class SemesterScoreServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_update_student_scores_upserts_semester_scores(): void
+    {
+        DB::table('midterm_exam')->insert([
+            'student_id' => 1,
+            'school_id' => 'SCH1',
+            'class_section_id' => 4,
+            'updated_by' => 99,
+            'score' => 88,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = new SemesterScoreService(
+            new FakeAttendanceCalculator(),
+            new FakeHomeworkCalculator(),
+            new FakeQuizCalculator(),
+            new FakeProjectCalculator()
+        );
+
+        $service->updateStudentScores([
+            'student_id' => 1,
+            'school_id' => 'SCH1',
+            'class_section_id' => 4,
+            'updated_by' => 99,
+        ], 'Fall', '2025-2026');
+
+        $row = DB::table('semester_scores')->where([
+            'student_id' => 1,
+            'class_section_id' => 4,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ])->first();
+
+        $this->assertNotNull($row);
+        $this->assertSame(95.0, (float) $row->attendance_score);
+        $this->assertSame(80.0, (float) $row->homework_avg);
+        $this->assertSame(90.0, (float) $row->quiz_avg);
+        $this->assertSame(100.0, (float) $row->project_avg);
+        $this->assertSame(84.0, (float) $row->ptap_score);
+        $this->assertSame(88.0, (float) $row->midterm_exam_score);
+        $this->assertSame(88.6, (float) $row->semester_score);
+    }
+}
+
+class FakeAttendanceCalculator extends AttendanceCalculator
+{
+    public function __construct()
+    {
+    }
+
+    public function calculate(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): array
+    {
+        return ['attendance_score' => 95.0];
+    }
+}
+
+class FakeHomeworkCalculator extends HomeworkCalculator
+{
+    public function __construct()
+    {
+    }
+
+    public function calculate(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): array
+    {
+        return ['homework_avg' => 80.0];
+    }
+}
+
+class FakeQuizCalculator extends QuizCalculator
+{
+    public function calculate(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): array
+    {
+        return ['quiz_avg' => 90.0];
+    }
+}
+
+class FakeProjectCalculator extends ProjectCalculator
+{
+    public function __construct()
+    {
+    }
+
+    public function calculate(int $studentId, string $semester, string $schoolYear, ?int $classSectionId = null): array
+    {
+        return [
+            'project_avg' => 100.0,
+            'participation_score' => 70.0,
+        ];
+    }
+}
diff --git a/tests/Unit/Services/Semesters/SemesterConfigServiceTest.php b/tests/Unit/Services/Semesters/SemesterConfigServiceTest.php
new file mode 100644
index 00000000..9f1976e5
--- /dev/null
+++ b/tests/Unit/Services/Semesters/SemesterConfigServiceTest.php
@@ -0,0 +1,27 @@
+<?php
+
+namespace Tests\Unit\Services\Semesters;
+
+use App\Services\Semesters\SemesterConfigService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class SemesterConfigServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_reads_dates_from_configuration(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'fall_semester_start', 'config_value' => '2025-09-01'],
+            ['id' => 2, 'config_key' => 'spring_semester_start', 'config_value' => '2026-01-20'],
+            ['id' => 3, 'config_key' => 'last_school_day', 'config_value' => '2026-06-01'],
+        ]);
+
+        $service = new SemesterConfigService();
+        $this->assertSame('2025-09-01', $service->getFallStart()?->format('Y-m-d'));
+        $this->assertSame('2026-01-20', $service->getSpringStart()?->format('Y-m-d'));
+        $this->assertSame('2026-06-01', $service->getLastSchoolDay()?->format('Y-m-d'));
+    }
+}
diff --git a/tests/Unit/Services/Semesters/SemesterRangeServiceTest.php b/tests/Unit/Services/Semesters/SemesterRangeServiceTest.php
new file mode 100644
index 00000000..58400bff
--- /dev/null
+++ b/tests/Unit/Services/Semesters/SemesterRangeServiceTest.php
@@ -0,0 +1,46 @@
+<?php
+
+namespace Tests\Unit\Services\Semesters;
+
+use App\Services\SemesterRangeService;
+use App\Services\Semesters\SemesterConfigService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class SemesterRangeServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_get_school_year_range_falls_back_when_config_missing(): void
+    {
+        $service = new SemesterRangeService(new SemesterConfigService());
+        [$start, $end] = $service->getSchoolYearRange('2025-2026');
+
+        $this->assertSame('2025-09-01', $start);
+        $this->assertSame('2026-06-30', $end);
+    }
+
+    public function test_get_semester_for_date_uses_config_dates(): void
+    {
+        DB::table('configuration')->insert([
+            ['id' => 1, 'config_key' => 'fall_semester_start', 'config_value' => '2025-09-01'],
+            ['id' => 2, 'config_key' => 'spring_semester_start', 'config_value' => '2026-01-20'],
+            ['id' => 3, 'config_key' => 'last_school_day', 'config_value' => '2026-06-01'],
+        ]);
+
+        $service = new SemesterRangeService(new SemesterConfigService());
+        $semester = $service->getSemesterForDate('2025-10-01');
+
+        $this->assertSame('Fall', $semester);
+    }
+
+    public function test_normalize_semester(): void
+    {
+        $service = new SemesterRangeService(new SemesterConfigService());
+
+        $this->assertSame('Fall', $service->normalizeSemester('fall'));
+        $this->assertSame('Spring', $service->normalizeSemester('SPRING'));
+        $this->assertSame('', $service->normalizeSemester('winter'));
+    }
+}
diff --git a/tests/Unit/Services/Users/LoginActivityServiceTest.php b/tests/Unit/Services/Users/LoginActivityServiceTest.php
new file mode 100644
index 00000000..12f899a5
--- /dev/null
+++ b/tests/Unit/Services/Users/LoginActivityServiceTest.php
@@ -0,0 +1,45 @@
+<?php
+
+namespace Tests\Unit\Services\Users;
+
+use App\Services\Users\LoginActivityService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class LoginActivityServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_returns_paginated_payload(): void
+    {
+        DB::table('login_activity')->insert([
+            'user_id' => 1,
+            'email' => 'user@example.com',
+            'login_time' => '2025-01-02 09:00:00',
+            'logout_time' => null,
+            'ip_address' => '10.0.0.1',
+            'user_agent' => 'TestAgent',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('login_activity')->insert([
+            'user_id' => 1,
+            'email' => 'user@example.com',
+            'login_time' => '2025-01-01 09:00:00',
+            'logout_time' => null,
+            'ip_address' => '10.0.0.2',
+            'user_agent' => 'TestAgent',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = app(LoginActivityService::class);
+        $payload = $service->list(1, 2);
+
+        $this->assertSame(2, $payload['pagination']['total']);
+        $this->assertSame(2, $payload['pagination']['currentPage']);
+        $this->assertSame('10.0.0.2', $payload['activities'][0]['ip_address']);
+    }
+}
diff --git a/tests/Unit/Services/Users/UserEventServiceTest.php b/tests/Unit/Services/Users/UserEventServiceTest.php
new file mode 100644
index 00000000..abb925b8
--- /dev/null
+++ b/tests/Unit/Services/Users/UserEventServiceTest.php
@@ -0,0 +1,52 @@
+<?php
+
+namespace Tests\Unit\Services\Users;
+
+use App\Services\EmailService;
+use App\Services\Users\UserEventService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Mockery;
+use Tests\TestCase;
+
+class UserEventServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_handle_new_account_sends_email(): void
+    {
+        $emailService = Mockery::mock(EmailService::class);
+        $emailService->shouldReceive('send')
+            ->once()
+            ->with(
+                'user@example.com',
+                'Welcome to Al Rahma Sunday School!',
+                Mockery::type('string'),
+                'registration'
+            )
+            ->andReturn(true);
+
+        $service = new UserEventService($emailService);
+
+        $result = $service->handleNewAccountAdded([
+            'firstname' => 'Test',
+            'lastname' => 'User',
+            'email' => 'user@example.com',
+        ]);
+
+        $this->assertTrue($result);
+    }
+
+    public function test_handle_new_account_requires_email(): void
+    {
+        $emailService = Mockery::mock(EmailService::class);
+        $emailService->shouldNotReceive('send');
+
+        $service = new UserEventService($emailService);
+        $result = $service->handleNewAccountAdded([
+            'firstname' => 'Test',
+            'lastname' => 'User',
+        ]);
+
+        $this->assertFalse($result);
+    }
+}
diff --git a/tests/Unit/Services/Users/UserListServiceTest.php b/tests/Unit/Services/Users/UserListServiceTest.php
new file mode 100644
index 00000000..565d7a42
--- /dev/null
+++ b/tests/Unit/Services/Users/UserListServiceTest.php
@@ -0,0 +1,73 @@
+<?php
+
+namespace Tests\Unit\Services\Users;
+
+use App\Models\User;
+use App\Services\Users\UserListService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Tests\TestCase;
+
+class UserListServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_list_includes_roles_and_second_parent_flag(): void
+    {
+        DB::table('roles')->insert([
+            'id' => 5,
+            'name' => 'Parent',
+            'slug' => 'parent',
+            'description' => 'Parent role',
+            'dashboard_route' => 'parent/dashboard',
+            'priority' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Jane',
+            'lastname' => 'Doe',
+            'cellphone' => '5551112222',
+            'email' => 'second.parent@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 5,
+        ]);
+
+        DB::table('parents')->insert([
+            'secondparent_firstname' => 'Jane',
+            'secondparent_lastname' => 'Doe',
+            'secondparent_gender' => 'Female',
+            'secondparent_email' => 'second.parent@example.com',
+            'secondparent_phone' => '5551112222',
+            'firstparent_id' => 10,
+            'secondparent_id' => 11,
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $service = app(UserListService::class);
+        $rows = $service->list('id', 'asc');
+
+        $this->assertCount(1, $rows);
+        $this->assertSame('second.parent@example.com', $rows[0]['user']['email']);
+        $this->assertSame(['Parent'], $rows[0]['roles']);
+        $this->assertSame('Yes', $rows[0]['second_from_parents']);
+    }
+}
diff --git a/tests/Unit/Services/Users/UserManagementServiceTest.php b/tests/Unit/Services/Users/UserManagementServiceTest.php
new file mode 100644
index 00000000..a8eb0782
--- /dev/null
+++ b/tests/Unit/Services/Users/UserManagementServiceTest.php
@@ -0,0 +1,153 @@
+<?php
+
+namespace Tests\Unit\Services\Users;
+
+use App\Models\User;
+use App\Services\Users\UserEventService;
+use App\Services\Users\UserManagementService;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Facades\DB;
+use Mockery;
+use Tests\TestCase;
+
+class UserManagementServiceTest extends TestCase
+{
+    use RefreshDatabase;
+
+    public function test_create_persists_user_and_role_and_sends_welcome(): void
+    {
+        DB::table('roles')->insert([
+            'id' => 1,
+            'name' => 'Parent',
+            'slug' => 'parent',
+            'description' => 'Parent role',
+            'dashboard_route' => 'parent/dashboard',
+            'priority' => 1,
+            'is_active' => 1,
+        ]);
+
+        $eventService = Mockery::mock(UserEventService::class);
+        $eventService->shouldReceive('handleNewAccountAdded')
+            ->once()
+            ->andReturn(true);
+
+        $service = new UserManagementService($eventService);
+
+        $result = $service->create([
+            'firstname' => 'New',
+            'lastname' => 'User',
+            'cellphone' => '5554443333',
+            'email' => 'new.user@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => true,
+            'role_id' => 1,
+            'password' => 'secret123',
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $this->assertTrue($result['ok']);
+        $this->assertInstanceOf(User::class, $result['user']);
+        $this->assertDatabaseHas('users', [
+            'email' => 'new.user@example.com',
+            'firstname' => 'New',
+            'lastname' => 'User',
+        ]);
+        $this->assertDatabaseHas('user_roles', [
+            'user_id' => $result['user']->id,
+            'role_id' => 1,
+        ]);
+    }
+
+    public function test_update_changes_user_fields(): void
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Test',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'test@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        $eventService = Mockery::mock(UserEventService::class);
+        $service = new UserManagementService($eventService);
+
+        $result = $service->update(1, [
+            'firstname' => 'Updated',
+            'email' => 'updated@example.com',
+            'accept_school_policy' => false,
+        ]);
+
+        $this->assertTrue($result['ok']);
+        $this->assertDatabaseHas('users', [
+            'id' => 1,
+            'firstname' => 'Updated',
+            'email' => 'updated@example.com',
+            'accept_school_policy' => 0,
+        ]);
+    }
+
+    public function test_delete_removes_user_and_roles(): void
+    {
+        DB::table('users')->insert([
+            'id' => 1,
+            'school_id' => 1,
+            'firstname' => 'Test',
+            'lastname' => 'User',
+            'cellphone' => '5555555555',
+            'email' => 'test@example.com',
+            'address_street' => '123 Main',
+            'city' => 'City',
+            'state' => 'ST',
+            'zip' => '12345',
+            'accept_school_policy' => 1,
+            'is_verified' => 1,
+            'status' => 'Active',
+            'is_suspended' => 0,
+            'failed_attempts' => 0,
+            'password' => bcrypt('secret'),
+            'semester' => 'Fall',
+            'school_year' => '2025-2026',
+        ]);
+
+        DB::table('roles')->insert([
+            'id' => 1,
+            'name' => 'Parent',
+            'slug' => 'parent',
+            'description' => 'Parent role',
+            'dashboard_route' => 'parent/dashboard',
+            'priority' => 1,
+            'is_active' => 1,
+        ]);
+
+        DB::table('user_roles')->insert([
+            'user_id' => 1,
+            'role_id' => 1,
+        ]);
+
+        $eventService = Mockery::mock(UserEventService::class);
+        $service = new UserManagementService($eventService);
+
+        $result = $service->delete(1);
+
+        $this->assertTrue($result['ok']);
+        $this->assertDatabaseMissing('users', ['id' => 1]);
+        $this->assertDatabaseMissing('user_roles', ['user_id' => 1]);
+    }
+}