/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.rjconsultores.ventaboletos.service.impl;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Comparator;
import java.util.List;

import org.apache.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.CorridaDAO;
import com.rjconsultores.ventaboletos.dao.EsquemaCorridaDAO;
import com.rjconsultores.ventaboletos.dao.RutaDAO;
import com.rjconsultores.ventaboletos.entidad.ClaseServicio;
import com.rjconsultores.ventaboletos.entidad.Empresa;
import com.rjconsultores.ventaboletos.entidad.OrgaoConcedente;
import com.rjconsultores.ventaboletos.entidad.Parada;
import com.rjconsultores.ventaboletos.entidad.ParadaSecuencia;
import com.rjconsultores.ventaboletos.entidad.ParadaSecuenciaCombinacaoLinha;
import com.rjconsultores.ventaboletos.entidad.Ruta;
import com.rjconsultores.ventaboletos.entidad.RutaCombinacion;
import com.rjconsultores.ventaboletos.entidad.RutaEmpresa;
import com.rjconsultores.ventaboletos.entidad.RutaSecuencia;
import com.rjconsultores.ventaboletos.entidad.Tramo;
import com.rjconsultores.ventaboletos.entidad.Via;
import com.rjconsultores.ventaboletos.exception.BusinessException;
import com.rjconsultores.ventaboletos.service.ParadaService;
import com.rjconsultores.ventaboletos.service.RutaCombinacionService;
import com.rjconsultores.ventaboletos.service.RutaSecuenciaService;
import com.rjconsultores.ventaboletos.service.RutaService;
import com.rjconsultores.ventaboletos.service.TramoService;
import com.rjconsultores.ventaboletos.utilerias.RegistroConDependenciaException;
import com.rjconsultores.ventaboletos.utilerias.UsuarioLogado;

/**
 * 
 * @author Rafius
 */
@Service("rutaService")
public class RutaServiceImpl implements RutaService {

	@Autowired
	private RutaDAO rutaDAO;
	@Autowired
	private TramoService tramoService;
	@Autowired
	private RutaCombinacionService rutaCombinacionService;
	@Autowired
	private RutaSecuenciaService rutaSecuenciaService;
	@Autowired
	private CorridaDAO corridaDAO;
	@Autowired
	private EsquemaCorridaDAO esquemaCorridaDAO;
	@Autowired
	private ParadaService paradaService;

	private static Logger log = Logger.getLogger(RutaServiceImpl.class);

	public List<Ruta> obtenerTodos() {
		return rutaDAO.obtenerTodos();
	}

	public Ruta obtenerID(Integer id) {
		return rutaDAO.obtenerID(id);
	}

	@Override
	@Transactional(rollbackFor = BusinessException.class)
	public Parada validaParada(String descripcionParada, Parada paradaAntiga) throws Exception {

		String cve = extrairCodigoOuLocalidade(descripcionParada, true, false);
		String descparada = extrairCodigoOuLocalidade(descripcionParada, false, true);

		if (cve == null || descparada == null)
			throw new BusinessException("editarCatalogoDeRutaController.actionCanbiarParada.businessException");
		try {
			List<Parada> paradas = paradaService.buscarCVE(cve);
			paradas.addAll(paradaService.buscar(descparada));
			if (!paradas.isEmpty()) {
				return paradas.iterator().next();
			} else {
				return null;
			}
		} catch (Exception e) {
			throw e;
		}
	}

	private String extrairCodigoOuLocalidade(String descripcionParada, boolean isCodigo, boolean isLocalidade) throws Exception {
		try {
			String arraySplit[] = new String[2];
			arraySplit = descripcionParada.split(" - ");
			if (isCodigo)
				return arraySplit[0];
			if (isLocalidade)
				return arraySplit[1];
		} catch (Exception e) {
			throw new BusinessException("editarCatalogoDeRutaController.actionCanbiarParada.businessException");
		}
		return null;
	}

