<?php

// définition du chemin absolu vers la racine du projet
if (! defined('PROJECT_ROOT')) {
    define('PROJECT_ROOT', dirname(__DIR__));
}

require_once dirname(dirname(__DIR__))."/obj/task.class.php";

/**
 * Classe qui traite les tâches de type 'DI'
 */
class TaskManager extends metiermanager
{
    /**
     * @var un cache pour stocker les infos des collectivités
     */
    protected $cacheCollectivites;

    /**
     * Pas implementé
     */
    protected function ajouter(&$data, $msg_OK = null, $msg_KO = null) {
        $this->setMessage('Pas implémenté');
        return $this->KO;
    }
    protected function modifier($data, $msg_OK = null, $msg_KO = null) {
        $this->setMessage('Pas implémenté');
        return $this->KO;
    }
    protected function supprimer(&$data, $msg_OK, $msg_KO) {
        $this->setMessage('Pas implémenté');
        return $this->KO;
    }

    /**
     * Renvoie le nom de la classe du 'processeur' permettant de traiter la tâche spécifiée.
     *
     * @param  $tache  La tâche à traiter.
     *
     * @return  Array & Callable  Une fonction appelable, pour traiter la tâche
     *
     * @throw  InvalidArgumentException  Lorsque que le type de tâche n'est pas supporté/invalide
     */
    protected function _getProcessorFromTache($tache) {
        switch($tache->getVal('type')) {
            case 'create_DI_for_consultation': return array($this, 'create_DI_for_consultation');
            case 'add_piece': return array($this, 'add_piece');
        }
        throw new InvalidArgumentException(sprintf(
            __("Type de tâche '%s' non supporté"), $tache->getVal('type')));
    }

    /**
     * Traite toutes les tâches, éventuellement seulement celles spécifiées par un type.
     *
     * @param  string  $statut  Un statut de tâche à traiter
     * @param  string  $type    Un type de tâche à traiter
     *
     * @return  Array  Un tableau contenant le récapitulatif des traitements
     *
     * @throw  RuntimeException  Lorsqu'il y a un échec pendant le traitement d'une tâche
     */
    public function traitement(array $requestData) {
        try {
            $this->addToLog(__METHOD__.'(): request data = '.var_export($requestData, true), VERBOSE_MODE);

            $statut = isset($requestData['statut']) ? $requestData['statut'] : task::STATUS_NEW;
            $type = isset($requestData['type']) ? $requestData['type'] : '';

            $this->addToLog(__METHOD__.'(): statut = '.var_export($statut, true).', '.
                        'type = '.var_export($type, true), VERBOSE_MODE);

            // construit le filtre SQL (clause WHERE)
            $filtreSQL = "stream = 'input' AND json_payload <> '{}'";
            $filtreSQL .= sprintf(" AND state = '%s'", $this->f->db->escapeSimple($statut));;
            if (! empty($type)) {
                $filtreSQL .= sprintf(" AND type = '%s'", $this->f->db->escapeSimple($type));
            }

            // stocke le résultat et les succès/échecs
            $success = array();
            $failures = array();

            // pour chaque tâche
            foreach($this->f->getAllObjects('task', $filtreSQL) as $tache) {
                $desc = $this->_getTacheDesc($tache);
                $type = $tache->getVal('type');

                // selon le type de la tâche invoquer un "processeur"
                // qui réalisera le traitement de cette tâche
                // stocker les succès et les échecs
                if (empty($type)) {
                    $this->_setTaskState($tache, 'invalide');
                    $failures[$desc] = "Attribut 'type' vide";
                }
                else {
                    $processorCallable = $this->_getProcessorFromTache($tache);
                    if (isset($processorCallable[0]) != $this) {
                        $processorClass = $processorCallable[0].'.class.php';
                        $processorClassPath = PROJECT_ROOT.'/obj/'.$processorClass;
                        if (file_exists($processorClassPath)) {
                            require_once $processorClassPath;
                            $processor = new $processorName($this->f, $this->APILogger);
                            $processorMethod = isset($processorCallable[1]) ? $processorCallable[1] : 'process';
                            $processorCallable = array($processor, $processorMethod);
                        }
                    }
                    if (is_callable($processorCallable)) {
                        $this->_setTaskState($tache, task::STATUS_PENDING);
                        $result = array();
                        try {
                            $result = call_user_func_array($processorCallable, array($tache));
                        }
                        catch(Exception $exception) {
                            $result['error'] = get_class($exception).' : '.$exception->getMessage();
                        }
                        if (isset($result['error']) && ! empty($result['error'])) {
                            $this->_setTaskState($tache, task::STATUS_ERROR);
                            $failures[$desc] = $result['error'];
                        }
                        elseif ($result === false) {
                            $this->_setTaskState($tache, task::STATUS_ERROR);
                            $failures[$desc] = 'erreur';
                        }
                        else {
                            $this->_setTaskState($tache, task::STATUS_DONE);
                            $success_message = 'succès';
                            if (is_array($result) && isset($result['message'])) {
                                $success_message = $result['message'];
                            }
                            $success[$desc] = $success_message;
                        }
                    }
                    else {
                        $this->_setTaskState($tache, 'invalide');
                        $failures[$desc] = "Processeur '".var_export($processorCallable, true)."' invalide pour la tâche '$desc'";
                    }
                }
            }

            // s'il y a eu des échecs de traitements
            if (! empty($failures)) {
                $this->addToLog(__METHOD__."(): il y a eu des échecs de traitements", DEBUG_MODE);

                // renvoyer un code HTTP adapté ainsi que les erreurs rencontrées
                $errorMsg = "Les tâches suivantes ont rencontrées un échec pendant leur traitement :\n";
                foreach($failures as $tacheDesc => $error) {
                    $this->addToLog(__METHOD__."(): * $tacheDesc => $error", DEBUG_MODE);
                    $errorMsg .= " - $tacheDesc: $error\n";
                }
                if(! empty($success)) {
                    $errorMsg .= "\nLes tâches suivantes ont été traitées avec succès :\n";
                    foreach($success as $tacheDesc => $msg) {
                        $this->addToLog(__METHOD__."(): * $tacheDesc => $msg", DEBUG_MODE);
                        $errorMsg .= " - $tacheDesc: $msg\n";
                    }
                }
                throw new RuntimeException($errorMsg);
            }

            // si tout s'est bien passé :
            // renvoyer un code HTTP adapté et le résultat obtenu (un tableau)
            $this->addToLog(__METHOD__."(): succès des traitements", VERBOSE_MODE);
            if (! empty($success)) {
                $this->setMessage(implode('\n', array_map(
                    function($desc, $msg) { return $desc.' : '.$msg; },
                    array_keys($success), $success)));
            }
            return $this->OK;
        }
        catch(InvalidArgumentException $exc) {
            $this->setMessage($exc->getMessage());
            return $this->BAD_DATA;
        }
        catch(Exception $exc) {
            $this->setMessage($exc->getMessage());
            return $this->KO;
        }
    }

