<?php

namespace App\Http\Controllers;

use App\Models\CandidaturaCertificacion;
use App\Models\Curso;
use App\Models\Leccion;
use App\Models\MovimientoMembresia;
use App\Models\Persona;
use App\Models\Resultado;
use App\Models\Role;
use App\Models\Sede;
use App\Models\User;
use App\Services\SensitiveDataAuditService;
use App\Services\CentralWorkInboxService;
use App\Services\UnifiedCalendarService;
use App\Support\InstitutionalContext;
use Carbon\Carbon;
use Barryvdh\DomPDF\Facade\Pdf;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Hash;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Validator;
use Illuminate\Validation\Rule;
use Illuminate\Validation\Rules\Password;
use Illuminate\Validation\ValidationException;

class AdminController extends Controller
{
    public function dashboard(InstitutionalContext $context, CentralWorkInboxService $inbox, UnifiedCalendarService $calendar)
    {
        $sedeId = $context->sedeId();
        $user = auth()->user();
        $pending = $context->can($user, 'bandeja.usar') ? $inbox->items($user, $sedeId, $context) : collect();
        $events = $context->can($user, 'calendario.usar')
            ? $calendar->events($user, $sedeId, now()->startOfDay(), now()->addDays(7)->endOfDay())->take(6)
            : collect();
        $metrics = [
            ['label' => 'Personas activas', 'value' => DB::table('sede_user')->where(['sede_id' => $sedeId, 'estatus' => 'ACTIVO'])->distinct('user_id')->count('user_id'), 'icon' => 'users', 'tone' => 'indigo', 'url' => route('admin.people')],
            ['label' => 'Aspirantes por revisar', 'value' => DB::table('solicitudes_admision as s')->join('convocatorias_admision as c', 'c.id', '=', 's.convocatoria_id')->where('c.sede_id', $sedeId)->where('s.estatus', 'EN_REVISION')->count(), 'icon' => 'user-plus', 'tone' => 'amber', 'url' => route('admin.admisiones.index', ['seccion' => 'aspirantes'])],
            ['label' => 'Inscripciones activas', 'value' => DB::table('inscripciones_academicas as i')->join('periodos_escolares as p', 'p.id', '=', 'i.periodo_escolar_id')->where('p.sede_id', $sedeId)->whereIn('i.estatus', ['ACTIVA', 'INSCRITO'])->count(), 'icon' => 'graduation', 'tone' => 'emerald', 'url' => route('admin.universidad.inscripciones.index')],
            ['label' => 'Pendientes asignados', 'value' => $pending->count(), 'icon' => 'inbox', 'tone' => 'violet', 'url' => route('work-inbox.index')],
        ];
        $alerts = collect([
            DB::table('periodos_escolares')->where('sede_id', $sedeId)->whereIn('estatus', ['ACTIVO', 'VIGENTE'])->exists() ? null : ['title' => 'No hay un periodo escolar activo', 'detail' => 'Configura o activa el periodo que regirá la operación académica.', 'url' => route('admin.universidad.index')],
            DB::table('documentos_personales as d')->join('users as u', 'u.persona_id', '=', 'd.persona_id')->join('sede_user as su', 'su.user_id', '=', 'u.id')->where('su.sede_id', $sedeId)->where('d.estatus', 'PENDIENTE')->exists() ? ['title' => 'Hay documentos personales pendientes', 'detail' => 'Control Escolar debe validar los expedientes recibidos.', 'url' => route('admin.people')] : null,
            DB::table('alertas_auditoria')->where('sede_id', $sedeId)->where('estatus', 'ABIERTA')->exists() ? ['title' => 'Existen alertas de seguridad abiertas', 'detail' => 'Consulta la consola de auditoría y documenta su atención.', 'url' => route('admin.audit.index')] : null,
        ])->filter()->values();
        $activity = DB::table('eventos_auditoria')
            ->leftJoin('users', 'users.id', '=', 'eventos_auditoria.actor_id')
            ->leftJoin('personas', 'personas.id', '=', 'users.persona_id')
            ->where('eventos_auditoria.sede_id', $sedeId)
            ->latest('eventos_auditoria.ocurrido_at')->limit(6)
            ->get(['eventos_auditoria.descripcion', 'eventos_auditoria.categoria', 'eventos_auditoria.ocurrido_at', DB::raw('COALESCE(personas.nombre_completo, users.email) as actor')]);

        return view('admin.dashboard-modern', compact('metrics', 'pending', 'events', 'alerts', 'activity'));
    }

