<?php

namespace App\Http\Controllers;

use App\Models\Docente;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Validator;
use Illuminate\Support\Facades\Hash;
use App\Traits\FileTrait;
use App\Traits\UserTrait;
use Spatie\ImageOptimizer\OptimizerChainFactory;
use Carbon\Carbon;
use Illuminate\Support\Facades\Log;

class DocenteController extends Controller
{
    use FileTrait, UserTrait;

    public function index($domain_id)
    {
        $docentes = DB::table('docentes as d')
            ->select('d.*', DB::raw('TIMESTAMPDIFF(YEAR, fecha_nacimiento, CURDATE()) as edad'))
            ->where('d.domain_id', $domain_id)
            ->get();

        foreach ($docentes as $docente) {
            if ($docente->foto) {
                $docente->foto = 'data:image/jpeg;base64,' . $docente->foto;
            } else {
                // Manejar el caso donde la foto no existe
                $docente->foto = null;
            }
        }

        return response()->json(['Exito' => true, 'Datos' => $docentes], 200);
    }

    public function getLoggedDocente($docente_id, $dominio)
    {
        $docente = Docente::leftJoin('domains', 'domains.id', '=', 'docentes.domain_id')
            ->select(
                'docentes.*',
                'domains.nombre as institucion',
                DB::raw('TIMESTAMPDIFF(YEAR, fecha_nacimiento, CURDATE()) as edad')

            )
            ->where('docentes.id', $docente_id)
            ->where('docentes.domain_id', $dominio)
            ->first();

        if ($docente) {
            // Si la foto existe, añade el prefijo base64
            if ($docente->foto) {
                $docente->foto = 'data:image/jpeg;base64,' . $docente->foto;
            }
            return response()->json($docente);
        }

        return response()->json('Docente no encontrado', 404);
    }

    public function imagen(Request $request)
    {
        $base64Image = $request->input('base64');
        if (!preg_match('/^data:image\/(\w+);base64,/', $base64Image, $matches)) {
            return response()->json(['Error' => true, 'Mensaje' => 'Imagen inválida']);
        }
        $imageType = $matches[1];
        $base64Image = preg_replace('/^data:image\/\w+;base64,/', '', $base64Image);
        $image = base64_decode($base64Image);

        // Generar un nombre único para el archivo
        $imageName = uniqid() . '.' . $imageType;

        // Definir la ruta donde se guardará la imagen
        $imagePath = storage_path('app\\public\\docentes\\' . $imageName);

        // Crear el directorio si no existe
        if (!file_exists(dirname($imagePath))) {
            mkdir(dirname($imagePath), 0777, true);
        }

        // Guardar la imagen en el disco
        file_put_contents($imagePath, $image);
        return response()->json($imagePath);
    }

    public function show($domain_id, $id)
    {
        // Asegúrate de filtrar también por el domain_id
        $docente = Docente::select(
            'id',
            'codigo',
            'nombres',
            'celular',
            'profesion',
            'tipo_documento',
            'doc_identidad',
            'fecha_nacimiento',
            'genero',
            'foto',
            'roles',
            'email',
            DB::raw('TIMESTAMPDIFF(YEAR, fecha_nacimiento, CURDATE()) as edad')
        )
            ->where('id', $id)
            ->where('domain_id', $domain_id) // Filtro por dominio
            ->first();

        if (!$docente) {
            return response()->json(['Error' => 'Docente no encontrado'], 404);
        }

        return response()->json(['Exito' => true, 'Datos' => $docente], 200);
    }