    /**
     * Renvoie une description textuelle d'une tâche (composée de son ID, son type et le dossier).
     *
     * @param  $tache  La tâche concernée
     *
     * @return  string  la description textuelle de la tâche
     */
    protected function _getTacheDesc($tache) {
        return '['.$tache->getVal('task').'] '.$tache->getVal('type').' '.$tache->getVal('dossier');
    }

    /**
     * Met à jours l'état d'une tâche.
     *
     * @param  $tache  La tâche concernée
     *
     * @return taskProcessorDemande
     */
    protected function _setTaskState($tache, string $statut) {
        $tache->update_task(array('val' => array('state' => $statut)));
        return $this;
    }

    /**
     * Traite les tâches de type 'creation_DI'.
     *
     * @param  $tache  La tâche à traiter
     *
     * @return Array|false  Un tableau contenant le résultat du traitement, false en cas d'erreur
     *
     * @throw InvalidArgumentException  En cas de donnée utilisateur invalide ou manquante
     * @throw RuntimeException          En cas d'erreur BDD
     */
    protected function create_DI_for_consultation($tache) {
        global $_POST;

        $this->addToLog(__METHOD__."(): Décode le json", VERBOSE_MODE);
        $request_data = json_decode($tache->getVal('json_payload'), true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            throw new InvalidArgumentException(sprintf(
                __("échec du décodage JSON (%s)"),
                json_last_error_msg()));
        }

        // TODO gérer l'ajout de demande sur existant
        // (on ne connait pas le format des données arrivant)

        // ajout d'une nouvelle demande

        // retraitement spécifique des données de la nouvelle demande
        $this->addToLog(__METHOD__."(): Prépare les données de la nouvelle demande", VERBOSE_MODE);
        $demande_values = $this->prepare_new_demande_data($request_data);

        // retraitement commun des données de la demande
        $this->addToLog(__METHOD__."(): Prépare les données de la demande", VERBOSE_MODE);
        $demande_values = $this->prepare_demande_data($request_data, $demande_values);

        // vérification des externals UUIDs
        if (! isset($request_data['external_uids']) || empty($request_data['external_uids'])) {
            throw new InvalidArgumentException(sprintf(
                __("Aucune valeur pour le paramètre '%s'"),
                'external_uids'));
        }

        // utilisation d'un faux $_POST pour stocker les demandeurs de la demande
        $_POST = array();

        // ajout des demandeurs
        $this->addToLog(__METHOD__."(): Créé les demandeurs", VERBOSE_MODE);
        if (! isset($request_data['demandeur']) && ! empty($request_data['demandeur'])) {
            throw new InvalidArgumentException(sprintf(
                __("Aucune valeur pour le paramètre '%s'"),
                'demandeur'));
        }
        foreach ($request_data["demandeur"] as $d_index => $demandeur_valeurs) {
            if (! isset($demandeur_valeurs['type_demandeur']) ||
                    empty($demandeur_valeurs['type_demandeur'])) {
                throw new InvalidArgumentException(sprintf(
                    __("Aucun type pour le demandeur '%s'"), $d_index));
            }
            $demandeur_type = $demandeur_valeurs['type_demandeur'];
            if (isset($demandeur_valeurs["${demandeur_type}_principal"]) &&
                    $demandeur_valeurs["${demandeur_type}_principal"] === 't') {
                $demandeur_type = "${demandeur_type}_principal";
                $demandeur_valeurs['type_demandeur'] = $demandeur_type;
            }
            $demandeur_id = $this->creation_demandeur(
                $demandeur_type, $demandeur_valeurs, $demande_values['om_collectivite']);
            if (isset($_POST[$demandeur_type]) === false) {
                $_POST[$demandeur_type] = array();
            }
            $_POST[$demandeur_type][] = $demandeur_id;
        }

        // création de l'objet demande
        $demande = $this->f->get_inst__om_dbform(array(
            "obj" => "demande",
            "idx" => "]",
        ));

        // Prise en compte des faux POST
        $this->f->set_submitted_value();
        $demande->getPostedValues();

        $this->addToLog(__METHOD__."(): Ajoute la demande", VERBOSE_MODE);
        if ($demande->ajouter($demande_values) === false) {
            throw new RuntimeException(__("Erreur lors de la création de la demande."));
        }
        elseif ($demande->correct === false) {
            throw new RuntimeException(__("Erreur lors de la création de la demande.").' '.
                sprintf(__("Détail: %s"), strip_tags(str_replace('<br />', '. ', $demande->msg))));
        }

        $dossier_instruction_id = $demande->getVal('dossier_instruction');
        $this->addToLog(__METHOD__."(): DI créé: '$dossier_instruction_id'", VERBOSE_MODE);

        // caractères supplémentaires en fin de numéro de dossier autorisé
        // si option des entités
        $extra_chars = '';
        $collectiviteId = $demande_values['om_collectivite'];
        if ($this->f->is_option_om_collectivite_entity_enabled($collectiviteId)) {
            $extra_chars = '([a-zA-Z0-9_-]*)?';
        }

        // vérifie le numéro de dossier obtenu
        $match = array();
        if (! preg_match(
                "|^([A-Z]{2,3})\s{0,1}(\d{6})\s{0,1}(\d{2})\s{0,1}".
                "([[:alnum:]]{5}[A-Z]{0,5}\d{0,2})${extra_chars}$|",
                $dossier_instruction_id, $match)) {
            /*throw new InvalidArgumentException(sprintf(__(
                "Erreur lors de la création de la demande. ".
                "Le format du numéro de dossier créé n'est pas correct ".
                "(ID: '%s')."), $dossier_instruction_id));*/
            $dossier_libelle = $dossier_instruction_id;
        }
        else {
            $dossier_libelle = $match[1].' '.$match[2].' '.$match[3].' '.$match[4];
            if (! empty($extra_chars)) {
                $dossier_libelle .= ' '.$match[5];
            }
        }
        $this->addToLog(__METHOD__."(): Libellé: '$dossier_libelle'", VERBOSE_MODE);

        //
        if (is_array($request_data['external_uids']) === true) {
            //
            foreach ($request_data['external_uids'] as $object => $external_uid) {
                //
                if (in_array($object, array('dossier', 'dossier_consultation', )) === true) {
                    //
                    $inst_lien = $this->f->get_inst__om_dbform(array(
                        "obj" => "lien_id_interne_uid_externe",
                        "idx" => ']',
                    ));
                    if ($inst_lien->is_exists($object, $dossier_instruction_id, $external_uid, $dossier_instruction_id) === false) {
                        //
                        $valF = array(
                            'lien_id_interne_uid_externe' => '',
                            'object' => $object,
                            'object_id' => $dossier_instruction_id,
                            'external_uid' => $external_uid,
                            'dossier' => $dossier_instruction_id,
                        );
                        $add = $inst_lien->ajouter($valF);
                        $message = $inst_lien->msg;
                        if ($add === false) {
                            throw new RuntimeException(__("Erreur lors de la création de la demande.").' '.
                                sprintf(__("Détail: %s"), strip_tags(str_replace('<br />', '. ', $message))));
                        }
                    }
                }
            }
        }

        //
        if (isset($request_data['consultation']) === true
            && is_array($request_data['consultation']) === true
            && count($request_data['consultation']) > 0) {
            //
            $valF = $request_data['consultation'];
            $inst_ce = $this->f->get_inst__om_dbform(array(
                "obj" => "consultation_entrante",
                "idx" => ']',
            ));
            $valF['consultation_entrante'] = '';
            $valF['dossier'] = $dossier_instruction_id;
            $add = $inst_ce->ajouter($valF);
            $message = $inst_lien->msg;
            if ($add === false) {
                throw new RuntimeException(__("Erreur lors de la création de la consultation entrante.").' '.
                    sprintf(__("Détail: %s"), strip_tags(str_replace('<br />', '. ', $message))));
            }
        }

        return array(
            "message" => sprintf(
                __("dossier instruction '%s' créé"),
                $dossier_libelle
            ),
        );
    }

