<?php

namespace App\Http\Controllers;

use App\Models\Curso;
use App\Models\EntregaLms;
use App\Models\EventoLms;
use App\Models\ForoLms;
use App\Models\GrupoAcademico;
use App\Models\GrupoIdioma;
use App\Models\Leccion;
use App\Models\Examen;
use App\Models\UnidadLms;
use App\Models\MensajeLms;
use App\Models\PublicacionForoLms;
use App\Models\TareaLms;
use App\Services\InstitutionalNotificationService;
use App\Support\InstitutionalContext;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;

class LmsController extends Controller
{
    public function teacherRoom(Curso $curso)
    {
        $this->teacherCourse($curso);
        $curso = $this->loadRoom($curso);
        $mensajes = $curso->mensajes()->with('remitente.persona')->latest()->get();

        $gradebook = $curso->usuarios->map(function ($student) use ($curso) {
            $deliveries = DB::table('entregas_lms')->join('tareas_lms', 'tareas_lms.id', '=', 'entregas_lms.tarea_id')->where('tareas_lms.curso_id', $curso->id)->where('entregas_lms.user_id', $student->id)->get();
            $results = DB::table('resultados')->join('examenes', 'examenes.id', '=', 'resultados.examen_id')->where('examenes.curso_id', $curso->id)->where('resultados.user_id', $student->id)->get();
            $lastActivity = DB::table('actividad_lms')->where('curso_id', $curso->id)->where('user_id', $student->id)->max('registrada_at');
            return ['student' => $student, 'tasks' => $deliveries->whereNotNull('calificacion')->avg('calificacion'), 'exams' => $results->avg('calificacion'), 'last_activity' => $lastActivity, 'inactive' => ! $lastActivity || now()->diffInDays($lastActivity) >= 7];
        });
        $bank = DB::table('banco_preguntas_lms')->where('sede_id', $curso->sede_id)->latest()->limit(100)->get();
        $history = DB::table('historial_contenido_lms')->where('curso_id', $curso->id)->latest()->limit(30)->get();
        view()->share(compact('curso', 'gradebook', 'bank', 'history'));

        return view('docente.aula', compact('curso', 'mensajes', 'gradebook', 'bank', 'history'));
    }

    public function studentRoom(Curso $curso)
    {
        $this->studentCourse($curso);

        $curso = $this->loadRoom($curso);
        $available = fn ($item) => (! isset($item->publicada) || $item->publicada) && (! $item->disponible_desde || now()->gte($item->disponible_desde)) && (! $item->disponible_hasta || now()->lte($item->disponible_hasta));
        $curso->setRelation('unidades', $curso->unidades->filter($available)->values());
        $curso->setRelation('lecciones', $curso->lecciones->filter($available)->values());
        $curso->setRelation('tareas', $curso->tareas->filter(fn ($task) => $task->publicada && (! $task->disponible_desde || now()->gte($task->disponible_desde)))->values());
        $curso->setRelation('foros', $curso->foros->filter(fn ($forum) => $forum->publicado)->values());
        $misEntregas = EntregaLms::where('user_id', auth()->id())->whereHas('tarea', fn ($q) => $q->where('curso_id', $curso->id))->get()->keyBy('tarea_id');
        $mensajes = $curso->mensajes()->with('remitente.persona')->where(fn ($q) => $q->where('remitente_id', auth()->id())->orWhere('destinatario_id', auth()->id())->orWhereNull('destinatario_id'))->latest()->get();
        $completedLessonIds = auth()->user()->leccionesCompletadas()->where('curso_id', $curso->id)->pluck('lecciones.id');
        $sequenceRequired = (bool) DB::table('configuracion_lms')->where('curso_id', $curso->id)->value('secuencia_obligatoria');
        $lockedLessonIds = $sequenceRequired ? $curso->lecciones->filter(fn ($lesson) => $lesson->prerequisito_leccion_id && ! $completedLessonIds->contains($lesson->prerequisito_leccion_id))->pluck('id') : collect();
        $examResults = DB::table('resultados')->where('user_id', auth()->id())->whereIn('examen_id', $curso->examenes->pluck('id'))->orderByDesc('numero_intento')->get()->groupBy('examen_id');

        DB::table('actividad_lms')->insert(['curso_id' => $curso->id, 'user_id' => auth()->id(), 'tipo' => 'AULA_VISITADA', 'registrada_at' => now(), 'created_at' => now(), 'updated_at' => now()]);
        $anuncios = $curso->anuncios()->whereNotNull('publicado_at')->where(fn ($query) => $query->whereNull('vence_at')->orWhere('vence_at', '>', now()))->latest('publicado_at')->get();
        $encuestas = $curso->encuestas()->with('respuestas')->where('publicada', true)->where(fn ($query) => $query->whereNull('disponible_hasta')->orWhere('disponible_hasta', '>', now()))->get();
        view()->share(compact('curso', 'anuncios', 'encuestas'));

        return view('alumno.aula', compact('curso', 'misEntregas', 'mensajes', 'anuncios', 'encuestas', 'lockedLessonIds', 'examResults'));
    }

