<?php
// declare(encoding='UTF-8');
/**
 * Classe de gestion des exceptions.
 * C'est un Singleton.
 *
 * PHP Version 5
 *
 * @category  Class
 * @package   Framework
 * @author	aurelien <aurelien@tela-botanica.org>
 * @copyright 2009 Tela-Botanica
 * @license   http://www.cecill.info/licences/Licence_CeCILL_V2-fr.txt Licence CECILL
 * @license   http://www.gnu.org/licenses/gpl.html Licence GNU-GPL
 * @version   SVN: $$Id$$
 * @link	  /doc/framework/
 *
 */
class GestionnaireException {

	/**
	 * Liste des exceptions enregistrées
	 */
	private static $exceptions = array();

	/**
	 * Détermine si l'on affiche ou non le contexte
	 */
	private static $contexte = false;

	 /**
	 * Détermine si l'on loggue ou non les erreurs
	 */
	private static $logger = false;

	/**
	 * Détermine si l'on loggue ou non les erreurs
	 */
	private static $afficher = false;

	/**
	 * Definit si php est lancé en ligne de commande ou en mode serveur
	 */
	private static $mode = null ;

	/**
	 * le gestionnaire d'exception est un singleton
	 * et possède donc un "pointeur statique sur lui-même"
	 */
	private static $gestionnaireException;

	/**
	 * Constructeur avec paramètres optionnel
	 * @param bool indique si l'on veut afficher ou non le contexte des exceptions (i.e. la trace)
	 */
	public function __construct() {
		self::$exceptions = array();
		self::$contexte = Config::get('fw_debogage_contexte');
		self::$logger = Config::get('fw_log_debogage');
		self::$afficher = Config::get('fw_debogage');
		self::$mode = php_sapi_name();

		set_exception_handler(array(get_class($this),'gererException'));
		set_error_handler(array(get_class($this),'gererErreur'));
	}

	/**
	 * Renvoie le booleen définissant si l'on affiche le contexte ou non
	 */
	public static function getContexte() {
		return self::$contexte;
	}

	/**
	 * Definit si l'on veut afficher le contexte ou non
	 * @param bool true si on veut afficher le contexte, false sinon, par défaut vaut false
	 */
	public static function setContexte($contexte) {
		self::$contexte = $contexte;
	}

	 /** Fonction d'accès au singleton
	 * @return GestionnaireErreur le gestionnaire d'exceptions courant
	 */
	public static function getInstance() {
		if (self::$gestionnaireException instanceof GestionnaireException) {
			return self::$gestionnaireException;
		}
		self::$gestionnaireException = new GestionnaireException;

		return self::$gestionnaireException;
	}

	/**
	 * Fonction de gestion des exceptions, remplace le handler par défaut
	 * @param Exception $e l'exception à traiter
	 */
	public static function gererException(Exception $e) {
		// pour le moment on se contente de l'ajouter au tableau et de les afficher
		self::$exceptions[] = $e;

		// si on doit logger on envoie l'exception au loggeur
		if (self::$logger) {
			self::loggerException($e);
		}
	}

	/**
	 * Gère les erreurs en les convertissant en exceptions (remplace la fonction gestion d'erreurs native de php)
	 * @param int $niveau le niveau de l'erreur
	 * @param string $message le message associé à l'erreur
	 * @param string $fichier le nom du fichier où l'erreur s'est produite
	 * @param int $ligne la ligne où l'erreur s'est produite
	 * @param string $contexte le contexte associé à l'erreur
	 */
	public static function gererErreur($niveau,  $message,  $fichier,  $ligne,  $contexte){
		// si aucun rapport d'erreur, on sort directement
		if (error_reporting() == 0) {
			return;
		}

		// sinon on crée une exception
		$e = new ErrorException($message, 0, $niveau, $fichier, $ligne);
		// que l'on donne au tableau d'exceptions
		self::$exceptions[] = $e;
		// on la logge si nécéssaire
		if (self::$logger) {
			self::loggerException($e);
		}
		return;
	}

	/**
	 * Renvoie les exceptions au format (X)HTML
	 * ou bien au format texte suivant le mode d'utilisation de PHP
	 */
	public static function getExceptions() {
		$retour = '';
		foreach (self::$exceptions as $cle => $e) {
			switch (self::$mode) {
				case 'cli' :
					$retour .= $e->getMessage()."\n";
					$retour .= 'Fichier : '.$e->getFile()."\n";
					$retour .= 'Ligne : '.$e->getLine()."\n";
					if (self::getContexte()) {
						$retour .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
					}
					break;
				default:
					$retour .= '<pre class="debogage">'."\n";
					$retour .= $e->getMessage()."\n";
					$retour .= '<span class="debogage_fichier">'.'Fichier : '.$e->getFile().'</span>'."\n";
					$retour .= '<span class="debogage_ligne">'.'Ligne : '.$e->getLine().'</span>'."\n";
					$retour .= '</pre>'."\n";

					if (self::getContexte()) {
						$retour .= '<pre>'."\n";
						$retour .= '<strong>Contexte : </strong>'."\n".print_r($e->getTraceAsString(), true)."\n";
						$retour .= '</pre>'."\n";
					}
			}
			// Nous vidons le tableau des exceptions au fur et à mesure
			unset(self::$exceptions[$cle]);
		}
		return $retour;
	}

	/**
	 * logge une exception donnée sous une forme lisible
	 * @param Exception	$e l'exception à logger
	 */
	private static function loggerException($e) {
		$erreur = '';
		$erreur .= $e->getMessage()."\n";
		$erreur .= 'Fichier : '.$e->getFile()."\n";
		$erreur .= 'Ligne : '.$e->getLine()."\n";
		if (self::getContexte()) {
			$erreur .= 'Contexte : '."\n".print_r($e->getTraceAsString(), true)."\n";
		}
		$erreur .= "\n";
		Log::ajouterEntree('erreurs',$erreur);
	}

	public function __destruct() {
		// Si des erreurs n'ont pas été affichée nous forçons leur affichage
		if (self::$afficher && count(self::$exceptions) > 0) {
			echo self::getExceptions();
		}
	}

}
?>