<?php

class OdsImageEspece extends JRestService {
	
	private $droits = 0755;
	const PREFIXE = 'get';

	public function OdsImageEspece($config) {
		$this->config=$config;
	}
	
	/**
     * Méthode appelée avec une requête de type GET.
     *
     */
    function getElement($param = array()) {
    	
    	$type = $param[0];
    	    	
        if ($type == '*' || is_numeric($type)) {
            $info = $this->getElementParDefaut($param);
        } else {
            $methode = self::PREFIXE.$type;
            if (method_exists($this, $methode)) {
                array_shift($param);
                $info = $this->$methode($param);
            } else {
                $this->messages[] = "Le type d'information demandé '$type' n'est pas disponible.";
            }
        }
       
        // Envoi sur la sortie standard
        echo 'OK';
    }
    
    /**
     * 
     * Méthode appelée avec une requête de type POST.
     */
    public function createElement($params) {  
		// fonction devant uniquement être appelée depuis le serveur
    	// lui-même, cad par l'application de saisie
    	$controle = new ControleUtilisateur($this->config);
    	$controle->controleAppelIpAutorisee();
    	
    	$chemin_temp = $params['chemin'];
    	$nom_espece = $params['nom_fichier'];
    	$credits = $params['credits'];
    	
    	$chemin_image_final = $this->stockerFichierOriginal($nom_espece, $chemin_temp);
    	$chemin_credits = $this->stockerCredits($nom_espece, $credits);
    	
    	$this->creerMiniatures($nom_espece.'.jpg', $chemin_image_final);
    	
    	echo json_encode('ok');
    }
    
    private function stockerFichierOriginal($nom_espece, $chemin_temp) {
    	$dossier = $this->config['appli']['chemin_stockage_images_especes'];
    	$chemin_dest = $dossier.'/'.$nom_espece.'.jpg';
    	copy($chemin_temp, $chemin_dest);
    	
    	return $chemin_dest;
    }
    
 	private function stockerCredits($nom_espece, $credits) {
 		$dossier = $this->config['appli']['chemin_stockage_images_especes'];
 		$chemin_dest = $dossier.'/'.$nom_espece.'.txt';
 		file_put_contents($chemin_dest, $credits);
 	}
 	