    public function store(Request $request)
    {
        DB::beginTransaction();
        try {
            // Validar los campos de entrada
            $validator = Validator::make($request->all(), [
                'codigo' => 'required|string|max:20',
                'nombres' => 'required|string|max:200',
                'contraseña' => 'required|string|max:30',
                'celular' => 'required|string|max:20',
                'profesion' => 'required|string|max:200',
                'tipo_documento' => 'required|string|max:20',
                'doc_identidad' => 'required|string|max:20',
                'fecha_nacimiento' => 'required|date|before:today',
                'genero' => 'required|string|max:100',
                'foto' => 'nullable|string', // La foto es opcional y debe ser una cadena base64
                'roles' => 'required|string|max:100',
                'email' => 'required|email',
                'domain_id' => 'required|integer',
            ]);

            if ($validator->fails()) {
                return response()->json(['Error' => $validator->errors()], 422);
            }

            // Procesar la imagen base64
            $imageBase64 = $request->input('foto');
            $imagePath = null;

            if ($imageBase64) {
                // Verifica si la imagen está en formato base64
                if (preg_match('/^data:image\/(\w+);base64,/', $imageBase64, $matches)) {
                    $imageType = $matches[1]; // Obtener el tipo de imagen (jpeg, png, etc.)
                    $imageBase64 = preg_replace('/^data:image\/\w+;base64,/', '', $imageBase64);
                    $image = base64_decode($imageBase64);

                    // Puedes optar por almacenar la imagen directamente en Base64 o convertir a formato adecuado
                    // Guarda la cadena base64 en la base de datos
                    $imagePath = $imageBase64;
                }
            }
            $docenteRol = DB::table('rol')->where('nombre', 'Docentes')->first();

            if (!$docenteRol) {
                return response()->json(['Error' => true, 'Mensaje' => 'El rol "Docentes" no existe en la base de datos.'], 400);
            }
            // Guardar el docente
            $docenteData = [
                'codigo' => $request->codigo,
                'nombres' => $request->nombres,
                'celular' => $request->celular,
                'profesion' => $request->profesion,
                'tipo_documento' => $request->tipo_documento,
                'doc_identidad' => $request->doc_identidad,
                'fecha_nacimiento' => $request->fecha_nacimiento,
                'genero' => $request->genero,
                'foto' => $imagePath, // La imagen en formato Base64
                'roles' => $request->roles,
                'email' => $request->email,
                'domain_id' => $request->domain_id
            ];

            $docenteId = DB::table('docentes')->insertGetId($docenteData);

            // Guardar también los datos del usuario
            $userData = [
                'name' => $request->nombres,
                'email' => $request->email,
                'password' => Hash::make($request->contraseña),
                'rol_id' => $docenteRol->id,
                'domain_id' => $request->domain_id,
                'docente_id' => $docenteId,
                'password_changed' => false,
                'password_changed_at' => null,
                'created_at' => Carbon::now(),
                'updated_at' => Carbon::now()
            ];
            DB::table('users')->insert($userData);

            // Enviar correo de bienvenida con enlace de cambio de contraseña
            try {
                $docente = (object) array_merge($docenteData, ['email' => $request->email, 'codigo' => $request->codigo, 'profesion' => $request->profesion]);
                $passwordResetController = new \App\Http\Controllers\FrontendPasswordController();
                $resetUrl = $passwordResetController->generateResetUrl($request->email);
                $emailService = new \App\Services\EmailService();
                $emailService->sendWelcomeEmailDocente($docente, $resetUrl);
            } catch (\Exception $e) {
                Log::error('Error al enviar correo de bienvenida a docente: ' . $e->getMessage());
            }

            DB::commit();
            return response()->json(['Exito' => true, 'Mensaje' => 'Registro exitoso'], 201);
        } catch (\Exception $e) {
            DB::rollBack();
            return response()->json(['Error' => true, 'Mensaje' => $e->getMessage()], 500);
        }
    }

