PlataformaEducativaWeb2/Back/backendP-Educativa/app/Http/Controllers/Api/CircularesController.php

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Services\PeriodoService;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Facades\Validator;


class CircularesController extends Controller
{

    protected $nombrePeriodoActivo;


    public function __construct(PeriodoService $periodoService)
    {
        try {
            $this->nombrePeriodoActivo = $periodoService->obtenerPeriodoActivoNombre();
        } catch (\Exception $e) {
            $this->nombrePeriodoActivo = null;
        }
    }

    public function findOne($id)
    {
        $id = base64_decode($id);
        $circular = DB::table('circulares')->where('idCircular', $id)->first();
        return response()->json($circular, 200);
    }

    public function getByUser($id)
    {
        $circular = DB::table('vista_circulares_cu')->where('idUsuario', $id)->get();
        return response()->json($circular, 200);
    }

    public function estadisticas($id)
    {
        // $id = base64_decode($id);
        $circular = DB::table('circulares_usuarios_colegioabc')
            ->join('usuarios as u', 'circulares_usuarios_colegioabc.idUsuario', '=', 'u.idUsuario')
            ->select(
                'circulares_usuarios_colegioabc.idUsuario',
                'circulares_usuarios_colegioabc.fechaLectura',
                'circulares_usuarios_colegioabc.medioLectura',
                DB::raw("CONCAT(u.primerNombre, ' ', COALESCE(u.segundoNombre, ''), ' ', u.apellidoPaterno, ' ', COALESCE(u.apellidoMaterno, '')) AS nombreCompleto")
            )
            ->where('circulares_usuarios_colegioabc.idCircular', $id)
            ->get();

        $vistos = DB::table('circulares_usuarios_colegioabc')
            ->select('idUsuario', 'fechaLectura', 'medioLectura')
            ->where('idCircular', $id)
            ->whereNotNull('fechaLectura')
            ->get();

        $total = $circular->count();
        $vistosa = $vistos->count();
        $porcentaje = ($vistosa * 100) / $total;
        $porcentaje = number_format($porcentaje, 2, '.', '');
        return response()->json([
            'data' => $circular,
            'total' => $total,
            'vistos' => $vistosa,
            'porcentaje' => '%' . $porcentaje

        ], 200);
    }

    public function download($id)
    {
        // $id = base64_decode($id);
        $fileUrl = $id ? asset('storage/circulares/' . $id) : null;
        return response()->json($fileUrl, 200);
    }

    public function mostrar()
    {
        $circularList = DB::table('circulares')
            ->where('idEscuela', 'COLEGIOABC')
            ->orderBy('estado', 'asc')
            ->get();
        foreach ($circularList as $circular) {
            if (isset($circular->audiencia)) {
                $audiencia = null;
                if ($circular->audiencia == 'AL') {
                    $audiencia = 'Alumnos';
                } else if ($circular->audiencia == 'PF') {
                    $audiencia = 'Padres de Familia';
                } else if ($circular->audiencia == 'PR') {
                    $audiencia = 'Profesores';
                } else if ($circular->audiencia == 'AD') {
                    $audiencia = 'Administrativos';
                }


                if (isset($circular->idReceptores)) {
                    $nombreReceptor = null;

                    $nivel = DB::table('niveles')->where('idNivel', $circular->idReceptores)->first(['nombreNivel']);
                    if ($nivel) {
                        $nombreReceptor = $nivel->nombreNivel;
                    }

                    if (!$nombreReceptor) {
                        $grupo = DB::table('grupos')->where('idGrupo', $circular->idReceptores)->first(['nombreGrupo']);
                        if ($grupo) {
                            $nombreReceptor = $grupo->nombreGrupo;
                        }
                    }

                    if (!$nombreReceptor) {
                        $materia = DB::table('materias')->where('idMateria', $circular->idReceptores)->first(['nombreMateria']);
                        if ($materia) {
                            $nombreReceptor = $materia->nombreMateria;
                        }
                    }

                    if (!$nombreReceptor) {
                        $nombreReceptor = $circular->idReceptores;
                    }

                    if ($circular->idReceptores == 'AL' || $circular->idReceptores == 'PF' || $circular->idReceptores == 'PR' || $circular->idReceptores == 'AD') {
                        $nombreReceptor = 'Todos';
                    }

                    if ($nombreReceptor) {
                        $circular->rolName = $nombreReceptor . ' - ' . $audiencia;
                    }

                }
            }
        }

        return response()->json($circularList, 200);
    }



