//Objetivo: Centralizar rutinas de tratamiento de fechas en javascript independientemente del navegador.
//Desarrollada el 18 de septiembre de 2001. David Bayo
//Comentarios adicionales:
//Explorer 5.5 falla al hacer parseInt de 08 y 09 -> da 0 cuando deberia dar 8 y 9
//Por este motivo hay una multiplicación por 1
//La longitud de la fecha debe ser 10 en formato dd/mm/yyyy. En caso de cifras menores que 10
//se pondrá un 0 delante. Por ejemplo: 01/09/2001
var MIN_YEAR = 1900;
var MAX_YEAR = 9999;
var MIN_MONTH = 1;
var MAX_MONTH = 12;
var MIN_DAY = 1;
var MIN_MINUTE = 0;
var MAX_MINUTE = 59;
var MIN_HOUR = 0;
var MAX_HOUR = 23;

/** Comprueba si una Hora(hora y minuto) es correcta. El formato que se comprueba es hh:mm.
  * Parameters:  hourMin - Cadena con la hora (hora y minuto)que se quiere comprobar.
  * Return:      boolean - Cierto si es correcta, falso en caso contrario.
  */
function isValidHourMin(hourMin) {
   //Se comprueba que el formato de la data hora sea hh:mm
   if (hourMin == null) return false;
   if (hourMin.length != 5) return false;
   if (hourMin.indexOf(":") == -1) return false;
   return ((isValidHour(hourMin.substr(0,2))) && (isValidMinute(hourMin.substr(3,2))));
}

/** Comprueba si una Hora(hora y minuto) es correcta. El formato que se comprueba es hh(separador)mm.
  * Parameters:  hourMin - Cadena con la hora (hora y minuto)que se quiere comprobar.
  * Return:      boolean - Cierto si es correcta, falso en caso contrario.
  */
function isValidHourMinWithFormat(hourMin, separador) {
   //Se comprueba que el formato de la data hora sea hh(separador)mm
   if (hourMin == null) return false;
   if (hourMin.length != 5) return false;
   if (hourMin.indexOf(separador) == -1) return false;
   return ((isValidHour(hourMin.substr(0,2))) && (isValidMinute(hourMin.substr(3,2))));
}

/** Comprueba si una hora es correcta. El formato que se comprueba es hh.
  * Parameters:  hour    - Cadena con la hora que se quiere comprobar.
  * Return:      boolean - Cierto si es correcta, falso en caso contrario.
  */
function isValidHour(hour) {
   //Se comprueba que el formato de la data hora sea hh:mm
   if (hour == null) return false;
   if (hour.length != 2) return false;
   return (isHour(hour));
}

/** omprueba si el campo minuto de una hora es correcto. El formato que se comprueba es mm.
  * Parameters:  minute  - Cadena con el minuto que se quiere comprobar.
  * Return:      boolean - Cierto si es correcto, falso en caso contrario.
  */
function isValidMinute(minute) {
   //Se comprueba que el formato de la data hora sea hh:mm
   if (minute == null) return false;
   if (minute.length != 2) return false;
   return (isMinute(minute));
}

/** Comprueba que el rango de el campo hora sea el correcto.
  * Parameters:  hour    - Cadena con el campo hora que se quiere comprobar.
  * Return:      boolean - Cierto si es correcto, falso en caso contrario.
  */
function isHour(hour) {
   if (! isInteger(hour)) return false;
   hourInt = getHour(hour);
   return ((hourInt >= getMinHour()) && (hourInt <= getMaxHour()));
}

/** Comprueba que el rango de el campo minuto sea el correcto.
  * Parameters:  minute  - Cadena con el campo minuto que se quiere comprobar.
  * Return:      boolean - Cierto si es correcto, falso en caso contrario.
  */
function isMinute(minute) {
   if (! isInteger(minute)) return false;
   minuteInt = getMinute(minute);
   return ((minuteInt >= getMinMinute()) && (minuteInt <= getMaxMinute()));
}

/** Devuelve la hora (hour)  en entero.
  * Parameters:  hour  - Cadena con el campo hora que se quiere.
  * Return:      int   - La hora en entero.
  */
function getHour(hour) {
   return parseInt(1 * hour);
}

/** Devuelve el minuto (minute)  en entero.
  * Parameters:  minute  - Cadena con el campo minuto que se quiere.
  * Return:      int     - El minuto en entero.
  */
