/**
 * @package webeezy
 * @subpackage webservices
 * @author reservoir34
 * @copyright reservoir34
 * @date 07/08/2008
 */
/**
 * Compteur permettant de déterminer l'id unique de l'objet
 * @var int
 */
var CPT = 1;
/**
 * Tableau des objets ajax
 * @var array
 */
var AJAX_OBJECTS = [];
/**
 * Cette fonction permet d'utiliser l'objet de requete ajax fournis par YAHOO
 *
 * @param string la méthode d'envoi des données (POST ou GET)
 * @param string l'url du fichier à appeler
 *		- si post : url vers le fichier webservice
 *		- si get : url du fichier avec les paramètres en get dans l'url
 * @param string la fonction à rappeler. Par défaut, ce sera doCallback si la fonction vaut ''
 * @param string le format attendu de la réponse
 * @return true;
 */
function doAjaxRequest(/*string*/$_ajaxMethod, /*string*/$_ajaxUrl, /*string*/$_ajaxParams, /*string*/$_callbackFunction, /*string*/$_responseFormat)
{
	displayDebug("doAjaxRequest", { 'method' :$_ajaxMethod, 'ajaxUrl' :$_ajaxUrl, 'ajaxParams' :$_ajaxParams, 'callbackFunction' :$_callbackFunction, 'responseFormat' :$_responseFormat }, false);
	AjaxObject = { response : {}, responseFormat :'', callbackFunction :'', id :1, argument :'', toString : function toString()
	{
		return 'AjaxObject';
	},
	/**
	 * Méthode d'exécution de la requete
	 *
	 * @return bool true
	 */
	startRequest : function startRequest()
	{
		this.addToAjaxObjects(this);
		switch (this.getResponseFormat())
		{
			case 'XML':
				YAHOO.util.Connect.asyncRequest($_ajaxMethod, $_ajaxUrl, { 'success' :eval(this.getCallbackFunction()), 'failure' :eval(this.getCallbackFunction()) }, $_ajaxMethod == 'GET' ? null : $_ajaxParams);
				break;
			default:
				YAHOO.util.Connect.asyncRequest($_ajaxMethod, $_ajaxUrl, { 'success' :AjaxObject.handleResponse, 'failure' :AjaxObject.handleResponse, 'scope' :AjaxObject, 'argument' :this.getId() }, $_ajaxMethod == 'GET' ? null : $_ajaxParams);
				break;
		}
		return displayDebug(this.toString() + '.startRequest', 'Appel de la méthode', false);
	},
	/**
	 * Méthode chargée de récupérer la réponse de la requete AJAX et de dispatcher la réponse selon la vérification de la réponse
	 */
	handleResponse : function handleResponse($_response)
	{
		displayDebug(this.toString() + '.handleResponse', $_response, false);
		/**
		 * S'il y a effectivement une fonction de rappel à appeler, alors on va vérifier la réponse par rapport au format demandé et appeler la fonction de rappela avec la réponse
		 * au format {success:[webServiceResponse/null],failure:[failureResponse/null]}
		 */
		if ($_response.argument)// && !CHECK.isUndefined(AJAX_OBJECTS[$_response.argument]))
		{
			this.setArgument($_response.argument);
			if (this.getCallbackFunction() != '')
			{
				switch (this.getResponseFormat())
				{
					case 'XML':
						AJAX_OBJECTS[this.getArgument()].setResponse($_response);
						break;
					case 'JSON':
						AJAX_OBJECTS[this.getArgument()].setResponse($_response.responseText);
						break;
					default:
						AJAX_OBJECTS[this.getArgument()].setResponse($_response.responseText);
						break;
				}
				var verifyResult = { 'response' :'', 'isError' :false };
				switch (this.getResponseFormat())
				{
					case 'XML':
						verifyResult = verifyXML(AJAX_OBJECTS[this.getArgument()].getResponse());
						var verifyLevel = {};
						verifyLevel.isError = false;
						break;
					case 'JSON':
						verifyResult = verifyJSON(AJAX_OBJECTS[this.getArgument()].getResponse());
						var verifyLevel = CHECK.JSON.parse(verifyResult);
						break;
				}
				if (verifyLevel.isError)
					AJAX_OBJECTS[this.getArgument()].handleFailure(verifyResult);
				else
					AJAX_OBJECTS[this.getArgument()].processSuccess(AJAX_OBJECTS[this.getArgument()].getResponse());
			}
		}
	},
	/**
	 * Méthode de gestion d'une réponse négative
	 *
	 * @return bool false
	 */
	handleFailure : function handleFailure($_verifyResult)
	{
		/**
		 * enregistrement de l'erreur dans le fichier d'erreur
		 */
		saveLog('ERROR', this.toString() + '.handleFailure', $_verifyResult);
		/**
		 * appel de méthode de rappel
		 */
		eval(this.getCallbackFunction() + '({\'success\':null,\'failure\':' + $_verifyResult + '})');
		return !displayDebug(this.toString() + '.handleFailure', { 'verifyResult' :$_verifyResult }, true);
	},
	/**
	 * Méthode de gestion d'une réponse positive
	 *
	 * @return bool true
	 */
	processSuccess : function processSuccess($_response)
	{
		a = this.getResponse();
		eval(this.getCallbackFunction() + '({\'success\':' + this.getResponse() + ',\'failure\':null})');
		return displayDebug(this.toString() + '.processSuccess', 'Fin d\'appel de la méthode', false);
	},
	/**
	 * Méthode de définition de la réponse
	 *
	 * @param object la réponse
	 * @return bool true
	 */
	setResponse : function setResponse($_response)
	{
		this.response = $_response;
		return displayDebug(this.toString() + '.setResponse', $_response, false);
	},
	/**
	 * Méthode de récupération de la réponse
	 *
	 * @return object
	 */
	getResponse : function getResponse()
	{
		return this.response;
	},
	/**
	 * Méthode de définition du format de la réponse attendue
	 *
	 * @param string le format de la réponse
	 * @return bool true
	 */
	setResponseFormat : function setResponseFormat(/*string*/$_responseFormat)
	{
		this.responseFormat = $_responseFormat;
		return displayDebug(this.toString() + '.setResponseFormat', $_responseFormat, false);
	},
	/**
	 * Méthode de récupération ddu format de lé réponse attendue
	 *
	 * @return string
	 */
	getResponseFormat : function getResponseFormat()
	{
		return this.responseFormat;
	},
	/**
	 * Méthode de définition de la fonction de rappel
	 *
	 * @param string la fonction de rappel
	 * @return bool true
	 */
	setCallbackFunction : function setCallbackFunction(/*string*/$_callbackFunction)
	{
		this.callbackFunction = $_callbackFunction;
		return displayDebug(this.toString() + '.setCallbackFunction', $_callbackFunction, false);
	},
	/**
	 * Méthode de récupération de la méthode de rappel
	 *
	 * @return string
	 */
	getCallbackFunction : function getCallbackFunction()
	{
		return this.callbackFunction;
	},
	/**
	 * Méthode de définition de l'id unique de l'objet
	 *
	 * @param int
	 * @return bool true
	 */
	setId : function setId(/*int*/$_id)
	{
		this.id = $_id;
		return displayDebug(this.toString() + '.setId', $_id, false);
	},
	/**
	 * Méthode retournant l'id unique de l'objet
	 *
	 * @return int
	 */
	getId : function getId()
	{
		return this.id;
	},
	/**
	 * Méthode de définition des objets Ajax en cours d'utilisation
	 *
	 * @param AjaxObject
	 * @return bool true
	 */
	setajaxObjects : function setajaxObjects(/*array*/$_ajaxObjects)
	{
		AJAX_OBJECTS = $_ajaxObjects;
		return displayDebug(this.toString() + '.setajaxObjects', $_ajaxObjects, false);
	},
	/**
	 * Méthode de définition des objets Ajax en cours d'utilisation
	 *
	 * @return array ajaxObjects
	 */
	getajaxObjects : function getajaxObjects()
	{
		return AJAX_OBJECTS;
	},
	/**
	 * Méthode 'ajout de l'objet ajax au tableau des objets ajax en cours d'utilisation
	 *
	 * @return object AjaxObject
	 */
	addToAjaxObjects : function addToAjaxObjects(/*AjaxObject*/$_ajaxObject)
	{
		if ($_ajaxObject.toString() == this.toString())
		{
			AJAX_OBJECTS[$_ajaxObject.getId()] = $_ajaxObject;
			return displayDebug(this.toString() + '.addToAjaxObjects', $_ajaxObject, false);
		}
		return !displayDebug(this.toString() + '.addToAjaxObjects', $_ajaxObject, false);
	},
	/** 
	 * Méthode de définition de l'argument renvoyé par l'appel yahoo
	 *
	 * @param int l'argument
	 * @return bool true
	 */
	setArgument : function setArgument(/*int*/$_argument)
	{
		this.argument = $_argument;
		return displayDebug(this.toString() + '.setArgument', $_argument, false);
	},
	/** 
	 * Méthode de récupération de l'argument renvoyé par l'appel yahoo
	 *
	 * @return bool true
	 */
	getArgument : function getArgument()
	{
		return this.argument;
	} };
	/**
	 * Instanciation de l'objet de requetes
	 */
	AjaxObject.setResponseFormat($_responseFormat);
	AjaxObject.setCallbackFunction($_callbackFunction);
	AjaxObject.setId(CPT++);
	/**
	 * Start the transaction.
	 */
	AjaxObject.startRequest();
	return displayDebug('doAjaxRequest', 'Fin de la méthode', false);
}
/**
 * Méthode de vérification de la consistence de la réponse au format XML
 */
