package com.rjconsultores.ventaboletos.service.impl;

import java.io.ByteArrayOutputStream;
import java.math.BigDecimal;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.BooleanUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.zkoss.util.resource.Labels;

import com.rjconsultores.ventaboletos.constantes.Constantes;
import com.rjconsultores.ventaboletos.constantes.TipoEventoExtra;
import com.rjconsultores.ventaboletos.dao.ComissaoDAO;
import com.rjconsultores.ventaboletos.dao.ConferenciaComissaoDAO;
import com.rjconsultores.ventaboletos.entidad.Comissao;
import com.rjconsultores.ventaboletos.entidad.Conferencia;
import com.rjconsultores.ventaboletos.entidad.Constante;
import com.rjconsultores.ventaboletos.entidad.DescontoComissao;
import com.rjconsultores.ventaboletos.entidad.Empresa;
import com.rjconsultores.ventaboletos.entidad.EmpresaImposto;
import com.rjconsultores.ventaboletos.entidad.PtovtaComissao;
import com.rjconsultores.ventaboletos.entidad.PtovtaComissao.Receita;
import com.rjconsultores.ventaboletos.entidad.PuntoVenta;
import com.rjconsultores.ventaboletos.enums.IndStatusBoleto;
import com.rjconsultores.ventaboletos.enums.MimeType;
import com.rjconsultores.ventaboletos.exception.BusinessException;
import com.rjconsultores.ventaboletos.exception.ComissaoException;
import com.rjconsultores.ventaboletos.service.CalculoComissaoService;
import com.rjconsultores.ventaboletos.service.ComissaoService;
import com.rjconsultores.ventaboletos.service.ConferenciaComissaoService;
import com.rjconsultores.ventaboletos.service.ConstanteService;
import com.rjconsultores.ventaboletos.service.DescontoComissaoService;
import com.rjconsultores.ventaboletos.service.EmpresaImpostoService;
import com.rjconsultores.ventaboletos.service.PtovtaComissaoService;
import com.rjconsultores.ventaboletos.utilerias.DateUtil;
import com.rjconsultores.ventaboletos.utilerias.MoneyHelper;
import com.rjconsultores.ventaboletos.utilerias.SendMail;
import com.rjconsultores.ventaboletos.vo.comissao.BoletoComissao;
import com.rjconsultores.ventaboletos.vo.comissao.ComissaoDesconto;
import com.rjconsultores.ventaboletos.vo.comissao.ComissaoDesconto.TipoDesconto;
import com.rjconsultores.ventaboletos.vo.comissao.ComissaoReceita;
import com.rjconsultores.ventaboletos.vo.comissao.EventosFinanceirosVO;
import com.rjconsultores.ventaboletos.vo.comissao.HistoricoComissao;
import com.rjconsultores.ventaboletos.vo.comissao.RegistroCalculo;

@Service("calculoComissaoService")
public class CalculoComissaoServiceImpl implements CalculoComissaoService {

	private static final Logger log = LoggerFactory.getLogger(CalculoComissaoServiceImpl.class);
	private static final BigDecimal CEM = BigDecimal.TEN.multiply(BigDecimal.TEN);
	
	@Autowired
	private PtovtaComissaoService ptovtaComissaoService;

	@Autowired
	private EmpresaImpostoService empresaImpostoService;

	@Autowired
	private ComissaoService comissaoService;

	@Autowired
	private ComissaoDAO comissaoDAO;

	@Autowired
	private ConferenciaComissaoDAO conferenciaComissaoDAO;
	
	@Autowired
	private ConferenciaComissaoService conferenciaComissaoService; 

	@Autowired
	private DescontoComissaoService descontoComissaoService;
	
	@Autowired
	private ConstanteService constanteService;
	
	public boolean validaCompetencia(Date periodo) {
		Calendar calendario = Calendar.getInstance();
		calendario.setTime(periodo);

		int mes = calendario.get(Calendar.MONTH) + 1;
		int ano = calendario.get(Calendar.YEAR);

		Calendar now = Calendar.getInstance();
		int mesNow = now.get(Calendar.MONTH) + 1;
		int anoNow = now.get(Calendar.YEAR);

		if (anoNow == ano) {
			if (mesNow > mes) {
				return true;
			}

		} else if (anoNow > ano) {
			return true;
		}

		return false;
	}

