<?php

global $plugins, $CONFIG;

define('_SCDE_ARCH_DEP_NORM', 'SCDE_ARCH_DEP_NORM');
define('_SCDE_ARCH_DEP_SENS', 'SCDE_ARCH_DEP_SENS');
define('_SCDE_ARCH_PJGN_NORM', 'SCDE_ARCH_PJGN_NORM');
define('_SCDE_ARCH_PJGN_SENS', 'SCDE_ARCH_PJGN_SENS');
define('_CRV_KO_DROITS', 'CRV_KO_DROITS');
define('_CRV_KO_TECH', 'CRV_KO_TECH');

/**
 * 
 * Lorsqu'une erreur est détectée
 * 
 * @param string $error Libellé de l'erreur
 * @param string $file Archive concerné par l'erreur
 * @param string $identifier Numéro de dossier de l'archive concernée
 * @param integer $codeUnite Code unité propriétaire de l'archive
 * @param string $hash Emprunte de l'archive
 * @param boolean $rollback Indique si un rollback de base est nécessaire
 * @param boolean $withExit Indique si le script doit se terminer si l'erreur est rencontrée
 * @param string $code Code de l'erreur
 */
function erreur($error, $file, $identifier = 0, $codeUnite = 0, $hash = '', $rollback = true, $withExit = true, $code = _CRV_KO_TECH) {
    Maarch_AutoImport_writeLog($error.", le fichier ".$file." sera ignoré", 'KO', 'ERROR');
    if ($rollback == true) {
        Maarch_AutoImport_writeLog("Rollback de l'insertion en base de données", 'OK', 'INFO');
        rollback($identifier);
    }
    genererCRV($code, $error, $hash, $identifier, $codeUnite);
    if ($withExit == true) {
        exit;
    }
}

/**
 * 
 * Met toutes les archives à importer en erreur
 * 
 * @param string $errorMsg Libellé de l'erreur
 */
function putAllfilesInError($errorMsg) {
    // On met en erreur tous les fichiers
    $fileNames = $_ENV['fileNameLoaded'];
    foreach ($fileNames as $importedFile) {
        // On récupère le nom de chaque xml
        if (preg_match('/.xml$/', $importedFile)) {
            $xmlFullPath = $_ENV['sid']."/".$importedFile;
            if (file_exists($xmlFullPath)) {
                //loading of the xml config file.
                if (!($xmlConfig = simplexml_load_file($xmlFullPath))) {
                     erreur("Impossible de lire le fichier XML", $importedFile);
                }
                else {
                    $identifier = (string) $xmlConfig->dossier;
                    $codeUnite = (string) $xmlConfig->unite;
                    $initialHash = (string) $xmlConfig->checksum;
                    excludeFile($importedFile, $errorMsg, $initialHash, $identifier, $codeUnite);
                }
            }
            else {
                erreur("Impossible de lire le fichier XML", $importedFile);
            }
        }
    }
}

/**
 * 
 * S'il est impossible d'écrire dans le docserver
 */
function docserverError() {
    putAllfilesInError("Ecriture impossible dans le docserver");
}

/**
 * 
 * S'il est impossible d'accéder à la base de données
 */
function databaseError() {
    putAllfilesInError("Erreur d'écriture dans la base de données");
}

/**
 * 
 * Remplace le expressions joker dans une chaîne de caractère
 * 
 * @param string $string Chaîne de caractère à modifier
 */
function replaceJokersMail($string) {
    $string = str_replace('%numero_dossier%', $_ENV['identifier'], $string);
    $string = str_replace('%validateur%', $_ENV['archiviste'], $string);
    $string = str_replace('%date%', date('d/m/Y'), $string);
    $string = str_replace('%heure%', date('H\hi'), $string);
    return $string;
}

/**
 * 
 * Génère un compte rendu de versement négatif
 * 
 * @param string $codeId Code de l'erreur
 * @param string $errorMsg Libellé de l'erreur
 * @param string $hash Emprunte de l'archive
 * @param string $identifier Numéro de dossier
 * @param integer $codeUnite Code unité propriétaire de l'archive
 */
