<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Http\Controllers\Controller;
use App\Models\Curso;
use Illuminate\Support\Facades\DB;
use Carbon\Carbon;
use Illuminate\Support\Facades\Log;

class CursoController extends Controller
{
    public function index($id)
    {
        $courses = Curso::leftJoin('ciclos', 'ciclos.id', '=', 'cursos.ciclo_id')
            ->leftJoin('modulos_formativos', 'modulos_formativos.id', '=', 'cursos.modulo_formativo_id')
            ->leftJoin('area_de_formacion', 'area_de_formacion.id', '=', 'cursos.area_de_formacion_id') // Usar la tabla area_de_formacion
            ->leftJoin('estados', 'estados.id', '=', 'cursos.estado_id') // Usar la tabla estados
            ->leftJoin('carreras', 'carreras.id', '=', 'cursos.carrera_id')
            ->leftJoin('docentes', 'docentes.id', '=', 'cursos.docente_id')
            ->where('cursos.carrera_id', $id)
            ->select(
                'cursos.*',
                'ciclos.nombre as ciclo_nombre',
                'modulos_formativos.nombre as modulo_formativo_nombre',
                'area_de_formacion.nombre as area_de_formacion_nombre', // Usar el campo nombre desde la tabla area_de_formacion
                'carreras.nombres as carrera_nombre',
                'estados.nombre as estado_nombre', // Usar el campo nombre desde la tabla estados
                'docentes.id as docente_id',
                'docentes.nombres as docente_nombre'
            )
            ->get();

        return response()->json($courses);
    }

    public function getCursosByAlumno($alumnoId)
    {
        $courses = Curso::leftJoin('curso_alumno', 'curso_alumno.curso_id', '=', 'cursos.id')
            ->leftJoin('ciclos', 'ciclos.id', '=', 'cursos.ciclo_id')
            ->leftJoin('modulos_formativos', 'modulos_formativos.id', '=', 'cursos.modulo_formativo_id')
            ->leftJoin('area_de_formacion', 'area_de_formacion.id', '=', 'cursos.area_de_formacion_id') // Usar la tabla area_de_formacion
            ->leftJoin('estados', 'estados.id', '=', 'cursos.estado_id') // Usar la tabla estados
            ->leftJoin('carreras', 'carreras.id', '=', 'cursos.carrera_id')
            ->leftJoin('docentes', 'docentes.id', '=', 'cursos.docente_id')
            ->where('curso_alumno.alumno_id', $alumnoId)
            ->select(
                'cursos.*',
                'ciclos.nombre as ciclo_nombre',
                'modulos_formativos.nombre as modulo_formativo_nombre',
                'area_de_formacion.nombre as area_de_formacion_nombre', // Usar el campo nombre desde la tabla area_de_formacion
                'carreras.nombres as carrera_nombre',
                'estados.nombre as estado_nombre', // Usar el campo nombre desde la tabla estados
                'docentes.id as docente_id'
            )
            ->get();

        return response()->json($courses);
    }


    public function getCursosByDomain($domainId)
    {
        $courses = Curso::leftJoin('ciclos', 'ciclos.id', '=', 'cursos.ciclo_id')
            ->leftJoin('modulos_formativos', 'modulos_formativos.id', '=', 'cursos.modulo_formativo_id')
            ->leftJoin('area_de_formacion', 'area_de_formacion.id', '=', 'cursos.area_de_formacion_id') // Usar la tabla area_de_formacion
            ->leftJoin('estados', 'estados.id', '=', 'cursos.estado_id') // Usar la tabla estados
            ->leftJoin('carreras', 'carreras.id', '=', 'cursos.carrera_id')
            ->leftJoin('docentes', 'docentes.id', '=', 'cursos.docente_id')
            ->leftJoin('plan_de_estudios', 'plan_de_estudios.id', '=', 'cursos.estado_id')
            ->where('cursos.domain_id', $domainId)
            ->select(
                'cursos.*',
                'ciclos.nombre as ciclo_nombre',
                'modulos_formativos.nombre as modulo_formativo_nombre',
                'area_de_formacion.nombre as area_de_formacion_nombre', // Usar el campo nombre desde la tabla area_de_formacion
                'carreras.nombres as carrera_nombre',
                'estados.nombre as estado_nombre', // Usar el campo nombre desde la tabla estados
                'docentes.id as docente_id',
                'docentes.nombres as docente_nombre',
                'plan_de_estudios.nombre as plan_estudios_nombre'

            )
            ->get();

        return response()->json($courses);
    }