    public function extraInfo($id)
    {
        $id = base64_decode($id);
        $circular = DB::table('vista_circulares_usuarios')
            ->where('idCircular', $id)
            ->first();
        return response()->json($circular, 200);
    }

    public function ultimasCirc()
    {
        $circularList = DB::table('circulares')
            ->where('idEscuela', 'COLEGIOABC')
            ->where('estado', 'Activo')
            ->orderBy('fechaCreacion', 'desc')
            ->get();

        foreach ($circularList as $circular) {
            if (isset($circular->audiencia)) {
                $audiencia = null;
                if ($circular->audiencia == 'AL') {
                    $audiencia = 'Alumnos';
                } else if ($circular->audiencia == 'PF') {
                    $audiencia = 'Padres de Familia';
                } else if ($circular->audiencia == 'PR') {
                    $audiencia = 'Profesores';
                } else if ($circular->audiencia == 'AD') {
                    $audiencia = 'Administrativos';
                }
                $circular->audiencia = $audiencia;
            }
        }
        foreach ($circularList as $circular) {
            if (isset($circular->idReceptores)) {
                $nombreReceptor = null;

                $nivel = DB::table('niveles')->where('idNivel', $circular->idReceptores)->first(['nombreNivel']);
                if ($nivel) {
                    $nombreReceptor = $nivel->nombreNivel;
                }

                if (!$nombreReceptor) {
                    $grupo = DB::table('grupos')->where('idGrupo', $circular->idReceptores)->first(['nombreGrupo']);
                    if ($grupo) {
                        $nombreReceptor = $grupo->nombreGrupo;
                    }
                }

                if (!$nombreReceptor) {
                    $materia = DB::table('materias')->where('idMateria', $circular->idReceptores)->first(['nombreMateria']);
                    if ($materia) {
                        $nombreReceptor = $materia->nombreMateria;
                    }
                }

                if (!$nombreReceptor) {
                    $nombreReceptor = $circular->idReceptores;
                }

                if ($circular->idReceptores == 'AL' || $circular->idReceptores == 'PF' || $circular->idReceptores == 'PR' || $circular->idReceptores == 'AD') {
                    $nombreReceptor = 'Todos';
                }

                if ($nombreReceptor) {
                    $circular->idReceptores = $nombreReceptor;
                }
            }
        }
        return response()->json($circularList, 200);
    }

    // public function crear(Request $request)
    // {
    //     try {
    //         // Rutas para almacenar los archivos
    //         $storagePath = 'public/circulares/';
    //         $archivosAdjuntos = [];

    //         // Procesar cada archivo en base64
    //         if ($request->has('bases64')) {
    //             foreach ($request->bases64 as $file) {
    //                 // Extraer la extensión del archivo
    //                 $fileInfo = explode(';', $file['base64'])[0];
    //                 $fileExtension = explode('/', $fileInfo)[1];

    //                 switch ($fileExtension) {
    //                     case 'vnd.openxmlformats-officedocument.wordprocessingml.document':
    //                         $fileExtension = 'docx';
    //                         break;
    //                     case 'vnd.openxmlformats-officedocument.spreadsheetml.sheet':
    //                         $fileExtension = 'xlsx';
    //                         break;
    //                     case 'vnd.openxmlformats-officedocument.presentationml.presentation':
    //                         $fileExtension = 'pptx';
    //                         break;
    //                     default;
    //                 }

    //                 // Decodificar el archivo base64
    //                 $fileData = substr($file['base64'], strpos($file['base64'], ',') + 1);
    //                 $fileData = str_replace(' ', '+', $fileData);

    //                 // Nombre del archivo con la extensión correcta
    //                 $fileName = $file['id'] . '.' . $fileExtension;