	@Override
	public void registrarCalculoComissao(PuntoVenta puntoVenta, Empresa empresa, Date periodo, boolean ignorarComissaoGerada) throws ComissaoException {
		
		try {
			
			if (validaCompetencia(periodo)) {
	
				String competencia = DateUtil.getStringDate(periodo, "MM/yyyy");
				
				if(conferenciaComissaoService.isConferenciaCompetenciaEncerrada(competencia, empresa, puntoVenta)) {
					Comissao comissaoCadastrada = comissaoDAO.buscaComissaoVigencia(puntoVenta.getPuntoventaId(), empresa.getEmpresaId(), competencia);
					if (comissaoCadastrada == null) {
		
						RegistroCalculo rc = realizarCalculoComissao(puntoVenta.getPuntoventaId(), empresa.getEmpresaId(), periodo);
		
						Comissao comissao = new Comissao();
						comissao.setCompetencia(competencia);
						comissao.setEmpresaId(empresa.getEmpresaId());
						comissao.setPuntoVenta(puntoVenta);
						comissao.setBonificacaoMetas(rc.getComissaoBonificaoMetas());
						comissao.setComissaoBpr(rc.getComissaoBPR());
						comissao.setEntregasPassagem(rc.getComissaoEntregaPassagem());
						comissao.setReceitaExcessobagagem(rc.getComissaoExcessoBagagem());
						comissao.setReceitaSeguroopcional(rc.getComissaoSegOpcional());
						comissao.setReceitaOutros(rc.getComissaoOutros());
						comissao.setRoyaties(rc.getRoyaties());
						comissao.setIssRetido(rc.getRetidoISS());
		
						comissao.setIndPago(false);
						comissao.setUsuarioPagamentoId(null);
						comissao.setDataPagamento(null);
						comissao.setDescontosEventuais(BigDecimal.ZERO);
						comissao.setDescontosFixos(BigDecimal.ZERO);
		
						for (ComissaoDesconto cd : rc.getLsDescontos()) {
							if (cd.getTipo().equals(TipoDesconto.EVENTUAL)) {
								comissao.setDescontosEventuais(cd.getValorDesconto());
							} else if (cd.getTipo().equals(TipoDesconto.FIXO)) {
								comissao.setDescontosFixos(cd.getValorDesconto());
							}
						}
						
						for (ComissaoReceita comissaoReceita : rc.getLsReceitas()) {
							comissao.setReceitaBPR(MoneyHelper.somar(comissao.getReceitaBPR(), comissaoReceita.getReceitaBPR(), 2));
							comissao.setDevolvidos(MoneyHelper.somar(comissao.getDevolvidos(), comissaoReceita.getDevolvidosRelatorio(), 2));
							comissao.setDevolvidos(MoneyHelper.somar(comissao.getDevolvidos(), comissaoReceita.getDevolvidosGAPRelatorio(), 2));
							comissao.setDevolvidos(MoneyHelper.somar(comissao.getDevolvidos(), comissaoReceita.getCancelados(), 2));
							comissao.setDevolvidos(MoneyHelper.somar(comissao.getDevolvidos(), comissaoReceita.getCanceladosGAP(), 2));
							comissao.setDevolvidos(MoneyHelper.somar(comissao.getDevolvidos(), comissaoReceita.getCanceladosGAP(), 2));
							comissao.setReceitaBrutaExcessoBagagem(MoneyHelper.somar(comissao.getReceitaBrutaExcessoBagagem(), comissaoReceita.getReceitaExcessoBagagem(), 2));
							comissao.setReceitaBrutaSeguroopcional(MoneyHelper.somar(comissao.getReceitaBrutaSeguroopcional(), comissaoReceita.getReceitaSeguroOpcional(), 2));
						}
		
						comissao = comissaoService.suscribir(comissao);
					} else if(!ignorarComissaoGerada){
						throw new ComissaoException("busquedaCalculoComissaoController.registro.exception", null, comissaoCadastrada.getPuntoVenta().getNombpuntoventa());
					}
				} else {
					throw new ComissaoException("busquedaCalculoComissaoController.conferenciaNaoEncerrada.exception", null, puntoVenta.getNombpuntoventa());
				}
			} else {
				throw new ComissaoException("busquedaCalculoComissaoController.competencia.exception");
			}
		
		} catch (ComissaoException e) {
			throw e;
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			throw new ComissaoException(e.getMessage(), e);
		}
	}

	@Override
	public void cancelarCalculoComissao(Integer puntoVentaId, Integer empresaId, Date periodo) throws ComissaoException {

		String competencia = DateUtil.getStringDate(periodo, "MM/yyyy");
		Comissao comissao = comissaoDAO.buscaComissaoVigencia(puntoVentaId, empresaId, competencia);
		if (comissao != null) {
			comissaoService.borrar(comissao);

		} else {
			throw new ComissaoException("busquedaCalculoComissaoController.comissao.exception");
		}
	}

	@Override
	public RegistroCalculo relatorioCalculoComissao(Integer puntoVentaId, Integer empresaId, Date periodo) throws ComissaoException, BusinessException {
		return realizarCalculoComissao(puntoVentaId, empresaId, periodo);
	}

	private BigDecimal calculoComisssaoBPR(boolean isAltaTemporada, PtovtaComissao ptovtaComissao, BigDecimal bpr, BigDecimal gap) {

		// Comissão BPR = Receita Comissão * (% Com BPR)
		BigDecimal recbpr = BigDecimal.ZERO;
		BigDecimal receitaBPR = MoneyHelper.somar(bpr, gap, 2);
		if (isAltaTemporada) {
			recbpr = MoneyHelper.multiplicar(receitaBPR, MoneyHelper.dividir(  ptovtaComissao.getPassagemAlta() != null ? ptovtaComissao.getPassagemAlta() : BigDecimal.ZERO,CEM,4), 4);
		} else {
			recbpr = MoneyHelper.multiplicar(receitaBPR, MoneyHelper.dividir(  ptovtaComissao.getPassagemBaixa() != null ? ptovtaComissao.getPassagemBaixa() : BigDecimal.ZERO,CEM,4), 4);
		}

		recbpr = MoneyHelper.arredondar(recbpr);
		return recbpr;
	}

	private BigDecimal calculoEntregaPassagem(boolean isAltaTemporada, PtovtaComissao ptovtaComissao, BigDecimal gapImpressa, BigDecimal internet, int contImpressa) {

		// EntregaPassagem (Internet/Venda Impressão Posterior/Outros)
		BigDecimal entregaPassagem = BigDecimal.ZERO;
		BigDecimal receitaEntrega = MoneyHelper.somar(gapImpressa, internet, 2);
		if(ptovtaComissao.getValorImpressaoGap() != null) {
			if (BooleanUtils.toBoolean(ptovtaComissao.getIndimpressaogapporc())) {
				entregaPassagem = MoneyHelper.multiplicar(receitaEntrega, ptovtaComissao.getValorImpressaoGap() != null ? MoneyHelper.dividir(ptovtaComissao.getValorImpressaoGap(),CEM,4) : BigDecimal.ZERO, 2);
			} else {
				entregaPassagem = ptovtaComissao.getValorImpressaoGap() != null ? MoneyHelper.multiplicar(ptovtaComissao.getValorImpressaoGap(),new BigDecimal(contImpressa), 2) : BigDecimal.ZERO;
			}
		}

		return entregaPassagem;
	}

