/********************************************************************************
 COPYRIGHT(C):  IAAA-2003
 PROYECTO:      Búsquedas
 ARCHIVO:       TextDateIntervalCriterionQueryBuilder.js
 CREACION:      15-06-05 claborda
 ULTIMA MODIF:
 LENGUAJE:      Javascript
 PLATAFORMA:    Windows 95-NT, debe funcionar en todas
 REQUERIM.:
 DESCRIPCION:   Criterio de búsqueda por intervalo de tiempo (fechas), en zona 
 		común de memoria para todos los JSP.
 HISTORIA:      15-06-05 claborda Creación.
*******************************************************************************/


 /**
  *   Constructor.
  * @param name nombre.
  * @return nueva instancia de la clase.
  */
 function TextDateIntervalCriterionQueryBuilder(name, config, contexto, containingDocument, myPath)
 {
	this._name = name;
	
	// contexto de la aplicación. Obtenido del fichero web.xml
	this._contexto = contexto;
	
	//config: Array de etiquetas del criterio Name.
	this._config = config;
	
	this._containingDocument = containingDocument;
 	this._mypath = myPath;
	
	this._dateStart = new TextFieldCriterionQueryBuilder("_dateStart", this._config._startDate, this._contexto, null, null);
	this._dateEnd = new TextFieldCriterionQueryBuilder("_dateEnd", this._config._endDate, this._contexto, null, null);
	
	this._dateStart.addInputValidator(this.checkTextDate);
	this._dateStart.addInputValidator(this.isValidDate);
	this._dateEnd.addInputValidator(this.checkTextDate);
	this._dateEnd.addInputValidator(this.isValidDate);
	
	this._DATE_INTERVAL_QUERY_FIELDS = null;
	this._avoFilterBuilder = new AVOFilterBuilder(name + "_avoFB");
	this.loadDateIntervalCriterionQueryFields();
	this._avoFilterBuilder.setAttributes(this._DATE_INTERVAL_CRITERION_QUERY_FIELDS);
	this._avoFilterBuilder.setInnerOperator("AND");
	this._undefinedValue = null;
	
	this._filterBuilder = new FilterBuilderToolkitObject();
    
	this._title = this._config._title;
	this._ticketFrom = this._config._from
	this._ticketTo = this._config._to
	this._language = this._config._language;
	this._tooltip = this._config._formatting;
	
	this._inputValidators =  new Array();

	this.addInputValidator(this.isValidDateInterval);
	
	// Variables para guardar las fechas a imprimir en 'stateString'
	this._userDateStart = "";
	this._userDateEnd = "";
 }

 TextDateIntervalCriterionQueryBuilder.prototype.setContainingDocument = function(document) {
 	this._containingDocument = document;
 	
 	this._dateStart.setContainingDocument(this._containingDocument);
 	this._dateEnd.setContainingDocument(this._containingDocument);
 }
 
 TextDateIntervalCriterionQueryBuilder.prototype.setPath = function(path) {
 	this._mypath = path;
 	
 	var thePath2 = new Array();
 	for (i=0; i<this._mypath.length; i++) {
 		thePath2.push(this._mypath[i]);
 	}
	thePath2.push(this._name);
 	
  	this._dateStart.setPath(thePath2);
  	this._dateEnd.setPath(thePath2);
 }

 TextDateIntervalCriterionQueryBuilder.prototype.loadDateIntervalCriterionQueryFields = function()
 {
	this._DATE_INTERVAL_CRITERION_QUERY_FIELDS = new Array(this._config._queryFields.length);
 	for (i=0; i<this._config._queryFields.length; i++) 
 	{
    		this._DATE_INTERVAL_CRITERION_QUERY_FIELDS[i] = this._config._queryFields[i];
    	}
 }

 /**
  *    Método para generar una consulta por todos los campos de this._searchingAttributes
  *  a partir del texto introducido por el usuario.
  */
 TextDateIntervalCriterionQueryBuilder.prototype.getQueryTree = function(queryStart, queryEnd)
 {
 	var queryTreeArrayAux = new Array();
 	
	queryTreeArrayAux[0] = queryStart;
	queryTreeArrayAux[1] = queryEnd;

	return this._filterBuilder.logicalMultipleUnification(queryTreeArrayAux, "AND");
 }

 TextDateIntervalCriterionQueryBuilder.prototype.getQueryTreeFromGUI = function()
 {
	var queryDateStart = "";
	var queryDateEnd = "";
	
	this._userDateStart = this._dateStart.getState();
	this._userDateEnd = this._dateEnd.getState();

	queryDateStart = this._dateStart.getQueryTreeFromGUI();
	queryDateEnd = this._dateEnd.getQueryTreeFromGUI();

	if ((queryDateStart == "") || (queryDateEnd == "")) {
		 return ("");
	}
	else {
		return this.getQueryTree(queryDateStart, queryDateEnd);
	}
 }

 TextDateIntervalCriterionQueryBuilder.prototype.getGUI = function()
 {
	var code = "";
    
    	code = '<p align="center" style="margin-left: 5">' + '\n';
	code = code + ' <table align="center">' + '\n';
	code = code + '	   <tr>' + '\n';
    	code = code + '	       <td>' + '\n';
    	code = code + '	       </td>' + '\n';
    	code = code + '	       <td>' + '\n';
    	code = code + '	           <p class="intro" style="font-size:8pt">' + this._tooltip + '</p>' + '\n';
    	code = code + '	       </td>' + '\n';
    	code = code + '	   </tr>' + '\n';
	code = code + '    <tr>';
	code = code + '        <td>';
	code = code + '            <p class="intro" style="text-align:left;font-size:12px">' + this._ticketFrom + ':\n</p>';
	code = code + '        </td>';
	code = code + '        <td>';
	code = code + this._dateStart.getGUI();
	code = code + '        </td>';
	code = code + '    </tr>';
	code = code + '    <tr>';
	code = code + '        <td>';
	code = code + '            <p class="intro" style="text-align:left;font-size:12px">' + this._ticketTo + ':</p>\n';
	code = code + '        </td>';
	code = code + '        <td>';
	code = code + this._dateEnd.getGUI();
	code = code + '        </td>';
	code = code + '    </tr>';
	code = code + ' </table>' + '\n';
	code = code + '</p>' + '\n';

    	return code;
 }

 /*TextDateIntervalCriterionQueryBuilder.prototype.onChangeHandler = function()
 {
 	for (var i = 0; i < this._onChangeEventListeners.length; i++) {
 		var eventListener = this._onChangeEventListeners[i];
 		var listener = eventListener.listener;
 		var target = eventListener.target;
 		listener.call(target);
 	}
 }
 
 
 TextDateIntervalCriterionQueryBuilder.prototype.addOnChangeEventListener = function(listener, target)
 {
 	var eventListener = new Array();
 	eventListener.listener = listener;
 	eventListener.target = target;
 	this._onChangeEventListeners.push(eventListener);
 }
 
 TextDateIntervalCriterionQueryBuilder.prototype.onKeyDownHandler = function()
 {
 	for (var i = 0; i < this._onKeyDownEventListeners.length; i++) {
 		var eventListener = this._onKeyDownEventListeners[i];
 		var listener = eventListener.listener;
 		var target = eventListener.target;
 		listener.call(target);
 	}
 }
 
 TextDateIntervalCriterionQueryBuilder.prototype.addOnKeyDownEventListener = function(listener, target)
 {
 	var eventListener = new Array();
 	eventListener.listener = listener;
 	eventListener.target = target;
 	this._onKeyDownEventListeners.push(eventListener);
 }*/

 TextDateIntervalCriterionQueryBuilder.prototype.checkInput = function()
 {
 	if ((!this._dateStart.checkInput()) || (!this._dateEnd.checkInput()))
 	{
 		return false;
 	}
 	
 	var dateStartString = this._dateStart.getState();
 	var dateEndString = this._dateEnd.getState();
 	
 	for (var i = 0; i < this._inputValidators.length; i++) {
		var inputValidator = this._inputValidators[i];
		if(!inputValidator(dateStartString, dateEndString)) {
			return false;
		}
	}
	
	return true;
 }
 
 TextDateIntervalCriterionQueryBuilder.prototype.addInputValidator = function(inputValidator)
 {
 	this._inputValidators.push(inputValidator);
 }
 
 TextFieldCriterionQueryBuilder.prototype.deleteInputValidators = function()
 {
 	this._inputValidators.length = 0;
 }
 
 /*TextDateIntervalCriterionQueryBuilder.prototype.applyFilters = function()
 {
	userInputText = this._containingDocument.getElementsByName(this._name + 'TextInput')[0].value;

	for (var i = 0; i < this._inputFilters.length; i++) {
		var inputFilter = this._inputFilters[i];
		userInputText = inputFilter(userInputText);
	}
	return userInputText;
 }
 
 TextDateIntervalCriterionQueryBuilder.prototype.addInputFilter = function(inputFilter)
 {
 	this._inputFilters.push(inputFilter);
 }*/

 /*TextDateIntervalCriterionQueryBuilder.prototype.getState = function()
 {
	var from = this._dateStart.getState();
	var to = this._dateEnd.getState();

	if ((from == "") || (to == "")) return "";

	var separator= '@';

	return from + separator + to;
 }*/

 TextDateIntervalCriterionQueryBuilder.prototype.setState = function()
 {
	this._dateStart.setState();
	this._dateEnd.setState();
 }
 
 TextDateIntervalCriterionQueryBuilder.prototype.resetState = function()
 {
 	this._dateStart.resetState();
	this._dateEnd.resetState();
	
	this._userDateStart = "";
	this._userDateEnd = "";
 }
 
 TextDateIntervalCriterionQueryBuilder.prototype.isValidDateInterval = function(dateStart, dateEnd)
 {	
 	if ((dateStart != "") && (dateEnd != ""))
 	{
 		var dateStartArray = dateStart.split('-');
 		var dateEndArray = dateEnd.split('-');
 	
 		var dateStartObject = new Date(dateStartArray[0], dateStartArray[1] - 1, dateStartArray[2]);
 		var dateEndObject = new Date(dateEndArray[0], dateEndArray[1] - 1, dateEndArray[2]);

 		return (dateStartObject <= dateEndObject);
 	}
 	else if (((dateStart == "") && (dateEnd != "")) 
 		 || ((dateStart != "") && (dateEnd == "")))
 	{
 		return false;
 	}
 	else
 	{
 		return true;
 	}
 }
 	
 TextDateIntervalCriterionQueryBuilder.prototype.isValidDate = function(dateString)
 {
 	if (dateString != "")
 	{
 		// Extraer año, mes y dia
 		var dateArray = dateString.split('-');
 		// Construir un objeto Date
 		// El rango de meses es 0-11, asi que restamos uno
 		var dateObject = new Date(dateArray[0], dateArray[1] - 1, dateArray[2]);
 		// Date ajusta la fecha si el rango de meses o dias es incorrecto;
 		// comprobamos si mantiene los mismos valores
 		return (dateArray[0] == dateObject.getFullYear())
 	    		&& ((dateArray[1] - 1) == dateObject.getMonth())
 	    		&& (dateArray[2] == dateObject.getDate());
	}
	else
	{
		return true;
	}
 }

 TextDateIntervalCriterionQueryBuilder.prototype.checkTextDate = function(dateInput)
 {
	var regExpDate = /^\d{4}-\d{2}-\d{2}$/

	if (dateInput != "")
	{
		return ((regExpDate.exec(dateInput) != null));
	} 
	else
	{
		return true;
	}
 }
 
  TextDateIntervalCriterionQueryBuilder.prototype.stateString = function()
 {   	
 	var cadena = "<b>" + this._title + ":</b>&nbsp;";
	if ((this._userDateStart != "") && (this._userDateEnd != ""))
	{
		return cadena + " " + this._config._from + " " + this._userDateStart 
			      + " " + this._config._to + " " + this._userDateEnd + '<br/>';
	}
	else
	{
		return "";
	}
 }
 
 // PRIVATE

 // función que da acceso al objeto javaScript identificado
 // por nombre y que está declarado en thePath
 function consCadPath(thePath,nombre)
 {
	var k = 0;
	var limite= thePath.length;
	var cadena= "";
	
	while(k<limite)
	{
		cadena = cadena + thePath[k] + '.';
		k++;
	}
	cadena = cadena + nombre;
	return cadena;
 }