<?php
require_once 'OExceptions.php';

define('E_DB_RES','0');
define('E_DB_ERR','1');

/**
 * Wrapper per le funzioni di libreria php mysqli
 * 
 * @author gine
 * @original author: Micah Carrick
 * @version: 1.1
 * @licence: GPL 2
 *
 */
class Database {
	/**
	 * Ricordati di settarla a FALSE per tutti i programmi  
	 * in cui usi questa classe.
	 */
	private $debug=FALSE;
	
	private static $m_pInstance = array();
    private $last_query;     // last query executed.
    var $row_count;          // last number of rows
	var $db_link;            // current/last database link identifier
    private $auto_slashes;       // the class will add/strip slashes when it can
    private $host, $user, $pw, $db, $port;

    /**
     * Costruttore della classe che si interfaccia con il dbms. Privata per via del Singleton.
     * 
     * @param string $db
     */
    private function Database($db) {
    	$dbConfPath=dirname(__FILE__).'/../config/';
    	
    	include($dbConfPath.'db.php');
    	if ($db == "dns")
    		include($dbConfPath.'smdns_db.php');
    	elseif ($db == "db") {
    		include($dbConfPath.'mysql_db.php');
    		require_once dirname(__FILE__).'/../lib/terminal.php';
    		$dbms_password=prompt_silent();
    	} elseif ($db == "ot") 
    	    include($dbConfPath.'ot_db.php');
    	elseif($db == "std") 
    		include($dbConfPath.'config.php');
    	

        $this->host = $dbms_server;
        $this->user = $dbms_user;
        $this->pw = $dbms_password;
        $this->db = $dbms_db;
        $this->port = $dbms_port;

        $this->auto_slashes = true;
        
        self::connect();
    }
    
    /**
     * Singleton multiplo del costruttore della classe Database. Ritorna un istanza della classe.
     * $db può essere: ot, dns, db, ftp. Default: ot
     * 
     * @param string $db
     * @return Mysqli_link $m_pInstance
     */
    public static function getInstance($db='ot'){
    	if (!isset(self::$m_pInstance[$db])){
    		self::$m_pInstance[$db] = new Database($db);
    	}
    	
    	return self::$m_pInstance[$db];
    }
    
    /**
     * Esegue la connect al dbms. 
     * I parametri, se configurato il costruttore correttamente, sono opzionali. Ritorna un mysqli_link. 
     * 
     * Solleva un eccezione se ci sono problemi di connessione.
     * 
     * @param url $host
     * @param string $user
     * @param string $pw
     * @param string $db
     * @param int $port
     * @throws DbErrException
     * @return Mysqli_link $db_link
	 *    
     */
    function connect($host='', $user='', $pw='', $db='', $port='') {
        if (!empty($host)) $this->host = $host;
        if (!empty($user)) $this->user = $user;
        if (!empty($pw)) $this->pw = $pw;
        if (!empty($pw)) $this->port = $port;

        $this->db_link = mysqli_init();
		mysqli_real_connect($this->db_link , $this->host, $this->user, $this->pw, $this->db, $this->port);
        if (!$this->db_link)
            $this->callException(_("Database connection problem."),E_DB_ERR);
        return $this->db_link;
    }
    
    private function setDebugErr($msg){
    	$err['text']=$msg;
    	$err['code']=0;
    
    	if($this->debug){
    		$err['text'].="\n".$this->last_query;
    		$err['code']=mysqli_errno($this->db_link);
    	}
    	
    	return $err;
    }
    
    private function callException($msg,$e_type){
    	$err=$this->setDebugErr($msg);
    	if($e_type == E_DB_RES)
    		throw new DbResException($err['text'],$err['code']);
    	elseif($e_type == E_DB_ERR)
    		throw new DbErrException($err['text'],$err['code']);
    	else {
    		die(_("what shit?!"));
    		exit;
    	}
    }
    