    public function previewStudentRoom(Curso $curso)
    {
        $this->teacherCourse($curso);
        $curso = $this->loadRoom($curso);
        $available = fn ($item) => (! isset($item->publicada) || $item->publicada)
            && (! $item->disponible_desde || now()->gte($item->disponible_desde))
            && (! $item->disponible_hasta || now()->lte($item->disponible_hasta));
        $curso->setRelation('unidades', $curso->unidades->filter($available)->values());
        $curso->setRelation('lecciones', $curso->lecciones->filter($available)->values());
        $curso->setRelation('tareas', $curso->tareas->filter(fn ($task) => $task->publicada && (! $task->disponible_desde || now()->gte($task->disponible_desde)))->values());
        $curso->setRelation('foros', $curso->foros->filter(fn ($forum) => $forum->publicado)->values());
        return view('docente.aula-preview', compact('curso'));
    }

    public function unit(Request $request, Curso $curso)
    {
        $this->teacherCourse($curso);
        $data = $request->validate(['titulo' => ['required', 'string', 'max:255'], 'descripcion' => ['nullable', 'string'], 'orden' => ['required', 'integer', 'min:1'], 'disponible_desde' => ['nullable', 'date'], 'disponible_hasta' => ['nullable', 'date', 'after:disponible_desde'], 'publicada' => ['nullable', 'boolean']]);
        $unit = $curso->unidades()->create($data + ['publicada' => $request->boolean('publicada')]);
        $this->auditContent($curso, 'CREAR', 'UNIDAD', ['id' => $unit->id, 'titulo' => $unit->titulo]);

        return back()->with('success', 'Unidad creada.');
    }

    public function updateUnit(Request $request, UnidadLms $unidad)
    {
        $this->teacherCourse($unidad->curso);
        $data=$request->validate(['titulo'=>['required','string','max:255'],'descripcion'=>['nullable','string'],'orden'=>['required','integer','min:1'],'disponible_desde'=>['nullable','date'],'disponible_hasta'=>['nullable','date','after:disponible_desde'],'publicada'=>['nullable','boolean']]);
        $unidad->update($data+['publicada'=>$request->boolean('publicada')]);
        $this->auditContent($unidad->curso,'ACTUALIZAR','UNIDAD',['id'=>$unidad->id,'titulo'=>$unidad->titulo]);
        return back()->with('success','Unidad actualizada.');
    }

    public function deleteUnit(UnidadLms $unidad)
    {
        $this->teacherCourse($unidad->curso);
        abort_if($unidad->lecciones()->exists()||$unidad->tareas()->exists(),422,'Mueve o elimina primero el contenido de la unidad.');
        $course=$unidad->curso;$id=$unidad->id;$unidad->delete();$this->auditContent($course,'ELIMINAR','UNIDAD',['id'=>$id]);
        return back()->with('success','Unidad eliminada.');
    }

    public function updateLesson(Request $request, Leccion $leccion, InstitutionalNotificationService $notifications)
    {
        $this->teacherCourse($leccion->curso);
        $data=$request->validate(['titulo'=>['required','string','max:255'],'contenido_texto'=>['nullable','string'],'url_recurso'=>['nullable','url','max:2048'],'orden'=>['required','integer','min:1'],'unidad_id'=>['nullable','exists:unidades_lms,id'],'prerequisito_leccion_id'=>['nullable','exists:lecciones,id'],'disponible_desde'=>['nullable','date'],'disponible_hasta'=>['nullable','date','after:disponible_desde'],'publicada'=>['nullable','boolean']]);
        if($data['unidad_id']??null) abort_unless($leccion->curso->unidades()->whereKey($data['unidad_id'])->exists(),422);
        if($data['prerequisito_leccion_id']??null) abort_unless((int)$data['prerequisito_leccion_id']!==$leccion->id&&$leccion->curso->lecciones()->whereKey($data['prerequisito_leccion_id'])->exists(),422);
        $wasPublished=$leccion->publicada;$leccion->update($data+['publicada'=>$request->boolean('publicada'),'version'=>$leccion->version+1]);
        if(!$wasPublished&&$leccion->publicada&&(!$leccion->disponible_desde||$leccion->disponible_desde->isPast())) foreach($leccion->curso->usuarios as $student)$notifications->notifyUser($leccion->curso->sede_id,$student->id,'LECCION-PUBLICADA-'.$leccion->id.'-'.$student->id,'ACADEMICO','Nuevo contenido de clase',$leccion->titulo.' está disponible.','/alumno/aulas/'.$leccion->curso_id,'Abrir contenido');
        $this->auditContent($leccion->curso,'ACTUALIZAR','LECCION',['id'=>$leccion->id,'version'=>$leccion->version]);
        return back()->with('success','Contenido actualizado y versionado.');
    }