function genererCRV($codeId, $errorMsg, $hash, $identifier, $codeUnite) {
    $_ENV['identifier'] = $identifier;
    // On vérifie qu'on a pu récupérer l'email de l'archiviste
    $adresseMailArchiviste = "";
    if (!isset($_ENV['archiviste_mail']) || empty($_ENV['archiviste_mail'])) {
        Maarch_AutoImport_writeLog("Problème détecté lors de la génération du CRV pour le dossier ".$identifier.", impossible de trouver l'archiviste spécifié : ".$_ENV['archiviste'].". Celui-ci ne pourra donc être prévenu par mail.", 'KO', 'WARN');
    }
    else {
        $adresseMailArchiviste = $_ENV['archiviste_mail'];
    }
    // On récupère l'IP du département
    $_ENV['db']->query("SELECT ip_departement FROM pjgn_departements WHERE id_departement = '".$codeUnite."'");
    if (!$line = $_ENV['db']->fetch_object()) {
        Maarch_AutoImport_writeLog("Génération du CRV pour le dossier ".$identifier." échoué, impossible de trouver l'IP de la brigade : ".$codeUnite, 'KO', 'ERROR');
        return false;
    }
    
    $ip = $line->ip_departement;
    $date = date("dmY");
    $heure = date("His");
    $millitime = round(microtime(true) * 1000);
    $file = $ip."-".$date.$heure.$millitime.".xml";
    Maarch_AutoImport_writeLog("Génération du CRV pour le fichier ".$file, 'OK', 'INFO');
    $dom = new DOMDocument();
    // Définition des autres propriétés
    $dom->encoding = 'UTF-8';
    $dom->formatOutput = true; 
    // Noeud crv
    $crv = $dom->createElement("crv");
    $dom->appendChild($crv);
    //     Noeud origin
    $origin = $dom->createElement("origin");
    $crv->appendChild($origin);
    $originTxt = $dom->createTextNode($ip.'s');
    $origin->appendChild($originTxt);
    //     Noeud dossier
    $dossier = $dom->createElement("dossier");
    $dossier->setAttribute("checksum", $hash);
    $dossier->setAttribute("id", $identifier);
    $crv->appendChild($dossier);
    //        Noeud error
    $error = $dom->createElement("error");
    $dossier->appendChild($error);
    //            Noeud code
    $code = $dom->createElement("code");
    $codeTxt = $dom->createTextNode($codeId);
    $error->appendChild($code);
    $code->appendChild($codeTxt);
    //            Noeud message
    $message = $dom->createElement("message");
    $messageTxt = $dom->createTextNode($errorMsg);
    $error->appendChild($message);
    $message->appendChild($messageTxt);
    
    // Noeud administrateurs
    $administrateurs = $dom->createElement("administrateurs");
    $dossier->appendChild($administrateurs);
    
    // boucle sur les mail d'administrateurs connus
    foreach ($_ENV['administrators'] as $administrator) {
        $administrateurMail = $dom->createElement("administrateur_mail");
        $administrateurMailTxt = $dom->createTextNode($administrator);
        $administrateurs->appendChild($administrateurMail);
        $administrateurMail->appendChild($administrateurMailTxt);
    }
    
    // Récupération de l'email
    $emailSujetModele = "";
    $emailCorpsModele = "";
    $_ENV['db']->query("SELECT sujet_modele, corps_modele FROM pjgn_modeles_courriels WHERE code_modele = '".$codeId."'");
    if (!$email = $_ENV['db']->fetch_object()) {
        Maarch_AutoImport_writeLog("Génération du CRV pour l'UPVA ".$identifier." échoué, impossible de trouver le template d'email : ".$codeId.". L'archiviste ne pourra donc être prévenu par mail.", 'KO', 'WARN');
    }
    else {
        $emailSujetModele = $email->sujet_modele;
        $emailCorpsModele = $email->corps_modele;
    }
    
    //        Noeud sujet_mail
    $sujetMail = $dom->createElement("sujet_mail");
    $sujetMailTxt = $dom->createTextNode(replaceJokersMail($emailSujetModele));
    $dossier->appendChild($sujetMail);
    $sujetMail->appendChild($sujetMailTxt);
    
    //        Noeud message_mail
    $messageMail = $dom->createElement("message_mail");
    $messageMailTxt = $dom->createCDATASection(replaceJokersMail($emailCorpsModele));
    $dossier->appendChild($messageMail);
    $messageMail->appendChild($messageMailTxt);

    if ($dom->save($_ENV['crvPath'].'/'.$file)) {
        Maarch_AutoImport_writeLog("Génération du CRV pour le fichier ".$file." terminé", 'OK', 'INFO');
    }
    else {
        Maarch_AutoImport_writeLog("Génération du CRV pour le fichier ".$file." échoué", 'KO', 'ERROR');
    }
    return true;
}

/**
 * 
 * Effectue un rollback de base de données
 * 
 * @param string $identifier Numéro de dossier
 */
function rollback($identifier) {
    // On récupère la derniere ressource insérée correspondant à l'identifiant d'UPVA
    $_ENV['db']->query("select MAX(res_id) as id from res_pjgn where identifier = '".$identifier."'");
    if ($line = $_ENV['db']->fetch_object()) {
        // On supprime l'entrée correspondant à l'UPVA en base de données 
        $_ENV['db']->query("DELETE FROM res_pjgn WHERE res_id = '".$line->id."'");
    }
}

