<?php

/**
 * Ce fichier permet de créer une classe utilisée pour stocker les
 * messages sur la pile de RabbitMQ réservée au ERP.
 *
 * @package openfoncier
 */

// inclusion de la librairie php-amqplib
require_once('vendor/autoload.php');
use PhpAmqpLib\Connection\AMQPConnection;
use PhpAmqpLib\Message\AMQPMessage;

(defined("DEBUG") ? "" : define("DEBUG", EXTRA_VERBOSE_MODE));

// pour des besoins de logging il faut setter $_SERVER["REQUEST_URI"]
if (!isset($_SERVER["REQUEST_URI"])) {
    $_SERVER["REQUEST_URI"] = __FILE__;
}

// Si le AMQP_DEBUG est defini a true, les messages DEBUG sont envoyes aux
// stdout ce qui peut etre bien pour deboguer
if (DEBUG > PRODUCTION_MODE) {
    define('AMQP_DEBUG', true);
}


class MessageEnqueuer {

    // message "Demande de completude de dossier PC pour un ERP"
    public static $ERP_DEMANDE_COMPLETUDE_PC = 'erpDemandeCompletudePc';
    // message "ERP Qualifie"
    public static $ERP_QUALIFIE = 'erpQualifie';
    // message "Demande de qualification de dossier PC pour un ERP"
    public static $ERP_DEMANDE_QUALIFICATION_PC = 'erpDemandeQualificationPc';
    // message "Demande d'instruction de dossier PC pour un ERP"
    public static $ERP_DEMANDE_INSTRUCTION_PC = 'erpDemandeInstructionPc';
    // message "Consultation ERP pour conformite"
    public static $ERP_CONSULTATION_CONFORMITE = 'erpConsultationConformite';
    // message "Demande d'ouverture ERP PC"
    public static $ERP_DEMANDE_OUVERTURE_PC = 'erpDemandeOuverturePc';
    // message "Depot de dossier DAT"
    public static $ERP_DEPOT_DOSSIER_DAT = 'erpDepotDossierDat';
    // message "Annulation de la demande"
    public static $ERP_ANNULATION_DEMANDE = 'erpAnnulationDemande';
    // message "Demande d'ouverture ERP DAT"
    public static $ERP_DEMANDE_OUVERTURE_DAT = 'erpDemandeOuvertureDat';
    // message "Decision de conformite effectue"
    public static $ERP_DECISION_CONFORMITE_EFFECTUE = 'erpDecisionConformiteEffectue';
    // message "Arrete d'un dossier PC effectue"
    public static $ERP_ARRETE_PC_EFFECTUE = 'erpArretePcEffectue';
    // message soap d'un arrêté vers référentiel Arrete
    public static $ARRETE_ENVOI = 'arreteEnvoi';
    // message "Ajout de pièce"
    public static $ERP_AJOUT_PIECE = 'erpAjoutPiece';
    
    // variables utilises pour le retour de resultat d'envoi d'un message
    var $BAD_DATA = -2;
    var $OK = 0;
    var $KO = -1;
    var $ERROR_CONNECTION = -3;
    
 
    /**
     * Constructeur
     */
    public function __construct() {
        // include les variables de connexion avec RabbitMQ
        include_once('../dyn/services.inc.php');
        // initialisation des donnees
        $this->ret_array = array();
        $this->ret_array['date'] = date('d/m/Y H:i');
        $this->ret_array['emetteur'] = $_SESSION['login'];
        $this->dossier_instruction = null;
        $this->competence = null;
        $this->contrainte_plu = null;
        $this->consultation = null;
        $this->decision = null;
        $this->reference_cadastrale = null;
        $this->type_piece = null;
        
        // sauvegarde des donnees de la connexion avec RabbitMQ
        // nom de la pile
        $this->queueErp = $ERP_QUEUE;
        $this->queueArrete = $ARRETE_QUEUE;
        $this->loginArrete = $ARRETE_WS_LOGIN;
        $this->passArrete = $ARRETE_WS_PASS;
        $this->host = $RMQ_CONNECTION_HOST;
        $this->port = $RMQ_CONNECTION_PORT;
        $this->user = $RMQ_CONNECTION_USER;
        $this->password = $RMQ_CONNECTION_PASSWORD;
        $this->vhost = $RMQ_CONNECTION_VHOST;
    }
    
    
    /**
     * Appelle pour stocker un message sur la pile d'ERP dans RabbitMQ
     * Precondition: $msg_type est egal a valeur d'une des $ERP_*
     * @param string $method La methode qui sera appellee pour stocker
     * un message sur la pile.
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */
    public function enqueueMessage($method) {
        // si $method existe dans la classe, apelle la
        if (method_exists($this, $method)) {
            return $this->$method();
        }
        // rien a faire
        return $this->KO;
    }
    
    
    /**
     * Met un message sur la pile de RabbitMQ définie dans le paramètre.
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */

    private function enqueueRequest($queue, $type) {
        // encode le tableau a envoyer en format JSON
        $msg_str = json_encode($this->ret_array);
        
        // s'il a eu des erreurs dans l'encodage, indique une erreur
        if ($msg_str === false) {
            return $this->KO;
        }
       
        // un exchange fait le routage des messages vers les piles
        $exchange = 'router'.$type;
        
        try {
            // etablis une connexion avec RabbitMQ instance
            $conn = new AMQPConnection($this->host, $this->port, $this->user,
                                   $this->password, $this->vhost);
        }
        //Si une erreur s'est produite lors de l'initialisation de AMQP 
        catch (Exception $e) {
            logger::instance()->log('class '.get_class().' : method '.
                __FUNCTION__.' - '._('Erreur lors de l\'initialisation de la '.
                'connexion : ').$e->getMessage(), DEBUG_MODE);
            logger::instance()->writeErrorLogToFile();
            return $this->ERROR_CONNECTION;
        }
        // obtient un canal de connexion
        $ch = $conn->channel();
        // si le canal n'est pas disponible retourne une erreur
        if (is_null($ch)) {
            logger::instance()->log('class '.get_class().' : method '.
                __FUNCTION__.' - '._('Le canal de communication n\'a pas pu '.
                                    'etre etabli'), DEBUG_MODE);
            logger::instance()->writeErrorLogToFile();
            return $this->ERROR_CONNECTION;
        }

        // declare une pile (la creer s'il faut)
        $ch->queue_declare($queue, false, true, false, false);
        
        // declare un exchange qui va diriger les messages
        $ch->exchange_declare($exchange, 'direct', false, true, false);
        
        // relier la pile d'ERP au exchange
        $ch->queue_bind($queue, $exchange);
        
        // crees un objet de type AMQPMessage qui contient le message
        $msg = new AMQPMessage($msg_str,
                    array('content_type' => 'text/plain', 'delivery_mode' => 2));
        // empile le message sur l'exchange
        $ch->basic_publish($msg, $exchange);
        
        // ferme le canal
        $ch->close();
        
        // ferme la connexion
        $conn->close();
        
        // log le message qui etait mis sur la pile dans RabbitMQ
        logger::instance()->log("Ajout du message sur pile: ".
                            json_encode($this->ret_array), EXTRA_VERBOSE_MODE);
        
        // retourne succes
        return $this->OK;
    }


    /**
     * Sauvegarde l'identifiant du dossier d'instruction.
     * @param string $id L'identifiant du dossier d'instruction
     */
    public function setDossierInstructionIdentifier($id) {
        $this->dossier_instruction = $id;
    }
    
    
    /**
     * Sauvegarde de l'autorite competente.
     * @param string $competence L'autorite competente
     */
    public function setCompetence($competence) {
        $this->competence = $competence;
        if (is_null($this->competence)) {
            $this->competence = "";
        }
    }
    
    
    /**
     * Sauvegarde de servitude/contrainte_plu
     * @param string $competence La contrainte plu
     */
    public function setContraintePlu($contrainte_plu) {
        $this->contrainte_plu = $contrainte_plu;
        if (is_null($this->contrainte_plu)) {
            $this->contrainte_plu = "";
        }
    }
    
    
    /**
     * Sauvegarde l'identifiant du la consultation.
     * @param string $id L'identifiant de la consultation
     */
    public function setConsultationIdentifier($id) {
        $this->consultation = $id;
    }
    
    
    /**
     * Sauvegarde de la decision (evenement arrete).
     * @param string $decision La decision sur le dossier.
     */
    public function setDecision($decision) {
        $this->decision = $decision;
        if (is_null($this->decision)) {
            $this->decision = "";
        }
    }
    
    
    /**
     * Sauvegarde de la reference cadastrale
     * @param string $ref_cad La reference cadastrale
     */
    public function setReferenceCadastrale($ref_cad) {
        $this->reference_cadastrale = $ref_cad;
        if (is_null($this->reference_cadastrale)) {
            $this->reference_cadastrale = "";
        }
    }

    /**
     * Sauvegarde l'identifiant du dossier d'instruction.
     * @param string $id L'identifiant du dossier d'instruction
     */
    public function setArreteInfo($ws_DA_In) {
        $this->ret_array = $ws_DA_In;
    }

    /**
     * Sauvegarde le type de pièce ajoutée.
     * @param string $type_piece Le type de pièce
     */
    public function setTypePiece($type_piece) {
        $this->type_piece = $type_piece;
        if (is_null($this->type_piece)) {
            $this->type_piece = "";
        }
    }
    
