<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Validator;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use PhpOffice\PhpSpreadsheet\Writer\Xlsx;
use PhpOffice\PhpSpreadsheet\Style\Alignment;
use PhpOffice\PhpSpreadsheet\Style\Border;
use PhpOffice\PhpSpreadsheet\Style\Fill;
use Carbon\Carbon;
use Carbon\CarbonPeriod;

class HorariosController extends Controller
{
    /**
     * ✅ Crear horario y generar clases automáticamente
     * POST /api/horarios
     */
    public function store(Request $request)
    {
        try {
            $validator = Validator::make($request->all(), [
                'curso_id' => 'required|integer',
                'docente_id' => 'required|integer',
                'fecha_inicio' => 'required|date',
                'fecha_fin' => 'required|date|after_or_equal:fecha_inicio',
                'dias_semana' => 'required|array|min:1',
                'dias_semana.*' => 'integer|between:1,7',
                'hora_inicio' => 'required|date_format:H:i',
                'hora_fin' => 'required|date_format:H:i|after:hora_inicio',
                'aula' => 'nullable|string|max:100',
                'domain_id' => 'required|integer'
            ]);

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

            $data = $validator->validated();

            // ✅ VALIDACIÓN: Verificar si ya existe un horario activo
            $horarioExistente = DB::table('horarios_unidad_didactica')
                ->where('curso_id', $data['curso_id'])
                ->where('domain_id', $data['domain_id'])
                ->where('activo', 1)
                ->whereNull('deleted_at')
                ->exists();

            if ($horarioExistente) {
                return response()->json([
                    'success' => false,
                    'message' => 'Ya existe un horario activo para este curso. Debe eliminarlo antes de crear uno nuevo.'
                ], 409); // ✅ 409 Conflict
            }

            DB::beginTransaction();

            // Crear horario...
            $horarioId = DB::table('horarios_unidad_didactica')->insertGetId([
                'curso_id' => $data['curso_id'],
                'docente_id' => $data['docente_id'],
                'fecha_inicio' => $data['fecha_inicio'],
                'fecha_fin' => $data['fecha_fin'],
                'dias_semana' => json_encode($data['dias_semana']),
                'hora_inicio' => $data['hora_inicio'],
                'hora_fin' => $data['hora_fin'],
                'aula' => $data['aula'] ?? null,
                'activo' => 1,
                'domain_id' => $data['domain_id'],
                'created_at' => Carbon::now(),
                'updated_at' => Carbon::now()
            ]);

            $clasesGeneradas = $this->generarClasesProgramadas($horarioId, $data);

            DB::commit();

            return response()->json([
                'success' => true,
                'message' => 'Horario creado exitosamente',
                'data' => [
                    'horario_id' => $horarioId,
                    'total_clases' => count($clasesGeneradas['todas']),
                    'clases_activas' => count($clasesGeneradas['activas']),
                    'clases_inhabilitadas' => count($clasesGeneradas['inhabilitadas']),
                    'feriados_detectados' => $clasesGeneradas['feriados']
                ]
            ], 201);
        } catch (\Exception $e) {
            DB::rollBack();
            Log::error('Error creando horario:', [
                'error' => $e->getMessage(),
                'line' => $e->getLine()
            ]);

            return response()->json([
                'success' => false,
                'message' => 'Error al crear el horario',
                'error' => $e->getMessage()
            ], 500);
        }
    }

