<?php

	namespace api\module;
	use \database\core\DatabaseDriver;
	use \manager\sessionManager;
	use \error\core\Error;
	use \error\core\Err;
	use \database\core\Repo;
	use \api\core\Request;

	class machineDefault{

		public function __construct(){}
		public function __destruct(){}


		/* 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 function create($params){
			extract($params);

			/* [1] Vérification unicité (name)
			=========================================================*/
			/* (1) Check if unique : name */
			$byName_r = new Repo('machine/getByName', [$_SESSION['WAREHOUSE']['id'], $name]);
			$byName = $byName_r->answer();

			/* (2) If already used -> error */
			if( $byName != false )
				return ['error' => new Error(Err::AlreadyExists, 'name')];


			/* [2] 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 ['error' => new Error(Err::ModuleError)];


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


		/* 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 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 [ 'error' => $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 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 [ 'error' => $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 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 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 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 [ 'error' => new Error(Err::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 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 [ 'error' => new Error(Err::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 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 [ 'error' => new Error(Err::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 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 ['error' => new Error(Err::NoMatchFound)];


			/* [2] Vérification unicité (name)
			=========================================================*/
			/* (1) Check if unique : name */
			$byName_r = new Repo('machine/getByName', [$_SESSION['WAREHOUSE']['id'], $name]);
			$byName = $byName_r->answer();

			/* (2) If already used (not current machine) -> error */
			if( $byName != false && $byName['id_machine'] != $id_machine )
				return ['error' => new Error(Err::AlreadyExists, 'name')];


			/* [3] 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']
			];


			/* [4] 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 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();


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


		/* RETURN MACHINE STATE
		*
		* @id_machine<int>						UID of the machine
		*
		* @return state<string>						Machine state
		*
		*/
		public function getState($params){
			extract($params);


			/* [1] Get machine info
			=========================================================*/
			/* (1) Write request */
			$machine_req = new Request('machineDefault/getById', ['id_machine' => $id_machine]);

			/* (2) Execute request */
			$machine_res = $machine_req->dispatch();

			/* (3) Manage error */
			if( $machine_res->error->get() != Err::Success )
				return [ 'error' => $machine_res->error ];

			/* (4) Fetch data */
			$machine = $machine_res->get('machine');


			/* [2] Get action id=>name
			=========================================================*/
			$action = [];

			/* (1) Write request */
			$action_req = new Repo('action/getAll', []);

			/* (2) Manage error */
			if( $action_req->error->get() != Err::Success )
				return [ 'error' => $action_req->error ];

			/* (3) Create association array */
			foreach($action_req->answer() as $a)
				$action[ strtolower($a['name']) ] = $a['id_action'];


			/* [3] Get history for the machine
			=========================================================*/
			/* (1) Write request */
			$history_req = new Repo('history/getByIdMachine', [$id_machine]);

			/* (2) Manage error */
			if( $history_req->error->get() != Err::Success )
				return [ 'error' => $history_req->error ];

			/* (3) Extract history */
			$history = $history_req->answer();


			/* [4] Process state
			=========================================================*/

			/* (1) IF DETACHED (never initialized)
			---------------------------------------------------------*/
			/* (1) Check machine data (no token | unlock code) */
			if( !$machine['token'] || $machine['unlock_code'] )
				return [ 'state' => 'detached' ];


			/* (2) STOPPED (no history)
			---------------------------------------------------------*/
			if( count($history) <= 0 )
				return [ 'state' => 'stopped' ];

			/* (3) LOCKED (last = lock)
			---------------------------------------------------------*/
			if( $history[0]['id_action'] == $action['lock'] )
				return [ 'state' => 'locked' ];

			/* (4) STOPPED (last = unlock | stop)
			---------------------------------------------------------*/
			if( in_array($history[0]['id_action'], [$action['stop'], $action['unlock']]) )
				return [ 'state' => 'stopped' ];


			/* (5) SIGNALED (start|stop ..... signal)
			---------------------------------------------------------*/
			for( $c = 0 ; $c < count($history) ; $c++ ){

				/* (1) If (start|stop), continue to search */
				if( in_array($history[$c]['id_action'] , [$action['start'], $action['stop']]) )
					continue;

				/* (2) If (signal) found, therefore it is signaled */
				else if( $history[$c]['id_action'] == $action['signal'] )
					return [ 'state' => 'signaled' ];

				/* (6.1) STARTED (last state)
				---------------------------------------------------------*/
				else
					return [ 'state' => 'started' ];

			}

			/* (6.2) STARTED (last state)
			---------------------------------------------------------*/
			return [ 'state' => 'started' ];

		}


		/* RETURNS ALL INFORMATION NEEDED BY MACHINES IN ORDER TO WORK
		*
		* @id_machine<int>						Machine UID
		*
		* @return data<Array<Mixed>>					Useful data
		*
		*/
		private static function getMachineWorkingInformation($id_machine){

			/* [1] On récupére la liste des actions
			=========================================================*/
			$actionsReq = new Repo('action/getAll');
			$actions    = ($actionsReq->error->get()==Err::Success) ? $actionsReq->answer() : [];
			// var_dump($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' => intval($action['id_action']),
					'name'      => strtolower($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->get()==Err::Success)  ? $globalStatesReq->answer()  : [];


			/* [4] On récupère la liste des MODULES (puces)
			=========================================================*/
			$chipsReq   = new Repo('chip/getAll', [$_SESSION['WAREHOUSE']['id']]);
			$chips      = ($chipsReq->error->get()==Err::Success) ? $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->get()==Err::Success) ? $pinsReq->answer() : [];

				$chips[$c]['pins'] = [];
				foreach($pins as $p=>$pin)
					$chips[$c]['pins'][$p] = intval($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->get()==Err::Success) ? $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']);
					foreach($chips[$c]['states'][$state['state']] as $s2=>$state2)
						$chips[$c]['states'][$state['state']][$s2] = intval($state2);
				}

			}


			/* [5] 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/getAccess', [
				$_SESSION['WAREHOUSE']['id'],
				$id_machine
			]);
			$permissions = ($permissionsReq->error->get()==Err::Success) ? $permissionsReq->answer() : [];

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

			foreach($permissions as $p=>$permission){
				$actionList = explode(',', $permission['id_action']);

				foreach($actionList as $a=>$action)
					$actionList[$a] = intval($action);

				sort($actionList);

				$indexed_permissions[$permission['code']] = [
					'id_user' => intval($permission['id_user']),
					'actions' => $actionList
				];
			}


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

		}


		/* ENVOI DES DONNEES D'INITIALISATION DU SATS
		*
		* @return id_machine<int> 					UID de la machine
		* @return token<string> 					Nouveau token d'identification (hashage cyclique)
		* @return unlock<string> 					Code de déblocage de la machine
		*
		*/
		public function sync($params){
			extract($params);


			/* [1] On essaie de débloquer la machine
			=========================================================*/
			/* (1) On rédige la requête */
			$unlockReq = new Repo('machine/unlock', [
				$_SESSION['WAREHOUSE']['id'],
				$id_machine,
				$unlock,
				$token
			]);

			/* (2) On gère l'erreur */
			if( $unlockReq->error->get() != Err::Success || !$unlockReq->answer() )
				return [ 'error' => new Error(Err::TokenError) ];


			/* [N] Retourne les données
			=========================================================*/
			return self::getMachineWorkingInformation($id_machine);
		}


		/* MET A JOUR 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 function update($params){
			extract($params);


			/* [1] Initialisation des variables
			=========================================================*/
			$fetched = [
				'history' => 0,  // count of registered logs
				'feature' => [], // count of registered logs for each feature
				'identity' => [ // network identity
					'ap' => isset($data['identity']) && is_array($data['identity']) && isset($data['identity']['ap']) ? $data['identity']['ap'] : null,
					'ip' => isset($data['identity']) && is_array($data['identity']) && isset($data['identity']['ip']) ? $data['identity']['ip'] : null
				]
			];


			/* [2] Gestion des données reçues
			=========================================================*/
			/* (1) For each history entry */
			if( isset($data['default']) && is_array($data['default']) ){

				/* (2) Create history entry in db */
				foreach($data['default'] as $entry){

					// {1} Build request //
					$log_req = new Request('historyDefault/create', [
						'timestamp'  => $entry[0],
						'id_user'    => $entry[1],
						'id_action'  => $entry[2],
						'id_machine' => $_SESSION['SATS']['id']
					]);

					// {2} Process + get response //
					$log_res = $log_req->dispatch();

					// {3} Exit on failure //
					if( $log_res->error->get() != Err::Success )
						break;

					// {4} Register count if success //
					$fetched['history']++;
				}

			}

			/* (2) For each feature's entry */
			// TODO: Manage feature's entries

			/* (3) Mise à jour de l'identité de la machine (ap-ip) */
			$updateNetId = new Repo('machine/updateNetworkIdentity', [
				$_SESSION['WAREHOUSE']['id'],
				$_SESSION['SATS']['id'],
				$fetched['identity']['ap'],
				$fetched['identity']['ip']
			]);

			/* (2) On gère l'erreur */
			if( $updateNetId->error->get() != Err::Success || !$updateNetId->answer() )
				return [ 'error' => new Error(Err::RepoError), 'details' => $updateNetId->answer() ];


			/* [3] Gestion des données à envoyer
			=========================================================*/
			/* (1) Basic working data update
			---------------------------------------------------------*/
			$basis_update = self::getMachineWorkingInformation($_SESSION['SATS']['id']);


			/* [4] Envoi des données
			=========================================================*/
			return array_merge($basis_update, ['saved' => $fetched, 'id' => $fetched['identity']]);

		}


	}


?>