package com.rjconsultores.ventaboletos.service.impl;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.List;

import org.apache.commons.lang.math.NumberUtils;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import com.rjconsultores.ventaboletos.dao.CorridaTramoDAO;
import com.rjconsultores.ventaboletos.dao.TramoTiempoDAO;
import com.rjconsultores.ventaboletos.entidad.Autobus;
import com.rjconsultores.ventaboletos.entidad.Ciudad;
import com.rjconsultores.ventaboletos.entidad.ClaseServicio;
import com.rjconsultores.ventaboletos.entidad.Corrida;
import com.rjconsultores.ventaboletos.entidad.CorridaTramo;
import com.rjconsultores.ventaboletos.entidad.EsquemaCorrida;
import com.rjconsultores.ventaboletos.entidad.EsquemaTramo;
import com.rjconsultores.ventaboletos.entidad.Estado;
import com.rjconsultores.ventaboletos.entidad.Nodo;
import com.rjconsultores.ventaboletos.entidad.Tramo;
import com.rjconsultores.ventaboletos.entidad.TramoServicio;
import com.rjconsultores.ventaboletos.entidad.TramoTiempo;
import com.rjconsultores.ventaboletos.service.BoletoService;
import com.rjconsultores.ventaboletos.service.CorridaService;
import com.rjconsultores.ventaboletos.service.CorridaTramoService;
import com.rjconsultores.ventaboletos.service.TramoServicioService;
import com.rjconsultores.ventaboletos.utilerias.ActivoUtil;
import com.rjconsultores.ventaboletos.utilerias.ApplicationProperties;
import com.rjconsultores.ventaboletos.utilerias.CustomEnum;
import com.rjconsultores.ventaboletos.utilerias.DateUtil;
import com.rjconsultores.ventaboletos.utilerias.HoraSistema;
import com.rjconsultores.ventaboletos.utilerias.UsuarioLogado;

@Service("corridaTramoService")
public class CorridaTramoServiceImpl implements CorridaTramoService {
	
	
	Logger log;
	
	@Autowired
	private TramoServicioService tramoServicioService;
	
	@Autowired
	private CorridaService corridaService;
	
	@Autowired
	BoletoService boletoService;
	
	public CorridaTramoServiceImpl() {
		super();
		log = LogManager.getLogger(CorridaTramoServiceImpl.class);
	}


	@Autowired
    private CorridaTramoDAO corridaTramoDAO;
	
	@Autowired
	private TramoTiempoDAO tramoTiempoDAO;
	
	@Override
	public List<CorridaTramo> obtenerTodos() {
		return corridaTramoDAO.obtenerTodos();
	}

	@Override
	public CorridaTramo obtenerID(Integer id) {
		return corridaTramoDAO.obtenerID(id);
	}


	@Transactional
	public CorridaTramo suscribir(CorridaTramo entidad) {
		return corridaTramoDAO.suscribir(entidad);
	}

	@Override
	@Transactional
	public CorridaTramo actualizacion(CorridaTramo entidad) {
		return corridaTramoDAO.actualizacion(entidad);
	}

	@Override
	public void borrar(CorridaTramo entidad) {
		corridaTramoDAO.borrar(entidad);
	}

	@Override
	public List<CorridaTramo> obtenerTramoTarjetaEmitida() {
		return corridaTramoDAO.obtenerTramoTarjetaEmitida();
	}
	
	

