<?php

/**
 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)
 * Copyright (c) Cake Software Foundation, Inc.
 * (http://cakefoundation.org)
 * Licensed under The MIT License
 * For full copyright and license information, please see the LICENSE.txt
 * Redistributions of files must retain the above copyright notice.
 *
 * @copyright Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)
 * @link http://cakephp.org CakePHP(tm) Project
 * @since 0.2.9
 * @license http://www.opensource.org/licenses/mit-license.php MIT License
 */
namespace App\Controller;

use Cake\Controller\Controller;
use Cake\Event\Event;
use Cake\ORM\TableRegistry;
use Cake\Mailer\Email;
use Cake\Core\Configure;
use Cake\I18n\Time;
use Cake\I18n\Date;

/**
 * Application Controller
 * Add your application-wide methods in the class below, your controllers
 * will inherit them.
 *
 * @link http://book.cakephp.org/3.0/en/controllers.html#the-app-controller
 */
class AppController extends Controller {

    public $confLabinvent;
    
    const PROFILE_USER = 1;
    const PROFILE_RESPONSABLE = 2;
    const PROFILE_ADMIN = 3;
    const PROFILE_ADMINPLUS = 4;
    const PROFILE_SUPERADMIN = 5;
    
    //private $allProfiles = [
    const PROFILES = [
        'Utilisateur' => self::PROFILE_USER,
   		'Responsable' => self::PROFILE_RESPONSABLE,
   		'Administration' => self::PROFILE_ADMIN,
   		'Administration Plus' => self::PROFILE_ADMINPLUS,
   		'Super Administrateur' => self::PROFILE_SUPERADMIN
    ];
    
    // Current priviledged USER (if so, otherwise = NULL)
    private $CURRENT_PRIVILEDGED_USER = null;
    
    // Current ROLE (by default = "Utilisateur")
    private $CURRENT_ROLE = null;
    
    // EP 08/2017
    protected $easyACL = array(
        
        /** Default ACL for ALL (logged) users
         * 
         * Les actions non mentionnées sont accessibles à tous (par défaut), 
         * exemple 'find', 'index'...
         * Ces default ACL peuvent être surchargées pour un profil précis
         * (par exemple pour 'USER' qui est plus restreint)
         */
        //'ALL' => array (
        'DEFAULT' => array (
            // 'action' => 'condition for execution' (= 'Y', 'N', or '<condition>'),
            // with <condition> like "'field name' == 'value'"
            // CRUD actions :
            //'edit' => 'N', // update
            //'delete' => 'N',
            'autre' => 'Y',
        ),
        
        // Ajoute des ACL plus spécifiques (ci-dessus) pour le profil USER qui est plus restreint
        // Les actions absentes ne sont pas surchargées (elles sont exécutées selon les conditions définies pour 'ALL')
        'USER' => array (
            // CRUD actions
            'add' => 'Y', // C
            'index' => 'Y', // R all
            'view' => 'Y', // R one
            //'edit' => 'N', // U
            'edit' => 'is_creator', // is_creator = (nom_createur == CURRENT_USER_NAME)
            'delete' => 'N', // D
            // OTHER actions
            'find' => 'Y', // create
            /* ceci n'a aucun sens car l'action sur le modèle "Pages" s'appelle toujours "display" (et non pas tools, infos, ou printers...)
             'tools' => 'N',
             'infos' => 'N',
             'printers' => 'N',
             */
        ),
        
        // Surcharge des ACL par défaut (ci-dessus) pour le profil RESPONSABLE qui est plus restreint
        // Les actions absentes ne sont pas surchargées (elles sont exécutées selon les conditions définies pour 'ALL')
        'RESPONSABLE' => array (
        ),
        
        // Surcharge des ACL par défaut (ci-dessus) pour le profil ADMIN
        'ADMIN' => array (
            //'add' => 'Y', // create
            'edit' => 'Y', // update
            //'delete' => 'Y', // update
        ),
        
        // Surcharge des ACL par défaut (ci-dessus) pour le profil ADMINPLUS
        'ADMINPLUS' => array (
            //'edit' => 'Y', // update
        ),
        
        // Surcharge des ACL par défaut (ci-dessus) pour le profil SUPERADMIN
        'SUPERADMIN' => array (
            //'add' => 'Y', // create
            //'edit' => 'Y', // update
            'delete' => 'Y',
        ),
    ); // $easyACL
    
    
    //@todo
    public function startsWith($haystack, $needle) {
        return true;
    }
    //@todo
    public function endsWith($haystack, $needle) {
        return true;
    }
    public function evalACL($condition) {
        // Simple case
        if ($condition == 'Y') return true;
        if ($condition == 'F') return false;
        // Complex case
        //@todo
        return true;
    }
    public function evalSpecificRule($condition, AppController $controller, $user, $role, $action, $id=null) {
        // if starts with "&&" eval DEFAULT rule && specific rule
        if ($this->startsWith($condition,'&&')) return $this->evalACL($controller->easyACL['DEFAULT'][$action]) && $this->evalACL($condition);
        // otherwise, eval only specific rule
        return $this->evalACL($condition);
    }
    /**
     * @param AppController $controller // a subclass of AppController (MaterielsController or any other)
     * @param array $user
     * @param string $role
     * @param string $action
     * @param string $id
     */
    public function isAuthorizedAction(AppController $controller, $user, $role, $action, $id=null) {
        
        // 1) controller specific (role) rule for action
        $condition = $controller->easyACL[$role][$action];
        if (isset($condition)) return $this->evalSpecificRule($condition, $controller, $user, $role, $action);
        
        // 2) AppController ($this) specific (role) rule for action
        $condition = self::easyACL[$role][$action];
        if (isset($condition)) return $this->evalSpecificRule($condition, $this, $user, $role, $action);
        
        // 3) controller general (DEFAULT) rule for action
        $condition = $controller->easyACL['DEFAULT'][$action];
        if (isset($condition)) return $this->evalACL($condition);
        
        /*
         * (RECURSIVE CALL)
         * 4) controller previous specific (role) rule for action
         * ex: if role is 'SUPER', use 'ADMIN' rule
         * ex: if role is 'ADMIN', use 'RESP' rule
         * ex: if role is 'RESP', use 'USER' rule
         * ex: if role is 'USER', stop recursive call
         * Stop recursive call if role is 'USER' => no rule found, so default is authorize (Y)
         */ 
        if ($role == 'USER') return true;
        return $this->isAuthorizedAction($controller, $user, $role-1, $action, $id);
        
    }
    