    //                 // Guardar el archivo
    //                 //
    //                 Storage::put($storagePath . $fileName, base64_decode($fileData));

    //                 $archivosAdjuntos[] = [
    //                     'nombre' => $file['nombre'],
    //                     'ruta' => Storage::url($storagePath . $fileName)
    //                 ];
    //             }
    //         }

    //         // Insertar la circular en la base de datos
    //         DB::table('circulares')->insert([
    //             'idEscuela' => 'COLEGIOABC',
    //             'estado' => 'Activo',
    //             'titulo' => $request->titulo,
    //             'audiencia' => $request->audiencia,
    //             'idReceptores' => $request->idReceptores,
    //             'contenido' => $request->contenido,
    //             'jsonAdjuntos' => json_encode($request->jsonAdjuntos),
    //             'importancia' => $request->importancia,
    //             'fechaCreacion' => $request->fechaCreacion,
    //             'fechaPublicacion' => $request->fechaPublicacion,
    //             'fechaCaducidad' => $request->fechaCaducidad,
    //             'idUsuario' => $request->idUsuario
    //         ]);

    //         return response()->json([
    //             'mensaje' => 'Circular creada exitosamente',
    //             'idCircular' => DB::getPdo()->lastInsertId()
    //         ], 201);
    //     } catch (\Exception $e) {
    //         return response()->json(['mensaje' => 'Error al crear la circular: ' . $e->getMessage()], 500);
    //     }
    // }


    public function crear(Request $request)
    {
        $carpetaBase = config('custom.s3_carpeta_base');
        try {

            $periodoService = new PeriodoService();
            $carpetaPeriodo = $periodoService->obtenerPeriodoActivoNombre();

            $rutaBucket = 'circulares/';
            $archivosAdjuntos = [];

            // Procesar cada archivo en base64
            if ($request->has('bases64')) {
                foreach ($request->bases64 as $file) {
                    // Extraer la extensión MIME y convertir si es necesario
                    $fileInfo = explode(';', $file['base64'])[0];
                    $fileExtension = explode('/', $fileInfo)[1];

                    switch ($fileExtension) {
                        case 'vnd.openxmlformats-officedocument.wordprocessingml.document':
                            $fileExtension = 'docx';
                            break;
                        case 'vnd.openxmlformats-officedocument.spreadsheetml.sheet':
                            $fileExtension = 'xlsx';
                            break;
                        case 'vnd.openxmlformats-officedocument.presentationml.presentation':
                            $fileExtension = 'pptx';
                            break;
                    }

                    // Decodificar el archivo base64
                    $fileData = substr($file['base64'], strpos($file['base64'], ',') + 1);
                    $fileData = str_replace(' ', '+', $fileData);
                    $contenidoArchivo = base64_decode($fileData);

                    // Generar nombre del archivo
                    $fileName = $file['id'] . '-' . $file['nombre'] . '.' . $fileExtension;
                    $pathS3 = $carpetaBase. '/' . $carpetaPeriodo . '/' .$rutaBucket . $fileName;

                    // Esto sube al s3
                    Storage::disk('s3')->put($pathS3, $contenidoArchivo, 'public');

                    $archivosAdjuntos[] = [
                        'id' => $file['id'],
                        'nombre' => $file['nombre'],
                        'ruta' => Storage::disk('s3')->url($pathS3)
                    ];
                }
            }

            // Insertar la circular en la base de datos
            DB::table('circulares')->insert([
                'idEscuela' => 'COLEGIOABC',
                'estado' => 'Activo',
                'titulo' => $request->titulo,
                'audiencia' => $request->audiencia,
                'idReceptores' => $request->idReceptores,
                'contenido' => $request->contenido,
                'jsonAdjuntos' => json_encode($archivosAdjuntos),
                'importancia' => $request->importancia,
                'fechaCreacion' => $request->fechaCreacion,
                'fechaPublicacion' => $request->fechaPublicacion,
                'fechaCaducidad' => $request->fechaCaducidad,
                'idUsuario' => $request->idUsuario
            ]);

            return response()->json([
                'mensaje' => 'Circular creada exitosamente',
                'idCircular' => DB::getPdo()->lastInsertId()
            ], 201);
        } catch (\Exception $e) {
            return response()->json(['mensaje' => 'Error al crear la circular: ' . $e->getMessage()], 500);
        }
    }


