CMS-CSE/core/class/debug.class.php

<?php

/**
 * Classe de gestion des fonctionnalités de débogage.
 *
 * Cette classe fournit des outils pour le débogage, tels que la gestion des journaux,
 * l'affichage des erreurs, et la mesure du temps d'exécution.
 */
class debug
{
    /**
     * Tableau des journaux de débogage.
     *
     * @var array
     */
    private static $logs = [];

    /**
     * Temps de début pour mesurer l'exécution.
     *
     * @var float
     */
    private static $startTime;

    /**
     * Temps de fin pour mesurer l'exécution.
     *
     * @var float
     */
    private static $closeTime;

    /**
     * Active l'affichage des erreurs PHP.
     */
    public static function display_errors(){
        ini_set('display_errors', 1);
        ini_set('display_startup_errors', 1);
        error_reporting(E_ALL);
    }
    
    /**
     * Génère le type de fichier en fonction d'une chaîne donnée.
     *
     * @param string $_string Chaîne utilisée pour déterminer le type de fichier.
     * @return string Nom du fichier généré.
     */
    private static function typeFile(string $_string){
        switch ($_string) {
            case 'maintenance':
                return ".lock-maintenance";
                break;
            case 'debug':
                return ".active-debug";
                break;
            default:
                return ".active-debug-".$_string;
                break;
        }
    }
    
    /**
     * Ajoute un fichier spécifique dans le répertoire racine.
     *
     * @param string|null $_string Nom du fichier à ajouter (optionnel).
     */
    public static function addFile(?string $_string = NULL)
    {
        if($_string != NULL){
            $myfile = fopen(DOCUMENT_ROOT . self::typeFile($_string), "w");
            fclose($myfile);
        }
    }

    /**
     * Supprime un fichier spécifique du répertoire racine.
     *
     * @param string|null $_string Nom du fichier à supprimer (optionnel).
     */
    public static function removeFile(?string $_string = NULL)
    {
        if($_string != NULL){
            unlink(DOCUMENT_ROOT . self::typeFile($_string));
        }
    }

    /**
     * Vérifie si un fichier spécifique existe dans le répertoire racine.
     *
     * @param string|null $_string Nom du fichier à vérifier (optionnel).
     * @return bool TRUE si le fichier existe, FALSE sinon.
     */
    public static function isFile(?string $_string = NULL)
    {
        return file_exists(DOCUMENT_ROOT . self::typeFile($_string)) ? TRUE : FALSE;
    }
    
    /**
     * Inclut les ressources de débogage si le mode debug est activé.
     */
    public static function includeDebug()
    {
        if (debug::isFile("debug")) {
            echo '<link rel="stylesheet" href="' . cache::getFileWithTime("css/debug.css") . '">';
        }
    }

    /**
     * Affiche ou retourne une variable formatée pour le débogage.
     *
     * @param mixed $var Variable à afficher.
     * @param string $label Étiquette pour identifier la variable (par défaut 'Dump').
     * @param bool $echo Indique si la sortie doit être affichée (TRUE) ou retournée (FALSE).
     * @return string|null Contenu formaté si $echo est FALSE, sinon NULL.
     */
    public static function dump($var, $label = 'Dump', $echo = true)
    {
        // Start output buffering
        ob_start();

        echo "<pre class='debug-dump'>";
        echo "<strong>" . $label . ":</strong> ";

        // Convert array or object to string
        if (is_array($var)) {
            print_r($var);
        } elseif (is_object($var)) {
            echo self::objectToString($var);
        } else {
            var_dump($var);
        }

        echo "</pre>";

        // Get the contents of the buffer
        $output = ob_get_clean();

        // If echo is true, print the output
        if ($echo) {
            echo $output;
        } else {
            return $output;
        }
    }