    public function storeMasivos(Request $request)
    {
        DB::beginTransaction();
        try {
            // Validar que se reciba un array de docentes directamente
            $validator = Validator::make($request->all(), [
                '*.codigo' => 'required|string|max:20',
                '*.nombres' => 'required|string|max:200',
                '*.contraseña' => 'required|string|max:30',
                '*.celular' => 'required|string|max:20',
                '*.profesion' => 'required|string|max:200',
                '*.tipo_documento' => 'required|string|max:20',
                '*.doc_identidad' => 'required|string|max:20',
                '*.genero' => 'required|string|max:100',
                '*.foto' => 'nullable|string', // La foto es opcional y debe ser una cadena base64
                '*.roles' => 'required|string|max:100',
                '*.email' => 'required|email',
                '*.domain_id' => 'required|integer',
            ]);

            if ($validator->fails()) {
                return response()->json(['Error' => $validator->errors()], 422);
            }

            // Validar que el request sea un array
            $docentesData = $request->all();
            if (!is_array($docentesData) || empty($docentesData)) {
                return response()->json(['Error' => 'Se requiere un array de docentes'], 400);
            }

            // Obtener el rol de docentes una sola vez
            $docenteRol = DB::table('rol')->where('nombre', 'Docentes')->first();

            if (!$docenteRol) {
                return response()->json(['Error' => true, 'Mensaje' => 'El rol "Docentes" no existe en la base de datos.'], 400);
            }

            $docentesCreados = [];
            $docentesActualizados = [];

            // Procesar cada docente del array
            foreach ($docentesData as $index => $docenteData) {

                // Verificar si el docente ya existe por código
                $docenteExistente = DB::table('docentes')
                    ->where('codigo', $docenteData['codigo'])
                    ->where('domain_id', $docenteData['domain_id'])
                    ->first();

                // Validación de email según si el docente existe o no
                if ($docenteExistente) {
                    // CASO: Docente existe - verificar si hay más de 2 registros con el mismo email
                    $countEmailExist = DB::table('users')
                        ->where('email', $docenteData['email'])
                        ->count();

                    if ($countEmailExist >= 2) {
                        throw new \Exception("Docente en posición {$index}: El email {$docenteData['email']} ya existe en 2 o más registros");
                    }

                    // CASO: Docente existe - verificar si hay más de 2 registros con el mismo doc_identidad
                    $countDocExist = DB::table('docentes')
                        ->where('doc_identidad', $docenteData['doc_identidad'])
                        ->count();

                    if ($countDocExist >= 2) {
                        throw new \Exception("Docente en posición {$index}: El documento de identidad {$docenteData['doc_identidad']} ya existe en 2 o más registros");
                    }
                } else {
                    // CASO: Docente nuevo - verificar que el email no exista en absoluto
                    $emailExist = DB::table('users')
                        ->where('email', $docenteData['email'])
                        ->first();

                    if ($emailExist) {
                        throw new \Exception("Docente en posición {$index}: El email {$docenteData['email']} ya existe");
                    }

                    // CASO: Docente nuevo - verificar que el documento de identidad no exista
                    $docExist = DB::table('docentes')
                        ->where('doc_identidad', $docenteData['doc_identidad'])
                        ->first();

                    if ($docExist) {
                        throw new \Exception("Docente en posición {$index}: El documento de identidad {$docenteData['doc_identidad']} ya existe");
                    }
                }

                // Procesar la imagen base64
                $imageBase64 = $docenteData['foto'] ?? null;
                $imagePath = null;

                if ($imageBase64) {
                    // Verifica si la imagen está en formato base64
                    if (preg_match('/^data:image\/(\w+);base64,/', $imageBase64, $matches)) {
                        $imageType = $matches[1]; // Obtener el tipo de imagen (jpeg, png, etc.)
                        $imageBase64 = preg_replace('/^data:image\/\w+;base64,/', '', $imageBase64);
                        $image = base64_decode($imageBase64);

                        // Validar que la decodificación fue exitosa
                        if ($image === false) {
                            throw new \Exception("Docente en posición {$index}: Imagen base64 inválida");
                        }

                        // Guarda la cadena base64 en la base de datos
                        $imagePath = $imageBase64;
                    }
                }

                $fechaNacimiento = $docenteData['fecha_nacimiento'];
                if (!empty($fechaNacimiento) && is_string($fechaNacimiento)) {
                    try {
                        $fechaNacimiento = Carbon::createFromFormat('d/m/Y', trim($fechaNacimiento))->format('Y-m-d');
                    } catch (\Exception $e) {
                        $fechaNacimiento = date('Y-m-d');
                    }
                } else {
                    $fechaNacimiento = date('Y-m-d');
                }

                // Preparar datos del docente
                $docenteDataForDB = [
                    'codigo' => $docenteData['codigo'],
                    'nombres' => $docenteData['nombres'],
                    'celular' => $docenteData['celular'],
                    'profesion' => $docenteData['profesion'],
                    'tipo_documento' => $docenteData['tipo_documento'],
                    'doc_identidad' => $docenteData['doc_identidad'],
                    'fecha_nacimiento' => $fechaNacimiento,
                    'genero' => $docenteData['genero'],
                    'foto' => $imagePath,
                    'roles' => $docenteData['roles'],
                    'email' => $docenteData['email'],
                    'domain_id' => $docenteData['domain_id'],
                    'updated_at' => Carbon::now()
                ];

                $docenteId = null;
                $esActualizacion = false;

                if ($docenteExistente) {
                    // ACTUALIZAR docente existente
                    DB::table('docentes')
                        ->where('id', $docenteExistente->id)
                        ->update($docenteDataForDB);

                    $docenteId = $docenteExistente->id;
                    $esActualizacion = true;

                    // Actualizar también el usuario correspondiente
                    DB::table('users')
                        ->where('docente_id', $docenteId)
                        ->update([
                            'name' => $docenteData['nombres'],
                            'email' => $docenteData['email'],
                            'password' => Hash::make($docenteData['contraseña']),
                            'updated_at' => Carbon::now()
                        ]);
                } else {
                    // CREAR nuevo docente
                    $docenteDataForDB['created_at'] = Carbon::now();
                    $docenteId = DB::table('docentes')->insertGetId($docenteDataForDB);

                    // Crear el usuario correspondiente
                    $userData = [
                        'name' => $docenteData['nombres'],
                        'email' => $docenteData['email'],
                        'password' => Hash::make($docenteData['contraseña']),
                        'rol_id' => $docenteRol->id,
                        'domain_id' => $docenteData['domain_id'],
                        'docente_id' => $docenteId,
                        'created_at' => Carbon::now(),
                        'updated_at' => Carbon::now()
                    ];

                    DB::table('users')->insert($userData);
                }

                // Agregar a la lista correspondiente
                $docenteInfo = [
                    'docente_id' => $docenteId,
                    'codigo' => $docenteData['codigo'],
                    'nombres' => $docenteData['nombres'],
                    'email' => $docenteData['email'],
                    'fecha_nacimiento' => $fechaNacimiento
                ];

                if ($esActualizacion) {
                    $docentesActualizados[] = $docenteInfo;
                } else {
                    $docentesCreados[] = $docenteInfo;
                }
            }

            DB::commit();

            return response()->json([
                'Exito' => true,
                'Mensaje' => 'Proceso completado: ' . count($docentesCreados) . ' docentes creados, ' . count($docentesActualizados) . ' docentes actualizados',
                'docentes_creados' => count($docentesCreados),
                'docentes_actualizados' => count($docentesActualizados),
                'total_procesados' => count($docentesData),
                'docentes_nuevos' => $docentesCreados,
                'docentes_actualizados' => $docentesActualizados
            ], 201);
        } catch (\Exception $e) {
            DB::rollBack();

            return response()->json([
                'message' => 'Error al procesar los docentes: ' . $e->getMessage(),
                'details' => config('app.debug') ? $e->getTraceAsString() : null
            ], 500);
        }
    }