	private BigDecimal calculoExcessoBagagem(boolean isAltaTemporada, PtovtaComissao ptovtaComissao, BigDecimal excBag) {

		// Comissão Excesso = Receita Excesso Bagagem * (% Com. Exc. Bag)
		BigDecimal excessoBagagem = BigDecimal.ZERO;
		if (isAltaTemporada) {
			excessoBagagem = MoneyHelper.multiplicar(excBag, ptovtaComissao.getExcessoAlta() != null ? MoneyHelper.dividir(ptovtaComissao.getExcessoAlta(), CEM,4) : BigDecimal.ZERO, 2);
		} else {
			excessoBagagem = MoneyHelper.multiplicar(excBag, ptovtaComissao.getExcessoBaixa() != null ? MoneyHelper.dividir(ptovtaComissao.getExcessoBaixa(), CEM,4) : BigDecimal.ZERO, 2);
		}

		return excessoBagagem;
	}

	private BigDecimal calculoSeguroOpcional(boolean isAltaTemporada, PtovtaComissao ptovtaComissao, BigDecimal segOpcional) {

		// Comissão Seg. Opcional = Receita Seguro Opcional * (% Com. Seg. Pol)
		BigDecimal recsegOpcional = BigDecimal.ZERO;
		if (isAltaTemporada) {
			recsegOpcional = MoneyHelper.multiplicar(segOpcional, ptovtaComissao.getSeguroAlta() != null ? MoneyHelper.dividir(ptovtaComissao.getSeguroAlta(), CEM,4) : BigDecimal.ZERO, 2);
		} else {
			recsegOpcional = MoneyHelper.multiplicar(segOpcional, ptovtaComissao.getSeguroBaixa() != null ? MoneyHelper.dividir(ptovtaComissao.getSeguroBaixa(), CEM,4) : BigDecimal.ZERO, 2);
		}
		return recsegOpcional;
	}

	private BigDecimal calculoOutros(boolean isAltaTemporada, PtovtaComissao ptovtaComissao, BigDecimal outros) {

		// Comissão Seg. Opcional = Receita Seguro Opcional * (% Com. Seg. Pol)
		BigDecimal recoutros = BigDecimal.ZERO;
		if (isAltaTemporada) {
			recoutros = MoneyHelper.multiplicar(outros, ptovtaComissao.getOutrosAlta() != null ? MoneyHelper.dividir(ptovtaComissao.getOutrosAlta(), CEM,4) : BigDecimal.ZERO, 2);
		} else {
			recoutros = MoneyHelper.multiplicar(outros, ptovtaComissao.getOutrosBaixa() != null ? MoneyHelper.dividir(ptovtaComissao.getOutrosBaixa(), CEM,4) : BigDecimal.ZERO, 2);
		}
		return recoutros;
	}

	private Map<String, Object> calculoDescontos(Integer puntoVentaId, Integer empresaId, Date periodo, PtovtaComissao ptovtaComissao) {

		List<ComissaoDesconto> lsDescontos = new ArrayList<ComissaoDesconto>();
		BigDecimal valorDescontoTotal = BigDecimal.ZERO;

		Date inicioPeriodo = DateUtil.inicioFechaPeriodoMeses(periodo);
		Date fimPeriodo = DateUtil.fimFechaPeriodoMeses(periodo);
		List<DescontoComissao> itensDescontos = descontoComissaoService.buscaDescontoComissaoPeriodo(puntoVentaId, empresaId, inicioPeriodo, fimPeriodo);

		for (DescontoComissao dc : itensDescontos) {

			BigDecimal valorDesconto = dc.getPreco();
			valorDescontoTotal = MoneyHelper.somar(valorDescontoTotal, valorDesconto, 2);

			ComissaoDesconto desconto = new ComissaoDesconto();
			if (dc.getDatafinal() == null) {
				desconto.setTipo(TipoDesconto.FIXO);
			} else {
				desconto.setTipo(TipoDesconto.EVENTUAL);
			}
			desconto.setNomeDesconto(dc.getItemDesconto().getNomitemdesconto());
			desconto.setValorDesconto(valorDesconto);

			lsDescontos.add(desconto);
		}

		Map<String, Object> respDescontos = new HashMap<String, Object>();
		respDescontos.put("LISTA_DESCONTOS", lsDescontos);
		respDescontos.put("VALOR_DESCONTOS", valorDescontoTotal);

		return respDescontos;
	}