    /**
     * Convertit un objet en chaîne formatée pour le débogage.
     *
     * @param object $object Objet à convertir.
     * @param string|null $_tab Indentation pour le formatage (optionnel).
     * @return string Représentation formatée de l'objet.
     */
    public static function objectToString($object, $_tab = NULL) {
        ob_start();

        $tab = "&nbsp;&nbsp;&nbsp;&nbsp;" . $_tab;
        
        echo "<span class='debug-console-capsule'>Object (" . get_class($object) . ")\n</span>";
        echo $_tab . "<span class='debug-console-capsule'>{\n</span>";
        
        foreach (get_object_vars($object) as $property => $value) {
            echo $tab . "<span class='debug-console-capsule'>[<span class='debug-console-key'>$property</span>] => </span>";
            if (is_array($value)) {
                echo self::arrayToString($value, $tab);
            } elseif (is_object($value)) {
                echo self::objectToString($value, $tab);
            } else {
                echo "<span class='debug-console-value'>" . var_export($value, true) . "</span>\n";
            }
        }
        
        echo $_tab . "<span class='debug-console-capsule'>}\n</span>";
        
        return ob_get_clean();
    }



    /**
     * Convertit un tableau en chaîne formatée pour le débogage.
     *
     * @param array $array Tableau à convertir.
     * @param string|null $_tab Indentation pour le formatage (optionnel).
     * @return string Représentation formatée du tableau.
     */
    public static function arrayToString($array, $_tab = NULL)
    {
        ob_start();

        $tab = "&nbsp;&nbsp;&nbsp;&nbsp;".$_tab;
        
        echo "<span class='debug-console-capsule'>Array\n</span>";
        echo $_tab . "<span class='debug-console-capsule'>(\n</span>";
        
        foreach ($array as $key => $value) {
            echo $tab . "<span class='debug-console-capsule'>[<span class='debug-console-key'>$key</span>] => </span>";
            if (is_array($value)) {
                echo self::arrayToString($value, $tab);
            } elseif (is_object($value)) {
                echo self::objectToString($value, $tab);
            } else {
                echo "<span class='debug-console-value'>" . var_export($value, true) . "</span>\n";
            }
        }
        
        echo $_tab . "<span class='debug-console-capsule'>)\n</span>";
        
        return ob_get_clean();
    }

    /**
     * Convertit une variable en chaîne de caractères pour le débogage.
     *
     * @param mixed $var La variable à convertir.
     * @param string $label Une étiquette pour identifier la variable.
     * @return string La représentation formatée de la variable.
     */
    private static function variableToString($var, $label)
    {
        ob_start();
        echo "$label: ";
        if (is_array($var) || is_object($var)) {
            print_r($var);
        } else {
            var_dump($var);
        }
        return ob_get_clean();
    }

    /**
     * Récupère la trace d'exécution sous forme de chaîne.
     *
     * @return string La trace d'exécution formatée.
     */
    public static function getTraces(){
        $return = "Trace : ";
        
        // Obtenir la trace d'exécution
        $backtrace = debug_backtrace();
        $nb = count($backtrace)-1;

        for ($i=$nb; $i > 0; $i--) { 
            $return .= ($i != 0) ? "[".$backtrace[$i]["function"]."] " : NULL;
            $return .= str_replace(DOCUMENT_ROOT, '', $backtrace[$i]["file"]).":".$backtrace[$i]["line"];
            $return .= ($i != 1) ? " >> " : NULL;
        }

        return $return;
    }

    /**
     * Affiche un tableau formaté pour le débogage.
     *
     * @param array|null $_array Le tableau à afficher (optionnel).
     * @param int|null $_exit Si défini, termine le script après l'affichage (optionnel).
     */
    public static function print_r(?array $_array = NULL, ?int $_exit = NULL)
    {
        echo "<div>".debug::getTraces() . "</div>";

        if(empty($_array)){
            echo "<pre>EMPTY</pre>";
        } else {
            echo "<pre>";
            print_r($_array);
            echo "</pre>";
        }
        ($_exit != NULL) ? exit() : NULL;
    }

    /**
     * Vérifie si une chaîne contient du HTML.
     *
     * @param string $_string La chaîne à vérifier.
     * @return bool TRUE si la chaîne contient du HTML, FALSE sinon.
     */
    public static function isHtml(string $_string) : bool 
    {
        $stripped_string = strip_tags($_string);
        return $_string !== $stripped_string;
    }

