<?php

// force l'utilisation d'UTF8
header('Content-type: text/html; charset=UTF-8');

include_once '../lib/pog/objects/class.element.php';
include_once '../lib/pog/objects/class.champ.php';
include_once '../lib/pog/objects/class.categorie.php';
include_once '../lib/pog/objects/class.type.php';
include_once '../lib/pog/objects/class.valeur.php';
include_once '../lib/pog/objects/class.champ.php';
include_once '../lib/Zend/Search/Lucene.php';

/**
 * Met à disposition les métodes qui permettent à l'interface utilisateur
 * de communiquer avec les objets générés par POG.
 *
 */
class Services
{

   /**
    * Chemin complet des fichiers d'index
    *
    */
   private $INDEX_PATH = "/Users/rdewolff/Documents/TD/dev/OpsIndexer/_index";

	/**
	 * Retourne la liste des éléements les plus récent
	 *
	 * @return la liste des éléments
	 */
	public function getElements()
	{
		$e = new Element();

		return $e->GetList(); // TODO : limit?
	}

	public function addValeur(Valeur $valeur)
	{
	    $valeur->Save();
	}

	public function addUri(Uri $uri)
	{
	    $uri->Save();
	}

	/**
	 * Retourne la liste des catégories
	 *
	 * @return la liste des catégories
	 */
	public function getCategories()
	{
		$c = new Categorie();
		return $c->GetList(null, null, false, null);
	}

	/**
	 * Retourne la liste des champs
	 *
	 * @return la liste des champs
	 */
	public function getFields()
	{
	    $f = new Champ();
	    return $f->GetList();
	}

	/**
	 * Retourne la structure d'une catégorie, c'est à dire la liste des champs
	 * qu'il peut contenir
	 *
	 * TODO : si edit, renvoyer la valeur du champs
	 *
	 * @return la liste des champs que comporte cette catégorie
	 */
   public function getCategorieFields($id)
   {
   	// récupère la catégorie passée en paramètre
      $cat = new Categorie();
      $cat->Get($id);

      // construit un tableau avec l'id de chaque champs, son nom et son type
      $arr = array();
      foreach ($cat->GetChampList() as $champ)
      {
      	$arr[] = array(
      	  "champId" => $champ->champId,
      	  "nom"     => $champ->nom,
      	  "type"    => $champ->GetType()->nom
      	);
      }

      // retourne le tableau
      return $arr;
   }


	/**
	 * Ajoute un élément dans l'application
	 *
	 * @param Element $e
	 */
	public function addElement(Element $e)
	{
		$e->Save();
		// renvoie l'id de l'element
		return $e->elementId;
	}

	/**
	 * Retoune un tableau avec les tags ainsi que leur score
	 *
	 */
	public function getTags()
	{

	   // récupère la liste des éléments
	   $e = new Element();
      $elems = $e->GetList();

		// tableau de score des tags
		$tags = Array();

		// compteur de tags
		$tagsTotal = 0;

		// parcours chaque élément
		foreach ($elems as $el)
		{
			// et sa liste de tag
			$t = explode(" ", $el->tags);
			foreach($t as $name) {
				$tagsTotal++;
				// incrément la table de hashage qui stock le nombre d'occurence du tag
				$name = strtolower($name);
				if ($tags[$name]) {
					$tags[$name]++;
				} else {
					$tags[$name] = 1;
				}
			}
		}

		// calcul le score de chaque terme
		// et prépare un tableau a retourner
		$tagToReturn = Array();
		$i = 0; // limite
		$keys = array_keys($tags);
		foreach ($tags as $t)
		{
			$tagToReturn[] = Array($keys[$i], $t/$tagsTotal);
			$i++;
			// TODO : limite
			/*
			if ($i > 1)
				break; */
		}

		// renvoie les tags
		return $tagToReturn;
	}

	/**
	 * Non implémenté
	 * Futur : ajouter un service permettant de vérifier le chemin des fichiers
	 * et ressource sur le réseau.
	 */
	public function checkValidPath($pathName)
	{
		// ->  "\\\\ServeurOnline\\Backup\\Efface.bat.old"
		return fopen($pathName, 'r');
		// file_exists("\\\\192.168.1.35\\TD_TO_INDEX\\testFiles\\testHTML.html");
		//fopen($pathName, 'r');
	}

	/**
	 * Retourne la liste des utilisateur disponible dans la base de données
	 * externe.
	 */
	public function getUserListFromExternalDatabase()
	{
	    return $this->externalDatabaseQuery("Online","SELECT ID, CONCAT(Visa, ' (', Nom, ' ', Prenom, ')') AS Nom FROM temployes WHERE Actif=1 AND Categorie=0 ORDER BY Nom");
	}