    /**
     * ✅ Exportar control de asistencia - Banner desde B2, bordes solo derecha en A
     * GET /api/horarios/{horario_id}/exportarAsistencia
     */
    public function exportarAsistencia($horario_id)
    {
        try {
            $horario = DB::table('horarios_unidad_didactica as h')
                ->select('h.*', 'c.nombre as curso_nombre', 'c.codigo as curso_codigo')
                ->join('cursos as c', 'c.id', '=', 'h.curso_id')
                ->where('h.id', $horario_id)
                ->whereNull('h.deleted_at')
                ->first();

            if (!$horario) {
                return response()->json([
                    'success' => false,
                    'message' => 'Horario no encontrado'
                ], 404);
            }

            // Obtener clases programadas
            $clases = DB::table('clases_programadas')
                ->where('horario_id', $horario_id)
                ->where('estado', 'programada')
                ->orderBy('fecha')
                ->get();

            if ($clases->isEmpty()) {
                return response()->json([
                    'success' => false,
                    'message' => 'No hay clases programadas para este horario'
                ], 404);
            }

            // Obtener alumnos
            $alumnos = DB::table('alumnos as a')
                ->select('a.id', 'a.codigo', 'a.nombres', 'a.apellidos')
                ->join('curso_alumno as ca', function ($join) use ($horario) {
                    $join->on('ca.alumno_id', '=', 'a.id')
                        ->where('ca.curso_id', (int)$horario->curso_id)
                        ->where('ca.domain_id', (int)$horario->domain_id);
                })
                ->where('a.domain_id', (int)$horario->domain_id)
                ->whereNull('a.deleted_at')
                ->orderBy('a.apellidos')
                ->orderBy('a.nombres')
                ->get();

            if ($alumnos->isEmpty()) {
                return response()->json([
                    'success' => false,
                    'message' => 'No hay alumnos matriculados en este curso'
                ], 404);
            }

            // Obtener asistencias
            $asistenciasData = DB::table('asistencias')
                ->whereIn('clase_programada_id', $clases->pluck('id'))
                ->get()
                ->groupBy('clase_programada_id');

            // Crear Excel
            $spreadsheet = new Spreadsheet();
            $sheet = $spreadsheet->getActiveSheet();

            $totalColumnas = 1 + 2 + count($clases) + 2;
            $ultimaColumna = $this->getColumnLetter($totalColumnas);
            $ultimaColumnaFechas = $this->getColumnLetter(3 + count($clases));
            $colTotalInasistencias = $this->getColumnLetter(3 + count($clases) + 1);
            $colPorcentaje = $this->getColumnLetter(3 + count($clases) + 2);

            // ========== FILA 1: SEPARACIÓN SUPERIOR ==========
            $sheet->mergeCells('A1:' . $ultimaColumna . '1');
            $sheet->getRowDimension(1)->setRowHeight(15);

            // ========== FILA 2: CABECERA "CONTROL DE ASISTENCIA" ==========
            // ✅ Banner empieza en B2 (no en A2)
            $sheet->setCellValue('B2', 'CONTROL DE ASISTENCIA');
            $sheet->mergeCells('B2:' . $ultimaColumna . '2');

            $sheet->getStyle('B2')->getFont()->setBold(true)->setSize(14);
            $sheet->getStyle('B2')->getAlignment()
                ->setHorizontal(Alignment::HORIZONTAL_CENTER)
                ->setVertical(Alignment::VERTICAL_CENTER);

            // Borde alrededor del banner (desde B2)
            $sheet->getStyle('B2:' . $ultimaColumna . '2')->getBorders()->getOutline()
                ->setBorderStyle(Border::BORDER_MEDIUM)
                ->setColor(new \PhpOffice\PhpSpreadsheet\Style\Color('000000'));

            // ✅ A2: Solo borde derecho
            $sheet->getStyle('A2')->getBorders()->getRight()
                ->setBorderStyle(Border::BORDER_MEDIUM)
                ->setColor(new \PhpOffice\PhpSpreadsheet\Style\Color('000000'));

            $sheet->getRowDimension(2)->setRowHeight(30);

            // ========== FILA 3: SEPARACIÓN INFERIOR ==========
            $sheet->mergeCells('A3:' . $ultimaColumna . '3');
            $sheet->getRowDimension(3)->setRowHeight(15);

            // ========== FILA 4-6: HEADER ==========
            // Columna A: vacía (fusionada verticalmente)
            $sheet->mergeCells('A4:A6');

            // ✅ A4:A6: Solo borde derecho
            $sheet->getStyle('A4:A6')->getBorders()->getRight()
                ->setBorderStyle(Border::BORDER_THIN)
                ->setColor(new \PhpOffice\PhpSpreadsheet\Style\Color('000000'));

            // Columna B: N° Orden (VERTICAL)
            $sheet->setCellValue('B4', 'N° Orden');
            $sheet->mergeCells('B4:B6');

            // Columna C: Estudiante (VERTICAL)
            $sheet->setCellValue('C4', 'Estudiante');
            $sheet->mergeCells('C4:C6');

            // Columna D en adelante: FECHAS
            $sheet->setCellValue('D4', 'FECHAS');
            $sheet->mergeCells('D4:' . $ultimaColumnaFechas . '4');

            // ========== FILA 5: Subtítulo ==========
            $sheet->setCellValue('D5', 'Registro del día y mes de la inasistencia (Eje 26/10)');
            $sheet->mergeCells('D5:' . $ultimaColumnaFechas . '5');

            // ========== FILA 6: Números (1, 2, 3...) ==========
            $colIndex = 4;
            $numeroFecha = 1;
            
            /** @var \stdClass $clase */
            foreach ($clases as $clase) {
                $colLetter = $this->getColumnLetter($colIndex);
                $sheet->setCellValue($colLetter . '6', $numeroFecha);
                $colIndex++;
                $numeroFecha++;
            }

            // Total Inasistencias (VERTICAL)
            $sheet->setCellValue($colTotalInasistencias . '4', 'Total Inasistencias');
            $sheet->mergeCells($colTotalInasistencias . '4:' . $colTotalInasistencias . '6');

            // % Inasistencias (VERTICAL)
            $sheet->setCellValue($colPorcentaje . '4', '% Inasistencias');
            $sheet->mergeCells($colPorcentaje . '4:' . $colPorcentaje . '6');

            // ========== ESTILOS DEL HEADER (B4 en adelante) ==========
            $headerRange = 'B4:' . $ultimaColumna . '6';
            
            $sheet->getStyle($headerRange)->getFont()->setBold(true)->setSize(10);
            $sheet->getStyle($headerRange)->getAlignment()
                ->setHorizontal(Alignment::HORIZONTAL_CENTER)
                ->setVertical(Alignment::VERTICAL_CENTER)
                ->setWrapText(true);

            // TEXTO VERTICAL
            $sheet->getStyle('B4:B6')->getAlignment()->setTextRotation(90);
            $sheet->getStyle('C4:C6')->getAlignment()->setTextRotation(90);
            $sheet->getStyle($colTotalInasistencias . '4:' . $colTotalInasistencias . '6')->getAlignment()->setTextRotation(90);
            $sheet->getStyle($colPorcentaje . '4:' . $colPorcentaje . '6')->getAlignment()->setTextRotation(90);

            // Bordes del header (desde B4)
            $sheet->getStyle($headerRange)->getBorders()->getAllBorders()
                ->setBorderStyle(Border::BORDER_THIN)
                ->setColor(new \PhpOffice\PhpSpreadsheet\Style\Color('000000'));

            // ========== DATOS DE ALUMNOS ==========
            $row = 7;
            $numero = 1;

            /** @var \stdClass $alumno */
            foreach ($alumnos as $alumno) {
                // Columna A: vacía con borde derecho
                $sheet->setCellValue('A' . $row, '');
                $sheet->getStyle('A' . $row)->getBorders()->getRight()
                    ->setBorderStyle(Border::BORDER_THIN)
                    ->setColor(new \PhpOffice\PhpSpreadsheet\Style\Color('000000'));

                // Columna B: N° Orden
                $sheet->setCellValue('B' . $row, str_pad($numero, 2, '0', STR_PAD_LEFT));
                
                // Columna C: Estudiante
                $nombreCompleto = $alumno->apellidos . ' ' . $alumno->nombres;
                $sheet->setCellValue('C' . $row, $nombreCompleto);

                // Asistencias (empiezan en columna D)
                $colIndex = 4;
                
                /** @var \stdClass $clase */
                foreach ($clases as $clase) {
                    $colLetter = $this->getColumnLetter($colIndex);

                    $asistencia = null;
                    if (isset($asistenciasData[$clase->id])) {
                        $asistencia = $asistenciasData[$clase->id]->firstWhere('alumno_id', $alumno->id);
                    }

                    if ($asistencia) {
                        $marca = $asistencia->estado === 'presente' ? 'P' : 'F';
                        $sheet->setCellValue($colLetter . $row, $marca);

                        // SOLO color de texto (sin fondo)
                        if ($asistencia->estado === 'presente') {
                            $sheet->getStyle($colLetter . $row)->getFont()
                                ->getColor()->setRGB('006100');
                        } else {
                            $sheet->getStyle($colLetter . $row)->getFont()
                                ->getColor()->setRGB('9C0006');
                        }
                    } else {
                        $sheet->setCellValue($colLetter . $row, '');
                    }

                    $colIndex++;
                }

                // Total Inasistencias
                $primeraColumnaClases = 'D' . $row;
                $ultimaColumnaClases = $ultimaColumnaFechas . $row;
                
                $sheet->setCellValue(
                    $colTotalInasistencias . $row,
                    '=TEXT(COUNTIF(' . $primeraColumnaClases . ':' . $ultimaColumnaClases . ',"F"),"00")'
                );

                // % Inasistencias
                $sheet->setCellValue(
                    $colPorcentaje . $row,
                    '=IF(COUNTA(' . $primeraColumnaClases . ':' . $ultimaColumnaClases . ')>0,' .
                        'ROUND(COUNTIF(' . $primeraColumnaClases . ':' . $ultimaColumnaClases . ',"F")/' .
                        'COUNTA(' . $primeraColumnaClases . ':' . $ultimaColumnaClases . ')*100,0)&"%","")'
                );

                $row++;
                $numero++;
            }

            // ========== AJUSTAR ANCHOS ==========
            $sheet->getColumnDimension('A')->setWidth(3);
            $sheet->getColumnDimension('B')->setWidth(10);
            $sheet->getColumnDimension('C')->setWidth(30);

            for ($i = 4; $i <= 3 + count($clases); $i++) {
                $colLetter = $this->getColumnLetter($i);
                $sheet->getColumnDimension($colLetter)->setWidth(6);
            }

            $sheet->getColumnDimension($colTotalInasistencias)->setWidth(18);
            $sheet->getColumnDimension($colPorcentaje)->setWidth(15);

            // ========== BORDES Y ALINEACIONES ==========
            // Bordes desde B4 (excluyendo columna A que ya tiene su borde derecho)
            $dataRange = 'B4:' . $ultimaColumna . ($row - 1);
            $sheet->getStyle($dataRange)->getBorders()->getAllBorders()
                ->setBorderStyle(Border::BORDER_THIN)
                ->setColor(new \PhpOffice\PhpSpreadsheet\Style\Color('000000'));

            // Centrar
            $sheet->getStyle('B7:B' . ($row - 1))->getAlignment()
                ->setHorizontal(Alignment::HORIZONTAL_CENTER);
            
            $sheet->getStyle('D7:' . $ultimaColumna . ($row - 1))->getAlignment()
                ->setHorizontal(Alignment::HORIZONTAL_CENTER)
                ->setVertical(Alignment::VERTICAL_CENTER);

            // Nombres a la izquierda
            $sheet->getStyle('C7:C' . ($row - 1))->getAlignment()
                ->setHorizontal(Alignment::HORIZONTAL_LEFT);

            // ========== ALTURA DE FILAS ==========
            $sheet->getRowDimension(4)->setRowHeight(60);
            $sheet->getRowDimension(5)->setRowHeight(30);
            $sheet->getRowDimension(6)->setRowHeight(20);

            // Generar archivo
            $writer = new Xlsx($spreadsheet);
            $fileName = 'Control_Asistencia_' . $horario->curso_codigo . '_' .
                Carbon::parse($horario->fecha_inicio)->format('Ymd') . '.xlsx';

            $tempFile = tempnam(sys_get_temp_dir(), $fileName);
            $writer->save($tempFile);

            Log::info('Control de asistencia exportado:', [
                'horario_id' => $horario_id,
                'curso' => $horario->curso_nombre,
                'alumnos' => count($alumnos),
                'clases' => count($clases)
            ]);

            return response()->download($tempFile, $fileName)->deleteFileAfterSend(true);

        } catch (\Exception $e) {
            Log::error('Error exportando asistencia:', [
                'horario_id' => $horario_id,
                'error' => $e->getMessage(),
                'line' => $e->getLine()
            ]);

            return response()->json([
                'success' => false,
                'message' => 'Error al exportar control de asistencia',
                'error' => config('app.debug') ? $e->getMessage() : null
            ], 500);
        }
    }