	@Override
	@Transactional(rollbackFor = BusinessException.class)
	public boolean cambiarParadaRuta(Ruta ruta, Parada paradaAntiga, Parada nuevaParada, String descripcionParada) throws Exception {

		try {
			String cve = extrairCodigoOuLocalidade(descripcionParada, true, false);
			String descparada = extrairCodigoOuLocalidade(descripcionParada, false, true);

			if (nuevaParada == null) {
				nuevaParada = crearNuevaParada(paradaAntiga, cve, descparada);
				paradaService.suscribirActualizar(nuevaParada);
			}

			List<Tramo> tramos = validaTramosRuta(ruta);
			List<CambioRutaTramo> cambios = new ArrayList<CambioRutaTramo>();
			for (Tramo tramo : tramos) {
				Tramo nTramo = crearNuevoTramo(tramo, paradaAntiga, nuevaParada);
				if (nTramo != null) {
					cambios.add(new CambioRutaTramo(tramo, nTramo, paradaAntiga, nuevaParada));
					tramoService.suscribirActualizar(nTramo);
				}
			}

			for (CambioRutaTramo crt : cambios) {
				rutaDAO.updateAsientosVendibles(ruta, crt.getViejoTramo(), crt.getNuevoTramo());
			}

			return true;

		} catch (Exception e) {
			throw e;
		}
	}

	private List<Tramo> validaTramosRuta(Ruta ruta) {

		List<Tramo> tramosRuta = new ArrayList<Tramo>();

		for (RutaCombinacion rc : ruta.getRutaCombinacionList()) {
			if (!tramosRuta.contains(rc.getTramo()))
				tramosRuta.add(rc.getTramo());
		}

		for (RutaSecuencia rs : ruta.getRutaSecuenciaList()) {
			if (!tramosRuta.contains(rs.getTramo()))
				tramosRuta.add(rs.getTramo());
		}

		return tramosRuta;
	}

	private Tramo crearNuevoTramo(Tramo tramo, Parada viejaParada, Parada nuevaParada) {

		Tramo viejoTramo = tramoService.obtenerID(tramo.getTramoId());
		if (viejoTramo.getOrigem().equals(viejaParada) || viejoTramo.getDestino().equals(viejaParada)) {

			Tramo ptramo = null;
			if (viejoTramo.getOrigem().equals(viejaParada)) {
				ptramo = tramoService.obtenerTramotPorOrigemDestinoVia(nuevaParada, viejoTramo.getDestino(), viejoTramo.getVia());
			}

			if (viejoTramo.getDestino().equals(viejaParada)) {
				ptramo = tramoService.obtenerTramotPorOrigemDestinoVia(viejoTramo.getOrigem(), nuevaParada, viejoTramo.getVia());
			}

			if (ptramo == null) {

				Tramo nuevoTramo = new Tramo();
				nuevoTramo.setDesctramo(viejoTramo.getDesctramo() + " II");
				nuevoTramo.setVia(viejoTramo.getVia());
				nuevoTramo.setKmPagoConductor(viejoTramo.getKmPagoConductor());
				nuevoTramo.setKmReal(viejoTramo.getKmReal());

				nuevoTramo.setLsTramoTiempo(viejoTramo.getLsTramoTiempo());
				nuevoTramo.setLsOrgaoTramo(viejoTramo.getLsOrgaoTramo());

				nuevoTramo.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				nuevoTramo.setFecmodif(Calendar.getInstance().getTime());
				nuevoTramo.setActivo(Boolean.TRUE);

				if (viejoTramo.getOrigem().equals(viejaParada)) {
					nuevoTramo.setOrigem(nuevaParada);
					nuevoTramo.setDestino(viejoTramo.getDestino());
				}
				if (viejoTramo.getDestino().equals(viejaParada)) {
					nuevoTramo.setDestino(nuevaParada);
					nuevoTramo.setOrigem(viejoTramo.getOrigem());
				}

				return nuevoTramo;
			} else {
				return ptramo;
			}
		} else {
			return null;
		}
	}