function getMinute(minute) {
   return parseInt(1 * minute);
}

/** Mira si el formato de la fecha pasada por parametro es correcta.
  * El formato que se mira es  dd/mm/yyyy.
  * Parameters:  dataField   - Cadena con la fecha.
  * Return:      boolean     - Cierto si el formato es dd/mm/yyyy, falso en caso contrario.
  */ 
function isValidFormat(dataField) {
    if (dataField == null) return false;
    if (dataField.length != 10) return false;
    if (dataField.charAt(2) != '/') return false;
    if (dataField.charAt(5) != '/') return false;
 return true;
}

/** Mira si la fecha dataField es correcte o no. El parametro de entrada es un String.
  * El formato que se mira es  dd/mm/yyyy.
  * Parameters:  dataField   - Cadena con la fecha.
  * Return:      boolean     - Cierto si la feccha es correcta (mira tambien si el formato
  *                 es correcto). Falso en caso contrario.
  */
function isValidDate(dataField) {
   if (isEmpty(dataField)) return false;
   if (! isValidFormat(dataField)) return false;
   if (! isYear(dataField.substr(6,4))) return false;
   if (! isMonth(dataField.substr(3,2))) return false;
   if (! isDay(dataField)) return false;
   return true;
}

/** Mira si el año pasado por parametro es correcto o no.
  * Parameters:  year        - Cadena con el año.
  * Return:      boolean     - Cierto si el año es correcto. Falso en caso contrario.
  */
function isYear(year) {
   if (! isInteger(year)) return false;
   yearInt = getYear(year);
   return ((yearInt >= getMinYear()) && (yearInt <= getMaxYear()));
}

/** Mira si el mes pasado por parametro es correcto o no.
  * Parameters:  month       - Cadena con el mes.
  * Return:      boolean     - Cierto si el mes es correcto. Falso en caso contrario.
  */
function isMonth(month) {
   if (! isInteger(month)) return false;
   monthInt = getMonth(month);
   return ((monthInt >= getMinMonth()) && (monthInt <= getMaxMonth()));
}

/** Comprobara, si el dia de ese año y mes es correcto. El dia esta vinculado a mes, y el mes al año. 
  * Por eso es necesario pasar por parametro toda la fecha.
  * Parameters:  dataField   - Cadena con la fecha a comprobar.
  * Return:      boolean     - Cierto si ese dia es correcto (tambien comprueba el formato de la fecha)
  *                         es correcto. Falso en caso contrario.
  */
function isDay(dataField) {
   if (! isValidFormat(dataField)) return false;
   if (! isInteger(dataField.substr(0,2))) return false;
   dayInt = getDay(dataField.substr(0,2));
   return ((dayInt >= getMinDay()) && (dayInt <= getMaxDay(dataField)));
}

/** Dado una cadena del año, te lo transforma en un numero.
  * Parameters:  year        - Cadena con el año.
  * Return:      int         - Devuelve el año en entero.
  */
function getYear(year) {
   return parseInt(1 * year);
}

/** Dado una cadena del mes, te lo transforma en un numero.
  * Parameters:  month       - Cadena con el mes.
  * Return:      int         - Devuelve el mes en entero.
  */
function getMonth(month) {
   return parseInt(1 * month);
}

/** Dado una cadena del dia, te lo transforma en un numero.
  * Parameters:  day         - Cadena con el dia.
  * Return:      int         - Devuelve el dia en entero.
  */
function getDay(day) {
   return parseInt(1 * day);
}

/** Dado un año te devuelve los dias que tiene el mes de febrero.
  * February has 29 days in any year evenly divisible by four,
  * EXCEPT for centurial years which are not also divisible by 400.
  * Parameters:  year        - El año en entero.
  * Return:      int         - Dias del mes de febrero de dicho año.
  */
function getDaysInFebruary (year)
{   // February has 29 days in any year evenly divisible by four,
    // EXCEPT for centurial years which are not also divisible by 400.
    return (  ((year % 4 == 0) && ( (!(year % 100 == 0)) || (year % 400 == 0) ) ) ? 29 : 28 );
}

/** Devuelve el numero minimo de minutos(MIN_MINUTE).
  * Return:      int         - Numero minimo de minutos
  */
function getMinMinute() {return MIN_MINUTE;}