    //@todo
    public function getMandatoryFieldsForAction($action) {
        $fields = [];
        // meme fonctionnement recursif que isAuthorizedAction() ci-dessus
        return $fields;
    }
    //@todo
    public function getHiddenFieldsForAction($action) {
        $fields = [];
        // meme fonctionnement recursif que isAuthorizedAction() ci-dessus
        return $fields;
    }
    //@todo
    public function getReadOnlyFieldsForAction($action) {
        $fields = [];
        // meme fonctionnement recursif que isAuthorizedAction() ci-dessus
        return $fields;
    }
    //@todo
    public function getDefaultValueFieldsForAction($action) {
        $fields = [];
        // meme fonctionnement recursif que isAuthorizedAction() ci-dessus
        return $fields;
    }
    
    
    public static function getRoleLevel($role) {
        //return $this->allProfiles[$role];  
        //debug("role is" .$role);
        return self::PROFILES[$role];
    }

    public function getActionPassed() {
        // BETTER:
        //return $this->request->getAttribute('params')['action'];
        return $this->request->getParam('action');
    }
    
    public function getIdPassed() {
        //return (int) $this->request->getAttribute('params')['pass'][0];
        return (int) $this->request->getParam('pass.0');
    }
    
    
    
    /**
     * Initialization hook method.
     * Use this method to add common initialization code like loading components.
     * e.g. `$this->loadComponent('Security');`
     *
     * @return void
     */
    public function initialize() {
        parent::initialize();

        $this->loadComponent('RequestHandler');
        $this->loadComponent('Flash');
        $this->loadComponent('LdapAuth', [
            'authorize' => [ 'Controller'],
            'loginRedirect' => ['controller' => 'Pages', 'action' => 'home'],
            'logoutRedirect' => ['controller' => 'Pages', 'action' => 'home' ]
        ]);
        // On charge la configuration
        $this->confLabinvent = TableRegistry::get('Configurations')->find()->where(['id =' => 1])->first();
    }

    
    /**
     * Autorisations fréquentes utilisées par bcp de isAuthorized() de controlleurs
     * Ca évite de répéter 10 fois la meme chose !!!
     */
    public function isAuthorizedCommons($user) {
        $action = $this->getActionPassed();
        //$role = $this->getUserRole($user);
        
        // Seul Administration (et +) peut ajouter, supprimer ou modifier
        if( in_array($action,['add','delete','edit'])) {
            if ($this->USER_IS_ADMIN_AT_LEAST()) return true;
            // Les autres n'y ont pas accès
            return false;
        }
        
        // By default
        //return parent::isAuthorized($user);
        return AppController::isAuthorized($user);
    }
    