    /**
     * Selezioziona il database ritorna TRUE se selezionato correttamente.
     * Solleva una Exception in caso di fallimento.
     * 
     * @param string $db
     * @throws DbErrException
     * @return boolean
     */
    function selectDb($db='') {
        if (!empty($db)) $this->db = $db;

        if (!mysqli_select_db($this->db_link,$this->db))
        	$this->callException(_("Database selection problem."),E_DB_ERR);	

        return true;
    }
    
    /**
     * Esegue una SELECT espressa con una SqlQuery. 
     * Utile quando non si conosce in numero di righe o colonne che potrebbero tornare. 
     * Ritorna un oggetto mysqli_result. Solleva una eccezione sul fallimento.
     * 
     * @param SqlQuery $sql
     * @throws DbErrException
     * @return mixed
     */
    function select($sql) {
        $this->last_query = $sql;

        $r = mysqli_query($this->db_link,$sql);
        if (!$r)
            $this->callException(_("Query select error."),E_DB_ERR);

        $this->row_count = mysqli_num_rows($r);

        return $r;
    }
    
    /**
     * Esegue una SELECT il cui risultato deve essere 1 sola riga.
     * Ritorna la riga. Solleva un eccezzione DbResException altrimenti.
     *
     * @param SqlQuery $sql
     * @throws DbResException
     * @return mixed
     */
    function selectOneRow($sql) {
    	$oi=_("Your query returned ");
    	$r = self::select($sql);
    
    	if ($this->row_count > 1)
    		$this->callException($oi._("more than one result."),ERR_DB_RES);
    	elseif ($this->row_count < 1)	
    		$this->callException($oi._("less than one result."),ERR_DB_RES);
    
    	return mysqli_fetch_row($r);
    }

    /**
     * Esegue una SELECT il cui risultato deve essere 1 sola cella. 
     * Ritorna la cella. Solleva un eccezzione DbResException altrimenti.
     * 
     * @param SqlQuery $sql
     * @throws DbResException
     * @return mixed
     */
    function selectFirstRowFirstCell($sql) {
        $r = $this->select($sql);

        if ($this->row_count > 1 or $this->row_count < 1)
            $this->callException(_("Your query returned more or less that one result."),ERR_DB_RES);

        $ret = mysqli_fetch_row($r);

        if ($this->auto_slashes)
            return stripslashes($ret[0]);
        else
            return $ret[0];
    }

    /**
     * Esegue una select il cui risultato deve essere un array composto da
     * una sola cella per riga. Solleva un eccezzione DbResException altrimenti.
     * 
     * @param SqlQuery $sql
     * @throws DbResException
     * @return array
     */
    function selectArrayOneElem($sql) {
    	$arr=array();
    	
    	$r= $this->select($sql); 
    	for ($i=0; $i<$this->row_count;$i++){
    		$row=mysqli_fetch_row($r);
    		if (isset($row[1]))
    			$this->callException(_("Your query return more than 1 element for row."),ERR_DB_RES);
    			
    		$arr[$i]=$row[0];
    	}
    
    	return $arr;
    }
    
    /**
     * Esegue una select il cui risultato deve essere un array composto da
     * una $n celle per riga. Solleva un eccezzione DbResException altrimenti.
     * Se $n non è specificato non viene effettuato nessun controllo sul 
     * numero di elementi per riga.
     *
     * @param SqlQuery $sql
     * @throws DbResException
     * @return array
     */
    function selectArrayNElem($sql,$n=NULL) {
    	$arr=array();
    	 
    	$r= $this->select($sql);
    	for ($i=0; $i<$this->row_count;$i++){
    		$row=mysqli_fetch_row($r);
    		if($n!=NULL){
    			if (isset($row[$n]))
    				$this->callException(sprintf(_("Your query return more than %s element for row."),$n),ERR_RES);
    		}
    		$arr[$i]=$row;
    	}
    
    	return $arr;
    }
    