	@SuppressWarnings("unchecked")
	public RegistroCalculo realizarCalculoComissao(Integer puntoVentaId, Integer empresaId, Date periodo) throws ComissaoException, BusinessException {

		PtovtaComissao ptovtaComissao = ptovtaComissaoService.buscarPuntaVentaEmpresa(puntoVentaId, empresaId);
		if (ptovtaComissao != null) {

			Conferencia conferencia = new Conferencia();
			conferencia.setPuntoVenta(new PuntoVenta(puntoVentaId));
			conferencia.setEmpresa(new Empresa(empresaId));
			conferencia.setCompetencia(DateUtil.getStringDate(periodo, "MM/yyyy"));
			List<BoletoComissao> receitasBoleto = conferenciaComissaoDAO.carregarBilhetesComissao(conferencia);
			List<EventosFinanceirosVO> eventosFinanceirosVOs = conferenciaComissaoDAO.carregarEventosFinanceiros(conferencia);

			Calendar calendario = Calendar.getInstance();
			calendario.setTime(periodo);

			int ultimodia = calendario.getActualMaximum(Calendar.DAY_OF_MONTH);
			int mes = calendario.get(Calendar.MONTH) + 1;
			int ano = calendario.get(Calendar.YEAR);

			List<ComissaoReceita> receitas = calculaReceitaComissao(empresaId, ptovtaComissao, receitasBoleto, ultimodia, mes, ano, eventosFinanceirosVOs);

			RegistroCalculo rc = new RegistroCalculo();
			rc.setNombpuntoventa(ptovtaComissao.getPuntoventaId().getNombpuntoventa());
			rc.setNumPuntoVenta(ptovtaComissao.getPuntoventaId().getNumPuntoVenta());

			BigDecimal comissaoBPR = BigDecimal.ZERO;
			BigDecimal comissaoExcessoBagagem = BigDecimal.ZERO;
			BigDecimal comissaoSegOpcional = BigDecimal.ZERO;
			BigDecimal comissaoEntregaPassagem = BigDecimal.ZERO;
			BigDecimal comissaoOutros = BigDecimal.ZERO;
			BigDecimal receitaTotal = BigDecimal.ZERO;
			BigDecimal comissaoTotal = BigDecimal.ZERO;

			for (ComissaoReceita cr : receitas) {
				receitaTotal = MoneyHelper.somar(receitaTotal, cr.getReceitaComissao());
				comissaoBPR = MoneyHelper.somar(comissaoBPR, cr.getComissaoBPRDiaria());
				comissaoEntregaPassagem = MoneyHelper.somar(comissaoEntregaPassagem, cr.getComissaoEntregaPassagemDiaria());
				comissaoExcessoBagagem = MoneyHelper.somar(comissaoExcessoBagagem, cr.getComissaoExcessoBagagemDiaria());
				comissaoSegOpcional = MoneyHelper.somar(comissaoSegOpcional, cr.getComissaoSegOpcionalDiaria());
				comissaoOutros = MoneyHelper.somar(comissaoOutros, cr.getComissaoOutrosDiaria());
				comissaoTotal = MoneyHelper.somar(comissaoTotal, cr.getTotalComissao());
			}

			rc.setLsReceitas(receitas);

			rc.setComissaoBPR(comissaoBPR);
			rc.setComissaoExcessoBagagem(comissaoExcessoBagagem);
			rc.setComissaoSegOpcional(comissaoSegOpcional);
			rc.setComissaoEntregaPassagem(comissaoEntregaPassagem);
			rc.setComissaoOutros(comissaoOutros);

			// Descontos (Fixos e Eventuais)
			Map<String, Object> respDescontos = calculoDescontos(puntoVentaId, empresaId, periodo, ptovtaComissao);
			rc.setDescontos((BigDecimal) respDescontos.get("VALOR_DESCONTOS"));
			rc.setLsDescontos((List<ComissaoDesconto>) respDescontos.get("LISTA_DESCONTOS"));

			/**
			 * Bonificação Metas - Meta = Eh o valor estipulado de receita dentro do periodo que a agencia deve alcançar. - Bonificação = Eh uma porcentagem paga encima da comissao, por alcançar a meta.
			 */
			BigDecimal comissaoBonificaoMetas = BigDecimal.ZERO;
			rc.setComissaoBonificaoMetas(comissaoBonificaoMetas);

			// Royaties
			BigDecimal royaties = BigDecimal.ZERO;
			if(ptovtaComissao.getRoyalties() != null) {
				royaties = MoneyHelper.multiplicar(receitaTotal, MoneyHelper.dividir(ptovtaComissao.getRoyalties(), CEM));
			}
			rc.setRoyaties(royaties);

			// ISS retido
			BigDecimal issRetido = BigDecimal.ZERO;
			if(ptovtaComissao.getIssretido() != null) {
				issRetido = MoneyHelper.multiplicar(comissaoTotal, MoneyHelper.dividir(ptovtaComissao.getIssretido(), CEM));
			}
			rc.setRetidoISS(issRetido);

			// Comissão à pagar = Comissão BPR + Comissão Excesso Bagagem + Comissão Seg. Opcional + Bonificação Metas + Internet(EntregaPassagem)
			BigDecimal comissaoPagar = BigDecimal.ZERO;
			comissaoPagar = MoneyHelper.somar(comissaoPagar,comissaoBPR);
			comissaoPagar = MoneyHelper.somar(comissaoPagar,comissaoExcessoBagagem);
			comissaoPagar = MoneyHelper.somar(comissaoPagar,comissaoSegOpcional);
			comissaoPagar = MoneyHelper.somar(comissaoPagar,comissaoEntregaPassagem);
			comissaoPagar = MoneyHelper.somar(comissaoPagar,comissaoOutros);
			comissaoPagar = MoneyHelper.somar(comissaoPagar,comissaoBonificaoMetas);

			// - Descontos (Fixos e Eventuais) - Royaties - ISS retido
			comissaoPagar = MoneyHelper.subtrair(comissaoPagar,rc.getDescontos());
			comissaoPagar = MoneyHelper.subtrair(comissaoPagar,royaties);
			comissaoPagar = MoneyHelper.subtrair(comissaoPagar,issRetido);
			rc.setComissaoPagar(comissaoPagar);

			return rc;
		} else {
			throw new ComissaoException("busquedaCalculoComissaoController.PtovtaComissao.exception");
		}

	}

	private boolean validaAltaTemporada(List<EmpresaImposto> impostos, int mes, int estadoId) {

		for (EmpresaImposto ei : impostos) {
			if (ei.getEstado().getEstadoId().equals(estadoId)) {
				switch (mes - 1) {
				case Calendar.JANUARY:
					return ei.getIndJaneiro() == null ? false : ei.getIndJaneiro();
				case Calendar.FEBRUARY:
					return ei.getIndFevereiro() == null ? false : ei.getIndFevereiro();
				case Calendar.MARCH:
					return ei.getIndMarco() == null ? false : ei.getIndMarco();
				case Calendar.APRIL:
					return ei.getIndAbril() == null ? false : ei.getIndAbril();
				case Calendar.MAY:
					return ei.getIndMaio() == null ? false : ei.getIndMaio();
				case Calendar.JUNE:
					return ei.getIndJunho() == null ? false : ei.getIndJunho();
				case Calendar.JULY:
					return ei.getIndJulho() == null ? false : ei.getIndJulho();
				case Calendar.AUGUST:
					return ei.getIndAgosto() == null ? false : ei.getIndAgosto();
				case Calendar.SEPTEMBER:
					return ei.getIndSetembro() == null ? false : ei.getIndSetembro();
				case Calendar.OCTOBER:
					return ei.getIndOutubro() == null ? false : ei.getIndOutubro();
				case Calendar.NOVEMBER:
					return ei.getIndNovembro() == null ? false : ei.getIndNovembro();
				case Calendar.DECEMBER:
					return ei.getIndDezembro() == null ? false : ei.getIndDezembro();
				default:
					break;
				}
			}
		}

		return false;
	}