    public function task(Request $request, Curso $curso, InstitutionalNotificationService $notifications)
    {
        $this->teacherCourse($curso);
        $data = $request->validate(['unidad_id' => ['nullable', 'exists:unidades_lms,id'], 'titulo' => ['required', 'string', 'max:255'], 'instrucciones' => ['required', 'string'], 'puntaje_maximo' => ['required', 'numeric', 'min:1'], 'ponderacion' => ['nullable','numeric','between:0,100'], 'categoria'=>['nullable','string','max:40'], 'disponible_desde' => ['nullable', 'date'], 'fecha_limite' => ['required', 'date'], 'permite_tardia' => ['nullable', 'boolean'], 'publicada' => ['nullable', 'boolean']]);
        if ($data['unidad_id'] ?? null) {
            abort_unless($curso->unidades()->whereKey($data['unidad_id'])->exists(), 404);
        }
        abort_if($curso->tareas()->sum('ponderacion')+$curso->examenes()->sum('ponderacion')+(float)($data['ponderacion']??0)>100,422,'La ponderación total del curso supera 100%.');
        $task = $curso->tareas()->create($data + ['ponderacion'=>$data['ponderacion']??0,'categoria'=>$data['categoria']??'TAREAS','permite_tardia' => $request->boolean('permite_tardia'), 'publicada' => $request->boolean('publicada')]);
        if ($task->publicada) {
            foreach ($curso->usuarios as $student) {
                $notifications->notifyUser($curso->sede_id, $student->id, 'TAREA-PUBLICADA-'.$task->id.'-'.$student->id, 'ACADEMICO', 'Nueva tarea publicada', $task->titulo.' vence el '.$task->fecha_limite->format('d/m/Y H:i').'.', '/alumno/aulas/'.$curso->id, 'Abrir aula');
            }
        }
        $this->auditContent($curso, 'CREAR', 'TAREA', ['id' => $task->id, 'titulo' => $task->titulo]);

        return back()->with('success', 'Tarea publicada.');
    }

    public function criterion(Request $request, TareaLms $tarea)
    {
        $this->teacherCourse($tarea->curso);
        $data = $request->validate(['criterio' => ['required', 'string', 'max:255'], 'descripcion' => ['nullable', 'string'], 'puntaje_maximo' => ['required', 'numeric', 'min:0.01'], 'orden' => ['required', 'integer', 'min:1']]);
        abort_if($tarea->criterios()->sum('puntaje_maximo') + $data['puntaje_maximo'] > $tarea->puntaje_maximo, 422, 'La rúbrica supera el puntaje de la tarea.');
        $tarea->criterios()->create($data);

        return back()->with('success', 'Criterio agregado.');
    }

    public function updateTask(Request $request,TareaLms $tarea)
    {
        $this->teacherCourse($tarea->curso);
        $data=$request->validate(['titulo'=>['required','string','max:255'],'instrucciones'=>['required','string'],'puntaje_maximo'=>['required','numeric','min:1'],'ponderacion'=>['required','numeric','between:0,100'],'categoria'=>['required','string','max:40'],'disponible_desde'=>['nullable','date'],'fecha_limite'=>['required','date'],'permite_tardia'=>['nullable','boolean'],'publicada'=>['nullable','boolean']]);
        $other=$tarea->curso->tareas()->whereKeyNot($tarea->id)->sum('ponderacion')+$tarea->curso->examenes()->sum('ponderacion');abort_if($other+$data['ponderacion']>100,422,'La ponderación total del curso supera 100%.');
        $tarea->update($data+['permite_tardia'=>$request->boolean('permite_tardia'),'publicada'=>$request->boolean('publicada')]);$this->auditContent($tarea->curso,'ACTUALIZAR','TAREA',['id'=>$tarea->id]);
        return back()->with('success','Actividad actualizada.');
    }