    /**
     * Génère un contenu HTML encapsulé dans un iframe.
     *
     * @param string $htmlContent Le contenu HTML à encapsuler.
     * @return string Le contenu HTML complet avec iframe.
     */
    public static function generateHtmlContent($htmlContent)
    {
        $id = md5(microtime());
        return <<<HTML
                    <!DOCTYPE html>
                    <html>
                    <head>
                        <title>Exécution de HTML</title>
                        <style>
                            .isolated-iframe {
                                width: 100%;
                                height: 300px;
                                border: none;
                            }
                        </style>
                    </head>
                    <body>
                        <iframe id="isolatedIframe-$id" class="isolated-iframe"></iframe>
                        <script>
                            var iframe = document.getElementById('isolatedIframe-$id');
                            var doc = iframe.document || iframe.contentDocument || iframe.contentWindow.document;
                            doc.open();
                            doc.write(`{$htmlContent}`);
                            doc.close();
                        </script>
                    </body>
                    </html>
                    HTML;
    }


    /**
     * Ajoute un message au journal de débogage.
     *
     * @param mixed $_message Le message à ajouter.
     * @param string|null $_mark Une marque pour identifier le message (optionnel).
     */
    public static function log($_message, $_mark = NULL)
    {        
        $mark = "<div class='debug-head-console'>";
        $mark .= ($_mark != NULL) ? "<div style='font-weight: bold;'>". $_mark . "</div>" : NULL;
        $mark .= self::getTraces();
        $mark .= "</div>";
        if($_message != NULL) {
            if(is_array($_message)){
                self::$logs[] = ["data" => $mark ."<div class='debug-console'>" . self::arrayToString($_message) . "</div>", "nl2br" => TRUE];
            } elseif(is_object($_message)){
                self::$logs[] = ["data" => $mark ."<div class='debug-console'>" . self::objectToString($_message) . "</div>", "nl2br" => TRUE];
            } elseif(self::isHtml($_message)){
                self::$logs[] = ["data" => $mark ."<div class='debug-console'>" . self::generateHtmlContent($_message) . "</div>", "nl2br" => FALSE];
            } elseif($mark != NULL){
                self::$logs[] = ["data" => $mark ."<div class='debug-console' style='color:blue;'>" . $_message . "</div>", "nl2br" => TRUE];
            } else {
                self::$logs[] = ["data" => $_message, "nl2br" => TRUE];
            }
        }
    }

    /**
     * Ajoute un message au journal de session de débogage.
     *
     * @param mixed $_message Le message à ajouter.
     * @param string|null $_mark Une marque pour identifier le message (optionnel).
     */
    public static function logSession($_message, $_mark = NULL)
    {        
        $mark = "<div class='debug-head-console'>";
        $mark .= ($_mark != NULL) ? "<div style='font-weight: bold;'>". $_mark . "</div>" : NULL;
        $mark .= self::getTraces();
        $mark .= "</div>";
        if($_message != NULL) {
            if(is_array($_message)){
                self::setSession(["data" => $mark ."<div class='debug-console'>" . self::arrayToString($_message) . "</div>", "nl2br" => TRUE]);
            } elseif(is_object($_message)){
                self::setSession(["data" => $mark ."<div class='debug-console'>" . self::objectToString($_message) . "</div>", "nl2br" => TRUE]);
            } elseif(self::isHtml($_message)){
                self::setSession(["data" => $mark ."<div class='debug-console'>" . self::generateHtmlContent($_message) . "</div>", "nl2br" => false]);
            } elseif($mark != NULL){
                self::setSession(["data" => $mark ."<div class='debug-console' style='color:blue;'>" . $_message . "</div>", "nl2br" => TRUE]);
            } else {
                self::setSession(["data" => $_message, "nl2br" => TRUE]);
            }
        }
    }