	private List<ComissaoReceita> calculaReceitaComissao(Integer empresaId, PtovtaComissao ptovtaComissao, List<BoletoComissao> receitasBoleto, Integer ultimodia, Integer mes, Integer ano, List<EventosFinanceirosVO> eventosFinanceirosVOs) {

		List<EmpresaImposto> impostos = empresaImpostoService.buscarEmpresaImposto(empresaId);

		List<ComissaoReceita> receitas = new ArrayList<ComissaoReceita>();
		for (int dia = 1; dia <= ultimodia; dia++) {

			List<BoletoComissao> list = verificaCalculoComissaoProDia(receitasBoleto, dia, mes);

			Calendar dataRegistro = Calendar.getInstance();
			dataRegistro.set(Calendar.DAY_OF_MONTH, dia);
			dataRegistro.set(Calendar.MONTH, mes - 1);
			dataRegistro.set(Calendar.YEAR, ano);

			ComissaoReceita cr = new ComissaoReceita();
			cr.setData(dataRegistro.getTime());

			BigDecimal receitaComissao = BigDecimal.ZERO;

			BigDecimal receitaBPR = BigDecimal.ZERO;
			BigDecimal receitaGAP = BigDecimal.ZERO;
			BigDecimal internet = BigDecimal.ZERO;
			BigDecimal receitaExcessoBagagem = BigDecimal.ZERO;
			BigDecimal receitaSeguroOpcional = BigDecimal.ZERO;
			BigDecimal receitaSeguroOutros = BigDecimal.ZERO;

			BigDecimal cancelados = BigDecimal.ZERO;
			BigDecimal devolvidos = BigDecimal.ZERO;
			BigDecimal devolvidosOrigem = BigDecimal.ZERO;
			BigDecimal canceladosGAP = BigDecimal.ZERO;
			BigDecimal devolvidosGAP = BigDecimal.ZERO;
			BigDecimal devolvidosGAPOrigem = BigDecimal.ZERO;

			BigDecimal gapImpressa = BigDecimal.ZERO;
			int contImpressa = 0;

			BigDecimal comissaoBPR = BigDecimal.ZERO;
			BigDecimal comissaoExcessoBagagem = BigDecimal.ZERO;
			BigDecimal comissaoSegOpcional = BigDecimal.ZERO;
			BigDecimal comissaoEntregaPassagem = BigDecimal.ZERO;
			BigDecimal comissaoOutros = BigDecimal.ZERO;

			// Receita Total -- bruta/liquida - abatimento do valor do icms
			boolean isReceitaLiquida = false;
			Receita receita = Receita.getByValor(ptovtaComissao.getReceita());
			if (receita.equals(Receita.RECEITALIQUIDA)) {
				isReceitaLiquida = true;
			}

			/* Calculando comissão para os boletos */
			for (BoletoComissao rcc : list) {

				boolean isAltaTemporada = validaAltaTemporada(impostos, mes, rcc.getEstadoId());

				IndStatusBoleto statusBoleto = IndStatusBoleto.valueOf(rcc.getIndstatusboleto());
				boolean isSaidaCaixa = (rcc.getMotivoCancelacionId() != null) && (rcc.getIndreimpresion() != null && !rcc.getIndreimpresion());

				BigDecimal receitaItem = BigDecimal.ZERO;
				BigDecimal receitaDevItem = BigDecimal.ZERO;

				if (!isSaidaCaixa){
					// Totais
					if (BooleanUtils.toBoolean(ptovtaComissao.getTarifaReceita())) {
						receitaItem = MoneyHelper.somar(receitaItem, rcc.getValorpagado());
					}
	
					if (BooleanUtils.toBoolean(ptovtaComissao.getTaxaReceita())) {
						receitaItem = MoneyHelper.somar(receitaItem, rcc.getEmbarque());
					}
	
					if (BooleanUtils.toBoolean(ptovtaComissao.getSeguroReceita())) {
						receitaItem = MoneyHelper.somar(receitaItem, rcc.getSeguro());
					}
	
					if (BooleanUtils.toBoolean(ptovtaComissao.getPedagioReceita())) {
						receitaItem = MoneyHelper.somar(receitaItem, rcc.getPedagio());
					}
				}

				if (isSaidaCaixa){
					// Totais de Devolução / Cancelamento
					if (BooleanUtils.toBoolean(ptovtaComissao.getTarifaDev())) {
						receitaDevItem = MoneyHelper.somar(receitaDevItem, rcc.getValorpagado());
					}
	
					if (BooleanUtils.toBoolean(ptovtaComissao.getTaxaDev())) {
						receitaDevItem = MoneyHelper.somar(receitaDevItem, rcc.getEmbarque());
					}
	
					if (BooleanUtils.toBoolean(ptovtaComissao.getSeguroDev())) {
						receitaDevItem = MoneyHelper.somar(receitaDevItem, rcc.getSeguro());
					}
	
					if (BooleanUtils.toBoolean(ptovtaComissao.getPedagioDev())) {
						receitaDevItem = MoneyHelper.somar(receitaDevItem, rcc.getPedagio());
					}
				}
				
				// Calculo de ICMS sobre o valor do bilhete
				if (isReceitaLiquida) {
					BigDecimal icms = MoneyHelper.multiplicar(receitaItem, MoneyHelper.dividir(rcc.getIcmsBase(), CEM));
					receitaItem = MoneyHelper.subtrair(receitaItem, icms);

					BigDecimal icmsDev = MoneyHelper.multiplicar(receitaDevItem, MoneyHelper.dividir(rcc.getIcmsBase(), CEM));
					receitaDevItem = MoneyHelper.subtrair(receitaDevItem,icmsDev);

				}

				// Boletos impressos no punto venta
				if (statusBoleto.equals(IndStatusBoleto.E)) {
					contImpressa++;
					gapImpressa = MoneyHelper.somar(gapImpressa, receitaItem);

					BigDecimal entregaPassagem = calculoEntregaPassagem(isAltaTemporada, ptovtaComissao, receitaItem, BigDecimal.ZERO, contImpressa);
					comissaoEntregaPassagem = MoneyHelper.somar(comissaoEntregaPassagem, entregaPassagem);

				} else {

					// Receita GAP
					if (rcc.getTipoVenta().equals(Constantes.TPV_BOLETO_REMOTO.intValue())) {
						receitaGAP = MoneyHelper.somar(receitaGAP, receitaItem);

						BigDecimal bpr = calculoComisssaoBPR(isAltaTemporada, ptovtaComissao, BigDecimal.ZERO, receitaItem);
						comissaoBPR = MoneyHelper.somar(comissaoBPR, bpr);
					}
					// Internet
					else if (rcc.getTipoVenta().equals(Constantes.TPV_POR_INTERNET.intValue())) {
						internet = MoneyHelper.somar(internet, receitaItem);

						BigDecimal entregaPassagem = calculoEntregaPassagem(isAltaTemporada, ptovtaComissao, BigDecimal.ZERO, receitaItem, contImpressa);
						comissaoEntregaPassagem = MoneyHelper.somar(comissaoEntregaPassagem, entregaPassagem);
					}

					// Receita BPR
					else {
						receitaBPR = MoneyHelper.somar(receitaBPR, receitaItem);

						BigDecimal bpr = calculoComisssaoBPR(isAltaTemporada, ptovtaComissao, receitaItem, BigDecimal.ZERO);
						comissaoBPR = MoneyHelper.somar(comissaoBPR, bpr);
					}
				}

				if (isSaidaCaixa) {
					// Devolução Receita
					if (rcc.getMotivoCancelacionId().equals(Constantes.MVO_CANCEL_DEVOLUCAO.intValue()) || rcc.getMotivoCancelacionId().equals(Constantes.MVO_CANCEL_GERACAO_OCD.intValue())) {

						// Devolução Receita GAP
						if (rcc.getTipoVenta().equals(Constantes.TPV_BOLETO_REMOTO.intValue())) {

							// Impresso Venta de otro punto venta
							if (rcc.isPtoVtaOrigem()) {
								devolvidosGAPOrigem = MoneyHelper.somar(devolvidosGAPOrigem, receitaDevItem);
							}
							devolvidosGAP = MoneyHelper.somar(devolvidosGAP, receitaDevItem);

						} else {
							// Impresso Venta de otro punto venta
							if (rcc.isPtoVtaOrigem()) {
								devolvidosOrigem = MoneyHelper.somar(devolvidosOrigem, receitaDevItem);
							}

							devolvidos = MoneyHelper.somar(devolvidos, receitaDevItem);
						}

					}

					// Cancelamento Receita
					else {
						// Cancelamento Receita GAP
						if (rcc.getTipoVenta().equals(Constantes.TPV_BOLETO_REMOTO.intValue())) {
							canceladosGAP = MoneyHelper.somar(canceladosGAP, receitaDevItem);
						} else {
							cancelados = MoneyHelper.somar(cancelados, receitaDevItem);
						}
					}
					
					//Abate no valor da comissão bpr as saídas de caixa
					boolean consideraBilhetesDevolvidosEmOutraAgencia = (ptovtaComissao.getIndbilhetesdevcanorigem() == null)?false:ptovtaComissao.getIndbilhetesdevcanorigem();
					
					if (rcc.isPtoVtaOrigem() && consideraBilhetesDevolvidosEmOutraAgencia) {
						BigDecimal bpr = calculoComisssaoBPR(isAltaTemporada, ptovtaComissao, receitaDevItem, BigDecimal.ZERO);
						comissaoBPR = MoneyHelper.subtrair(comissaoBPR, bpr);
					}
				}
			}
			
			/* Calculando comissão para os eventos extras */
			List<EventosFinanceirosVO> listEventosFinanceiros = verificaEventoFinanceiroProDia(eventosFinanceirosVOs, dia, mes);
			for (EventosFinanceirosVO eventosFinanceiros : listEventosFinanceiros) {
				boolean isAltaTemporada = validaAltaTemporada(impostos, mes, eventosFinanceiros.getEstadoId());
				
				if(TipoEventoExtra.EXCESSO_BAGAGEM.toString().equals(eventosFinanceiros.getCvetipoevento())) {
					receitaExcessoBagagem = MoneyHelper.somar(receitaExcessoBagagem, eventosFinanceiros.getImpingreso());
					BigDecimal excessoBagagem = calculoExcessoBagagem(isAltaTemporada, ptovtaComissao, eventosFinanceiros.getImpingreso());
					comissaoExcessoBagagem = MoneyHelper.somar(comissaoExcessoBagagem, excessoBagagem);
				} else if(TipoEventoExtra.SEGURO_OPCIONAL.toString().equals(eventosFinanceiros.getCvetipoevento())) {
					receitaSeguroOpcional = MoneyHelper.somar(receitaSeguroOpcional, eventosFinanceiros.getImpingreso());
					BigDecimal segOpcional = calculoSeguroOpcional(isAltaTemporada, ptovtaComissao, eventosFinanceiros.getImpingreso());
					comissaoSegOpcional = MoneyHelper.somar(comissaoSegOpcional, segOpcional);
				} else {
					receitaSeguroOutros = MoneyHelper.somar(receitaSeguroOutros, eventosFinanceiros.getImpingreso());
					BigDecimal outros = calculoOutros(isAltaTemporada, ptovtaComissao, eventosFinanceiros.getImpingreso());
					comissaoOutros = MoneyHelper.somar(comissaoOutros, outros);
				}
			}

			cr.setCancelados(cancelados);
			cr.setCanceladosGAP(canceladosGAP);
			cr.setDevolvidos(devolvidos);
			cr.setDevolvidosGAP(devolvidosGAP);
			cr.setDevolucoesOrigem(devolvidosOrigem);
			cr.setDevolucoesOrigemGAP(devolvidosGAPOrigem);

			cr.setReceitaBPR(receitaBPR);
			cr.setReceitaExcessoBagagem(receitaExcessoBagagem);
			cr.setReceitaGAP(receitaGAP);
			cr.setReceitaSeguroOpcional(receitaSeguroOpcional);
			cr.setReceitaSeguroOutros(receitaSeguroOutros);
			cr.setInternet(internet);

			cr.setGapImpressa(gapImpressa);
			cr.setContImpressa(contImpressa);

			// Receita Comissão = Receita BPR + Receita GAP - GapImpressa - Internet
			// - Cancelados - Devoluções Origem - Cancelados GAP - Devoluções GAP Origem - Devoluções - Devoluções GAP
			receitaComissao = MoneyHelper.somar(receitaComissao,receitaBPR);
			receitaComissao = MoneyHelper.somar(receitaComissao,receitaGAP);

			receitaComissao = MoneyHelper.subtrair(receitaComissao,gapImpressa);
			receitaComissao = MoneyHelper.subtrair(receitaComissao,internet);
			receitaComissao = MoneyHelper.subtrair(receitaComissao,cancelados);
			receitaComissao = MoneyHelper.subtrair(receitaComissao,devolvidos);
			receitaComissao = MoneyHelper.subtrair(receitaComissao,devolvidosGAP);
			receitaComissao = MoneyHelper.subtrair(receitaComissao,devolvidosOrigem);
			receitaComissao = MoneyHelper.subtrair(receitaComissao,devolvidosGAPOrigem);
			receitaComissao = MoneyHelper.subtrair(receitaComissao,cancelados);
			receitaComissao = MoneyHelper.subtrair(receitaComissao,canceladosGAP);
			
			cr.setReceitaComissao(receitaComissao);

			cr.setComissaoBPRDiaria(comissaoBPR);
			cr.setComissaoEntregaPassagemDiaria(comissaoEntregaPassagem);
			cr.setComissaoExcessoBagagemDiaria(comissaoExcessoBagagem);
			cr.setComissaoSegOpcionalDiaria(comissaoSegOpcional);
			cr.setComissaoOutrosDiaria(comissaoOutros);

			receitas.add(cr);
		}

		return receitas;

	}