    public function deleteTask(TareaLms $tarea)
    {
        $this->teacherCourse($tarea->curso);abort_if($tarea->entregas()->exists(),422,'No se puede eliminar una actividad con entregas; retírala de publicación.');$course=$tarea->curso;$id=$tarea->id;$tarea->delete();$this->auditContent($course,'ELIMINAR','TAREA',['id'=>$id]);return back()->with('success','Actividad eliminada.');
    }

    public function updateExam(Request $request,Examen $examen)
    {
        $this->teacherCourse($examen->curso);$data=$request->validate(['titulo'=>['required','string','max:255'],'instrucciones'=>['nullable','string'],'limite_tiempo'=>['required','integer','between:1,180'],'intentos_permitidos'=>['required','integer','between:1,10'],'ponderacion'=>['required','numeric','between:0,100'],'categoria'=>['required','string','max:40'],'disponible_desde'=>['nullable','date'],'disponible_hasta'=>['nullable','date','after:disponible_desde'],'calificacion_minima'=>['required','numeric','between:0,10'],'publicado'=>['nullable','boolean'],'aleatorizar_preguntas'=>['nullable','boolean'],'mostrar_resultado'=>['nullable','boolean']]);
        $other=$examen->curso->examenes()->whereKeyNot($examen->id)->sum('ponderacion')+$examen->curso->tareas()->sum('ponderacion');abort_if($other+$data['ponderacion']>100,422,'La ponderación total del curso supera 100%.');abort_if($request->boolean('publicado')&&$examen->preguntas()->doesntExist(),422,'Agrega al menos un reactivo antes de publicar.');
        $examen->update($data+['publicado'=>$request->boolean('publicado'),'aleatorizar_preguntas'=>$request->boolean('aleatorizar_preguntas'),'mostrar_resultado'=>$request->boolean('mostrar_resultado')]);$this->auditContent($examen->curso,'ACTUALIZAR','EXAMEN',['id'=>$examen->id]);return back()->with('success','Evaluación actualizada.');
    }

    public function submit(Request $request, TareaLms $tarea)
    {
        $this->studentCourse($tarea->curso);
        abort_unless($tarea->publicada, 404);
        abort_if(now()->gt($tarea->fecha_limite) && ! $tarea->permite_tardia, 422, 'La fecha límite terminó.');
        $data = $request->validate(['comentario_alumno' => ['nullable', 'string', 'max:3000'], 'archivo' => ['nullable', 'file', 'max:20480', 'mimes:pdf,doc,docx,xls,xlsx,ppt,pptx,jpg,jpeg,png,zip'], 'accion' => ['nullable', 'in:BORRADOR,ENTREGAR']]);
        abort_unless(filled($data['comentario_alumno'] ?? null) || $request->hasFile('archivo'), 422, 'Agrega un comentario o archivo.');
        $delivery = EntregaLms::firstOrNew(['tarea_id' => $tarea->id, 'user_id' => auth()->id()]);
        abort_if($delivery->calificada_at, 422, 'La entrega ya fue calificada.');
        if ($request->hasFile('archivo')) {
            $delivery->archivo_path = $request->file('archivo')->store('lms/entregas/'.$tarea->id, 'local');
            $delivery->archivo_nombre = $request->file('archivo')->getClientOriginalName();
        }$isDraft = ($data['accion'] ?? 'ENTREGAR') === 'BORRADOR';
        $delivery->fill(['comentario_alumno' => $data['comentario_alumno'] ?? null, 'estatus' => $isDraft ? 'BORRADOR' : (now()->gt($tarea->fecha_limite) ? 'TARDIA' : 'ENTREGADA'), 'entregada_at' => $isDraft ? null : now()])->save();
        DB::table('actividad_lms')->insert(['curso_id'=>$tarea->curso_id,'user_id'=>auth()->id(),'tipo'=>$isDraft?'ENTREGA_BORRADOR':'TAREA_ENTREGADA','recurso_tipo'=>TareaLms::class,'recurso_id'=>$tarea->id,'registrada_at'=>now(),'created_at'=>now(),'updated_at'=>now()]);

        return back()->with('success', $isDraft ? 'Borrador guardado. Puedes continuar después.' : 'Entrega registrada y comprobante generado.');
    }