    /**
     * Traite les tâches de type 'add_piece'.
     *
     * @param  $tache  La tâche à traiter
     *
     * @return Array|false  Un tableau contenant le résultat du traitement, false en cas d'erreur
     *
     * @throw InvalidArgumentException  Si le DA existe déjà ou si le numéro dossier est invalide
     * @throw RuntimeException          En cas d'erreur BDD
     */
    protected function add_piece($tache) {

        $this->addToLog(__METHOD__."(): Décode le json", VERBOSE_MODE);
        $request_data = json_decode($tache->getVal('json_payload'), true);
        if (json_last_error() !== JSON_ERROR_NONE) {
            throw new InvalidArgumentException("échec du décodage JSON (".json_last_error_msg().')');
        }

        // vérification de la présence des externals UUIDs
        if (! isset($request_data['external_uids']) || empty($request_data['external_uids'])) {
            throw new InvalidArgumentException(__(
                "Aucune valeur pour l'external_uids"));
        }

        // vérification de la présence du numéro de dossier
        if(! isset($request_data['external_uids']['dossier']) ||
               empty($request_data['external_uids']['dossier'])) {
            throw new InvalidArgumentException(__("L'attribut external_uids.dossier n'est pas présent."));
        }

        // récupération de l'identifiant de collectivité
        $collectiviteId = $this->get_collectivite_id_from_acteur_or_collectivite($request_data, 'external_uids');

        // il faut que le dossier existe pour qu'on puis ajouter la pièce
        $this->addToLog(__METHOD__."(): Vérification de l'existance du dossier", VERBOSE_MODE);

        // Comme la numérotation du dossier peut être différente entre le numéro de dossier openads et le numéro
        // de dossier envoyé par Plat'AU on se base sur l'external uid pour vérifier si le dossier existe

        // On instancie l'objet lien_id_interne_uid_externe
        $inst_lien = $this->f->get_inst__om_dbform(array(
            "obj" => "lien_id_interne_uid_externe",
            "idx" => 0,
        ));

        // instanciation d'un document numérisé "vide"
        $this->addToLog(__METHOD__."(): \tInitialise une instance de 'document_numerise'", VERBOSE_MODE);
        $document_numerise = $this->f->get_inst__om_dbform(array(
            "obj" => "document_numerise",
            "idx" => "]",
        ));

        // retraitement spécifique des données de la nouvelle pièce
        $this->addToLog(__METHOD__."(): Prépare les données de la nouvelle piece", VERBOSE_MODE);
        $attachment_values = $this->prepare_attachment_data(
            $request_data, $document_numerise, $inst_lien, $collectiviteId);

        $this->addToLog(__METHOD__."(): Ajoute la pièce", VERBOSE_MODE);
        $this->addToLog(__METHOD__."(): Valeurs:\n---\n".var_export($attachment_values, true)."\n---\n", VERBOSE_MODE);
        if ($document_numerise->ajouter($attachment_values) === false) {
            throw new RuntimeException(
                __("Erreur lors de la création de la pièce.").' '.
                sprintf(__("Détail: %s"), strip_tags(str_replace('<br />', '. ', $document_numerise->msg))));
        }
        elseif ($document_numerise->correct === false) {
            throw new RuntimeException(__("Erreur lors de la création de la pièce.").' '.
                sprintf(__("Détail: %s"), strip_tags(str_replace('<br />', '. ', $document_numerise->msg))));
        }

        $document_numerise_id = $document_numerise->getVal('document_numerise');
        $this->addToLog(__METHOD__."(): pièce créée: '$document_numerise_id'", VERBOSE_MODE);

        //
        if (is_array($request_data['external_uids']) === true) {
            //
            foreach ($request_data['external_uids'] as $object => $external_uid) {
                //
                if (in_array($object, array('piece', )) === true) {
                    //
                    $inst_lien = $this->f->get_inst__om_dbform(array(
                        "obj" => "lien_id_interne_uid_externe",
                        "idx" => ']',
                    ));
                    if ($inst_lien->is_exists($object, $document_numerise_id, $external_uid, $attachment_values['dossier']) === false) {
                        //
                        $valF = array(
                            'lien_id_interne_uid_externe' => '',
                            'object' => $object,
                            'object_id' => $document_numerise_id,
                            'external_uid' => $external_uid,
                            'dossier' => $attachment_values['dossier'],
                        );
                        $add = $inst_lien->ajouter($valF);
                        $message = $inst_lien->msg;
                        if ($add === false) {
                            throw new RuntimeException(__("Erreur lors de la création de la pièce.").' '.
                                sprintf(__("Détail: %s"), strip_tags(str_replace('<br />', '. ', $message))));
                        }
                    }
                }
            }
        }

        return array(
            "message" => sprintf(
                __("pièce : '%s' créée sur le dossier d'instruction '%s'"),
                $document_numerise_id,
                $attachment_values['dossier']
            ),
        );
    }