    public function actualizar(Request $request)
    {
        try {
            $rutaBucket = 'circulares/';
            $archivosAdjuntos = [];

            // Obtener los adjuntos anteriores desde la BD
            $adjuntosAnteriores = DB::table('circulares')
                ->where('idCircular', $request->idCircular)
                ->value('jsonAdjuntos');

            $adjuntosAnteriores = $adjuntosAnteriores ? json_decode($adjuntosAnteriores, true) : [];

            // Si se mandan nuevos archivos base64, los procesamos
            if ($request->has('bases64') && !empty($request->bases64)) {
                foreach ($request->bases64 as $file) {
                    // Extraer extensión
                    $fileInfo = explode(';', $file['base64'])[0];
                    $fileExtension = explode('/', $fileInfo)[1];

                    switch ($fileExtension) {
                        case 'vnd.openxmlformats-officedocument.wordprocessingml.document':
                            $fileExtension = 'docx';
                            break;
                        case 'vnd.openxmlformats-officedocument.spreadsheetml.sheet':
                            $fileExtension = 'xlsx';
                            break;
                        case 'vnd.openxmlformats-officedocument.presentationml.presentation':
                            $fileExtension = 'pptx';
                            break;
                    }

                    // Generar nombre
                    $fileName = $file['id'] . '-' . $file['nombre'] . '.' . $fileExtension;
                    $pathS3 = $rutaBucket . $fileName;

                    // Subir nuevo archivo
                    $fileData = substr($file['base64'], strpos($file['base64'], ',') + 1);
                    $fileData = str_replace(' ', '+', $fileData);
                    $contenidoArchivo = base64_decode($fileData);

                    Storage::disk('s3')->put($pathS3, $contenidoArchivo, 'public');

                    $archivosAdjuntos[] = [
                        'id' => $file['id'],
                        'nombre' => $file['nombre'],
                        'ruta' => Storage::disk('s3')->url($pathS3)
                    ];
                }

                $archivosAdjuntos = array_merge($adjuntosAnteriores, $archivosAdjuntos);
            } else {
                // Se mantienen los adjuntos anteriores si no se mandaron nuevos archivos
                $archivosAdjuntos = $adjuntosAnteriores;
            }

            // Actualizar la circular
            DB::table('circulares')
                ->updateOrInsert(
                    ['idCircular' => $request->idCircular],
                    [
                        'titulo' => $request->titulo,
                        'audiencia' => $request->audiencia,
                        'idReceptores' => $request->idReceptores,
                        'contenido' => $request->contenido,
                        'jsonAdjuntos' => json_encode($archivosAdjuntos),
                        'importancia' => $request->importancia,
                        'fechaPublicacion' => $request->fechaPublicacion,
                        'fechaCaducidad' => $request->fechaCaducidad,
                        'idUsuario' => $request->idUsuario
                    ]
                );

            return response()->json(['mensaje' => 'Circular actualizada exitosamente'], 200);

        } catch (\Exception $e) {
            return response()->json(['mensaje' => 'Error al actualizar la circular: ' . $e->getMessage()], 500);
        }
    }