	@Override
	@Transactional
	public List<CorridaTramo> recriaCorridaTramo(EsquemaCorrida esquemaCorrida, Date dataCorrida, List<EsquemaTramo> esquemaTramoNovoList, Corrida corrida, List<EsquemaTramo> lsEsquemaTramoOrignal, Date horaSalidaOriginal) {
		List<CorridaTramo> corridaTramoListAntigas = corridaTramoDAO.buscaCorridaTramoByFecCorridaECorridaId(dataCorrida, esquemaCorrida.getNumCorrida(), false);
		//Caso encontre nas CorridaTramo existente algum trecho vendido que não está nas configurações do serviço retorna null
		
		boolean permiteRecriarCorridaTramo= !isPermiteAlterarHorarioCorridaComVendas() ? Boolean.TRUE : (isPermiteAlterarHorarioCorridaComVendas() && validarSeHorarioCorridaFoiAlterado(esquemaCorrida.getHorasalida(), horaSalidaOriginal)? Boolean.FALSE :Boolean.TRUE);
				
		if(permiteRecriarCorridaTramo) {
			if(!validaTramoInexistenteServicoComVenda(esquemaCorrida, dataCorrida, lsEsquemaTramoOrignal, corridaTramoListAntigas)) {
				return corridaTramoListAntigas;
			};
		}
		
		inativaCorridasTramos(corridaTramoListAntigas);
		
		Date fechorSalidaOriginalH = null;
		List<CorridaTramo> lsCorridaTramoNovas = criaCorridaTramoList(esquemaCorrida.getAutoBus(), dataCorrida, fechorSalidaOriginalH,esquemaTramoNovoList, null, esquemaCorrida.getClaseServicio(), esquemaCorrida.getStatusCorrida());
		
		if(corrida==null) {
			corrida = new Corrida(esquemaCorrida.getNumCorrida(), dataCorrida);
		}
		for (CorridaTramo corridaTramo : lsCorridaTramoNovas) {
			corridaTramo.setCorrida(corrida);
		}
		return lsCorridaTramoNovas;
		
	}

	/**
	 * Valida se existe alguma CorrridaTramo atualmente que contem venda e não está nas configurações de Serviço.
	 * @param esquemaCorrida
	 * @param dataCorrida
	 * @param lsParadaEsquemaOrignal
	 * @param corridaTramoListAntigas
	 * @return
	 */
	private boolean validaTramoInexistenteServicoComVenda(EsquemaCorrida esquemaCorrida, Date dataCorrida,
			List<EsquemaTramo> lsParadaEsquemaOrignal, List<CorridaTramo> corridaTramoListAntigas) {
		List<CorridaTramo> corridaTramoInexistenteList = new ArrayList<CorridaTramo>();
		for (CorridaTramo corridaTramo : corridaTramoListAntigas) {
			boolean isTrechoExiste = false;
			for (EsquemaTramo esquemaTramo : lsParadaEsquemaOrignal) {
				if(esquemaTramo.getTramo().getOrigem().equals(corridaTramo.getTramo().getOrigem()) && 
						esquemaTramo.getTramo().getDestino().equals(corridaTramo.getDestino())) {
					isTrechoExiste = true;
					break;
				}
			}
			if(!isTrechoExiste) {
				corridaTramoInexistenteList.add(corridaTramo);
			}
		}
		for (CorridaTramo corridaTramo : corridaTramoInexistenteList) {
			if(boletoService.isExisteBoletoPorCorridaOrigemIdOuDestinoId(esquemaCorrida.getNumCorrida(), dataCorrida, corridaTramo.getOrigem().getParadaId(), corridaTramo.getDestino().getParadaId())){
				return false;
			}
			
		}
		return true;
	}

	
	
	/**
	 * Verifica se hay una excepcione de tiempo para el tramo informado.
	 * 
	 * @param corridaTramo
	 * @param claseServicio
	 * @return - Si existe una excepcion, regresa la nueva fecLlegada para el tramo, sino, regreso null
	 */
	private Date arreglaExcepcionTiempo(CorridaTramo corridaTramo, ClaseServicio claseServicio) {
		Date nuevaFecLlegada = null;

		Tramo tramo = corridaTramo.getTramo();

		List<TramoTiempo> lsExcepciones = tramoTiempoDAO.buscar(tramo, claseServicio, corridaTramo.getFechorsalida(), corridaTramo.getFechorllegada());

		if (!lsExcepciones.isEmpty()) {
			TramoTiempo tramoTiempo = lsExcepciones.get(0);
			List<Integer> diasSemana = getDiaDeLaSemana(tramoTiempo);

			Calendar fecCorrida = Calendar.getInstance();
			fecCorrida.setTime(corridaTramo.getFechorllegada());

			if (diasSemana.contains(fecCorrida.get(Calendar.DAY_OF_WEEK))) {

				Calendar fechorsalida = Calendar.getInstance();
				fechorsalida.setTime(corridaTramo.getFechorsalida());

				HoraSistema horaSistema = new HoraSistema(tramoTiempo.getTiemporecorrido());

				fechorsalida.add(Calendar.HOUR, horaSistema.getHora());
				fechorsalida.add(Calendar.MINUTE, horaSistema.getMinuto());

				nuevaFecLlegada = fechorsalida.getTime();
			}
		}

		return nuevaFecLlegada;
	}

	