     /**
     * Ré-organise les données reçues pour qu'elles puissent être utilisées en tant que 
     * paramètre de la méthode document_numerise::ajouter().
     *
     * @param   array   $request_data   données reçues
     * @param   object  $inst_doc_num   instance de document_numerise
     * @param   object  $inst_lien      instance de lien_id_interne_uid_externe
     * @param    int    $collectiviteId identifiant de la collectivité du dossier de la pièce
     *
     * @return array  données ré-organisées
     */
    protected function prepare_attachment_data(array $request_data, $inst_doc_num, $inst_lien,
                                               int $collectiviteId) {

        $this->addToLog(__METHOD__."(): \tRempli une instance de 'document_numerise'", VERBOSE_MODE);
        $attachment_values = array();

        $this->addToLog(__METHOD__."(): \tRempli un tableau qui contiendra les données ".
            "de la piece", VERBOSE_MODE);
        foreach ($inst_doc_num->champs as $value) {
            $attachment_values[$value] = null;
            if (isset($request_data['document_numerise'][$value])) {
                $attachment_values[$value] = $request_data['document_numerise'][$value];
            }
            if($value == 'document_numerise_type' &&
                    isset($request_data['document_numerise']['document_numerise_type_code'])) {
                $attachment_values["document_numerise_type"] =
                    $request_data['document_numerise']['document_numerise_type_code'];
            }
        }

        // sélectionne la référence externe la plus pertinente
        // - dossier_consultation: si spécifiée
        // - dossier: sinon
        $ref_external_uid = $request_data['external_uids']['dossier'];
        $type_external_uid = 'dossier';
        $err_external_uid = __("Le dossier %s n'existe pas.");
        if(isset($request_data['external_uids']['dossier_consultation']) &&
               ! empty($request_data['external_uids']['dossier_consultation'])) {
            $ref_external_uid = $request_data['external_uids']['dossier_consultation'];
            $type_external_uid = 'dossier_consultation';
            $err_external_uid = __("La consultation %s n'existe pas.");
        }

        // récupération de l'id dossier openADS à partir de l'uid externe
        $attachment_values['dossier'] = $inst_lien->get_id_dossier_from_external_uid(
            $ref_external_uid, $collectiviteId, $type_external_uid);
        if(empty($attachment_values['dossier'])) {
            throw new InvalidArgumentException(sprintf($err_external_uid, $ref_external_uid));
        }

        return $attachment_values;
    }