 	public function creerMiniatures($nom_fichier, $chemin) {
 		$formats = array('CXS','XS','S','M');
 		$infos_image_originale = $this->obtenirImageEtInfosPourChemin($chemin);
 		
 		// creation de miniatures pour chacuns des formats définis
 		foreach($formats as $format) {
 			$this->creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier, $infos_image_originale, $format);
 		}
 	}
	
	public function getRecreationMiniatures() {
		
		$dossier = $this->config['appli']['chemin_stockage_images_especes'];
	
		$formats = array('CXS','XS','S','M');
		
		$dossiers_a_exclure = array();
		
		foreach (new DirectoryIterator($dossier) as $fichier_ou_dossier) {
			
			if($fichier_ou_dossier->isDot() || $fichier_ou_dossier->isDir()) {
				continue;
			}
			
			if(in_array($fichier_ou_dossier->getBasename(), $dossiers_a_exclure)) {
				continue;
			}

			$extension = pathinfo($fichier_ou_dossier->getPathname(),PATHINFO_EXTENSION);
			if($extension == 'txt') {
				continue;
			}
		    	    	
		    $nom_fichier = $fichier_ou_dossier->getFilename();
		    						
			$infos_image_originale = $this->obtenirImageEtInfosPourChemin($fichier_ou_dossier->getPathname());
				
		    // creation de miniatures pour chacuns des formats définis
			foreach($formats as $format) {
				$this->creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier, $infos_image_originale, $format);
			}
		}
	}
			
	public function creerEtStockerMiniatureFichierImageSelonFormat($nom_fichier ,$infos_image_originale, $format = 'O') {
		
		if($format == 'O') {		
			// format original : rien à faire
			$image_redimensionnee = $infos_image_originale['image'];
			
		} else {
			// le format carre et une image redimensionnée en gardant son ratio, insérée dans un carré blanc
			if($this->estUnFormatCarre($format)) {
				$image_redimensionnee = $this->creerMiniatureCarree($infos_image_originale, $format); 														
							
			} else {
				// la minature est une image redimensionnée en gardant son ratio
				$image_redimensionnee = $this->creerMiniature($infos_image_originale, $format); 														
			}
		}

		$taux_compression = 100;
		if($format == 'O') {
			$taux_compression = $this->renvoyerTauxCompressionPourPoids($infos_image_originale['poids_octets']);
		}
		$this->ecrireImageSurDisque($image_redimensionnee, $nom_fichier, $format, $taux_compression);
				
		return true;
	}
	
	public function creerImageRedimensionnee($infos_image_originale, $hauteur_redimension, $largeur_redimension) {
		
		$image_redimensionnee = imagecreatetruecolor($largeur_redimension, $hauteur_redimension);
		
		imagecopyresampled($image_redimensionnee, 
						$infos_image_originale['image'], 
						0, 0, 
						0, 
						0, 
						$largeur_redimension, 
						$hauteur_redimension, 
						$infos_image_originale['largeur'], 
						$infos_image_originale['hauteur']
		);
		
		return $image_redimensionnee;
	}
	
	public function creerMiniature($informations_images, $format) {
				
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
		
		$taille_image_redimensionnee = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);
		$image_redimensionnee = $this->creerImageRedimensionnee($informations_images, $taille_image_redimensionnee['hauteur'], $taille_image_redimensionnee['largeur']);
		
		return $image_redimensionnee;
	}
	
	public function creerMiniatureCarree($informations_images, $format) {
		
		$taille_reference_pour_format = $this->obtenirDimensionsPourFormat($format);
		$cote_carre = $taille_reference_pour_format['largeur'];
		
		$image_redimensionnee_avec_rapport = $this->creerMiniature($informations_images, $format);
		$taille_redimensionnee_avec_rapport = $this->calculerTailleImage($informations_images, $taille_reference_pour_format['hauteur']);
		
		if($this->estPaysage($informations_images)) {				
				$debut_largeur_a_copier = 0 ;
				$debut_hauteur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['hauteur'])/2 ;	
		} else {
				$debut_largeur_a_copier = ($cote_carre - $taille_redimensionnee_avec_rapport['largeur'])/2 ;
				$debut_hauteur_a_copier = 0 ;	
		}
		
		$image_carre_cible = $this->renvoyerEtCreerImageCarreeSelonFormat($cote_carre);
		
		imagecopy($image_carre_cible, $image_redimensionnee_avec_rapport,
				$debut_largeur_a_copier ,$debut_hauteur_a_copier, 0, 0,
				$taille_redimensionnee_avec_rapport['largeur'], $taille_redimensionnee_avec_rapport['hauteur']
		);

		return $image_carre_cible;
	}
	
	public function obtenirImageEtInfosPourChemin($chemin_fichier) {
		
		$image_et_infos = array();
		
		list($image_et_infos['largeur'], $image_et_infos['hauteur']) = getimagesize($chemin_fichier);		
		$image_et_infos['poids_octets'] = filesize($chemin_fichier);
		$image_et_infos['image'] = imagecreatefromjpeg($chemin_fichier);
		
		return $image_et_infos;
	}
	
	public function obtenirDimensionsPourFormat($format) {
		
		$dimensions = array('largeur' => 0, 'hauteur' => 0);
			
		if(isset($this->config['appli']['format_'.$format])) {
			
			$format_largeur_hauteur = explode('_', $this->config['appli']['format_'.$format]);
			
			$dimensions['largeur'] = $format_largeur_hauteur[0];
			$dimensions['hauteur'] = $format_largeur_hauteur[1];
		}
		
		return $dimensions;
		
	}
	
	public function calculerTailleImage($informations_images, $taille_max) {
	
	        $HL_redimension = array();
	        
	        if($this->estPaysage($informations_images)) {
	        
		        $rapport = $informations_images['hauteur']/$informations_images['largeur'] ;
		        $HL_redimension['largeur'] = round($taille_max) ;
		        $HL_redimension['hauteur'] = round($taille_max*$rapport) ;
		        
	        } else {
	        	$rapport = $informations_images['largeur']/$informations_images['hauteur'] ;
		        $HL_redimension['hauteur'] = round($taille_max) ;
		        $HL_redimension['largeur'] = round($taille_max*$rapport) ;
	        }
	        
	        return $HL_redimension;
	}
	
	public function estUnFormatCarre($format) {
		
		return (strpos($format,'C') === 0);		
	}
	
	public function estPaysage($informations_images) {
		return $informations_images['largeur'] > $informations_images['hauteur'];
	}
	
	public function estPortait($informations_images) {
		return $informations_images['largeur'] < $informations_images['hauteur'];
	}
	
	public function renvoyerTauxCompressionPourPoids($poids_octets) {

		$poids_max_octets = $this->config['appli']['taille_max'];
		
		$ratio_compression = 100 ;
	
	    if($poids_octets >= $poids_max_octets) {
	      $ratio_compression = 85 ;
	    }
	    
	    return $ratio_compression;
	}
	
	public function ecrireImageSurDisque($image, $nom_fichier, $format, $compression) {
		
		umask(0);
		
		$chemin_sur_serveur_final = $this->config['appli']['chemin_stockage_images_especes'].'/'.$format;
		
		if(!is_dir($chemin_sur_serveur_final)) {
			mkdir($chemin_sur_serveur_final,$this->droits);
		}
		
		if(file_exists($chemin_sur_serveur_final.'/'.$nom_fichier)) {
			unlink($chemin_sur_serveur_final.'/'.$nom_fichier);
		}
		
		imagejpeg($image, $chemin_sur_serveur_final.'/'.$nom_fichier);
		chmod($chemin_sur_serveur_final.'/'.$nom_fichier,$this->droits);

	}
	
	public function renvoyerEtCreerImageCarreeSelonFormat($cote) {
		
		$r = $g = $b = 255;
		
		if(isset($this->config['appli']['couleur_fond_carre'])) {
			$rgb = $this->config['appli']['couleur_fond_carre'];
			
			$r = base_convert(substr($rgb,0,2), 16, 10);
			$g = base_convert(substr($rgb,2,2), 16, 10);
			$b = base_convert(substr($rgb,4,2), 16, 10);
		}
		
		$image_couleur = imagecreatetruecolor($cote, $cote);		
		$couleur = imagecolorallocate($image_couleur, $r, $g, $b);
		imagefilledrectangle($image_couleur, 0, 0, $cote, $cote, $couleur);
		
		return $image_couleur;
	}
	
	public function detruireImageEnMemoire($image) {		
		imagedestroy($image);
	}
}
?>