    public function people()
    {
        $allowedSedeIds = $this->authorizedSedeIds('admin.access');
        $sedes = Sede::whereIn('id', $allowedSedeIds)->get();
        $userSedeIds = $this->authorizedSedeIds('personas.ver');
        $courseSedeIds = collect($this->authorizedSedeIds('courses.manage'))
            ->merge($this->authorizedSedeIds('reportes.exportar'))
            ->unique()
            ->all();
        $usuariosQuery = User::with(['persona', 'sedes', 'cursos', 'roles'])->latest();

        $usuariosQuery->whereHas('sedes', fn ($query) => $query->whereIn('sedes.id', $userSedeIds));

        $usuarios = $usuariosQuery->get();
        $cursos = Curso::with(['examenes', 'sede', 'lecciones'])
            ->whereIn('sede_id', $courseSedeIds)
            ->latest()
            ->get();
        $rolesRbac = Role::where('activo', true)->orderBy('nombre')->get();

        return view('admin.dashboard', compact('usuarios', 'cursos', 'sedes', 'rolesRbac'));
    }

    // --- CRUD DE CURSOS / MATERIAS ---
    public function courses(InstitutionalContext $context)
    {
        $sedeIds = $this->authorizedSedeIds('courses.manage');
        $cursos = Curso::with(['sede', 'user.persona', 'unidades', 'lecciones' => fn ($q) => $q->withTrashed(), 'tareas', 'examenes'])
            ->withCount(['usuarios', 'lecciones', 'tareas', 'examenes'])
            ->whereIn('sede_id', $sedeIds)
            ->latest()->get();
        $sedes = Sede::whereIn('id', $sedeIds)->orderBy('nombre')->get();

        return view('admin.courses.index', compact('cursos', 'sedes'));
    }

    public function storeCurso(Request $request)
    {
        $validated = $request->validate([
            'nombre' => 'required|string|max:255',
            'descripcion' => 'nullable|string',
            'sede_id' => 'required|exists:sedes,id',
        ]);
        abort_unless(in_array((int) $validated['sede_id'], $this->authorizedSedeIds('courses.manage'), true), 403);

        Curso::create([
            'nombre' => $validated['nombre'],
            'descripcion' => $validated['descripcion'] ?? '',
            'sede_id' => $validated['sede_id'],
            'user_id' => auth()->id(),
        ]);

        return redirect()->route('admin.dashboard')->with('success', 'Materia / Curso registrado exitosamente en la Sede.');
    }

    public function updateCurso(Request $request, $id)
    {
        $curso = $this->authorizedCourse($id);

        $validated = $request->validate([
            'nombre' => 'required|string|max:255',
            'descripcion' => 'nullable|string',
            'sede_id' => 'required|exists:sedes,id',
        ]);
        abort_unless(in_array((int) $validated['sede_id'], $this->authorizedSedeIds('courses.manage'), true), 403);

        $curso->update([
            'nombre' => $validated['nombre'],
            'descripcion' => $validated['descripcion'] ?? '',
            'sede_id' => $validated['sede_id'],
        ]);

        return redirect()->route('admin.dashboard')->with('success', 'Materia / Curso actualizado correctamente.');
    }

    public function destroyCurso($id)
    {
        $curso = $this->authorizedCourse($id);
        $curso->delete();

        return redirect()->route('admin.dashboard')->with('success', 'Materia / Curso eliminado del catálogo escolar.');
    }