    /**
     * Ré-organise les données reçues pour qu'elles puissent être utilisées en tant que 
     * paramètre de la méthode demander::ajouter().
     * Les données traitées dans cette méthode ne concernent que les données spécifiques
     * lors d'une nouvelle demande.
     * Celle-ci est complétée par la méthode 'prepare_demande_data()'.
     *
     * @param   Array   $request_data   données reçues
     *
     * @return Array  données ré-organisées
     */
    protected function prepare_new_demande_data(array $request_data) {

        $this->addToLog(__METHOD__."(): \tInitialise une instance de 'demande'", VERBOSE_MODE);
        $demande_values = array();
        $demande = $this->f->get_inst__om_dbform(array(
            "obj" => "demande",
            "idx" => "]",
        ));

        $this->addToLog(__METHOD__."(): \tRempli un tableau qui contiendra les données ".
            "de la demande", VERBOSE_MODE);
        foreach ($demande->champs as $value) {
            $demande_values[$value] = null;
            if (isset($request_data['dossier'][$value])) {
                $demande_values[$value] = $request_data['dossier'][$value];
            }
        }

        // si le DA est spécifié, mais que la version est 0, alors on supprime le DA
        // sinon cela va faire boguer la création du dossier (recherchant le DA inexistant)
        //if(! $this->f->is_option_dossier_saisie_numero_complet_enabled()) {
            if (isset($demande_values['dossier_autorisation']) && (
                    ! isset($demande_values['version']) || $demande_values['version'] == '0')) {
                $demande_values['dossier_autorisation'] = null;
            }
        //}

        $this->addToLog(__METHOD__."(): \tObtient le DAtd à partir de la valeur fournie ".
            "'".$request_data['dossier']["dossier_autorisation_type_detaille_code"]."'",
            VERBOSE_MODE);
        $demande_values['dossier_autorisation_type_detaille'] = (
            $this->get_dossier_autorisation_type_detaille(
                $request_data['dossier']["dossier_autorisation_type_detaille_code"]));

        // si l'option de saisie du numéro complet est activée
        if($this->f->is_option_dossier_saisie_numero_complet_enabled() &&
                isset($request_data['dossier']['dossier'])) {
            $demande_values['num_doss_complet'] = $request_data['dossier']['dossier'];
            $demande_values['num_doss_manuel'] = 'Oui';
            $this->f->addToLog(__METHOD__."(): num_doss_complet = '".$demande_values['num_doss_complet']."'", VERBOSE_MODE);
        }

        return $demande_values;
    }

    /**
     * Ré-organise les données reçues pour qu'elles puissent être utilisées en tant que
     * paramètre de la méthode demander::ajouter().
     * Les données traitées dans cette méthode ne concernent que les données "communes"
     * lors d'une nouvelle demande ou d'une demande sur existant.
     * Celle-ci est complétée par la méthode 'prepare_new_demande_data()'.
     *
     * @param   Array   $request_data   données reçues
     *
     * @return Array  données ré-organisées
     *
     * @throw InvalidArgumentException  En cas de donnée utilisateur invalide ou manquante
     */
    protected function prepare_demande_data(array $request_data, array $demande_values) {

        // numéro de dossier
        $this->ensure_numero_dossier($request_data);

        // références cadastrales
        if (isset($request_data["dossier"]['terrain_references_cadastrales']) &&
                ! empty($request_data["dossier"]['terrain_references_cadastrales'])) {
            // TODO vérifier le format
            $demande_values['terrain_references_cadastrales'] = strtoupper(
                $request_data["dossier"]['terrain_references_cadastrales']);
        }

        // date demande
        $demande_values['date_demande'] = (new DateTime())->format('d/m/Y');
        if (isset($request_data['dossier']['date_demande']) &&
                ! empty($request_data['dossier']['date_demande'])) {
            // TODO vérifier le format
            $demande_values['date_demande'] = $request_data['dossier']['date_demande'];
        }

        // collectivité
        $collectiviteId = $this->get_collectivite_id_from_acteur_or_collectivite($request_data);
        $demande_values['om_collectivite'] = $collectiviteId;

        // commune
        if ($this->f->is_option_dossier_commune_enabled()) {

            // si le code insee n'est pas fourni
            if (! isset($request_data['dossier']['insee']) ||
                    empty($request_data['dossier']['insee'])) {
                throw new InvalidArgumentException(sprintf(__(
                    "Le paramètre '%s' est obligatoire"), 'dossier/insee'));
            }
            $insee = $request_data['dossier']['insee'];
            $this->addToLog(__METHOD__."(): code INSEE '$insee'", VERBOSE_MODE);

            // récupère la commune à partir du code insee
            $commune = $this->get_commune_from_insee($insee);
            if (empty($commune)) {
                throw new InvalidArgumentException(sprintf(__(
                    "Impossible de trouver la commune pour le code INSEE '%s'"), $insee));
            }
            $this->addToLog(__METHOD__."(): commune '$commune'", VERBOSE_MODE);
            $demande_values['commune'] = $commune;
        }

        // demande type
        $demande_values['demande_type'] = $this->get_demande_type(
            $demande_values,
            intval($demande_values['dossier_autorisation_type_detaille']),
            $collectiviteId);

        // version
        $demande_values['version'] = '0';
        if (isset($request_data['dossier']['version']) &&
                ! empty($request_data['dossier']['version'])) {
            $demande_values['version'] = $request_data['dossier']['version'];
        }

        // dépôt électronique
        $demande_values['depot_electronique'] = (
            isset($request_data['dossier']['depot_electronique']) &&
            $request_data['dossier']['depot_electronique'] === 't');

        // parcelle temporaire
        $demande_values['parcelle_temporaire'] = (
            isset($request_data['dossier']['parcelle_temporaire']) &&
            $request_data['dossier']['parcelle_temporaire'] === 't');

        return $demande_values;
    }