	private List<EventosFinanceirosVO> verificaEventoFinanceiroProDia(List<EventosFinanceirosVO> eventosFinanceirosVOs, Integer dia, Integer mes) {
		List<EventosFinanceirosVO> aux = new ArrayList<EventosFinanceirosVO>();
		for (EventosFinanceirosVO rcc : eventosFinanceirosVOs) {
			Calendar calendario = Calendar.getInstance();
			calendario.setTime(rcc.getFeccorte());

			int diaItem = calendario.get(Calendar.DAY_OF_MONTH);
			int mesItem = calendario.get(Calendar.MONTH) + 1;

			if (dia.equals(diaItem) && mes.equals(mesItem)) {
				aux.add(rcc);
			}
		}
		return aux;
	}

	private List<BoletoComissao> verificaCalculoComissaoProDia(List<BoletoComissao> list, Integer dia, Integer mes) {
		List<BoletoComissao> aux = new ArrayList<BoletoComissao>();
		for (BoletoComissao rcc : list) {
			Calendar calendario = Calendar.getInstance();
			calendario.setTime(rcc.getFeccorte());

			int diaItem = calendario.get(Calendar.DAY_OF_MONTH);
			int mesItem = calendario.get(Calendar.MONTH) + 1;

			if (dia.equals(diaItem) && mes.equals(mesItem)) {
				aux.add(rcc);
			}
		}
		return aux;
	}