	private Date calcularFechorllegada(EsquemaTramo esquemaTramo, ClaseServicio clase, Date dataGeracao, Date horaChegada) {
		GregorianCalendar gHoraChegada = new GregorianCalendar();
		gHoraChegada.setTime(horaChegada);
		HoraSistema hs = null;

		if (esquemaTramo.getExcepcionRecorrido() != null) {
			hs = new HoraSistema(esquemaTramo.getExcepcionRecorrido());

			gHoraChegada.add(Calendar.HOUR_OF_DAY, hs.getHora());
			gHoraChegada.add(Calendar.MINUTE, hs.getMinuto());
		} else {
			Tramo tramo = esquemaTramo.getTramo();
			List<TramoServicio> lsTramoServicio = tramoServicioService.buscarPorTramoServico(tramo, clase);

			for (TramoServicio ts : lsTramoServicio) {
				hs = new HoraSistema(ts.getTiemporecorrido());

				gHoraChegada.add(Calendar.HOUR_OF_DAY, hs.getHora());
				gHoraChegada.add(Calendar.MINUTE, hs.getMinuto());
			}
		}

		return gHoraChegada.getTime();
	}
	
	private Calendar getCalendarFechorllegada(Date fecHorallegada) {
		Calendar llegada = Calendar.getInstance();
		llegada.setTime(fecHorallegada);
		llegada.set(llegada.get(Calendar.YEAR), llegada.get(Calendar.MONTH), llegada.get(Calendar.DATE),
				llegada.get(Calendar.HOUR_OF_DAY), llegada.get(Calendar.MINUTE), NumberUtils.INTEGER_ZERO);
		return llegada;
	}

