package com.ejie.ab61.comun.utilidades;

import java.io.Serializable;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Locale;
import java.util.TimeZone;

import javax.xml.datatype.XMLGregorianCalendar;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.i18n.LocaleContextHolder;

import com.ejie.ab61.comun.Constantes;

/**
 * 
 *  
 * 
 */
public abstract class DateUtils implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = -8490805404102741744L;
	private static final String[] MESES_EUS = { "urtarrila", "otsaila", "martxoa", "apirila", "maiatza", "ekaina",
			"uztaila", "abuztua", "iraila", "urria", "azaroa", "abendua" };

	private static final Logger logger = LoggerFactory.getLogger(DateUtils.class);

	/**
	 * 
	 */
	public DateUtils() {
	}

	/**
	 * Metodo que obtiene la edad a partir de la fecha de nacimiento
	 * 
	 * @param birthDate
	 *            Fecha de nacimiento
	 * @return edad (int) del usuario
	 */
	public static int getAge(Date birthDate) {

		Calendar birthDateCal = Calendar.getInstance();
		birthDateCal.setTime(birthDate);

		Calendar now = Calendar.getInstance();

		// edad aproximada del usuario, puede ser un año menos si no ha
		// complido
		int edad = now.get(Calendar.YEAR) - birthDateCal.get(Calendar.YEAR);

		Calendar compareCal = Calendar.getInstance();
		compareCal.set(birthDateCal.get(Calendar.YEAR), now.get(Calendar.MONTH), now.get(Calendar.DAY_OF_MONTH));
		if (birthDateCal.after(compareCal)) {
			edad = edad - 1;
		}
		return edad;
	}

	/**
	 * Metdo que formatea un String para pasarlo a DATE
	 * 
	 * @param date
	 *            String a formatear
	 * @param format
	 *            formato de la fecha
	 * @return Date obtenido
	 * @throws ParseException
	 *             Excepcion de parseo
	 */
	public static Date formatDate(String date, String format) throws ParseException {

		SimpleDateFormat formatSd = new SimpleDateFormat(format);
		formatSd.setLenient(false);
		return formatSd.parse(date);

	}

	/**
	 * Metdo que formatea un Date para pasarlo a String
	 * 
	 * @param date
	 *            String a formatear
	 * @param formato
	 *            formato de la fecha
	 * @return Date obtenido
	 * @throws ParseException
	 *             Excepcion de parseo
	 */
	public static String formatDate(Date date, String formato) throws ParseException {
		SimpleDateFormat format = new SimpleDateFormat(formato);
		format.setLenient(false);
		return format.format(date);

	}

	/**
	 * Formatear valores de base de datos para que cumplan ###,##0.00 y
	 * aplicandose el locale ES
	 * 
	 * @param valor
	 *            BigDecimal
	 * @return String
	 */
	public static String formatearMiles(BigDecimal valor) {
		if (valor != null) {
			return localizedFormat("###,##0.00", valor.doubleValue(), new Locale("es", "ES"));
		} else
			return "";
	}

	/**
	 * Fomateo general de miles y decimales al idioma ES
	 * 
	 * @param pattern
	 *            a cumplir
	 * @param value
	 *            double
	 * @param loc
	 *            locale, en nuestro caso new Locale("es", "ES")
	 * @return String valor formateado
	 */
	private static String localizedFormat(String pattern, double value, Locale loc) {
		NumberFormat nf = NumberFormat.getNumberInstance(loc);
		DecimalFormat df = (DecimalFormat) nf;
		df.applyPattern(pattern);
		return df.format(value);
	}

	/**
	 * Metdo que formatea un String para pasarlo a DATE
	 * 
	 * @param date
	 *            String a formatear
	 * @param locale
	 *            Locale en el que esta la fecha
	 * @return Date obtenido
	 * @throws ParseException
	 *             Excepcion de parseo
	 */
	public static Date formatDateHour(String date, Locale locale) throws ParseException {

		DateUtils.logger.info("Metdo que formatea un String para pasarlo a DATE. Parametro fecha = " + date
				+ " y parametro idioma = " + locale.getLanguage());

		if (date == null || ("").equals(date.trim())) {
			return null;
		}
		if (locale.getLanguage().toUpperCase().equals(Constantes.Language.CASTELLANO)) {
			return DateUtils.formatDate(date, "dd/MM/yyyy HH:mm");

		} else {
			return DateUtils.formatDate(date, "yyyy/MM/dd HH:mm");

		}
	}

	/**
	 * Formatea la fecha de registro que viene en el xml de la cola
	 * 
	 * @param date
	 *            String
	 * @return Date Date
	 * @throws ParseException
	 *             ParseException
	 */
	public static Date formatFechaReg(String date) throws ParseException {
		return DateUtils.formatDate(date, "dd-MM-yyyy HH:mm:ss");
	}

	/**
	 * Metdo que formatea una fecha String a Date
	 * 
	 * @param strDate
	 *            String Fecha a convertir en Date
	 * 
	 * @return Date
	 * 
	 * @throws ParseException
	 *             Excepcion de parseo
	 */
	public static Date formatDate(String strDate) throws ParseException {
		return DateUtils.formatDate(strDate, LocaleContextHolder.getLocale());
	}

	/**
	 * Metdo que formatea un String para pasarlo a DATE
	 * 
	 * @param date
	 *            String a formatear
	 * @param locale
	 *            Locale en el que esta la fecha
	 * @return Date obtenido
	 * @throws ParseException
	 *             Excepcion de parseo
	 */
	public static Date formatDate(String date, Locale locale) throws ParseException {

		if (date == null || ("").equals(date.trim())) {
			return null;
		}

		if (locale.getLanguage().toUpperCase().equals(Constantes.Language.CASTELLANO)) {
			String formatCas = "dd/MM/yyyy";
			String[] dateStr = date.split("/");
			if (dateStr[2] != null && dateStr[2].length() == 2) {
				formatCas = "dd/MM/yy";

			}

			return DateUtils.formatDate(date, formatCas);
		} else {
			String formatEus = "yyyy/MM/dd";
			String[] dateStr = date.split("/");
			if (dateStr[0] != null && dateStr[0].length() == 2) {
				formatEus = "dd/MM/yy";
			}

			return DateUtils.formatDate(date, formatEus);
		}
	}

	/**
	 * Metdo que formatea un String para pasarlo a DATE
	 * 
	 * @param date
	 *            String a formatear
	 * @param locale
	 *            Locale en el que esta la fecha
	 * @return Date obtenido
	 * @throws ParseException
	 *             Excepcion de parseo
	 */
	public static Date formatDateLarge(String date, Locale locale) throws ParseException {
		if (date == null || ("").equals(date.trim())) {
			return null;
		}
		if (locale.getLanguage().toUpperCase().equals(Constantes.Language.CASTELLANO)) {
			return DateUtils.formatDate(date, "dd/MM/yyyy HH:mm:ss");
		} else {
			return DateUtils.formatDate(date, "yyyy/MM/dd HH:mm:ss");
		}
	}

	/**
	 * Metdo que formatea un String para pasarlo a DATE
	 * 
	 * @param date
	 *            String a formatear
	 * @return Date obtenido
	 * @throws ParseException
	 *             Excepcion de parseo
	 */
	public static Date formatStrToDateSinBarra(String date) throws ParseException {
		if (date == null || ("").equals(date.trim())) {
			return null;
		}

		return DateUtils.formatDate(date, "ddMMyy");

	}

	/**
	 * Metodo que transforma un DATE a String con el formato de fecha usado en
	 * la aplicacion::::: Euskera : yyyy/MM/dd HH:mm:ss - Castellano: dd/MM/yyyy
	 * HH:mm:ss
	 * 
	 * @param date
	 *            Date fecha a formatear
	 * @param locale
	 *            Locale idioma de la fecha
	 * @return String fecha formateada
	 * @throws ParseException
	 *             ParseException
	 */
	public static String formatDateHour(Date date, Locale locale) throws ParseException {
		String formato = "yyyy/MM/dd HH:mm:ss";
		if (Constantes.ES_LOCALE.getLanguage().equals(locale.getLanguage())) {
			formato = "dd/MM/yyyy HH:mm:ss";
		}
		return DateUtils.formatDate(date, formato);
	}

	/**
	 * Metodo que transforma un DATE a String con el formato de fecha usado en
	 * la aplicacion::::: Euskera : yyyy/MM/dd - Castellano: dd/MM/yyyy
	 * 
	 * @param date
	 *            Date fecha a formatear
	 * @param locale
	 *            Locale idioma de la fecha
	 * @return String fecha formateada
	 * @throws ParseException
	 *             ParseException
	 */
	public static String formatDate(Date date, Locale locale) throws ParseException {
		String formato = "yyyy/MM/dd";
		if (Constantes.ES_LOCALE.getLanguage().equals(locale.getLanguage())) {
			formato = "dd/MM/yyyy";
		}

		return DateUtils.formatDate(date, formato);
	}

	/**
	 * Metodo que transforma un DATE a String con el formato de fecha usado en
	 * la aplicacion::::: Euskera : yyyy/MM/dd - Castellano: dd/MM/yyyy
	 * 
	 * @param date
	 *            Date fecha a formatear
	 * @param locale
	 *            Locale idioma de la fecha
	 * @return String fecha formateada
	 * @throws ParseException
	 *             ParseException
	 */
	public static String formatDateLarge(Date date, Locale locale) throws ParseException {
		if (date == null) {
			return null;
		}
		String formato = "";
		if (locale.getLanguage().toUpperCase().equals(Constantes.Language.CASTELLANO)) {
			formato = "dd/MM/yyyy HH:mm:ss";
		} else {
			formato = "yyyy/MM/dd HH:mm:ss";
		}
		return DateUtils.formatDate(date, formato);
	}

	/**
	 * Metodo que transforma un DATE a String con el formato de fecha usado en
	 * la aplicacion::::: Euskera : yyyy/MM/dd - Castellano: dd/MM/yyyy
	 * 
	 * @param date
	 *            Date fecha a formatear
	 * @param locale
	 *            Locale idioma de la fecha
	 * @return String fecha formateada
	 * @throws ParseException
	 *             ParseException
	 */
	public static String formatDateCoraSinBarra(Date date, Locale locale) throws ParseException {
		if (date == null) {
			return null;
		}
		String formato = "";
		if (locale.getLanguage().toUpperCase().equals(Constantes.Language.CASTELLANO)) {
			formato = "ddMMyyyy";
		} else {
			formato = "yyyyMMdd";
		}
		return DateUtils.formatDate(date, formato);
	}

	/**
	 * M�todo de depuraci�n para mostrar una fecha con hora en consola/trazas
	 * 
	 * @param date
	 *            Date fecha a formatear
	 * @return String fecha formateada con formato "dd/MM/yyyy HH:mm")
	 * @throws ParseException
	 *             ParseException
	 */
	public static String timestampToString(Date date) throws ParseException {
		return date != null ? DateUtils.formatDate(date, "dd/MM/yyyy HH:mm") : "";
	}

	/**
	 * Metodo que obtiene la diferencia en dias, meses y anos entre dos fechas
	 * 
	 * @param fechaInicio
	 *            DATE
	 * @param fechaFin
	 *            DATE
	 * @return Integer[]
	 */
	public static Long[] getDiferenciasFechasDate(Date fechaInicio, Date fechaFin) {
		Locale locES = new Locale("es");
		String fechaIniStr = null;
		try {
			fechaIniStr = DateUtils.formatDate(fechaInicio, locES);
		} catch (ParseException e) {
			return null;
		}
		String fechaFinStr = null;
		try {
			fechaFinStr = DateUtils.formatDate(fechaFin, locES);
		} catch (ParseException e) {
			return null;
		}

		return DateUtils.getDiferenciasFechas(fechaIniStr, fechaFinStr);
	}

	/**
	 * Metodo que obtiene la diferencia en dias, meses y anos entre dos fechas
	 * 
	 * @param fechaInicio
	 *            fecha de inicio
	 * @param fechaFin
	 *            fecha de fin
	 * @return Long[] , [DD,MM,AA]
	 */
	public static Long[] getDiferenciasFechas(String fechaInicio, String fechaFin) {

		Long[] diferencias = new Long[Constantes.MAGIC_NUMBER_3];

		String[] aFechaIng = fechaInicio.split("/");
		Integer diaInicio = Integer.parseInt(aFechaIng[0]);
		Integer mesInicio = Integer.parseInt(aFechaIng[1]);
		Integer anioInicio = Integer.parseInt(aFechaIng[2]);

		String[] aFecha = fechaFin.split("/");
		Integer diaActual = Integer.parseInt(aFecha[0]);
		Integer mesActual = Integer.parseInt(aFecha[1]);
		Integer anioActual = Integer.parseInt(aFecha[2]);

		int b = 0;
		int dias = 0;
		int mes = 0;
		int anios = 0;
		int meses = 0;
		mes = mesInicio - 1;
		if (mes == 2) {
			if ((anioActual % Constantes.MAGIC_NUMBER_4 == 0) && ((anioActual % Constantes.MAGIC_NUMBER_100 != 0)
					|| (anioActual % Constantes.MAGIC_NUMBER_400 == 0))) {
				b = Constantes.MAGIC_NUMBER_29;
			} else {
				b = Constantes.MAGIC_NUMBER_28;
			}
		} else if (mes <= Constantes.MAGIC_NUMBER_7) {
			if (mes == 0) {
				b = Constantes.MAGIC_NUMBER_31;
			} else if (mes % 2 == 0) {
				b = Constantes.MAGIC_NUMBER_30;
			} else {
				b = Constantes.MAGIC_NUMBER_31;
			}
		} else if (mes > Constantes.MAGIC_NUMBER_7) {
			if (mes % 2 == 0) {
				b = Constantes.MAGIC_NUMBER_31;
			} else {
				b = Constantes.MAGIC_NUMBER_30;
			}
		}
		if ((anioInicio > anioActual) || (anioInicio.equals(anioActual) && mesInicio > mesActual)
				|| (anioInicio.equals(anioActual) && mesInicio.equals(mesActual) && diaInicio > diaActual)) {
			return null;
		} else {
			if (mesInicio <= mesActual) {
				anios = anioActual - anioInicio;
				if (diaInicio <= diaActual) {
					meses = mesActual - mesInicio;
					// dias = b - (diaInicio - diaActual);
					dias = diaActual - diaInicio;
				} else {
					if (mesActual.equals(mesInicio)) {
						anios = anios - 1;
					}
					if (anios < 0) {
						return null;
					}
					meses = (mesActual - mesInicio - 1 + Constantes.MAGIC_NUMBER_12) % Constantes.MAGIC_NUMBER_12;
					dias = b - (diaInicio - diaActual);
				}
			} else {
				anios = anioActual - anioInicio - 1;

				if (diaInicio > diaActual) {
					meses = mesActual - mesInicio - 1 + Constantes.MAGIC_NUMBER_12;
					dias = b - (diaInicio - diaActual);
				} else {
					meses = mesActual - mesInicio + Constantes.MAGIC_NUMBER_12;
					dias = diaActual - diaInicio;
				}
			}
		}

		diferencias[0] = Long.valueOf(dias);
		diferencias[1] = Long.valueOf(meses);
		diferencias[2] = Long.valueOf(anios);

		return diferencias;

	}

	/**
	 * Metodo que calcula la diferencia en dias entre dos fechas
	 * 
	 * @param fechaMenor
	 *            Date
	 * @param fechaMayor
	 *            Date
	 * @return long numero de dias
	 */
	public static long getDiferenciaFechasDias(Date fechaMenor, Date fechaMayor) {

		Calendar c1 = Calendar.getInstance();
		Calendar c2 = Calendar.getInstance();

		c1.setTime(fechaMenor);
		c2.setTime(fechaMayor);
		int diffDay = 0;

		if (c1.before(c2)) {
			diffDay = DateUtils.countDiffDay(c1, c2);
		} else {
			diffDay = DateUtils.countDiffDay(c2, c1);
		}

		return diffDay;
	}

	/**
	 * Metodo que calcula la diferencia en dias entre dos fechas Calendar
	 * 
	 * @param c1
	 *            fecha mayor
	 * @param c2
	 *            fecha menor
	 * @return int numero de dias
	 */
	public static int countDiffDay(Calendar c1, Calendar c2) {
		int returnInt = 0;
		while (!c1.after(c2)) {
			c1.add(Calendar.DAY_OF_MONTH, 1);
			returnInt++;
		}

		return (returnInt);
	}

	/**
	 * Metodo que obtiene el numero de dias entre dos fechas
	 * 
	 * @param fechaIni
	 *            fecha de inicio
	 * @param fechaFin
	 *            fecha de fin
	 * @return long
	 */
	public static long getDiferenciaFechasDiasStr(String fechaIni, String fechaFin) {
		/**
		 * Fecha de inicio de factura
		 */
		Date fechaIncioFact;
		try {
			fechaIncioFact = DateUtils.formatDate(fechaIni, LocaleContextHolder.getLocale());
		} catch (Exception e) {
			fechaIncioFact = null;
		}
		/**
		 * Fecha de fin de factura
		 */
		Date fechaFinFact;
		try {
			fechaFinFact = DateUtils.formatDate(fechaFin, LocaleContextHolder.getLocale());
		} catch (ParseException e) {
			fechaFinFact = null;
		}

		if (fechaIncioFact != null && fechaFinFact != null) {
			return DateUtils.getDiferenciaFechasDias(fechaIncioFact, fechaFinFact);
		} else {
			return 0;
		}
	}

	/**
	 * Metodo que comprueba si una fecha esta entre dos
	 * 
	 * @param fecha
	 *            Date a comparar
	 * @param fechaMin
	 *            fecha minima del rango
	 * @param fechaMax
	 *            fecha Max del rango
	 * @return true si esta dentro false si no esta dentro del rango
	 */
	public static Boolean isInRangoDate(Date fecha, Date fechaMin, Date fechaMax) {
		if (fecha == null || fechaMin == null || fechaMax == null) {
			return Boolean.FALSE;
		}
		if (fecha.before(fechaMin) || fecha.after(fechaMax)) {
			return Boolean.FALSE;
		}
		return Boolean.TRUE;
	}

	/**
	 * Suma dias a una fecha
	 * 
	 * @param fch
	 *            Date
	 * @param dias
	 *            int
	 * @return Date
	 */
	public static Date sumarFechasDias(Date fch, int dias) {
		Calendar cal = new GregorianCalendar();
		cal.setTimeInMillis(fch.getTime());
		cal.add(Calendar.DATE, dias);
		return new Date(cal.getTimeInMillis());
	}

	/**
	 * Get a Calendar instance for current thread.
	 * 
	 * @return A Calendar instance for current thread.
	 */
	public static Calendar getCalendar() {
		// We have to reset the time zone each time in case the result set
		// implementation changes it.
		Calendar calendar = Calendar.getInstance();
		TimeZone tz = TimeZone.getTimeZone("GMT");
		calendar.setTimeZone(tz);
		return calendar;
	}

	/**
	 * Devuelve el numero de dias que tiene el ano al que pertenece la fecha
	 * 
	 * @param fecha
	 *            Date
	 * @return int numero de dias
	 */
	public static int getNumeroDiasAnio(Date fecha) {
		Calendar fechaCal = Calendar.getInstance();
		fechaCal.setTime(fecha);
		int anio = fechaCal.get(Calendar.YEAR);
		if ((anio % Constantes.MAGIC_NUMBER_4 == 0)
				&& ((anio % Constantes.MAGIC_NUMBER_100 != 0) || (anio % Constantes.MAGIC_NUMBER_400 == 0))) {
			// El ano es bisiesto
			return Constantes.MAGIC_NUMBER_366;
		} else {
			// El ano NO es bisiesto
			return Constantes.MAGIC_NUMBER_365;
		}
	}

	/**
	 * Converts an XMLGregorianCalendar to an instance of java.util.Date
	 * 
	 * @param xgc
	 *            Instance of XMLGregorianCalendar or a null reference
	 * @return java.util.Date instance whose value is based upon the value in
	 *         the xgc parameter. If the xgc parameter is null then this method
	 *         will simply return null.
	 */
	public static java.util.Date xmlGregorianCalendarTODate(XMLGregorianCalendar xgc) {
		if (xgc == null) {
			return null;
		} else {
			return xgc.toGregorianCalendar().getTime();
		}
	}

	/**
	 * @param fecha
	 *            String
	 * @param locale
	 *            Locale
	 * 
	 * @return Long[]
	 * 
	 * @throws ParseException
	 *             ParseException
	 */
	public static Long[] getAnioMesDia(String fecha, Locale locale) throws ParseException {
		Date fechaDt = DateUtils.formatDate(fecha, locale);
		Calendar fechaCal = Calendar.getInstance();
		fechaCal.setTime(fechaDt);

		Long[] anioMesDia = new Long[Constantes.MAGIC_NUMBER_3];
		anioMesDia[0] = Long.valueOf(fechaCal.get(Calendar.YEAR));
		anioMesDia[1] = Long.valueOf(fechaCal.get(Calendar.MONTH) + 1);
		anioMesDia[2] = Long.valueOf(fechaCal.get(Calendar.DAY_OF_MONTH));

		return anioMesDia;
	}

	/**
	 * 
	 * @param hora
	 *            String
	 * 
	 * @return String[]
	 */
	public static String[] getHoraMinutos(String hora) {
		return hora.split(":");
	}

	/**
	 * Agrega o quita minutos a una fecha dada. Para quitar minutos hay que
	 * sumarle valores negativos.
	 * 
	 * @param date
	 *            java.util.Date
	 * @param minutes
	 *            numero de minutos
	 * @return Date
	 */
	public static Date addMinutesToDate(Date date, int minutes) {
		Calendar calendarDate = Calendar.getInstance();
		calendarDate.setTime(date);
		calendarDate.add(Calendar.MINUTE, minutes);
		return calendarDate.getTime();
	}

	/**
	 * Agrega o quita minutos a una fecha dada. Para quitar minutos hay que
	 * sumarle valores negativos.
	 * 
	 * @param calendarDate
	 *            calendarDate
	 * @param minutes
	 *            numero de minutos
	 * @return Date
	 */
	public static Calendar addMinutesToCalendar(Calendar calendarDate, int minutes) {
		calendarDate.add(Calendar.MINUTE, minutes);
		return calendarDate;
	}

	/**
	 * 
	 * @param date
	 *            Calendar
	 * @param locale
	 *            Locale
	 * 
	 * @return String
	 */
	public static String formateaFecha(Calendar date, Locale locale) {
		if (date == null) {
			return null;
		}
		if (locale.getLanguage().toUpperCase().equals(Constantes.Language.CASTELLANO)) {
			SimpleDateFormat dateFormatter = new SimpleDateFormat("dd/MM/yyyy", new Locale(Constantes.ES_STR));
			dateFormatter.setTimeZone(date.getTimeZone());
			return dateFormatter.format(date.getTime());
		} else {
			SimpleDateFormat dateFormatter = new SimpleDateFormat("yyyy/MM/dd", new Locale(Constantes.EU_STR));
			dateFormatter.setTimeZone(date.getTimeZone());
			return dateFormatter.format(date.getTime());
		}
	}

	/**
	 * Da formato a una hora
	 * 
	 * @param date
	 *            objeto {@link Calendar}
	 * 
	 * @return String: texto con la hora formateada en HH:mm
	 */
	public static String formateaHora(Calendar date) {
		if (date == null) {
			return null;
		}
		SimpleDateFormat dateFormatter = new SimpleDateFormat("HH:mm", new Locale(Constantes.ES_STR));
		dateFormatter.setTimeZone(date.getTimeZone());
		return dateFormatter.format(date.getTime());
	}

	/**
	 * Da formato a una hora
	 * 
	 * @param date
	 *            objeto {@link Calendar}
	 * 
	 * @return String: texto con la hora formateada en HH:mm
	 */
	public static String formateaHora(Date date) {
		if (date == null) {
			return null;
		}
		SimpleDateFormat dateFormatter = new SimpleDateFormat("HH:mm", new Locale(Constantes.ES_STR));
		return dateFormatter.format(date);
	}

	/**
	 * Comprueba si una hora es mayor, menor o igual a otra
	 * 
	 * @param firstHour
	 *            texto con la primera hora a comprarar en formato HH:mm
	 * @param secondHour
	 *            texto con la segunda hora a comparar en formato HH:mm
	 * @return 0 si son iguales, positivo sin la segunda hora es posterior a la
	 *         primera, negativo si la segunda hora es inferior a la primera
	 */
	public static int hourStringCompareTo(String firstHour, String secondHour) {
		Calendar hour1 = DateUtils.hourStringToCalendar(firstHour);
		Calendar hour2 = DateUtils.hourStringToCalendar(secondHour);
		return hour2.compareTo(hour1);
	}

	/**
	 * Convierte una hora en formato HH:mm en calendar
	 * 
	 * @param hour
	 *            String: texto con la hora en formato HH:mm
	 * 
	 * @return Calendar
	 */
	public static Calendar hourStringToCalendar(String hour) {

		String[] data = DateUtils.getHoraMinutos(hour);
		Calendar result = Calendar.getInstance();
		result.set(Calendar.HOUR, Integer.valueOf(data[0]));
		result.set(Calendar.MINUTE, Integer.valueOf(data[1]));
		return result;
	}

	/**
	 * Transforma una String tipo dd/MM/yyyy o yyyy/MM/dd a dd/MM/yyyy.
	 * 
	 * @param fecha
	 *            String
	 * @return fecha String
	 */
	public static String convertirStringEnStringFormateado(String fecha) {
		String fechaAux = fecha;
		if (fechaAux != null && !fechaAux.equals("")) {
			String fechas[] = fechaAux.split("/");
			if (fechas[0].length() == Constantes.MAGIC_NUMBER_4) {
				fechaAux = fechas[2] + "/" + fechas[1] + "/" + fechas[0];
			}
			return fechaAux;
		}
		return "";
	}

	/**
	 * 
	 * @return String
	 */
	public static String getFechaActual() {
		// Instanciamos el objeto Calendar
		// en fecha obtenemos la fecha y hora del sistema
		Calendar fecha = new GregorianCalendar();
		// Obtenemos el valor del a�o, mes, d�a,
		// hora, minuto y segundo del sistema
		// usando el m�todo get y el par�metro correspondiente
		int anyo = fecha.get(Calendar.YEAR);
		int mes = fecha.get(Calendar.MONTH);
		int dia = fecha.get(Calendar.DAY_OF_MONTH);

		return dia + "/" + (mes + 1) + "/" + anyo;
	}

	/**
	 * Devuelve la fecha pasada por parametro en formato yyyy-MM-dd HH:mm:ss
	 * 
	 * @param fecha
	 *            Date
	 * @return fecha String
	 */
	public static String convertirEnFechaConHora(Date fecha) {
		if (fecha != null) {
			if ("es".equalsIgnoreCase(LocaleContextHolder.getLocale().toString())) {
				return (new SimpleDateFormat("dd/MM/yyyy HH:mm:ss")).format(fecha);
			} else {
				return (new SimpleDateFormat("yyyy/MM/dd HH:mm:ss")).format(fecha);
			}
		} else {
			return "";
		}
	}

	/**
	 * Transforma una java.util.Date a String en formato extendido dependiendo
	 * de si est� en castellano o en euskera.
	 * 
	 * @param fecha
	 *            Date
	 * @return fecha String
	 */
	public static String convertirFechaEnStringExt(Date fecha) {
		return DateUtils.convertirFechaEnStringExt(fecha, LocaleContextHolder.getLocale());
	}

	/**
	 * Transforma una java.util.Date a String en formato extendido dependiendo
	 * de si est� en castellano o en euskera.
	 * 
	 * @param fecha
	 *            Date
	 * @param locale
	 *            Locale
	 * @return fecha String
	 */
	public static String convertirFechaEnStringExt(Date fecha, Locale locale) {
		if (fecha != null) {
			SimpleDateFormat formato = null;

			if (locale.getLanguage().equals("es")) {
				formato = new SimpleDateFormat("d 'de' MMMM 'de' yyyy", new Locale("es", "ES"));
			} else {
				// Java Locale no soporta Euskera as� que se formatean los
				// meses
				// a mano.
				Calendar cal = Calendar.getInstance();
				cal.setTime(fecha);
				int month = cal.get(Calendar.MONTH);
				formato = new SimpleDateFormat("yyyy'ko' '" + DateUtils.MESES_EUS[month] + "ren' d",
						new Locale("eu", "ES"));
			}
			return formato.format(fecha);
		} else {
			return "";
		}
	}
}