    /**
     * Affiche le panneau des journaux du débogueur en HTML.
     *
     * Cette méthode affiche les versions de PHP et MySQL, le temps d'exécution, ainsi qu'un ensemble de cases à cocher
     * pour intercepter différents types d'actions (Submit, requêtes SQL, Emails et mode debug d'envoi d'email).
     * Elle affiche ensuite les journaux de débogage collectés et, si disponibles, les journaux de session.
     * Enfin, elle charge le JavaScript associé au débogage.
     *
     * @return void
     */
    public static function renderLogs()
    {
            echo "<div id='debugger-logs'>";

            echo "<div class='debug-renderLogs-header'>";
            echo "PHP <span style=\"font-weight: bold;\">". phpversion() . "</span> | MYSQL <span style=\"font-weight: bold;\">" . db::version() . "</span> | " . number_format(self::$closeTime, 4) . " secondes ";
            echo "</div>";
            echo "<div class=\"form-check form-switch\" style=\"margin-top: -30px;\">
                <div>
                    <input class=\"form-check-input\" type=\"checkbox\" id=\"checkIsSubmit\" " . core::checkboxSelecter(self::isFile("submit"), 0) . " >
                    <label class=\"form-check-label\" for=\"checkIsSubmit\">Intercepter les <span style=\"font-weight: bold;\">Submit</span></label>
                </div>
                <div>
                    <input class=\"form-check-input\" type=\"checkbox\" id=\"checkIsSql\" " . core::checkboxSelecter(self::isFile("sql"), 0) . " >
                    <label class=\"form-check-label\" for=\"checkIsSql\">Intercepter les <span style=\"font-weight: bold;\">requêtes SQL</span></label>
                </div>
                <div>
                    <input class=\"form-check-input\" type=\"checkbox\" id=\"checkIsEmail\" " . core::checkboxSelecter(self::isFile("email"), 0) . " >
                    <label class=\"form-check-label\" for=\"checkIsEmail\">Intercepter les <span style=\"font-weight: bold;\">Email</span></label>
                </div>
                <div>
                    <input class=\"form-check-input\" type=\"checkbox\" id=\"checkSendIsEmail\" " . core::checkboxSelecter(self::isFile("send-email"), 0) . " >
                    <label class=\"form-check-label\" for=\"checkSendIsEmail\">Afficher le mode debug lors de l'<span style=\"font-weight: bold;\">envoie d'email</span></label>
                </div>
            </div>";

            foreach (self::$logs as $log) {
                if($log != NULL){
                    echo "<div class='debug-renderLogs-print'>";
                        echo $log["nl2br"] == TRUE ? nl2br($log["data"]) : $log["data"];
                    echo "</div>";
                }
            }

            if(self::ifSession()){
                foreach (self::getSession() as $logSession) {
                    echo "<div class='debug-renderLogs-print'>";
                        echo $logSession["nl2br"] == TRUE ? nl2br($logSession["data"]) : $logSession["data"];
                    echo "</div>";
                }
            }

            echo "</div>";
            get::javascript("debug");
    }

    /**
     * Initialise le débogueur en enregistrant une fonction de fermeture.
     */
    public static function init()
    {
        register_shutdown_function(function () {
            self::renderLogs();
        });
    }

    /**
     * Démarre un chronomètre pour mesurer le temps d'exécution.
     */
    public static function startTimer()
    {
        self::$startTime = microtime(true);
    }

    /**
     * Arrête le chronomètre et calcule le temps écoulé.
     */
    public static function endTimer()
    {
        self::$closeTime = microtime(true) - self::$startTime;
    }

    /**
     * Génère un badge HTML avec un lien et un libellé.
     *
     * @param string $_link Lien vers lequel le badge redirige.
     * @param string $_label Libellé affiché sur le badge.
     * @return string Le code HTML du badge.
     */
    public static function getBadge(string $_link,string $_label){
        return '<a href="'. $_link .'" target="_blank" class="badge debug-badge">'. $_label .'</a>';
    }

    /**
     * Affiche l'environnement actuel si ce n'est pas l'environnement de production.
     */
    public static function printEnvironnement(){
        echo (ENVIRONNEMENT != "PROD") ? " [" . ENVIRONNEMENT . "]" : NULL;
    }