    /**
     * @param $user
     * @return boolean
     * 
     * isAuthorized is located in the Auth component
     * Check whether a LOGGED in user has a set of permissions to perform a given action
     * Give authorization in general
     * 
     * 2) Autorisation APRES connexion
     * (Avant, c'est beforeFilter() qui s'en occupe)
     */
    public function isAuthorized($user) {
        /*
        // ATTENTION, normalement, on devrait tester si role est défini..., mais c'est sans doute pas utile
        // cf https://book.cakephp.org/3.0/fr/tutorials-and-examples/blog-auth-example/auth.html
        if (isset($user['role']) && $user['role'] === 'admin') {
            return true;
        }
        */
        
        $configuration = $this->confLabinvent;
        $role = $this->getUserRole($user);
        /*
        $role = TableRegistry::get('Users')->find()
	        ->where(['username' => $user[$configuration->authentificationType_ldap][0]])
	        ->first()['role'];
	    */
	    $this->myDebug("role is ".$role);

        //BETTER:
        //$action = $this->request->getAttribute('params')['action'];
        //$action = $this->request->getParam('action');
        $action = $this->getActionPassed();
        
        // error_log($action);

        // ACL : Actions accessibles à tous les roles (profils)
        if (in_array($action, ['index', 'view', 'add', 'find', 'creer', 'getNextDate', 'getDateGarantie']))
            return true;
            
        // ACL : Super-Admin peut accéder à toutes les actions
        if ($role == 'Super Administrateur') return true;

        // ACL : Par défaut refuser
        return false;
    }
    
    public function getTablePriviledgedUserFromCurrentSessionUserIfExists($user=null) {
        if (! $this->CURRENT_PRIVILEDGED_USER) {
            $configuration = $this->confLabinvent;
            $username = $user ? $user[$configuration->authentificationType_ldap][0] : $this->LdapAuth->user($configuration->authentificationType_ldap)[0];
            $priviledgedUser = TableRegistry::get('Users')
                ->find()
                ->where(['username' => $username])
                //->where(['username' => $this->LdapAuth->user('cn')[0]])
                ->first();
            //if (! $priviledgedUser) $priviledgedUser = "Unpriviledged User (not in table utilisateurs)";
            $this->CURRENT_PRIVILEDGED_USER = $priviledgedUser;
        }
        return $this->CURRENT_PRIVILEDGED_USER;
    }
    public function getUserRole($user=null) { 
        if (! $this->CURRENT_ROLE) {
            $priviledgedUser = $this->getTablePriviledgedUserFromCurrentSessionUserIfExists($user);
            // default role is "Utilisateur" (for people who are not in the table utilisateurs)
            $this->CURRENT_ROLE = ($priviledgedUser) ? $priviledgedUser['role'] : 'Utilisateur';
        }
        return $this->CURRENT_ROLE;
    }
    