	private Calendar getCalendarFechorSalida(Date fecHorSalida) {
		Calendar salida = Calendar.getInstance();
		salida.setTime(fecHorSalida);
		salida.set(salida.get(Calendar.YEAR), salida.get(Calendar.MONTH), salida.get(Calendar.DATE),
				salida.get(Calendar.HOUR_OF_DAY), salida.get(Calendar.MINUTE), NumberUtils.INTEGER_ZERO);
		return salida;
	}
	private Date calcularHusoHorVeranoLlegada(EsquemaTramo esquemaTramo, CorridaTramo corridaTramo) {

		Ciudad ciudadOrigen = esquemaTramo.getTramo().getOrigem().getCiudad();
		Estado estadoOrigen = ciudadOrigen.getEstado();
		
		int tiempoOrigen = estadoOrigen.getTiempoHorHuso() == null ? 0 : estadoOrigen.getTiempoHorHuso();

		Date fecInicioHorVerano = estadoOrigen.getFecInicioHorVerano();
		Date fecFinHorVerano = estadoOrigen.getFecFinoHorVerano();
		
		

		if ((fecInicioHorVerano != null) && (fecFinHorVerano != null)) {
			if ((DateUtil.compareOnlyDate(fecInicioHorVerano, corridaTramo.getFechorsalida()) <= 0) && (DateUtil.compareOnlyDate(fecFinHorVerano, corridaTramo.getFechorsalida()) >= 0)) {
				tiempoOrigen += estadoOrigen.getTiempoHorVerano();
			}
		}
		// 21688
		Ciudad ciudadDestino = esquemaTramo.getTramo().getDestino().getCiudad();
		Estado estadoDestino = ciudadDestino.getEstado();
		int tiempoDestino = 0;

		if (!estadoDestino.equals(estadoOrigen)) {
			tiempoDestino = estadoDestino.getTiempoHorHuso() == null ? 0 : estadoDestino.getTiempoHorHuso();
			
			

			Date fecInicioHorVeranoDestino = estadoDestino.getFecInicioHorVerano();
			Date fecFinHorVeranDestino = estadoDestino.getFecFinoHorVerano();

			if ((fecInicioHorVeranoDestino != null) && (fecFinHorVeranDestino != null)) {
				if ((DateUtil.compareOnlyDate(fecInicioHorVeranoDestino, corridaTramo.getFechorllegada()) <= 0) && (DateUtil.compareOnlyDate(fecFinHorVeranDestino, corridaTramo.getFechorllegada()) >= 0)) {
					tiempoDestino += estadoDestino.getTiempoHorVerano();
				}
			}
		} else {
			tiempoDestino =0;
			tiempoOrigen=0;
		}
		
		//Consideração do fuso por cidade. 
		//Nesse caso, é mandatório em relação ao estado.Ou seja, equanto que no fuso do estado, 
		//tem que haver Mudança de estado, para a cidade NÃO, pois pode-se considerar cada cidade
		//como um único estado. Sendo assim, devendo ser considerado sempre quando preenchido
		if ( (ciudadOrigen.getZonaHoraria() != null) && (ciudadOrigen.getZonaHoraria() != 0 )){
			log.info("Fuso da cidade origem " + ciudadOrigen.getNombciudad() + " : " + ciudadOrigen.getZonaHoraria());
			
			tiempoOrigen += ciudadOrigen.getZonaHoraria();
		}
		
		if ( (ciudadDestino.getZonaHoraria() != null) && (ciudadDestino.getZonaHoraria() != 0 )){
			log.info("Fuso da cidade destino " + ciudadDestino.getNombciudad() + " : " + ciudadDestino.getZonaHoraria());
			
			tiempoDestino += ciudadDestino.getZonaHoraria();
		}
		//Fim consideração fuso por cidade

		Calendar horLlegada = null;

		long elapsedMinutes = DateUtil.getElapsedMinutos(corridaTramo.getFechorsalida(), corridaTramo.getFechorllegada());

		horLlegada = Calendar.getInstance();
		horLlegada.setTime(corridaTramo.getFechorsalidaH());

		horLlegada.add(Calendar.MINUTE, (int) elapsedMinutes);
		
		// Si los tiempos son distintos, hube cambio de huso horario/horario de verano
		if (tiempoOrigen != tiempoDestino) {
			horLlegada.add(Calendar.HOUR, (tiempoDestino - tiempoOrigen));

		}

		return (horLlegada == null) ? null : horLlegada.getTime();
	}

	
	@SuppressWarnings("deprecation")
	private Date calcularFechorsalida(EsquemaTramo esquemaTramo, Date dataGeracao, Date horaChegadaAnterior, java.util.Date tiempoEstanciaAnterior) {
		SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
		Date horaSaida;

		if (horaChegadaAnterior == null) {
			horaSaida = truncarDataHora(dataGeracao, esquemaTramo.getEsquemaCorrida().getHorasalida());
		} else {
			GregorianCalendar gHoraSaidaProximo = new GregorianCalendar();
			gHoraSaidaProximo.setTime(horaChegadaAnterior);

			log.debug("Tempo Recorrido  : " + sdf.format(gHoraSaidaProximo.getTime()));

			if (tiempoEstanciaAnterior != null) {
				gHoraSaidaProximo.add(Calendar.MINUTE, tiempoEstanciaAnterior.getMinutes());
				gHoraSaidaProximo.add(Calendar.HOUR_OF_DAY, tiempoEstanciaAnterior.getHours());

				log.debug("Tempo Recorrido + Estancia: " + sdf.format(gHoraSaidaProximo.getTime()));
			}

			horaSaida = gHoraSaidaProximo.getTime();
		}

		GregorianCalendar gHoraSaida = new GregorianCalendar();
		gHoraSaida.setTime(horaSaida);

		return gHoraSaida.getTime();
	}

	
	/**
	 * Adiciciona as horas do parametro hora na data dataGeracao.
	 * 
	 * Alem disso eh zerado os campos segundos e milisegundos.
	 * 
	 * @param dataGeracao
	 * @param hora
	 * @return
	 */
	private Date truncarDataHora(Date dataGeracao, Date hora) {
		Date dataCorreta = new Date();

		GregorianCalendar gAux = new GregorianCalendar();
		gAux.setTime(hora);
		GregorianCalendar gcalendar = new GregorianCalendar();
		gcalendar.setTime(dataGeracao);
		gcalendar.set(Calendar.HOUR_OF_DAY, gAux.get(Calendar.HOUR_OF_DAY));
		gcalendar.set(Calendar.MINUTE, gAux.get(Calendar.MINUTE));
		gcalendar.set(Calendar.SECOND, 0);
		gcalendar.set(Calendar.MILLISECOND, 0);

		dataCorreta = gcalendar.getTime();

		return dataCorreta;
	}

	
	
