/**
 * Created by Cap Adresse on 05/11/2014.
 *
 * Pour plus de sécurité
 * On englobe l'application dans une fonction anonyme qui s'execute immédiatement
 * Elle prend en paramètre l'objet jQuery pour pouvoir utiliser le symbole '$' sans risque de conflit
 *
 * @param  {object} $ Objet jQuery permettant ainsi d'éviter les conflits avec l'utilisation du '$'
 * @return {void}
 */
(function($) {

/**
 * Objet contenant les fonctions / variables pour Cap Email
 * @type {object}
 */
cap.email = cap.email || {};



/**
 * Simple chaîne de caractère contenant le numéro de version
 * @type {string}
 */
cap.email.version = '3.0.7';



/**
 * Options par défaut
 * @type {object}
 */
cap.email.defaults = {
    // Gestion des messages d'erreur
    errorMessages: {
        // Pour afficher les messages d'erreur lors de la saisie
        showMessage: true,
        // Positionne le message d'erreur au dessus ou en dessous de l'input text (2 valeurs : 'top' || 'bottom')
        position: 'top'
    },

    // Gestion des messages pour la popup
    popupMessages: {
        // Titre de la popup quand l'email est erroné
        errorTitle: 'Veuillez modifier votre saisie',
        // Message affiché avant le message d'erreur renvoyé par le service web
        errorMessage: "Erreur dans l'adresse email :",
        // Titre de la popup quand l'email est litigieux
        warningTitle: 'Voulez-vous conserver cet email ?',
        // Texte du bouton pour annuler et modifier son email (lorsqu'il est litigieux)
        warningBtnCancel: 'Modifier',
        // Texte du bouton pour valider son email (lorsqqu'il est litigieux)
        warningBtnOk: 'Conserver',
        // Message affiché avant l'email qui a été saisi
        recapMessage: 'Adresse saisie :'
    },

    // Chemin permettant de faire les appels au service web
    path: '',

    // Timeout qu'on autorise au service web avant de considérer qu'il est HS (en millisecondes)
    timeout: 3000,

    // Username pour l'authentification HTTP
    username: 'JBCONCEPT',

    // Mot de passe pour l'authentification HTTP
    password: '892z342zy82Jbbg',

    // Permet d'enregistrer le Code Qualité Email
    cqe_ID: 'code-qualite-email',

    // Les identifiants des champs sont nécessaires pour pouvoir les récupérer via jQuery et activer l'autocomplétion
    // ID de la div qui contiendra le formulaire de l'adresse (si celui-ci est chargé en Ajax)
    divContent_ID: '',

    // ID du champ prénom
    firstName_ID: 'firstname',
    // ID du champ nom
    lastName_ID: 'lastname',
    // ID du champ email
    email_ID: 'email'
};


/**
 * Objet content les noms par défaut des champs
 * @type {object}
 */
cap.email.defaultInputs = {
    // Div qui contiendra le formulaire de l'adresse (si celui-ci est chargé en Ajax)
    divContent: '',

    // Champ Code Qualité Email
    cqe: '',
    // Champ prénom
    firstName: '',
    // Champ nom
    lastName: '',
    // Champ email
    email: ''
};


/**
 * Tableau où seront stockés les différents champs (via jQuery)
 * C'est grâce à ces éléments qu'on pourra activer l'autocomplétion
 * @type {array}
 */
cap.email.inputs = [];



/**
 * Permet d'arrêter les appels Ajax lorsqu'on choisit une proposition
 * @type {boolean}
 */
cap.email.stopCalling = false;

/**
 * Permet de savoir si l'email est ok ou non
 * @type {boolean}
 */
cap.email.validated = false;

/**
 * Permet de savoir si le service ne répond plus
 * @type {boolean}
 */
cap.email.serviceHS = false;

/**
 * Permet de savoir si la fonction CheckMail a déjà été appelée ou non
 * @type {array}
 */
cap.email.called = [false];

/**
 * Permet de savoir s'il y a une faute de syntax dans l'email
 * @type {array}
 */
cap.email.syntaxError = [false];

/**
 * Tableau contenant les différents code qualité
 * Un pour chaque formulaire
 * @type {array}
 */
cap.email.cqe = [''];

/**
 * Tableau contenant les différentes configurations
 * Une pour chaque formulaire différent
 * @type {array}
 */
cap.email.settings = [];

/**
 * Pour savoir sur quel formulaire on se situe
 * @type {integer}
 */
cap.email.instance = 0;

/**
 * Nombre d'email validés
 * Pour pouvoir valider tous les emails s'il y a plusieurs formulaire
 * @type {integer}
 */
cap.email.emailValidated = [true];

/**
 * Nombre de champs email
 * Pour savoir la limite à ne pas dépasser lors de la validation
 * @type {integer}
 */
cap.email.nbInputs = 0;

/**
 * Tableau contenant les emails à valider
 * @type {array}
 */
cap.email.sMails = [];

/**
 * Objet contenant l'email saisi ainsi que l'éventuel message d'erreur
 * @type {array}
 */
cap.email.propChoisie = [];

/**
 * Variable qui contiendra le retour de l'appel à CheckMailSrvWS
 * @type {array}
 */
cap.email.validateData = [];



/**
 * Tableau contenant les propositions à afficher
 * @type {array}
 */
cap.email.propositions = [];

/**
 * Permet de stocker une fonction contenant l'appel Ajax
 * Pour pouvoir l'appeler quand on en a besoin
 * @type {mixed}
 */
cap.email.appelAjax = null;

/**
 * Variable permettant de savoir si une requête Ajax est en cours ou non
 * @type {boolean}
 */
cap.email.inProgress = false;

/**
 * Peut contenir une fonction permettant de mettre en attente une requête Ajax
 * Elle est automatiquement mise à null dès qu'elle a été appelée
 * @type {mixed}
 */
cap.email.waitingCall = null;

/**
 * Peu contenir une fonction qui servira de callback une fois la validation terminée
 * @type {mixed}
 */
cap.email.validationCallback = null;



/**
 * Permet de définir des options par défaut pour l'ensemble des formulaires
 * Ce qui permet d'éviter de définir plusieurs fois des options qui sont identiques à chaque formulaire
 *
 * @param {object} options Options que l'on souhaite redéfinir
 */
cap.email.setDefaultOptions = function( options )
{
    var _this = this;

    options = options || {};

    $.extend(true, _this.defaults, options);
};

/**
 * Initialisation de l'application
 * On récupère les champs du formulaire via leur ID
 *
 * @param  {object} settings Paramètres de l'utilisateur
 * @return {void}
 */
cap.email.init = function( settings )
{
    var _this = this;
    var settings_length = 1;
    var i;

    if (!$.isArray(settings))
    {
        _this.settings.push($.extend(true, _this.defaults, settings));
    }
    else
    {
        settings_length = settings.length;
        $.each(settings, function(index, setting) {
            _this.settings.push($.extend(true, {}, _this.defaults, setting));
        });
    }

    _this.nbInputs = settings_length;

    for (i = 0; i < settings_length; i++)
    {
        // On utilise $.extend pour éviter qu'il n'écrase l'objet defaultInputs
        _this.inputs.push($.extend(true, {}, _this.defaultInputs));

        _this.retrieveInputFields(i);

        if (_this.settings[i].errorMessages.showMessage && _this.inputs[i].email !== '')
        {
            cap.utils.addDivError(_this.inputs[i].email, _this.settings[i].errorMessages.position);
        }

        // Initialisation par défaut
        _this.emailValidated[i] = true;
        _this.called[i] = true;
        _this.syntaxError[i] = false;
        _this.propChoisie[i] = {};
        _this.validateData[i] = {};

        if (_this.inputs[i].cqe !== '')
        {
            _this.cqe[i] = _this.inputs[i].cqe.val();
        }
        else
        {
            _this.cqe[i] = '';
        }
    }

    // Vérification du service web
    _this.checkWebService();
};

/**
 * Permet de récupérer les différents champs via jQuery
 * grâce aux ID qui ont été passés en paramètres lors de l'initialisation
 *
 * @param  {integer} i Instance/champ dans lequel on se trouve
 * @return {void}
 */
cap.email.retrieveInputFields = function( i )
{
    var _this = this;
    var inputs = _this.inputs[i];
    var settings = _this.settings[i];

    $.each(inputs, function(index) {

        if (settings[index+'_ID'] !== '')
        {
            inputs[index] = document.getElementById(settings[index+'_ID']) !== null ? $('[id="'+settings[index+'_ID']+'"]') : '';
        }
    });
};

/**
 * Permet de vérifier que le service web répond
 * On l'appelle dès l'initialisation pour éviter des appels superflus
 *
 * @return {void}
 */
cap.email.checkWebService = function()
{
    var _this = this;
    var instance = _this.instance;
    var settings = _this.settings[instance];

    if (settings.path !== '')
    {
        $.ajax({
            dataType: 'json',
            timeout: settings.timeout,
            url: settings.path,
            beforeSend: function(xhr) {
                xhr.setRequestHeader('Authorization', 'Basic ' + btoa(settings.username + ':' + settings.password));
            },
            data: {
                request: 'SearchMailCivWS',
                sInput: 'sInput',
                sNom: 'sNom',
                sPrenom: 'sPrenom'
            }
        })
        .fail(function(data) {

            if (cap.utils.nonDefini(data.statusText) === 'timeout')
            {
                _this.serviceDown();
            }
        });
    }
};

/**
 * Fonction appelée lorsque le service web ne répond pas
 * Dans ce cas, on valide tout et on réinitialise les codes qualités
 *
 * @return {void}
 */
cap.email.serviceDown = function()
{
    var _this = this;
    var i;

    _this.serviceHS = true;

    for (i = 0; i < _this.nbInputs; i++)
    {
        _this.updateEmailStatus({emailIndex: i, valid: true});
    }

    // On met le code qualité à vide car on ne peut pas traiter correctement l'adresse
    _this.updateEmailQualityCode();
};

/**
 * Permet de réinitialiser toutes les variables
 * Et de vider le(s) champ(s) email.
 *
 * @param {string} formID ID du formulaire qu'on veut réinitialiser
 *                        Si vide ou non renseigné, on vide tous les formulaires
 * @return {void}
 */
cap.email.reset = function( formID )
{
    var _this = this;
    var form_ID = cap.utils.nonDefini(formID);
    var i;
    var inputs;

    // On reconsidère le service web comme étant opérationnel
    _this.serviceHS = false;

    // Réinitialisation des variables relatives aux appels Ajax
    _this.stopCalling = false;
    _this.propositions = [];
    _this.appelAjax = null;
    _this.inProgress = false;
    _this.waitingCall = null;

    // Réinitialisation des variables relatives à la validité des emails
    for (i = 0; i < _this.nbInputs; i++)
    {
        inputs = cap.utils.nonDefini(_this.inputs[i]);

        if (form_ID === inputs.formID || form_ID === '')
        {
            _this.instance = i;
            _this.autocompleteInit();

            _this.updateEmailStatus({emailIndex: i, valid: true});
            _this.called[i] = true;
            _this.syntaxError[i] = false;
            _this.propChoisie[i] = {};
            _this.validateData[i] = {};

            // Réinitialisation du code qualité
            _this.updateEmailQualityCode(i);

            // On vide tous les champs email
            if (cap.utils.nonDefini(inputs.email) !== '')
            {
                // Suppression du message d'erreur
                cap.utils.afficherMessage(inputs.email);
                inputs.email.val('');
            }
        }
    }

};

/**
 * Fonction appelée à chaque caractère saisi dans le champ Email
 *
 * @param  {object} event Touche saisie par l'utilisateur
 * @return {void}
 */
cap.email.search = function( event )
{
    var _this = this;
    var firstname = '';
    var instance = _this.instance;
    var inputs = _this.inputs[instance];
    var lastname = '';
    var settings = _this.settings[instance];
    var touche_autorisee = cap.utils.toucheAutorisee(event);
    var user_input = '';

    // Lancement du traitement uniquement s'il s'agit d'une touche autorisée (voir la fonction pour plus de détails)...
    if (touche_autorisee && !_this.serviceHS)
    {
        _this.stopCalling = false;

        firstname = cap.utils.getInputValue(inputs.firstName);
        lastname = cap.utils.getInputValue(inputs.lastName);
        user_input = cap.utils.getInputValue(inputs.email);

        // Si on repasse ici, c'est qu'on modifie un email qui a été validé
        _this.called[instance] = false;
        _this.validated = false;

        _this.syntaxError[instance] = false;

        _this.updateEmailStatus({emailIndex: instance});

        // On réinitialise le Code Qualité Email
        _this.updateEmailQualityCode(instance);

        if (user_input === '')
        {
            _this.propositions = [];
            _this.autocompleteInit();

            // Suppression du message d'erreur
            if (cap.utils.inputExists(inputs.email))
            {
                cap.utils.afficherMessage(inputs.email);
            }
        }
        else if (settings.path !== '' && !_this.serviceHS)
        {
            _this.appelAjax = function()
            {
                $.ajax({
                    dataType: 'json',
                    timeout: settings.timeout,
                    url: settings.path,
                    beforeSend: function(xhr) {
                        xhr.setRequestHeader('Authorization', 'Basic ' + btoa(settings.username + ':' + settings.password));
                    },
                    data: {
                        request: 'SearchMailCivWS',
                        sInput: user_input,
                        sNom: lastname,
                        sPrenom: firstname
                    }
                })
                .done(function(data) {
                    _this.list(data);
                })
                .fail(function(data) {

                    if (cap.utils.nonDefini(data.statusText) === 'timeout')
                    {
                        _this.serviceDown();
                    }
                });
            };

            if (!_this.inProgress)
            {
                _this.inProgress = true;
                // Appel ajax (via jQuery)
                _this.appelAjax();
            }
            else
            {
                _this.waitingCall = function()
                {
                    _this.inProgress = true;
                    _this.appelAjax();
                };
            }
        }
    }
};

/**
 * Fonction permettant d'afficher la liste des emails retournés par le service web
 * La liste sera affichée sous le champ grâce à jQueryUI
 *
 * @param  {object} response Objet JSON renvoyé par la recherche de l'email
 * @return {void}
 */
cap.email.list = function( response )
{
    var _this = this;
    var email = '';
    var instance = _this.instance;
    var inputs = _this.inputs[instance];
    var jQinput = cap.utils.inputExists(inputs.email) ? inputs.email : '';
    var proposition = {};
    var return_value = parseInt(response.iRet);
    var settings = _this.settings[instance];

    if (!_this.stopCalling)
    {
        // Affichage du message d'erreur
        if (settings.errorMessages.showMessage && jQinput !== '' && return_value > 0)
        {
            _this.syntaxError[instance] = true;
            _this.propChoisie[instance].iRet = return_value;
            _this.propChoisie[instance].sMessage = cap.utils.nonDefini(response.sMessage);

            cap.utils.afficherMessage(jQinput, _this.propChoisie[instance].sMessage, settings.errorMessages.position);
        }
        // Suppression du message d'erreur
        else if (jQinput !== '' && return_value === 0)
        {
            cap.utils.afficherMessage(jQinput);
        }

        _this.propositions = [];

        if (cap.utils.nonDefini(response.Mail) !== '')
        {
            $.each(response.Mail, function(index, value) {
                email = cap.utils.nonDefini(value.sMail);
                proposition = {
                    value: email,
                    label: email,
                    sMail: email
                };

                _this.propositions.push(proposition);
            });
        }

        if (jQinput !== '')
        {
            if (jQinput.autocomplete('instance'))
            {
                jQinput.autocomplete('option', {
                    source: _this.propositions
                }).autocomplete('search', '');
            }
            else
            {
                _this.autocompleteInit();
                jQinput.autocomplete('search', '');
            }

            _this.inProgress = false;

            if (_this.waitingCall)
            {
                _this.waitingCall();
                _this.waitingCall = null;
            }
        }
    }
    else
    {
        _this.inProgress = false;
        _this.waitingCall = null;
        _this.stopCalling = false;
    }
};

/**
 * Fonction appelée lors du choix d'une proposition dans la liste affichée à l'utilisateur
 * Remplis automatiquement le champ avec la sélection choisie
 *
 * @param  {object} sMail Objet correspondant au choix de l'utilisateur
 * @param  {object} event Touche saisie par l'utilisateur
 * @return {boolean}
 */
cap.email.choisirProposition = function( sMail, event )
{
    var _this = this;
    var email_regular_expression = new RegExp('[a-z0-9._-]+@[a-z0-9._-]+', 'gi');
    var instance = _this.instance;
    var inputs = _this.inputs[instance];

    if (cap.utils.nonDefini(event) !== '')
    {
        event.preventDefault();
    }

    // Suppression du message d'erreur
    if (cap.utils.inputExists(inputs.email))
    {
        cap.utils.afficherMessage(inputs.email);
    }

    if (email_regular_expression.test(sMail) && cap.utils.inputExists(inputs.email))
    {
        cap.utils.putFocusOnNextInput(inputs.email);
    }

    cap.utils.updateInputValue(inputs.email, sMail);

    return false;
};

/**
 * Appel de CheckMailSrvWS (pour vérification de l'email)
 *
 * @param  {object}  options          Objet contenant les options de la fonction
 * @param  {integer} options.instance Instance/champ dans lequel on se trouve
 * @param  {string}  options.formID   Identifiant du formulaire dans lequel on se trouve
 * @return {void}
 */
cap.email.check = function( options )
{
    options = options || {};

    var _this = this;
    var instance = cap.utils.isNum(options.instance) ? parseInt(options.instance) : 0;
    var email = cap.utils.nonDefini(_this.sMails[instance]);
    var settings = cap.utils.nonDefini(_this.settings[instance]);

    if (email !== '' && _this.called[instance] && !_this.serviceHS)
    {
        options.data = _this.validateData[instance];
        _this.afficherPopup(options);
    }
    else
    {
        $.ajax({
            dataType: 'json',
            timeout: settings.timeout,
            url: settings.path,
            beforeSend: function(xhr) {
                xhr.setRequestHeader('Authorization', 'Basic ' + btoa(settings.username + ':' + settings.password));
            },
            data: {
                request: 'CheckMailSrvWS',
                sMail: email
            }
        })
        .done(function(data) {

            _this.called[instance] = true;
            _this.validateData[instance] = data;
            options.data = data;

            _this.afficherPopup(options);
        })
        .fail(function(data) {

            if (cap.utils.nonDefini(data.statusText) === 'timeout')
            {
                _this.serviceDown();
                _this.checkMail(instance + 1, cap.utils.nonDefini(options.formID));
            }
        });
    }
};

/**
 * Lance la vérification des emails
 *
 * @param  {string}   formID   ID du formulaire dans lequel on se trouve
 * @param  {function} callback Fonction de callback
 * @return {boolean}
 */
cap.email.validate = function( formID, callback )
{
    if (!cap.utils.isString(formID) || cap.utils.nonDefini(formID) === '')
    {
        throw {
            message: "L'ID du formulaire n'est pas renseigné ou vide"
        };
    }

    var _this = this;
    var current_email_valid_status;

    _this.validationCallback = cap.utils.nonDefini(callback);

    $.each(_this.inputs, function(index, inputs) {
        _this.sMails[index] = cap.utils.getInputValue(inputs.email);

        //current_email_valid_status = false;
      current_email_valid_status = _this.emailValidated[index];

        if (_this.sMails[index] === '' || _this.settings[index].path === '')
        {
            current_email_valid_status = true;
        }

        _this.updateEmailStatus({emailIndex: index, valid: current_email_valid_status});
    });

    _this.validated = (_this.getNbEmailValidated() === _this.nbInputs);

    if (!_this.validated)
    {
        _this.checkMail(0, formID);
    }
    else if (cap.utils.isFunction(_this.validationCallback))
    {
        _this.validationCallback(_this.validated);
    }
};

/**
 * Fonction appelée de manière récursive
 * Elle valide tous les emails qui ont été définis lors de l'initialisation
 *
 * @param  {integer}  index    Entier correspondant au champ/formulaire dans lequel on se trouve
 * @param  {string}   formID   ID du formulaire dans lequel on se trouve
 * @return {void}
 */
cap.email.checkMail = function( index, formID )
{
    var _this = this;
    var i = parseInt(index);
    var email = cap.utils.nonDefini(_this.sMails[i]);
    var form_ID = cap.utils.nonDefini(formID);
    var inputs = cap.utils.nonDefini(_this.inputs[i]);
    var input_form_ID = (inputs !== '') ? cap.utils.nonDefini(inputs.formID) : '';
    var nb_email_validated = _this.getNbEmailValidated();
    // Récupération des paramètres
    var settings = cap.utils.nonDefini(_this.settings[i]);

    // Tous les emails sont validés, on appel la fonction de callback
    if (nb_email_validated === _this.nbInputs)
    {
        _this.validated = true;

        if (cap.utils.isFunction(_this.validationCallback))
        {
            _this.validationCallback(_this.validated);
        }
    }
    // L'email en cours est déjà validé, on passe au suivant
    else if (_this.emailValidated[i])
    {
        _this.checkMail(i + 1, form_ID);
    }
    // L'email est vide ou le service web ne répond plus
    // On considère l'email valide et on passe au suivant
    else if (email === '' || _this.serviceHS)
    {
        if (i < _this.nbInputs)
        {
            _this.updateEmailStatus({emailIndex: i, valid: true});
        }

        _this.checkMail(i + 1, form_ID);
    }
    // Le formulaire passé en paramètre est différent de celui correspondant au champ email en cours
    // On le considère donc comme valide
    else if (input_form_ID !== form_ID && i < _this.nbInputs)
    {
        _this.updateEmailStatus({emailIndex: i, valid: true});
        _this.checkMail(i + 1, form_ID);
    }
    // L'email n'est pas vide mais il y a une erreur de syntaxe
    else if (input_form_ID === form_ID && i < _this.nbInputs && email !== '' && _this.syntaxError[i] && !_this.serviceHS)
    {
        _this.afficherPopup({instance: i, data: _this.propChoisie[i]});
    }
    // L'email n'est pas vide et n'a pas été testé
    else if (input_form_ID === form_ID && i < _this.nbInputs && email !== '' && !_this.serviceHS)
    {
        _this.check({instance: i, formID: form_ID});
    }
};

/**
 * Permet d'afficher une popup à l'utilisateur s'il y a une erreur lors de la validation
 *
 * @param  {object}  options          Objet contenant les ptions de la fonction
 * @param  {object}  options.data     Objet contenant la réponse du service web
 * @param  {string}  options.formID   ID du formulaire que l'on veut valider
 * @param  {integer} options.instance Index du formulaire dans lequel on se trouve
 * @return {void}
 */
cap.email.afficherPopup = function( options )
{
    options = options || {};

    var _this = this;
    var data = cap.utils.nonDefini(options.data);
    var form_ID = cap.utils.nonDefini(options.formID);
    var i = cap.utils.isNum(options.instance) ? parseInt(options.instance) : 0;
    var email = cap.utils.nonDefini(_this.sMails[i]);
    var inputs = cap.utils.nonDefini(_this.inputs[i]);
    var input_form_ID = (inputs !== '') ? cap.utils.nonDefini(inputs.formID) : '';
    var popup_confirme_email;
    var return_value = parseInt(data.iRet);
    // Récupération des paramètres
    var settings = cap.utils.nonDefini(_this.settings[i]);
    // Récupération de l'objet contenant les messages pour la popup
    var settings_popup_messages = cap.utils.nonDefini(settings.popupMessages);
    var dialog_options = {
        closeText: 'X',
        resizable: false,
        autoOpen: false,
        height: 'auto',
        width: 400,
        modal: true,
        draggable: false,
        open: function()
        {
            $('.ui-widget-overlay').bind('click', function() {
                $('#cap-popup-confirme-email').dialog('close');
            });
        }
    };

    // Message bloquant
    if (return_value === 1)
    {
        $('#cap-spn-message').html(cap.utils.nonDefini(settings_popup_messages.errorMessage) + ' ' + cap.utils.nonDefini(data.sMessage));
        $('#cap-spn-adresse-saisie').html(email);
        dialog_options.title = cap.utils.nonDefini(settings_popup_messages.errorTitle);
        dialog_options.buttons = [
            // Permet de modifier l'email
            {
                text: 'Ok',
                class: 'cap-popup-alert__button',
                click: function()
                {
                    $(this).dialog('close');

                    if (inputs.email !== '')
                    {
                        inputs.email.focus();
                    }
                }
            }
        ];

        popup_confirme_email = $('#cap-popup-confirme-email').dialog(dialog_options);
        popup_confirme_email.dialog('open');

        // On repositionne la popup au centre lorsqu'on change la taille de la fenêtre
        $(window).resize(function() {
            popup_confirme_email.dialog('option', 'position', {my: 'center', at: 'center', of: window});
        });
    }
    // Erreur possible dans l'adresse email, on demande à l'utilisateur s'il veut modifier/conserver sa saisie
    else if (return_value === 2)
    {
        $('#cap-spn-message').html(cap.utils.nonDefini(data.sMessage));
        $('#cap-spn-adresse-saisie').html(email);

        _this.updateEmailQualityCode(i, cap.utils.nonDefini(data.sCodeTraitement));

        dialog_options.title = cap.utils.nonDefini(settings_popup_messages.warningTitle);

        dialog_options.buttons = [
            // Permet de modifier l'email
            {
                text: cap.utils.nonDefini(settings_popup_messages.warningBtnCancel),
                class: 'cap-popup-alert__button cap-popup-alert__button-cancel',
                click: function()
                {
                    $(this).dialog('close');

                    if (inputs.email !== '')
                    {
                        inputs.email.focus();
                    }
                }
            },
            // Permet de valider l'email
            {
                text: cap.utils.nonDefini(settings_popup_messages.warningBtnOk),
                class: 'cap-popup-alert__button cap-popup-alert__button-confirm',
                click: function()
                {
                    $(this).dialog('close');

                    _this.updateEmailStatus({emailIndex: i, valid: true});
                    _this.checkMail(i + 1, form_ID);
                }
            }
        ];

        popup_confirme_email = $('#cap-popup-confirme-email').dialog(dialog_options);
        popup_confirme_email.dialog('open');

        // On repositionne la popup au centre lorsqu'on change la taille de la fenêtre
        $(window).resize(function() {
            popup_confirme_email.dialog('option', 'position', {my: 'center', at: 'center', of: window});
        });
    }
    // Si iRet == 0 : L'email est correct
    // Si iRet < 0 : Il y a eu une erreur donc on considère quand même l'email valide
    else if (return_value <= 0)
    {
        _this.updateEmailQualityCode(i, cap.utils.nonDefini(data.sCodeTraitement));

        _this.updateEmailStatus({emailIndex: i, valid: true});
        _this.checkMail(i + 1, form_ID);
    }
};

/**
 * Fonction permettant d'initialiser l'autocomplete de jQueryUI
 * L'initialisation se fait via le tableau cap.email.propositions
 *
 * @return {void}
 */
cap.email.autocompleteInit = function()
{
    var _this = this;
    var instance = _this.instance;
    var inputs = _this.inputs[instance];

    if (cap.utils.inputExists(inputs.email))
    {
        inputs.email.autocomplete({
            // Spécifie la source de données
            // On utilise une fonction pour empêcher jQuery de filtrer les résultats
            source: function(request, response)
            {
                response(_this.propositions);
            },
            // Permet de sélectionner automatiquement la première proposition
            autoFocus: true,
            // Permet d'afficher les propositions même si rien n'est saisi
            minLength: 0,
            // Permet d'annuler le changement du input text lors de la sélection d'une proposition au clavier
            focus: function()
            {
                return false;
            },
            // Action lors de la validation d'un email
            select: function(event, ui)
            {
                /**
                 * On test que la touche 'shift' n'est pas appuyée
                 * Pour empêcher de sélectionner automatiquement la première proposition
                 * Et permettre de remonter les champs input avec 'shift + tab'
                 */
                if (!event.shiftKey)
                {
                    _this.choisirProposition(ui.item.sMail, event);
                }

                return false;
            }
        });
    }
};

/**
 * Permet de mettre à jour le code qualité
 * Si aucun paramètre n'est envoyé, tous les codes qualités sont réinitialisés à vide
 *
 * @param  {integer} instance Entier correspondant au champ/formulaire dans lequel on se trouve
 * @param  {string}  cqe      Code qualité Email
 * @return {void}
 */
cap.email.updateEmailQualityCode = function( instance, cqe )
{
    var _this = this;
    var email_quality_code = cap.utils.nonDefini(cqe);
    var end_loop = _this.nbInputs;
    var i = 0;
    var $input;

    if (cap.utils.isNum(instance) && instance < end_loop)
    {
        i = instance;
        end_loop = instance + 1;
    }

    for (; i < end_loop; i++)
    {
        _this.cqe[i] = email_quality_code;
        $input = cap.utils.nonDefini(_this.inputs[i].cqe);

        cap.utils.updateInputValue($input, _this.cqe[i]);
    }
};

/**
 * Permet de récupérer le nombre d'email qui ont été validés
 *
 * @return {integer} Nombre d'email qui ont été validés
 */
cap.email.getNbEmailValidated = function()
{
    var _this = this;
    var i = 0;
    var nb_email_validated = 0;

    for (; i < _this.nbInputs; i++)
    {
        if (_this.emailValidated[i])
        {
            nb_email_validated++;
        }
    }

    return nb_email_validated;
};

/**
 * Permet de valider ou non un email
 *
 * @param {object}  emailOptions            Options concernant le status de l'email
 * @param {integer} emailOptions.emailIndex Index de l'email qu'on veut valider ou non
 * @param {boolean} emailOptions.valid      Permet de savoir si on valide ou non l'email
 *                                          Si aucune valeur, alors c'est mis à false par défaut
 * @return {void}
 */
cap.email.updateEmailStatus = function( emailOptions )
{
    var _this = this;
    var email_options = emailOptions || {};
    var i = cap.utils.isNum(email_options.emailIndex) ? parseInt(email_options.emailIndex) : 0;
    var valid = cap.utils.isBoolean(email_options.valid) ? email_options.valid : false;

    _this.emailValidated[i] = valid;
};



// Ajout de l'objet dans le DOM
window.cap.email = cap.email;

// Lorsque la page est chargée, on peut capturer l'évènement keyup
$(document).ready(function() {

    var closest_form;

    $.each(cap.email.inputs, function(index, value) {

        $.each(value, function(inputName, inputValue) {

            closest_form = (inputValue !== '') ? inputValue.closest('form') : '';

            if (closest_form.length && closest_form.attr('id') !== '')
            {
                cap.email.inputs[index].formID = (closest_form !== '') ? closest_form.attr('id') : '';
            }
        });

        if (cap.email.inputs[index].divContent !== '')
        {
            // On utilise le keyup sur la div qui contient le formulaire de l'adresse
            // Car celui-ci est chargé dynamiquement en AJAX
            cap.email.inputs[index].divContent.on('keyup', ':input', function(event) {
                // On récupère l'ID de l'input en cours
                var input_ID = $(this).prop('id');

                // On lance la recherche en fonction de l'input sur lequel on est.
                if (input_ID == cap.email.settings[index].email_ID)
                {
                    cap.email.instance = index;
                    cap.email.search(event);
                }
            })
            .on('blur', ':input', function() {
                // On récupère l'ID de l'input en cours
                var input_ID = $(this).prop('id');

                if (input_ID == cap.email.settings[index].email_ID)
                {
                    cap.email.stopCalling = true;
                }
            });
        }
        else if (cap.email.inputs[index].email !== '')
        {
            // Capture de l'évènement keyup sur le champ email
            cap.email.inputs[index].email.on('keyup', function(event) {
                cap.email.instance = index;
                cap.email.search(event);
            })
            .on('blur', function() {
                cap.email.stopCalling = true;
            });
        }

        /**
         * HACK POUR CHROME POUR L'EMPÊCHER D'ACTIVER SON AUTOCOMPLETE
         * EN GROS, ON MET L'ATTRIBUT AUTOCOMPLETE À FALSE
         * CAR CHROME IGNORE TOTALEMENT LA VALEUR OFF
         */
        cap.utils.changeAutocompleteAttribute(cap.email.inputs[index]);
    });

    // Creation de la div qui contiendra la popup de confirmation pour l'email
    var email_popup_html = '' +
        '<div class="cap-alert-popup" id="cap-popup-confirme-email" title="" style="display: none">' +
        '  <span class="cap-alert-popup-title" id="cap-spn-message"></span><br />' +
        '  '+ cap.email.defaults.popupMessages.recapMessage + ' <span id="cap-spn-adresse-saisie"></span><br />' +
        '</div>';

    // Ajout de la div à l'élément <body>
    $('body').append(email_popup_html);
});

})(jQuery);