function verifyXML($_response)
{
	return response = { 'response' :$_response, 'isError' :false };
};
/**
 * Méthode de vérification de la consistence de la réponse au format JSON
 */
function verifyJSON($_response)
{
	var response = { 'response' :'', 'isError' :false };
	try
	{
		displayDebug("verifyJSON (try)", $_response, false);
		response = '{"response":"Aucune erreur detectee","isError":false}';
		CHECK.JSON.parse($_response);
	}
	catch (e)
	{
		displayDebug("verifyJSON (catch)", $_response, true);
		response = '{"response":"Erreur lors de la vérification de l\'objet de reponse","isError":true}';
		saveLog('EXCEPTION', 'verifyJSON', { 'response' :$_response, 'exception' :e });
	}
	return response;
};
/**
 * Fonction d'enregistrement des logs d'erreurs générées par les requetes ajax
 *
 * @param string le type du log (enresgitrement différent selon le type de log(
 * @param string le context du log (fonction, méthode, objet)
 * @param mixed le contenu du message logguer
 * @return bool true 
 */
function saveLog($_logType, $_context, $_message)
{
	displayDebug('saveLog', { '$_logType' :$_logType, '$_context' :$_context, '$_message' :$_message }, false);
	switch ($_logType)
	{
		case 'EXCEPTION':
			doAjaxRequest('POST', WEBEEZY_LOG_EXCEPTION_URL, "context=" + $_context + "&message=" + encodeURIComponent(CHECK.dump($_message)), '', '', '');
			break;
		case 'ERROR':
			doAjaxRequest('POST', WEBEEZY_LOG_ERROR_URL, "context=" + $_context + "&message=" + encodeURIComponent(CHECK.dump($_message)), '', '', '');
			break;
		default:
			doAjaxRequest('POST', WEBEEZY_LOG_URL, "context=" + $_context + "&message=" + encodeURIComponent(CHECK.dump($_message)), '', '', '');
			break;
	}
	return displayDebug('saveLog', 'Sauvegarde du log terminé', false);
}
/**
 * Gère l'affichage de l'image de chargement Ajax 
 * Visuel : barre de progression non centrée, non modale
 * @param String|HTMLElement	$_target 		élément dans lequel placer l'image
 * @param bool 					$_showLoader	afficher/cacher
 * @return void
 */
function showAjaxLoading($_target, $_showLoader)
{
	var $_target = (isObject($_target)) ? $_target : DOM.get($_target);
	var targetID = ($_target.id == null) ? '0' : $_target.id;
	if (isObject($_target))
	{
		if ($_showLoader)
		{
			if (isObject($_target) && !DOM.get('AjaxLoaderImage_' + $_target))
			{
				var ajaxLoaderImage = document.createElement('IMG');
				ajaxLoaderImage.setAttribute('alt', 'chargement en cours...');
				ajaxLoaderImage.setAttribute('src', WEEZBE_URL + 'images/AjaxLoadBar.gif');
				ajaxLoaderImage.setAttribute('class', 'AjaxLoader');
				ajaxLoaderImage.setAttribute('id', 'AjaxLoaderImage_' + targetID);
				ajaxLoaderImage.setAttribute('style', 'position:absolute;');
				$_target.appendChild(ajaxLoaderImage);
			}
		}
		else
		{
			if (isObject(DOM.get('AjaxLoaderImage_' + targetID)))
			{
				var imgToDelete = DOM.get('AjaxLoaderImage_' + targetID);
				DOM.get('AjaxLoaderImage_' + targetID).parentNode.removeChild(imgToDelete);
			}
		}
	}
}