battle.dao.php

Aller à la documentation de ce fichier.

<?php
class BattleDAO {
    private ?PDO $pdo;
 
    public function __construct(?PDO $pdo = null)
    {
        $this->pdo = $pdo;
    }
 
    public function findAll(): array
    {
        $sql = "SELECT * FROM battle";
        $pdoStatement = $this->pdo->prepare($sql);
        $pdoStatement->execute();
        $pdoStatement->setFetchMode(PDO::FETCH_ASSOC);
        $tableau = $pdoStatement->fetchAll();
        $battle = $this->hydrateMany($tableau);
        return $battle;
    }
 
    public function find(int $id): Battle
    {
        $sql = "SELECT * FROM battle WHERE idBattle = :id";
        $pdoStatement = $this->pdo->prepare($sql);
        $pdoStatement->execute(array(
            ':id' => $id
        ));
 
        $pdoStatement->setFetchMode(PDO::FETCH_ASSOC);
        $tableau = $pdoStatement->fetch();
        $battle = $this->hydrate($tableau);
        return $battle;
    }
 
    public function hydrate(array $data): Battle
    {
        $battle = new Battle();
 
        $battle->setIdBattle(isset($data['idBattle']) ? (int)$data['idBattle'] : null);
        $battle->setTitreBattle($data['titreBattle'] ?? null);
 
        // Conversion sécurisée des dates SQL → objets DateTime
        $battle->setDateDebutBattle(
            !empty($data['dateDebutBattle']) ? new DateTime($data['dateDebutBattle']) : null
        );
 
        $battle->setDateFinBattle(
            !empty($data['dateFinBattle']) ? new DateTime($data['dateFinBattle']) : null
        );
 
        // Conversion du statut (enum)
        if (!empty($data['statutBattle'])) {
            $battle->setStatutBattle(StatutBattle::from($data['statutBattle']));
        }
 
        $battle->setEmailCreateurBattle($data['emailCreateurBattle'] ?? null);
        $battle->setEmailParticipantBattle($data['emailParticipantBattle'] ?? null);
        $battle->setIdChansonCreateur($data['idChansonCreateur'] ?? null);
        $battle->setIdChansonParticipant($data['idChansonParticipant'] ?? null);
 
        // --- HYDRATATION DES OBJETS LIÉS (SÉCURITÉ PSEUDO/PHOTO) ---
        $uDao = new UtilisateurDAO($this->pdo);
        $cDao = new ChansonDAO($this->pdo);
 
        // Hydratation du créateur
        if (!empty($data['emailCreateurBattle'])) {
            $battle->setCreateur($uDao->find($data['emailCreateurBattle']));
        }
 
        // Hydratation du participant
        if (!empty($data['emailParticipantBattle'])) {
            $battle->setParticipant($uDao->find($data['emailParticipantBattle']));
        }
 
        // Hydratation de la chanson du créateur
        if (!empty($data['idChansonCreateur'])) {
            $battle->setChansonCreateurObj($cDao->findId((int)$data['idChansonCreateur']));
        }
 
        // Hydratation de la chanson du participant
        if (!empty($data['idChansonParticipant'])) {
            $battle->setChansonParticipantObj($cDao->findId((int)$data['idChansonParticipant']));
        }
 
        return $battle;
    }
 
    public function hydrateMany(array $rows): array
    {
        $battles = [];
        foreach ($rows as $row) {
            $battles[] = $this->hydrate($row);
        }
        return $battles;
    }
 
    public function getPdo(): ?PDO
    {
        return $this->pdo;
    }
 
    public function setPdo(?PDO $pdo): void
    {
        $this->pdo = $pdo;
    }
 