/**
 * 
 * Permet de rechercher si un groupe existe dans une liste
 * 
 * @param string $group Groupe à rechercher
 * @param array $user Tableau contenant la liste des groupes
 */
function hasGroup($group, $user) {
    $nbGroups = count($user['groups']);
    for ($i = 0; $i < $nbGroups; $i++) {
        if ($user['groups'][$i] == $group) {
            return true;
        }
    }
    return false;
}

/**
 * 
 * Vérifie le format du fichier XML de méta-données
 * et vérifie que l'utilisateur a les droits de verser
 */
function verifFormat() {
    // On lit le fichier
    $fileNames = $_ENV['fileNameLoaded'];
    foreach ($fileNames as $importedFile) {
        // On récupère le nom du xml
        if (preg_match('/.xml$/', $importedFile)) {
            Maarch_AutoImport_writeLog("Prise en charge du dossier ".$importedFile, 'OK', 'INFO');
            $xmlFullPath = $_ENV['sid']."/".$importedFile;
            if (file_exists($xmlFullPath)) {
                //loading of the xml config file.
                if (!($xmlConfig = simplexml_load_file($xmlFullPath))) {
                     erreur("Impossible de lire le fichier XML", $importedFile);
                }
                $identifier = (string) $xmlConfig->dossier;
                $codeUnite = (string) $xmlConfig->unite;
                $initialHash = (string) $xmlConfig->checksum;
                $estSensible = (string) $xmlConfig->est_sensible;
                $archiviste = (string) $xmlConfig->archiviste;
                $_ENV['archiviste'] = $archiviste;
                $expert = (string) $xmlConfig->expert;
                // On vérifie que le fichier est complet
                // nom du fichier sans extension
                $importedFileWithoutExt = substr($importedFile, 0, strrpos($importedFile, '.'));
                // récupération du fichier associé au XML
                foreach ($_ENV['fileNameLoaded'] as $archive) {
                    if (!preg_match('/.xml$/', $archive) && preg_match('/^'.$importedFileWithoutExt.'/', $archive)) {
                        // ici on check le fichier
                        $initialFileSize = filesize($_ENV['sid']."/".$archive);
                        sleep(1);
                        clearstatcache();
                        $finalFileSize = filesize($_ENV['sid']."/".$archive);
                        // fin check
                        if ($initialFileSize != $finalFileSize) {
                            excludeFileWithoutDelete($importedFile, "Fichier incomplet", $initialHash, $identifier, $codeUnite);
                            continue 2;
                        }
                        break 1;
                    }
                }
                // On récupère les groupes de l'archiviste (il peut en avoir plusieurs)
                // On récupère l'unité de l'archiviste
                // On fait les vérifications
                $_ENV['db']->query("
                SELECT 
                	uc.group_id, 
                	ue.entity_id,
                	u.mail
                FROM 
                	usergroup_content uc,
                	users_entities ue, 
                	users u 
                WHERE 
                	custom_t1 = '".$archiviste."'
                AND
                	u.user_id = uc.user_id
                AND
                	u.user_id = ue.user_id
                AND
                	ue.user_id = uc.user_id");
                $i = 0;
                $user = array();
                $user['groups'] = array();
                while ($line = $_ENV['db']->fetch_object()) {
                    $_ENV['archiviste_mail'] = $line->mail;
                    $user['unite'] = $line->entity_id;
                    $user['groups'][$i] = $line->group_id;
                    $i++;
                }
                if ($i == 0) {
                    excludeFile($importedFile, "Les droits d'accès de l'archiviste spécifié ne sont pas suffisants pour effectuer le versement", 
                        $initialHash, $identifier, $codeUnite, _CRV_KO_DROITS);
                }
                // Si on a les droits de verser pour l'unite
                if (hasGroup(_SCDE_ARCH_PJGN_NORM, $user) || 
                hasGroup(_SCDE_ARCH_PJGN_SENS, $user) || 
                (hasGroup(_SCDE_ARCH_DEP_NORM, $user) && $codeUnite == $user['unite']) ||
                (hasGroup(_SCDE_ARCH_DEP_SENS, $user) && $codeUnite == $user['unite'])) {
                    // Si on a le droit de verser le type d'archive
                    if (!(((hasGroup(_SCDE_ARCH_DEP_NORM, $user) || hasGroup(_SCDE_ARCH_PJGN_NORM, $user)) && $estSensible != 1) ||
                    ((hasGroup(_SCDE_ARCH_DEP_SENS, $user) || hasGroup(_SCDE_ARCH_PJGN_SENS, $user)) && $estSensible == 1))) {
                        excludeFile($importedFile, "Les droits d'accès de l'archiviste spécifié ne sont pas suffisants pour effectuer le versement", 
                            $initialHash, $identifier, $codeUnite, _CRV_KO_DROITS);
                    }
                }
                else {
                    excludeFile($importedFile, "Les droits d'accès de l'archiviste spécifié ne sont pas suffisants pour effectuer le versement", 
                        $initialHash, $identifier, $codeUnite, _CRV_KO_DROITS);
                }
                
                // On vérifie le checksum
                // nom du fichier sans extension
                $importedFileWithoutExt = substr($importedFile, 0, strrpos($importedFile, '.'));
                // récupération du fichier associé au XML
                foreach ($_ENV['fileNameLoaded'] as $archive) {
                    if (!preg_match('/.xml$/', $archive) && preg_match('/^'.$importedFileWithoutExt.'/', $archive)) {
                        $hash = Maarch_AutoImport_doFingerprint($_ENV['sid']."/".$archive, $_ENV['docserverFingerprintMode']);
                        if ($hash != $initialHash) {
                            excludeFile($importedFile, "Checksum incorrect", $initialHash, $identifier, $codeUnite);
                        }
                        break 1;
                    }
                }
            }
            else {
                Maarch_AutoImport_writeLog("Impossible de trouver le fichier XML ".$importedFile, 'KO', 'ERROR');
            }
        }
    }
}

/**
 * 
 * Permet d'ignorer une archive dans le répertoire d'import
 * 
 * @param string $file Nom de l'archive
 * @param string $message Libellé du message de warning
 * @param string $hash Emprunte de l'archive
 * @param string $identifier Numéro de dossier
 * @param integer $codeUnite Code unité propriétaire de l'archive
 */
function excludeFileWithoutDelete($file, $message, $hash, $identifier, $codeUnite) {
    $newFilenames = array();
    $fileWithoutDot = substr($file, 0, strrpos($file, '.'));
    foreach ($_ENV['fileNameLoaded'] as $entry) {
        // Si c'est pas le fichier a exclure
        if (!preg_match('/^'.$fileWithoutDot.'\.[0-9a-zA-Z]*$/', $entry)) {
            array_push($newFilenames, $entry);
        }
    }
    $_ENV['fileNameLoaded'] = $newFilenames;
    var_dump($_ENV['fileNameLoaded']);
    Maarch_AutoImport_writeLog($message.", le fichier ".$file." sera ignoré", 'KO', 'WARN');
}

/**
 * 
 * Permet de supprimer une archive dans le répertoire d'import
 * 
 * @param string $file Nom de l'archive
 * @param string $message Libellé du message d'erreur
 * @param string $hash Emprunte de l'archive
 * @param string $identifier Numéro de dossier
 * @param integer $codeUnite Code unité propriétaire de l'archive
 * @param string $code Code d'erreur
 */
function excludeFile($file, $message, $hash, $identifier, $codeUnite, $code = _CRV_KO_TECH) {
    $newFilenames = array();
    $fileWithoutDot = substr($file, 0, strrpos($file, '.'));
    foreach ($_ENV['fileNameLoaded'] as $entry) {
        // Si c'est pas le fichier a exclure
        if (!preg_match('/^'.$fileWithoutDot.'\.[0-9a-zA-Z]*$/', $entry)) {
            array_push($newFilenames, $entry);
        }
        // Sinon on le déplace
        else {
            Maarch_AutoImport_putFileInError($_ENV['sid'].DIRECTORY_SEPARATOR.$entry);
        }
    }
    $_ENV['fileNameLoaded'] = $newFilenames;
    erreur($message, $file, $identifier, $codeUnite, $hash, false, false, $code);
}

/**
 * 
 * Fonction appelée lors du démarrage de l'importation
 */
function start() {
    global $CONFIG;
    
    $_ENV['db']->query("
    SELECT 
    	mail 
    FROM 
    	users u, 
    	usergroup_content ug 
    WHERE 
    	u.user_id = ug.user_id
    AND
    	ug.group_id = 'SCDE_PJGN_ADM'");
   $_ENV['administrators'] = array();
   while ($line = $_ENV['db']->fetch_object()) {
       array_push($_ENV['administrators'], $line->mail);
   }
    
    $_ENV['crvPath'] = $CONFIG->CRV_PATH;
    Maarch_AutoImport_writeLog("Début du versement d'un lot", 'OK', 'INFO');
}

/**
 * 
 * Fonction appelée lors de la fin de l'importation
 */
function stop() {
    Maarch_AutoImport_writeLog("Fin du versement d'un lot", 'OK', 'INFO');
}

$plugins->register("program_start", "start");
$plugins->register("program_end", "stop");
$plugins->register("error_docserver_end", "docserverError");
$plugins->register("error_database_begin", "databaseError");
$plugins->register("filenames_loaded_end", "verifFormat");