    public function grade(Request $request, EntregaLms $entrega, InstitutionalNotificationService $notifications)
    {
        $this->teacherCourse($entrega->tarea->curso);
        $rules = ['retroalimentacion' => ['required', 'string', 'min:3'], 'archivo_retroalimentacion' => ['nullable', 'file', 'max:10240']];
        foreach ($entrega->tarea->criterios as $c) {
            $rules['criterios.'.$c->id] = ['required', 'numeric', 'between:0,'.$c->puntaje_maximo];
        }$data = $request->validate($rules);
        $score = $entrega->tarea->criterios->isEmpty() ? (float) $request->validate(['calificacion' => ['required', 'numeric', 'between:0,'.$entrega->tarea->puntaje_maximo]])['calificacion'] : collect($data['criterios'])->sum();
        DB::transaction(function () use ($entrega, $data, $score, $request) {
            foreach ($data['criterios'] ?? [] as $id => $points) {
                $entrega->evaluaciones()->updateOrCreate(['criterio_id' => $id], ['puntaje' => $points]);
            }$values = ['calificacion' => $score, 'retroalimentacion' => $data['retroalimentacion'], 'estatus' => 'CALIFICADA', 'calificada_por' => auth()->id(), 'calificada_at' => now()];
            if ($request->hasFile('archivo_retroalimentacion')) {
                $values['archivo_retroalimentacion_path'] = $request->file('archivo_retroalimentacion')->store('lms/retroalimentacion/'.$entrega->id, 'local');
            }$entrega->update($values);
        });
        $notifications->notifyUser($entrega->tarea->curso->sede_id, $entrega->user_id, 'TAREA-CALIFICADA-'.$entrega->id.'-'.$entrega->updated_at->timestamp, 'ACADEMICO', 'Tarea calificada', 'Tu entrega de '.$entrega->tarea->titulo.' recibió '.$score.' puntos.', '/alumno/aulas/'.$entrega->tarea->curso_id, 'Ver retroalimentación');

        return back()->with('success', 'Entrega calificada.');
    }

    public function forum(Request $request, Curso $curso)
    {
        $this->teacherCourse($curso);
        $data = $request->validate(['titulo' => ['required', 'string'], 'descripcion' => ['nullable', 'string'], 'cierra_at' => ['nullable', 'date'], 'unidad_id' => ['nullable', 'exists:unidades_lms,id']]);
        $forum = $curso->foros()->create($data);
        $this->auditContent($curso, 'CREAR', 'FORO', ['id' => $forum->id, 'titulo' => $forum->titulo]);

        return back()->with('success', 'Foro creado.');
    }

    public function post(Request $request, ForoLms $foro)
    {
        $this->participantCourse($foro->curso);
        abort_if($foro->cierra_at && now()->gt($foro->cierra_at), 422, 'El foro está cerrado.');
        $data = $request->validate(['contenido' => ['required', 'string', 'max:5000'], 'parent_id' => ['nullable', 'exists:publicaciones_foro_lms,id']]);
        if ($data['parent_id'] ?? null) {
            abort_unless($foro->publicaciones()->whereKey($data['parent_id'])->exists(), 404);
        }PublicacionForoLms::create($data + ['foro_id' => $foro->id, 'user_id' => auth()->id()]);

        return back()->with('success', 'Participación publicada.');
    }

    public function message(Request $request, Curso $curso)
    {
        $this->participantCourse($curso);
        $data = $request->validate(['destinatario_id' => ['nullable', 'exists:users,id'], 'asunto' => ['required', 'string', 'max:255'], 'mensaje' => ['required', 'string', 'max:5000']]);
        if ($data['destinatario_id'] ?? null) {
            abort_unless($curso->usuarios()->whereKey($data['destinatario_id'])->exists() || (int) $curso->user_id === (int) $data['destinatario_id'], 422);
        }MensajeLms::create($data + ['curso_id' => $curso->id, 'remitente_id' => auth()->id()]);

        return back()->with('success', 'Mensaje enviado.');
    }

    public function event(Request $request, Curso $curso)
    {
        $this->teacherCourse($curso);
        $data = $request->validate(['tipo' => ['required', 'in:CLASE,TAREA,EXAMEN,ASESORIA,OTRO'], 'titulo' => ['required', 'string'], 'descripcion' => ['nullable', 'string'], 'inicia_at' => ['required', 'date'], 'termina_at' => ['nullable', 'date', 'after:inicia_at'], 'url' => ['nullable', 'url']]);
        $event = EventoLms::create($data + ['curso_id' => $curso->id, 'creado_por' => auth()->id()]);
        $this->auditContent($curso, 'CREAR', 'EVENTO', ['id' => $event->id, 'titulo' => $event->titulo]);

        return back()->with('success', 'Evento agregado.');
    }

    public function deliveryFile(EntregaLms $entrega)
    {
        $this->participantCourse($entrega->tarea->curso);
        abort_unless(auth()->id() === $entrega->user_id || $this->isCourseTeacher($entrega->tarea->curso), 403);

        return Storage::disk('local')->download($entrega->archivo_path, $entrega->archivo_nombre);
    }