    // --- CRUD DE USUARIOS ---
    public function storeUser(Request $request)
    {
        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'email' => 'required|email|unique:users,email',
            'password' => ['required', Password::min(8)->letters()->numbers()],
            'role' => 'nullable|in:ADMINISTRATIVO,DOCENTE,ALUMNO',
            'estatus' => 'nullable|in:ACTIVO,BAJA_TEMPORAL,BAJA_DEFINITIVA,EGRESADO',
            'curp' => ['nullable', 'string', 'size:18', 'regex:/^[A-Z]{4}\d{6}[HM][A-Z]{5}[A-Z0-9]\d$/i'],
            'fecha_nacimiento' => 'nullable|date|before:today',
            'sexo' => 'nullable|in:H,M,X',
            'nacionalidad' => 'nullable|string|max:80',
            'telefono' => 'nullable|string|max:20',
            'email_alternativo' => 'nullable|email|max:255',
            'domicilio' => 'nullable|string|max:1000',
            'contacto_emergencia_nombre' => 'nullable|string|max:255',
            'contacto_emergencia_telefono' => 'nullable|string|max:20',
            'contacto_emergencia_parentesco' => 'nullable|string|max:80',
            'foto' => 'nullable|image|mimes:jpg,jpeg,png,webp|max:3072',
            'matricula' => 'nullable|string|max:50',
            'sedes' => 'nullable|array',
            'sedes.*' => 'integer|distinct|exists:sedes,id',
            'membresias' => 'nullable|array',
            'membresias.*.seleccionada' => 'nullable|boolean',
            'membresias.*.role' => 'nullable|in:ADMINISTRATIVO,DOCENTE,ALUMNO',
            'membresias.*.estatus' => 'required_with:membresias.*.seleccionada|in:ACTIVO,BAJA_TEMPORAL,BAJA_DEFINITIVA,EGRESADO',
            'membresias.*.matricula' => 'nullable|string|max:30',
            'membresias.*.roles' => 'nullable|array|min:1',
            'membresias.*.roles.*' => 'integer|distinct|exists:roles,id',
            'cursos' => 'nullable|array',
            'cursos.*' => 'integer|distinct|exists:cursos,id',
        ], [
            'curp.size' => 'La CURP debe contener exactamente 18 caracteres.',
            'curp.regex' => 'El formato de la CURP no cumple con la estructura oficial de la SEP.',
            'email.unique' => 'El correo electrónico ya se encuentra registrado.',
        ]);

        $fotoPath = $request->file('foto')?->store('personas/fotos', 'local');

        DB::transaction(function () use ($validated, $fotoPath) {
            $persona = Persona::create([
                'nombre_completo' => $validated['name'],
                'curp' => $this->nullableUpper($validated['curp'] ?? null),
                ...$this->personalData($validated),
                'foto_path' => $fotoPath,
            ]);

            $user = User::create([
                'persona_id' => $persona->id,
                'email' => strtolower($validated['email']),
                'password' => Hash::make($validated['password']),
            ]);

            $user->sedes()->sync($this->legacyMemberships($user, $validated));
            $this->syncMembershipRoles($user, $validated);
            $this->registerMembershipEntries($user);
            $user->cursos()->sync($validated['cursos'] ?? []);
        });

        return redirect()->route('admin.dashboard')->with('success', 'Usuario registrado e inscrito exitosamente en el Padrón Escolar.');
    }

    public function updateUser(Request $request, $id)
    {
        $user = $this->authorizedUser($id, 'personas.editar');

        $validated = $request->validate([
            'name' => 'required|string|max:255',
            'email' => ['required', 'email', Rule::unique('users')->ignore($user->id)],
            'password' => ['nullable', Password::min(8)->letters()->numbers()],
            'role' => 'nullable|in:ADMINISTRATIVO,DOCENTE,ALUMNO',
            'estatus' => 'nullable|in:ACTIVO,BAJA_TEMPORAL,BAJA_DEFINITIVA,EGRESADO',
            'curp' => ['nullable', 'string', 'size:18', 'regex:/^[A-Z]{4}\d{6}[HM][A-Z]{5}[A-Z0-9]\d$/i'],
            'fecha_nacimiento' => 'nullable|date|before:today',
            'sexo' => 'nullable|in:H,M,X',
            'nacionalidad' => 'nullable|string|max:80',
            'telefono' => 'nullable|string|max:20',
            'email_alternativo' => 'nullable|email|max:255',
            'domicilio' => 'nullable|string|max:1000',
            'contacto_emergencia_nombre' => 'nullable|string|max:255',
            'contacto_emergencia_telefono' => 'nullable|string|max:20',
            'contacto_emergencia_parentesco' => 'nullable|string|max:80',
            'foto' => 'nullable|image|mimes:jpg,jpeg,png,webp|max:3072',
            'eliminar_foto' => 'nullable|boolean',
            'matricula' => 'nullable|string|max:50',
            'sedes' => 'nullable|array',
            'sedes.*' => 'integer|distinct|exists:sedes,id',
            'membresias' => 'nullable|array',
            'membresias.*.seleccionada' => 'nullable|boolean',
            'membresias.*.role' => 'nullable|in:ADMINISTRATIVO,DOCENTE,ALUMNO',
            'membresias.*.estatus' => 'required_with:membresias.*.seleccionada|in:ACTIVO,BAJA_TEMPORAL,BAJA_DEFINITIVA,EGRESADO',
            'membresias.*.matricula' => 'nullable|string|max:30',
            'membresias.*.roles' => 'nullable|array|min:1',
            'membresias.*.roles.*' => 'integer|distinct|exists:roles,id',
            'cursos' => 'nullable|array',
            'cursos.*' => 'integer|distinct|exists:cursos,id',
        ], [
            'curp.size' => 'La CURP debe contener exactamente 18 caracteres.',
            'curp.regex' => 'El formato de la CURP no cumple con la estructura oficial SEP.',
        ]);

        $data = [
            'email' => $validated['email'],
        ];

        if (! empty($validated['password'])) {
            $data['password'] = Hash::make($validated['password']);
        }

        $oldPhoto = $user->persona?->foto_path;
        $newPhoto = $request->file('foto')?->store('personas/fotos', 'local');

        DB::transaction(function () use ($user, $validated, $data, $oldPhoto, $newPhoto) {
            $persona = $user->persona()->updateOrCreate([], [
                'nombre_completo' => $validated['name'],
                'curp' => $this->nullableUpper($validated['curp'] ?? null),
                ...$this->personalData($validated),
                'foto_path' => $newPhoto
                    ?: (($validated['eliminar_foto'] ?? false) ? null : $oldPhoto),
            ]);
            $data['persona_id'] = $persona->id;
            $user->update($data);
            $user->sedes()->sync($this->legacyMemberships($user, $validated));
            $this->syncMembershipRoles($user, $validated);
            $this->registerMembershipEntries($user);
            $user->cursos()->sync($validated['cursos'] ?? []);
        });

        if ($oldPhoto && ($newPhoto || ($validated['eliminar_foto'] ?? false))) {
            Storage::disk('local')->delete($oldPhoto);
        }

        return redirect()->route('admin.dashboard')->with('success', 'Expediente de usuario y carga académica actualizados correctamente.');
    }

    public function destroyUser($id)
    {
        $user = $this->authorizedUser($id, 'personas.eliminar');

        if ($user->id === auth()->id()) {
            return redirect()->route('admin.dashboard')->with('error', 'No puedes eliminar tu propia cuenta de administrador.');
        }

        $user->delete();

        return redirect()->route('admin.dashboard')->with('success', 'Usuario dado de baja del Padrón Escolar.');
    }

    public function fotoPersona($id, SensitiveDataAuditService $audit)
    {
        $user = $this->authorizedUser($id, 'personas.ver')->load('persona');
        abort_unless($user->persona?->foto_path, 404);
        abort_unless(Storage::disk('local')->exists($user->persona->foto_path), 404);
        $audit->record('VISUALIZACION', $user->persona, null, $user->id, app(InstitutionalContext::class)->sedeId(), 'fotografia-identidad');

        return Storage::disk('local')->response(
            $user->persona->foto_path,
            'foto-'.$user->id.'.'.pathinfo($user->persona->foto_path, PATHINFO_EXTENSION),
            ['Cache-Control' => 'private, max-age=3600']
        );
    }

    public function descargarActaCurso($id)
    {
        $curso = $this->authorizedCourse($id, 'reportes.exportar')->load('examenes');
        $examenIds = $curso->examenes->pluck('id')->toArray();

        $actas = Resultado::with(['user.persona', 'user.sedes'])
            ->whereIn('examen_id', $examenIds)
            ->orderBy('calificacion', 'desc')
            ->get();

        $pdf = Pdf::loadView('admin.acta', compact('curso', 'actas'))
            ->setPaper('a4', 'landscape');

        return $pdf->download('Acta_Oficial_SEP_'.str_replace(' ', '_', $curso->nombre).'.pdf');
    }

    public function importUsers(Request $request)
    {
        $request->validate([
            'file' => 'required|mimes:csv,txt|max:2048',
        ]);

        $file = fopen($request->file('file')->getRealPath(), 'r');
        $header = array_map('trim', fgetcsv($file) ?: []);
        if ($header !== ['nombre', 'email', 'password', 'sede_clave', 'role', 'estatus', 'curp', 'matricula']) {
            fclose($file);

            return back()->withErrors(['file' => 'La estructura del archivo CSV no es válida.']);
        }

        $registrados = 0;
        $omitidosPorCurp = 0;
        $regexCurp = '/^[A-Z]{4}[0-9]{6}[HM][A-Z]{5}[A-Z0-9][0-9]$/';

        while (($row = fgetcsv($file, 1000, ',')) !== false) {
            if (count($row) === 8) {
                $email = strtolower(trim($row[1]));
                $sedeClave = strtoupper(trim($row[3]));
                $role = strtoupper(trim($row[4]));
                $role = $role === 'ADMINISTRATIVO' ? 'SUPERADMINISTRADOR' : $role;
                $estatus = strtoupper(trim($row[5]));
                $curp = strtoupper(trim($row[6])) ?: null;
                $matricula = trim($row[7]) ?: null;

                $validator = Validator::make([
                    'name' => trim($row[0]),
                    'email' => $email,
                    'password' => $row[2],
                    'sede_clave' => $sedeClave,
                    'role' => $role,
                    'estatus' => $estatus,
                    'curp' => $curp,
                    'matricula' => $matricula,
                ], [
                    'name' => ['required', 'string', 'max:255'],
                    'email' => ['required', 'email', 'max:255'],
                    'password' => ['required', 'string', 'min:8'],
                    'sede_clave' => ['required', 'exists:sedes,clave'],
                    'role' => ['required', Rule::exists('roles', 'slug')->where('activo', true)],
                    'estatus' => ['required', Rule::in(['ACTIVO', 'BAJA_TEMPORAL', 'BAJA_DEFINITIVA', 'EGRESADO'])],
                    'curp' => ['nullable', 'size:18', 'regex:/^[A-Z]{4}\d{6}[HM][A-Z]{5}[A-Z0-9]\d$/'],
                    'matricula' => ['nullable', 'string', 'max:20'],
                ]);

                if ($validator->fails()) {
                    $omitidosPorCurp++;

                    continue;
                }

                if (in_array($role, ['ALUMNO', 'DOCENTE', 'CANDIDATO'], true) && ! empty($curp)) {
                    if (! preg_match($regexCurp, $curp)) {
                        $omitidosPorCurp++;

                        continue;
                    }
                }

                DB::transaction(function () use ($row, $email, $role, $estatus, $curp, $matricula, $sedeClave) {
                    $user = User::firstOrNew(['email' => $email]);
                    $persona = $user->persona
                        ?: ($curp ? Persona::firstOrNew(['curp' => $curp]) : new Persona);
                    $persona->fill(['nombre_completo' => trim($row[0]), 'curp' => $curp]);
                    $persona->save();

                    $user->fill([
                        'persona_id' => $persona->id,
                    ]);
                    if (! $user->exists) {
                        $user->password = Hash::make($row[2]);
                    }
                    $user->save();

                    $sede = Sede::where('clave', $sedeClave)->firstOrFail();
                    $roleModel = Role::where('slug', $role)->where('activo', true)->firstOrFail();
                    if (! auth()->user()->tienePermiso('roles.manage')) {
                        $elevated = $roleModel->permissions()
                            ->whereIn('permissions.slug', [
                                'roles.manage',
                                'security.manage',
                                'certificaciones.coordinar',
                                'certificados.emitir',
                            ])
                            ->exists();
                        abort_if($elevated, 403, 'No puedes importar asignaciones de seguridad elevada.');
                    }
                    $legacyRole = $this->legacyRoleFromIds([$roleModel->id], 'ALUMNO');
                    $user->sedes()->syncWithoutDetaching([$sede->id => [
                        'role' => $legacyRole,
                        'estatus' => $estatus,
                        'matricula' => $matricula ?: $sede->clave.'-'.str_pad((string) $user->id, 6, '0', STR_PAD_LEFT),
                        'fecha_ingreso' => now()->toDateString(),
                    ]]);
                    DB::table('membership_role')->insertOrIgnore([
                        'user_id' => $user->id,
                        'sede_id' => $sede->id,
                        'role_id' => $roleModel->id,
                        'asignado_por' => auth()->id(),
                        'asignado_at' => now(),
                    ]);
                    if ($roleModel->slug === 'CANDIDATO') {
                        CandidaturaCertificacion::ensureFor($user, $sede);
                    }
                    $this->registerMembershipEntries($user, [$sede->id]);
                });
                $registrados++;
            }
        }

        fclose($file);

        $feedback = "¡Padrón procesado con éxito! Se integraron {$registrados} expedientes escolares válidos.";
        if ($omitidosPorCurp > 0) {
            $feedback .= " Advertencia: Omitimos {$omitidosPorCurp} fila(s) debido a CURP inválida.";
        }

        return redirect()->back()->with('success', $feedback);
    }

    public function downloadTemplate()
    {
        $headers = [
            'Content-type' => 'text/csv; charset=UTF-8',
            'Content-Disposition' => 'attachment; filename=plantilla_usuarios_sep.csv',
            'Pragma' => 'no-cache',
            'Cache-Control' => 'must-revalidate, post-check=0, pre-check=0',
            'Expires' => '0',
        ];

        $callback = function () {
            $file = fopen('php://output', 'w');
            fputcsv($file, ['nombre', 'email', 'password', 'sede_clave', 'role', 'estatus', 'curp', 'matricula']);
            fputcsv($file, ['Juan Perez', 'juan.perez@consorcio.com', 'Alumno2026*', 'UNI', 'ALUMNO', 'ACTIVO', 'PEPJ990101HDFRRN09', 'UNI-2026-0001']);
            fclose($file);
        };

        return response()->stream($callback, 200, $headers);
    }

    // --- GESTIÓN DE LECCIONES / TEMARIO ---
    public function storeLeccion(Request $request)
    {
        $validated = $request->validate([
            'curso_id' => 'required|exists:cursos,id',
            'titulo' => 'required|string|max:255',
            'contenido_texto' => 'nullable|string',
            'url_recurso' => 'nullable|url',
            'orden' => 'nullable|integer',
        ], [
            'url_recurso.url' => 'El enlace proporcionado debe ser una URL válida (ej: https://youtube.com/...).',
        ]);

        Leccion::create([
            'curso_id' => $validated['curso_id'],
            'titulo' => $validated['titulo'],
            'contenido_texto' => $validated['contenido_texto'] ?? null,
            'url_recurso' => $validated['url_recurso'] ?? null,
            'orden' => $validated['orden'] ?? 1,
        ]);

        return redirect()->route('admin.dashboard')->with('success', 'Lección/Tema agregado correctamente al programa del curso.');
    }

    public function destroyLeccion($id)
    {
        $leccion = Leccion::findOrFail($id);
        $leccion->delete();

        return redirect()->route('admin.dashboard')->with('success', 'Lección eliminada del programa escolar.');
    }

    private function legacyMemberships(User $user, array $validated): array
    {
        $courseIds = $validated['cursos'] ?? [];
        $requestedMemberships = collect($validated['membresias'] ?? [])
            ->filter(fn ($membership) => (bool) ($membership['seleccionada'] ?? false));
        $sedeIds = $requestedMemberships->isNotEmpty()
            ? $requestedMemberships->keys()->map(fn ($id) => (int) $id)->all()
            : ($validated['sedes'] ?? []);
        if ($sedeIds === []) {
            throw ValidationException::withMessages([
                'sedes' => 'Debes asignar al menos una sede.',
            ]);
        }
        abort_if(array_diff($sedeIds, $this->authorizedSedeIds('membresias.administrar')) !== [], 403);
        $validCourses = Curso::whereIn('id', $courseIds)->whereIn('sede_id', $sedeIds)->count();

        if ($validCourses !== count($courseIds)) {
            throw ValidationException::withMessages([
                'cursos' => 'Cada curso seleccionado debe pertenecer a una sede asignada al usuario.',
            ]);
        }

        $memberships = collect($sedeIds)->mapWithKeys(function ($sedeId) use ($user, $validated, $requestedMemberships) {
            $sede = Sede::findOrFail($sedeId);
            $membership = $requestedMemberships->get($sedeId, []);
            $existing = $user->membresiaEnSede((int) $sedeId);

            return [$sedeId => [
                'role' => $this->legacyRoleFromIds(
                    $membership['roles'] ?? [],
                    $membership['role'] ?? ($validated['role'] ?? 'ALUMNO')
                ),
                'estatus' => $existing?->estatus ?? ($membership['estatus'] ?? ($validated['estatus'] ?? 'ACTIVO')),
                'matricula' => ($membership['matricula'] ?? null) ?: (($validated['matricula'] ?? null)
                    ?: $sede->clave.'-'.str_pad((string) $user->id, 6, '0', STR_PAD_LEFT)),
                'fecha_ingreso' => $existing?->fecha_ingreso?->toDateString() ?? now()->toDateString(),
                'fecha_baja' => $existing?->fecha_baja?->toDateString(),
            ]];
        });

        // Una membresía existente no se elimina ni cambia de estatus desde el editor
        // general. Esos cambios requieren un movimiento institucional auditable.
        $existingMemberships = $user->exists
            ? $user->sedes()
                ->get()
                ->mapWithKeys(fn ($sede) => [$sede->id => [
                    'role' => $sede->pivot->role,
                    'estatus' => $sede->pivot->estatus,
                    'matricula' => $sede->pivot->matricula,
                    'fecha_ingreso' => $sede->pivot->fecha_ingreso?->toDateString(),
                    'fecha_baja' => $sede->pivot->fecha_baja?->toDateString(),
                ]])
            : collect();

        return $memberships->union($existingMemberships)->all();
    }

    private function registerMembershipEntries(User $user, ?array $sedeIds = null): void
    {
        $memberships = $user->sedes()
            ->when($sedeIds, fn ($query) => $query->whereIn('sedes.id', $sedeIds))
            ->get();

        foreach ($memberships as $sede) {
            MovimientoMembresia::firstOrCreate(
                [
                    'user_id' => $user->id,
                    'sede_id' => $sede->id,
                    'tipo' => 'INGRESO',
                ],
                [
                    'estatus_anterior' => 'SIN_MEMBRESIA',
                    'estatus_nuevo' => $sede->pivot->estatus,
                    'motivo' => 'Ingreso institucional',
                    'observaciones' => 'Adscripción registrada en el padrón institucional.',
                    'autorizado_por' => auth()->id(),
                    'autorizado_at' => $sede->pivot->fecha_ingreso?->startOfDay() ?? now(),
                ]
            );
        }
    }

    private function syncMembershipRoles(User $user, array $validated): void
    {
        $memberships = collect($validated['membresias'] ?? [])
            ->filter(fn ($membership) => (bool) ($membership['seleccionada'] ?? false));

        foreach ($memberships as $sedeId => $membership) {
            $roleIds = collect($membership['roles'] ?? [])->map(fn ($id) => (int) $id)->unique()->values();
            if ($roleIds->isEmpty()) {
                continue;
            }

            $roles = Role::with('permissions')->whereIn('id', $roleIds)->where('activo', true)->get();
            abort_unless($roles->count() === $roleIds->count(), 422);

            if (! auth()->user()->tienePermiso('roles.manage')) {
                $elevated = $roles->contains(fn ($role) => $role->permissions->contains(
                    fn ($permission) => in_array($permission->slug, [
                        'roles.manage',
                        'security.manage',
                        'certificaciones.coordinar',
                        'certificados.emitir',
                    ], true)
                ));
                abort_if($elevated, 403, 'No puedes asignar roles de seguridad elevada.');
            }

            DB::table('membership_role')
                ->where('user_id', $user->id)
                ->where('sede_id', (int) $sedeId)
                ->delete();
            foreach ($roleIds as $roleId) {
                DB::table('membership_role')->insert([
                    'user_id' => $user->id,
                    'sede_id' => (int) $sedeId,
                    'role_id' => $roleId,
                    'asignado_por' => auth()->id(),
                    'asignado_at' => now(),
                ]);
                if ($roles->firstWhere('id', $roleId)?->slug === 'CANDIDATO') {
                    CandidaturaCertificacion::ensureFor($user, Sede::findOrFail((int) $sedeId));
                }
            }
        }
    }

    private function legacyRoleFromIds(array $roleIds, string $fallback): string
    {
        $slugs = Role::whereIn('id', $roleIds)->pluck('slug');
        if ($slugs->contains(fn ($slug) => in_array($slug, [
            'SUPERADMINISTRADOR',
            'DIRECTOR_SEDE',
            'CONTROL_ESCOLAR',
            'COORDINADOR_ACADEMICO',
            'COORDINADOR_CERTIFICACION',
            'SERVICIOS_ESCOLARES',
            'FINANZAS',
            'RECURSOS_HUMANOS',
            'TUTOR',
            'EVALUADOR',
            'APLICADOR',
        ], true))) {
            return 'ADMINISTRATIVO';
        }

        return $slugs->contains('DOCENTE') ? 'DOCENTE' : $fallback;
    }

    private function nullableUpper(?string $value): ?string
    {
        return filled($value) ? strtoupper($value) : null;
    }

    private function personalData(array $validated): array
    {
        return collect($validated)->only([
            'fecha_nacimiento',
            'sexo',
            'nacionalidad',
            'telefono',
            'email_alternativo',
            'domicilio',
            'contacto_emergencia_nombre',
            'contacto_emergencia_telefono',
            'contacto_emergencia_parentesco',
        ])->map(fn ($value) => filled($value) ? $value : null)->all();
    }

    private function authorizedSedeIds(string $permission = 'admin.access'): array
    {
        $ids = auth()->user()->sedesConPermiso($permission)->pluck('sedes.id')->map(fn ($id) => (int) $id)->all();

        return $ids;
    }

    private function authorizedCourse($id, string $permission = 'courses.manage'): Curso
    {
        return Curso::whereKey($id)->whereIn('sede_id', $this->authorizedSedeIds($permission))->firstOrFail();
    }

    private function authorizedUser($id, string $permission = 'personas.editar'): User
    {
        $allowed = $this->authorizedSedeIds($permission);
        $allSedes = Sede::count();

        return User::whereKey($id)
            ->where(function ($query) use ($allowed, $allSedes) {
                $query->whereHas('sedes', fn ($sedes) => $sedes->whereIn('sedes.id', $allowed));
                if (count($allowed) === $allSedes) {
                    $query->orDoesntHave('sedes');
                }
            })
            ->firstOrFail();
    }
}
