package com.rjconsultores.ventaboletos.service.impl;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import org.apache.commons.lang.StringUtils;
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.constantes.TipoSeguro;
import com.rjconsultores.ventaboletos.dao.OrgaoConcedenteDAO;
import com.rjconsultores.ventaboletos.dao.SeguroKmDAO;
import com.rjconsultores.ventaboletos.dao.SeguroTarifaDAO;
import com.rjconsultores.ventaboletos.dao.TarifaOficialDAO;
import com.rjconsultores.ventaboletos.entidad.CasetaPeaje;
import com.rjconsultores.ventaboletos.entidad.ClaseServicio;
import com.rjconsultores.ventaboletos.entidad.Empresa;
import com.rjconsultores.ventaboletos.entidad.Marca;
import com.rjconsultores.ventaboletos.entidad.Moneda;
import com.rjconsultores.ventaboletos.entidad.OrgaoConcedente;
import com.rjconsultores.ventaboletos.entidad.Parada;
import com.rjconsultores.ventaboletos.entidad.Peaje;
import com.rjconsultores.ventaboletos.entidad.Ruta;
import com.rjconsultores.ventaboletos.entidad.TarifaOficial;
import com.rjconsultores.ventaboletos.entidad.Tramo;
import com.rjconsultores.ventaboletos.entidad.Via;
import com.rjconsultores.ventaboletos.entidad.VigenciaTarifa;
import com.rjconsultores.ventaboletos.exception.BusinessException;
import com.rjconsultores.ventaboletos.service.LogAuditoriaService;
import com.rjconsultores.ventaboletos.service.PeajeService;
import com.rjconsultores.ventaboletos.service.TarifaOficialService;
import com.rjconsultores.ventaboletos.utilerias.UsuarioLogado;
import com.rjconsultores.ventaboletos.vo.comissao.TarifaOficialComComposicaoDoPedagioVo;
import com.rjconsultores.ventaboletos.vo.comissao.TarifaOficialVO;

@Service("tarifaOficialService")
public class TarifaOficialServiceImpl implements TarifaOficialService {

	private static Logger log = LogManager.getLogger(TarifaOficialServiceImpl.class);
	
	@Autowired
	private TarifaOficialDAO tarifaOficialDAO;
	@Autowired
	private SeguroKmDAO seguroKmDAO;
	@Autowired
	private SeguroTarifaDAO seguroTarifaDAO;
	@Autowired
	private OrgaoConcedenteDAO orgaoConcedenteDAO;
	
	@Autowired
	private LogAuditoriaService logAuditoriaService;
	
	
	@Autowired
	private PeajeService peajeService;

	@Override
	@Transactional
	public Integer gerarTarifaPorCoeficiente(Integer rutaId, OrgaoConcedente orgaoConcedente, List<Integer> idsEmpresas,Integer[] lsCasetaPeaje) {
		return tarifaOficialDAO.gerarTarifaPorCoeficiente(rutaId, UsuarioLogado.getUsuarioLogado().getUsuarioId(), orgaoConcedente, idsEmpresas,lsCasetaPeaje );
	}
	
	@Override
	@Transactional
	public Integer atualizarTarifaPorCoeficiente(Integer rutaId, OrgaoConcedente orgaoConcedente) {
		return tarifaOficialDAO.atualizarTarifaCoeficiente(rutaId, UsuarioLogado.getUsuarioLogado().getUsuarioId(), orgaoConcedente);
	}

	@Override
	@Transactional
	public void copiarParaTarifa(VigenciaTarifa vigenciaTarifa,  Boolean calculaPegagio, Boolean calculaTarifa, Boolean calculaTaxaEmbarque, Boolean calculaSeguro, Boolean calculaTPP, Boolean calculaEmbarcada, Empresa empresa, OrgaoConcedente orgaoConcedente) {
		tarifaOficialDAO.copiarParaTarifa(vigenciaTarifa, UsuarioLogado.getUsuarioLogado().getUsuarioId(), 
				calculaPegagio, calculaTarifa, calculaTaxaEmbarque, calculaSeguro, calculaTPP, calculaEmbarcada, empresa, orgaoConcedente);
	}