    /**
     * Construit un badge HTML personnalisé à partir des données fournies.
     *
     * @param array $_data Données pour personnaliser le badge (couleur, texte, lien, etc.).
     * @return string Le code HTML du badge.
     */
    private static function buildBadge(array $_data){
        $color = empty($_data["color"]) ? "black" : $_data["color"];
        $backgroundColor = empty($_data["background-color"]) ? "orangered" : $_data["background-color"];
        $class = empty($_data["class"]) ? NULL : $_data["class"];
        $link = empty($_data["link"]) ? "#" : $_data["link"];
        $txt = empty($_data["txt"]) ? NULL : $_data["txt"];
        $icon = empty($_data["icon"]) ? NULL : "<i class=\"" . $_data["icon"] . "\"></i> ";
        return "<a href=\"" . $link . "\"><span class=\"badge " . $class . "\" style=\"background-color:" . $backgroundColor . "; color:" . $color . "; padding: 3px 5px 2px 5px; margin-right: 5px;\">" . $icon . $txt . "</span></a>";
    }

    /**
     * Récupère tous les badges de débogage disponibles.
     *
     * @return string Les badges HTML générés.
     */
    public static function getBadges(){
        $return = "";
        if(debug::isFile("maintenance")){
            $return .= self::buildBadge([
                "icon" => "bi bi-exclamation-diamond-fill",
                "link" => "/parametres.html#parametres-debug", 
                "background-color" => "red",  
                "color" => "white", 
                "txt" => "MODE MAINTENANCE"
            ]);
        }
        if(debug::isFile("debug")){
            $return .= self::buildBadge([
                "icon" => "bi bi-bug-fill",
                "class" => "toggle-logs",
                "link" => "#", 
                "background-color" => "orangered",  
                "color" => "white", 
                "txt" => "MODE DEBUG"
            ]);
        } 
        if(self::isFile("sql")){
            $return .= self::buildBadge([
                "icon" => "bi bi-database-fill",
                "class" => "toggle-logs",
                "link" => "#", 
                "background-color" => "orange",  
                "color" => "black", 
                "txt" => "DEBUG SQL"
            ]);
        }
        if(self::isFile("email")){
            $return .= self::buildBadge([
                "icon" => "bi bi-envelope-fill",
                "class" => "toggle-logs",
                "link" => "#", 
                "background-color" => "orange",  
                "color" => "black", 
                "txt" => "DEBUG EMAIL"
            ]);
        }
        if(self::isFile("send-email")){
            $return .= self::buildBadge([
                "icon" => "bi bi-envelope-fill",
                "class" => "toggle-logs",
                "link" => "#", 
                "background-color" => "orange",  
                "color" => "black", 
                "txt" => "DEBUG SEND EMAIL"
            ]);
        }
        if(self::isFile("submit")){
            $return .= self::buildBadge([
                "icon" => "bi bi-send-fill",
                "class" => "toggle-logs",
                "link" => "#", 
                "background-color" => "orange",  
                "color" => "black", 
                "txt" => "DEBUG SUBMIT"
            ]);
        } 
        return $return;
    }

    /**
     * Ajoute des données au tableau de session de débogage.
     *
     * @param mixed $_data Les données à ajouter à la session.
     */
    public static function setSession($_data){
        $_SESSION["DEBUG"][] = $_data;
    }

    /**
     * Récupère les données de la session de débogage et les réinitialise.
     *
     * @return array Les données de la session de débogage.
     */
    public static function getSession(){
        $return = $_SESSION["DEBUG"];
        self::resetSession();
        return $return;
    }

    /**
     * Vérifie si des données de débogage sont présentes dans la session.
     *
     * @return bool TRUE si des données sont présentes, FALSE sinon.
     */
    public static function ifSession(){
        return empty($_SESSION["DEBUG"]) ? FALSE : TRUE;
    }

    /**
     * Réinitialise les données de la session de débogage.
     */
    public static function resetSession(){
        unset($_SESSION["DEBUG"]);
    }
}