triviagmatico/clases/ClasePartida.php

<?php
require_once __DIR__ . '/../includes/conexionBD.php';

class Partida
{

    public $idPartida;
    public $nombrePartida;
    public $idUsuario;

    public function __construct(
        $idPartida = null,
        $nombrePartida = null,
        $idUsuario = null
    ) {
        $this->idPartida = $idPartida;
        $this->nombrePartida = $nombrePartida;
        $this->idUsuario = $idUsuario;
    }

    public function insertar()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                INSERT INTO partida
                (nombrePartida,idUsuario)
                VALUES
                (:nombrePartida,:idUsuario)
            ");
            $consulta->bindParam(":nombrePartida", $this->nombrePartida);
            $consulta->bindParam(":idUsuario", $this->idUsuario);
            $consulta->execute();
            return [
                "exito" => "La partida se creó correctamente.",
                "exito_tecnico" => $conexion->lastInsertId()
            ];
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al guardar la partida.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

    public function listar()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("SELECT * FROM partida");
            $consulta->execute();
            return $consulta->fetchAll(PDO::FETCH_ASSOC);
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al obtener el listado.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

    public function buscar()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                SELECT *
                FROM partida
                WHERE idPartida=:idPartida
            ");
            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->execute();
            return $consulta->fetch(PDO::FETCH_ASSOC);
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al buscar la partida.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

    public function editar()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                UPDATE partida
                SET
                    nombrePartida=:nombrePartida,
                    idUsuario=:idUsuario
                WHERE idPartida=:idPartida
            ");
            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->bindParam(":nombrePartida", $this->nombrePartida);
            $consulta->bindParam(":idUsuario", $this->idUsuario);
            $consulta->execute();
            return [
                "exito" => "La partida se editó correctamente.",
                "exito_tecnico" => $this->idPartida
            ];
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al editar la partida.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