/** Devuelve el numero maximo de minutos(MAX_MINUTE).
  * Return:      int         - Numero máximo de minutos.
  */
function getMaxMinute() {return MAX_MINUTE;}

/** Devuelve el numero minimo de horas(MIN_HOUR).
  * Return:      int         - Numero minimo de horas.
  */
function getMinHour() {return MIN_HOUR;}

/** Devuelve el numero maximo de horas(MAX_HOUR).
  * Return:      int         - Numero maximo de horas.
  */
function getMaxHour() {return MAX_HOUR;}

/** Devuelve el numero minimo de años(MIN_YEAR).
  * Return:      int         - Numero minimo de años.
  */
function getMinYear() {return MIN_YEAR;}

/** Devuelve el numero maximo de años(MAX_YEAR).
  * Return:      int         - Numero maximo de años.
  */
function getMaxYear() {return MAX_YEAR;}

/** Devuelve el numero minimo de meses(MIN_MONTH).
  * Return:      int         - Numero minimo de meses.
  */
function getMinMonth() {return MIN_MONTH;}

/** Devuelve el numero maximo de meses(MAX_MONTH).
  * Return:      int         - Numero maximo de meses.
  */
function getMaxMonth() {return MAX_MONTH;}

/** Devuelve el numero minimo de dias(MIN_DAY).
  * Return:      int         - Numero maximo de dias.
  */
function getMinDay() {return MIN_DAY;}

/** Dada una cadena con una fecha, te devuelve el numero maximo de dias del
  * correspondiente mes y año.
  * Parameters:  dataField   - La cadena con la fecha.
  * Return:      int         - El numero maximo de dias que tiene el mes y año
  *                         que indica la fecha pasada por parametro. 
  */
function getMaxDay(dataField) {
    month = getMonth(dataField.substr(3,2));

    if (month==1 || month==3 || month==5 || month==7 || month==8 ||
        month==10 || month==12)  return 31;
    if (month==4 || month==6 || month==9 || month==11) return 30;
    if (month==2) return getDaysInFebruary(getYear(dataField.substr(6,4)));
    return null;
}

/** Dada una cadena te indica si es o no un entero.
  * Parameters:  value       - La cadena.
  * Return:      bool        - Devuelve cierto si la cadena de entrada representa un entero.
  *			   Falso en caso contrario. 
  */
function isInteger(value) {
    valueInt = parseInt(1 * value);

    if (isNaN(valueInt)) return false;
    else return true;
}

/** Dada una cadena te indica si es de tipo float o no.
  * Parameters:  value       - La cadena.
  * Return:      bool        - Devuelve cierto si la cadena de entrada representa un float.
  *			   Falso en caso contrario. 
  */
function isFloat(value) {
    valueFloat = parseFloat(value);

    if (isNaN(valueFloat)) return false;
    else return true;
}

// Marca la situacio del calendari per defecte
var defaultSituacio="/wltmb/st/js/";

/** Mira si una cadena esta vacia.
  * Parameters:  s           - La cadena.
  * Return:      boolean        - Devuelve cierto si la cadena de entrada es null o esta
  *				   vacia. Falso en caso contrario. 
  */
function isEmpty(s)
{   
    return ((s == null) || (s.length == 0));
}

/** Cambia el path de la situacion por defecto del calendario.
  * Parameters:  novaSituacio - La cadena con el nuevo path.
  * Return:      void
  */	
function setSituacio(novaSituacio){
   defaultSituacio = novaSituacio;
}

/** Te abre el calendario desde la situacion por defecto
  * Parameters:  data - La cadena con la fecha que se quiere abrir el calendario.
  * Return:      void
  */	
function obrirCalendari(data){
     window.dateField = data;
     calendari = window.open(defaultSituacio + 'calendari.html','cal','WIDTH=200, HEIGHT=250');
}

/** Te abre el calendario desde la situacion que le digas
  * Parameters: data     - La cadena con la fecha que se quiere abrir el calendario.
  * 	        situacio - El path donde se encuentra el calendario.
  *	Return:      void
  */
function obrirCalendariWithSituacio(data,situacio){
     window.dateField = data;
     calendari = window.open(situacio + 'calendari.html','cal','WIDTH=200, HEIGHT=250');
}