    // Reemplazar el método getCursosByPlanEstudioYCarrera en CursoController.php

    public function getCursosByPlanEstudioYCarrera($planEstudioId, $carreraId, $alumnoId = null)
    {
        // Log de parámetros recibidos
        Log::info('getCursosByPlanEstudioYCarrera - Parámetros recibidos:', [
            'planEstudioId' => $planEstudioId,
            'carreraId' => $carreraId,
            'alumnoId' => $alumnoId
        ]);

        if ($alumnoId) {
            Log::info('Consultando cursos para alumno específico', ['alumnoId' => $alumnoId]);

            $query = DB::table('curso_alumno')
                ->leftJoin('cursos', 'curso_alumno.curso_id', '=', 'cursos.id')
                ->leftJoin('carreras', 'cursos.carrera_id', '=', 'carreras.id')
                ->leftJoin('plan_de_estudios', 'cursos.estado_id', '=', 'plan_de_estudios.id')
                ->leftJoin('ciclos', 'cursos.ciclo_id', '=', 'ciclos.id')
                ->leftJoin('area_de_formacion', 'cursos.area_de_formacion_id', '=', 'area_de_formacion.id')
                ->leftJoin('modulos_formativos', 'cursos.modulo_formativo_id', '=', 'modulos_formativos.id')
                ->select(
                    'cursos.*',
                    'carreras.nombres as carrera_nombre',
                    'plan_de_estudios.nombre as plan_de_estudio_nombre',
                    'ciclos.nombre as ciclo_nombre',
                    'area_de_formacion.nombre as area_formacion_nombre',
                    'modulos_formativos.nombre as modulo_formativo_nombre'
                )
                ->where('curso_alumno.alumno_id', $alumnoId)
                ->where('cursos.estado_id', $planEstudioId)
                ->where('cursos.carrera_id', $carreraId)
                // 🔧 CORRECCIÓN: Excluir cursos FINALIZADOS (estado_id = 6)
                ->where('curso_alumno.estado_id', '!=', [3,4,6]) // NO mostrar cursos finalizados
                ->whereIn('curso_alumno.estado_id', [2]); // Solo PENDIENTES (1) y EN PROCESO (2)

            // Log de la consulta SQL generada
            Log::info('SQL Query (con alumno):', [
                'sql' => $query->toSql(),
                'bindings' => $query->getBindings()
            ]);

            $resultado = $query->get();

            Log::info('Resultados encontrados para alumno:', [
                'total_cursos' => $resultado->count(),
                'cursos_ids' => $resultado->pluck('id')->toArray()
            ]);

            return $resultado;
        }

        Log::info('Consultando todos los cursos disponibles (sin alumno específico)');

        $query = DB::table('cursos')
            ->join('carreras', 'cursos.carrera_id', '=', 'carreras.id')
            ->join('plan_de_estudios', 'cursos.estado_id', '=', 'plan_de_estudios.id')
            ->leftJoin('ciclos', 'cursos.ciclo_id', '=', 'ciclos.id')
            ->leftJoin('area_de_formacion', 'cursos.area_de_formacion_id', '=', 'area_de_formacion.id')
            ->leftJoin('modulos_formativos', 'cursos.modulo_formativo_id', '=', 'modulos_formativos.id')
            ->select(
                'cursos.*',
                'carreras.nombres as carrera_nombre',
                'plan_de_estudios.nombre as plan_de_estudio_nombre',
                'ciclos.nombre as ciclo_nombre',
                'area_de_formacion.nombre as area_formacion_nombre',
                'modulos_formativos.nombre as modulo_formativo_nombre'
            )
            ->where('cursos.estado_id', $planEstudioId)
            ->where('cursos.carrera_id', $carreraId);

        // Log de la consulta SQL generada
        Log::info('SQL Query (sin alumno):', [
            'sql' => $query->toSql(),
            'bindings' => $query->getBindings()
        ]);

        $resultado = $query->get();

        Log::info('Resultados encontrados:', [
            'total_cursos' => $resultado->count(),
            'cursos_ids' => $resultado->pluck('id')->toArray()
        ]);

        return $resultado;
    }