	private void inativaCorridasTramos(List<CorridaTramo> corridaTramoList) {
		//Inativa corrida tramo  
		for (CorridaTramo corridaTramo : corridaTramoList) {
			corridaTramo.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
			corridaTramo.setFecmodif(new Date());
			corridaTramo.setActivo(0);
			corridaTramoDAO.suscribir(corridaTramo);	
						
		}
	}

		
	private List<Integer> getDiaDeLaSemana(TramoTiempo tramoTiempo) {
		List<Integer> diasValidos = new ArrayList<Integer>();

		if (tramoTiempo.getIndapliclun()) {
			diasValidos.add(Calendar.MONDAY);
		}
		if (tramoTiempo.getIndaplicmar()) {
			diasValidos.add(Calendar.TUESDAY);
		}
		if (tramoTiempo.getIndaplicmie()) {
			diasValidos.add(Calendar.WEDNESDAY);
		}
		if (tramoTiempo.getIndaplicjue()) {
			diasValidos.add(Calendar.THURSDAY);
		}
		if (tramoTiempo.getIndaplicvie()) {
			diasValidos.add(Calendar.FRIDAY);
		}
		if (tramoTiempo.getIndaplicsab()) {
			diasValidos.add(Calendar.SATURDAY);
		}
		if (tramoTiempo.getIndaplicdom()) {
			diasValidos.add(Calendar.SUNDAY);
		}

		return diasValidos;
	}

	private List<Integer> carregaParadaIdItinerario(List<CorridaTramo> miListTramos) {
		List<Integer> paradasIdItinerario = new ArrayList<Integer>();
		for (CorridaTramo corridaTramo : miListTramos) {
			if (!paradasIdItinerario.contains(corridaTramo.getOrigem().getParadaId())) {
				paradasIdItinerario.add(corridaTramo.getOrigem().getParadaId());
			}
			if (!paradasIdItinerario.contains(corridaTramo.getDestino().getParadaId())) {
				paradasIdItinerario.add(corridaTramo.getDestino().getParadaId());
			}
		}
		return paradasIdItinerario;
	}
	