    /**
     * Convertir número de columna a letra de Excel
     */
    private function getColumnLetter($columnNumber)
    {
        $letter = '';
        while ($columnNumber > 0) {
            $temp = ($columnNumber - 1) % 26;
            $letter = chr($temp + 65) . $letter;
            $columnNumber = (int)(($columnNumber - $temp - 1) / 26);
        }
        return $letter;
    }

    /**
     * ✅ Generar clases programadas según días seleccionados
     */
    private function generarClasesProgramadas($horarioId, $data)
    {
        $fechaInicio = Carbon::parse($data['fecha_inicio']);
        $fechaFin = Carbon::parse($data['fecha_fin']);
        $diasSeleccionados = $data['dias_semana']; // [1,3,5] = Lun,Mie,Vie
        $domainId = $data['domain_id'];

        // Obtener todos los feriados del periodo
        $feriados = DB::table('feriados')
            ->where('domain_id', $domainId)
            ->whereBetween('fecha', [$fechaInicio, $fechaFin])
            ->where('activo', 1)
            ->whereNull('deleted_at')
            ->pluck('id', 'fecha')
            ->toArray();

        $clasesGeneradas = [
            'todas' => [],
            'activas' => [],
            'inhabilitadas' => [],
            'feriados' => []
        ];

        // Generar periodo de fechas
        $periodo = CarbonPeriod::create($fechaInicio, $fechaFin);

        foreach ($periodo as $fecha) {
            $diaSemana = $fecha->dayOfWeekIso; // 1=Lun, 7=Dom

            // Verificar si este día está en los días seleccionados
            if (in_array($diaSemana, $diasSeleccionados)) {
                $fechaStr = $fecha->format('Y-m-d');
                $esFeriado = isset($feriados[$fechaStr]);
                $feriadoId = $esFeriado ? $feriados[$fechaStr] : null;

                $clase = [
                    'horario_id' => $horarioId,
                    'fecha' => $fechaStr,
                    'hora_inicio' => $data['hora_inicio'],
                    'hora_fin' => $data['hora_fin'],
                    'es_feriado' => $esFeriado ? 1 : 0,
                    'feriado_id' => $feriadoId,
                    'estado' => $esFeriado ? 'inhabilitada' : 'programada',
                    'observaciones' => $esFeriado ? 'Clase suspendida por feriado' : null,
                    'created_at' => Carbon::now(),
                    'updated_at' => Carbon::now()
                ];

                DB::table('clases_programadas')->insert($clase);

                $clasesGeneradas['todas'][] = $clase;

                if ($esFeriado) {
                    $clasesGeneradas['inhabilitadas'][] = $fechaStr;

                    // Obtener nombre del feriado
                    $nombreFeriado = DB::table('feriados')
                        ->where('id', $feriadoId)
                        ->value('nombre');

                    $clasesGeneradas['feriados'][] = [
                        'fecha' => $fechaStr,
                        'feriado' => $nombreFeriado
                    ];
                } else {
                    $clasesGeneradas['activas'][] = $fechaStr;
                }
            }
        }

        return $clasesGeneradas;
    }

