<?php

namespace App\Http\Controllers\Api;

use App\Models\Configuration;
use App\Models\WhatsappGroupLink;
use App\Models\WhatsappGroupMembership;
use App\Models\ClassSection;
use App\Models\Student;
use App\Models\User;
use App\Models\Enrollment;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Log;
use Symfony\Component\HttpFoundation\Response;

class WhatsappController extends BaseApiController
{
    protected WhatsappGroupLink $link;
    protected WhatsappGroupMembership $membership;
    protected Configuration $config;
    protected ClassSection $classSection;
    protected Student $student;
    protected User $user;
    protected Enrollment $enrollment;
    protected string $schoolYear;
    protected string $semester;

    public function __construct()
    {
        parent::__construct();
        $this->link         = model(WhatsappGroupLink::class);
        $this->membership   = model(WhatsappGroupMembership::class);
        $this->config       = model(Configuration::class);
        $this->classSection = model(ClassSection::class);
        $this->student      = model(Student::class);
        $this->user         = model(User::class);
        $this->enrollment   = model(Enrollment::class);
        $this->schoolYear        = (string) ($this->config->getConfig('school_year') ?? '');
        $this->semester          = (string) ($this->config->getConfig('semester') ?? '');
    }

    public function links()
    {
        try {
            $links = $this->link->newQuery()
                ->where('school_year', $this->schoolYear)
                ->where('semester', $this->semester)
                ->orderBy('class_section_name', 'ASC')
                ->get()
                ->getResultArray();

            return $this->success($links, 'WhatsApp links retrieved successfully');
        } catch (\Throwable $e) {
            log_message('error', 'WhatsApp links error: ' . $e->getMessage());
            return $this->respondError('Failed to retrieve WhatsApp links', Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

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

        $rules = [
            'class_section_id' => 'required|integer',
            'invite_link'      => 'required|string',
            'active'           => 'nullable|in:0,1',
        ];

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

        $sectionId   = (int) $payload['class_section_id'];
        $sectionName = trim((string) ($payload['class_section_name'] ?? ''));
        $inviteLink  = trim((string) $payload['invite_link']);
        $active      = isset($payload['active']) ? (int) $payload['active'] : 1;

        if ($inviteLink === '') {
            return $this->error('Invite link is required', Response::HTTP_UNPROCESSABLE_ENTITY);
        }

        try {
            $existing = $this->link->where([
                'class_section_id' => $sectionId,
                'school_year'      => $this->schoolYear,
                'semester'         => $this->semester,
            ])->first();

            // Resolve display name if not provided
            if ($sectionName === '') {
                $row = $this->link->getLinkForSection($sectionId, $this->schoolYear, $this->semester);
                $sectionName = $row['class_section_name'] ?? '';
                if ($sectionName === '') {
                    $sectionName = $this->classSection->getClassSectionNameBySectionId($sectionId) ?? ('Section ' . $sectionId);
                }
            }

            $linkData = [
                'class_section_id'   => $sectionId,
                'class_section_name' => $sectionName,
                'invite_link'        => $inviteLink,
                'active'             => $active ? 1 : 0,
                'school_year'        => $this->schoolYear,
                'semester'           => $this->semester,
            ];

            if ($existing) {
                $linkId = (int) $existing['id'];
                $this->link->update($linkId, $linkData);
            } else {
                $linkId = (int) $this->link->insert($linkData);
            }

            if (!$linkId) {
                return $this->respondError('Failed to save WhatsApp link', Response::HTTP_INTERNAL_SERVER_ERROR);
            }

            $link = $this->link->find($linkId);
            return $this->success($link, 'WhatsApp link saved successfully');
        } catch (\Throwable $e) {
            log_message('error', 'WhatsApp link save error: ' . $e->getMessage());
            return $this->respondError('Failed to save WhatsApp link', Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

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

        $sid = (int) ($payload['class_section_id'] ?? 0);
        $primaryId = (int) ($payload['primary_id'] ?? 0);
        $secondId = (int) ($payload['second_id'] ?? 0);

        $isChecked = static function ($v): bool {
            if (is_array($v)) {
                foreach ($v as $one) {
                    if ($one === '1' || strtolower((string) $one) === 'on') return true;
                }
                return false;
            }
            return ($v === '1' || strtolower((string) $v) === 'on');
        };

        $primaryValueRaw = $payload['primary_member'] ?? null;
        $secondValueRaw = $payload['second_member'] ?? null;

        if ($sid <= 0) {
            return $this->respondError('Invalid class section.', Response::HTTP_BAD_REQUEST);
        }

        $schoolYear = trim((string) ($payload['school_year'] ?? $this->schoolYear ?? ''));
        $semester = trim((string) ($payload['semester'] ?? $this->semester ?? ''));

        $verifiedBy = $this->getCurrentUserId();

        try {
            $saved = [];

            if ($primaryId > 0) {
                $isMember = $isChecked($primaryValueRaw);
                $id = $this->membership->upsertMembership($sid, $schoolYear, $semester, 'primary', $primaryId, $isMember, $verifiedBy);
                if ($id > 0) {
                    $saved[] = 'primary=' . $primaryId . ':' . ($isMember ? '1' : '0');
                }
            }

            if ($secondId > 0) {
                $isMember = $isChecked($secondValueRaw);
                $id = $this->membership->upsertMembership($sid, $schoolYear, $semester, 'second', $secondId, $isMember, $verifiedBy);
                if ($id > 0) {
                    $saved[] = 'second=' . $secondId . ':' . ($isMember ? '1' : '0');
                }
            }

            if (empty($saved)) {
                return $this->respondError('Nothing to save (missing parent IDs).', Response::HTTP_BAD_REQUEST);
            }

            return $this->success([
                'saved' => $saved,
                'term' => ['school_year' => $schoolYear, 'semester' => $semester],
            ], 'Membership updated successfully');
        } catch (\Throwable $e) {
            Log::error('Failed to update WhatsApp membership: ' . $e->getMessage());
            return $this->respondError('Failed to save membership.', Response::HTTP_INTERNAL_SERVER_ERROR);
        }
    }

    /**
     * GET /api/v1/whatsapp/index
     * Get initial data for WhatsApp management page
     */
    public function index()
    {
        [$parents, $sections] = $this->prepareIndexData();

        // Build links map
        $links = $this->link->getAllForTerm($this->schoolYear, $this->semester);
        $linksBySection = [];
        foreach ($links as $l) {
            $linksBySection[(int) $l['class_section_id']] = $l;
        }

        return $this->success([
            'sections' => $sections,
            'parents' => $parents,
            'linksBySection' => $linksBySection,
            'schoolYear' => $this->schoolYear,
            'semester' => $this->semester,
        ], 'WhatsApp management data retrieved successfully');
    }

    /**
     * POST /api/v1/whatsapp/send-invites
     * Send invites in three modes: 'parents' | 'class' | 'all'
     */
    public function sendInvites()
    {
        $data = $this->payloadData();
        $mode = trim((string) ($data['mode'] ?? ''));
        $parentIdsPicked = array_map('intval', (array) ($data['parent_ids'] ?? []));
        $rawClassId = $data['class_section_id'] ?? null;
        $classSectionId = ($rawClassId === '' || $rawClassId === null) ? 0 : (int) $rawClassId;

        if (!in_array($mode, ['parents', 'class', 'all'], true)) {
            return $this->respondError('Invalid mode.', Response::HTTP_BAD_REQUEST);
        }

        if ($mode === 'parents' && empty(array_filter($parentIdsPicked))) {
            return $this->respondError('Please select at least one parent.', Response::HTTP_BAD_REQUEST);
        }

        if ($mode === 'class' && $classSectionId <= 0) {
            return $this->respondError('Please select a class/section.', Response::HTTP_BAD_REQUEST);
        }

        // Load all links for the term once
        $links = $this->link->getAllForTerm($this->schoolYear, $this->semester);
        $linkBySection = [];
        foreach ($links as $l) {
            $cid = (int) ($l['class_section_id'] ?? 0);
            if ($cid) $linkBySection[$cid] = $l;
        }

        // Build per-family bundles
        $payloads = [];

        if ($mode === 'parents') {
            foreach ($parentIdsPicked as $pickedId) {
                if ($pickedId <= 0) continue;
                $bundle = $this->bundleForSingleParent($pickedId, $linkBySection);
                if ($bundle && !empty($bundle['emails']) && !empty($bundle['links'])) {
                    $payloads[] = $bundle;
                }
            }
        } elseif ($mode === 'class') {
            $bundles = $this->bundleForSingleClass($classSectionId, $linkBySection);
            foreach ($bundles as $b) {
                if (!empty($b['emails']) && !empty($b['links'])) {
                    $payloads[] = $b;
                }
            }
        } else { // 'all'
            $bundles = $this->bundlesForAllParentsAllClasses($linkBySection);
            foreach ($bundles as $b) {
                if (!empty($b['emails']) && !empty($b['links'])) {
                    $payloads[] = $b;
                }
            }
        }

        if (empty($payloads)) {
            return $this->respondError('No recipients found (missing links or emails).', Response::HTTP_BAD_REQUEST);
        }

        // Consolidate per-student bundles into one bundle per parent
        $normEmailsList = static function (array $list): array {
            $out = [];
            foreach ($list as $e) {
                $e = strtolower(trim((string) $e));
                if ($e !== '' && filter_var($e, FILTER_VALIDATE_EMAIL)) {
                    $out[$e] = true;
                }
            }
            return array_keys($out);
        };

        $mergeUniqueList = static function (array $a, array $b): array {
            $map = [];
            foreach (array_merge($a, $b) as $v) {
                $k = is_array($v) ? md5(json_encode($v)) : (string) $v;
                $map[$k] = $v;
            }
            return array_values($map);
        };

        $mergeSections = static function (array $A, array $B): array {
            $byKey = [];
            $put = static function (&$byKey, $row) {
                if (is_array($row)) {
                    $id = $row['class_section_id'] ?? null;
                    $name = $row['class_section_name'] ?? null;
                    $key = $id !== null ? ('id:' . (int) $id) : ('name:' . (string) $name);
                    $byKey[$key] = $row;
                } else {
                    $byKey['name:' . (string) $row] = $row;
                }
            };
            foreach ($A as $r) $put($byKey, $r);
            foreach ($B as $r) $put($byKey, $r);
            return array_values($byKey);
        };

        $mergeLinks = static function (array $A, array $B): array {
            $index = [];
            $add = static function (&$index, $item) {
                if (is_array($item)) {
                    $key = (isset($item['class_section_id']) && $item['class_section_id'] !== null)
                        ? 'id:' . (int) $item['class_section_id']
                        : ('url:' . (string) ($item['invite_link'] ?? json_encode($item)));
                    $index[$key] = $item;
                } else {
                    $index['url:' . (string) $item] = $item;
                }
            };
            foreach ($A as $it) $add($index, $it);
            foreach ($B as $it) $add($index, $it);
            return array_values($index);
        };

        $grouped = [];
        foreach ($payloads as $b) {
            $parent = $b['parent'] ?? [];
            $pid = (int) ($parent['id'] ?? 0);
            $primary = $normEmailsList((array) ($b['emails'] ?? []));
            $groupKey = $pid > 0 ? ('pid:' . $pid) : ('mail:' . implode(',', $primary));

            if (!isset($grouped[$groupKey])) {
                $grouped[$groupKey] = [
                    'parent' => $parent,
                    'emails' => $primary,
                    'sections' => (array) ($b['sections'] ?? []),
                    'links' => (array) ($b['links'] ?? []),
                    'teachers' => (array) ($b['teachers'] ?? []),
                    'items' => (array) ($b['items'] ?? []),
                ];
            } else {
                $grouped[$groupKey]['parent'] = !empty($parent) ? $parent : $grouped[$groupKey]['parent'];
                $grouped[$groupKey]['emails'] = $normEmailsList(array_merge($grouped[$groupKey]['emails'], $primary));
                $grouped[$groupKey]['sections'] = $mergeSections($grouped[$groupKey]['sections'], (array) ($b['sections'] ?? []));
                $grouped[$groupKey]['links'] = $mergeLinks($grouped[$groupKey]['links'], (array) ($b['links'] ?? []));
                $grouped[$groupKey]['teachers'] = $mergeUniqueList($grouped[$groupKey]['teachers'], (array) ($b['teachers'] ?? []));
                $grouped[$groupKey]['items'] = $mergeLinks($grouped[$groupKey]['items'], (array) ($b['items'] ?? []));
            }
        }

        $payloads = array_values($grouped);

        $norm = static function (array $list): array {
            $out = [];
            foreach ($list as $e) {
                $e = strtolower(trim((string) $e));
                if ($e !== '' && filter_var($e, FILTER_VALIDATE_EMAIL)) {
                    $out[$e] = true;
                }
            }
            return array_keys($out);
        };

        $getSecondaryEmails = function (array $bundle) use ($norm) {
            $collected = [];
            if (!empty($bundle['emails_secondary'])) {
                $collected = array_merge($collected, (array) $bundle['emails_secondary']);
            }
            if (!empty($bundle['secondary_parents'])) {
                foreach ((array) $bundle['secondary_parents'] as $sp) {
                    if (!empty($sp['email'])) $collected[] = $sp['email'];
                }
            }
            $p = $bundle['parent'] ?? [];
            foreach (['secondary_email', 'secondparent_email', 'sec_email', 'email_secondary'] as $k) {
                if (!empty($p[$k])) $collected[] = $p[$k];
            }
            if (!empty($p['secondparent']['email'])) $collected[] = $p['secondparent']['email'];

            try {
                $primaryId = (int) ($p['id'] ?? 0);
                if ($primaryId > 0) {
                    $row = DB::table('parents')
                        ->select('secondparent_email')
                        ->where('firstparent_id', $primaryId)
                        ->orderBy('updated_at', 'DESC')
                        ->first();
                    if ($row && !empty($row->secondparent_email)) {
                        $collected[] = $row->secondparent_email;
                    }
                }
            } catch (\Throwable $e) {
                Log::error('Secondary email DB lookup failed: ' . $e->getMessage());
            }

            return $norm($collected);
        };

        // Trigger one event per family
        $triggered = 0;
        foreach ($payloads as $b) {
            try {
                $primaryEmails = $norm((array) ($b['emails'] ?? []));
                $secondaryEmails = $getSecondaryEmails($b);

                $to = $primaryEmails;
                $cc = [];

                if (!empty($primaryEmails) && !empty($secondaryEmails)) {
                    $cc = array_values(array_diff($secondaryEmails, $primaryEmails));
                } elseif (empty($primaryEmails) && !empty($secondaryEmails)) {
                    $to = $secondaryEmails;
                }

                if (empty($to)) {
                    Log::warning('Skipping whatsapp_invites.send: no recipient email(s) for parent_id ' . ($b['parent']['id'] ?? null));
                    continue;
                }

                Event::dispatch('whatsapp_invites.send', [
                    'parent' => $b['parent'] ?? null,
                    'sections' => $b['sections'] ?? [],
                    'schoolYear' => $this->schoolYear,
                    'semester' => $this->semester,
                    'links' => $b['links'] ?? [],
                    'teachers' => $b['teachers'] ?? [],
                    'to_emails' => $to,
                    'cc_emails' => $cc,
                ]);

                $triggered++;
            } catch (\Throwable $e) {
                Log::error('whatsapp_invites.send failed: ' . $e->getMessage());
            }
        }

        return $this->success([
            'triggered' => $triggered,
            'total' => count($payloads),
        ], "Invite processing started for {$triggered} recipient group(s).");
    }

    /**
     * GET /api/v1/whatsapp/parent-contacts
     * Get parent contacts list
     */
    public function parentContacts()
    {
        $schoolYear = $this->schoolYear ?? (string) ($this->request->getGet('school_year') ?? '');
        $semester = $this->semester ?? (string) ($this->request->getGet('semester') ?? '');

        $b = DB::table('parents sp')
            ->select([
                'sp.id as parents_row_id',
                'sp.firstparent_id as firstparent_id',
                'sp.secondparent_firstname as sp_firstname',
                'sp.secondparent_lastname as sp_lastname',
                'sp.secondparent_email as sp_email',
                'sp.secondparent_phone as sp_phone',
                'sp.school_year as sp_school_year',
                'sp.semester as sp_semester',
                'u.id as u_id',
                'u.firstname as u_firstname',
                'u.lastname as u_lastname',
                'u.email as u_email',
                'u.cellphone as u_phone',
                'u.school_year as u_school_year',
                'u.semester as u_semester',
            ])
            ->leftJoin('users u', 'u.id', '=', 'sp.firstparent_id');

        if ($schoolYear !== '') {
            $b->where('sp.school_year', $schoolYear);
        }
        if ($semester !== '') {
            $b->where('sp.semester', $semester);
        }

        $rows = $b->get();

        $contacts = [];
        foreach ($rows as $r) {
            if (!empty($r->u_id)) {
                $contacts[] = [
                    'firstname' => (string) ($r->u_firstname ?? ''),
                    'lastname' => (string) ($r->u_lastname ?? ''),
                    'email' => (string) ($r->u_email ?? ''),
                    'phone' => (string) ($r->u_phone ?? ''),
                    'type' => 'Primary Parent',
                ];
            }

            $hasSecond = !empty($r->sp_firstname) || !empty($r->sp_lastname) || !empty($r->sp_email) || !empty($r->sp_phone);
            if ($hasSecond) {
                $contacts[] = [
                    'firstname' => (string) ($r->sp_firstname ?? ''),
                    'lastname' => (string) ($r->sp_lastname ?? ''),
                    'email' => (string) ($r->sp_email ?? ''),
                    'phone' => (string) ($r->sp_phone ?? ''),
                    'type' => 'Second Parent',
                ];
            }
        }

        $contacts = array_values(array_filter($contacts, function ($c) {
            $name = trim(($c['firstname'] ?? '') . ($c['lastname'] ?? ''));
            $contact = trim(($c['phone'] ?? '') . ($c['email'] ?? ''));
            return $name !== '' || $contact !== '';
        }));

        usort($contacts, function ($a, $b) {
            $la = strtolower($a['lastname'] ?? '');
            $lb = strtolower($b['lastname'] ?? '');
            if ($la !== $lb) return $la <=> $lb;
            $fa = strtolower($a['firstname'] ?? '');
            $fb = strtolower($b['firstname'] ?? '');
            if ($fa !== $fb) return $fa <=> $fb;
            $ta = ($a['type'] ?? '') === 'Primary Parent' ? 0 : 1;
            $tb = ($b['type'] ?? '') === 'Primary Parent' ? 0 : 1;
            return $ta <=> $tb;
        });

        return $this->success([
            'contacts' => $contacts,
            'schoolYear' => $schoolYear,
            'semester' => $semester,
        ], 'Parent contacts retrieved successfully');
    }

    /**
     * GET /api/v1/whatsapp/parent-contacts-by-class
     * Get parent contacts grouped by class section
     */
    public function parentContactsByClass()
    {
        $schoolYear = $this->schoolYear ?? (string) ($this->request->getGet('school_year') ?? '');
        $semester = $this->semester ?? (string) ($this->request->getGet('semester') ?? '');

        // Get distinct class_section_id from student_class
        $csb = DB::table('student_class sc')
            ->select('sc.class_section_id', DB::raw('MAX(sc.semester) as semester'), DB::raw('MAX(sc.school_year) as school_year'));

        if ($schoolYear !== '') $csb->where('sc.school_year', $schoolYear);
        if ($semester !== '') $csb->where('sc.semester', $semester);

        $sections = $csb->groupBy('sc.class_section_id')
            ->orderBy('sc.class_section_id', 'ASC')
            ->get();

        $sectionIds = array_values(array_filter(array_unique($sections->pluck('class_section_id')->map(fn($id) => (int) $id)->toArray())));

        // Fetch names from classSection
        $namesById = [];
        if (!empty($sectionIds)) {
            $nb = DB::table('classSection')
                ->select('class_section_id', 'class_section_name')
                ->whereIn('class_section_id', $sectionIds)
                ->get();

            foreach ($nb as $row) {
                $namesById[(int) $row->class_section_id] = (string) ($row->class_section_name ?? '');
            }
        }

        $classSections = [];
        foreach ($sections as $s) {
            $sid = (int) ($s->class_section_id ?? 0);
            if (!$sid) continue;

            $classSections[$sid] = [
                'class_section_id' => $sid,
                'class_section_name' => $namesById[$sid] ?? ('Section ' . $sid),
                'semester' => (string) ($s->semester ?? ''),
                'school_year' => (string) ($s->school_year ?? ''),
                'description' => '',
                'main_teachers' => [],
                'teacher_assistants' => [],
                'parents' => [],
            ];
        }

        // Parents per class
        $pb = DB::table('student_class sc')
            ->select([
                'sc.class_section_id',
                'u.id as primary_id',
                'u.firstname as primary_firstname',
                'u.lastname as primary_lastname',
                'u.email as primary_email',
                'u.cellphone as primary_phone',
                'sp.id as second_id',
                'sp.secondparent_firstname as second_firstname',
                'sp.secondparent_lastname as second_lastname',
                'sp.secondparent_email as second_email',
                'sp.secondparent_phone as second_phone',
            ])
            ->join('students s', 's.id', '=', 'sc.student_id')
            ->join('users u', 'u.id', '=', 's.parent_id')
            ->leftJoin('parents sp', function ($join) {
                $join->on('sp.firstparent_id', '=', 'u.id')
                    ->whereColumn('sp.school_year', 'sc.school_year')
                    ->where(function ($q) {
                        $q->whereColumn('sp.semester', 'sc.semester')
                            ->orWhereNull('sp.semester')
                            ->orWhere('sp.semester', '');
                    });
            });

        if ($schoolYear !== '') $pb->where('sc.school_year', $schoolYear);
        if ($semester !== '') $pb->where('sc.semester', $semester);

        $rows = $pb->orderBy('sc.class_section_id', 'ASC')
            ->orderBy('u.lastname', 'ASC')
            ->orderBy('u.firstname', 'ASC')
            ->get();

        $seen = [];
        foreach ($rows as $r) {
            $sid = (int) ($r->class_section_id ?? 0);
            $pid = (int) ($r->primary_id ?? 0);
            if (!$sid || !$pid || !isset($classSections[$sid])) continue;

            $key = $sid . ':' . $pid;
            if (isset($seen[$key])) continue;
            $seen[$key] = true;

            $classSections[$sid]['parents'][] = [
                'class_section_id' => $sid,
                'primary_id' => $pid,
                'primary_name' => trim(($r->primary_lastname ?? '') . ', ' . ($r->primary_firstname ?? '')),
                'primary_phone' => (string) ($r->primary_phone ?? ''),
                'primary_email' => (string) ($r->primary_email ?? ''),
                'second_id' => (int) ($r->second_id ?? 0),
                'second_name' => trim(($r->second_lastname ?? '') . ', ' . ($r->second_firstname ?? '')),
                'second_phone' => (string) ($r->second_phone ?? ''),
                'second_email' => (string) ($r->second_email ?? ''),
                'primary_member' => null,
                'second_member' => null,
            ];
        }

        // Annotate membership flags
        try {
            $sectionIds = array_keys($classSections);
            $m = $this->membership->getBySectionsAndTerm($sectionIds, $schoolYear, $semester);
            foreach ($classSections as $sid => &$sec) {
                foreach ($sec['parents'] as &$p) {
                    $pk1 = sprintf('%d:primary:%d', (int) $p['class_section_id'], (int) $p['primary_id']);
                    if (isset($m[$pk1])) {
                        $p['primary_member'] = (int) ($m[$pk1]['is_member'] ?? 0);
                    }
                    $secondId = (int) ($p['second_id'] ?? 0);
                    if ($secondId > 0) {
                        $pk2 = sprintf('%d:second:%d', (int) $p['class_section_id'], $secondId);
                        if (isset($m[$pk2])) {
                            $p['second_member'] = (int) ($m[$pk2]['is_member'] ?? 0);
                        }
                    }
                }
                unset($p);
            }
            unset($sec);
        } catch (\Throwable $e) {
            // ignore membership annotation errors
        }

        // Teachers
        try {
            $tb = DB::table('teacher_class tc')
                ->select('tc.class_section_id', 'tc.position', 'u.firstname', 'u.lastname')
                ->leftJoin('users u', 'u.id', '=', 'tc.teacher_id');

            if ($schoolYear !== '') $tb->where('tc.school_year', $schoolYear);
            if ($semester !== '') $tb->where('tc.semester', $semester);

            $teachers = $tb->get();

            foreach ($teachers as $t) {
                $sid = (int) ($t->class_section_id ?? 0);
                if (!isset($classSections[$sid])) continue;

                $name = trim(($t->lastname ?? '') . ', ' . ($t->firstname ?? ''));
                $pos = strtolower((string) ($t->position ?? 'main'));

                if ($pos === 'ta' || $pos === 'assistant') {
                    $classSections[$sid]['teacher_assistants'][] = $name;
                } else {
                    $classSections[$sid]['main_teachers'][] = $name;
                }
            }
        } catch (\Throwable $e) {
            // ignore if table not present
        }

        foreach ($classSections as &$sec) {
            $sec['main_teachers'] = array_values(array_filter($sec['main_teachers'] ?? []));
            $sec['teacher_assistants'] = array_values(array_filter($sec['teacher_assistants'] ?? []));
            $sec['parents'] = array_values($sec['parents'] ?? []);
        }
        unset($sec);

        return $this->success([
            'classSections' => array_values($classSections),
        ], 'Parent contacts by class retrieved successfully');
    }

    /**
     * Build initial lists for the page
     */
    private function prepareIndexData(): array
    {
        [$yearAliases, $normalizedYear, $startYear] = $this->syAliases($this->schoolYear);
        $semAliases = $this->semAliases($this->semester);

        // Sections list
        $secQ = DB::table('student_class sc')
            ->select(DB::raw('DISTINCT sc.class_section_id'));

        $secQ->where(function ($q) use ($yearAliases, $normalizedYear, $startYear) {
            $q->whereIn('sc.school_year', $yearAliases)
                ->orWhereRaw("REPLACE(REPLACE(sc.school_year,'/','-'),'–','-') = ?", [$normalizedYear])
                ->orWhere('sc.school_year', (string) $startYear);
        });

        if (!empty($semAliases)) {
            $secQ->where(function ($q) use ($semAliases) {
                foreach ($semAliases as $i => $s) {
                    if ($i === 0) {
                        $q->whereRaw('LOWER(sc.semester) = ?', [strtolower($s)]);
                    } else {
                        $q->orWhereRaw('LOWER(sc.semester) = ?', [strtolower($s)]);
                    }
                }
                $q->orWhere('sc.semester', $this->semester);
            });
        } else {
            $secQ->where('sc.semester', $this->semester);
        }

        $secRows = $secQ->orderBy('sc.class_section_id', 'ASC')->get();

        // Fallback to enrollments
        if ($secRows->isEmpty()) {
            $secQ = DB::table('enrollments e')
                ->select(DB::raw('DISTINCT e.class_section_id'));

            $secQ->where(function ($q) use ($yearAliases, $normalizedYear, $startYear) {
                $q->whereIn('e.school_year', $yearAliases)
                    ->orWhereRaw("REPLACE(REPLACE(e.school_year,'/','-'),'–','-') = ?", [$normalizedYear])
                    ->orWhere('e.school_year', (string) $startYear);
            });

            if (!empty($semAliases)) {
                $secQ->where(function ($q) use ($semAliases) {
                    foreach ($semAliases as $i => $s) {
                        if ($i === 0) {
                            $q->whereRaw('LOWER(e.semester) = ?', [strtolower($s)]);
                        } else {
                            $q->orWhereRaw('LOWER(e.semester) = ?', [strtolower($s)]);
                        }
                    }
                    $q->orWhere('e.semester', $this->semester);
                });
            } else {
                $secQ->where('e.semester', $this->semester);
            }

            $secRows = $secQ->orderBy('e.class_section_id', 'ASC')->get();
        }

        $sections = [];
        foreach ($secRows as $r) {
            $cid = (int) ($r->class_section_id ?? 0);
            if (!$cid) continue;

            $linkRow = $this->link->getLinkForSection($cid, $this->schoolYear, $this->semester);
            $name = $this->classSection->getClassSectionNameBySectionId($cid) ?? ('Section ' . $cid);

            $sections[] = [
                'class_section_id' => $cid,
                'class_section_name' => $name,
            ];
        }

        // Parents list
        $pidQ = DB::table('student_class sc')
            ->select(DB::raw('DISTINCT s.parent_id'))
            ->leftJoin('students s', 's.id', '=', 'sc.student_id');

        $pidQ->where(function ($q) use ($yearAliases, $normalizedYear, $startYear) {
            $q->whereIn('sc.school_year', $yearAliases)
                ->orWhereRaw("REPLACE(REPLACE(sc.school_year,'/','-'),'–','-') = ?", [$normalizedYear])
                ->orWhere('sc.school_year', (string) $startYear);
        });

        if (!empty($semAliases)) {
            $pidQ->where(function ($q) use ($semAliases) {
                foreach ($semAliases as $i => $s) {
                    if ($i === 0) {
                        $q->whereRaw('LOWER(sc.semester) = ?', [strtolower($s)]);
                    } else {
                        $q->orWhereRaw('LOWER(sc.semester) = ?', [strtolower($s)]);
                    }
                }
                $q->orWhere('sc.semester', $this->semester);
            });
        } else {
            $pidQ->where('sc.semester', $this->semester);
        }

        $pidQ->whereNotNull('s.parent_id');

        $primaryIdRows = $pidQ->get();

        // Fallback to enrollments
        if ($primaryIdRows->isEmpty()) {
            $pidQ = DB::table('enrollments e')
                ->select(DB::raw('DISTINCT s.parent_id'))
                ->leftJoin('students s', 's.id', '=', 'e.student_id');

            $pidQ->where(function ($q) use ($yearAliases, $normalizedYear, $startYear) {
                $q->whereIn('e.school_year', $yearAliases)
                    ->orWhereRaw("REPLACE(REPLACE(e.school_year,'/','-'),'–','-') = ?", [$normalizedYear])
                    ->orWhere('e.school_year', (string) $startYear);
            });

            if (!empty($semAliases)) {
                $pidQ->where(function ($q) use ($semAliases) {
                    foreach ($semAliases as $i => $s) {
                        if ($i === 0) {
                            $q->whereRaw('LOWER(e.semester) = ?', [strtolower($s)]);
                        } else {
                            $q->orWhereRaw('LOWER(e.semester) = ?', [strtolower($s)]);
                        }
                    }
                    $q->orWhere('e.semester', $this->semester);
                });
            } else {
                $pidQ->where('e.semester', $this->semester);
            }

            $pidQ->whereNotNull('s.parent_id');
            $primaryIdRows = $pidQ->get();
        }

        $primaryIds = [];
        foreach ($primaryIdRows as $r) {
            $pid = (int) ($r->parent_id ?? 0);
            if ($pid) $primaryIds[$pid] = true;
        }
        $primaryIds = array_keys($primaryIds);

        $primaryProfiles = [];
        if (!empty($primaryIds)) {
            $primRows = DB::table('users')
                ->select('id', 'firstname', 'lastname', 'email')
                ->whereIn('id', $primaryIds)
                ->get();

            foreach ($primRows as $u) {
                $uid = (int) ($u->id ?? 0);
                if (!$uid) continue;

                $primaryProfiles[$uid] = [
                    'id' => $uid,
                    'firstname' => (string) ($u->firstname ?? ''),
                    'lastname' => (string) ($u->lastname ?? ''),
                    'email' => (string) ($u->email ?? ''),
                    'source' => 'users',
                ];
            }
        }

        // Second parents
        $secondaryProfiles = [];
        if (!empty($primaryIds)) {
            $secRows = DB::table('parents')
                ->select('id', 'firstparent_id', 'secondparent_firstname', 'secondparent_lastname', 'secondparent_email', 'secondparent_phone')
                ->whereIn('firstparent_id', $primaryIds)
                ->orderBy('updated_at', 'DESC')
                ->get();

            foreach ($secRows as $r) {
                $primaryId = (int) $r->firstparent_id;
                $secondaryProfiles[$primaryId] = [
                    'id' => (int) $r->id,
                    'firstname' => (string) $r->secondparent_firstname,
                    'lastname' => (string) $r->secondparent_lastname,
                    'email' => (string) $r->secondparent_email,
                    'phone' => (string) $r->secondparent_phone,
                    'source' => 'parents',
                ];
            }
        }

        // Merge + sort
        $parents = array_values($primaryProfiles);
        foreach ($secondaryProfiles as $sp) $parents[] = $sp;

        usort($parents, function ($a, $b) {
            $ln = strcasecmp($a['lastname'] ?? '', $b['lastname'] ?? '');
            if ($ln !== 0) return $ln;
            $fn = strcasecmp($a['firstname'] ?? '', $b['firstname'] ?? '');
            if ($fn !== 0) return $fn;
            $sa = ($a['source'] ?? '') === 'users' ? 0 : 1;
            $sb = ($b['source'] ?? '') === 'users' ? 0 : 1;
            return $sa <=> $sb;
        });

        return [$parents, $sections];
    }

    /**
     * School-year aliases
     */
    private function syAliases(string $schoolYear): array
    {
        $trim = trim($schoolYear);
        if (preg_match('/\b(20\d{2})\b/', $trim, $m)) {
            $start = (int) $m[1];
        } else {
            $start = (int) date('Y');
        }

        $end = $start + 1;
        $normalized = "{$start}-{$end}";
        $aliases = [
            $normalized,
            "{$start}/{$end}",
            "{$start}–{$end}",
            sprintf('%d-%02d', $start, $end % 100),
            (string) $start,
        ];

        return [array_values(array_unique($aliases)), $normalized, $start];
    }

    /**
     * Semester aliases
     */
    private function semAliases(string $semester): array
    {
        $s = strtolower(trim($semester));
        if ($s === 'fall') return ['fall', 'sem1', 'semester 1', '1', 'f'];
        if ($s === 'spring') return ['spring', 'sem2', 'semester 2', '2', 's'];
        if ($s === 'summer') return ['summer', 'sem3', '3'];
        return [$s];
    }

    /**
     * Bundle for single parent
     */
    private function bundleForSingleParent(int $pickedId, array $linkBySection): ?array
    {
        $isPrimary = (bool) DB::table('users')->where('id', $pickedId)->first();
        $primaryId = $pickedId;

        if (!$isPrimary) {
            $map = DB::table('parents')
                ->select('firstparent_id', 'id')
                ->where('id', $pickedId)
                ->first();

            if (!$map || empty($map->firstparent_id)) {
                return null;
            }
            $primaryId = (int) $map->firstparent_id;
        }

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

        if (!$p) return null;

        $sec = DB::table('parents')
            ->select('id', 'secondparent_firstname', 'secondparent_lastname', 'secondparent_email')
            ->where('firstparent_id', $primaryId)
            ->where('id', '>', 0)
            ->first();

        // Sections for this primary
        $secRows = DB::table('student_class sc')
            ->select(DB::raw('DISTINCT sc.class_section_id'))
            ->leftJoin('students s', 's.id', '=', 'sc.student_id')
            ->where('sc.school_year', $this->schoolYear)
            ->where('sc.semester', $this->semester)
            ->where('s.parent_id', $primaryId)
            ->get();

        $sections = [];
        $linksSet = [];

        foreach ($secRows as $r) {
            $cid = (int) ($r->class_section_id ?? 0);
            if (!$cid) continue;

            $link = (string) ($linkBySection[$cid]['invite_link'] ?? '');
            if ($link === '') continue;

            $sections[] = [
                'class_section_id' => $cid,
                'class_section_name' => (string) ($linkBySection[$cid]['class_section_name'] ?? ('Section ' . $cid)),
                'invite_link' => $link,
            ];

            $linksSet[$link] = true;
        }

        if (empty($sections)) return null;

        $emailsSet = [];
        if (!empty($p->email)) $emailsSet[$p->email] = true;
        if ($sec && !empty($sec->secondparent_email)) $emailsSet[$sec->secondparent_email] = true;

        if (empty($emailsSet)) return null;

        return [
            'parent' => [
                'id' => (int) $p->id,
                'firstname' => (string) ($p->firstname ?? ''),
                'lastname' => (string) ($p->lastname ?? ''),
                'email' => (string) ($p->email ?? ''),
                'source' => 'users',
            ],
            'secondary_parents' => $sec && !empty($sec->id) ? [[
                'id' => (int) $sec->id,
                'firstname' => (string) ($sec->secondparent_firstname ?? ''),
                'lastname' => (string) ($sec->secondparent_lastname ?? ''),
                'email' => (string) ($sec->secondparent_email ?? ''),
                'source' => 'parents',
            ]] : [],
            'sections' => $sections,
            'links' => array_keys($linksSet),
            'emails' => array_keys($emailsSet),
        ];
    }

    /**
     * Bundle for single class
     */
    private function bundleForSingleClass(int $classSectionId, array $linkBySection): array
    {
        $link = (string) ($linkBySection[$classSectionId]['invite_link'] ?? '');
        if ($link === '') return [];

        // Students in this class
        $stuRows = DB::table('student_class')
            ->select('student_id')
            ->where('school_year', $this->schoolYear)
            ->where('semester', $this->semester)
            ->where('class_section_id', $classSectionId)
            ->get();

        if ($stuRows->isEmpty()) return [];

        $studentIds = array_values(array_unique($stuRows->pluck('student_id')->map(fn($id) => (int) $id)->toArray()));

        // Map students -> primary parent id
        $pRows = DB::table('students')
            ->select('id', 'parent_id')
            ->whereIn('id', $studentIds)
            ->get();

        $parentIds = [];
        foreach ($pRows as $r) {
            $pid = (int) ($r->parent_id ?? 0);
            if ($pid) $parentIds[$pid] = true;
        }
        $parentIds = array_keys($parentIds);

        if (empty($parentIds)) return [];

        // Load primary parent profiles
        $primRows = DB::table('users')
            ->select('id', 'firstname', 'lastname', 'email')
            ->whereIn('id', $parentIds)
            ->get();

        $profiles = [];
        foreach ($primRows as $u) {
            $uid = (int) $u->id;
            $profiles[$uid] = [
                'id' => $uid,
                'firstname' => (string) ($u->firstname ?? ''),
                'lastname' => (string) ($u->lastname ?? ''),
                'email' => (string) ($u->email ?? ''),
                'source' => 'users',
            ];
        }

        // Second-parents
        $secRows = DB::table('parents')
            ->select('firstparent_id', 'id', 'secondparent_firstname', 'secondparent_lastname', 'secondparent_email')
            ->where('id', '>', 0)
            ->whereIn('firstparent_id', $parentIds)
            ->get();

        $secByPrimary = [];
        foreach ($secRows as $r) {
            $fp = (int) $r->firstparent_id;
            $secByPrimary[$fp] = [
                'id' => (int) ($r->id ?? 0),
                'firstname' => (string) ($r->secondparent_firstname ?? ''),
                'lastname' => (string) ($r->secondparent_lastname ?? ''),
                'email' => (string) ($r->secondparent_email ?? ''),
                'source' => 'parents',
            ];
        }

        // One bundle per primary parent
        $bundles = [];
        foreach ($parentIds as $pid) {
            $profile = $profiles[$pid] ?? null;
            if (!$profile) continue;

            $emails = [];
            if (!empty($profile['email'])) $emails[$profile['email']] = true;
            if (!empty($secByPrimary[$pid]['email'])) $emails[$secByPrimary[$pid]['email']] = true;

            if (empty($emails)) continue;

            $bundles[] = [
                'parent' => $profile,
                'secondary_parents' => !empty($secByPrimary[$pid]['id']) ? [$secByPrimary[$pid]] : [],
                'sections' => [[
                    'class_section_id' => $classSectionId,
                    'class_section_name' => (string) ($linkBySection[$classSectionId]['class_section_name'] ?? ('Section ' . $classSectionId)),
                    'invite_link' => $link,
                ]],
                'links' => [$link],
                'emails' => array_keys($emails),
            ];
        }

        return $bundles;
    }

    /**
     * Bundles for all parents all classes
     */
    private function bundlesForAllParentsAllClasses(array $linkBySection): array
    {
        $secRows = DB::table('student_class')
            ->select(DB::raw('DISTINCT class_section_id'))
            ->where('school_year', $this->schoolYear)
            ->where('semester', $this->semester)
            ->orderBy('class_section_id', 'ASC')
            ->get();

        $bundles = [];
        foreach ($secRows as $r) {
            $cid = (int) ($r->class_section_id ?? 0);
            if (!$cid) continue;

            $classBundles = $this->bundleForSingleClass($cid, $linkBySection);
            foreach ($classBundles as $b) {
                $bundles[] = $b;
            }
        }

        return $bundles;
    }
}