	@Override
	@Transactional(rollbackFor = BusinessException.class)
	public void gerarAtualizarTarifa(List<Ruta> lsRuta, OrgaoConcedente orgaoConcedente, List<Empresa> lsEmpresaSelected, Integer[] lsCasetaPeaje) throws BusinessException {

		// Limpando a tabela de TARIFA_OFICIAL
		tarifaOficialDAO.limparTarifasOficiais(lsEmpresaSelected);
		
		int x = 0;
		if(lsRuta != null && !lsRuta.isEmpty()){
			x = lsRuta.size();
		}
		
		List<Integer> idsEmpresas = new ArrayList<Integer>();
		for(Empresa e : lsEmpresaSelected){
			idsEmpresas.add(e.getEmpresaId());
		}
		
		do{
			Integer rutaId = null;
			if(lsRuta != null && !lsRuta.isEmpty()){
				Ruta r = lsRuta.get(x-1);
				rutaId = r.getRutaId();
			}

			log.info("gerarAtualizarTarifa= rudaId:" + rutaId + ";orgaoConcedenteId:" + (orgaoConcedente != null ? orgaoConcedente.getOrgaoConcedenteId() : "null") + ";empresaId:" + idsEmpresas);

			// Gerando as tarifas pelo coeficiente
			if (orgaoConcedente == null ||
					(orgaoConcedente.getOrgaoConcedenteId() == null || orgaoConcedente.getOrgaoConcedenteId() != OrgaoConcedente.CODIGO_ARTESP)) {
				Integer qtdTarifaCoeficiente = gerarTarifaPorCoeficiente(rutaId, orgaoConcedente, idsEmpresas,lsCasetaPeaje);
				log.info("qtdTarifaCoeficiente=" + qtdTarifaCoeficiente);
			}

			// Gerando as tarifas para ARTESP
			if (orgaoConcedente == null ||
					(orgaoConcedente.getOrgaoConcedenteId() == null || orgaoConcedente.getOrgaoConcedenteId() == OrgaoConcedente.CODIGO_ARTESP)) {
				Integer qtdTarifaArtesp = tarifaOficialDAO.gerarTarifaArtesp(rutaId, UsuarioLogado.getUsuarioLogado().getUsuarioId(),
						orgaoConcedente != null ? orgaoConcedente.getOrgaoConcedenteId() : null, idsEmpresas);
				log.info("qtdTarifaArtesp=" + qtdTarifaArtesp);
			}
			x--;
		}while(x > 0);
		
		tarifaOficialDAO.removerDuplicidadeNaTarifaOficial();
	}
	
	@Override
	@Transactional(rollbackFor = BusinessException.class)
	public void gerarAtualizarTabelaZerada(List<Ruta> lsRuta, Integer orgaoConcedenteId, List<Empresa> lsEmpresaSelected,List<Integer> lsParadaIds) throws BusinessException {
		// Limpando a tabela de TARIFA_OFICIAL
		tarifaOficialDAO.limparTarifasOficiais(lsEmpresaSelected);
		
		int x =0;
		if(lsRuta != null && !lsRuta.isEmpty()){
			x = lsRuta.size();
		}
		
		List<Integer> idsEmpresas = new ArrayList<Integer>();
		for(Empresa e : lsEmpresaSelected){
			idsEmpresas.add(e.getEmpresaId());
		}
		
		do{
			Integer rutaId =null;
			if(lsRuta != null && !lsRuta.isEmpty()){
				rutaId = lsRuta.get(x-1).getRutaId();
			}
			 
			//Gerando as tarifas
			tarifaOficialDAO.gerarTabelaZerada(rutaId, UsuarioLogado.getUsuarioLogado().getUsuarioId(), orgaoConcedenteId, idsEmpresas,lsParadaIds);
		
			x--;
		}while(x > 0);
	}

	@Override
	@Transactional(rollbackFor = BusinessException.class)
	public void atualizarTaxaEmbarque(List<Ruta> lsRuta, Integer orgaoConcedenteId,boolean gerarTabelaZerada, List<Empresa> lsEmpresaSelected, List<Integer> lsParadaIds) throws BusinessException{

		if (gerarTabelaZerada){
			gerarAtualizarTabelaZerada(lsRuta, orgaoConcedenteId, lsEmpresaSelected,lsParadaIds);
		}
		
		List<Integer> idsEmpresas = new ArrayList<Integer>();
		for(Empresa e : lsEmpresaSelected){
			idsEmpresas.add(e.getEmpresaId());
		}
		
		tarifaOficialDAO.atualizarTaxaEmbarque(lsRuta, UsuarioLogado.getUsuarioLogado().getUsuarioId(), orgaoConcedenteId, idsEmpresas,lsParadaIds);
	}
	