    /**
     * Récupère l'identifiant d'une collectivité à partir d'un acteur ou d'un libellé.
     *
     * @param  array  $request_data       donnée utilisateurs reçues
     *
     * @return  int  L'identifiant de la collectivité
     *
     * @throw InvalidArgumentException lorsqu'aucune collectivité ne correspond à un acteur
     * @throw InvalidArgumentException lorsque ni l'acteur ni la collectivité n'ont été spécifiés
     */
    protected function get_collectivite_id_from_acteur_or_collectivite(array $request_data) {
        $collectiviteId = null;
        if (isset($request_data['external_uids']['acteur']) &&
                ! empty($request_data['external_uids']['acteur'])) {
            $acteurId = $request_data['external_uids']['acteur'];
            $collectiviteId = $this->get_collectivite_id_from_acteur($acteurId);
            if (empty($collectiviteId)) {
                throw new InvalidArgumentException(sprintf(__(
                    "Impossible de trouver le service correspondant à l'acteur '%s'"), $acteurId));
            }
            $this->addToLog(__METHOD__."(): acteur: '$acteurId' => collectivite '$collectiviteId'",
                            VERBOSE_MODE);
        }
        elseif (isset($request_data['dossier']['om_collectivite']) &&
                ! empty($request_data['dossier']['om_collectivite'])) {
            $collectiviteId = $this->get_collectivite_id(intval($request_data['dossier']["om_collectivite"]));
            $this->addToLog(__METHOD__."(): collectivite '$collectiviteId'", VERBOSE_MODE);
        }
        if (empty($collectiviteId)) {
            throw new InvalidArgumentException(sprintf(__(
                "Le paramètre %s est obligatoire."), "'acteur' (ou 'om_collectivite')"));
        }
        return $collectiviteId;
    }

    /**
     * Cette methode prend le type de demandeur et ces valeurs pour le créer
     * et renvoie l'identifiant du demandeur créé ou false en cas d'erreur
     *
     * @param  string  $demandeur_type    Le type de demandeur
     * @param  array   $demandeur_valeur  Les valeurs renseignés du demandeur
     * @param  int     $collectiviteId    L'identifiant de la collectivité
     *
     * @return  int  L'identifiant du demandeur
     *
     * @throw  InvalidArgumentException  Lorsque 'om_collectivite' est manquant
     * @throw  RuntimeException          En cas d'échec lors de l'ajout du demandeur
     */
    protected function creation_demandeur(string $demandeur_type, array $demandeur_valeur,
                                          int $collectiviteId) {

        // récupère une instance "vide"
        $demandeur = $this->f->get_inst__om_dbform(array(
            "obj" => "demandeur",
            "idx" => "]",
        ));

        // stocke les valeurs du demandeur, ré-organisées pour qu'elles puissent être fournies
        // en tant qu'argument à la méthode demandeur::ajouter().
        $valAuto = array();

        // initialisation des valeurs à null
        foreach($demandeur->champs as $value) {
            $valAuto[$value] = null;
        }

        // récupération des valeurs
        foreach ($demandeur_valeur as $colonne => $valeur) {
            $valAuto[$colonne] = $valeur;
        }

        // traitement spécifique pour la civilité
        if (isset($demandeur_valeur['particulier_civilite']) &&
                ! empty($demandeur_valeur['particulier_civilite'])) {
            $valAuto['particulier_civilite'] = $this->get_civilite($demandeur_valeur['particulier_civilite']);
        }
        if (isset($demandeur_valeur['personne_morale_civilite']) &&
                ! empty($demandeur_valeur['personne_morale_civilite'])) {
            $valAuto['personne_morale_civilite'] = $this->get_civilite($demandeur_valeur['personne_morale_civilite']);
        }

        // collectivité
        if (empty($collectiviteId)) {
            throw new InvalidArgumentException(sprintf(
                __("Le paramètre %s est obligatoire pour les données du demandeur."),
                "'acteur' (ou 'om_collectivite')"));
        }
        $valAuto['om_collectivite'] = $collectiviteId;

        // traitement spécifique pour la fréquence
        if (isset($demandeur_valeur['frequent']) && ! empty($demandeur_valeur['frequent'])) {
            $valAuto['frequent'] = $demandeur_valeur["frequent"] == 'f';
        }

        // traitement spécifique pour la qualité
        $valAuto['qualite'] = 'particulier';
        if (isset($demandeur_valeur['qualite']) && ! empty($demandeur_valeur['qualite'])) {
            $valAuto['qualite'] = str_replace(' ', '_', $demandeur_valeur['qualite']);
        }

        // traitement spécifique pour le type ==> TODO WHY ???
        $valAuto['type_demandeur'] = str_replace("_principal", "", $demandeur_type);

        // ajout du demandeur en BDD
        if ($demandeur->ajouter($valAuto) === false) {
            throw new RuntimeException(__("Échec lors de l'ajout du demandeur"));
        }

        // renvoie l'identifiant technique en BDD du demandeur créé
        return $demandeur->valF['demandeur'];
    }