    /**
     * Torna il numero di righe affette dalla query.
     * Da utilizzare con INSERT DELETE e UPDATE 
     * 
     * @param SqlQuery $sql
     * @throws DbResException
     * @return int
     */
    function execQuery($sql) {
		$this->last_query = $sql;
    	$r = mysqli_query($this->db_link,$sql);
    	if (!$r)
    		$this->callException(_("Exec Query error."),E_DB_ERR);
    	
    	return $this->row_count = mysqli_affected_rows($this->db_link);
    }

    /**
     * Eseque una SqlQuery il cui risultato deve aver avuto effetto su 1 sola riga. 
     * Ritorna TRUE o solleva una eccezione altrimenti.
     * 
     * @param SqlQuery $sql
     * @throws DbResException
     * @return boolean
     */
    function execQueryOneRow($sql) {
        self::execQuery($sql);
        if ($this->row_count == 0)
            $this->callException(_("No row affected."),ERR_RES);
        elseif($this->row_count > 1)
            $this->callException(_("More than 1 row are affected."),ERR_DB_RES);
    }

    /**
     *  Eseque una execQueryOneRow e ritorna l'ID della riga inserita. 
     *  Ottenuto tramite AUTOINCREMENT; comoda per le INSERT.
     *  
     * @param SqlQuery $sql
     */
    function execQueryRetId($sql) {
        $this->execQueryOneRow($sql);
        
        return mysqli_insert_id($this->db_link);
    }

    /**
     * Esegue una SELECT con $sql per verificare la presenza di un "id", se non esiste torna FALSE.
     * Altrimenti torna l'ID cercato con la select. 
     * Se ritornano più risultati solleva un DbResException.
     *
     * @param SelectSqlQuery $sql
     * @return mixed
     */
    function isThereAlready($sql){
    	$id=FALSE;
    	
    	$res=self::select($sql);
    	if($this->row_count == 1){
    		$row=mysqli_fetch_row($res);
    		$id=$row[0];
    	} elseif($this->row_count > 1 ) {
    		$this->callException(_("Are present more than 1 row."),ERR_DB_RES);
    	}
    	
    	return $id;
    }
    
    function escapeString($string){
    	return mysqli_real_escape_string($this->db_link,$string);
    }
    
    /**
     * Esegue un flush dei privilegi degli utenti mysql. 
     * Serve per assicurare  che le operazioni effettuate con altre funzioni, 
		 * come la creazione o la eliminazione di un utente, siano attive. 
     */
    function flushPrivileges(){
    	self::execQuery("FLUSH PRIVILEGES");
    }
    /**
     * Se $debug è TRUE stampa la query $sql altrimenti tramite reflection esegue il metodo $action sulla query.
     * 
     * @param boolean $debug TRUE|FALSE
     * @param String $action Metodi della Classe Database
     * @param SqlQuery $sql
     */
    function sqlOrDebug($debug,$action,$sql){
	$debug=true;
    	if (! $debug)
    		return self::$action($sql);
    	else
    		echo "DEBUG:OR: ".str_replace(array("\n","\r","\t","/\s\s+/"),"",$sql)."\n";
    }
    /**
     * Se $debug è FALSE esegue tramite reflection il metodo $action sulla query $sql, altrimenti stampa anche la query.
     *
     * @param boolean $debug TRUE|FALSE
     * @param String $action Metodi della Classe Database
     * @param SqlQuery $sql
     */
    function sqlAndDebug($debug,$action,$sql){
	$debug=true;
    	if ($debug)
    		echo "DEBUG:AND: ".str_replace(array("\n","\r","\t","/\s\s+/"),"",$sql)."\n";
    	
    	return self::$action($sql);
    }
    
    /**
     * Ritorna l'ultimo errore ottenuto durante le azioni precedenti sul database.
     */
    public function getLastError() {
        return $this->last_error;
    }
    
    /**
    * Ritorna l'ultima query effettuata
    */
    public function getLastQuery() {
        return $this->last_query;
    }
} 
?>