	@Override
	@Transactional(rollbackFor = BusinessException.class)
	public void atualizarSeguroPorKm(Integer rutaId, Integer orgaoId, TipoSeguro tipoSeguro) throws BusinessException {
		tarifaOficialDAO.atualizarSeguroPorKm(rutaId, orgaoId, UsuarioLogado.getUsuarioLogado().getUsuarioId(), tipoSeguro);
	}

	@Override
	@Transactional(rollbackFor = BusinessException.class)
	public void atualizarSeguroPorKmTPP(Integer rutaId, Integer orgaoId, TipoSeguro tipoSeguro) throws BusinessException {
			tarifaOficialDAO.atualizarPrecioPorTPP(rutaId, orgaoId, UsuarioLogado.getUsuarioLogado().getUsuarioId(), tipoSeguro);
	}

	@Override
	@Transactional(rollbackFor = BusinessException.class)
	public void atualizarSeguroPorTarifa(Integer rutaId, Integer orgaoId) throws BusinessException {
		tarifaOficialDAO.atualizarSeguroPorTarifa(rutaId, orgaoId, UsuarioLogado.getUsuarioLogado().getUsuarioId());
	}

	@Override
	@Transactional(rollbackFor = BusinessException.class)
	public void atualizarSeguro(List<Ruta> lsRuta, Integer orgaoId, TipoSeguro tipoSeguro) throws BusinessException {

		List<Integer> lsOrgaoId = new ArrayList<Integer>();

		if (orgaoId == null) {
			lsOrgaoId.addAll(orgaoConcedenteDAO.obtenerTodosIds());
		} else {
			lsOrgaoId.add(orgaoId);
		}

		int x = 0;
		if(lsRuta != null && !lsRuta.isEmpty()){
			x = lsRuta.size();
		}
		
		do{
			Integer rutaId = null;
			if(lsRuta != null && !lsRuta.isEmpty()){
				rutaId = lsRuta.get(x-1).getRutaId();
			}
			// O seguro por km é preferencial em relação ao por tarifa.
			for (Integer orgaoConcedenteId : lsOrgaoId) {
				if (seguroKmDAO.existe(orgaoConcedenteId)) {
					atualizarSeguroPorKm(rutaId, orgaoConcedenteId, tipoSeguro);
				} else if (seguroTarifaDAO.existe(orgaoConcedenteId)) {
					atualizarSeguroPorTarifa(rutaId, orgaoConcedenteId);
				}
			}
			x--;
		}while(x > 0);
	}
	
	@Override
	@Transactional(rollbackFor = BusinessException.class)
	public void atualizarSeguroTPP(List<Ruta> lsRuta, Integer orgaoId, TipoSeguro tipoSeguro) throws BusinessException {
		
		List<Integer> lsOrgaoId = new ArrayList<Integer>();
		
		if (orgaoId == null) {
			lsOrgaoId.addAll(orgaoConcedenteDAO.obtenerTodosIds());
		} else {
			lsOrgaoId.add(orgaoId);
		}
		
		int x = 0;
		if(lsRuta != null && !lsRuta.isEmpty()){
			x = lsRuta.size();
		}
		
		do{
			Integer rutaId = null;
			if(lsRuta != null && !lsRuta.isEmpty()){
				rutaId = lsRuta.get(x-1).getRutaId();
			}
			//O seguro por km é preferencial em relação ao por tarifa.
			for (Integer orgaoConcedenteId : lsOrgaoId) {
				if (seguroKmDAO.existe(orgaoConcedenteId)) {
					atualizarSeguroPorKmTPP(rutaId, orgaoConcedenteId, tipoSeguro);
				}
			}
			x--;
		} while (x > 0);
	}