    /**
     * Renvoie l'identifiant en BDD d'une collectivité à partir de son libellé ou de son ID.
     * Stocke l'info en cache et l'utilise ensuite si elle existe.
     *
     * @param  string|int  $collectivite  Libellé ou ID de la collectivité
     *
     * @return  int  L'identifiant de la collectivité en BDD
     */
    protected function get_collectivite_id(string $collectivite) {
        if (! isset($this->cacheCollectivites[$collectivite])) {
            $om_collectivite = $this->f->getSingleSqlValue(
                'om_collectivite', 'om_collectivite', 'om_collectivite.libelle', $collectivite);
            $this->cacheCollectivites[$collectivite] = $om_collectivite;
        }
        return $this->cacheCollectivites[$collectivite];
    }

    /**
     * Renvoi l'identifiant d'une collectivité à partir de la valeur de l'acteur (om_parametre).
     *
     * @param  $acteurId  string  L'identifiant de l'acteur (valeur de om_parametre)
     *
     * @return int|null  L'identifiant de la collectivité correspondante, ou null si non trouvée
     *
     * @throw  RuntimeException   En cas d'erreur BDD
     */
    protected function get_collectivite_id_from_acteur(string $acteurId) {
        $om_collectivite = null;
        foreach(array(
            'acteur_service_consulte',
            'acteur_guichet_unique',
            'acteur_service_instructeur',
            'acteur_autorite_competente'
        ) as $acteur_key) {
            $om_collectivite = $this->f->db->getOne(sprintf("
                SELECT
                    om_collectivite
                FROM
                    ".DB_PREFIXE."om_parametre
                WHERE
                    libelle = '%s'
                    AND valeur = '%s'
                ",
                "platau_$acteur_key", $this->f->db->escapeSimple($acteurId)));
            if ($this->f->isDatabaseError($om_collectivite, true)) {
                throw new RuntimeException(sprintf(
                    __("Échec à l'exécution de la requête SQL de sélection d'un service ".
                       "pour l'acteur '%s'"), $acteurId));
            }
            if (! empty($om_collectivite)) {
                break;
            }
        }
        return $om_collectivite;
    }

    /**
     * Renvoi le code INSEE d'une collectivité.
     *
     * @param  $collectiviteId  int  L'identifiant de la collectivite
     *
     * @return int|null  Le code INSEE de la collectivité, ou null si non trouvé
     *
     * @throw  RuntimeException   En cas d'erreur BDD
     */
    protected function get_code_insee_for_collectivite(int $collectiviteId) {
        $code_insee = $this->f->db->getOne(sprintf("
            SELECT
                valeur
            FROM
                ".DB_PREFIXE."om_parametre
            WHERE
                libelle = '%s'
                AND om_collectivie = '%d'
            ",
            'insee', $collectiviteId));
        if ($this->f->isDatabaseError($code_insee, true)) {
            throw new RuntimeException(sprintf(
                __("Échec à l'exécution de la requête SQL de sélection du code INSEE ".
                   "de la collectivité '%s'"), $collectiviteId));
        }
        return $code_insee;
    }

    /**
     * Renvoi le code commune à partir d'un code INSEE
     *
     * @param  $insee  int  Le code INSEE
     *
     * @return string|null  Le code de la commune, ou null si non trouvé
     *
     * @throw  RuntimeException   En cas d'erreur BDD
     */
    protected function get_commune_from_insee(string $insee) {
        $today = (new Datetime())->format('Y-m-d');
        $communeId = $this->f->db->getOne(sprintf("
            SELECT
                commune
            FROM
                ".DB_PREFIXE."commune
            WHERE
                com = '%s'
                AND (
                    om_validite_debut IS NULL
                    OR om_validite_debut <= TO_DATE('%s', 'YYYY-MM-DD')
                )
                AND (
                    commune.om_validite_fin IS NULL
                    OR om_validite_fin > TO_DATE('%s', 'YYYY-MM-DD')
                )
            ORDER BY
                om_validite_fin DESC NULLS FIRST,
                om_validite_debut DESC NULLS FIRST
            LIMIT 1
            ",
            $insee, $today, $today));
        if ($this->f->isDatabaseError($communeId, true)) {
            throw new RuntimeException(sprintf(
                __("Échec à l'exécution de la requête SQL de sélection d'idenfiant commune ".
                   "à partir du code INSEE '%s'"), $insee));
        }
        return $communeId;
    }

    /**
     * Renvoie l'identifiant en BDD d'une civilité à partir de son libellé ou de son ID.
     *
     * @param  string|int  $civilite  Libellé ou ID de la civilité
     *
     * @return  int  L'identifiant de la civilité en BDD
     */
    protected function get_civilite(string $civilite) {
        return $this->f->getSingleSqlValue(
            'civilite', 'civilite', 'civilite.libelle', $civilite);
    }

