<?php

	namespace manager;
	use \manager\Database;


	class ModuleRequest{

		// Constantes
		public static $config_path = 'f/json/modules/conf';

		// Attributs prives utiles (initialisation)
		private $path;
		private $params;
		private $modules;

		// Contiendra la reponse a la requete
		public $answer;

		// Contiendra l'etat de la requete
		public $error;


		/* CONSTRUCTEUR D'UNE REQUETE DE MODULE
		*
		* @path<String>				Chemin de delegation ("module/methode")
		* @param<Array>				Tableau associatif contenant les parametres utiles au traitement
		* @token<String>			Token d'acces a l'api (OPTIONNEL)
		*
		* @return status<Boolean>	Retourne si oui ou non tout s'est bien passe
		*
		*/
		public function __construct($path=null, $params=null, $token=null){
			// Si pas parametre manquant, on quitte
			if( $path == null ){
				$this->error = ManagerError::MissingPath;
				return false;
			}

			/* [0] On met a jour la configuration
			=========================================================*/
			// Modules specifies
			$this->modules = json_decode( ResourceDispatcher::getResource(self::$config_path), true );

			// Gestion de l'erreur de parsage
			if( $this->modules == null ){
				$this->error = ManagerError::ParsingFailed;
				return false;
			}


			/* [1] Verification des types des parametres
			=========================================================*/
			// Type de @path
			if( !is_string($path) ){ // Si le type est incorrect
				$this->error = ManagerError::WrongPathModule;
				return false; // On retourne FALSE, si erreur
			}

			// Type de @data (optionnel)
			$params = (is_array($params)) ? $params : array();


			/* [2] Verification du chemin (existence module+methode)
			=========================================================*/
			if( !$this->checkPath($path) ) // Verification de la coherence du chemin + attribution
				return false;


			/* [3] Verification des droits
			=========================================================*/
			if( !$this->checkPermission($token) ) // Si on a pas les droits
				return false;


			/* [4] Verification des parametres (si @type est defini)
			=========================================================*/
			if( !$this->checkParams($params) ){ // Verification de tous les types
				$this->error = ManagerError::ParamError;
				return false;
			}

			/* [5] Construction de l'objet
			=========================================================*/
			$this->params = $params;
			$this->error = ManagerError::Success;

			return true; // On retourne que tout s'est bien passe

		}


		/* EXECUTE LE TRAITEMENT ASSOCIE ET REMPLIE LA REPONSE
		*
		* @return answer<ModuleResponse> 								Retourne une reponse de type <ModuleResponse> si tout s'est bien passe
		*
		*/
		public function dispatch(){
			/* [1] On verifie qu'aucune erreur n'a ete signalee
			=========================================================*/
			if( $this->error != ManagerError::Success ) // si il y a une erreur
				return new ModuleResponse($this->error);  // on la passe a la reponse


			/* [2] On verifie que la methode est amorcable
			=========================================================*/
			if( !is_callable($this->getFunctionCaller()) ){
				$this->error = ManagerError::UncallableMethod;
				return new ModuleResponse($this->error);
			}


			/* [3] On amorce la methode
			=========================================================*/
			$returned = call_user_func( $this->getFunctionCaller(), $this->params );


			/* [4] Gestion de la reponse
			=========================================================*/
			$answer = new ModuleResponse($this->error);
			$answer->appendAll($returned);

			return $answer;
		}


		/* DESERIALISATION ET CREATION D'UN OBJET
		*
		* @jsonString<String> 									Json au format string contenant les donnees
		*
		* @return instance<ModuleRequest> 						Retourne un objet de type <ModuleRequest>
		*
		*/
		public static function fromString($jsonString){
			$json = json_decode( $jsonString, true );

			// Verification du parsage
			if( $json == null )
				return new ModuleRequest();

			// Verification des parametres
			if( !isset($json['path']) )
				return new ModuleRequest();

			// On definit $params au cas ou il soit vide
			$params = $json;
			// On retire le @path de @params
			unset($params['path']);

			return new ModuleRequest($json['path'], $params);
		}


		/* DESERIALISATION A PARTIR DES DONNEES POST
		*
		* @post<Array> 											Tableau des donnes $_POST => @path + @data (opt)
		*
		* @return instance<ModuleRequest> 						Retourne un objet de type <ModuleRequest>
		*
		*/
		public static function fromPost($post){
			/* [0] Verification de l'authentification
			=========================================================*/
			// On definit le token
			$token = isset($_SERVER['PHP_AUTH_DIGEST']) ? $_SERVER['PHP_AUTH_DIGEST'] : null;


			/* [1] On verifie que le @path est renseigne
			=========================================================*/
			if( !isset($post['path']) )
				return new ModuleRequest();

			/* [2] On verifie que @data est renseigne
			=========================================================*/
			// Si variable n'existe pas, on cree un tableau vide
			$params = $post;

			// On retire le @path de @params
			unset($params['path']);


			/* [3] On retourne une instance de <ModuleRequest>
			=========================================================*/
			// On cree notre requete avec le token
			return new ModuleRequest($post['path'], $params, $token);
		}


		/* VERIFICATION DU FORMAT ET DE LA COHERENCE DU CHEMIN SPECIFIE
		*
		* @path<String> 									String correspondant au chemin de delegation ("module/methode")
		*
		* @return validity<Boolean> 						Retourne si oui ou non l'objet est correct
		*
		*/
		private function checkPath($path){
			/* [1] Verification format general
			=========================================================*/
			if( !preg_match('#^([\w_-]+)/([\w_-]+)$#i', $path, $matches) ){ // Si mauvais format
				$this->error = ManagerError::WrongPathModule;
				return false;
			}

			// On recupere les donnes de la regex
			$module = $matches[1];
			$method = $matches[2];


			/* [2] Verification de l'existence du module (conf)
			=========================================================*/
			if( !array_key_exists($module, $this->modules) ){ // Si le module n'est pas specifie dans la conf
				$this->error = ManagerError::UnknownModule;
				return false; // On retourne FALSE, si erreur
			}

			/* [3] Verification de l'existence de la methode (conf)
			=========================================================*/
			if( array_key_exists($method, $this->modules[$module]) === false ){ // Si la methode n'est pas specifie dans la conf
				$this->error = ManagerError::UnknownMethod;
				return false; // On retourne FALSE, si erreur
			}


			/* [4] Enregistrement du chemin et renvoi de SUCCESS
			=========================================================*/
			$this->path = array(
				'module' => $module,
				'method' => $method
			);

			return true;
		}


		/* RETOURNE SI ON A LA PERMISSION D'EXECUTER CETTE METHODE
		*
		* @token<String>										Token d'acces a l'API (OPTIONNEL)
		*
		* @return permission<bool> 								Retourne si on a les droits ou pas pour executer cette methode
		*
		*/
		private function checkPermission($token=null){
			/* [1] On recupere les informations utiles
			=========================================================*/
			// On recupere le nom de la methode
			$method = $this->modules[$this->path['module']][$this->path['method']];

			// Si aucune permission n'est definie
			if( !isset($method['permissions']) ) return true;

			/* [2] Gestion si un @token est defini
			=========================================================*/
			if( Database::check('sha1', $token) ){


				/* (1) On verifie que le token est valide */
				$checkToken = new Repo('token/check', array($token) );
				$token_permissions = $checkToken->answer();

				// Si le token est invalide, on retourne une erreur -> FAUX
				if( $token_permissions === false ){
					$this->error = ManagerError::TokenError;
					return false;
				}

				$local_permissions = $token_permissions;


			/* [3] Gestion si aucun token, avec utilisateur connecté
			=========================================================*/
			}else if( isset($_SESSION['permission']) )
				$local_permissions = $_SESSION['permission'];
			// Si ni token, ni SESSION, erreur
			else{
				$this->error = ManagerError::PermissionError;
				return false;
			}


			/* [4] Verification des droits parmi les permissions donnees
			=========================================================*/
			/* (1) On recupere la liste des permissions possibles */
			$permissions = $method['permissions'];

			/* (2) Si aucune permission n'est definie, on laisse l'acces */
			if( count($permissions) == 0 ) return true;

			/* (3) On verifie qu'il y a au moins une permission ok */
			foreach($permissions as $permission)
				if( in_array($permission, $local_permissions) ) return true;


			/* [5] On retourne FAUX si aucun droit n'a ete trouve
			=========================================================*/
			$this->error = ManagerError::PermissionError;
			return false;
		}


		/* VERIFICATION DU TYPE DES PARAMETRES ENVOYES
		*
		* @params<Array> 									Tableau associatif contenant les parametres
		*
		* @return correct<bool> 							Retourne si oui ou non les parametres ont le bon type
		*
		*/
		private function checkParams($params){
			/* [1] On verifie qu'il ne manque aucun parametre
			=========================================================*/
			// Si @params n'est pas un tableau
			if( !is_array($params) ) return false;

			$method = $this->modules[$this->path['module']][$this->path['method']];

			// Si le nombre de parametre en entree est insuffisant
			// if( count($method['parameters']) > count($params) ) return false;


			/* [2] Si le type est defini, pour chaque param, on teste
			=========================================================*/
			foreach($method['parameters'] as $name=>$paramsdata){
				/* (1) On récupère si le paramètre est optionnel ou pas */
				$optional = isset($paramsdata['optional']) && $paramsdata['optional'] === true;

				/* (2) Si le paramètre est obligatoire et qu'il n'est pas donné -> erreur */
				if( !isset($params[$name]) && !$optional ) return false;

				/* (3) Si le type n'est pas defini, on a pas besoin de le vérifier */
				if( !isset($paramsdata['type']) ) continue;

				/* (4) Si le paramètre est optionnel et n'est pas donné */
				if( $optional && !isset($params[$name]) ){
					// On le crée avec la valeur NULL
					$params[$name] = null;
					// On passe au paramètre suivant
					continue;

				/* (5) Si le paramètre est renseigné */
				}else
					// Si la verification est fausse, on retourne faux
					if( !Database::check($paramsdata['type'], $params[$name]) ) return false;
			}

			/* [3] Gestion du retour, si tout s'est bien passe
			=========================================================*/
			return true;
		}


		/* RENVOI LE CHEMIN D'AMORCAGE DE LA METHODE
		*
		* @return path<Array> 									Retourne le chemin d'amorcage de la requete
		*
		*/
		private function getFunctionCaller(){
			return array( '\\manager\\module\\'.$this->path['module'], $this->path['method'] );
		}


	}

?>