<?php

/**
 * Classe `db`
 *
 * Cette classe gère la connexion à la base de données et fournit des méthodes pour exécuter des requêtes SQL.
 *
 * Fonctionnalités principales :
 * - Gestion de la connexion à la base de données avec PDO.
 * - Préparation et exécution de requêtes SQL.
 * - Gestion des transactions.
 * - Récupération des résultats des requêtes.
 * - Gestion des erreurs SQL.
 *
 * @package Core\Class
 */
class db
{
    private static PDO $dbh;
    private static string $error = '';
    private static PDOStatement $stmt;

    /**
     * Établit une connexion à la base de données si elle n'existe pas déjà.
     *
     * @return void
     * @throws Exception En cas d'erreur de connexion.
     */
    private static function connect(): void
    {
        if (isset(self::$dbh)) {
            return;
        }

        $dsn = "mysql:host=" . DB_HOST . ";dbname=" . DB_NAME . ";charset=utf8mb4";
        $options = [
            PDO::ATTR_PERSISTENT => true,
            PDO::ATTR_ERRMODE    => PDO::ERRMODE_EXCEPTION
        ];

        try {
            self::$dbh = new PDO($dsn, DB_USER, DB_PASS, $options);
        } catch (PDOException $e) {
            self::$error = $e->getMessage();
            throw new Exception("Database connection error: " . self::$error);
        }
    }

    /**
     * Récupère la version du serveur de base de données.
     *
     * @return string La version du serveur.
     */
    public static function version(): string
    {
        self::connect();
        return self::$dbh->getAttribute(PDO::ATTR_SERVER_VERSION);
    }

    /**
     * Prépare une requête SQL.
     *
     * @param string $query La requête SQL à préparer.
     * @return void
     */
    public static function query(string $query): void
    {
        self::connect();
        self::$stmt = self::$dbh->prepare($query);
    }

    /**
     * Lie une valeur à un paramètre dans la requête préparée.
     *
     * @param string $param Le nom du paramètre.
     * @param mixed $value La valeur à lier.
     * @param int|null $type Le type de la valeur (optionnel).
     * @return void
     */
    public static function bind(string $param, mixed $value = null, ?int $type = null): void
    {
        if (is_null($type)) {
            $type = match (true) {
                is_int($value)  => PDO::PARAM_INT,
                is_bool($value) => PDO::PARAM_BOOL,
                is_null($value) => PDO::PARAM_NULL,
                default         => PDO::PARAM_STR,
            };
        }
        self::$stmt->bindValue($param, $value, $type);
    }

    /**
     * Exécute la requête préparée.
     *
     * @return bool TRUE si l'exécution a réussi, FALSE sinon.
     */
    public static function execute(): bool
    {
        self::connect();
        if (class_exists('debug') && method_exists('debug', 'isFile') && debug::isFile("sql")) {
            ob_start();
            $result = self::$stmt->execute();
            self::$stmt->debugDumpParams();
            $debugOutput = ob_get_clean();
            debug::logSession($debugOutput);
            return $result;
        }
        return self::$stmt->execute();
    }

    /**
     * Récupère tous les résultats de la requête sous forme de tableau associatif.
     *
     * @return array Les résultats de la requête.
     */
    public static function resultset(): array
    {
        self::execute();
        return self::$stmt->fetchAll(PDO::FETCH_ASSOC);
    }

    /**
     * Récupère un seul résultat de la requête sous forme de tableau associatif.
     *
     * @return array|false Le résultat de la requête ou FALSE si aucun résultat.
     */
    public static function single(): array|false
    {
        self::execute();
        return self::$stmt->fetch(PDO::FETCH_ASSOC);
    }

    /**
     * Récupère le nombre de lignes affectées par la dernière requête.
     *
     * @return int Le nombre de lignes affectées.
     */
    public static function rowCount(): int
    {
        return self::$stmt->rowCount();
    }

    /**
     * Récupère l'ID de la dernière ligne insérée.
     *
     * @return string L'ID de la dernière ligne insérée.
     */
    public static function lastInsertId(): string
    {
        self::connect();
        return self::$dbh->lastInsertId();
    }

    /**
     * Démarre une transaction.
     *
     * @return bool TRUE si la transaction a démarré avec succès, FALSE sinon.
     */
    public static function beginTransaction(): bool
    {
        self::connect();
        return self::$dbh->beginTransaction();
    }

    /**
     * Valide une transaction.
     *
     * @return bool TRUE si la transaction a été validée avec succès, FALSE sinon.
     */
    public static function endTransaction(): bool
    {
        self::connect();
        return self::$dbh->commit();
    }

    /**
     * Annule une transaction.
     *
     * @return bool TRUE si la transaction a été annulée avec succès, FALSE sinon.
     */
    public static function cancelTransaction(): bool
    {
        self::connect();
        return self::$dbh->rollBack();
    }

    /**
     * Affiche les paramètres de la requête pour le débogage.
     *
     * @return void
     */
    public static function debugDumpParams(): void
    {
        self::connect();
        self::$stmt->debugDumpParams();
    }

    /**
     * Affiche les erreurs de la dernière requête SQL.
     *
     * @return void
     */
    public static function queryError(): void
    {
        self::connect();
        $qError = self::$dbh->errorInfo();
        if (!empty($qError[2])) {
            echo "Query Error: " . $qError[2];
        }
    }

    /**
     * Récupère le dernier message d'erreur de connexion.
     *
     * @return string Le message d'erreur.
     */
    public static function getError(): string
    {
        return self::$error;
    }
}