	private Parada crearNuevaParada(Parada parada, String cve, String descparada) {
		Parada nuevaParada = new Parada();
		nuevaParada.setCveparada(cve);
		nuevaParada.setDescparada(descparada);
		nuevaParada.setCiudad(parada.getCiudad());
		nuevaParada.setRegionMetropolitana(parada.getRegionMetropolitana());
		nuevaParada.setNodo(parada.getNodo());
		nuevaParada.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
		nuevaParada.setFecmodif(Calendar.getInstance().getTime());
		nuevaParada.setActivo(Boolean.TRUE);

		return nuevaParada;
	}

	@Transactional(rollbackFor = BusinessException.class)
	public Ruta suscribir(Ruta entidad, List<ParadaSecuencia> lsParadasSequencia) throws BusinessException {
		entidad.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
		entidad.setFecmodif(Calendar.getInstance().getTime());
		entidad.setActivo(Boolean.TRUE);

		if (entidad.getVentaOffLine() == null) {
			entidad.setVentaOffLine(false);
		}

		Boolean isClone = entidad.getIsClone() != null ? entidad.getIsClone() : Boolean.FALSE;
		entidad = rutaDAO.suscribir(entidad);
		if (lsParadasSequencia != null) {
			if (!isClone) {
				generarSecuencias(entidad, lsParadasSequencia);
			}
			generarCombinacion(entidad);
		}

		return entidad;
	}