	@Override
	public List<RegistroCalculo> relatorioCalculoComissao(Integer empresaId, Date periodo) throws ComissaoException, BusinessException {
		List<RegistroCalculo> registrosCalculo = new ArrayList<RegistroCalculo>();
		List<PuntoVenta> puntoventas = comissaoDAO.buscaPuntoVentasEmpresaComComissaoParametrizada(empresaId);
		for (PuntoVenta puntoVenta : puntoventas) {
			RegistroCalculo registroCalculo = relatorioCalculoComissao(puntoVenta.getPuntoventaId(), empresaId, periodo);
			totalizarRegistroCalculo(registroCalculo);
			registrosCalculo.add(registroCalculo);
		}
		Collections.sort(registrosCalculo, new Comparator<RegistroCalculo>() {
			@Override
			public int compare(RegistroCalculo o1, RegistroCalculo o2) {
				return o1.getNombpuntoventa().compareToIgnoreCase(o2.getNombpuntoventa());
			}
		});
		return registrosCalculo;
	}

	private void totalizarRegistroCalculo(RegistroCalculo registroCalculo) {
		ComissaoReceita comissaoReceitaTotal = new ComissaoReceita();
		for (ComissaoReceita comissaoReceita : registroCalculo.getLsReceitas()) {
			comissaoReceitaTotal.setReceitaComissao(comissaoReceitaTotal.getReceitaComissao().add(comissaoReceita.getReceitaComissao()));
			comissaoReceitaTotal.setReceitaBPR(comissaoReceitaTotal.getReceitaBPR().add(comissaoReceita.getReceitaBPR()));
			comissaoReceitaTotal.setReceitaGAP(comissaoReceitaTotal.getReceitaGAP().add(comissaoReceita.getReceitaGAP()));
			comissaoReceitaTotal.setGapImpressa(comissaoReceitaTotal.getGapImpressa().add(comissaoReceita.getGapImpressa()));
			comissaoReceitaTotal.setInternet(comissaoReceitaTotal.getInternet().add(comissaoReceita.getInternet()));
			comissaoReceitaTotal.setCancelados(comissaoReceitaTotal.getReceitaGAP().add(comissaoReceita.getCancelados()));
			comissaoReceitaTotal.setCanceladosGAP(comissaoReceitaTotal.getCanceladosGAP().add(comissaoReceita.getCanceladosGAP()));
			comissaoReceitaTotal.setDevolvidos(comissaoReceitaTotal.getDevolvidosGAP().add(comissaoReceita.getDevolvidos()));
			comissaoReceitaTotal.setDevolvidosGAP(comissaoReceitaTotal.getDevolvidosGAP().add(comissaoReceita.getDevolvidosGAP()));
			comissaoReceitaTotal.setDevolucoesOrigem(comissaoReceitaTotal.getDevolucoesOrigem().add(comissaoReceita.getDevolucoesOrigem()));
			comissaoReceitaTotal.setDevolucoesOrigemGAP(comissaoReceitaTotal.getDevolucoesOrigemGAP().add(comissaoReceita.getDevolucoesOrigemGAP()));
			comissaoReceitaTotal.setReceitaExcessoBagagem(comissaoReceitaTotal.getReceitaExcessoBagagem().add(comissaoReceita.getReceitaExcessoBagagem()));
			comissaoReceitaTotal.setReceitaSeguroOpcional(comissaoReceitaTotal.getReceitaSeguroOpcional().add(comissaoReceita.getReceitaSeguroOpcional()));
			comissaoReceitaTotal.setReceitaSeguroOutros(comissaoReceitaTotal.getReceitaSeguroOutros().add(comissaoReceita.getReceitaSeguroOutros()));
			comissaoReceitaTotal.setContImpressa(comissaoReceitaTotal.getContImpressa() + comissaoReceita.getContImpressa());
			comissaoReceitaTotal.setComissaoBPRDiaria(comissaoReceitaTotal.getComissaoBPRDiaria().add(comissaoReceita.getComissaoBPRDiaria()));
			comissaoReceitaTotal.setComissaoExcessoBagagemDiaria(comissaoReceitaTotal.getComissaoExcessoBagagemDiaria().add(comissaoReceita.getComissaoExcessoBagagemDiaria()));
			comissaoReceitaTotal.setComissaoSegOpcionalDiaria(comissaoReceitaTotal.getComissaoSegOpcionalDiaria().add(comissaoReceita.getComissaoSegOpcionalDiaria()));
			comissaoReceitaTotal.setComissaoEntregaPassagemDiaria(comissaoReceitaTotal.getComissaoEntregaPassagemDiaria().add(comissaoReceita.getComissaoEntregaPassagemDiaria()));
			comissaoReceitaTotal.setComissaoOutrosDiaria(comissaoReceitaTotal.getComissaoOutrosDiaria().add(comissaoReceita.getComissaoOutrosDiaria()));
		}
		registroCalculo.getLsReceitas().clear();
		registroCalculo.getLsReceitas().add(comissaoReceitaTotal);
	}