    // Crear un nuevo curso
    public function store(Request $request)
    {
        DB::beginTransaction();

        try {
            $this->validate($request, [
                'codigo' => 'required|string|max:255',
                'nombreCurso' => 'required|string|max:255',
                'cicloId' => 'required|integer',
                'areaFormacionId' => 'required|integer',
                'moduloFormativoId' => 'required|string',
                'cantidadCreditos' => 'required|numeric',
                'porcentajeCreditos' => 'required|numeric',
                'cantidadHoras' => 'required|integer',
                'horasPracticas' => 'required|integer',
                'carreraId' => 'required|integer',
                'syllabus' => 'string',
                'tema' => 'nullable|string',
                'estadoId' => 'nullable|integer',
                'domain_id' => 'required',
                'asignacionDocentesId' => 'nullable',
                'descripcion_competencia' => 'nullable|string|max:255',
            ]);

            // Crear el curso
            $curso = Curso::create([
                'codigo' => $request->codigo,
                'nombre' => $request->nombreCurso,
                'ciclo_id' => $request->cicloId,
                'area_de_formacion_id' => $request->areaFormacionId,
                'modulo_formativo_id' => $request->moduloFormativoId,
                'cantidad_de_creditos' => $request->cantidadCreditos,
                'porcentaje_de_creditos' => $request->porcentajeCreditos,
                'cantidad_de_horas' => $request->cantidadHoras,
                'horas_practicas' => $request->horasPracticas,
                'carrera_id' => $request->carreraId,
                'syllabus' => $request->syllabus,
                'tema' => $request->tema,
                'estado_id' => $request->estadoId,
                'domain_id' => $request->domain_id,
                'docente_id' => is_array($request->asignacionDocentesId) ? null : $request->asignacionDocentesId,
                'descripcion_competencia' => $request->descripcion_competencia,
                'created_at' => Carbon::now(),
            ]);

            // 🚀 EL OBSERVER SE ENCARGA AUTOMÁTICAMENTE DE LOS ENLACES CON ALUMNOS

            DB::commit();

            return response()->json([
                'curso' => $curso,
                'message' => 'Curso creado correctamente. Enlaces automáticos con alumnos aplicados.'
            ], 201);
        } catch (\Exception $e) {
            DB::rollBack();

            return response()->json([
                'error' => 'Error al crear el curso: ' . $e->getMessage()
            ], 500);
        }
    }

