<?php
require_once '../includes/conexionBD.php';

// Definición de la clase Pregunta que representará las preguntas de la trivia
class Pregunta {
    // ATRIBUTOS (Propiedades privadas para encapsular el estado de cada pregunta)
    private ?int $id_pregunta;     // El ID de la pregunta (autoincremental en la BD)
    private int $id_categoria;     // El ID de la categoría a la que pertenece la pregunta
    private string $texto_pregunta; // El enunciado de la pregunta
    private array $respuestas;     // Array que guardará la lista de respuestas posibles asociadas a esta pregunta

    // CONSTRUCTOR: Inicializa una nueva instancia de la clase Pregunta (sin pedir PDO de forma externa)
    public function __construct(int $id_categoria = 0, string $texto_pregunta = "", ?int $id_pregunta = null) {
        $this->id_pregunta = $id_pregunta;       // Asigna el ID (null si es una nueva pregunta que no se ha guardado)
        $this->id_categoria = $id_categoria;     // Asigna la categoría correspondiente
        $this->texto_pregunta = $texto_pregunta; // Asigna el texto de la pregunta
        $this->respuestas = [];                  // Inicializa el contenedor de respuestas como un array vacío
    }

    // --- GETTERS Y SETTERS ---

    // Getter para obtener el ID de la pregunta (solo lectura)
    public function getIdPregunta(): ?int { 
        return $this->id_pregunta; 
    }
    
    // Getter para obtener el ID de la categoría
    public function getIdCategoria(): int { 
        return $this->id_categoria; 
    }
    
    // Setter para cambiar la categoría de la pregunta
    public function setIdCategoria(int $id_categoria): void { 
        $this->id_categoria = $id_categoria; 
    }

    // Getter para obtener el texto de la pregunta
    public function getTextoPregunta(): string { 
        return $this->texto_pregunta; 
    }
    
    // Setter para cambiar el texto de la pregunta
    public function setTextoPregunta(string $texto_pregunta): void { 
        $this->texto_pregunta = $texto_pregunta; 
    }

    // Getter para obtener el array con todas las respuestas cargadas de esta pregunta
    public function getRespuestas(): array { 
        return $this->respuestas; 
    }

    // --- MÉTODOS DE BASE DE DATOS ---

    // Método para guardar una nueva pregunta en la base de datos
    public function guardar() {
        // Obtenemos la conexión llamando a tu función unificada del proyecto
        $conexion = conexionBD();

        // Si devuelve un array significa que ocurrió un error controlado al conectar
        if (is_array($conexion)) {
            return $conexion;
        }

        try {
            // Preparamos la consulta SQL para insertar la categoría y el texto de la pregunta
            $sql = "INSERT INTO pregunta (id_categoria, texto_pregunta) VALUES (:id_cat, :texto)";
            $stmt = $conexion->prepare($sql);
            
            // Ejecutamos la consulta asociando los atributos actuales del objeto a los marcadores SQL
            $stmt->execute([
                ':id_cat' => $this->id_categoria,
                ':texto' => $this->texto_pregunta
            ]);

            // Si se guardó correctamente, actualizamos el atributo id_pregunta del objeto con el ID generado en la BD
            $this->id_pregunta = (int)$conexion->lastInsertId();

            // Devolvemos la respuesta formateada con éxito e ID técnico para tu proyecto
            return [
                'exito' => 'Pregunta guardada correctamente',
                'exito_tecnico' => $this->id_pregunta
            ];

        } catch (PDOException $error) {
            // Si falla la inserción en MySQL, capturamos el error
            return [
                'error' => 'Ocurrió un error al guardar la pregunta.',
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

    // Método para buscar y cargar en memoria todas las respuestas asociadas a esta pregunta concreta
    public function cargarRespuestas() {
        // Si la pregunta aún no está guardada en la BD (su ID es null), no podemos buscar sus respuestas
        if ($this->id_pregunta === null) return;

        // Obtenemos la conexión llamando a tu función unificada del proyecto
        $conexion = conexionBD();

        // Si devuelve un array significa que ocurrió un error al conectar
        if (is_array($conexion)) {
            return $conexion;
        }

        try {
            // Consulta SQL adaptada exactamente a tus columnas reales: texto_respuesta y es_correcta
            $sql = "SELECT id_respuesta, texto_respuesta, es_correcta FROM respuesta WHERE id_pregunta = :id_preg";
            $stmt = $conexion->prepare($sql);
            $stmt->execute([':id_preg' => $this->id_pregunta]);
            
            // Guardamos todas las filas encontradas directamente dentro del array de respuestas del objeto
            $this->respuestas = $stmt->fetchAll(PDO::FETCH_ASSOC);

        } catch (PDOException $error) {
            // Capturamos cualquier excepción de base de datos
            return [
                'error' => 'Ocurrió un error al cargar las respuestas.',
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

    // Método estático para obtener un listado de preguntas aleatorias filtradas por una categoría
    public static function obtenerPorCategoria(int $id_categoria, int $limite = 10) {
        // Obtenemos la conexión llamando a tu función unificada del proyecto
        $conexion = conexionBD();

        // Si devuelve un array significa que ocurrió un error al conectar
        if (is_array($conexion)) {
            return $conexion;
        }

        try {
            // Consulta SQL que filtra por categoría, desordena los resultados al azar (RAND()) y limita la cantidad
            $sql = "SELECT * FROM pregunta WHERE id_categoria = :id_cat ORDER BY RAND() LIMIT :limite";
            $stmt = $conexion->prepare($sql);
            
            // Vinculamos los parámetros asegurando que el límite sea interpretado estrictamente como un número entero (PARAM_INT)
            $stmt->bindValue(':id_cat', $id_categoria, PDO::PARAM_INT);
            $stmt->bindValue(':limite', $limite, PDO::PARAM_INT);
            $stmt->execute(); // Ejecutamos la consulta

            $preguntas = []; // Array donde amontonaremos los objetos Pregunta resultantes
            
            // Recorremos fila por fila los resultados devueltos por la base de datos
            while ($datos = $stmt->fetch(PDO::FETCH_ASSOC)) {
                // Creamos un nuevo objeto Pregunta con los datos de la fila actual
                $preg = new Pregunta($datos['id_categoria'], $datos['texto_pregunta'], $datos['id_pregunta']);
                
                // Llamamos al método interno del objeto para que busque y le pegue sus opciones de respuesta correspondientes
                $preg->cargarRespuestas(); 
                
                // Añadimos el objeto completamente armado al array final
                $preguntas[] = $preg;
            }
            return $preguntas; // Devolvemos la lista de objetos Pregunta listos para jugar

        } catch (PDOException $error) {
            // Capturamos cualquier error en la consulta aleatoria
            return [
                'error' => 'Ocurrió un error al obtener las preguntas aleatorias.',
                'error_tecnico' => $error->getMessage()
            ];
        }
    }
}