	@Override
	public void registrarCalculoComissao(Empresa empresa, Date periodo, boolean ignorarComissaoGerada) throws ComissaoException {
		List<PuntoVenta> puntoventas = comissaoDAO.buscaPuntoVentasEmpresaComComissaoParametrizada(empresa.getEmpresaId());
		for (PuntoVenta puntoVenta : puntoventas) {
			registrarCalculoComissao(puntoVenta, empresa, periodo, ignorarComissaoGerada);
		}
	}

	@Override
	public void cancelarCalculoComissao(Integer empresaId, Date periodo) throws ComissaoException {
		List<PuntoVenta> puntoventas = comissaoDAO.buscaPuntoVentasEmpresaComComissaoParametrizada(empresaId);
		for (PuntoVenta puntoVenta : puntoventas) {
			cancelarCalculoComissao(puntoVenta.getPuntoventaId(), empresaId, periodo);
		}
	}

	@Override
	public List<HistoricoComissao> relatorioReciboComissao(Integer puntoVentaId, Integer empresaId, String competencia) throws ComissaoException {
		try {
			return comissaoDAO.buscaHistoricoComissao(puntoVentaId, empresaId, DateUtil.getDateFromString(competencia, "MM/yyyy"), DateUtil.getDateFromString(competencia, "MM/yyyy"));
		} catch (Exception e) {
			throw new ComissaoException(e.getMessage(), e);
		}
	}
	
	@Override
	public void enviarEmailReciboComissao(HistoricoComissao historicoComissao, byte[] recibo) {
		try {
			if(StringUtils.isNotBlank(historicoComissao.getDescCorreo())) {
				SendMail mail = new SendMail();
				mail.setEmailToCO(historicoComissao.getDescCorreo());

				Constante constante = constanteService.buscarPorNomeConstante("SMTP_COMISSAO_EMAIL");
				if(constante != null) {
					mail.setEmailFrom(constante.getValorconstante());
				}
				
				constante = constanteService.buscarPorNomeConstante("SMTP_COMISSAO_HOST");
				if(constante != null) {
					mail.setSmtpHost(constante.getValorconstante());
				}
				
				constante = constanteService.buscarPorNomeConstante("SMTP_COMISSAO_PASS");
				if(constante != null) {
					mail.setSmtpPassword(constante.getValorconstante());
				}
				
				constante = constanteService.buscarPorNomeConstante("SMTP_COMISSAO_PORT");
				if(constante != null) {
					mail.setSmtpPort(constante.getValorconstante());
				}
				
				constante = constanteService.buscarPorNomeConstante("SMTP_COMISSAO_USER");
				if(constante != null) {
					mail.setSmtpUser(constante.getValorconstante());
				}
				
				String assunto = Labels.getLabel("busquedaCalculoComissaoController.recibo.email.assunto", new String[] {historicoComissao.getCompetencia()});
				mail.setSubject(assunto);
				
				String texto = Labels.getLabel("busquedaCalculoComissaoController.recibo.email.texto", new String[] {historicoComissao.getCompetencia()});
				mail.setText(texto);
	
				ByteArrayOutputStream baos = new ByteArrayOutputStream(recibo.length);
				baos.write(recibo, 0, recibo.length);
				mail.addAnexo(Labels.getLabel("busquedaCalculoComissaoController.recibo.email.nomeAnexo", new String[] {historicoComissao.getCompetencia()}).concat(".pdf"), baos, MimeType.PDF);
						
				mail.send();
			}

		} catch (Exception e) {
			log.error(e.getMessage(), e);
		}
	}

}