/** Te devuelve el dia a partir de una fecha. 
  * Parameters:  data     - La cadena con la fecha.
  * Return:      String   - Una cadena de dos caracteres que representan el dia en la fecha que 
  *				se pasa por parametro. Se comprueba también que la fecha sea correcta.
  *			    Si es incorrecta se devuelve null.
  */
function getDayFromDate(data) {
    if (!isValidDate(data)) return null;
    else return data.substr(0,2);
}

/** Te devuelve el mes a partir de una fecha. 
  * Parameters:  data     - La cadena con la fecha.
  * Return:      String   - Una cadena de dos caracteres que representan el mes en la fecha que 
  *				se pasa por parametro. Se comprueba también que la fecha sea correcta.
  *			    Si es incorrecta se devuelve null.
  */
function getMonthFromDate(data) {
    if (!isValidDate(data)) return null;
    else return data.substr(3,2);
}

/** Te devuelve el año a partir de una fecha. 
  * Parameters:  data     - La cadena con la fecha.
  * Return:      String   - Una cadena de dos caracteres que representan el año en la fecha que 
  *				se pasa por parametro. Se comprueba también que la fecha sea correcta.
  *			    Si es incorrecta se devuelve null.
  */
function getYearFromDate(data) {
    if (!isValidDate(data)) return null;
    else return data.substr(6,4);
}

/** Compara fechas.
  * Parameters: dataInici  - La cadena con una fecha.
  * 	        dataFi     - La cadena con otra fecha.
  *	Return:     int        - Devuelve:
  *				     -1 -> dataInici<dataFi
  *				      0 -> dataInici==dataFi
  *				      1 -> dataInici>dataFi
  */
function compareDates(dataInici, dataFi){
     diaInici=getDayFromDate(dataInici);
     mesInici=getMonthFromDate(dataInici);
     diaFi=getDayFromDate(dataFi);
	 mesFi=getMonthFromDate(dataFi);
    
     if ((getYearFromDate(dataInici)) < (getYearFromDate(dataFi))) return -1;
     else if ((getYearFromDate(dataInici)) > (getYearFromDate(dataFi))) return 1;
     else return (compareMonthDay(mesInici,diaInici,mesFi,diaFi));
}

/** Compara meses y, si es necesario, los días.
  * Parameters: mesInici  - La cadena con un mes.
  * 	        diaInici  - La cadena con un dia.
  *		        mesFi     - Cadena con otro mes.
  *		        diaFi     - Cadena con otro dia.
  *	Return:     int       - Devuelve:
  *					 -1 -> si mesInici y dia Inici<mesFi y diaFi
  *				      0 -> si mesInici y dia Inici==mesFi y diaFi
  *				      1 -> si mesInici y dia Inici>mesFi y diaFi
  */
function compareMonthDay(mesInici, diaInici, mesFi, diaFi){
     value = compareMonth(mesInici, mesFi);
     if (value != 0) return value;
     else return (compareDay(diaInici, diaFi));
}

/** Compara meses.
  * Parameters: mesInici  - La cadena con un mes.
  * 	        mesFi     - Cadena con otro mes.
  *	Return:     int       - Devuelve:
  *					 -1 -> mesInici < mesFi       
  *					  0 -> mesInici == mesFi      
  *					  1 -> mesInici > mesFi       
  */
function compareMonth(mesInici, mesFi){
     if ((getMonth(mesInici)) < (getMonth(mesFi))) return -1;
     else if ((getMonth(mesInici)) > (getMonth(mesFi))) return 1;
     else return 0;
}

/** Compara días.
  * Parameters: diaInici  - La cadena con un dia.
  * 	        diaFi     - Cadena con otro dia.
  *	Return:     int       - Devuelve:
  *					 -1 -> diaInici<diaFi        
  *					  0 -> diaInici==diaFi       
  *					  1 -> diaInici>diaFi    
  */
function compareDay(diaInici,diaFi) {
     if ((getDay(diaInici)) < (getDay(diaFi))) return -1;
     else if ((getDay(diaInici)) > (getDay(diaFi))) return 1;
     else return 0;
}

// Codigo necesario para que compile -> Cuando la ventana del calendario se cierra
// se llama a una accion: accionRetorno, que ejecutara. Se puede actualizar esta
// accion con setAccionRetorno.
// Variable auxiliar superflua
varauxiliar = 0;
// Accion por defecto: asignacion superflua
accionRetorno = "varauxiliar=0";