    private function userHasRole($expectedRole, $ORMORE=false) {
        $role = $this->getUserRole();
        	if (! $ORMORE) return ($role == $expectedRole);
        	return ($this->getRoleLevel($role) >= $this->getRoleLevel($expectedRole));
        	/*
        //$hasRole = false;
        	switch ($expectedRole) {
            case 'Super Administrateur' :
                return (in_array($role, ['Super Administrateur']));
                break;
            case 'Administration Plus' :
                return (in_array($role, ['Administration Plus', 'Super Administrateur']));
                break;
            case 'Administration' :
                return (in_array($role, ['Administration', 'Administration Plus', 'Super Administrateur' ]));
                break;
            case 'Responsable' :
                return (in_array($role, ['Responsable', 'Administration', 'Administration Plus', 'Super Administrateur']));
                break;
            case 'Utilisateur' :
                return (in_array($role, ['Utilisateur', 'Responsable', 'Administration', 'Administration Plus', 'Super Administrateur']));
                break;
        }
        return $false;
        */
    }
    private function userHasRoleAtLeast($expectedRole) {
        return $this->userHasRole($expectedRole, true);
    }
    public function USER_IS_ADMIN_AT_LEAST() { return $this->userHasRoleAtLeast('Administration'); }
    public function USER_IS_RESP_AT_LEAST() { return $this->userHasRoleAtLeast('Responsable'); }
    public function USER_IS_SUPERADMIN() { return $this->userHasRole('Super Administrateur'); }
    public function USER_IS_ADMIN() { return $this->userHasRole('Administration'); }
    public function USER_IS_RESP() { return $this->userHasRole('Responsable'); }
    public function USER_IS_USER() { return $this->userHasRole('Utilisateur'); }
    
        
    /**
     * {@inheritdoc}
     *
     * @see \Cake\Controller\Controller::beforeFilter()
     * 
     * 1) Autorisations SANS (ou AVANT) connexion
     * 2) Ensuite, c'est isAuthorized qui gère
     * 
     */
    public function beforeFilter(Event $event) {
        // !!! Ne jamais autoriser l'action 'login', sinon cela va créer des problèmes sur le fonctionnement normal de AuthComponent (cf doc) !!!
        //parent::beforeFilter($event);
        
        /* EXEMPLES d'utilisation:
        // to allow all access to all actions:
        if (isset($this->Auth)) {
            $this->Auth->allow('*');
        }
        // Allow access to index & view actions:
        if (isset($this->Auth)) {
            $this->Auth->allowedActions = array('index', 'view');
        }
        */
        
        $configuration = $this->confLabinvent;

        if ($configuration->mode_install)
            $this->LdapAuth->allow(['display', 'add', 'edit', 'installOff']);
        else
            $this->LdapAuth->allow(['display']);

        $this->LdapAuth->config('authError', "Désolé, vous n'êtes pas autorisé à accéder à cette zone.");
    }

    public function afterFilter(Event $event) {
        if (in_array($this->request->getAttribute('params')['action'], ['edit', 'add']))
            $this->request->session()->write("retourForm1", true);
        else if ($this->request->getAttribute('params')['action'] != 'creer')
            $this->request->session()->write("retourForm1", false);
    }

