<?php
class CelEfloreImages extends Cel {
	
	private $formats_supportes = array('image/jpeg');
	private $format_retour_demande = 'image/jpeg';
	private $format_image_demande = 'M';
	private $num_nom_demande = null;
	private $ref_tax_demande = 'bdtfx';
	
	private $pattern_ref_tax_nn_composes = '/(([a-zA-Z]:((([0-9])+,)*([0-9])+));)*([a-zA-Z]:((([0-9])+,)*([0-9])+))*/i';
	
	public function getElement($uid) {
		return getRessource();
	}
	
	public function getRessource() {
		//TODO masque.nn = bdtfx:num_nom
		//TODO voir quels paramètres sont à passer en attributs de classe
		$parametres = $this->recupererParametresBruts();		
		$parametres = array_merge($parametres);
	
		try {
			$this->verifierErreurs($parametres);
			$this->affecterParametres($parametres);
			$id_image_a_renvoyer = $this->obtenirImageAuHasardPourNumNom($this->ref_tax_demande, $this->num_nom_demande);
			$this->traiterRetour($id_image_a_renvoyer);
		} catch (Exception $e) {
			$header = $this->renvoyerHeaderAssocie($e->getCode());
			$message = $e->getMessage();
			
			header($header);
			$this->envoyerTexteSimple($message);
		}
	}
	
	private function envoyerTexteSimple($chaine) {
		header("Content-type: text/plain");
		echo $chaine;
	}
	
	private function traiterRetour($id_image_a_renvoyer) {
		switch($this->format_retour_demande) {
			case 'image/jpeg':
				$this->renvoyerImageExistanteOuGeneree($id_image_a_renvoyer, $this->format_image_demande);
			break;
			
			default:
				$this->renvoyerImageExistanteOuGeneree($id_image_a_renvoyer, 'image/jpeg');
			break;
		}
	}
	
	private function renvoyerImageExistanteOuGeneree($id_image_a_renvoyer, $format = 'M') {
		if ($this->estUnFormatDejaCree($format)) {
			$this->renvoyerImageExistante($id_image_a_renvoyer, $format);
		} else {
			$this->renvoyerImageGeneree($id_image_a_renvoyer, $format);
		}
	}
	
	private function renvoyerImageExistante($id_image, $format = 'M') {
		$generateur_image = new ImageRecreation($this->config);
		$chemin = $generateur_image->functionObtenirCheminImagePourFormat($id_image, $format);
		if(file_exists($chemin)) {
			header("HTTP/1.0 200 OK");
			header("Content-type: image/jpeg");
			echo file_get_contents($chemin);  
		} else {
			throw new Exception("L\'image demandée est introuvable sur le serveur", "404");
		}
	}
	
	private function renvoyerImageGeneree($id_image, $format = 'M') {
		$generateur_image = new ImageRecreation($this->config);
		$infos_image = $generateur_image->obtenirImageEtInfosPourId($id_image);
		$image_a_renvoyer = $generateur_image->creerMiniatureImageSelonFormat($infos_image, $format);
		
		if($image_a_renvoyer) {
			header("HTTP/1.0 200 OK");
			header("Content-type: image/jpeg");
			imagejpeg($image_a_renvoyer);
		} else {
			throw new Exception("Problème lors de la génération de la miniature", "500");
		}
	}
	
	private function obtenirImageAuHasardPourNumNom($ref_tax, $num_nom) {
		//TODO: modifier la requete lors du passage à la nouvelle base de données pour faire quelques chose
		// du numéro nomenclatural
		$requete = 	'SELECT  cim.ci_id_image as id_image '.
						'FROM cel_obs_images AS coi '.
						'LEFT JOIN cel_inventory AS ci '.
							'ON (coi.coi_ce_observation = ci.ordre AND coi.coi_ce_utilisateur = ci.identifiant) '.
						'LEFT JOIN cel_images AS cim '.
							'ON (coi.coi_ce_image = cim.ci_id_image AND coi.coi_ce_utilisateur = cim.ci_ce_utilisateur) '.  
						'WHERE ci.transmission = 1 '.
						'	AND num_nom_sel = '.$this->proteger($num_nom).
						'	AND ci.identifiant = cim.ci_ce_utilisateur ';
			
		$resultat_images = $this->executerRequete($requete);

		if (!is_array($resultat_images) || count($resultat_images) <= 0) {
			$erreur = 'Aucune image ne correspond au numéro numenclatural '.$ref_tax.':'.$num_nom."\n";
			throw new Exception("404");	
		}
		
		$id_image_hasard = $resultat_images[array_rand($resultat_images)]['id_image'];
		return $id_image_hasard;
	}
		