	/**
	 * Retourne les informations sur l'identifiant de l'utilisateur passé en paramètre
	 *
	 * @param int $id l'identifiant de l'utilisateur recherché
	 * @return un  recordset avec les informations trouvées
	 */
	public function getUserNameFromId($id)
	{
	    return $this->externalDatabaseQuery("Online", "SELECT Prenom, Nom, Visa FROM temployes WHERE ID=" . $id);
	}

	public function getProjectListFromExternalDatabase()
	{
	    return $this->externalDatabaseQuery("Projets", "SELECT stNumProjet FROM tprojets ORDER BY stNumProjet");
	}

	/**
	 * Requete sur la base de données externes qui contient les informations sur
	 * les utilisateurs et sur les projets.
	 *
	 * @param String $query la requete
	 * @return un recordset contenant les résultats de la requête.
	 */
	private function externalDatabaseQuery($database, $query)
	{
	    // paramètres de configuration
	    $configExtern['host'] = "localhost";
       $configExtern['username'] = "root";
       $configExtern['password'] = "xou5quuc";
       $configExtern['database_port'] = "3306";

       // connexion a la base de données
       $dbExtern = mysql_connect($configExtern['host'], $configExtern['username'], $configExtern['password']);
       mysql_select_db($database, $dbExtern);

       // execute et renvoie le resultat de la requête
       return ( mysql_query($query) );

	}

	/**
	 * Recherche général
	 *
	 * @param String $keyword le ou les mots clés  recherchés
	 */
	public function search ($keyword)
    {
        // param par default
        $mode = "OR";

        // on cherche
        $keyword = '%' . $keyword . '%';

        // le tableau des elements correspondant trouvés
        $result = Array();

        /**
         * recherche dans les éléments
         */
        $e = new Element();
        $elemFound = $e->GetList(array(
            array("titre", "LIKE", $keyword),
            array($mode),
            array("tags", "LIKE", $keyword),
            array($mode),
            array("description", "LIKE", $keyword)
        ));

        // met la liste de résultat dans le tableau d'éléments trouvés
        foreach ($elemFound as $elem)
        {
            $result[] = $elem->elementId;
        }

        /**
         * recherche dans les valeurs des champs
         */
        $v = new Valeur();
        $valFound = $v->GetList(array(
            array("valeur", "LIKE", $keyword)
        ));

        // met la liste des résultats dans le tableau d'éléments trouvés
        foreach ($valFound as $valeur)
        {
            $result[] = $valeur->elementId;
        }

        /**
         * Recherche dans les fichiers indexés
         */
        // ouvre les fichiers d'index
        $index = Zend_Search_Lucene::open($this->INDEX_PATH);

        // effectue la recherche
        $hits = $index->find(strtolower($keyword));

        // parcours les résutat et les stocks
        foreach ($hits as $hit)
        {
            // chaque document comporte les champs : 'ID_OPS', 'chemin' et 'contents'.
            // $result[] = array($hit->getDocument()->ID_OPS, $hit->getDocument()->chemin);
            $result[] = $hit->getDocument()->ID_OPS;
        }

        /**
         * Normalisation des resultat
         * Chaque élément a pu être retourné plusieurs fois. On va attribuer un
         * score meilleurs au éléments qui sont revenu le plus souvent.
         */

        /**
         * tableau, les indices sont les identifiant des éléments, la valeur est
         * le nombre d'occurence dans les résultat de cet élément
         */
        $resultWithScore = Array();
        $total = count($result); // nombre total de résultat trouvés

        // calcul le nombre d'occurence de chaque element
        foreach ($result as $r)
        {
             if (!$resultWithScore[$r])
                $resultWithScore[$r] = 1;
             else
                 $resultWithScore[$r]++;
        }

        // normalise le resultat de chaque élément
        // $keys correspond a l'identifiant d'un élément
        // et ajoute la liste des fichiers liés a cet élément
        $keys = array_keys($resultWithScore);
        $i = 0;
        $final = Array();
        foreach ($resultWithScore as $r)
        {
            $uri = Array(); // tableau d'URI pour cet élément
            foreach ($hits as $hit)
            {
                if ($hit->getDocument()->ID_OPS == $keys[$i])
                     $uri[] = array($hit->score, $hit->getDocument()->chemin);
            }

            // ajoute ces éléments dans le tableau
            $final[] = array($keys[$i], $r/$total, $uri);

            $i++;
        }

        /**
         * Retourne le tableau d'éléments trouvés avec les scores
         */
        return $final;
    }

    /**
     * Effectue une recherche avancée dans la base de données
     *
     * @param array $query le tableau de requêtes
     */
    public function advancedSearch(Array $query)
    {

    }

}

?>