    /**
     * ✅ Obtener horarios con clases programadas
     * GET /api/horarios/{curso_id}
     */
    public function index($curso_id)
    {
        try {
            $horarios = DB::table('horarios_unidad_didactica as h')
                ->select(
                    'h.*',
                    DB::raw('COUNT(cp.id) as total_clases'),
                    DB::raw('SUM(CASE WHEN cp.es_feriado = 1 THEN 1 ELSE 0 END) as clases_inhabilitadas')
                )
                ->leftJoin('clases_programadas as cp', 'cp.horario_id', '=', 'h.id')
                ->where('h.curso_id', $curso_id)
                ->whereNull('h.deleted_at')
                ->groupBy('h.id')
                ->get();

            // Formatear días de la semana
            $horarios = $horarios->map(function ($horario) {
                $horario->dias_semana = json_decode($horario->dias_semana);
                $horario->dias_nombres = $this->getDiasNombres($horario->dias_semana);
                return $horario;
            });

            return response()->json([
                'success' => true,
                'data' => $horarios
            ]);
        } catch (\Exception $e) {
            Log::error('Error obteniendo horarios:', [
                'error' => $e->getMessage()
            ]);

            return response()->json([
                'success' => false,
                'message' => 'Error al obtener horarios'
            ], 500);
        }
    }

