<?php
/**
 * Réparation des polygones incomplets :
 *
 * Exemple de lancement du script :
 * /opt/lampp/bin/php -d memory_limit=8000M cli.php osm -a ordonnerPolygoneInc -m manuel -v 3
 *
 * /opt/lampp/bin/php -d memory_limit=8000M cli.php osm -a remplirPolygoneInc -m manuel -v 3
 *
 * /opt/lampp/bin/php -d memory_limit=8000M cli.php osm -a renommer -m manuel -v 3
 *
 */
class PolygoneReparateur {
	private $conteneur;
	private $bdd;
	private $messages;
	private $mode;

	public function __construct($conteneur) {
		$this->conteneur = $conteneur;
		$this->bdd = $this->conteneur->getBdd();
		$this->messages = $this->conteneur->getMessages();
		$this->mode = $this->conteneur->getParametre('m');
	}

	/**
	 * Fonction qui parcourt tous les ways les noeuds de chaque relation en prenant en considération l'ordre et
	 * le sens de chaque ways concaténés ensemble (séparés par des virgules). Update du champ polygone de chaque
	 * relation dans la table `osm_relations`
	 */
	public function executer() {
		// Lancement de l'action demandée
		$cmd = $this->conteneur->getParametre('a');
		switch ($cmd) {
			case 'ordonnerPolygoneInc' :
				$this->ordonnerRelationsAuPolygoneIncomplet();
				break;
			case 'remplirPolygoneInc' :
				$this->remplirRelationsAuPolygoneIncomplet();
				break;
			case 'renommer' :
				$this->renommerEnPolygoneIncomplet();
				break;
			default :
				$msgTpl = "Erreur : la commande '%s' n'est pas prise en compte par la classe %s !";
				$msg = sprintf($msgTpl, $cmd, get_class($this));
				throw new Exception($msg);
		}
		print "\n";// Pour ramener à la ligne en fin de script
	}

	/**
	 * Fonction qui récupère les relations des polygones incomplets et appelle pour chaque relation la fonction
	 * ordonnerPolygoneIncomplet($ordre,$tour,$idRelation,$nombrePolygone)
	 */
	private function ordonnerRelationsAuPolygoneIncomplet() {
		$relations = $this->getRelationsAuPolygoneIncomplet();
		foreach ($relations as $relation) {
			$idRelation = $relation['id_relation'];
			$this->ordonnerCheminsMultiPolygone($idRelation);

			if ($this->mode == 'manuel') {
				$this->messages->afficherAvancement("Réparation du polygone incomplet : ", 1);
			}
		}
	}

	/**
	 * Fonction récursive qui exécute la même tâche que la fonction ordonnerWays() pour chaque polygone d'un
	 * multipolygone et remplie le champ NbPoly dans la table `osm_relation_a_chemins` qui correspond au nombre de polygone fermé
	 * dans le multipolygone
	 */
	private function ordonnerCheminsMultiPolygone($idRelation, $numPolygone = 1, $ordre = 1, $tour = 1) {
		$chemins = $this->getChemins($idRelation);
		$nbreCheminsTotal = count($chemins);

		// premier élément du tableau
		$idPremierChemin = $chemins[0]['id_chemin'];
		$idChemin = $idPremierChemin;

		$this->mettreAJourChemin($idRelation, $idPremierChemin, $ordre, 'directe', $numPolygone);
		//selection dernier noeud
		$nodes = $this->getNoeuds($idPremierChemin);
		$nombreNodes = count($nodes);
		$premierNoeud = $nodes[0]['id_noeud'];
		$dernierNoeud = $nodes[$nombreNodes - 1]['id_noeud'];
		$noeudActuel = $dernierNoeud;

		//Condition pour laquelle la boucle while continue à tourner; tant que le premier noeud du polygone n'est
		//égale au dernier et tant qu'il reste des ways à gérer
		while (($premierNoeud != $noeudActuel) && (($ordre % 1000) < $nbreCheminsTotal)) {
			//select le way qui possède le dernier noeud du précédent way et écarter l'actuel
			$ordre++;

			$chemins = $this->getCheminsAOrdonner($idRelation, $idChemin, $noeudActuel);
			if (isset($chemins[0])) {
				$idChemin = $chemins[0]['id_chemin'];
				$nodes = $this->getNoeuds($idChemin);
				$nombreNodes = count($nodes);
				if (strcmp($nodes[0]['id_noeud'], $noeudActuel ) == 0) {
					$sens = 'directe';
					$noeudActuel = $nodes[$nombreNodes-1]['id_noeud'];
				} else {
					$sens = 'indirecte';
					$noeudActuel = $nodes[0]['id_noeud'];
				}
				$this->mettreAJourChemin($idRelation, $idChemin, $ordre, $sens, $numPolygone);
			}
		}
		$ordre = 1000 * $tour; //différencier chaque polygone: pour chaque polygone on a un multiple de mille
		if ($this->getNombreChemins($idRelation) != 0) {
			//appelle de la méthode récursivement
			$this->ordonnerCheminsMultiPolygone($idRelation, ++$numPolygone, $ordre, ++$tour);
		}
	}