/** Cuando la ventana del calendario se cierra se llama a una accion:                
  * accionRetorno, que se ejecutara. Esta funcion te permite cambiar dicha accion.   
  * Metodo set de la accion a realizar antes de cerrar la ventana del calendario     
  *	por defecto no hace nada (asignacion superflua)                                  
  *	Parameters:  accion  - La cadena con la accion a ejecutar al cerrar la ventana del
  *	 	               calendario.
  *	Return:      void 
  */
function setAccionRetorno(accion)
{
    accionRetorno = accion;
}

/** Compara fechas.
  * Parameters: date1  - La cadena con una fecha.
  * 	        date2  - La cadena con otra fecha.
  *	Return:     true si la date1 es mayor o igual que la date2, false en caso contrario.
  */

function isGreaterOrEqualThan(date1, date2){
	return (compareDates(date1, date2) != -1);
}

/** Compara fechas.
  * Parameters: date1  - La cadena con una fecha.
  * 	        date2  - La cadena con otra fecha.
  *	Return:     true si la date1 es menor o igual que la date2, false en caso contrario.
  */

function isLessOrEqualThan(date1, date2){
	return (compareDates(date1, date2) != 1);
}

/** Compara fechas.
  * Parameters: date1  - La cadena con la fecha.
  *	Return:     true si la date1 es igual a hoy, false en caso contrario.
  */

function isEqualThanToday(date1){
	return (compareDates(date1,getCurrentDate()) == 0);
}

/** Compara fechas.
  * Parameters: date1  - La cadena con una fecha.
  *	Return:     true si la date1 es mayor que hoy, false en caso contrario.
  */

function isGreaterThanToday(date1){
	return (compareDates(date1, getCurrentDate()) == 1);
}

/** Compara fechas.
  * Parameters: date1  - La cadena con una fecha.
  *	Return:     true si la date1 es menor que hoy, false en caso contrario.
  */

function isLessThanToday(date1){
	return (compareDates(date1, getCurrentDate()) == -1);
}

/** Compara fechas.
  * Parameters: dataInici  - La cadena con una fecha.
  * 	        dataFi     - La cadena con otra fecha.
  *	Return:     int        - Devuelve:
  *				     -1 -> dataInici<dataFi
  *				      0 -> dataInici==dataFi
  *				      1 -> dataInici>dataFi
  */
  
function compareDatesWithHour(dataInici, dataFi, hourInici, hourFi){
     var compareDatesValue = compareDates(dataInici, dataFi);
     //Si los comparación de años, mes, día ya da 0 (fechas iguales), entonces se da paso
     //a la comparación en horas y minutos. Si no es 0 es porque ya son fechas distintas
     if (compareDatesValue != 0) return compareDatesValue;

     if (hourInici < hourFi) return -1;
     else if (hourInici > hourFi) return 1;
     else return 0;
}

/** Compara fechas.
  * Parameters: dataInici  - La cadena con una fecha.
  * 	        dataFi     - La cadena con otra fecha.
  *	Return:     int        - Devuelve:
  *				     -1 -> dataInici<dataFi
  *				      0 -> dataInici==dataFi
  *				      1 -> dataInici>dataFi
  */
  
function compareDatesWithHourMin(dataInici, dataFi, hourInici, hourFi, minInici, minFi){
     var compareDatesWithHourValue = compareDatesWithHour(dataInici, dataFi, hourInici, hourFi);
     //Si los comparación de años, mes, día y horas ya da 0 (fechas iguales), entonces se da paso
     //a la comparación en minutos. Si no es 0 es porque ya son fechas distintas
     if (compareDatesWithHourValue != 0) return compareDatesWithHourValue;

     if (minInici < minFi) return -1;
     else if (minInici > minFi) return 1;
     else return 0;
}

/** Devuelve la fecha actual en formato dd/mm/yyyy.
  *	Return:     String
  */

function getCurrentDate()
{
  var time = new Date();
  var any = time.getFullYear();
  var mes = time.getMonth();
  var mesReal = mes+1;
  var dia = time.getDate();
  if (parseInt(mesReal) < 10) mesReal = "0" + mesReal;
  if (parseInt(dia) < 10) dia = "0" + dia;
  return (dia + '/' + mesReal + '/' + any);
}