    public function lessonFile(Leccion $leccion)
    {
        $this->participantCourse($leccion->curso);
        abort_unless($leccion->archivo_path && Storage::disk('local')->exists($leccion->archivo_path), 404);
        if (! $this->isCourseTeacher($leccion->curso)) {
            abort_unless($leccion->publicada, 404);
            abort_if($leccion->disponible_desde && now()->lt($leccion->disponible_desde), 404);
            abort_if($leccion->disponible_hasta && now()->gt($leccion->disponible_hasta), 404);
        }

        return Storage::disk('local')->download($leccion->archivo_path, $leccion->archivo_nombre);
    }

    public function lessonContent(Leccion $leccion)
    {
        $this->participantCourse($leccion->curso);
        abort_unless($leccion->archivo_path && Storage::disk('local')->exists($leccion->archivo_path), 404);
        if (! $this->isCourseTeacher($leccion->curso)) {
            abort_unless($leccion->publicada, 404);
            abort_if($leccion->disponible_desde && now()->lt($leccion->disponible_desde), 404);
            abort_if($leccion->disponible_hasta && now()->gt($leccion->disponible_hasta), 404);
        }
        return Storage::disk('local')->response($leccion->archivo_path, $leccion->archivo_nombre, ['Content-Disposition'=>'inline']);
    }

    public function readMessage(MensajeLms $mensaje)
    {
        $this->studentCourse($mensaje->curso);
        abort_unless((int) $mensaje->destinatario_id === auth()->id() || $mensaje->destinatario_id === null, 403);
        $mensaje->update(['leido_at' => now()]);
        return back()->with('success', 'Mensaje marcado como leído.');
    }

    public function settings(Request $request, Curso $curso)
    {
        $this->teacherCourse($curso);
        $data = $request->validate([
            'cuota_mb' => ['required', 'integer', 'between:100,51200'],
            'calificacion_minima' => ['required', 'numeric', 'between:0,10'],
            'decimales' => ['required', 'integer', 'between:0,2'],
            'secuencia_obligatoria' => ['nullable', 'boolean'],
            'requiere_aprobacion_publicacion' => ['nullable', 'boolean'],
        ]);
        DB::table('configuracion_lms')->updateOrInsert(['curso_id' => $curso->id], $data + [
            'secuencia_obligatoria' => $request->boolean('secuencia_obligatoria'),
            'requiere_aprobacion_publicacion' => $request->boolean('requiere_aprobacion_publicacion'),
            'created_at' => now(), 'updated_at' => now(),
        ]);
        $this->auditContent($curso, 'CONFIGURAR', 'AULA', $data);
        return back()->with('success', 'Políticas del aula actualizadas.');
    }

    public function trashLesson(Leccion $leccion)
    {
        $this->teacherCourse($leccion->curso);
        DB::table('versiones_contenido_lms')->insert([
            'curso_id' => $leccion->curso_id, 'leccion_id' => $leccion->id, 'version' => $leccion->version,
            'contenido' => json_encode($leccion->toArray()), 'creado_por' => auth()->id(), 'creado_at' => now(),
            'created_at' => now(), 'updated_at' => now(),
        ]);
        $course = $leccion->curso;
        $leccion->delete();
        $this->auditContent($course, 'ENVIAR_PAPELERA', 'LECCION', ['id' => $leccion->id, 'titulo' => $leccion->titulo]);
        return back()->with('success', 'Contenido enviado a la papelera; puede recuperarse.');
    }

    public function restoreLesson(int $lesson)
    {
        $leccion = Leccion::withTrashed()->findOrFail($lesson);
        $this->teacherCourse($leccion->curso);
        $leccion->restore();
        $this->auditContent($leccion->curso, 'RESTAURAR', 'LECCION', ['id' => $leccion->id]);
        return back()->with('success', 'Contenido restaurado.');
    }