    /**
     * Vérifie que le numéro de dossier est défini et conforme à la réglementation
     *
     * @param  array  Tableau des valeurs courantes de la demande
     *
     * @return array  Tableau contenant les clés 'di' et 'da' avec le numéro de dossier correspondant
     *
     * @throw  InvalidArgumentException  Lorsque une donnée utilisateur est invalide ou manquante
     */
    protected function ensure_numero_dossier(array $demande_values) {
        $num_matches = array('di' => null, 'da' => null);

        // s'il manque la clé 'dossier' alors que l'option
        // 'saisie complète numéro dossier' est activée
        if($this->f->is_option_dossier_saisie_numero_complet_enabled() &&
                (! isset($demande_values['dossier']['dossier']) ||
                    empty($demande_values['dossier']['dossier']))) {
            throw new InvalidArgumentException(sprintf(
                __("Le paramètre '%s' est obligatoire"), 'dossier/dossier'));
        }

        // sinon, si on a la clé 'dossier' qui est bien définie
        elseif(isset($demande_values['dossier']['dossier']) &&
            ! empty($demande_values['dossier']['dossier'])) {

            /*
             * On relache cette contrainte pour le cas ou les DA/DI sont non-règlementaires
             *
            // si le numéro de dossier n'est pas conforme à la numérotation
            $num_matches = $this->f->numerotation_urbanisme($demande_values['dossier']['dossier']);
            if (empty($num_matches['da']) || empty($num_matches['di'])) {
                throw new InvalidArgumentException(sprintf(
                    __("La valeur '%s' du paramètre '%s' n'est pas valide"),
                   $demande_values['dossier']['dossier'], 'dossier/dossier'));
            }*/
        }
        return $num_matches;
    }

    /**
     * [get_datd_values_by_id description]
     * @param  int    $datd_id [description]
     * @return [type]          [description]
     */
    protected function get_datd_values_by_id(int $datd_id) {
        //
        $inst_datd = $this->f->get_inst__om_dbform(array(
            "obj" => "dossier_autorisation_type_detaille",
            "idx" => $datd_id,
        ));
        $val = array();
        $val = array_combine($inst_datd->champs, $inst_datd->val);
        foreach ($val as $key => $value) {
            $val[$key] = strip_tags($value);
        }
        return $val;
    }

    /**
     * Renvoie l'identifiant en BDD d'une demande type à partir de son libellé ou de son ID.
     *
     * @param   array   $demande_values  Tableau des valeurs courantes de la demande
     * @param    int    $datd_id         Identifiant du type de dossier d'autorisation détaillé.
     * @param    int    $collectiviteId  Identifiant de la collectivité courante
     *
     * @return  int  L'identifiant de la demande type en BDD
     *
     * @throw  InvalidArgumentException  Lorsque le paramètrage des types de demande n'est pas défini
     */
    protected function get_demande_type(array $demande_values, int $datd_id, int $collectiviteId) {

        // nom du paramèrte permettant de récupérer le type de demande
        $type_demande_param = 'platau_type_demande_initial';

        // si on a la clé 'dossier' qui est bien définie
        if(isset($demande_values['dossier']['dossier']) &&
            ! empty($demande_values['dossier']['dossier'])) {

            // récupère le suffixe du numéro de dossier
            $matches = array();
            if (preg_match('([A-Z])[0-9]\+$', $demande_values['dossier']['dossier'], $matches)) {

                // en fonction du suffixe on définit le nom du paramètre du type de demande
                switch($matches[1]) {
                    case 'P': break ;
                    case 'M': $type_demande_param = 'platau_type_demande_modificatif'; break ;
                    case 'T': $type_demande_param = 'platau_type_demande_transfert'; break ;
                }
            }
        }

        // Complète le libellé du paramètre à récupérer avec le code du type de dossier
        // d'autorisation détaillé
        $get_datd_values_by_id = array();
        $get_datd_values_by_id = $this->get_datd_values_by_id($datd_id);
        $datd_code = $get_datd_values_by_id['code'];
        $type_demande_param = sprintf('%s_%s', $type_demande_param, $datd_code);

        //
        $param_collectivite = $this->f->getCollectivite($collectiviteId);
        $type_demande_code = null;
        if (is_array($param_collectivite) && isset($param_collectivite[$type_demande_param])) {
            $type_demande_code = $param_collectivite[$type_demande_param];
        }
        if (empty($type_demande_code)) {
            throw new InvalidArgumentException(sprintf(
                __("Le paramètre '%s' n'est pas défini pour la collectivité/le service dont l'identifiant est %d"),
                $type_demande_param, $param_collectivite['om_collectivite_idx']));
        }

        // récupère le type de demande à partir du code du type de demande
        return $this->f->getSingleSqlValue(
            'demande_type', 'demande_type', 'demande_type.code', $type_demande_code,
            'demande_type', 'demande_type.dossier_autorisation_type_detaille', strval($datd_id));
    }

    /**
     * Renvoie l'identifiant en BDD du DAtd à partir de son code.
     *
     * @param  string  $datd_code  Code du type de dossier d'autorisation detaillé
     *
     * @return  int  L'identifiant du DAtd en BDD
     */
    protected function get_dossier_autorisation_type_detaille(string $datd_code) {
        return $this->f->getSingleSqlValue(
            'dossier_autorisation_type_detaille', 'dossier_autorisation_type_detaille',
            'dossier_autorisation_type_detaille.code', $datd_code);
    }
}