    public function update(Request $request, $id)
    {
        DB::beginTransaction();
        try {
            // Verificar si el docente existe
            $docente = Docente::find($id);
            if (!$docente) {
                return response()->json(['Error' => 'Docente no encontrado'], 404);
            }

            // Validar los campos de entrada
            $validator = Validator::make($request->all(), [
                'codigo' => 'required|string|max:20',
                'nombres' => 'required|string|max:200',
                'clave' => 'nullable|string|max:30', // Clave es opcional
                'celular' => 'required|string|max:20',
                'profesion' => 'required|string|max:30',
                'tipo_documento' => 'required|string|max:20',
                'doc_identidad' => 'required|string|max:20|unique:docentes,doc_identidad,' . $id,
                'fecha_nacimiento' => 'required|date|before:today',
                'genero' => 'required|string|max:100',
                'roles' => 'required|string|max:100',
                'email' => 'required|email',
            ]);

            if ($validator->fails()) {
                return response()->json(['Error' => $validator->errors()], 422);
            }

            // Procesar la imagen si se envía una nueva
            $imageBase64 = $request->input('foto');
            if ($imageBase64) {
                // Verifica si la imagen está en formato base64
                if (preg_match('/^data:image\/(\w+);base64,/', $imageBase64, $matches)) {
                    $imageType = $matches[1]; // Obtener el tipo de imagen (jpeg, png, etc.)
                    $imageBase64 = preg_replace('/^data:image\/\w+;base64,/', '', $imageBase64);
                    $image = base64_decode($imageBase64);

                    // Guarda la cadena base64 en la base de datos
                    $docente->foto = $imageBase64;
                }
            }

            // Actualizar los datos del docente
            $docente->update([
                "codigo" => $request->codigo,
                "nombres" => $request->nombres,
                "celular" => $request->celular,
                "profesion" => $request->profesion,
                "tipo_documento" => $request->tipo_documento,
                "doc_identidad" => $request->doc_identidad,
                "fecha_nacimiento" => $request->fecha_nacimiento,
                "genero" => $request->genero,
                "roles" => $request->roles,
                'email' => $request->email,
                // No actualizar "foto" si no se envía una nueva imagen
            ]);

            // Actualizar los datos correspondientes en la tabla users
            $userData = [
                'name' => $request->nombres,
                'email' => $request->email,
                'domain_id' => $request->domain_id, // Usa el domain_id si es relevante en la actualización
                'docente_id' => $id,
            ];

            // Solo actualizar la contraseña si se envía una nueva
            if ($request->filled('clave')) {
                $userData['password'] = Hash::make($request->clave);
            }

            // Actualiza la tabla users donde el docente_id coincide
            DB::table('users')->where('docente_id', $id)->update($userData);

            DB::commit();
            return response()->json(['Exito' => true, 'Mensaje' => 'Docente y usuario actualizados correctamente'], 200);
        } catch (\Exception $e) {
            DB::rollBack();
            return response()->json(['Error' => true, 'Mensaje' => $e->getMessage()], 500);
        }
    }