	@Override
	public List<CorridaTramo>  criaCorridaTramoList(Autobus autobus, Date dataGeracao, Date fechorSalidaOriginalH  ,
			List<EsquemaTramo> lsEsquemaTramo, Nodo nodo, ClaseServicio claseServicio, String statusCorrida) {
		List<CorridaTramo> lsCorridaTramo = new ArrayList<CorridaTramo>();
		Date horaChegadaAnterior = null;
		Date husoHorVeranoLlegadaAnterior = null;
		Integer numSec = 1;
		for (EsquemaTramo esquemaTramo : lsEsquemaTramo) {

			CorridaTramo corridaTramo = new CorridaTramo();
		
			corridaTramo.setAutobus(autobus!= null ? autobus : null);
			corridaTramo.setConductor(null);
			corridaTramo.setConductor1(null);
			corridaTramo.setPlataforma(esquemaTramo.getPlataforma());
			corridaTramo.setTipoPassagem(esquemaTramo.getTipoPassagem());

			corridaTramo.setTiempoEstancia(esquemaTramo.getTiempoEstancia());

			// numSec: 1-2, 2-3, 3-4...
			corridaTramo.setNumsecorigen(numSec.shortValue());
			numSec = numSec + 1;
			corridaTramo.setNumsecdestino(numSec.shortValue());

			Date fecHorSalida = calcularFechorsalida(esquemaTramo, dataGeracao, horaChegadaAnterior, esquemaTramo.getTiempoEstancia());
			corridaTramo.setFechorsalida( getCalendarFechorSalida(fecHorSalida).getTime());

			Date fecHorallegada = calcularFechorllegada(esquemaTramo, claseServicio, dataGeracao, fecHorSalida);
			corridaTramo.setFechorllegada(getCalendarFechorllegada(fecHorallegada).getTime());

			horaChegadaAnterior = fecHorallegada;

			corridaTramo.setFechortarjetaviaje(null);
			corridaTramo.setNodo(nodo);

			corridaTramo.setNumsecuencia(esquemaTramo.getNumsecuencia());
			Tramo tramo = esquemaTramo.getTramo();
			if (tramo != null) {
				corridaTramo.setOrigem(tramo.getOrigem());
				corridaTramo.setDestino(tramo.getDestino());
			}
			corridaTramo.setTramo(tramo);
			corridaTramo.setUsuariotarjetaviajeId(null);

			Date excepcionTiempo = arreglaExcepcionTiempo(corridaTramo, claseServicio);
			if (excepcionTiempo != null) {
				corridaTramo.setFechorllegada(excepcionTiempo);
				horaChegadaAnterior = excepcionTiempo;
			}

			if ("A".equals(statusCorrida)) {
				corridaTramo.setActivo(ActivoUtil.ATIVO);
			} else if ("L".equals(statusCorrida)) {
				corridaTramo.setActivo(ActivoUtil.INATIVO);
			}
			//
			corridaTramo.setFecmodif(Calendar.getInstance().getTime());
			if (UsuarioLogado.getUsuarioLogado() != null) {
				corridaTramo.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
			}
			//corridaTramo.setCorrida(corrida);
			corridaTramo.setFechorSalidaOriginal(fecHorSalida);

			if (husoHorVeranoLlegadaAnterior == null) {
				corridaTramo.setFechorsalidaH(corridaTramo.getFechorsalida());
			} else {

				// Ajusta tambem o tempo de instancia do calculo do horario de verao
				if (esquemaTramo.getTiempoEstancia() != null) {
					SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy HH:mm:ss");
					GregorianCalendar tmp = new GregorianCalendar();
					tmp.setTime(husoHorVeranoLlegadaAnterior);

					tmp.add(Calendar.MINUTE, esquemaTramo.getTiempoEstancia().getMinutes());
					tmp.add(Calendar.HOUR_OF_DAY, esquemaTramo.getTiempoEstancia().getHours());

					log.debug("Tempo Recorrido H + Estancia: " + sdf.format(tmp.getTime()));

					husoHorVeranoLlegadaAnterior = tmp.getTime();

				}

				corridaTramo.setFechorsalidaH(husoHorVeranoLlegadaAnterior);
			}

			husoHorVeranoLlegadaAnterior = calcularHusoHorVeranoLlegada(esquemaTramo, corridaTramo);

			if (husoHorVeranoLlegadaAnterior != null) {
				corridaTramo.setFechorllegadaH(husoHorVeranoLlegadaAnterior);
				corridaTramo.setFechorSalidaOriginalH(husoHorVeranoLlegadaAnterior);
			} else {
				corridaTramo.setFechorllegadaH(corridaTramo.getFechorllegada());
				corridaTramo.setFechorSalidaOriginalH(corridaTramo.getFechorSalidaOriginal());
			}

			if (numSec == 1) {
				fechorSalidaOriginalH = corridaTramo.getFechorsalidaH();
				//corrida.setFechorSalidaOriginalH(corridaTramo.getFechorsalidaH());
			}

			lsCorridaTramo.add(corridaTramo);
			
		}
		return lsCorridaTramo;
	}
	
	private boolean validarSeHorarioCorridaFoiAlterado(Date horaSalidaAtual, Date horaSalidaOriginal) {
		try {
			if(DateUtil.isIgual(DateUtil.getDateFromString(DateUtil.getStringDate(horaSalidaAtual,DateUtil.HHmm), DateUtil.HHmm),DateUtil.getDateFromString(DateUtil.getStringDate(horaSalidaOriginal,DateUtil.HHmm), DateUtil.HHmm))) {
				return Boolean.FALSE;
			}
		} catch (ParseException e) {
			log.error("Erro ao fazer parse :"+e);
			return Boolean.FALSE;
		}
		return Boolean.TRUE;
	}
	private boolean isPermiteAlterarHorarioCorridaComVendas() {
		if (ApplicationProperties.getInstance().isCustomHabilitado(CustomEnum.IS_PERMITE_ALTERAR_HORARIO_CORRIDA_COM_VENDAS.getDescricao(), Boolean.FALSE)) {
			return Boolean.TRUE;
		}
		return Boolean.FALSE;
	}
}