    /**
     * ✅ Obtener clases programadas de un horario
     * GET /api/horarios/{horario_id}/clases
     */
    public function getClasesProgramadas($horario_id)
    {
        try {
            $clases = DB::table('clases_programadas as cp')
                ->select(
                    'cp.*',
                    'f.nombre as feriado_nombre'
                )
                ->leftJoin('feriados as f', 'f.id', '=', 'cp.feriado_id')
                ->where('cp.horario_id', $horario_id)
                ->orderBy('cp.fecha')
                ->get();

            return response()->json([
                'success' => true,
                'data' => $clases
            ]);
        } catch (\Exception $e) {
            Log::error('Error obteniendo clases:', [
                'error' => $e->getMessage()
            ]);

            return response()->json([
                'success' => false,
                'message' => 'Error al obtener clases programadas'
            ], 500);
        }
    }

    /**
     * ✅ Obtener horarios de un curso (para alumno)
     * GET /api/horarios/alumno/curso/{curso_id}
     */
    public function getHorariosPorCursoAlumno($curso_id)
    {
        try {
            // Obtener horarios del curso
            $horarios = DB::table('horarios_unidad_didactica as h')
                ->select(
                    'h.id',
                    'h.curso_id',
                    'h.docente_id',
                    'h.fecha_inicio',
                    'h.fecha_fin',
                    'h.dias_semana',
                    'h.hora_inicio',
                    'h.hora_fin',
                    'h.aula',
                    'h.domain_id',
                    'c.nombre as curso_nombre',
                    'c.codigo as curso_codigo',
                    DB::raw("COALESCE(d.nombres, 'Sin asignar') as docente_nombre") // ✅ Solo 'nombres'
                )
                ->join('cursos as c', 'c.id', '=', 'h.curso_id')
                ->leftJoin('docentes as d', 'd.id', '=', 'h.docente_id')
                ->where('h.curso_id', (int)$curso_id)
                ->where('h.activo', 1)
                ->whereNull('h.deleted_at')
                ->get();

            // Para cada horario, obtener estadísticas de clases
            $horariosConEstadisticas = $horarios->map(function ($horario) {
                // Contar clases programadas
                $estadisticas = DB::table('clases_programadas')
                    ->selectRaw('
                    COUNT(*) as total_clases,
                    SUM(CASE WHEN es_feriado = 1 THEN 1 ELSE 0 END) as clases_inhabilitadas
                ')
                    ->where('horario_id', $horario->id)
                    ->first();

                $horario->total_clases = $estadisticas->total_clases ?? 0;
                $horario->clases_inhabilitadas = $estadisticas->clases_inhabilitadas ?? 0;

                // Formatear días de la semana
                $diasArray = json_decode($horario->dias_semana);
                $horario->dias_semana = $diasArray;
                $horario->dias_nombres = $this->getDiasNombres($diasArray);

                return $horario;
            });

            return response()->json([
                'success' => true,
                'data' => $horariosConEstadisticas
            ]);
        } catch (\Exception $e) {
            Log::error('Error obteniendo horarios para alumno:', [
                'curso_id' => $curso_id,
                'error' => $e->getMessage(),
                'line' => $e->getLine(),
                'file' => $e->getFile(),
                'trace' => $e->getTraceAsString()
            ]);

            return response()->json([
                'success' => false,
                'message' => 'Error al obtener horarios',
                'error' => config('app.debug') ? $e->getMessage() : null
            ], 500);
        }
    }

    /**
     * ✅ Obtener clases programadas de un horario (para alumno)
     * GET /api/horarios/alumno/{horario_id}/clases
     */
    public function getClasesProgramadasAlumno($horario_id)
    {
        try {
            $clases = DB::table('clases_programadas as cp')
                ->select(
                    'cp.id',
                    'cp.fecha',
                    'cp.hora_inicio',
                    'cp.hora_fin',
                    'cp.es_feriado',
                    'cp.estado',
                    'cp.observaciones',
                    'f.nombre as feriado_nombre'
                )
                ->leftJoin('feriados as f', 'f.id', '=', 'cp.feriado_id')
                ->where('cp.horario_id', (int)$horario_id)
                ->orderBy('cp.fecha', 'asc')
                ->get();

            return response()->json([
                'success' => true,
                'data' => $clases
            ]);
        } catch (\Exception $e) {
            Log::error('Error obteniendo clases programadas para alumno:', [
                'horario_id' => $horario_id,
                'error' => $e->getMessage(),
                'line' => $e->getLine()
            ]);

            return response()->json([
                'success' => false,
                'message' => 'Error al obtener clases'
            ], 500);
        }
    }

    /**
     * ✅ Obtener nombres de días de la semana
     */
    private function getDiasNombres($diasArray)
    {
        if (!is_array($diasArray)) {
            return [];
        }

        $nombresDias = [
            1 => 'Lunes',
            2 => 'Martes',
            3 => 'Miércoles',
            4 => 'Jueves',
            5 => 'Viernes',
            6 => 'Sábado',
            7 => 'Domingo'
        ];

        return array_map(function ($dia) use ($nombresDias) {
            return $nombresDias[$dia] ?? 'Desconocido';
        }, $diasArray);
    }

    /**
     * ✅ Eliminar horario (soft delete)
     * DELETE /api/horarios/{id}
     */
    public function destroy($id)
    {
        try {
            DB::beginTransaction();

            // Verificar que el horario existe
            $horario = DB::table('horarios_unidad_didactica')
                ->where('id', $id)
                ->whereNull('deleted_at')
                ->first();

            if (!$horario) {
                return response()->json([
                    'success' => false,
                    'message' => 'Horario no encontrado'
                ], 404);
            }

            // Soft delete del horario
            DB::table('horarios_unidad_didactica')
                ->where('id', $id)
                ->update([
                    'deleted_at' => Carbon::now(),
                    'updated_at' => Carbon::now()
                ]);

            // Opcional: También eliminar clases programadas asociadas
            DB::table('clases_programadas')
                ->where('horario_id', $id)
                ->delete();

            DB::commit();

            Log::info('Horario eliminado exitosamente', [
                'horario_id' => $id
            ]);

            return response()->json([
                'success' => true,
                'message' => 'Horario eliminado exitosamente'
            ], 200);
        } catch (\Exception $e) {
            DB::rollBack();

            Log::error('Error eliminando horario:', [
                'horario_id' => $id,
                'error' => $e->getMessage(),
                'line' => $e->getLine()
            ]);

            return response()->json([
                'success' => false,
                'message' => 'Error al eliminar el horario',
                'error' => $e->getMessage()
            ], 500);
        }
    }
}