    public function countBattlesWon(string $emailArtiste): int
    {
        $sql = "SELECT COUNT(*) as wins FROM (
                    SELECT 
                        b.idBattle,
                        b.emailCreateurBattle,
                        b.emailParticipantBattle,
                        COALESCE(SUM(CASE WHEN v.emailVotee = b.emailCreateurBattle THEN 1 ELSE 0 END), 0) as votes_createur,
                        COALESCE(SUM(CASE WHEN v.emailVotee = b.emailParticipantBattle THEN 1 ELSE 0 END), 0) as votes_participant
                    FROM battle b
                    LEFT JOIN vote v ON b.idBattle = v.idBattle
                    WHERE b.statutBattle = 'terminee'
                      AND (b.emailCreateurBattle = :email1 OR b.emailParticipantBattle = :email2)
                    GROUP BY b.idBattle, b.emailCreateurBattle, b.emailParticipantBattle
                ) AS battle_stats
                WHERE 
                    (emailCreateurBattle = :email3 AND votes_createur > votes_participant)
                    OR (emailParticipantBattle = :email4 AND votes_participant > votes_createur)";
 
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([
            ':email1' => $emailArtiste,
            ':email2' => $emailArtiste,
            ':email3' => $emailArtiste,
            ':email4' => $emailArtiste
        ]);
        return (int)$stmt->fetchColumn();
    }
 
    public function update(Battle $battle): bool {
        $sql = "UPDATE battle SET 
                statutBattle = :statut, 
                emailParticipantBattle = :participant,
                idChansonCreateur = :chansonCreateur,
                idChansonParticipant = :chansonPart
                WHERE idBattle = :id";
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute([
            ':statut' => $battle->getStatutBattle()->value,
            ':participant' => $battle->getEmailParticipantBattle(),
            ':chansonCreateur' => $battle->getIdChansonCreateur(),
            ':chansonPart' => $battle->getIdChansonParticipant(),
            ':id' => $battle->getIdBattle()
        ]);
    }
 
    public function addVote(string $emailVotant, int $idBattle, string $emailVotee): bool {
        $sql = "INSERT INTO vote (emailVotant, idBattle, emailVotee) VALUES (:votant, :idB, :votee)";
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute([':votant' => $emailVotant, ':idB' => $idBattle, ':votee' => $emailVotee]);
    }
 
    public function insert(Battle $battle): bool {
        $sql = "INSERT INTO battle (titreBattle, dateDebutBattle, dateFinBattle, statutBattle, emailCreateurBattle, emailParticipantBattle) 
                VALUES (:titre, :debut, :fin, :statut, :createur, :participant)";
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute([
            ':titre' => $battle->getTitreBattle(),
            ':debut' => $battle->getDateDebutBattle()?->format('Y-m-d H:i:s'),
            ':fin' => $battle->getDateFinBattle()?->format('Y-m-d H:i:s'),
            ':statut' => $battle->getStatutBattle()->value,
            ':createur' => $battle->getEmailCreateurBattle(),
            ':participant' => $battle->getEmailParticipantBattle()
        ]);
    }
 
    public function updateSongs(int $idBattle, ?int $idChansonCreateur, ?int $idChansonParticipant): bool {
        $sql = "UPDATE battle SET idChansonCreateur = :c, idChansonParticipant = :p WHERE idBattle = :id";
        return $this->pdo->prepare($sql)->execute([':c' => $idChansonCreateur, ':p' => $idChansonParticipant, ':id' => $idBattle]);
    }
 
    public function getVotesCount(int $idBattle, string $emailArtiste): int {
        $sql = "SELECT COUNT(*) FROM vote WHERE idBattle = :idB AND emailVotee = :email";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([':idB' => $idBattle, ':email' => $emailArtiste]);
        return (int)$stmt->fetchColumn();
    }
 
    public function hasUserVoted(int $idBattle, string $emailVotant): bool {
        $sql = "SELECT COUNT(*) FROM vote WHERE idBattle = :idB AND emailVotant = :email";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([':idB' => $idBattle, ':email' => $emailVotant]);
        return $stmt->fetchColumn() > 0;
    }
 
    public function modifierChanson(int $idBattle, int $idChanson, bool $estCreateur): bool {
 
    $nomColonne = $estCreateur ? "idChansonCreateur" : "idChansonParticipant";
    $sql = "UPDATE `battle` SET `$nomColonne` = :idC WHERE `idBattle` = :idB";
    
    $stmt = $this->pdo->prepare($sql);
    return $stmt->execute([
        ':idC' => $idChanson, 
        ':idB' => $idBattle
    ]);
}
 
    public function modifierStatut(int $idBattle, string $nouveauStatut): bool {
        $sql = "UPDATE battle SET statutBattle = :statut WHERE idBattle = :id";
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute([
            ':statut' => $nouveauStatut, 
            ':id' => $idBattle
        ]);
    }
    public function findAllByUser(string $email): array
    {
        // On utilise :email1 et :email2 pour éviter l'erreur de paramètre dupliqué
        $sql = "SELECT * FROM battle 
                WHERE emailCreateurBattle = :email1 
                OR emailParticipantBattle = :email2 
                ORDER BY dateDebutBattle DESC";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([
            ':email1' => $email,
            ':email2' => $email
        ]);
        return $this->hydrateMany($stmt->fetchAll(PDO::FETCH_ASSOC));
    }
 
    public function getStatsArtiste(string $email): array
    {
        $sql = "SELECT 
                SUM(CASE 
                    WHEN (emailCreateurBattle = :email1 AND votes_createur > votes_participant) OR 
                         (emailParticipantBattle = :email2 AND votes_participant > votes_createur) 
                    THEN 1 ELSE 0 END) as victoires,
                SUM(CASE 
                    WHEN (emailCreateurBattle = :email3 AND votes_createur < votes_participant) OR 
                         (emailParticipantBattle = :email4 AND votes_participant < votes_createur) 
                    THEN 1 ELSE 0 END) as defaites
                FROM (
                    SELECT 
                        b.idBattle, b.emailCreateurBattle, b.emailParticipantBattle,
                        (SELECT COUNT(*) FROM vote v WHERE v.idBattle = b.idBattle AND v.emailVotee = b.emailCreateurBattle) as votes_createur,
                        (SELECT COUNT(*) FROM vote v WHERE v.idBattle = b.idBattle AND v.emailVotee = b.emailParticipantBattle) as votes_participant
                    FROM battle b
                    WHERE (b.emailCreateurBattle = :email5 OR b.emailParticipantBattle = :email6)
                    AND b.statutBattle = 'terminee'
                ) as stats";
 
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([
            ':email1' => $email, ':email2' => $email, 
            ':email3' => $email, ':email4' => $email,
            ':email5' => $email, ':email6' => $email
        ]);
        
        $res = $stmt->fetch(PDO::FETCH_ASSOC);
        return [
            'victoires' => (int)($res['victoires'] ?? 0),
            'defaites' => (int)($res['defaites'] ?? 0)
        ];
    }
    public function deleteBattle(int $idBattle): bool {
        $sql = "DELETE FROM battle WHERE idBattle = :id AND statutBattle = 'en_attente'";
        $stmt = $this->pdo->prepare($sql);
        return $stmt->execute([':id' => $idBattle]);
    }
 
}