	@Override
	@Transactional
	public void aplicarArredondamentoTarifa(Integer orgaoConcedenteId, Boolean taxaEmbarque) {
		tarifaOficialDAO.aplicarArredondamentoTarifa(orgaoConcedenteId, UsuarioLogado.getUsuarioLogado().getUsuarioId(), taxaEmbarque);
	}

	@Override
	@Transactional
	public void actualizacion(TarifaOficial tarifaOficial) {
		try {
			TarifaOficial originalClone = tarifaOficial.getCloneObject();
			tarifaOficialDAO.actualizacion(tarifaOficial);
			logAuditoriaService.auditar(originalClone, tarifaOficial, tarifaOficial.getMarca() != null && tarifaOficial.getMarca().getEmpresa() != null ? tarifaOficial.getMarca().getEmpresa().getEmpresaId() : null);
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new RuntimeException(e.getMessage(), e);
		}
	}

	@Override
	public TarifaOficial obtenerID(Integer tarifaOficialId) {
		TarifaOficial tarifaOficial = tarifaOficialDAO.obtenerID(tarifaOficialId);
		try {
			tarifaOficial.clonar();
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
		return tarifaOficial;
	}

	@Override
	@Transactional
	public void borrar(TarifaOficial tarifaOficial) {
		tarifaOficialDAO.borrar(tarifaOficial);
		logAuditoriaService.auditarExclusao(tarifaOficial, tarifaOficial.getMarca() != null && tarifaOficial.getMarca().getEmpresa() != null ? tarifaOficial.getMarca().getEmpresa().getEmpresaId() : null);		
	}

	@Override
	public long obtenerCount(List<Empresa> lstEmpresas){
		return tarifaOficialDAO.obtenerCount(lstEmpresas);
	}
	
	@Override
	@Transactional
	public void atualizarPedagio() {
		tarifaOficialDAO.atualizarPedagio();
	}

	@Override
	public List<TarifaOficial> obterTarifaOficialPorFiltro(Moneda moneda, Marca marca,List<Marca> lsMarcas,Parada origem, Parada destino, ClaseServicio claseServicio, Ruta ruta, String numRuta, Boolean vende){
		return  converterVo(tarifaOficialDAO.obterTarifaOficialPorFiltroVO(moneda, marca, lsMarcas, origem, destino, claseServicio, ruta, numRuta, vende));
	}
	public List<TarifaOficial> converterVo(List<TarifaOficialVO> lsTarifaOficialVo){
		List<TarifaOficial> lsTarifa= new ArrayList<TarifaOficial>();
		TarifaOficial ta;
		Parada origem;
		Parada destino;
		Tramo tramo;
		Marca marca;
		Via via;
		
		for(TarifaOficialVO t:lsTarifaOficialVo){
			 ta= new TarifaOficial();
			 ta.setTarifaOficialId(t.getTarifaoficialid());
			 ta.setPrecio(t.getPrecio());
			 ta.setPreciooriginal(t.getPreciooriginal());
			 ta.setImportepedagio(t.getImportepedagio());
			 ta.setImporteseguro(t.getImporteseguro());
			 ta.setImportetaxaembarque(t.getImportetaxaembarque());
			 ta.setImporteoutros(t.getImporteoutros());
			 ta.setImportetpp(t.getImportetpp());
			 origem = new Parada();
			 origem.setDescparada(t.getDescparadaorigem());
			 destino = new Parada();
			 destino.setDescparada(t.getDescparadadestino());
			 via =new Via();
			 via.setNombvia(t.getNomevia());
			 tramo = new Tramo();
			 tramo.setOrigem(origem);
			 tramo.setDestino(destino);
			 tramo.setVia(via);
			 ta.setTramo(tramo);
			 marca= new Marca();
			 marca.setDescmarca(t.getDescmarca());
			 ta.setMarca(marca);
			 OrgaoConcedente or = new OrgaoConcedente();
			 or.setDescOrgao(t.getDescorgao());
			 ta.setOrgaoConcedente(or);
			 ClaseServicio cl = new ClaseServicio();
			 cl.setDescclase(t.getDescclasse());
			 ta.setClaseServicio(cl);
			 Ruta r = new Ruta();
			 r.setPrefixo(t.getRutaprefixo());
			 r.setNumRuta(t.getNumruta());
			 ta.setRuta(r);
			 lsTarifa.add(ta);
			
		}
		return lsTarifa;
	}
	

	public void atualizarPedagioPorListaDePracaDePagio(List<CasetaPeaje> lsCasetaPeaje,Integer empresaId) {
        try {
		List<TarifaOficialComComposicaoDoPedagioVo> lsTarifaOficialComComposicaoDoPedagioVo = tarifaOficialDAO.oberTarifaOficialComComposicaoDoPedagioVo(empresaId);
       
		if (!lsTarifaOficialComComposicaoDoPedagioVo.isEmpty()) {
			log.info("tamanho da lsTarifaOficialComComposicaoDoPedagioVo: " + lsTarifaOficialComComposicaoDoPedagioVo.size());
			

			for (TarifaOficialComComposicaoDoPedagioVo tarifaOficialComComposicaoDoPedagioVo : lsTarifaOficialComComposicaoDoPedagioVo) {
				log.info("tarifaOficiald:" + tarifaOficialComComposicaoDoPedagioVo.getTarifaOficialId() + " | composicao do pedágio no cálculo:" + tarifaOficialComComposicaoDoPedagioVo.getComposicaoDoPedagioNaTarifaOficialComPeaje() + " | composicao do pedágio na tarifa:" + tarifaOficialComComposicaoDoPedagioVo.getComposicaoDoPedagioNaTarifa());
				
				if (StringUtils.isBlank(tarifaOficialComComposicaoDoPedagioVo.getComposicaoDoPedagioNaTarifa())|| tarifaOficialComComposicaoDoPedagioVo.getComposicaoDoPedagioNaTarifa().equalsIgnoreCase("null") ) {
					HashMap<Integer, Integer> mapComposicaoDoPedagioNaTarifaOficialComPeaje = new HashMap();
					String[] parDeChavePeajeMaisCasetaPeaje1 = tarifaOficialComComposicaoDoPedagioVo.getComposicaoDoPedagioNaTarifaOficialComPeaje().replace(" ", "").split(",");
					montaMapComposicao(mapComposicaoDoPedagioNaTarifaOficialComPeaje, parDeChavePeajeMaisCasetaPeaje1);
					BigDecimal valorPedagio = montarObterValorImportePedagio(mapComposicaoDoPedagioNaTarifaOficialComPeaje);
					String stringComposicaoDoPedagio = tarifaOficialComComposicaoDoPedagioVo.getComposicaoDoPedagioNaTarifaOficialComPeaje();

					atualizarPedagioComFiltroDePracaDePedagio(tarifaOficialComComposicaoDoPedagioVo, valorPedagio, stringComposicaoDoPedagio);

				} else {
					HashMap<Integer, Integer> mapComposicaoDoPedagioNaTarifa = new HashMap();
					String[] parDeChavePeajeMaisCasetaPeaje = tarifaOficialComComposicaoDoPedagioVo.getComposicaoDoPedagioNaTarifa().replace(" ", "").split(",");
					montaMapComposicao(mapComposicaoDoPedagioNaTarifa, parDeChavePeajeMaisCasetaPeaje);

					HashMap<Integer, Integer> mapComposicaoDoPedagioNaTarifaOficialComPeaje = new HashMap();
					String[] parDeChavePeajeMaisCasetaPeaje1 = tarifaOficialComComposicaoDoPedagioVo.getComposicaoDoPedagioNaTarifaOficialComPeaje().replace(" ", "").split(",");
					montaMapComposicao(mapComposicaoDoPedagioNaTarifaOficialComPeaje, parDeChavePeajeMaisCasetaPeaje1);

					atualizarComposicaoDoPedagioNaTarifa(lsCasetaPeaje, mapComposicaoDoPedagioNaTarifa, mapComposicaoDoPedagioNaTarifaOficialComPeaje);

					BigDecimal valorPedagio = montarObterValorImportePedagio(mapComposicaoDoPedagioNaTarifa);

					String stringComposicaoDoPedagio = "";
					stringComposicaoDoPedagio = remontarAStringDeComposicaoDoPedagio(mapComposicaoDoPedagioNaTarifa, stringComposicaoDoPedagio);

					atualizarPedagioComFiltroDePracaDePedagio(tarifaOficialComComposicaoDoPedagioVo, valorPedagio, stringComposicaoDoPedagio);

				}
				
			}
		} else {
			log.info("NÃO retornou nenhum registro da consulta oberTarifaOficialComComposicaoDoPedagioVo ");
		}
        }catch (Exception e) {
			// TODO: handle exception
        	e.printStackTrace();
		}

	}

	private void atualizarPedagioComFiltroDePracaDePedagio(TarifaOficialComComposicaoDoPedagioVo tarifaOficialComComposicaoDoPedagioVo, BigDecimal valorPedagio, String stringComposicaoDoPedagio) {
		log.info("tarifaOficiald:"+tarifaOficialComComposicaoDoPedagioVo.getTarifaOficialId()+" | composicao do pedágio na tarifa oficial:" + tarifaOficialComComposicaoDoPedagioVo.getComposicaoDoPedagioNaTarifaOficialComPeaje() +" | importePedagio:"+valorPedagio);
		
		tarifaOficialDAO.atualizarPedagioComFiltroDePracaDePedagio(tarifaOficialComComposicaoDoPedagioVo.getTarifaOficialId(), valorPedagio, stringComposicaoDoPedagio);
	}

	private String remontarAStringDeComposicaoDoPedagio(HashMap<Integer, Integer> mapComposicaoDoPedagioNaTarifa, String stringComposicaoDoPedagio) {
		Boolean inicio =true;
		
		for(Entry<Integer, Integer> map : mapComposicaoDoPedagioNaTarifa.entrySet()) {
			if(!inicio) {
				stringComposicaoDoPedagio += ",";
			}
			stringComposicaoDoPedagio += map.getKey()+";"+map.getValue();
			inicio=false;
		}
		return stringComposicaoDoPedagio;
	}

	private BigDecimal montarObterValorImportePedagio(HashMap<Integer, Integer> mapComposicaoDoPedagioNaTarifa) {
		 BigDecimal valorPedagio = new BigDecimal("0.0");
		for(Entry<Integer, Integer> map : mapComposicaoDoPedagioNaTarifa.entrySet()) {
			Peaje peaje = peajeService.buscarPeajePorId(map.getValue());
			valorPedagio=valorPedagio.add(peaje.getImportePeaje().setScale(2,RoundingMode.HALF_UP));
			
		}
		 return valorPedagio.setScale(2,RoundingMode.HALF_UP);
		
	}

	private void  atualizarComposicaoDoPedagioNaTarifa(List<CasetaPeaje> lsCasetaPeaje, HashMap<Integer, Integer> mapComposicaoDoPedagioNaTarifa, Map<Integer, Integer> mapComposicaoDoPedagioNaTarifaOficialComPeaje) {
		for(CasetaPeaje casetaPeaje : lsCasetaPeaje) {
			if(mapComposicaoDoPedagioNaTarifa.containsKey(casetaPeaje.getCasetaPeajeId())) {
				mapComposicaoDoPedagioNaTarifa.remove(casetaPeaje.getCasetaPeajeId());
			}
			
			if(mapComposicaoDoPedagioNaTarifaOficialComPeaje.containsKey(casetaPeaje.getCasetaPeajeId())) {
				mapComposicaoDoPedagioNaTarifa.put(casetaPeaje.getCasetaPeajeId(),mapComposicaoDoPedagioNaTarifaOficialComPeaje.get(casetaPeaje.getCasetaPeajeId()));
			}
			
		}
	}

	private void montaMapComposicao(Map<Integer, Integer> mapComposicaoDoPedagioNaTarifa, String[] parDeChavePeajeMaisCasetaPeaje) {
		for(String chavePeajeMaisCasetaPeaje:parDeChavePeajeMaisCasetaPeaje) {
			String[] composicao =	chavePeajeMaisCasetaPeaje.split(";");
			Integer casetaPeaje = Integer.parseInt(composicao[0].trim());
			Integer peaje = Integer.parseInt(composicao[1].trim());				
		 	mapComposicaoDoPedagioNaTarifa.put(casetaPeaje,peaje);
		}
	}
	
	public static void main(String[] args) {
		 BigDecimal valorPedagio = new BigDecimal("0.0");
		
		 valorPedagio=valorPedagio.add(new BigDecimal("100.005"));
		 System.out.println(valorPedagio.setScale(2,RoundingMode.HALF_UP));
	}

}