	private function getRelationsAuPolygoneIncomplet() {
		$requete = 'SELECT id_relation '.
			'FROM osm_communes '.
			"WHERE notes = 'Polygone incomplet' ".
			' -- '.__FILE__.' : '.__LINE__;
		$relations = $this->bdd->recupererTous($requete);
		return $relations;
	}

	private function getChemins($idRelation) {
		$requete = 'SELECT id_chemin '.
			'FROM osm_relation_a_chemins '.
			"WHERE id_relation = $idRelation ".
			"AND ordre IS NULL ".
			' -- '.__FILE__.' : '.__LINE__;
		$chemins = $this->bdd->recupererTous($requete);
		return $chemins;
	}
	/**
	 * Select des ways qui n'ont pas été ordonnés: on obtient à chaque itération les ways qui restent à ordonner
	 */
	private function getCheminsAOrdonner($idRelation, $idChemin, $idNoeud) {
		$requete = 'SELECT cn.id_chemin '.
			'FROM osm_relation_a_chemins AS rc '.
			'	INNER JOIN osm_chemin_a_noeuds AS cn ON (rc.id_chemin = cn.id_chemin) '.
			"WHERE cn.id_noeud = $idNoeud ".
			"AND cn.id_chemin != $idChemin ".
			"AND rc.id_relation = $idRelation ".
			"AND rc.ordre IS NULL ".
			' -- '.__FILE__.' : '.__LINE__;
		$chemins = $this->bdd->recupererTous($requete);
		return $chemins;
	}

	private function getNoeuds($idChemin) {
		$requete = 'SELECT id_noeud '.
			'FROM osm_chemin_a_noeuds '.
			"WHERE id_chemin = $idChemin ".
			'ORDER BY ordre '.
			' -- '.__FILE__.' : '.__LINE__;
		$noeuds = $this->bdd->recupererTous($requete);
		return $noeuds;
	}

	private function getNombreChemins($idRelation) {
		$requete = 'SELECT COUNT(id_chemin) AS nbre '.
			'FROM osm_relation_a_chemins '.
			"WHERE id_relation = $idRelation ".
			'AND ordre = 0 '.
			' -- '.__FILE__.' : '.__LINE__;
		$infos = $this->bdd->recuperer($requete);
		return $infos['nbre'];
	}

	private function mettreAJourChemin($idRelation, $idChemin, $ordre, $sens, $nbrePoly) {
		$requete = 'UPDATE osm_relation_a_chemins '.
			"SET ordre = '$ordre', sens = '$sens', num_poly = $nbrePoly ".
			"WHERE id_relation = $idRelation ".
			"AND id_chemin = $idChemin ".
			' -- '.__FILE__.' : '.__LINE__;
		$this->bdd->requeter($requete);
	}

	/**
	 * Fonction qui récupère les relations des polygones incomplets et appelle pour chaque relation la fonction
	 * remplirPolygoneIncomplet($idRelation);
	 */
	private function remplirRelationsAuPolygoneIncomplet() {
		$relations = $this->getRelationsAuPolygoneIncomplet();
		foreach ($relations as $relation) {
			$this->remplirPolygoneIncomplet($relation['id_relation']);
			if ($this->mode == 'manuel') {
				$this->messages->afficherAvancement("Création du polygone incomplet : ", 1);
			}
		}
	}