    /**
     * Before render callback.
     *
     * @param \Cake\Event\Event
     * $event The beforeRender event
     * @return void
     */
    public function beforeRender(Event $event) {
        
    	$this->set('PROFILE_USER', self::PROFILE_USER);
    	$this->set('PROFILE_ADMIN', self::PROFILE_ADMIN);
    	$this->set('PROFILE_RESPONSABLE', self::PROFILE_RESPONSABLE);
       	$this->set('PROFILE_ADMINPLUS', self::PROFILE_ADMINPLUS);
       	$this->set('PROFILE_SUPERADMIN', self::PROFILE_SUPERADMIN);
       	//$this->set('allProfiles', $this->allProfiles);
       	$this->set('allProfiles', self::PROFILES);
       	
    	if (!array_key_exists('_serialize', $this->viewVars) && in_array($this->response->type(), ['application/json', 'application/xml' ]))
            $this->set('_serialize', true);
    	
        $this->set('username', $this->LdapAuth->user('sn')[0] . ' ' . $this->LdapAuth->user('givenname')[0]);

        $configuration = $this->confLabinvent;
        $this->set('configuration', $configuration);
        $this->request->session()->write("authType", $configuration->authentificationType_ldap);

        // ATTENTION, $priviledgedUser = NULL si l'utilisateur courant n'est pas un utilisateur privilégié 
        // (c'est à dire s'il n'est pas dans la table "utilisateurs") 
        $priviledgedUser = $this->getTablePriviledgedUserFromCurrentSessionUserIfExists();
        /*
        $user = TableRegistry::get('Users')->find()
        	->where(['username' => $this->LdapAuth->user($configuration->authentificationType_ldap)[0]])
        	->first();
        $role = $user['role'];
        if ($role == null)
            $role = 'Utilisateur';
        */
        // Role = 'Utilisateur', 'Responsable", ...
        $role = $this->getUserRole();
        $this->set('role', $role);

        // Profile = PROFILE_USER (=1), PROFILE_RESPONSABLE (=2), ...
        //$profile = $this->allProfiles["$role"];
        $profile = self::PROFILES["$role"];
        $this->set('profile', $profile);
        
        $USER_IS_UTILISATEUR = ($profile == self::PROFILE_USER);
        $USER_IS_RESPONSABLE = ($profile == self::PROFILE_RESPONSABLE);
        $USER_IS_ADMIN = ($profile == self::PROFILE_ADMIN);
        $USER_IS_ADMINPLUS = ($profile == self::PROFILE_ADMINPLUS);
        $USER_IS_SUPERADMIN = ($profile == self::PROFILE_SUPERADMIN);
        $USER_IS_RESPONSABLE_OR_MORE = ($profile >= self::PROFILE_RESPONSABLE);
        $USER_IS_ADMIN_OR_MORE = ($profile >= self::PROFILE_ADMIN);
        $USER_IS_ADMINPLUS_OR_MORE = ($profile >= self::PROFILE_ADMINPLUS);
        
        $this->set('USER_IS_UTILISATEUR', $USER_IS_UTILISATEUR);
        $this->set('USER_IS_RESPONSABLE', $USER_IS_RESPONSABLE);
        $this->set('USER_IS_ADMIN', $USER_IS_ADMIN);
        $this->set('USER_IS_ADMINPLUS', $USER_IS_ADMINPLUS);
        $this->set('USER_IS_SUPERADMIN', $USER_IS_SUPERADMIN);
        $this->set('USER_IS_RESPONSABLE_OR_MORE', $USER_IS_RESPONSABLE_OR_MORE);
        $this->set('USER_IS_ADMIN_OR_MORE', $USER_IS_ADMIN_OR_MORE);
        $this->set('USER_IS_ADMINPLUS_OR_MORE', $USER_IS_ADMINPLUS_OR_MORE);
        
        $this->set('priviledgedUser', $priviledgedUser);

        $this->set('idGmNa', TableRegistry::get('GroupesMetiers')->find()->where(['nom =' => 'N/A'])->first()['id']);
        $this->set('idGtNa', TableRegistry::get('GroupesThematiques')->find()->where(['nom =' => 'N/A'])->first()['id']);

        $displayElement = function ($nom, $valeur, $params = "") {
            $balise = ($params != "") ? '<td ' . $params . '>' : '<td>';
            // Ca c'est parce que sinon y'a au moins deux tests qui passent pas, a cause de l'espace dans la balise ...
            if ($valeur != "")
                echo '<tr><td><strong>' . $nom . ' </strong></td>' . $balise . $valeur . '</td></tr>';
        };
        $this->set('displayElement', $displayElement);
        
        // Pass this function to all views
        // @todo : Si cette fonction ne concerne que SuivisController, il faut la déplacer dans ce controleur
        $dateProchainControleVerif = function($t) {
            	$time = Time::now(); // On récupère la date et l'heure actuelles
            	$today = new \DateTime((new date("$time->year-$time->month-$time->day"))->format('Y-m-d'));
            	$time1 = new time($t);
            	$dateTime1 = new \DateTime((new date("$time1->year-$time1->month-$time1->day"))->format('y-m-d'));
            	$interval = ($today->diff($dateTime1));
            	$strInterval = $interval->format('%a');
            	return (int) $strInterval;
        };
        $this->set('dateProchainControleVerif', $dateProchainControleVerif);
    }

    // "le materiel", "le suivi"...
    protected function getArticle() { return "Le "; }
    
    static function isLabinventDebugMode() { return  TableRegistry::get('Configurations')->find()->where(['id =' => 1])->first()->mode_debug; }

    function myDebug($arg, $stop = false) {
        if ($this->isLabinventDebugMode()) {
            Configure::write('debug', true);
            debug($arg);
            if ($stop)
                exit();
        }
    }