    public function eliminarArchivo(Request $request)
    {
        try {
            // Validar parámetros
            if (!$request->has('idCircular') || !$request->has('idArchivo')) {
                return response()->json(['mensaje' => 'Faltan parámetros'], 400);
            }

            $idCircular = $request->idCircular;
            $idArchivo = $request->idArchivo;

            // Obtener adjuntos actuales
            $adjuntos = DB::table('circulares')
                ->where('idCircular', $idCircular)
                ->value('jsonAdjuntos');

            $adjuntos = $adjuntos ? json_decode($adjuntos, true) : [];

            // Buscar el adjunto por idArchivo
            $index = array_search($idArchivo, array_column($adjuntos, 'id'));
            if ($index === false) {
                return response()->json(['mensaje' => 'Adjunto no encontrado'], 404);
            }

            $archivo = $adjuntos[$index];
            // Obtener la key de S3 desde la url
            $parsedUrl = parse_url($archivo['ruta'], PHP_URL_PATH);
            $key = ltrim(str_replace('pledu-dv-aeci/', '', $parsedUrl), '/');

            // Eliminar de S3 si existe
            if (Storage::disk('s3')->exists($key)) {
                Storage::disk('s3')->delete($key);
            }

            // Eliminar del array y actualizar BD
            array_splice($adjuntos, $index, 1);
            DB::table('circulares')
                ->where('idCircular', $idCircular)
                ->update(['jsonAdjuntos' => json_encode($adjuntos)]);

            return response()->json(['mensaje' => 'Archivo eliminado correctamente'], 200);

        } catch (\Exception $e) {
            return response()->json(['mensaje' => 'Error al eliminar el archivo: ' . $e->getMessage()], 500);
        }
    }




    public function habilitar($id)
    {
        $id = base64_decode($id);
        try {
            //code...
            DB::table('circulares')
                ->updateOrInsert(
                    ['idCircular' => $id],
                    ['estado' => 'Activo']
                );

            return response()->json(['mensaje' => 'Circular habilitada exitosamente'], 201);
        } catch (\Exception $e) {
            //throw $th;
            return response()->json(['mensaje' => 'Error al habilitar la circular: ' . $e->getMessage()], 500);
        }

    }
    public function eliminar($id)
    {
        $id = base64_decode($id);
        try {
            //code...
            DB::table('circulares')
                ->updateOrInsert(
                    ['idCircular' => $id],
                    ['estado' => 'Eliminado']
                );

            return response()->json(['mensaje' => 'Circular deshabilitada exitosamente'], 201);
        } catch (\Exception $e) {
            //throw $th;
            return response()->json(['mensaje' => 'Error al habilitar la circular: ' . $e->getMessage()], 500);
        }

    }