    public function storeMasivos(Request $request)
    {
        DB::beginTransaction();
        try {
            // Validar que se reciba un array de cursos directamente
            $this->validate($request, [
                '*.codigo' => 'required|string|max:255',
                '*.nombreCurso' => 'required|string|max:255',
                '*.cicloId' => 'required|string',
                '*.areaFormacionId' => 'required|string',
                '*.moduloFormativoId' => 'required|string',
                '*.cantidadCreditos' => 'required|numeric',
                '*.cantidadHoras' => 'required|integer',
                '*.horasPracticas' => 'required|integer',
                '*.carreraId' => 'required|string',
                '*.estadoId' => 'required|string',
                '*.domain_id' => 'required',
                '*.asignacionDocentesId' => 'nullable',
                '*.descripcionCompetencia' => 'nullable',
            ]);

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

            $cantidadCursos = count($cursosData);
            $Totalcred = 0;
            foreach ($cursosData as $cursoOriginal) {
                $Totalcred += $cursoOriginal['cantidadCreditos'];
            }

            $cursosCreados = [];
            $cursosActualizados = [];

            $gruposCreditos = [];
            foreach ($cursosData as $curso) {
                $clave = $curso['carreraId'] . '|' . $curso['estadoId'];

                if (!isset($gruposCreditos[$clave])) {
                    $gruposCreditos[$clave] = 0;
                }

                $gruposCreditos[$clave] += $curso['cantidadCreditos'];
            }

            // Procesar cada curso del array
            foreach ($cursosData as $index => $cursoData) {

                $claveGrupo = $cursoData['carreraId'] . '|' . $cursoData['estadoId'];
                $totalCreditosGrupo = $gruposCreditos[$claveGrupo] ?? 0;

                $porcentaje = $totalCreditosGrupo > 0
                    ? round(($cursoData['cantidadCreditos'] * 100) / $totalCreditosGrupo, 2)
                    : 0;

                // Verificar si el curso ya existe por código
                $cursoExistente = Curso::where('codigo', $cursoData['codigo'])
                    ->where('domain_id', $cursoData['domain_id'])
                    ->first();

                // Validar que el ciclo existe
                $cicloExist = DB::table('ciclos')->where('nombre', $cursoData['cicloId'])
                    ->where('domain_id', $cursoData['domain_id'])->first();
                if (!$cicloExist) {
                    throw new \Exception("Curso en posición {$index}: El ciclo con ID {$cursoData['cicloId']} no existe");
                }
                $cursoData['cicloId'] = $cicloExist->id;

                // Validar que la carrera existe
                $carreraExist = DB::table('carreras')->where('nombres', $cursoData['carreraId'])
                    ->where('domain_id', $cursoData['domain_id'])->first();
                if (!$carreraExist) {
                    throw new \Exception("Curso en posición {$index}: La carrera con ID {$cursoData['carreraId']} no existe");
                }
                $cursoData['carreraId'] = $carreraExist->id;

                // Validar que el área de formación existe
                $areaExist = DB::table('area_de_formacion')->where('nombre', $cursoData['areaFormacionId'])
                    ->where('domain_id', $cursoData['domain_id'])->first();
                if (!$areaExist) {
                    throw new \Exception("Curso en posición {$index}: El área de formación con ID {$cursoData['areaFormacionId']} no existe");
                }
                $cursoData['areaFormacionId'] = $areaExist->id;

                // Validar que el estado existe
                $estadoExist = DB::table('plan_de_estudios')->where('nombre', $cursoData['estadoId'])
                    ->where('domain_id', $cursoData['domain_id'])->first();
                if (!$estadoExist) {
                    throw new \Exception("Curso en posición {$index}: El estado con ID {$cursoData['estadoId']} no existe");
                }
                $cursoData['estadoId'] = $estadoExist->id;

                // Validar docente si se proporciona
                if (!empty($cursoData['asignacionDocentesId']) && !is_array($cursoData['asignacionDocentesId'])) {
                    $docenteExist = DB::table('docentes')->where('id', $cursoData['asignacionDocentesId'])->first();
                    if (!$docenteExist) {
                        throw new \Exception("Curso en posición {$index}: El docente con ID {$cursoData['asignacionDocentesId']} no existe");
                    }
                }

                // Preparar datos del curso
                $cursoDataForDB = [
                    'codigo' => $cursoData['codigo'],
                    'nombre' => $cursoData['nombreCurso'],
                    'ciclo_id' => $cursoData['cicloId'],
                    'area_de_formacion_id' => $cursoData['areaFormacionId'],
                    'modulo_formativo_id' => $cursoData['moduloFormativoId'],
                    'cantidad_de_creditos' => $cursoData['cantidadCreditos'],
                    'cantidad_de_horas' => $cursoData['cantidadHoras'],
                    'horas_practicas' => $cursoData['horasPracticas'],
                    'porcentaje_de_creditos' => $porcentaje,
                    'carrera_id' => $cursoData['carreraId'],
                    'syllabus' => $cursoData['syllabus'] ?? null,
                    'tema' => $cursoData['tema'] ?? null,
                    'estado_id' => $cursoData['estadoId'],
                    'domain_id' => $cursoData['domain_id'],
                    'docente_id' => is_array($cursoData['asignacionDocentesId']) ? null : $cursoData['asignacionDocentesId'],
                    'descripcion_competencia' => $cursoData['descripcionCompetencia'] ?? null,
                    'updated_at' => Carbon::now()
                ];

                $curso = null;
                $esActualizacion = false;

                if ($cursoExistente) {
                    // ACTUALIZAR curso existente
                    $cursoExistente->update($cursoDataForDB);
                    $curso = $cursoExistente->fresh(); // Obtener datos actualizados
                    $esActualizacion = true;
                } else {
                    // CREAR nuevo curso
                    $cursoDataForDB['created_at'] = Carbon::now();
                    $curso = Curso::create($cursoDataForDB);
                }

                // 🚀 EL OBSERVER SE ENCARGA AUTOMÁTICAMENTE DE LOS ENLACES CON ALUMNOS

                // Agregar a la lista correspondiente
                $cursoInfo = [
                    'curso_id' => $curso->id,
                    'codigo' => $curso->codigo,
                    'nombre' => $curso->nombre,
                    'carrera_id' => $curso->carrera_id,
                    'ciclo_id' => $curso->ciclo_id
                ];

                if ($esActualizacion) {
                    $cursosActualizados[] = $cursoInfo;
                } else {
                    $cursosCreados[] = $cursoInfo;
                }
            }

            DB::commit();

            return response()->json([
                'success' => true,
                'message' => 'Proceso completado: ' . count($cursosCreados) . ' cursos creados, ' . count($cursosActualizados) . ' cursos actualizados. Enlaces automáticos con alumnos aplicados.',
                'cursos_creados' => count($cursosCreados),
                'cursos_actualizados' => count($cursosActualizados),
                'total_procesados' => count($cursosData),
                'cursos_nuevos' => $cursosCreados,
                'cursos_actualizados' => $cursosActualizados
            ], 201);
        } catch (\Exception $e) {
            DB::rollBack();

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

    // Actualizar un curso existente
    public function update(Request $request, $id)
    {
        DB::beginTransaction();

        try {
            $this->validate($request, [
                'codigo' => 'required|string|max:255',
                'nombreCurso' => 'required|string|max:255',
                'cicloId' => 'required|integer',
                'areaFormacionId' => 'required|integer',
                'moduloFormativoId' => 'required|string',
                'cantidadCreditos' => 'required|numeric',
                'porcentajeCreditos' => 'required|numeric',
                'cantidadHoras' => 'required|integer',
                'horasPracticas' => 'required|integer',
                'carreraId' => 'required|integer',
                'syllabus' => 'string',
                'tema' => 'nullable|string',
                'estadoId' => 'nullable|integer',
                'domain_id' => 'required',
                'asignacionDocentesId' => 'nullable',
                'descripcion_competencia' => 'nullable|string|max:255',
            ]);

            $curso = Curso::find($id);

            if (!$curso) {
                return response()->json(['error' => 'Curso no encontrado'], 404);
            }

            // Actualizar el curso
            $curso->update([
                'codigo' => $request->codigo,
                'nombre' => $request->nombreCurso,
                'ciclo_id' => $request->cicloId,
                'area_de_formacion_id' => $request->areaFormacionId,
                'modulo_formativo_id' => $request->moduloFormativoId,
                'cantidad_de_creditos' => $request->cantidadCreditos,
                'porcentaje_de_creditos' => $request->porcentajeCreditos,
                'cantidad_de_horas' => $request->cantidadHoras,
                'horas_practicas' => $request->horasPracticas,
                'carrera_id' => $request->carreraId,
                'syllabus' => $request->syllabus,
                'tema' => $request->tema,
                'estado_id' => $request->estadoId,
                'domain_id' => $request->domain_id,
                'docente_id' => is_array($request->asignacionDocentesId) ? null : $request->asignacionDocentesId,
                'descripcion_competencia' => $request->descripcion_competencia,
                'nuevoTotalCreditos' => 'required|numeric|min:1',
            ]);


            $cursosGrupo = Curso::where('carrera_id', $request->carreraId)
                ->where('estado_id', $request->estadoId)
                ->where('id', '!=', $curso->id)
                ->get();

            foreach ($cursosGrupo as $otroCurso) {
                $nuevoPorcentaje = ($otroCurso->cantidad_de_creditos * 100) / $request->nuevoTotalCreditos;
                $otroCurso->porcentaje_de_creditos = round($nuevoPorcentaje, 2);
                $otroCurso->save();
            }

            // 🚀 EL OBSERVER SE ENCARGA AUTOMÁTICAMENTE DE RE-SINCRONIZAR ALUMNOS SI CAMBIÓ carrera_id O estado_id

            DB::commit();

            return response()->json([
                'curso' => $curso,
                'message' => 'Curso actualizado correctamente. Enlaces automáticos re-sincronizados.'
            ], 200);
        } catch (\Exception $e) {
            DB::rollBack();

            return response()->json([
                'error' => 'Error al actualizar el curso: ' . $e->getMessage()
            ], 500);
        }
    }

    public function show($id)
    {
        $course = Curso::find($id);
        if (!$course) {
            return response()->json(['Error' => 'Curso no encontrado'], 404);
        }

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

    public function getSyllabus($id)
    {
        $course = Curso::find($id, ['id', 'syllabus']);
        if (!$course) {
            return response()->json(['Error' => 'Curso no encontrado'], 404);
        }

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

    public function getTema($id)
    {
        $course = Curso::find($id, ['id', 'tema']);
        if (!$course) {
            return response()->json(['Error' => 'Curso no encontrado'], 404);
        }

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


    /*    public function update(Request $request, $id)
{
    $this->validate($request, [
        'codigo' => 'required|string|max:255',
        'nombreCurso' => 'required|string|max:255',
        'cicloId' => 'required|integer',
        'areaFormacionId' => 'required|integer',
        'moduloFormativoId' => 'required|string',
        'cantidadCreditos' => 'required|numeric',
        'porcentajeCreditos' => 'required',
        'cantidadHoras' => 'required|integer',
        'horasPracticas' => 'required|integer',
        'carreraId' => 'required|integer',
        'syllabus' => 'nullable|string',
        'tema' => 'nullable|string',
        'estadoId' => 'required|integer',
        'domain_id' => 'required',
        'asignacionDocentesId' => 'nullable',
        'descripcion_competencia' => 'nullable|string|max:255',
        'nuevoTotalCreditos' => 'required|numeric|min:1',
    ]);

    $curso = Curso::findOrFail($id);
    $curso->update([
        'codigo' => $request->codigo,
        'nombre' => $request->nombreCurso,
        'ciclo_id' => $request->cicloId,
        'area_de_formacion_id' => $request->areaFormacionId,
        'modulo_formativo_id' => $request->moduloFormativoId,
        'cantidad_de_creditos' => $request->cantidadCreditos,
        'porcentaje_de_creditos' => $request->porcentajeCreditos,
        'cantidad_de_horas' => $request->cantidadHoras,
        'horas_practicas' => $request->horasPracticas,
        'carrera_id' => $request->carreraId,
        'syllabus' => $request->syllabus,
        'tema' => $request->tema,
        'estado_id' => $request->estadoId,
        'domain_id' => $request->domain_id,
        'docente_id' => is_array($request->asignacionDocentesId) ? null : $request->asignacionDocentesId,
        'descripcion_competencia' => $request->descripcion_competencia,
    ]);

  
    $cursosGrupo = Curso::where('carrera_id', $request->carreraId)
        ->where('estado_id', $request->estadoId)
        ->where('id', '!=', $curso->id)
        ->get();

    foreach ($cursosGrupo as $otroCurso) {
        $nuevoPorcentaje = ($otroCurso->cantidad_de_creditos * 100) / $request->nuevoTotalCreditos;
        $otroCurso->porcentaje_de_creditos = round($nuevoPorcentaje, 2);
        $otroCurso->save();
    }


    return response()->json([
        'message' => 'Curso actualizado',
        'data' => $curso
    ], 200);
}*/


    public function getCursosDocente($docenteId)
    {


        $cursos = Curso::join('carreras', 'carreras.id', '=', 'cursos.carrera_id')
            ->join('plan_de_estudios', 'plan_de_estudios.id', '=', 'cursos.estado_id')
            ->join('ciclos', 'ciclos.id', '=', 'cursos.ciclo_id')
            ->where('cursos.docente_id', $docenteId)
            ->select(
                'cursos.nombre as curso_nombre',
                'carreras.nombres as carrera_nombre',
                'plan_de_estudios.nombre as plan_estudio_nombre',
                'ciclos.nombre as ciclo'
            )
            ->get();


        return response()->json($cursos);
    }

    public function getAllCursos($domain_id)
    {
        $courses = Curso::leftJoin('ciclos', 'ciclos.id', '=', 'cursos.ciclo_id')
            ->leftJoin('modulos_formativos', 'modulos_formativos.id', '=', 'cursos.modulo_formativo_id')
            ->leftJoin('area_de_formacion', 'area_de_formacion.id', '=', 'cursos.area_de_formacion_id')
            ->leftJoin('estados', 'estados.id', '=', 'cursos.estado_id')
            ->leftJoin('carreras', 'carreras.id', '=', 'cursos.carrera_id')
            ->leftJoin('docentes', 'docentes.id', '=', 'cursos.docente_id')
            ->leftJoin('plan_de_estudios', 'plan_de_estudios.id', '=', 'cursos.estado_id')
            ->select(
                'cursos.*',
                'ciclos.nombre as ciclo_nombre',
                'modulos_formativos.nombre as modulo_formativo_nombre',
                'area_de_formacion.nombre as area_de_formacion_nombre',
                'carreras.nombres as carrera_nombre',
                'estados.nombre as estado_nombre',
                'docentes.id as docente_id',
                'docentes.nombres as docente_nombre',
                'plan_de_estudios.nombre as plan_estudios_nombre'
            )
            ->where('cursos.domain_id', $domain_id)
            ->get();

        return response()->json($courses);
    }

    public function getTotalCreditsByCurso($domain_id, $carrera_id, $estado_id)
    {
        $totalCreditos = Curso::where('domain_id', $domain_id)
            ->where('carrera_id', $carrera_id)
            ->where('estado_id', $estado_id)
            ->sum('cantidad_de_creditos');

        return response()->json(['total_creditos' => $totalCreditos], 200);
    }



    public function destroy($id)
    {
        // Busca el curso por su ID
        $curso = Curso::find($id);

        // Verifica si el curso existe
        if (!$curso) {
            return response()->json([
                'message' => 'Curso no encontrado'
            ], 404);
        }

        // Guarda info antes de eliminar
        $carreraId = $curso->carrera_id;
        $estadoId = $curso->estado_id;
        $creditosEliminado = $curso->cantidad_de_creditos;

        // Elimina el curso
        $curso->delete();

        // Obtiene cursos restantes del mismo grupo
        $cursosGrupo = Curso::where('carrera_id', $carreraId)
            ->where('estado_id', $estadoId)
            ->get();

        // Calcula nuevo total de créditos
        $nuevoTotalCreditos = $cursosGrupo->sum('cantidad_de_creditos');

        // Evita división por 0
        if ($nuevoTotalCreditos > 0) {
            foreach ($cursosGrupo as $cursoRestante) {
                $nuevoPorcentaje = ($cursoRestante->cantidad_de_creditos * 100) / $nuevoTotalCreditos;
                $cursoRestante->porcentaje_de_creditos = round($nuevoPorcentaje, 2);
                $cursoRestante->save();
            }
        }

        // Devuelve una respuesta de éxito
        return response()->json([
            'message' => 'Curso eliminado exitosamente'
        ], 200);
    }
}