	private void generarSecuencias(Ruta ruta, List<ParadaSecuencia> lsParadasSequencia) throws BusinessException {

		if (lsParadasSequencia != null) {
			List<RutaSecuencia> lsRutaSecuencia = new ArrayList<RutaSecuencia>();

			// Desativo todas as secuencias e gero novamente.
			rutaSecuenciaService.borrarSecuencias(ruta);
			ruta.setRutaSecuenciaList(null);

			log.info("Geração de Secuencia!");
			log.info("Ruta: " + ruta.getRutaId() + " - " + ruta.getDescruta());

			lsRutaSecuencia.clear();
			StringBuilder sb = new StringBuilder("Tramo(s) inexistente(s):");
			sb.append("\n");
			boolean msg = false;
			for (int i = 0; i < lsParadasSequencia.size() - 1; i++) {
				Parada ori = lsParadasSequencia.get(i).getParada();
				Via via = lsParadasSequencia.get(i).getVia();
				Integer sec1 = lsParadasSequencia.get(i).getSecuencia().intValue();
				log.info("Secuencia: " + sec1 + " origen " + ori.getDescparada() + " - " + ori.getCveparada() + " Via: " + via.getNombvia());

				Parada des = lsParadasSequencia.get(i + 1).getParada();
				Integer sec2 = lsParadasSequencia.get(i + 1).getSecuencia().intValue();
				log.info("Secuencia: " + sec2 + " destino " + des.getDescparada() + " - " + des.getCveparada() + " Via: " + via.getNombvia());

				ClaseServicio claseServicio = ruta.getClaseServicio();

				Tramo tramo = tramoService.obtenerTramoUnicoRuta(ori, des, via, claseServicio);

				if (tramo != null) {

					RutaSecuencia rutaSecuencia = new RutaSecuencia();
					rutaSecuencia.setRuta(ruta);
					rutaSecuencia.setTramo(tramo);
					rutaSecuencia.setNumsecuencia(sec1.shortValue());
					rutaSecuencia.setActivo(Boolean.TRUE);
					rutaSecuencia.setFecmodif(Calendar.getInstance().getTime());
					rutaSecuencia.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());

					rutaSecuencia = rutaSecuenciaService.suscribir(rutaSecuencia);
					lsRutaSecuencia.add(rutaSecuencia);

				} else {
					throw new BusinessException("rutaServiceImpl.msg.validacionTRamo", new Object[] { ori.getCveparada(), des.getCveparada(), via.getNombvia(), claseServicio.getDescclase() });
				}
			}
			ruta.setRutaSecuenciaList(lsRutaSecuencia);
		}
	}

	@Transactional(rollbackFor = BusinessException.class)
	public Ruta actualizacion(Ruta ruta, List<ParadaSecuencia> lsParadasSequencia) throws BusinessException {
		if (lsParadasSequencia != null) {
			generarSecuencias(ruta, lsParadasSequencia);
			generarCombinacion(ruta);
		}

		ruta.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
		ruta.setFecmodif(Calendar.getInstance().getTime());
		ruta.setActivo(Boolean.TRUE);

		return rutaDAO.actualizacion(ruta);
	}

	@Transactional(rollbackFor = RegistroConDependenciaException.class)
	public void borrar(Ruta entidad) throws RegistroConDependenciaException {
		if ((corridaDAO.count(entidad) > 0l) || (esquemaCorridaDAO.count("ruta", entidad) > 0l)) {
			throw new RegistroConDependenciaException();
		}

		entidad = this.obtenerID(entidad.getRutaId());
		for (RutaCombinacion rutaCombinacion : entidad.getRutaCombinacionList()) {
			rutaCombinacion.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
			rutaCombinacion.setFecmodif(Calendar.getInstance().getTime());
			rutaCombinacion.setActivo(Boolean.FALSE);
		}

		for (RutaSecuencia rutaSecuencia : entidad.getRutaSecuenciaList()) {
			rutaSecuencia.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
			rutaSecuencia.setFecmodif(Calendar.getInstance().getTime());
			rutaSecuencia.setActivo(Boolean.FALSE);
		}

		for (RutaEmpresa rutaEmpresa : entidad.getLsRutaEmpresa()) {
			rutaEmpresa.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
			rutaEmpresa.setFecmodif(Calendar.getInstance().getTime());
			rutaEmpresa.setActivo(Boolean.FALSE);
		}

		entidad.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
		entidad.setFecmodif(Calendar.getInstance().getTime());
		entidad.setActivo(Boolean.FALSE);

		rutaDAO.actualizacion(entidad);
	}

	@Transactional(rollbackFor = BusinessException.class)
	public void generarCombinacion(Ruta ruta) throws BusinessException {

		rutaCombinacionService.borrarCombinaciones(ruta);

		List<RutaCombinacion> listRutaCombinacion = new ArrayList<RutaCombinacion>();
		List<RutaSecuencia> lsRutaSecuencia = new ArrayList<RutaSecuencia>();

		lsRutaSecuencia = rutaSecuenciaService.buscarSecuenciaOrdenado(ruta);

		StringBuilder sb = new StringBuilder();
		Boolean gerou = true;

		if (ruta.getRutaId() != null) {
			ruta.setRutaCombinacionList(rutaCombinacionService.obtenerPorRuta(ruta));
		}

		for (int i = 0; i < lsRutaSecuencia.size(); i++) {
			Tramo tramoSecuencia1 = lsRutaSecuencia.get(i).getTramo();
			Parada origem = tramoSecuencia1.getOrigem();

			for (int x = 0; x < lsRutaSecuencia.size(); x++) {
				Tramo tramoSecuencia2 = lsRutaSecuencia.get(x).getTramo();
				Parada destinoOrigem = tramoSecuencia2.getDestino();

				// Numero secuencia anterior > Numero secuencia atual não deve fazer.
				// Essa condição não permiti gerar uma volta.
				if (lsRutaSecuencia.get(i).getNumsecuencia().intValue() > lsRutaSecuencia.get(x).getNumsecuencia().intValue()) {
					continue;
				}

				// IDA - A x B - A x C
				if (origem == destinoOrigem) {
					continue;
				}

				List<Tramo> listTramo = tramoService.obtenerPorOrigemDestinoFetchLazy(origem, destinoOrigem);

				if (listTramo.isEmpty()) {
					throw new BusinessException("rutaServiceImpl.msg.validacionTRamoCombinacion", new Object[] { origem.getDescparada(), origem.getCveparada(), destinoOrigem.getDescparada(), destinoOrigem.getCveparada() });
				}

				Tramo trBuscaOrigemDestino = new Tramo();
				for (Tramo tm : listTramo) {
					if (tm.getVia().equals(tramoSecuencia2.getVia())) {
						trBuscaOrigemDestino = tm;
						break;
					} else if (tm.getVia().equals(tramoSecuencia1.getVia())) {
						trBuscaOrigemDestino = tm;
						break;
					} else {
						trBuscaOrigemDestino = tm;
					}
				}

				log.debug("Tramo:" + trBuscaOrigemDestino.getDesctramo());

				RutaCombinacion rc = new RutaCombinacion();
				rc.setActivo(Boolean.TRUE);
				rc.setFecmodif(Calendar.getInstance().getTime());
				rc.setIndventa(indVenta(ruta, trBuscaOrigemDestino));
				rc.setRuta(ruta);
				rc.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
				rc.setTramo(trBuscaOrigemDestino);

				// Verifica se já existe o registro INATIVO para Reativa-lo e manter a configuração se vende.
				// if (!rutaCombinacionService.busquedaRutaTramo(ruta, trBuscaOrigemDestino, Boolean.FALSE)) {
				rc = rutaCombinacionService.suscribir(rc);
				// } else {
				// rutaCombinacionService.activar(ruta, trBuscaOrigemDestino);
				// }

			}
		}
	}

	private boolean indVenta(Ruta ruta, Tramo trBuscaOrigemDestino) {
		for (RutaCombinacion rc : ruta.getRutaCombinacionList()) {
			if (rc.getTramo().equals(trBuscaOrigemDestino)) {
				return rc.getIndventa();
			}
		}
		return true;
	}

	public Parada getDestino(Ruta ruta) {
		return rutaDAO.buscarDestino(ruta);
	}

	public Parada getOrigem(Ruta ruta) {
		return rutaDAO.buscarOrigen(ruta);
	}

	public List<Ruta> buscarPorClaseServicioEmpresa(ClaseServicio claseServicio, Empresa empresa) {
		return rutaDAO.buscarPorClaseServicioEmpresa(claseServicio, empresa);
	}

	public List<Ruta> buscarPorClaseServicio(ClaseServicio claseServicio) {
		return rutaDAO.buscarPorClaseServicio(claseServicio);
	}

	public List<Ruta> buscar(String nomeRuta, ClaseServicio claseServicio, Boolean nomeObrigatorio) {
		return rutaDAO.buscar(nomeRuta, claseServicio, nomeObrigatorio);
	}

	public List<Ruta> obtenerPorEmpresa(Empresa empresa) {
		return rutaDAO.obtenerPorEmpresa(empresa);
	}

	public List<Ruta> buscarTodosExceto(Integer... idRuta) {
		return rutaDAO.buscarTodosExceto(idRuta);
	}

	public List<Ruta> buscarTodosEstos(Integer[] idRutas) {
		return rutaDAO.buscarTodosEstos(idRutas);
	}

	public List<Ruta> buscarNumRuta(String numRuta) {
		return rutaDAO.buscarNumRuta(numRuta);
	}

	@Override
	public boolean paradaExisteEnLaRuta(Parada parada, Ruta ruta) {
		ruta = obtenerID(ruta.getRutaId());
		boolean existe = false;
		for (int i = 0; (i < ruta.getRutaSecuenciaList().size()) && !existe; i++) {
			RutaSecuencia rutaSecuencia = ruta.getRutaSecuenciaList().get(i);
			Tramo tramo = rutaSecuencia.getTramo();
			if (tramo != null) {
				if (tramo.getOrigem().equals(parada) || tramo.getDestino().equals(parada)) {
					existe = true;
				}
			}
		}
		return existe;
	}

	public List<Ruta> buscaRuta(String palavraPesquisaRuta) {
		return rutaDAO.buscaRuta(palavraPesquisaRuta);
	}

	public List<Ruta> buscaRutasFromOrgao(OrgaoConcedente orgao) {
		return rutaDAO.buscaRutasFromOrgao(orgao);
	}

	@Override
	public List<Ruta> buscarRutasPorEmpresas(List<Empresa> lsEmp) {
		return rutaDAO.buscarPorRutaPorEmpresas(lsEmp);
	}

	private class RutaComparator implements Comparator<Ruta> {
		@Override
		public int compare(Ruta r1, Ruta r2) {
			String name1 = r1.getDescruta();
			String name2 = r2.getDescruta();
			return name1.compareTo(name2);
		}
	}

	@Override
	public Integer getNumSecuenciaOrigen(Integer rutaId, Integer origenId) {
		return obtenerID(rutaId).numSecuenciaOrigen(origenId);
	}

	@Override
	public Integer getNumSecuenciaDestino(Integer rutaId, Integer destinoId) {
		return obtenerID(rutaId).numSecuenciaDestino(destinoId);
	}

	@Override
	public List<ParadaSecuenciaCombinacaoLinha> verificarSeqRutaNaoGerada(Ruta ruta, List<ParadaSecuencia> lsParadasSecuencia) {

		List<ParadaSecuenciaCombinacaoLinha> sequencias = null;

		if (lsParadasSecuencia != null) {
			ClaseServicio claseServicio = ruta.getClaseServicio();
			sequencias = new ArrayList<ParadaSecuenciaCombinacaoLinha>();

			for (ParadaSecuencia sequenciaInformada : lsParadasSecuencia) {

				Parada origem = sequenciaInformada.getParada();
				Via via = sequenciaInformada.getVia();

				ParadaSecuenciaCombinacaoLinha paradaSecuenciaCombinacaoLinha = new ParadaSecuenciaCombinacaoLinha();
				paradaSecuenciaCombinacaoLinha.setOrigem(sequenciaInformada);
				paradaSecuenciaCombinacaoLinha.setVia(via);
				paradaSecuenciaCombinacaoLinha.setDestinos(new ArrayList<ParadaSecuencia>());

				for (ParadaSecuencia sequenciaExistente : lsParadasSecuencia) {
					if (sequenciaInformada.getParada().getParadaId() == sequenciaExistente.getParada().getParadaId()) {
						continue;
					}

					Parada destino = sequenciaExistente.getParada();
					Tramo tramo = tramoService.obtenerTramoUnicoRuta(origem, destino, via, claseServicio);

					if (tramo == null) {
						paradaSecuenciaCombinacaoLinha.getDestinos().add(sequenciaExistente);
					}
				}

				if (!paradaSecuenciaCombinacaoLinha.getDestinos().isEmpty()) {
					sequencias.add(paradaSecuenciaCombinacaoLinha);
				}
			}
		}

		return sequencias;
	}

	@Override
	public List<Ruta> buscarRutasPorEmpresaOrgaoConcedente(Empresa empresa, OrgaoConcedente orgao) {
		return rutaDAO.buscarRutasPorEmpresaOrgaoConcedente(empresa, orgao);
	}

	class CambioRutaTramo {
		private Tramo viejoTramo;
		private Tramo nuevoTramo;
		private Parada viejaParada;
		private Parada nuevaParada;

		public CambioRutaTramo(Tramo viejoTramo, Tramo nuevoTramo, Parada viejaParada, Parada nuevaParada) {
			super();
			this.viejoTramo = viejoTramo;
			this.nuevoTramo = nuevoTramo;
			this.viejaParada = viejaParada;
			this.nuevaParada = nuevaParada;
		}

		public Tramo getViejoTramo() {
			return viejoTramo;
		}

		public void setViejoTramo(Tramo viejoTramo) {
			this.viejoTramo = viejoTramo;
		}

		public Tramo getNuevoTramo() {
			return nuevoTramo;
		}

		public void setNuevoTramo(Tramo nuevoTramo) {
			this.nuevoTramo = nuevoTramo;
		}

		public Parada getViejaParada() {
			return viejaParada;
		}

		public void setViejaParada(Parada viejaParada) {
			this.viejaParada = viejaParada;
		}

		public Parada getNuevaParada() {
			return nuevaParada;
		}

		public void setNuevaParada(Parada nuevaParada) {
			this.nuevaParada = nuevaParada;
		}
	}
}