    public function getUsuariosCircular(Request $request)
    {
        if ($request->Audiencia == 'AL') {

            if ($request->Destino == 'NivelEducativo') {
                $iDUsuario = DB::table('usuarios')
                    ->leftJoin('vista_grados_niveles', 'vista_grados_niveles.nombreGrado', '=', 'usuarios.grado')
                    ->leftJoin('vista_usuarios_Grupos1', 'usuarios.idUsuario', '=', 'vista_usuarios_Grupos1.idUsuario')
                    ->where('usuarios.idEscuela', 'COLEGIOABC')
                    ->where('usuarios.tipoUsuario', 'AL')
                    ->where('vista_grados_niveles.idNivel', $request->id)
                    ->select('usuarios.idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);
            } else if ($request->Destino == 'Grado') {
                $iDUsuario = DB::table('usuarios')
                    ->where('idEscuela', 'COLEGIOABC')
                    ->where('tipoUsuario', 'AL')
                    ->where('grado', $request->id)
                    ->select('idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);
            } else if ($request->Destino == 'Grupo') {
                $iDUsuario = DB::table('grupos_usuarios')
                    ->where('idEscuela', 'COLEGIOABC')
                    ->where('idGrupo', $request->id)
                    ->select('idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);
            } else if ($request->Destino == 'Materias') {
                $iDUsuario = DB::table('usuarios')
                    ->leftJoin('vista_usuarios_Grupos1', 'vista_usuarios_Grupos1.idUsuario', '=', 'usuarios.idUsuario')
                    ->leftJoin('vista_materias_grados_grupos', function ($join) {
                        $join->on('vista_materias_grados_grupos.idGradoGrupoRelacionado', '=', 'usuarios.grado')
                            ->orOn('vista_materias_grados_grupos.idGradoGrupoRelacionado', '=', 'vista_usuarios_Grupos1.idGrupo');
                    })
                    ->where('usuarios.idEscuela', 'COLEGIOABC')
                    ->where('usuarios.tipoUsuario', 'AL')
                    ->where('vista_materias_grados_grupos.idMateria', $request->id)
                    ->select('usuarios.idUsuario')
                    ->get();
                $iDUsuario = $iDUsuario->unique('idUsuario');
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);
            } else if ($request->Destino == 'todos') {
                $iDUsuario = DB::table('usuarios')
                    ->where('idEscuela', 'COLEGIOABC')
                    ->where('tipoUsuario', 'AL')
                    ->select('idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);
            }

        } else if ($request->Audiencia == 'PF') {

            if ($request->Destino == 'NivelEducativo') {
                $iDUsuario = DB::table('usuarios')
                    ->leftJoin('usuarios_padres', 'usuarios_padres.idUsuario', '=', 'usuarios.idUsuario')
                    ->leftJoin('vista_usuarios_Grupos1', 'usuarios.idUsuario', '=', 'vista_usuarios_Grupos1.idUsuario')
                    ->leftJoin('vista_grados_niveles', 'vista_grados_niveles.nombreGrado', '=', 'usuarios.grado')
                    ->where('usuarios.idEscuela', 'COLEGIOABC')
                    ->where('usuarios.tipoUsuario', 'AL')
                    ->where('vista_grados_niveles.idNivel', $request->id)
                    ->select('usuarios_padres.idPadre')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idPadre')->toArray()
                ], 200);
            } else if ($request->Destino == 'Grado') {
                $iDUsuario = DB::table('usuarios')
                    ->leftJoin('usuarios_padres', 'usuarios_padres.idUsuario', '=', 'usuarios.idUsuario')
                    ->where('usuarios.idEscuela', 'COLEGIOABC')
                    ->where('usuarios.tipoUsuario', 'AL')
                    ->where('usuarios.grado', $request->id)
                    ->select('usuarios_padres.idPadre')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idPadre')->toArray()
                ], 200);

            } else if ($request->Destino == 'Grupo') {
                $iDUsuario = DB::table('usuarios')
                    ->leftJoin('usuarios_padres', 'usuarios_padres.idUsuario', '=', 'usuarios.idUsuario')
                    ->leftJoin('grupos_usuarios', 'grupos_usuarios.idUsuario', '=', 'usuarios.idUsuario')
                    ->where('usuarios.idEscuela', 'COLEGIOABC')
                    ->where('usuarios.tipoUsuario', 'AL')
                    ->where('grupos_usuarios.idGrupo', $request->id)
                    ->select('usuarios_padres.idPadre')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idPadre')->toArray()
                ], 200);

            } else if ($request->Destino == 'Materias') {
                $iDUsuario = DB::table('usuarios')
                    ->leftJoin('usuarios_padres', 'usuarios_padres.idUsuario', '=', 'usuarios.idUsuario')
                    ->leftJoin('vista_usuarios_Grupos1', 'vista_usuarios_Grupos1.idUsuario', '=', 'usuarios.idUsuario')
                    ->leftJoin('vista_materias_grados_grupos', function ($join) {
                        $join->on('vista_materias_grados_grupos.idGradoGrupoRelacionado', '=', 'usuarios.grado')
                            ->orOn('vista_materias_grados_grupos.idGradoGrupoRelacionado', '=', 'vista_usuarios_Grupos1.idGrupo');
                    })
                    ->where('usuarios.idEscuela', 'COLEGIOABC')
                    ->where('usuarios.tipoUsuario', 'AL')
                    ->where('vista_materias_grados_grupos.idMateria', $request->id)
                    ->select('usuarios_padres.idPadre')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idPadre')->toArray()
                ], 200);
            } else if ($request->Destino == 'todos') {
                $iDUsuario = DB::table('usuarios')
                    ->where('idEscuela', 'COLEGIOABC')
                    ->where('tipoUsuario', 'PF')
                    ->select('idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);
            }

        } else if ($request->Audiencia == 'AD') {

            if ($request->Destino == 'todos') {
                $iDUsuario = DB::table('usuarios')
                    ->where('idEscuela', 'COLEGIOABC')
                    ->where('tipoUsuario', 'AD')
                    ->select('idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);
            }

        } else if ($request->Audiencia == 'PR') {

            if ($request->Destino == 'NivelEducativo') {
                $iDUsuario = DB::table('usuarios')
                    ->leftJoin('vista_usuarios_materias', 'vista_usuarios_materias.idProfesor', '=', 'usuarios.idUsuario')
                    ->leftJoin('vista_grados_niveles', 'vista_grados_niveles.nombreGrado', '=', 'vista_usuarios_materias.idGradoGrupoRelacionado')
                    ->where('usuarios.idEscuela', 'COLEGIOABC')
                    ->where('usuarios.tipoUsuario', 'PR')
                    ->where('vista_grados_niveles.idNivel', $request->id)
                    ->select('usuarios.idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);

            } else if ($request->Destino == 'Grado') {
                $iDUsuario = DB::table('usuarios')
                    ->leftJoin('vista_usuarios_materias', 'vista_usuarios_materias.idProfesor', '=', 'usuarios.idUsuario')
                    ->where('usuarios.idEscuela', 'COLEGIOABC')
                    ->where('usuarios.tipoUsuario', 'PR')
                    ->where('vista_usuarios_materias.idGradoGrupoRelacionado', $request->id)
                    ->select('usuarios.idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);
            } else if ($request->Destino == 'Grupo') {
                $iDUsuario = DB::table('usuarios')
                    ->leftJoin('vista_usuarios_materias', 'vista_usuarios_materias.idProfesor', '=', 'usuarios.idUsuario')
                    ->where('usuarios.idEscuela', 'COLEGIOABC')
                    ->where('usuarios.tipoUsuario', 'PR')
                    ->where('vista_usuarios_materias.idGradoGrupoRelacionado', $request->id)
                    ->select('usuarios.idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);

            } else if ($request->Destino == 'Materias') {
                $iDUsuario = DB::table('usuarios')
                    ->leftJoin('vista_usuarios_materias', 'vista_usuarios_materias.idProfesor', '=', 'usuarios.idUsuario')
                    ->where('usuarios.idEscuela', 'COLEGIOABC')
                    ->where('usuarios.tipoUsuario', 'PR')
                    ->where('vista_usuarios_materias.idMateria', $request->id)
                    ->select('usuarios.idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);
            } else if ($request->Destino == 'todos') {
                $iDUsuario = DB::table('usuarios')
                    ->where('idEscuela', 'COLEGIOABC')
                    ->where('tipoUsuario', 'PR')
                    ->select('idUsuario')
                    ->get();
                return response()->json([
                    'idUsuario' => $iDUsuario->pluck('idUsuario')->toArray()
                ], 200);
            }

        }
    }

    public function crearDestinoCircular(Request $request)
    {
        $destinoCircular = DB::table('circulares_usuarios_colegioabc')->Insert([
            "idCircular" => $request->idCircular,
            "idUsuario" => $request->idUsuario,
            "fechaLectura" => null,
            "medioLectura" => null,
        ]);
        return response()->json([
            'mensaje' => 'Destino creado exitosamente',
            'Usuario' => $request->idUsuario
        ], 201);
    }

    public function actualizarVisto(Request $request)
    {
        $validator = Validator::make($request->all(), [
            'idCircular' => 'required|integer',
            'idUsuario' => 'required|string',
        ]);

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

        $idCircular = $request->input('idCircular');
        $idUsuario = $request->input('idUsuario');

        $record = DB::table('circulares_usuarios_colegioabc')
            ->where('idCircular', $idCircular)
            ->where('idUsuario', $idUsuario)
            ->first();

        if ($record->fechaLectura !== null || $record->medioLectura !== null) {
            return response()->json(['mensaje' => 'Este ya se ha visto'], 200);
        }

        DB::table('circulares_usuarios_colegioabc')
            ->where('idCircular', $idCircular)
            ->where('idUsuario', $idUsuario)
            ->update([
                'fechaLectura' => now(),
                'medioLectura' => 'Web'
            ]);

        return response()->json(['mensaje' => 'Record updated successfully'], 200);
    }

}