    /**
     * Prepare les donnees pour insertion dans la pile de RabbitMQ
     * @param string $msg_type Le type de message a envoyer
     * @param mixed $contenu_keys Les noms des attributs qui doivent
     * avoir une valeur pour que le message soit envoye
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */
    private function generic($msg_type, $contenu_keys = null) {
        // set le type du message
        $this->ret_array["type"] = $msg_type;
        // verifie que le dossier d'instruction etait set
        if (is_null($this->dossier_instruction)) {
            // manque des donnees obligatoires
            return $this->BAD_DATA;
        }
        // set le date
        $this->ret_array['date'] = date('d/m/Y H:i');
        // set le login d'emetteur
        $this->ret_array['emetteur'] = $_SESSION['login'];
        // set le identifiant du dossier d'instruction
        $this->ret_array['dossier_instruction'] = $this->dossier_instruction;
        
        // si le message doit contenir le clef 'contenu', cree le
        if (!is_null($contenu_keys)) {
            $contenu = array();
            // verifie pour chaque clef qui doit etre present dans le
            // contenu s'il est set et si oui prends sa valeur
            foreach ($contenu_keys as $attrib) {
                // si un clef n'est pas set, on a une erreur, et on
                // retourne une valeur d'erreur des donnees
                if (is_null($this->$attrib)) {
                    return $this->BAD_DATA;
                }
                // stocke le clef => vleur paire
                $contenu[$attrib] = $this->$attrib;
            }
            // set le contenu
            $this->ret_array['contenu'] = $contenu;
        }
        // stocke le message dans la pile de RabbitMQ designe a ERP
        return $this->enqueueRequest($this->queueErp, 'Rest');
    }
    
    
    /**
     * Envoi du message "ERP Qualifie".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */
    private function erpQualifie() {
        $contenu_keys = array('competence',
                            'contrainte_plu',
                            'reference_cadastrale');
        return $this->generic('ERP Qualifié',
                              $contenu_keys);
    }
    

    /**
     * Envoi du message "Demande de completude de dossier PC pour un ERP".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */    
    private function erpDemandeCompletudePc() {
        return $this->generic('Demande de complétude dossier ERP');
    }


    /**
     * Envoi du message "Demande de qualification de dossier PC pour un ERP".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */        
    private function erpDemandeQualificationPc() {
        return $this->generic('Demande de qualification ERP');
    }
  

    /**
     * Envoi du message "Demande d'instruction de dossier PC pour un ERP".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */          
    private function erpDemandeInstructionPc() {
        if (is_null($this->consultation)) {
            return $this->BAD_DATA;
        }
        // set l'identifiant de la consultation
        $this->ret_array['consultation'] = $this->consultation;
        return $this->generic('Demande d\'avis de dossier PC pour un ERP');
    }
    
    
    /**
     * Envoi du message "Arrete d'un dossier PC effectue".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */
    private function erpArretePcEffectue() {
        return $this->generic('Arrêté PC effectué',
                              array('decision'));
    }
    
    
    /**
     * Envoi du message "Consultation ERP pour conformite".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */    
    private function erpConsultationConformite() {
        if (is_null($this->consultation)) {
            return $this->BAD_DATA;
        }
        $this->ret_array['consultation'] = $this->consultation;
        return $this->generic('Consultation ERP pour conformité');
    }
    

    /**
     * Envoi du message "Demande d'ouverture ERP PC".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */
    private function erpDemandeOuverturePc() {
        return $this->generic('Demande d\'ouverture ERP PC');
    }
    

    /**
     * Envoi du message "Depot de dossier DAT".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */    
    private function erpDepotDossierDat() {
        return $this->generic('Dépôt de dossier DAT');
    }
    
    
    /**
     * Envoi du message "Annulation de la demande".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */
    public function erpAnnulationDemande() {
        return $this->generic('Annulation de la demande');
    }
    

    /**
     * Envoi du message "Demande d'ouverture ERP DAT".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */    
    public function erpDemandeOuvertureDat() {
        return $this->generic('Demande d\'ouverture ERP DAT');
    }
    

    /**
     * Envoi du message "Decision de conformite effectue".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */        
    public function erpDecisionConformiteEffectue() {
        return $this->generic('Décision de conformité effectuée');
    }