	private function recupererParametresBruts() {
		$parametres_bruts = array();
		if (!empty($_SERVER['QUERY_STRING'])) {
			$paires = explode('&', $_SERVER['QUERY_STRING']);
			foreach ($paires as $paire) {
				$nv = explode('=', $paire);
				$nom = urldecode($nv[0]);
				$valeur = urldecode($nv[1]);
				$parametres_bruts[$nom] = $valeur;
			}
			$parametres_bruts = $this->nettoyerParametres($parametres_bruts);
		}
		return $parametres_bruts;
	}
	
	private function nettoyerParametres(Array $parametres) {
		// Pas besoin d'utiliser urldecode car déjà fait par php pour les clés et valeur de $_GET
		if (isset($parametres) && count($parametres) > 0) {
			foreach ($parametres as $cle => $valeur) {
				$verifier = array('NULL', "\n", "\r", "\\", "'", '"', "\x00", "\x1a", ';');
				$parametres[$cle] = strip_tags(str_replace($verifier, '', $valeur));
			}
		}
		return $parametres;
	}
	
	private function verifierErreurs($parametres) {
		$erreurs = false;
		
		if (!isset($parametres['masque.nn'])) {
			$erreurs .= 'Le paramètre masque.nn est obligatoire '."\n";
		} else {
			if(!preg_match($this->pattern_ref_tax_nn_composes, $parametres['masque.nn'])) {
				$erreurs .= 'Le paramètre masque.nn est mal formé '."\n";
			}
		}
		
		if (isset($parametres['retour']) && !$this->retourEstSupporte($parametres['retour'])) {
			$erreurs .= 'Le type de retour '.$parametres['retour'].' n\'est pas supporté  '."\n";
		}
		
		if (isset($parametres['retour.format']) && !$this->formatEstSupporte($parametres['retour.format'])) {
			$erreurs .= 'Le type de format '.$parametres['retour.format'].' n\'est pas supporté  '."\n";
		}
		
		if($erreurs != '') {
			throw new Exception($erreurs, "400");
		}
	}
	
	private function affecterParametres($parametres) {
		// cette fonction est appelée en considérant que les vérifications d'erreurs ont été passées 
		// avec succès
		$this->analyserMasqueNumNom($parametres['masque.nn']);
		if(isset($parametres['retour'])) {
			$this->format_retour_demande =  $parametres['retour'] ;
		}
		if(isset($parametres['retour.format'])) {
			$this->format_image_demande = $parametres['retour.format'];
		}
	}
	
	private function analyserMasqueNumNom($masque_num_nom) {
		// cette fonction est appelée en considérant que le masque num nom est valide
		//
		// cas du numero sans référentiel : ref tax par defaut
		if(is_numeric($masque_num_nom)) {
			$this->num_nom_demande = $masque_num_nom;
		} else {
			// ceci contient potentiellement des formes ref_tax1:nn1,nn2;ref_tax2:nn3,nn4
			$composants_masques = explode(';', $masque_num_nom);
			if (count($composants_masques) > 0) {
				foreach($composants_masques as $composant_ref_nn) {
					$ref_nn = explode(':', $composant_ref_nn);
					$this->ref_tax_demande[$composant_ref_nn[0]] = explode(',', $composant_ref_nn[1]);
				}
			}
		}
	}
	
	private function getFormats() {
		$formats = array();
		
		foreach ($this->config['cel_db'] as $param_config => $valeur) {
			if (substr_count($param_config,'format_') != 0) {
				$formats[$param_config] = $valeur;
			}
		}
		
		return $formats;
	}
	
	private function retourEstSupporte($retour = 'image/jpeg') {
		return in_array($retour, $this->formats_supportes);
	}
	
	private function formatEstSupporte($format = 'M') {
		
		$format_supporte = true;
		
		// cas du format déjà existant (S, M, L etc...)
		$format_supporte = $this->estUnFormatDejaCree($format);
		
		//TODO: décommenter les lignes suivantes lorsque les formats "à la demande" seront implémentés
		// cas du coté maximal de l'image demandé
		//$format_supporte = is_numeric($format) ? true : false;
		// cas du format exact demande Lxl
		//$format_supporte = preg_match('/[0-9]*x[0-9]*/', $format) ? true : false;

		return $format_supporte;
	}
	
	private function estUnFormatDejaCree($format = 'M') {
		$formats = $this->getFormats();
		$format_supporte = isset($formats['format_'.$format]) ? true : false;

		return $format_supporte;
	}	
	
	private function renvoyerHeaderAssocie($code) {
		switch ($code) {
			
			case '500':
				$header = "HTTP/1.0 500 Internal Server Error";
			break;
			
			case '404':
				$header = "HTTP/1.0 404 Not Found";
			break;
			
			case '400':
				$header = "HTTP/1.0 400 Bad Request";
			break;
				
			case '200':
				$header = "HTTP/1.0 200 OK";
			break;
			
			default:
			break;
		}
	}
}
?>