	/**
	 * Fonction qui exécute la même tâche que la fonction remplirPolygone() pour chaque polygone d'un multipolygone
	 * et renvoie un tableau MultiPolygone[] où chaque case contient un polygone fermé. Puis met à jour le polygone
	 * de la commune.
	 */
	private function remplirPolygoneIncomplet($idRelation) {
		// Tableau multipolygone qui contient tous les polygones d'un multipolygone
		$multiPolygone = array();
		// Tableau roles qui contient les différents roles des chemins de la relation
		$roles = array();
		// Sélectionner le nombre de polygones qui existe dans un multipolygone
		$nbPoly = $this->getNombrePoly($idRelation);
		//boucle for qui parcourt chaque polygone du multipolygone
		for ($numPoly = 1; $numPoly <= $nbPoly; $numPoly++) {
			$polygone = array();
			$chemins = $this->getCheminsParPolygone($idRelation, $numPoly);
			foreach ($chemins as $chemin) {
				$role = $chemin['role'];
				$roles[$role] = (isset($roles[$role])) ? $roles[$role]++ : 1;
				$noeuds = $this->getNoeudsPourCheminEtSens($chemin['id_chemin'], $chemin['sens']);
				$polygone = array_merge($polygone, $noeuds);
			}
			$multiPolygone[] = implode(', ', $polygone);
		}
		$this->mettreAJourMultiPolygone($multiPolygone, $roles, $idRelation, $nbPoly);
	}

	private function getNombrePoly($idRelation) {
		$requete = 'SELECT MAX(num_poly) AS num_poly '.
			'FROM osm_relation_a_chemins '.
			"WHERE id_relation = $idRelation ".
			' -- '.__FILE__.' : '.__LINE__;
		$resultat = $this->bdd->recuperer($requete);
		return $resultat['num_poly'];
	}

	private function getCheminsParPolygone($idRelation, $numPoly) {
		$requete = 'SELECT id_chemin, sens, role '.
			'FROM osm_relation_a_chemins '.
			"WHERE id_relation = $idRelation ".
			"AND num_poly = $numPoly ".
			'ORDER BY ordre '.
			' -- '.__FILE__.' : '.__LINE__;
		$chemins = $this->bdd->recupererTous($requete);
		return $chemins;
	}

	private function getNoeudsPourCheminEtSens($idChemin, $sens) {
		$tri = ($sens == 'directe') ? 'ASC' : 'DESC';
		$requete = 'SELECT NLL.id_noeud, NLL.lat, NLL.`long` '.
			'FROM osm_chemin_a_noeuds AS WN '.
			'	INNER JOIN osm_noeuds AS NLL ON (WN.id_noeud = NLL.id_noeud) '.
			"WHERE WN.id_chemin = $idChemin ".
			"ORDER BY WN.ordre $tri ".
			' -- '.__FILE__.' : '.__LINE__;
		$noeuds = $this->bdd->recupererTous($requete);
		$latLng = array();
		foreach ($noeuds as $noeud) {
			$latLng[] = $noeud['lat'].' '.$noeud['long'];
		}
		return $latLng;
	}

	/**
	 * Remplie le champ polygone à partir du tableau MultiPolygone
	 */
	private function mettreAJourMultiPolygone($multiPolygone, $roles, $idRelation, $nbPoly) {
		// Présence d'une enclave contenue dans cette entité administrative mais qui appartient à une autre entité administrative
		if ((isset($roles['inner']) || isset($roles['enclave']))) {
			if ($nbPoly == 2) {
				$multiPoly = implode('),(', $multiPolygone);
			} else {
				$multiPoly = null;
				$msgTpl = "La relation '%s' possède plus de 2 polygones de type enclaves.";
				$this->messages->traiterErreur($msgTpl, array($idRelation));
			}
		} else {
			// Tous les autres cas
			$multiPoly = implode(')),((', $multiPolygone);
		}
		if (isset($multiPoly)) {
			$this->mettreAJourCommune($idRelation, $multiPoly);
		}
	}

	private function mettreAJourCommune($idRelation, $multiPoly) {
		$requete = 'UPDATE osm_communes '.
			"SET polygone = MPOLYFROMTEXT('MULTIPOLYGON((($multiPoly)))'), ".
			"notes = 'Polygone complet' ".
			"WHERE id_relation = $idRelation ".
			' -- '.__FILE__.' : '.__LINE__;
		$this->bdd->requeter($requete);
	}

	/**
	 * Renomme la note des polygones vides d'un polygone complet en polygone incomplet
	 */
	private function renommerEnPolygoneIncomplet() {
		$requete = 'UPDATE osm_communes '.
			"SET notes = 'Polygone incomplet' ".
			"WHERE ASTEXT(polygone) IS NULL ".
			' -- '.__FILE__.' : '.__LINE__;

		$retour = $this->bdd->requeter($requete);
		$this->messages->traiterInfo("Nombre de polygones définis à incomplet : ".$retour->rowCount());
	}
}