    /**
     * Envoi un mail avec un sujet, contenant un message à destination d'une liste de mails, selon l'action effectuée.
     *
     * @param $obj :
     *            Matériel concerné
     * @param $subject :
     *            Sujet du message à envoyer. Si $subject n'est pas renseigné, un sujet par défaut sera généré.
     * @param $msg :
     *            Message à envoyer. Si $msg n'est pas renseigné, un message par défaut sera généré.
     */
    public function sendEmail($obj, $subject = null, $msg = null) {
        /*
         * $_SESSION['Auth']['User'] pour retrouver TOUTES les infos de la session courante (tout est du string) :
         * nom		$_SESSION['Auth']['User']['sn'][0]
         * prenom	$_SESSION['Auth']['User']['givenname'][0]
         * mail		$_SESSION['Auth']['User']['mail'][0]
         * login	$_SESSION['Auth']['User']['xxx'][0]		/!\ Ce champ est suceptible de changer de nom, dans les tests ce champ est ['cn'][0]
         * mdp		$_SESSION['Auth']['User']['userpassword'][0]
         */
        $configuration = $this->confLabinvent;
        $action = $this->request->getAttribute('params')['action']; // add or edit or delete or ...

        // Si les deux cases "Activer l'envoi des mails.." sont décochée, on se fatigue pas à exécuter la fonction
        if (!$configuration->envoi_mail && !$configuration->envoi_mail_guests)
            return null;

        $materiel = $obj;
        $mailList = array();

        // On détermine le message et le sujet du mail en fonction de l'action effectuee
        $acteur = $_SESSION['Auth']['User']['givenname'][0] . ' ' . $_SESSION['Auth']['User']['sn'][0];
        if ($materiel != null) {
            $nom_materiel = $materiel->designation;
            if ($subject == null && $msg == null) {
                Switch ($action) {
                    case 'add' :
                        $subject = "Ajout d'un matériel";
                        $msg = "$acteur a ajouté le matériel \"$nom_materiel\".";
                        break;
                    case 'edit' :
                        $subject = "Modification d'un matériel";
                        $msg = "$acteur a modifié le matériel \"$nom_materiel\".";
                        break;
                    case 'delete' :
                        $subject = "Suppression d'un matériel";
                        $msg = "$acteur a supprimé le matériel \"$nom_materiel\".";
                        
                        if ($materiel->	sur_categorie_id != "") $msg .= "\n\nDomaine : ". $materiel->description;
                        if ($materiel->	categorie_id != "") $msg .= "\n\nCatégorie : ". $materiel->description;
                        if ($materiel->	sous_categorie_id != "") $msg .= "\n\nSous-catégorie : ". $materiel->description;
						if ($materiel->description != "") $msg .= "\n\nDescription :\n\n". $materiel->description;
						
                        break;
                    case 'statusCreated' :
                        $subject = "Dé-validation d'un matériel";
                        $msg = "$acteur a dé-validé le matériel \"$nom_materiel\".";
                        break;
                    case 'statusValidated' :
                        $subject = "Validation d'un matériel";
                        $msg = "$acteur a validé le matériel \"$nom_materiel\".";
                        break;
                    case 'statusToBeArchived' :
                        $subject = "Demande d'archivage d'un matériel";
                        $msg = "$acteur a demandé l'archivage du matériel \"$nom_materiel\".";
                        break;
                    case 'statusArchived' :
                        $subject = "Archivage  d'un matériel";
                        $msg = "$acteur a archivé le matériel \"$nom_materiel\".";
                        break;
                    case 'setLabelIsPlaced' :
                        $subject = "Etiquette posée sur un matériel";
                        $msg = "Etiquette posée sur le matériel \"$nom_materiel\".";
                        break;
                    case 'printLabelRuban' :
                        $subject = "Etiquette imprimée";
                        $msg = "L'étiquette concerant votre matériel \"$nom_materiel\" a été imprimée.";
                        $mailList[0] = $materiel->email_responsable;
                    default :
                        $subject = "Action \"$action\" sur un matériel";
                        $msg = "$acteur a effectué l'action \"$action\" sur le matériel \"$nom_materiel\".";
                        break;
                }
            }

            // Et maintenant on construit la liste de mails ...
            // Si l'envoi général est activé (et que l'action ne correspond pas à 'printLabelRuban'):
            if ($configuration->envoi_mail && $action != 'printLabelRuban') {
            	
                // mail owner
                $mailList[0] = $materiel->email_responsable;

                // mail resp
                $mailsRespMetier = null;
                $mailsRespMetier = null;

                if ($materiel->groupes_metier_id != null && $materiel->groupes_metier_id != 1)
                    // Le ..!= 1 c'est parce que le groupe métier/thématique d'id 1 correspond au groupe N/A, soit aucun groupe
                    $mailsRespMetier = TableRegistry::get('Users')->find()->select('email')
                    	->where(['role =' => 'Responsable', 'groupes_metier_id =' => $materiel->groupes_metier_id])
                    	->toArray();

                if ($mailsRespMetier != null && $mailsRespMetier != null) {
                    $mailResp = array_unique(array_merge($mailsRespMetier, $mailRespThematique));
                    for ($i = 0; $i < sizeof($mailsResp); $i ++) {
                        $mailList[sizeof($mailList)] = $mailsResp[$i]['email'];
                    }
                }

                // mail admin de reference (ici appele gestionnaire) -> Partie administration
                // Cela a été mis en commentaire car de toute façon l'utilisateur va voir un administratif pour faire valider sa fiche,
                // Pas la peine de spam l'administration de mails non plus hein !

                /*
                 * if ($action != 'statusValidated' && $action != 'statusArchived') {
                 * $mailsAdmin = TableRegistry::get('Users')->find()->select('email')
                 * ->where(['role =' => 'Administration'])
                 * ->toArray();
                 * for ($i = 0; $i < sizeof($mailsAdmin); $i ++) {
                 * $mailList[sizeof($mailList)] = $mailsAdmin[$i]['email'];
                 * }
                 * }
                 */
            }
        }

        // Si l'envoi à la liste spécifiée est activé (et que l'action ne correspond pas à 'printLabelRuban'):
        if ($configuration->envoi_mail_guests && $action != 'printLabelRuban') {
            // mail aux adresses specifiees dans la config
            for ($i = 0; $i < 11; $i ++) {
                if ($configuration['emailGuest' . $i])
                    $mailList[sizeof($mailList)] = $configuration['emailGuest' . $i];
                // Le if vérifie que la ligne soit pas null
            }
        }

        // On dedoublonne la liste des mails, c'pas tres cool de se faire spam 2-3 fois pour la meme action sur le meme materiel, non mais !
        $List = array_unique($mailList);

        // ... Pour envoyer les mails aux personnes concernees
        foreach ($List as $mail) {
            // On envoi des mails à toute la liste, sauf pour "l'acteur", il sait ce qu'il a fait, pas besoin de le spam non plus hein
            if ($mail != $_SESSION['Auth']['User']['mail'][0]) {
                $message = $msg; // Sisi, cette variable $message est utile, m'enfin vous pouvez toujours essayer de la supprimer ..... Et pensez à regarder le contenu de vos mails !!! Sinon ca fait une tumeur
                $role = TableRegistry::get('Users')->find()->select('role')->where(['email =' => $mail])->first()['role'];
                
                if ($action != 'statusValidated' && $materiel != null)
                    $message .= "\nVeuillez vérifier et compléter si besoin la fiche corespondante.";
                
                // Génération du message "Vous recevez ce message en tant que $role"
                // Si $role innexistant (lorsque c'est un mail de la liste entrée en configuration), le message est plutot "Vous recevez ce message car vous avez demandé à le recevoir. [...]"
                if ($role)
                    $role = 'en tant que ' . $role;
                else
                    $role = 'car vous avez demandé à le recevoir. Pour faire retirer votre mail de la liste, veuillez contacter un SuperAdmin.';
                
                $message .= "\n\n" . 'Vous recevez ce message ' . $role;
                $this->sendEmailTo("$subject", $message, $mail, $configuration);
            }
        }
        return $List;
    }

    // Fonction d'envoi de mails
    private function sendEmailTo($subject, $msg, $mail, $config) {
        if ($mail != null && !$config->test) {
            if (filter_var($mail, FILTER_VALIDATE_EMAIL)) {
                $email = new Email();
                $etiquetteFrom = explode("@", $config->sender_mail);
                $email->transport('default')->from([$config->sender_mail => $etiquetteFrom[0]])
                	->to($mail)->subject("[LabInvent] " . $subject)->send($msg);
            }
        }
    }
}