    public function bulkGrade(Request $request, TareaLms $tarea, InstitutionalNotificationService $notifications)
    {
        $this->teacherCourse($tarea->curso);
        $data = $request->validate(['calificaciones' => ['required', 'array'], 'calificaciones.*' => ['nullable', 'numeric', 'between:0,'.$tarea->puntaje_maximo]]);
        foreach ($data['calificaciones'] as $deliveryId => $score) {
            if ($score === null || $score === '') continue;
            $delivery = $tarea->entregas()->whereKey($deliveryId)->firstOrFail();
            $delivery->update(['calificacion' => $score, 'retroalimentacion' => 'Calificación registrada de forma masiva.', 'estatus' => 'CALIFICADA', 'calificada_por' => auth()->id(), 'calificada_at' => now()]);
            $notifications->notifyUser($tarea->curso->sede_id, $delivery->user_id, 'CALIFICACION-MASIVA-'.$delivery->id.'-'.$delivery->updated_at->timestamp, 'ACADEMICO', 'Actividad calificada', $tarea->titulo.' recibió '.$score.' puntos.', '/alumno/aulas/'.$tarea->curso_id, 'Ver calificación');
        }
        return back()->with('success', 'Calificaciones masivas guardadas.');
    }

    public function exportGrades(Curso $curso)
    {
        $this->teacherCourse($curso);
        $curso = $this->loadRoom($curso);
        $rows = [['Matrícula', 'Alumno', 'Correo', 'Tarea', 'Calificación', 'Estatus']];
        foreach ($curso->tareas as $task) {
            foreach ($curso->usuarios as $student) {
                $delivery = $task->entregas->firstWhere('user_id', $student->id);
                $rows[] = [$student->matriculaEnSede($curso->sede_id), $student->name, $student->email, $task->titulo, $delivery?->calificacion, $delivery?->estatus ?? 'SIN ENTREGA'];
            }
        }

        return response()->streamDownload(function () use ($rows) {
            $output = fopen('php://output', 'w');
            fwrite($output, "\xEF\xBB\xBF");
            foreach ($rows as $row) fputcsv($output, $row);
            fclose($output);
        }, 'calificaciones-'.Str::slug($curso->nombre).'.csv', ['Content-Type' => 'text/csv; charset=UTF-8']);
    }

    public function announcement(Request $request, Curso $curso, InstitutionalNotificationService $notifications)
    {
        $this->teacherCourse($curso);
        $data = $request->validate(['titulo' => ['required', 'string', 'max:255'], 'mensaje' => ['required', 'string', 'max:5000'], 'vence_at' => ['nullable', 'date', 'after:now'], 'destacado' => ['nullable', 'boolean']]);
        $announcement = $curso->anuncios()->create($data + ['creado_por' => auth()->id(), 'publicado_at' => now(), 'destacado' => $request->boolean('destacado')]);
        foreach ($curso->usuarios as $student) {
            $notifications->notifyUser($curso->sede_id, $student->id, 'ANUNCIO-LMS-'.$announcement->id.'-'.$student->id, 'ACADEMICO', $announcement->titulo, $announcement->mensaje, '/alumno/aulas/'.$curso->id, 'Abrir aula');
        }
        $this->auditContent($curso, 'PUBLICAR', 'ANUNCIO', ['id' => $announcement->id, 'titulo' => $announcement->titulo]);

        return back()->with('success', 'Anuncio publicado y notificado.');
    }

    public function survey(Request $request, Curso $curso)
    {
        $this->teacherCourse($curso);
        $data = $request->validate(['titulo' => ['required', 'string', 'max:255'], 'pregunta' => ['required', 'string', 'max:3000'], 'disponible_hasta' => ['nullable', 'date', 'after:now'], 'anonima' => ['nullable', 'boolean']]);
        $survey = $curso->encuestas()->create($data + ['creado_por' => auth()->id(), 'anonima' => $request->boolean('anonima'), 'publicada' => true]);
        $this->auditContent($curso, 'PUBLICAR', 'ENCUESTA', ['id' => $survey->id, 'titulo' => $survey->titulo]);

        return back()->with('success', 'Encuesta publicada.');
    }

    public function answerSurvey(Request $request, \App\Models\EncuestaLms $encuesta)
    {
        $this->studentCourse($encuesta->curso);
        abort_if(! $encuesta->publicada || ($encuesta->disponible_hasta && now()->gt($encuesta->disponible_hasta)), 422, 'La encuesta no está disponible.');
        $data = $request->validate(['valor' => ['required', 'integer', 'between:1,5'], 'comentario' => ['nullable', 'string', 'max:3000']]);
        $identity = $encuesta->anonima ? ['token_anonimo' => hash('sha256', $encuesta->id.'|'.auth()->id().'|'.config('app.key'))] : ['user_id' => auth()->id()];
        \App\Models\RespuestaEncuestaLms::updateOrCreate(['encuesta_id' => $encuesta->id] + $identity, $data + ($encuesta->anonima ? ['user_id' => null] : []));

        return back()->with('success', 'Respuesta registrada.');
    }

