/**
 * Fonctions utilisées par le formulaire MEC, ce script est invoqué par form.js
 * L'utilisation des calendriers impose aussi l'utilisation de calendar.js et calendar.css
 * L'utilisation de la completion impose l'utilisation de completionMEC.js et completionMEC.css
 *
 * Encapsulation de variables locales (privées).
 */
(function() {
	// Raccourci vers window
	var WIN = this,
			// Raccourci vers document
			DOC = WIN.document,
			// Raccourci vers window.ev
			EASY = WIN.ev,
			// Raccourci vers window.ev.log
			LOG = EASY && EASY.log,
			// Raccourci vers window.ev.dom
			DOM = EASY && EASY.dom,
			// Raccourci vers window.ev.forms.util
			FORMS = EASY && EASY.forms && EASY.forms.util,
			// Raccourci vers fonctions utiles
			getElementById = DOM && DOM.element,
			addClass = DOM && DOM.addClass,
			removeClass = DOM && DOM.removeClass,
			setFieldStyleError = FORMS && FORMS.setFieldError,
			resetFieldStyleError = FORMS && FORMS.resetFieldError,
			capTextField = FORMS && FORMS.capTextField,
			isValidDate = WIN.isValidDate,
			createDate = WIN.createDate,
			initMois = WIN.initMois,
			initJours = WIN.initJours,
			initHeures = WIN.initHeures,
			addJavascriptToAttribute = WIN.addJavascriptToAttribute,
			transfertLangURLToElement = WIN.transfertLangURLToElement,
			genericNavigator = WIN.genericNavigator,
			MSIE = WIN.MSIE,
			submitValueSubmitME = WIN.submitValueSubmitME,
			waitValueSubmitME = WIN.waitValueSubmitME,
			/**
	 * Indique si le formulaire MEC a déjà été setté
	 */
			flagInitFormMEC = false,
			allerMEC,
			retourMEC,
			/**
	 * Indique si le formulaire est erronnée.
	 */
			errorMEC,
			errorDestinationsMEC,
			errorDatesMEC,
			JOUR = 24 * 60 * 60 * 1000;

	if (!EASY || !DOM) { throw 'Needs ev.core and ev.dom modules!'; }

	/**
	 * Désactive les options du sélecteur en fonction d'une date de référence.
	 * @param {!{d: !Element, m: !Element}} mySelect groupe de Sélecteurs choisi ("allerMEC" ou "retourMEC").
	 * @param {!Date} myDate Date du selecteur.
	 * @param {!Date} refDate Date minimum.
	 * @param {Boolean} forceClean Optionel, oblige le repositionnement des sélecteurs, utile à l'INIT et pour IE.
	 * @private
	 */
	function limitDateChoices(mySelect,myDate,refDate,forceClean) {
		var now = new Date();
		refDate = refDate || now;
		forceClean = forceClean || false;
		var refY = refDate.getFullYear(), refM = refDate.getMonth(), daysForm, monthsForm;
		if (mySelect === allerMEC || mySelect === retourMEC) {
			daysForm = mySelect.d;
			monthsForm = mySelect.m;
		}
		else {return;}
		//if(mySelect===allerMEC){LOG.info(">limitDateChoicesMEC ALLER");}
		//if(mySelect===retourMEC){LOG.info(">limitDateChoicesMEC RETOUR");}
		//LOG.info(">>limitDateChoicesMEC "+myDate.getDate()+" "+myDate.getMonth());
		var cleanSel = false, // supprime les paramètres "disabled", si aucun élément de la liste ne doit être bloqué.
				currentTestedSelectMonth = 0,
				currentTestedSelectYear = 0,
				currentTestedSelectDay = 0,
				currentSelectedOptionMonth,
				currentSelectedOptionDay,
				i, k;
		if (myDate.getMonth() < 9) {currentSelectedOptionMonth = '0' + (myDate.getMonth() + 1) + '/' + myDate.getFullYear();}
		else {currentSelectedOptionMonth = (myDate.getMonth() + 1) + '/' + myDate.getFullYear();}
		if (myDate.getDate() < 10) {currentSelectedOptionDay = '0' + myDate.getDate();}
		else {currentSelectedOptionDay = myDate.getDate() + '';}
		//LOG.info(">>>limitDateChoicesMEC "+currentSelectedOptionDay+" "+currentSelectedOptionMonth+" ");
		for (i = 0; i < monthsForm.options.length; i++)
		{
			monthsForm.options[i].disabled = false;
			removeClass(monthsForm.options[i], 'disabled');
			if (forceClean && monthsForm.options[i].value === currentSelectedOptionMonth) {
				monthsForm.selectedIndex = i;
				//LOG.info(">>>>limitDateChoicesMEC MONTH ok!"+i);
			}
			currentTestedSelectMonth = parseInt(monthsForm.options[i].value.replace(/\/[0-9]{4}$/, ''), 10) - 1;
			currentTestedSelectYear = parseInt(monthsForm.options[i].value.replace(/^[0-9]{2}\//, ''), 10);
			if (currentTestedSelectYear < refY || currentTestedSelectYear === refY && currentTestedSelectMonth < refM)// CURRENT IT YEAR < REF YEAR || CURRENT IT YEAR = REF YEAR & CURRENT IT MONTH < REF MONTH : on cache le mois inaccessible
			{
				monthsForm.options[i].disabled = true;
				addClass(monthsForm.options[i], 'disabled');
				cleanSel = false;
			}
			else if (currentTestedSelectYear === refY && myDate.getFullYear() === refY)// CURRENTYEARSelect = REFYEAR, and ,MYYEAR = REFYEAR
			{
				if (currentTestedSelectMonth === myDate.getMonth() && currentTestedSelectMonth === refM)// CURRENTMONTHSelect == MYMONTH, and ,CURRENTMONTHSelect == REFMONTH
				{
					for (k = 0; k < daysForm.options.length; k++)
					{
						daysForm.options[k].disabled = false;
						removeClass(daysForm.options[k], 'disabled');
						currentTestedSelectDay = parseInt(daysForm.options[k].value, 10);
						if (forceClean && daysForm.options[k].value === currentSelectedOptionDay) {
							daysForm.selectedIndex = k;
							//LOG.info(">>>>>limitDateChoicesMEC DAY ok!"+i);
						}
						if (currentTestedSelectDay === now.getDate() && currentTestedSelectDay <= refDate.getDate() || currentTestedSelectDay < refDate.getDate())// J-0 si RefDate==now, sinon J-1 meme.
						{
							daysForm.options[k].disabled = true;
							addClass(daysForm.options[k], 'disabled');
						}
						cleanSel = true;
					}
				}
			}
		}
		if (!cleanSel)
		{
			for (i = 0; i < daysForm.options.length; i++)
			{
				if (forceClean && daysForm.options[i].value === currentSelectedOptionDay) {
					daysForm.selectedIndex = i;
					//LOG.info(">>>>>limitDateChoicesMEC DAY ok!"+i);
				}
				daysForm.options[i].disabled = false;
				removeClass(daysForm.options[i], 'disabled');
			}
		}
	}
	/**
	 * Initialise les dates par défaut en utilisant l'horloge du client, la règle est la suivante pour la date aller: c'est le
	 * prochain vendredi jusqu'au mercredi, et le vendredi en 8 à partir du jeudi. La date retour est le vendredi suivant
	 * la date aller.
	 * On faire abstraction des dates par défaut précédentes et fixer les dates aller et retour en les passant en paramètre
	 * au format jj/mm/aaaa
	 *
	 * @param {string=} dateDepartText date aller sous forme de texte (optionnelle ; par défaut new Date()).
	 * @param {string=} dateReturnText date retour (optionnelle).
	 **/
	function initDates(dateDepartText,dateReturnText) {
		//LOG.info("FORM MEC initDates Depart:"+dateDepartText+", Return:"+dateReturnText);
		var jourMECAller,
				moisMECAller,
				jourMECRetour,
				moisMECRetour,
				jourAller,
				moisAller,
				anneeAller,
				jourRetour,
				moisRetour,
				anneeRetour,
				dateAller,
				dateRetour;
		jourMECAller = getElementById('jourDebutMEC');
		moisMECAller = getElementById('moisDebutMEC');
		jourMECRetour = getElementById('jourFinMEC');
		moisMECRetour = getElementById('moisFinMEC');
		if (!(jourMECAller && moisMECAller && jourMECRetour && moisMECRetour)) {return;}

		/*Gestion du delta*/
		var now = new Date(),
				day = now.getDay(),
				delta = 5 - day;
		if (delta <= 1) {delta += 7;}

		/* -------------------------------- */
		/* ALLER */
		if (dateDepartText && dateDepartText.match(/[0-9]{1,2}\/[0-9]{1,2}\/[0-9]{4}/)) {
			jourAller = dateDepartText.replace(/\/[0-9]{1,2}\/[0-9]{4}$/, '');
			moisAller = dateDepartText.replace(/^[0-9]{1,2}\/|\/[0-9]{4}$/g, '');
			anneeAller = dateDepartText.replace(/[0-9]{1,2}\//g, '');
			dateAller = new Date(parseInt(anneeAller, 10), parseInt(moisAller, 10) - 1, parseInt(jourAller, 10));
		}
		else {
			dateAller = new Date();
			dateAller.setTime(now.getTime() + delta * JOUR);
			jourAller = '' + dateAller.getDate();
			if (dateAller.getDate() < 10) {jourAller = '0' + dateAller.getDate();}
			moisAller = '' + (dateAller.getMonth() + 1);
			if (dateAller.getMonth() < 9) {moisAller = '0' + (dateAller.getMonth() + 1);}
			moisAller += '/' + dateAller.getFullYear();
		}
		jourMECAller.value = jourAller;
		moisMECAller.value = moisAller;
		allerMEC = {d: jourMECAller, m: moisMECAller};
		limitDateChoices(allerMEC, dateAller, now, true);

		/* -------------------------------- */
		/* DERNIER JOUR POSSIBLE DU FORMULAIRE */

		var lastDayOfFormMEC = jourMECRetour.options[jourMECRetour.options.length - 1].value,
				lastMonthOfFormMEC = moisMECRetour.options[moisMECRetour.options.length - 1].value,
				lMValue = lastMonthOfFormMEC.replace(/\/[0-9]{4}$/g, ''),
				lYValue = lastMonthOfFormMEC.replace(/^[0-9]{1,2}\//g, ''),
				lD = parseInt((lastDayOfFormMEC), 10),
				lM = parseInt((lMValue - 1), 10),
				lY = parseInt(lYValue, 10),
				lastDateOfFormMEC = new Date(lY, lM, lD);

		/* -------------------------------- */
		/* RETOUR */
		if (dateReturnText && dateReturnText.match(/[0-9]{1,2}\/[0-9]{1,2}\/[0-9]{4}/)) {
			jourRetour = dateReturnText.replace(/\/[0-9]{1,2}\/[0-9]{4}$/, '');
			moisRetour = dateReturnText.replace(/^[0-9]{1,2}\/|\/[0-9]{4}$/g, '');
			anneeRetour = dateReturnText.replace(/[0-9]{1,2}\//g, '');
			dateRetour = new Date(parseInt(anneeRetour, 10), parseInt(moisRetour, 10) - 1, parseInt(jourRetour, 10));
		}
		else {
			dateRetour = new Date();
			dateRetour.setTime(dateAller.getTime() + 7 * JOUR);
			while ((lastDateOfFormMEC - dateRetour) < 0) {dateRetour.setTime(dateRetour.getTime() - JOUR);}// Si RETOUR > LASTDATE, on revient en arrière, jusqu'à la date ALLER, s'il le faut.
			jourRetour = '' + dateRetour.getDate();
			if (dateRetour.getDate() < 10) {jourRetour = '0' + dateRetour.getDate();}
			moisRetour = '' + (dateRetour.getMonth() + 1);
			if (dateRetour.getMonth() < 9) {moisRetour = '0' + moisRetour;}
			moisRetour += '/' + dateRetour.getFullYear();
		}
		/* Si la date de retour proposée est supérieur au dernier jour du formulaire, date RETOUR = date ALLER */
		jourMECRetour.value = jourRetour;
		moisMECRetour.value = moisRetour;
		retourMEC = {d: jourMECRetour, m: moisMECRetour};
		limitDateChoices(retourMEC, dateRetour, dateAller, true);
	}
	// Fonctions de compatibilité ancien moteurs (v2)
	WIN.initMECDates = initDates;

	/**
	 * NON UTILISE A L'HEURE ACTUELLE. A UTILISER POUR LE PRESET DES HORAIRES D'ARRIVEE ET DE DEPART
	 * Initialise les horaires de recuperation et de retour du vehicule.
	 * Peut etre appelee soit avec les deux horaires en parametre, soit avec aucun et dans ce cas les valeurs seront initialisees toutes deux a '10:00'
	 *
	 * @param {string=} heureDepartText heure aller sous forme de texte (optionnelle).
	 * @param {string=} heureReturnText heure retour (optionnelle).
	 **/
	function initHorairesAllerRetour(heureDepartText,heureReturnText) {
		var jourMECAller,
				heureMECAller,
				heureMECRetour;
				heureMECAller = getElementById('heureDebutMEC');
		heureMECRetour = getElementById('heureFinMEC');
		if (!(heureMECAller && heureMECRetour)) {return;}

				/* -------------------------------- */
		/* ALLER */
		if (heureDepartText) {
			jourMECAller.value = heureDepartText;
		}else{
			jourMECAller.value = '10:00';
		}

		/* -------------------------------- */
		/* RETOUR */
		if (heureReturnText) {
			heureMECRetour.value = heureReturnText;
		}else{
			heureMECRetour.value = '10:00';
		}
	}
	// Fonctions de compatibilité ancien moteurs (v2)
	WIN.initMECHorairesAllerRetour = initHorairesAllerRetour;

	/**
	 * FIXME Identique à celle de MEV et MEC (à factoriser)
	 * errorDisplay : Affiche la première erreur qui a été détectée.
	 * @param {Array} el : Tableaux des différents ID du champ d'erreur.
	 * @private
	 */
	function errorDisplay(el,errList) {
		var elt, i, cnt = errList.length;
		for (i = 0; i < cnt; ++i) {
			elt = getElementById(errList[i]);
			if (elt) {
				elt.style.display = 'none';
			}
		}
		elt = getElementById(el && el[0]);
		if (elt) {
			elt.style.display = 'block';
		}
	}

	/**
	 * verifyDatesFormMEC : test la validité des champs de dates.
	 * @param {Boolean} isEvent : Définit si l'appel est direct ou provient d'un evenement.
	 * @return {Boolean} "true" si le formulaire est valide.
	 */
	WIN.verifyDatesFormMEC = function(isEvent) {
		/* Permet de déterminer l'élément et la nature de l'évènement */
		var eventTarget = false, currentTarget;
		if (isEvent !== undefined &&
				typeof isEvent !== 'string' &&
				typeof isEvent !== 'boolean') {
			if (!isEvent) {isEvent = WIN.event;}
			if (isEvent.target) {currentTarget = isEvent.target;}
			else if (isEvent.srcElement) {currentTarget = isEvent.srcElement;}
			if (currentTarget && currentTarget.nodeType === 3) {currentTarget = currentTarget.parentNode;}// // Redéfinition de la cible si c'est un noeud texte (cf bug Safari)
			if (currentTarget) {eventTarget = currentTarget.id;}
		}
		else {eventTarget = isEvent || false;}
		//LOG.info("FORM MEC verifyDatesFormMEC()");
		var ADateObj = {d: 'jourDebutMEC', m: 'moisDebutMEC', err: 'errorMECDateDebutErronee'},
				RDateObj = {d: 'jourFinMEC', m: 'moisFinMEC', err: 'errorMECDateFinErronee'},
				reversedDateList = {err: 'errorMECDatesInversees'},
				errorsList = [ADateObj.err, RDateObj.err, reversedDateList.err],
				errorsToDisplay = [], isReverted = false, aller, retour;
		errorDatesMEC = false;
		/**
		 * isValid : test si la date est correctement formatée et si elle est passée.
		 * @param {!string} _d ID selecteur.
		 * @param {!string} _m ID selecteur.
		 * @param {!string} errorEl ID selecteur.
		 * @return {{date: !Date, d: !number, m: !number, y: !number, valid: !boolean}}
		 */
		function isValid(_d,_m,errorEl) {
			var day = parseInt(getElementById(_d).value, 10),
					month = parseInt(getElementById(_m).value.replace(/\/[0-9]{4}$/, ''), 10),
					year = parseInt(getElementById(_m).value.replace(/^[0-9]{2}\//, ''), 10);
			//LOG.info("FORMMEC "+day+"/"+month+"/"+year+" est valide?"+isValidDate(day,month,year));
			if (!isValidDate(day, month, year)) {
				if (!errorDatesMEC) {errorDatesMEC = true;}
				errorsToDisplay.push(errorEl);
				if (day < 10) {day = '0' + day;}
				if (month < 10) {month = '0' + month;}
				return {
					date: createDate(day, month, year),
					d: day,
					m: month,
					y: year,
					valid: false
				};
			}
			if (day < 10) {day = '0' + day;}
			if (month < 10) {month = '0' + month;}
			return {
				date: createDate(day, month, year),
				d: day,
				m: month,
				y: year,
				valid: true
			};
		}
		/**
		 * isDatesReversed : compare les 2 dates : affiche une erreur que pour l'Aller.
		 * @param {!{date: !Date, d: number, m: number, y: number, valid: boolean}} first premier objet date à comparer
		 * @param {!{date: !Date, d: number, m: number, y: number, valid: boolean}} second deuxième objet date à comparer
		 * @param {!string} errorEl : ID selecteur.
		 * @return boolean true si les dates sont inversées.
		 */
		function isDatesReversed(first, second, errorEl) {
			if (first.date.getTime() > second.date.getTime()) {
				//LOG.warn("FORMMEC Les Dates sont inversées");
				errorsToDisplay.push(errorEl);
				if (!errorDatesMEC) {errorDatesMEC = true;}
				return true;
			}
			return false;
		}
		//INIT
		var now;
		errorDisplay(errorsToDisplay, errorsList);
		aller = isValid(ADateObj.d, ADateObj.m, ADateObj.err);
		retour = isValid(RDateObj.d, RDateObj.m, RDateObj.err);
		if (!errorDatesMEC) {errorDatesMEC = (isReverted = isDatesReversed(aller, retour, reversedDateList.err));}
		if (eventTarget === ADateObj.d || eventTarget === ADateObj.m) {
			if (aller.valid && retour.valid && !isReverted && !errorDatesMEC) {
				initDates(aller.d + '/' + aller.m + '/' + aller.y, retour.d + '/' + retour.m + '/' + retour.y);
				errorDatesMEC = false;
			}
			else if (!aller.valid) {
				now = new Date();
				limitDateChoices(allerMEC, aller.date, now.date);
			}
			else if (!retour.valid || isReverted) {
				initDates(aller.d + '/' + aller.m + '/' + aller.y);
				errorDatesMEC = false;
			}
		}
		else if (eventTarget === RDateObj.d || eventTarget === RDateObj.m) {
			if (aller.valid && retour.valid && !isReverted && !errorDatesMEC) {
				initDates(aller.d + '/' + aller.m + '/' + aller.y, retour.d + '/' + retour.m + '/' + retour.y);
				errorDatesMEC = false;
			}
			else if (!retour.valid || isReverted) {
				limitDateChoices(retourMEC, retour.date, aller.date);
			}
		}
		else {
			if (aller.valid && retour.valid && !isReverted && !errorDatesMEC) {
				initDates(aller.d + '/' + aller.m + '/' + aller.y, retour.d + '/' + retour.m + '/' + retour.y);
				errorDatesMEC = false;
			}
			else if (!aller.valid) {
				now = new Date();
				limitDateChoices(allerMEC, aller.date, now.date);
			}
			else if (!retour.valid || isReverted) {
				limitDateChoices(retourMEC, retour.date, aller.date);
			}
		}

		if (isEvent && errorDatesMEC || errorsToDisplay && errorDatesMEC) {
			errorDisplay(errorsToDisplay, errorsList);
		}
		LOG.info('formMEC#verifyDatesFormMEC(' + isEvent + '): end [error=' + errorDatesMEC + ']');
		return errorDatesMEC;
	};
	/**
	 * verifyDestinationFormMEC : test la validité des champs de destination et de voyageurs.
	 * @param {Boolean} isEvent : Définit si l'appel est direct ou provient d'un evenement.
	 * @return {Boolean} "true" si le formulaire est valide.
	 */
	WIN.verifyDestinationsFormMEC = function(isEvent) {
		//LOG.info("FORM MEC verifyDestinationsFormMEC()");
		var CurrentDestObj = 'lieuMEC',
				testDestList = {el: CurrentDestObj, err: 'errorMECLieuVide'},
				curError,
				curInput,
				errorsToDisplay = [];
		// remise a false
		errorDestinationsMEC = false;
		/**
		 * isEmpty : renvoie "false" si le paramètre existe et qu'il a une valeur, sinon "true".
		 * @param {!string} el ID selecteur.
		 * @return {boolean}
		 */
		function isEmpty(el) {
			el = getElementById(el);
			if (el && !el.value) {
				setFieldStyleError(el);
				errorsToDisplay.push(testDestList.err);
				//el.focus();
				errorMEC = true;
				return errorMEC;
			}
			return false;
		}
		//INIT
		errorDisplay(errorsToDisplay, testDestList.err);
		//TEST
		if (getElementById(testDestList.err)) {
			curError = getElementById(testDestList.err);
			curError.style.display = 'none';
		}
		if (getElementById(CurrentDestObj)) {
			curInput = getElementById(CurrentDestObj);
			resetFieldStyleError(curInput);
			capTextField(curInput, 30);
		}
		if (isEvent) {
			if (!errorDestinationsMEC) {errorDestinationsMEC = isEmpty(CurrentDestObj);}
		}
		if (isEvent || errorsToDisplay) {errorDisplay(errorsToDisplay, testDestList.err);}
		return errorDestinationsMEC;
	};

	/**
	 * Cette fonction vérifie la cohérence des données du formulaire MEC et active éventuellement les messages d'erreur.
	 * Cette fonction retourne aussi un booléen qui indique si le formulaire est sans erreur, donc retourne true si aucune
	 * erreur n'est présente, false dans le cas contraire
	 **/
	WIN.verifyFormMEC = function(isEvent) {
		// INIT
		errorMEC = false;
		errorDatesMEC = WIN.verifyDatesFormMEC(isEvent);
		errorDestinationsMEC = WIN.verifyDestinationsFormMEC(isEvent);
		if (errorDestinationsMEC || errorDatesMEC) {errorMEC = true;}
		return !errorMEC;
	};

	/**
	 * Fonction invoquée par initForm() du script form.js
	 **/
	WIN.initFormMEC = function() {
		if (!flagInitFormMEC) {flagInitFormMEC = true;}
		else {return;}
		var formMEC = getElementById('formMEC');
		if (!formMEC) {
			if (LOG && LOG.error) {
				LOG.error("initFormMEC> Can't find 'formMEC' element!");
			}
			return;
		}
		if (genericNavigator.navigator.id == MSIE) {
			addJavascriptToAttribute(formMEC, 'onsubmit', 'cancelIEEvent();submitFormMEC();');
		}
		else {
			addJavascriptToAttribute(formMEC, 'onsubmit', 'submitFormMEC();return false;');
		}

		// Ajout des calendriers dynamiques (si les icones sont présentes)
		var jourDebutMEC = getElementById('jourDebutMEC'),
				moisDebutMEC = getElementById('moisDebutMEC'),
				heureDebutMEC = getElementById('heureDebutMEC'),
				jourFinMEC = getElementById('jourFinMEC'),
				moisFinMEC = getElementById('moisFinMEC'),
				heureFinMEC = getElementById('heureFinMEC'),
				calendrierMECDebutIcon = getElementById('calendrierMECDebutIcon'),
				calendrierMECFinIcon = getElementById('calendrierMECFinIcon'),
				calendrierMECDebut = getElementById('calendrierMECDebut'),
				calendrierMECFin = getElementById('calendrierMECFin'),
				calendarMECdebut, calendarMECFin;

		var formChangeListener = function(e) {
			if (!e) {e = WIN.event;}
			WIN.verifyDatesFormMEC(e);
		};
		var formClickListener = function() {
			calendarMECdebut.hide('cache ALLER');
			calendarMECFin.hide('cache RETOUR');
		};

		initJours(jourDebutMEC);
		initMois(moisDebutMEC);
		initHeures(heureDebutMEC);
		initJours(jourFinMEC);
		initMois(moisFinMEC);
		initHeures(heureFinMEC);
		heureDebutMEC.value = '10:00';
		heureFinMEC.value = '10:00';


		if (jourDebutMEC && moisDebutMEC && calendrierMECDebutIcon && calendrierMECDebut) {
			try {
				calendarMECdebut = new WIN.Calendar(jourDebutMEC, moisDebutMEC, calendrierMECDebut, formChangeListener);
				calendrierMECDebutIcon.onclick = function() {
					calendarMECdebut.clicAction(calendarMECdebut.poolIndex, true);
				};
			}
			catch (e1) {
				if (LOG && LOG.error) {
					LOG.error('initFormMEC> problème de définition du calendrier début MEC : ' + e1);
				}
			}
		}
		if (jourFinMEC && moisFinMEC && calendrierMECFinIcon && calendrierMECFin) {
			try {
				calendarMECFin = new WIN.Calendar(jourFinMEC, moisFinMEC, calendrierMECFin, formChangeListener);
				calendrierMECFinIcon.onclick = function() {
					calendarMECFin.clicAction(calendarMECFin.poolIndex, true);
				};
			}
			catch (e2) {
				if (LOG && LOG.error) {
					LOG.error('initFormMEC> problème de définition du calendrier fin MEC : ' + e2);
				}
			}
		}
		jourDebutMEC.onchange = formChangeListener;
		moisDebutMEC.onchange = formChangeListener;
		jourFinMEC.onchange = formChangeListener;
		moisFinMEC.onchange = formChangeListener;
		jourDebutMEC.onclick = formClickListener;
		moisDebutMEC.onclick = formClickListener;
		jourFinMEC.onclick = formClickListener;
		moisFinMEC.onclick = formClickListener;

		var lieuMEC = getElementById('lieuMEC');
		var adresseCodeMEC = getElementById('adresseCodeMEC');
		var propositionsMEC = getElementById('propositionsMEC');
		var nombrePropositionsCompletionMEC = 12;
		if (lieuMEC && adresseCodeMEC && propositionsMEC) {
			try {
				var compl = new WIN.CompletionMEC(lieuMEC, adresseCodeMEC, propositionsMEC, nombrePropositionsCompletionMEC);
				if (!compl && LOG && LOG.error) {
					LOG.error('initFormMEC> problème de définition de la completion MEC.');
				}
			}
			catch (e3) {
				if (LOG && LOG.error) {
					LOG.error('initFormMEC> error : ' + e3);
				}
			}
		}

		// FIXME [ygally] : support des anciens formulaires utilisant un bouton de validation de type='button'
		var submitMEC = getElementById('submitMEC');
		if (submitMEC && submitMEC.type == 'button') {
			addJavascriptToAttribute(submitMEC, 'onclick', 'submitFormMEC();');
		}

		// Si on a unlieu de retrait, on initialise le champ caché "adresse de retrait" avec son code
		var lieuDataPickUp = WIN.evData.pickUpLieuData;
		if(lieuDataPickUp){
			WIN.initMECAdresseCode(lieuDataPickUp);
		}

		// Si on a une date aller et une date retour, on initialise les selects avec les bonnes dates. Sinon, on met les dates par defaut
		if(WIN.evData.dateAller && WIN.evData.dateRetour){
			initDates(WIN.evData.dateAller, WIN.evData.dateRetour);
		}else{
			initDates();
		}

		// [dzisso] preset de l'heure de la meme maniere que pour la date. Non activee a ce jour pour cause, entre autres, de problemes dans l'adapteur global. Le code reste tout de meme ici a disposition.
//		if(WIN.evData.heureAller && WIN.evData.heureRetour){
//			initHorairesAllerRetour(WIN.evData.heureAller, WIN.evData.dateRetour);
//		}else{
//			initHorairesAllerRetour();
//		}

		WIN.verifyFormMEC(false);

		// [bfoucher] : permet de remettre le bouton de recherche du formulaire dans son état initial dans le cas où la page est rechargée
		var body = DOC.getElementsByTagName('BODY')[0];
		addJavascriptToAttribute(body, 'onunload', 'resetSubmitMECButton');
	};

	/**
	 * Initialise le lieu avec un texte par défaut.
	 **/
	WIN.initMECLieu = function(lieu) {
		if (lieu) {
			getElementById('lieuMEC').value = lieu;
		}
	};

	/**
	 * Initialise le lieu avec un texte par défaut.
	 **/
	WIN.initMECAdresseCode = function(lieu) {
		if (lieu) {
			getElementById('adresseCodeMEC').value = lieu;
		}
	};

	/**
	 * Initialise l'age du conducteur.
	 **/
	WIN.initMECdriverAge = function(driverAge) {
		if (driverAge) {
			getElementById('ageMEC').value = driverAge;
		}
	};

	/**
	 * Cette méthode doit correspondre à la soumission réelle du formulaire.
	 * @param f : formulaire à soumettre
	 * Elle peut être surchargée si besoin.
	 */
	WIN.doSubmitFormMEC = function(f) {
		if (f) {
			try {
				f.submit();
			}catch (e) {
				if (LOG && LOG.error) {
					LOG.error('doSubmitFormMEC> error : ' + e);
				}
			}
		}
	};

	var RE_HOST = new RegExp('www\\.(easyvoyage\\.com||easyviajar.com||easyviaggio\\.com||easyvoyage\\.co\\.uk||easyvoyage\\.de)');

	/**
	 * Cette fonction vérifie la cohérence des données, et le cas échéant soumet le formulaire formMEC
	 * Elle ajoute la classe wait à submitMEC pour permettre l'affichage d'une image de chargement.
	 * MAJ :
	 * Pour un code plus propre, depuis août 2010, les textes insérés dans une image sont proscrits.
	 * On profite donc de la classe wait pour aligner le texte et non plus pour charger une image de chargement.
	 * la fonction dot3 permet l'affichage des trois petits points après le texte "En cours".
	 *
	 * FIXME :
	 * Comme le changement implique de retoucher au CSS des affiliés (1100 form à vérifier/corriger), il a été décidé
	 * de n'executer ce code que dans l'environnement ESV, ce qui exclu les affiliés.
	 * TODO : Il faudra supprimer le test du "window.location.host" et vérifier les affiliations.
	 **/
	WIN.submitFormMEC = function() {
		if (!WIN.verifyFormMEC(true)) { return false; }
		var submitMEC = getElementById('submitMEC');
		addClass(submitMEC, 'wait');
		if (submitMEC.value && RE_HOST.test(WIN.location.host)) {
			EASY.fx.dot3(submitMEC, 'value', waitValueSubmitME);
		}
		errorMEC = false;
		WIN.doSubmitFormMEC(getElementById('formMEC'));
		return true;
	};

	WIN.resetSubmitMECButton = function() {
		var submitMEC = getElementById('submitMEC');
		removeClass(submitMEC, 'wait');
		if (submitMEC.value) {
			if (typeof submitMEC.stopDot3 == 'function') {
				submitMEC.stopDot3(submitValueSubmitME);
			}
			submitMEC.value = submitValueSubmitME;
		}
	};

	WIN.setActionMEC = function(dir) {
		getElementById('formMEC').setAttribute('action', dir);
	};

	WIN.setTargetFormMEC = function(targetForm) {
		getElementById('formMEC').setAttribute('target', targetForm);
	};

	//  WIN.getParamMEC=function (paramMECAller){
	//    var paramVilleDepart, paramVilleArrivee, // par défaut 'undefined'
	//    i, paramMECDepart = paramMECAller; //on defini le nom du parametre de l'url propre a chaque langue
	//    for(i = 0; i < paramUrl.length; i++){
	//      if(paramUrl[i].indexOf(paramMECDepart) >= 0){ //si le parametre paramDepart defini est present
	//        params = paramUrl[i].split("="); //alors divise la chaine dans un tableau avec le separateur =, qui est du coup supprime
	//        paramVilleMECDepart = params[1]; //et on recupere la valeur du parametre
	//      }
	//    }
	//  };

	/**
	 * Cette fonction effectue le préchargement des champs de formulaire du form MEC en fonction
	 * des paramètres d'URL associés.
	 **/
	WIN.readURLMEC = function() {
		var clientIdValue = EASY.tools.getParameter('clientId'), inputs, cnt, i;
		if (clientIdValue) {
			inputs = EASY.dom.tags('input', getElementById('formMEC'));
			cnt = inputs.length;
			for (i = 0; i < cnt; ++i) {
				if (inputs[i].name === 'clientId') {
					inputs[i].value = clientIdValue;
				}
			}
		}

		transfertLangURLToElement([
			{'lang': 'fr_FR', 'param': 'arrivee', 'id': 'lieuMEC', 'id2': 'adresseCodeMEC'},
			{'lang': 'es_ES', 'param': 'destino', 'id': 'lieuMEC', 'id2': 'adresseCodeMEC'},
			{'lang': 'it_IT', 'param': 'destinazione', 'id': 'lieuMEC', 'id2': 'adresseCodeMEC'},
			{'lang': 'en_GB', 'param': 'arrival', 'id': 'lieuMEC', 'id2': 'adresseCodeMEC'},
			{'lang': 'de_DE', 'param': 'ankunft', 'id': 'lieuMEC', 'id2': 'adresseCodeMEC'}
		]);
	};
}()); // exécution fonction anonyme ici