    public function eliminar()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                DELETE FROM partida
                WHERE idPartida=:idPartida
            ");
            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->execute();
            return [
                "exito" => "La partida se eliminó correctamente.",
                "exito_tecnico" => $this->idPartida
            ];
        } catch (PDOException $error) {
            return [
                "error" => "No se pudo eliminar la partida.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

    public function iniciar()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                UPDATE partida
                SET fechaInicio = NOW()
                WHERE idPartida = :idPartida
                AND fechaInicio IS NULL
            ");
            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->execute();
            return [
                "exito" => "La partida se inició correctamente.",
                "exito_tecnico" => $this->idPartida
            ];
        } catch (PDOException $error) {
            return [
                "error" => "No se pudo iniciar la partida.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }


    public function finalizar()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                UPDATE partida
                SET fechaFin = NOW()
                WHERE idPartida = :idPartida
                AND fechaInicio IS NOT NULL
                AND fechaFin IS NULL
            ");
            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->execute();
            return [
                "exito" => "La partida se finalizó correctamente.",
                "exito_tecnico" => $this->idPartida
            ];
        } catch (PDOException $error) {
            return [
                "error" => "No se pudo finalizar la partida.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }


    public function getPreguntas()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                SELECT
                    pxp.idPartidaxPregunta,
                    p.*
                FROM partidaxpregunta pxp
                INNER JOIN pregunta p
                    ON pxp.idPregunta=p.idPregunta
                WHERE pxp.idPartida=:idPartida
                ORDER BY pxp.idPartidaxPregunta
            ");
            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->execute();
            return $consulta->fetchAll(PDO::FETCH_ASSOC);
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al recuperar las preguntas de la partida.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

   
    public function asignarPregunta($idPregunta)
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                INSERT INTO partidaxpregunta
                (idPartida,idPregunta)
                VALUES
                (:idPartida,:idPregunta)
            ");
            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->bindParam(":idPregunta", $idPregunta);
            $consulta->execute();
            return [
                "exito" => "La pregunta se asignó correctamente.",
                "exito_tecnico" => $conexion->lastInsertId()
            ];
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al asignar la pregunta.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }
    //Cuenta cuántas preguntas tiene la partida en total. Es la primera mitad de la comprobación "¿ha terminado el usuario de jugar?".
    public function contarPreguntasAsignadas()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                SELECT COUNT(*) AS total
                FROM partidaxpregunta
                WHERE idPartida=:idPartida
            ");
            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->execute();
            $fila = $consulta->fetch(PDO::FETCH_ASSOC);
            return (int)$fila["total"];
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al contar las preguntas.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

    public function contarRespuestasUsuario($idUsuario)
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                SELECT COUNT(*) AS total
                FROM respuestaalmacenada ra
                INNER JOIN partidaxpregunta pxp
                    ON ra.idPartidaxPregunta=pxp.idPartidaxPregunta
                WHERE pxp.idPartida=:idPartida
                AND ra.idUsuario=:idUsuario
            ");
            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->bindParam(":idUsuario", $idUsuario);
            $consulta->execute();
            $fila = $consulta->fetch(PDO::FETCH_ASSOC);
            return (int)$fila["total"];
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al contar las respuestas del usuario.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

    /**
     * Sustituye al antiguo campo `terminada`: compara cuántas preguntas
     * tiene la partida contra cuántas ha respondido este usuario.
     */
    public function estaFinalizadaParaUsuario($idUsuario)
    {
        $totalPreguntas = $this->contarPreguntasAsignadas();
        if (is_array($totalPreguntas)) {
            return $totalPreguntas;
        }
        $totalRespondidas = $this->contarRespuestasUsuario($idUsuario);
        if (is_array($totalRespondidas)) {
            return $totalRespondidas;
        }
        return $totalPreguntas > 0 && $totalPreguntas === $totalRespondidas;
    }

    /**
     * Partidas creadas por un usuario, de más reciente a más antigua.
     */
    public function listarDelUsuario()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $consulta = $conexion->prepare("
                SELECT *
                FROM partida
                WHERE idUsuario=:idUsuario
                ORDER BY idPartida DESC
            ");
            $consulta->bindParam(":idUsuario", $this->idUsuario);
            $consulta->execute();
            return $consulta->fetchAll(PDO::FETCH_ASSOC);
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al recuperar las partidas del usuario.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }

    public function preguntaAsignada($idPregunta)
    {
        $conexion = conexionBD();

        if (is_array($conexion)) {
            return $conexion;
        }

        try {
            $consulta = $conexion->prepare("
                SELECT COUNT(*) AS total
                FROM partidaxpregunta
                WHERE idPartida=:idPartida
                AND idPregunta=:idPregunta
            ");

            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->bindParam(":idPregunta", $idPregunta);
            $consulta->execute();

            $fila = $consulta->fetch(PDO::FETCH_ASSOC);

            return (int)$fila["total"] > 0;
        } catch (PDOException $error) {

            return [
                "error" => "Ocurrió un error al comprobar la pregunta.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }
    /**
     * Vincula un equipo a esta partida en la tabla intermedia 'equipoxpartida'.
     * Permite registrar qué grupos están participando en este torneo.
     */
    public function registrarEquipoEnPartida($idEquipo)
    {
        $conexion = conexionBD(); // Obtenemos la conexión modular del proyecto

        if (is_array($conexion)) {
            return $conexion; // Si hay error en la conexión, lo devuelve
        }

        try {
            // Preparamos la consulta para insertar la relación en la tabla intermedia real
            $consulta = $conexion->prepare("
                INSERT INTO equipoxpartida 
                (idPartida, idEquipo) 
                VALUES 
                (:idPartida, :idEquipo)
            ");

            // Vinculamos los parámetros con el objeto de la partida actual y el equipo recibido
            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->bindParam(":idEquipo", $idEquipo);
            $consulta->execute();

            return [
                "exito" => "El equipo se vinculó a la partida correctamente.",
                "exito_tecnico" => $conexion->lastInsertId()
            ];
        } catch (PDOException $error) {
            // Capturamos el error extrayendo solo el mensaje de texto limpio
            return [
                "error" => "Ocurrió un error al asignar el equipo a la partida.",
                "error_tecnico" => $error->getMessage()
            ];
        }
    }

    /**
     * Obtiene todos los equipos que están compitiendo en esta partida.
     * Es útil para mostrar la lista de rivales antes de empezar a responder.
     */
    public function getEquiposParticipantes()
    {
        $conexion = conexionBD();

        if (is_array($conexion)) {
            return $conexion;
        }

        try {
            // Hacemos un INNER JOIN para traer los nombres de los equipos desde la tabla intermedia
            $consulta = $conexion->prepare("
                SELECT 
                    exp.idEquipoxPartida,
                    e.idEquipo,
                    e.nombreEquipo
                FROM equipoxpartida exp
                INNER JOIN equipo e 
                    ON exp.idEquipo = e.idEquipo
                WHERE exp.idPartida = :idPartida
                ORDER BY e.nombreEquipo ASC
            ");

            $consulta->bindParam(":idPartida", $this->idPartida);
            $consulta->execute();

            return $consulta->fetchAll(PDO::FETCH_ASSOC); // Devuelve el array con los equipos rivales
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al recuperar los equipos de la partida.",
                "error_tecnico" => $error->getMessage()
            ];
        }
    }

    /**
     * Obtiene todos los jugadores reales (Usuarios) que están jugando en esta partida.
     * Utiliza la tabla 'equipoxusuario' en SQL para cruzar los datos.
     */
    public function getJugadoresDeLaPartida()
    {
        $conexion = conexionBD();

        if (is_array($conexion)) {
            return $conexion;
        }

        try {

            $consulta = $conexion->prepare("
            SELECT DISTINCT
                u.idUsuario,
                u.nombreUsuario,
                u.email,
                e.idEquipo,
                e.nombreEquipo
            FROM equipoxpartida exp

            INNER JOIN equipoxusuario exu
                ON exp.idEquipo = exu.idEquipo

            INNER JOIN usuario u
                ON exu.idUsuario = u.idUsuario

            INNER JOIN equipo e
                ON exu.idEquipo = e.idEquipo

            WHERE exp.idPartida = :idPartida

            ORDER BY e.nombreEquipo ASC,
                     u.nombreUsuario ASC
        ");

            $consulta->bindParam(
                ":idPartida",
                $this->idPartida
            );

            $consulta->execute();

            return $consulta->fetchAll(PDO::FETCH_ASSOC);
        } catch (PDOException $error) {

            return [
                "error" =>
                "Ocurrió un error al obtener la lista de jugadores.",

                "error_tecnico" =>
                $error->getMessage()
            ];
        }
    }

    public function contar()
    {
        $conexion = conexionBD();
        if (is_array($conexion)) {
            return $conexion;
        }
        try {
            $sql="SELECT COUNT(*) AS total FROM partida";
            $consulta = $conexion->prepare($sql);
            $consulta->execute();
            return (int) $consulta->fetchColumn();
        } catch (PDOException $error) {
            return [
                "error" => "Ocurrió un error al obtener el listado.",
                'error_tecnico' => $error->getMessage()
            ];
        }
    }


}