    public function importBankQuestion(Request $request, Curso $curso)
    {
        $this->teacherCourse($curso);
        $data = $request->validate(['examen_id' => ['required', 'exists:examenes,id'], 'pregunta_id' => ['required', 'exists:banco_preguntas_lms,id']]);
        $exam = $curso->examenes()->findOrFail($data['examen_id']);
        $question = DB::table('banco_preguntas_lms')->where('sede_id', $curso->sede_id)->find($data['pregunta_id']);
        abort_unless($question, 404);
        $exam->preguntas()->create(collect((array) $question)->only(['texto_pregunta', 'opcion_a', 'opcion_b', 'opcion_c', 'opcion_d', 'opcion_correcta', 'retroalimentacion'])->all());
        $this->auditContent($curso, 'REUTILIZAR', 'PREGUNTA_BANCO', ['pregunta_id' => $question->id, 'examen_id' => $exam->id]);

        return back()->with('success', 'Reactivo agregado desde el banco.');
    }

    public function cloneCourse(Request $request, Curso $curso)
    {
        $this->teacherCourse($curso);
        $data = $request->validate(['nombre' => ['required', 'string', 'max:255']]);
        $copy = DB::transaction(function () use ($curso, $data) {
            $copy = Curso::create(['nombre' => $data['nombre'], 'descripcion' => $curso->descripcion, 'user_id' => auth()->id(), 'sede_id' => $curso->sede_id, 'curso_origen_id' => $curso->id]);
            foreach ($curso->unidades as $unit) $copy->unidades()->create($unit->only(['titulo', 'descripcion', 'orden', 'disponible_desde', 'disponible_hasta']) + ['publicada' => false]);
            foreach ($curso->lecciones as $lesson) $copy->lecciones()->create($lesson->only(['titulo', 'contenido_texto', 'url_recurso', 'orden', 'tipo', 'transcripcion', 'descripcion_accesible']) + ['publicada' => false]);
            foreach ($curso->examenes()->with('preguntas')->get() as $exam) {
                $newExam = $copy->examenes()->create($exam->only(['titulo', 'limite_tiempo', 'instrucciones', 'intentos_permitidos', 'aleatorizar_preguntas', 'calificacion_minima', 'mostrar_resultado']) + ['publicado' => false]);
                foreach ($exam->preguntas as $question) $newExam->preguntas()->create($question->only(['texto_pregunta', 'opcion_a', 'opcion_b', 'opcion_c', 'opcion_d', 'opcion_correcta', 'retroalimentacion']));
            }
            return $copy;
        });
        $this->auditContent($copy, 'CLONAR', 'CURSO', ['curso_origen_id' => $curso->id]);

        return redirect()->route('docente.aulas.show', $copy)->with('success', 'Curso copiado como borrador.');
    }

    private function loadRoom(Curso $course): Curso
    {
        return $course->load(['sede', 'usuarios.persona', 'unidades', 'lecciones', 'examenes.preguntas', 'tareas.criterios', 'tareas.entregas.alumno', 'foros.publicaciones', 'eventos', 'anuncios', 'encuestas.respuestas', 'gruposAcademicos.periodo', 'gruposAcademicos.materia', 'gruposIdioma.periodo', 'gruposIdioma.nivel.idioma']);
    }

    private function teacherCourse(Curso $course): void
    {
        abort_unless((int) $course->sede_id === app(InstitutionalContext::class)->sedeId() && $this->isCourseTeacher($course), 404);
    }

    private function studentCourse(Curso $course): void
    {
        abort_unless((int) $course->sede_id === app(InstitutionalContext::class)->sedeId() && $course->usuarios()->whereKey(auth()->id())->exists(), 404);
    }

    private function participantCourse(Curso $course): void
    {
        if ($this->isCourseTeacher($course)) {
            $this->teacherCourse($course);
        } else {
            $this->studentCourse($course);
        }
    }

    private function isCourseTeacher(Curso $course): bool
    {
        return (int) $course->user_id === auth()->id()
            || GrupoAcademico::where('curso_lms_id', $course->id)->whereHas('docentes', fn ($query) => $query->whereKey(auth()->id()))->exists()
            || GrupoIdioma::where('curso_lms_id', $course->id)->where('docente_id', auth()->id())->exists();
    }

    private function auditContent(Curso $course, string $action, string $type, array $data): void
    {
        DB::table('historial_contenido_lms')->insert(['curso_id' => $course->id, 'user_id' => auth()->id(), 'accion' => $action, 'recurso_tipo' => $type, 'recurso_id' => $data['id'] ?? null, 'datos' => json_encode($data), 'created_at' => now(), 'updated_at' => now()]);
    }
}