    public function destroy($id)
    {
        DB::beginTransaction();
        try {
            // Elimina primero los registros relacionados en la tabla `users`
            DB::table('users')->where('docente_id', $id)->delete();

            // Luego elimina el docente
            $docente = Docente::find($id);
            if (!$docente) {
                DB::rollBack();
                return response()->json(['Error' => 'Docente no encontrado'], 404);
            }
            $docente->delete();

            DB::commit();
            return response()->json(['Mensaje' => 'Docente eliminado'], 200);
        } catch (\Exception $e) {
            DB::rollBack();
            return response()->json(['Error' => $e->getMessage()], 500);
        }
    }

    public function dropDown($domain_id)
    {
        $docentes = Docente::select('id', 'nombres')->where('domain_id', $domain_id)->get();
        return response()->json($docentes);
    }

    /**
     * Obtener todos los alumnos que llevan/llevaron cursos de un docente específico
     * con información del estado y fechas
     */
    public function getAlumnosPorDocente($docente_id, $domain_id)
    {
        try {
            $alumnos = DB::table('curso_alumno')
                ->join('cursos', 'cursos.id', '=', 'curso_alumno.curso_id')
                ->join('alumnos', 'alumnos.id', '=', 'curso_alumno.alumno_id')
                ->leftJoin('ciclos', 'ciclos.id', '=', 'cursos.ciclo_id')
                ->leftJoin('carreras', 'carreras.id', '=', 'cursos.carrera_id')
                ->leftJoin('promociones', 'promociones.id', '=', 'alumnos.promocion_id')
                ->leftJoin('estado_curso_alumno', 'curso_alumno.estado_curso_id', '=', 'estado_curso_alumno.id')
                ->where('cursos.docente_id', $docente_id)
                ->where('cursos.domain_id', $domain_id)
                ->where('alumnos.estadoAlumno', '!=', 'RETIRADO')
                ->select([
                    // Datos del alumno
                    'alumnos.id as alumno_id',
                    'alumnos.codigo as alumno_codigo',
                    'alumnos.nombres as alumno_nombres',
                    'alumnos.apellidos as alumno_apellidos',
                    'alumnos.email as alumno_email',
                    'alumnos.celular as alumno_celular',
                    'alumnos.estadoAlumno as estado_alumno',

                    // Datos del curso
                    'cursos.id as curso_id',
                    'cursos.codigo as curso_codigo',
                    'cursos.nombre as curso_nombre',
                    'cursos.cantidad_de_creditos',
                    'cursos.cantidad_de_horas',

                    // Datos académicos
                    'ciclos.nombre as ciclo_nombre',
                    'carreras.nombres as carrera_nombre',
                    'promociones.nombre_promocion as promocion_nombre',

                    // Estado del curso-alumno
                    'curso_alumno.estado_id',
                    'curso_alumno.estado_curso_id',
                    'curso_alumno.updated_at as fecha_actualizacion',
                    'estado_curso_alumno.nombre as estado_curso_nombre',
                    'estado_curso_alumno.color as estado_color',

                    // Estado calculado
                    DB::raw("IF(estado_curso_alumno.nombre IS NULL, 'PENDIENTE', estado_curso_alumno.nombre) as estadoCursoAlumno"),

                    // Información adicional
                    DB::raw("
                    CASE 
                        WHEN curso_alumno.estado_id = 6 THEN 'FINALIZADO'
                        WHEN curso_alumno.estado_id = 2 THEN 'EN PROCESO'
                        WHEN curso_alumno.estado_id = 1 THEN 'PENDIENTE'
                        ELSE 'DESCONOCIDO'
                    END as estado_administrativo
                "),

                    // Fecha de finalización (cuando se aprobó/desaprobó)
                    DB::raw("
                    CASE 
                        WHEN estado_curso_alumno.nombre IN ('APROBADO', 'DESAPROBADO') 
                        THEN curso_alumno.updated_at
                        ELSE NULL
                    END as fecha_finalizacion
                ")
                ])
                ->orderBy('carreras.nombres')
                ->orderBy('ciclos.nombre')
                ->orderBy('cursos.nombre')
                ->orderBy('alumnos.apellidos')
                ->orderBy('alumnos.nombres')
                ->get();

            // Agrupar por curso para mejor organización
            $cursosPorDocente = $alumnos->groupBy('curso_id')->map(function ($alumnosPorCurso) {
                $primerAlumno = $alumnosPorCurso->first();

                return [
                    'curso' => [
                        'id' => $primerAlumno->curso_id,
                        'codigo' => $primerAlumno->curso_codigo,
                        'nombre' => $primerAlumno->curso_nombre,
                        'creditos' => $primerAlumno->cantidad_de_creditos,
                        'horas' => $primerAlumno->cantidad_de_horas,
                        'ciclo' => $primerAlumno->ciclo_nombre,
                        'carrera' => $primerAlumno->carrera_nombre
                    ],
                    'estadisticas' => [
                        'total_alumnos' => $alumnosPorCurso->count(),
                        'aprobados' => $alumnosPorCurso->where('estadoCursoAlumno', 'APROBADO')->count(),
                        'desaprobados' => $alumnosPorCurso->where('estadoCursoAlumno', 'DESAPROBADO')->count(),
                        'en_proceso' => $alumnosPorCurso->where('estadoCursoAlumno', 'EN PROCESO')->count(),
                        'pendientes' => $alumnosPorCurso->where('estadoCursoAlumno', 'PENDIENTE')->count(),
                        'finalizados' => $alumnosPorCurso->where('estado_administrativo', 'FINALIZADO')->count()
                    ],
                    'alumnos' => $alumnosPorCurso->map(function ($alumno) {
                        return [
                            'alumno_id' => $alumno->alumno_id,
                            'codigo' => $alumno->alumno_codigo,
                            'nombres' => $alumno->alumno_nombres,
                            'apellidos' => $alumno->alumno_apellidos,
                            'email' => $alumno->alumno_email,
                            'celular' => $alumno->alumno_celular,
                            'promocion' => $alumno->promocion_nombre,
                            'estado_alumno' => $alumno->estado_alumno,
                            'estado_curso' => $alumno->estadoCursoAlumno,
                            'estado_administrativo' => $alumno->estado_administrativo,
                            'color_estado' => $alumno->estado_color ?: '#909090',
                            'fecha_actualizacion' => $alumno->fecha_actualizacion,
                            'fecha_finalizacion' => $alumno->fecha_finalizacion,
                            'dias_desde_finalizacion' => $alumno->fecha_finalizacion ?
                                Carbon::parse($alumno->fecha_finalizacion)->diffInDays(Carbon::now()) : null
                        ];
                    })->values()
                ];
            })->values();

            // Estadísticas generales
            $estadisticasGenerales = [
                'total_cursos' => $cursosPorDocente->count(),
                'total_alumnos' => $alumnos->count(),
                'total_aprobados' => $alumnos->where('estadoCursoAlumno', 'APROBADO')->count(),
                'total_desaprobados' => $alumnos->where('estadoCursoAlumno', 'DESAPROBADO')->count(),
                'total_en_proceso' => $alumnos->where('estadoCursoAlumno', 'EN PROCESO')->count(),
                'total_pendientes' => $alumnos->where('estadoCursoAlumno', 'PENDIENTE')->count(),
                'porcentaje_aprobacion' => $alumnos->count() > 0 ?
                    round(($alumnos->where('estadoCursoAlumno', 'APROBADO')->count() / $alumnos->count()) * 100, 2) : 0
            ];

            return response()->json([
                'success' => true,
                'data' => [
                    'cursos' => $cursosPorDocente,
                    'estadisticas' => $estadisticasGenerales
                ]
            ], 200);
        } catch (\Exception $e) {
            Log::error('Error al obtener alumnos por docente: ' . $e->getMessage());

            return response()->json([
                'success' => false,
                'message' => 'Error al obtener los datos de alumnos',
                'error' => $e->getMessage()
            ], 500);
        }
    }

    /**
     * Obtener alumnos de un curso específico del docente
     */
    public function getAlumnosPorCurso($docente_id, $curso_id, $domain_id)
    {
        try {
            // Verificar que el curso pertenece al docente
            $cursoDocente = DB::table('cursos')
                ->where('id', $curso_id)
                ->where('docente_id', $docente_id)
                ->where('domain_id', $domain_id)
                ->first();

            if (!$cursoDocente) {
                return response()->json([
                    'success' => false,
                    'message' => 'Curso no encontrado o no pertenece al docente'
                ], 404);
            }

            $alumnos = DB::table('curso_alumno')
                ->join('alumnos', 'alumnos.id', '=', 'curso_alumno.alumno_id')
                ->leftJoin('promociones', 'promociones.id', '=', 'alumnos.promocion_id')
                ->leftJoin('estado_curso_alumno', 'curso_alumno.estado_curso_id', '=', 'estado_curso_alumno.id')
                ->where('curso_alumno.curso_id', $curso_id)
                ->where('alumnos.estadoAlumno', '!=', 'RETIRADO')
                ->select([
                    'alumnos.id as alumno_id',
                    'alumnos.codigo',
                    'alumnos.nombres',
                    'alumnos.apellidos',
                    'alumnos.email',
                    'alumnos.celular',
                    'alumnos.estadoAlumno',
                    'promociones.nombre_promocion as promocion',
                    'curso_alumno.estado_id',
                    'curso_alumno.updated_at as fecha_actualizacion',
                    'estado_curso_alumno.nombre as estado_curso',
                    'estado_curso_alumno.color as color_estado',
                    DB::raw("IF(estado_curso_alumno.nombre IS NULL, 'PENDIENTE', estado_curso_alumno.nombre) as estadoCursoAlumno"),
                    DB::raw("
                    CASE 
                        WHEN estado_curso_alumno.nombre IN ('APROBADO', 'DESAPROBADO') 
                        THEN curso_alumno.updated_at
                        ELSE NULL
                    END as fecha_finalizacion
                ")
                ])
                ->orderBy('alumnos.apellidos')
                ->orderBy('alumnos.nombres')
                ->get();

            return response()->json([
                'success' => true,
                'data' => $alumnos
            ], 200);
        } catch (\Exception $e) {
            Log::error('Error al obtener alumnos por curso: ' . $e->getMessage());

            return response()->json([
                'success' => false,
                'message' => 'Error al obtener los alumnos del curso',
                'error' => $e->getMessage()
            ], 500);
        }
    }
}