    /**
     * Vérification pour envoi des données au référentiel arrêté
     **/
    private function arreteEnvoi() {

        // Vérification des champs obligatoires
        if($this->ret_array['ws_da_in_signataire'] == "" OR
           $this->ret_array['ws_da_in_sign_nom'] == "" OR
           $this->ret_array['ws_da_in_sign_prenom'] == "" OR
           $this->ret_array['ws_da_in_sign_qualite'] == "" OR
           $this->ret_array['ws_da_in_dte_redac'] == "" OR
           $this->ret_array['ws_da_in_n_doss_das'] == "" OR
           $this->ret_array['ws_da_in_decision'] == "" ) {
           
           logger::instance()->log('class '.get_class().' : method '.
                __FUNCTION__.' - '._('Variables obligatoires non renseignees'), 
                DEBUG_MODE);
           logger::instance()->writeErrorLogToFile();
           return $this->BAD_DATA;
        }
        // rétablissement de la casse des clés associatives
        $temp['ws_DA_In_Login'] = $this->loginArrete;
        $temp['ws_DA_In_Password'] = $this->passArrete;
        $temp['ws_DA_In_TS'] = date('j/m/Y/h/m/s');
        $temp["ws_DA_In_Signataire"] = $this->ret_array[strtolower("ws_DA_In_Signataire")];
        $temp["ws_DA_In_Sign_Nom"] = $this->ret_array[strtolower("ws_DA_In_Sign_Nom")];
        $temp["ws_DA_In_Sign_Prenom"] = $this->ret_array[strtolower("ws_DA_In_Sign_Prenom")];
        $temp["ws_DA_In_Sign_Qualite"] = $this->ret_array[strtolower("ws_DA_In_Sign_Qualite")];
        $temp["ws_DA_In_Dte_Redac"] = $this->ret_array[strtolower("ws_DA_In_Dte_Redac")];
        $temp["ws_DA_In_lieu_Redac"] = $this->ret_array[strtolower("ws_DA_In_lieu_Redac")];
        $temp["ws_DA_In_N_Doss_DAS"] = $this->ret_array[strtolower("ws_DA_In_N_Doss_DAS")];
        $temp["ws_DA_In_Sigle"] = $this->ret_array[strtolower("ws_DA_In_Sigle")];
        $temp["ws_DA_In_Decision"] = $this->ret_array[strtolower("ws_DA_In_Decision")];
        $temp["ws_DA_In_Dte_Depot_Dem"] = $this->ret_array[strtolower("ws_DA_In_Dte_Depot_Dem")];
        $temp["ws_DA_In_N_Voie"] = $this->ret_array[strtolower("ws_DA_In_N_Voie")];
        $temp["ws_DA_In_Type_Voie"] = $this->ret_array[strtolower("ws_DA_In_Type_Voie")];
        $temp["ws_DA_In_Adresse1"] = $this->ret_array[strtolower("ws_DA_In_Adresse1")];
        $temp["ws_DA_In_Adresse2"] = $this->ret_array[strtolower("ws_DA_In_Adresse2")];
        $temp["ws_DA_In_CP"] = $this->ret_array[strtolower("ws_DA_In_CP")];
        $temp["ws_DA_In_Ville"] = $this->ret_array[strtolower("ws_DA_In_Ville")];
        $temp["ws_DA_In_Nb_Parcelle"] = $this->ret_array[strtolower("ws_DA_In_Nb_Parcelle")]      ;
        $temp["ws_DA_In_Detail_Parcelle"] = $this->ret_array[strtolower("ws_DA_In_Detail_Parcelle")];
        $temp["ws_DA_In_Nature_Trvx"] = $this->ret_array[strtolower("ws_DA_In_Nature_Trvx")];
        $temp["ws_DA_In_Destination_Trvx"] = $this->ret_array[strtolower("ws_DA_In_Destination_Trvx")];
        $temp["ws_DA_In_Type_Dos_Autoris"] = $this->ret_array[strtolower("ws_DA_In_Type_Dos_Autoris")];
        $temp["ws_DA_In_Nom_Petition"] = $this->ret_array[strtolower("ws_DA_In_Nom_Petition")];
        $temp["ws_DA_In_Prenom_Petition"] = $this->ret_array[strtolower("ws_DA_In_Prenom_Petition")];
        $temp["ws_DA_In_Piece_GED"] = $this->ret_array[strtolower("ws_DA_In_Piece_GED")];
        $temp["ws_DA_In_Dte_Signature"] = $this->ret_array[strtolower("ws_DA_In_Dte_Signature")];
        
        // Affectation du tableau avec les bonnes clés
        $this->ret_array = $temp;
        
        return $this->enqueueRequest($this->queueArrete, 'Soap');

    }
    
    /**
     * Envoi du message "Ajout de piece".
     * @return En cas de succes on retourne 0. Si les donnees sont mauvaises,
     * on retourne -2, et s'il y a eu une erreur au niveau de la BD on
     * retourne -1
     */
    private function erpAjoutPiece() {
        return $this->generic(_("Ajout de piece"),
                              array('type_piece'));
    }
}

?>