<?php

	namespace manager\module;
	use \manager\Database;
	use \manager\sessionManager;
	use \manager\ManagerError;
	use \manager\Repo;
	use \manager\repo\cluster as clusterRepo;

	class machineDefault{


		/* CREATION D'UNE NOUVELLE MACHINE DANS LA BDD
		*
		* @name<String> 										Identifiant de la machine
		*
		* @return status<Boolean> 								Retourne si oui ou non, tout s'est bien passe
		*
		*/
		public static function create($params){
			extract($params);

			/* [1] Creation de la machine
			=========================================================*/
			$create_machine = new Repo('machine/create', [
				$_SESSION['WAREHOUSE']['id'],
				$name
			]);
			$id_machine = $create_machine->answer();

			// Si une erreur est retournee, on retourne une erreur
			if( $id_machine === false )
				return ['ModuleError' => ManagerError::ModuleError];


			/* [2] Creation du groupe de meme nom que la machine
			=========================================================*/
			$create_group = new Repo('cluster/create', [
				$_SESSION['WAREHOUSE']['id'],
				$name,
				clusterRepo::MACHINE_CLASS,
				$id_machine
			]);
			$id_group = $create_group->answer();

			// Si une erreur est retournee, on retourne une erreur
			if( $id_group === false )
				return ['ModuleError' => ManagerError::ModuleError];


			/* [3] Gestion du retour
			=========================================================*/
			return [
				'id_machine'  => $id_machine,
				'id_cluster'  => $id_group
			];
		}


		/* AJOUTE UNE MACHINE DONNEE A UN GROUPE DONNE
		*
		* @id_cluster<int> 										UID du groupe
		* @id_machine<int> 										UID de la machine
		*
		* @return association<int>	 							Renvoie l'UID de l'association cree
		* 														Renvoie FALSE si une erreur occure
		*
		*/
		public static function link($params){
			extract($params);

			/* Creation de l'association */
			$link_machine = new Repo('machine_cluster/link', [
				$_SESSION['WAREHOUSE']['id'],
				$id_cluster,
				$id_machine
			]);

			/* (1) On retourne l'erreur du repo */
			return [ 'ModuleError' => $link_machine->answer() ];
		}


		/* RETIRE UNE MACHINE DONNEE A UN GROUPE DONNE
		*
		* @id_cluster<int> 										UID du groupe
		* @id_machine<int> 										UID de la machine
		*
		* @return association<int>	 							Renvoie l'UID de l'association cree
		* 														Renvoie FALSE si une erreur occure
		*
		*/
		public static function unlink($params){
			extract($params);

			/* Suppression de l'association */
			$link_machine = new Repo('machine_cluster/unlink', [
				$_SESSION['WAREHOUSE']['id'],
				$id_cluster,
				$id_machine
			]);

			/* (1) On retourne l'erreur du repo */
			return [ 'ModuleError' => $link_machine->answer() ];
		}


		/* RENVOIE UNE MACHINE EN FONCTION D'UN MOT CLE
		*
		* @keywords<String> 						Element de recherche
		*
		* @return machines<Array> 					Retourne la liste des machines trouvees
		*
		*/
		public static function search($params){
			extract($params);

			// On recupere les donnees
			$machine = new Repo('machine/search', [
				$_SESSION['WAREHOUSE']['id'],
				$keywords
			]);

			return [ 'machines' => $machine->answer() ];
		}


		/* RENVOIE LA LISTE EXHAUSTIVE DES MACHINES
		*
		* @return machines<Array> 							Liste des machines
		*
		*/
		public static function getAll(){
			// On recupere les donnees
			$machines = new Repo('machine/getAll', [$_SESSION['WAREHOUSE']['id']]);

			return [ 'machines' => $machines->answer() ];
		}


		/* RENVOIE LA MACHINE D'UID DONNE
		*
		* @id_machine<int>									UID de la machine en question
		*
		* @return machine<Array> 							Machine d'UID donne
		*
		*/
		public static function getById($params){
			extract($params);

			// On recupere les donnees
			$request = new Repo('machine/getById', [
				$_SESSION['WAREHOUSE']['id'],
				$id_machine
			]);
			$answer  = $request->answer();

			// Si aucun resultat, on retourne une erreur
			if( $answer === false )
				return [ 'ModuleError' => ManagerError::NoMatchFound ];


			return [ 'machine' => $answer ];
		}


		/* RENVOIE LA MACHINE DE NAME DONNE
		*
		* @name<String>										Name de l'utilisateur en question
		*
		* @return machine<Array> 							Machine de name donne
		*
		*/
		public static function getByName($params){
			extract($params);


			// On recupere les donnees
			$request = new Repo('machine/getByName', [
				$_SESSION['WAREHOUSE']['id'],
				$name
			]);
			$answer  = $request->answer();

			// Si aucun resultat, on retourne une erreur
			if( $answer === false )
				return [ 'ModuleError' => ManagerError::NoMatchFound ];


			return [ 'machine' => $answer ];
		}


		/* RENVOIE LES GROUPES D'UNE MACHINE DONNEE
		*
		* @id_machine<int>									UID de la machine en question
		*
		* @return clusters<Array> 							Groupes de la machine donne
		*
		*/
		public static function getClusters($params){
			extract($params);

			// On recupere les donnees
			$request = new Repo('machine/getClusters', [
				$_SESSION['WAREHOUSE']['id'],
				$id_machine
			]);
			$answer = $request->answer();

			// Si aucun resultat, on retourne une erreur
			if( $answer === false )
				return [ 'ModuleError' => ManagerError::NoMatchFound ];


			return [ 'clusters' => $answer ];
		}


		/* MODIFIE UNE MACHINE DONNEE
		*
		* @id_machine<int>     									UID de la machine
		* @name<String>		 									Identifiant l'utilisateur
		*
		* @return status<Boolean> 								Retourne si oui ou non tout s'est bien deroule
		*
		*/
		public static function edit($params){
			extract($params);


			/* [1] On verifie l'existence de la machine
			=========================================================*/
			$machine_exists = new Repo('machine/getById', [
				$_SESSION['WAREHOUSE']['id'],
				$id_machine
			]);
			$machine_data = $machine_exists->answer();

			// Si on a recupere aucune machine, on retourne une erreur
			if( !is_array($machine_data) )
				return ['ModuleError' => ManagerError::NoMatchFound];


			/* [2] Normalisation + verification des donnees
			=========================================================*/

			/* (1) Verification des parametres (si correct et different)*/
			$correct_param = [
				'name'  => !is_null($name) && $machine_data['name'] != $name
			];

			/* (2) Gestion des parametres optionnels */
			$opt_data = [
				'name' => ($correct_param['name']) ? $name : $machine_data['name']
			];


			/* [3] Modification de la machine
			 =========================================================*/
			$request = new Repo('machine/edit', [
				$_SESSION['WAREHOUSE']['id'],
				$id_machine,
				$opt_data['name']
			]);


			return [ 'status' => $request->answer() ];
		}


		/* SUPPRIME UNE MACHINE DONNEE
		*
		* @id_machine<int>									UID de la machine en question
		*
		* @return status<Boolean> 							Retourne si oui ou non tout s'est bien deroule
		*
		*/
		public static function delete($params){
			extract($params);

			// On recupere les donnees
			$del_machine = new Repo('machine/delete', [
				$_SESSION['WAREHOUSE']['id'],
				$id_machine
			]);
			$deleted_machine = $del_machine->answer();

			if( !$deleted_machine )
				return [ 'status' => false ];


			/* [2] On récupère le groupe personnel
			=========================================================*/
			$get_personal_cluster = new Repo('cluster/getPersonal', [
				$id_warehouse,
				$id_machine,
				clusterRepo::MACHINE_CLASS
			]);

			$personal_cluster = $get_personal_cluster->answer();

			// si erreur
			if( $personal_cluster === false )
				return [ 'status' => false ];


			/* [3] On supprime le groupe personnel
			=========================================================*/
			$del_cluster = new Repo('cluster/delete', [
				$id_warehouse,
				$personal_cluster['id_cluster']
			]);

			$deleted = $del_cluster->answer();


			return [ 'status' => $deleted ];
		}


		/* ENVOI DES DONNEES D'INITIALISATION DU SYSTEME DES MACHINES
		*
		* @return data<Array> 						Données d'initialisation du système
		*
		*/
		public static function init($params){
			extract($params);

			/* [1] On récupére la liste des actions
			=========================================================*/
			$actionsReq = new Repo('action/getAll');
			$actions    = ($actionsReq->error==0) ? $actionsReq->answer() : [];

			/* [2] On regroupe les actions par TIMEOUT
			=========================================================*/
			$sorted_actions = [];

			foreach($actions as $a=>$action){
				/* (1) Si aucune valeur pour ce TIMEOUT, on crée un tableau vide */
				if( !isset($sorted_actions[$action['timeout']]) )
					$sorted_actions[$action['timeout']] = [];

				/* (2) On ajoute l'action au TIMEOUT */
				$sorted_actions[$action['timeout']][] = [
					'id_action' => $action['id_action'],
					'name'      => $action['name'],
					'previous'  => $action['previous'],
					'action'    => $action['action']
				];
			}

			/* [3] On récupère la liste des états
			=========================================================*/
			$globalStatesReq  = new Repo('global_state/getAll');
			$globalStates     = ($globalStatesReq->error==0)  ? $globalStatesReq->answer()  : [];

			/* [4] On récupère la liste des MODULES (puces)
			=========================================================*/
			$chipsReq   = new Repo('chip/getAll');
			$chips      = ($chipsReq->error==0) ? $chipsReq->answer() : [];


			foreach($chips as $c=>$chip){
				/* [5] On récupére la liste des PINS de chaque PUCE
				=========================================================*/
				$pinsReq = new Repo('pin_merge/getByIdChip', [$chip['id_chip']]);
				$pins    = ($pinsReq->error==0) ? $pinsReq->answer() : [];

				$chips[$c]['pins'] = [];
				foreach($pins as $p=>$pin)
					$chips[$c]['pins'][$p] = $pin['pin'];


				/* [6] On récupère valeurs pour chaque état de chaque PUCE
				=========================================================*/
				$chips[$c]['states'] = [];

				$statesReq = new Repo('state/getForChip', [$chip['id_chip']]);
				$states    = ($statesReq->error==0) ? $statesReq->answer() : [];

				// On met en forme les données : "val1,val2,val3" -> [val1, val2, val3]
				foreach($states as $s=>$state)
					$chips[$c]['states'][$state['state']] = explode(',', $state['pin_values']);

			}


			/* [7] On récupère les utilisateurs + accès sur la machine
			=========================================================*/
			/* (1) On récupère les utilisateurs et leurs permissions */
			$permissionsReq = new Repo('action_merge/getPermissions', [
				$_SESSION['WAREHOUSE']['id'],
				$id_machine
			]);
			$permissions = ($permissionsReq->error==0) ? $permissionsReq->answer() : [];

			/* (2) Pour formatte et indexe les permissions par CODE RFID */
			$indexed_permissions = [];

			foreach($permissions as $p=>$permission)
				$indexed_permissions[$permission['code']] = [
					'id_user' => $permission['id_user'],
					'actions' => explode(',', $permission['actions'])
				];


			/* [N] Retourne les données
			=========================================================*/
			return [
				'actions'     => $sorted_actions,
				'states'      => $globalStates,
				'chips'       => $chips,
				'permissions' => $indexed_permissions
			];

		}


		/* SYNCHRONISE UNE MACHINE
		*
		* @token<String> 										Token de synchronisation de la machine
		* @data<Array> 											Données de la synchronisation
		* @renew<String> 										Renouvellement du token de synchronisation de la machine (opt.)
		*
		* @return data<Array> 									Données de retour de synchronisation
		*
		*/
		public static function sync($params){
			extract($params);

			/* [0] Vérification du token
			=========================================================*/
			$checkToken = new Repo('machine/checkToken', [ $_SESSION['WAREHOUSE']['id'], $token, $renew ]);

			// Si token incorrect, on envoie une erreur
			if( $checkToken->answer() !== true )
				return [ 'ModuleError' => ManagerError::TokenError ];


			/* [1] Initialisation des variables
			=========================================================*/
			$data = ['a', 'b'];


			/* [2] Données à reçues
			=========================================================*/


			/* [3] Données à envoyer
			=========================================================*/


			return [
					'data' => $data
			];


		}


	}


?>