package com.rjconsultores.ventaboletos.web.gui.controladores.comissao;

import java.math.BigDecimal;
import java.text.ParseException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Controller;
import org.zkoss.util.resource.Labels;
import org.zkoss.zhtml.Messagebox;
import org.zkoss.zk.ui.Component;
import org.zkoss.zk.ui.Executions;
import org.zkoss.zk.ui.event.CheckEvent;
import org.zkoss.zk.ui.event.Event;
import org.zkoss.zk.ui.event.EventListener;
import org.zkoss.zul.Checkbox;
import org.zkoss.zul.Comboitem;
import org.zkoss.zul.Listcell;
import org.zkoss.zul.Listitem;
import org.zkoss.zul.Radio;

import com.rjconsultores.ventaboletos.constantes.Constantes;
import com.rjconsultores.ventaboletos.entidad.Conferencia;
import com.rjconsultores.ventaboletos.entidad.Empresa;
import com.rjconsultores.ventaboletos.entidad.LogConferencia;
import com.rjconsultores.ventaboletos.entidad.PuntoVenta;
import com.rjconsultores.ventaboletos.enums.comissao.BoletoStatusComissao;
import com.rjconsultores.ventaboletos.enums.comissao.StatusLogConferencia;
import com.rjconsultores.ventaboletos.enums.comissao.TipoLogConferencia;
import com.rjconsultores.ventaboletos.exception.BusinessException;
import com.rjconsultores.ventaboletos.service.ConferenciaComissaoService;
import com.rjconsultores.ventaboletos.utilerias.BigDecimalUtil;
import com.rjconsultores.ventaboletos.utilerias.DateUtil;
import com.rjconsultores.ventaboletos.utilerias.LocaleUtil;
import com.rjconsultores.ventaboletos.utilerias.UsuarioLogado;
import com.rjconsultores.ventaboletos.vo.comissao.BoletoComissao;
import com.rjconsultores.ventaboletos.vo.comissao.ConferenciaComissaoVO;
import com.rjconsultores.ventaboletos.vo.comissao.EventosFinanceirosVO;
import com.rjconsultores.ventaboletos.vo.comissao.LogConferenciaVO;
import com.rjconsultores.ventaboletos.vo.comissao.OcdVO;
import com.rjconsultores.ventaboletos.vo.comissao.ResumoComissao;
import com.rjconsultores.ventaboletos.web.utilerias.MyComboboxEstandar;
import com.rjconsultores.ventaboletos.web.utilerias.MyGenericForwardComposer;
import com.rjconsultores.ventaboletos.web.utilerias.MyListbox;
import com.rjconsultores.ventaboletos.web.utilerias.MyTextbox;
import com.rjconsultores.ventaboletos.web.utilerias.MyTextboxDecimal;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderBoletoComissao;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderEventosFinanceiros;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderFormapagoComissao;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderLogConferencia;
import com.rjconsultores.ventaboletos.web.utilerias.render.RenderOcd;

@Scope("prototype")
@Controller("conferenciaController")
public class ConferenciaController extends MyGenericForwardComposer {

	private static final long serialVersionUID = 1L;

	private static Logger log = Logger.getLogger(ConferenciaController.class);
	
	@Autowired
	private ConferenciaComissaoService conferenciaComissaoService;

	private String datamovimento;
	private Empresa empresa;
	private Integer puntoventaId;
	private PuntoVenta puntoventaFiltro;
	private String puntoventa;
	private Conferencia conferencia;
	
	private MyListbox eventosFinanceirosList;
	private List<EventosFinanceirosVO> lsEventosFinanceiros;
	
	private MyListbox logsConferenciaList;
	private List<LogConferenciaVO> lsLogsConferencia;
	
	private MyTextboxDecimal txtTotalCreditosEventoFinanceiros;
	private MyTextboxDecimal txtTotalDebitosEventoFinanceiros;
	private MyTextboxDecimal txtTotalDiferencaEventoFinanceiros;
	
	private MyTextboxDecimal txtTotalBilhetes;
	private MyTextboxDecimal txtTotalBilhetesCancelados;
	private MyTextboxDecimal txtTotalBilhetesDevolvidos;
	private MyTextboxDecimal txtTotalBilhetesDevolvidosTroca;
	private MyTextboxDecimal txtTotalBilhetesDevolvidosOcd;
	private MyTextboxDecimal txtTotalBilhetesGap;
	private MyTextboxDecimal txtTotalBilhetesGapCancelados;
	private MyTextboxDecimal txtTotalBilhetesGapDevolvidos;
	private MyTextboxDecimal txtTotalBilhetesGapDevolvidosOcd;
	private MyTextboxDecimal txtTotalBilhetesGapDevolvidosTroca;
	private MyTextboxDecimal txtTotalBilhetesManual;
	private MyTextboxDecimal txtTotalOcdValorPagar;
	private MyTextboxDecimal txtTotalOcdPenalizacion;

	private MyTextbox txtQtdeTotalBilhetes;
	private MyTextbox txtQtdeTotalBilhetesCancelados;
	private MyTextbox txtQtdeTotalBilhetesDevolvidos;
	private MyTextbox txtQtdeTotalBilhetesGap;
	private MyTextbox txtQtdeTotalBilhetesGapCancelados;
	private MyTextbox txtQtdeTotalBilhetesGapDevolvidos;
	private MyTextbox txtQtdeTotalBilhetesManual;
	private MyTextbox txtQtdeTotalOcd;

	private MyComboboxEstandar cmbSituacaoLog;
	private MyTextboxDecimal txtPrecoLog;
	private MyTextbox txtObservacaoLog;
	
	private MyListbox bilhetesList;
	private List<BoletoComissao> lsBilhetes;
	
	private MyListbox bilhetesCanceladosList;
	private List<BoletoComissao> lsBilhetesCancelados;
	
	private MyListbox bilhetesDevolvidosList;
	private List<BoletoComissao> lsBilhetesDevolvidos;
	
	private MyListbox bilhetesGapList;
	private List<BoletoComissao> lsBilhetesGap;
	
	private MyListbox bilhetesGapCanceladosList;
	private List<BoletoComissao> lsBilhetesGapCancelados;
	
	private MyListbox bilhetesGapDevolvidosList;
	private List<BoletoComissao> lsBilhetesGapDevolvidos;
	
	private MyListbox bilhetesManualList;
	private List<BoletoComissao> lsBilhetesManual;

	private List<OcdVO> lsOcds;
	private MyListbox ocdsList;
	
	private MyListbox conferenciaList;
	
	private Radio rDebito;
	
	private ResumoComissao resumo;
	private BigDecimal totalBilhetesManual;
	private BigDecimal totalBilhetesVendidos;
	private BigDecimal totalBilhetesCancelados;
	private BigDecimal totalBilhetesDevolvidos;
	private BigDecimal totalBilhetesDevolvidosTroca;
	private BigDecimal totalBilhetesDevolvidosOcd;
	private BigDecimal totalBilhetesGap;
	private BigDecimal totalBilhetesGapCancelados;
	private BigDecimal totalBilhetesGapDevolvidos;
	private BigDecimal totalBilhetesGapDevolvidosTroca;
	private BigDecimal totalBilhetesGapDevolvidosOcd;
	private BigDecimal totalCreditosEventoFinanceiros;
	private BigDecimal totalDebitosEventoFinanceiros;
	private OcdVO ocdTotal;
	private MyListbox formapagosList;
	
	@Override
	public void doAfterCompose(Component comp) throws Exception {
		
		conferenciaList = (MyListbox) Executions.getCurrent().getArg().get("conferenciaList");
		Long conferenciaId = (Long) Executions.getCurrent().getArg().get("conferenciaId");
		datamovimento = (String) Executions.getCurrent().getArg().get("datamovimento");
		empresa = (Empresa) Executions.getCurrent().getArg().get("empresa");
		puntoventaId = (Integer) Executions.getCurrent().getArg().get("puntoventaId");
		puntoventaFiltro = Executions.getCurrent().getArg().get("puntovendaFiltro") != null && !Executions.getCurrent().getArg().get("puntovendaFiltro").toString().equals("null") ? (PuntoVenta) Executions.getCurrent().getArg().get("puntovendaFiltro") : null;
		String nombpuntoventa = (String) Executions.getCurrent().getArg().get("nombpuntoventa");
		String numPuntoVenta = (String) Executions.getCurrent().getArg().get("numPuntoVenta");
		puntoventa = numPuntoVenta.concat(" - ").concat(nombpuntoventa);
		recuperarConferencia(conferenciaId);

		super.doAfterCompose(comp);
		logsConferenciaList.setItemRenderer(new RenderLogConferencia());
		
		ocdsList.setItemRenderer(new RenderOcd());
		ocdsList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				OcdVO ocd = (OcdVO) ocdsList.getSelected();
				lancarLogConferenciaOcd(ocd, ocdsList);
			}
		});

		eventosFinanceirosList.setItemRenderer(new RenderEventosFinanceiros(){
			@Override
			@SuppressWarnings("unchecked")
			public void render(Listitem lstm, Object o) throws Exception {
				super.render(lstm, o);
				final EventosFinanceirosVO eventoFinanceiro = (EventosFinanceirosVO) o;
				List<Component> com = lstm.getChildren();
				for (Component component: com) {
					Listcell listCell = (Listcell) component;
					if(listCell.getFirstChild() instanceof Checkbox) {
						Checkbox chk = (Checkbox)component.getFirstChild();
						chk.setDisabled(isExibirBotaoReabrirMovimento());
						chk.addEventListener("onCheck", new EventListener() {
							@Override
							public void onEvent(Event event) throws Exception {
								CheckEvent checkEvent = (CheckEvent) event;
								if(checkEvent.isChecked() && eventoFinanceiro.getLogconferenciaId() == null) {
									gravarLogConferenciaEventoFinanceiro(eventoFinanceiro);
								} else if(!checkEvent.isChecked() && eventoFinanceiro.getLogconferenciaId() != null) {
									removerLogConferenciaEventoFinanceiro(eventoFinanceiro);
								}
							}
						});
					}
				}
			}
		});
		eventosFinanceirosList.addEventListener("onDoubleClick", new EventListener() {
            @Override
            public void onEvent(Event event) throws Exception {
                EventosFinanceirosVO eventosFinanceiros = (EventosFinanceirosVO) eventosFinanceirosList.getSelected();
                lancarLogConferenciaEventosFinanceiros(eventosFinanceiros, eventosFinanceirosList);
            }
        });
		
		ajustarListsBilhetes();
		
		rDebito.setChecked(Boolean.TRUE);
		
		formapagosList.setItemRenderer(new RenderFormapagoComissao());
		
		popularCombobox();
		
		carregarDados();
	}

	private void ajustarListsBilhetes() {
		bilhetesManualList.setItemRenderer(new RenderBoletoComissao(){
			@Override
			@SuppressWarnings("unchecked")
			public void render(Listitem lstm, Object o) throws Exception {
				super.render(lstm, o);
				final BoletoComissao boletoComissao = (BoletoComissao) o;
				List<Component> com = lstm.getChildren();
				for (Component component: com) {
					Listcell listCell = (Listcell) component;
					if(listCell.getFirstChild() instanceof Checkbox) {
						Checkbox chk = (Checkbox)component.getFirstChild();
						chk.setDisabled(isExibirBotaoReabrirMovimento());
						chk.addEventListener("onCheck", new EventListener() {
							@Override
							public void onEvent(Event event) throws Exception {
								CheckEvent checkEvent = (CheckEvent) event;
								if(checkEvent.isChecked() && boletoComissao.getLogconferenciaId() == null) {
									gravarLogConferenciaBilhete(bilhetesManualList, boletoComissao);
								} else if(!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesManualList, boletoComissao);
								}
							}
						});
					}
				}
			}
		});
		bilhetesManualList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				BoletoComissao boletoComissao = (BoletoComissao) bilhetesManualList.getSelected();
				lancarLogConferenciaBilhete(boletoComissao, bilhetesManualList);
			}
		});
		
		bilhetesList.setItemRenderer(new RenderBoletoComissao(){
			@Override
			@SuppressWarnings("unchecked")
			public void render(Listitem lstm, Object o) throws Exception {
				super.render(lstm, o);
				final BoletoComissao boletoComissao = (BoletoComissao) o;
				List<Component> com = lstm.getChildren();
				for (Component component: com) {
					Listcell listCell = (Listcell) component;
					if(listCell.getFirstChild() instanceof Checkbox) {
						Checkbox chk = (Checkbox)component.getFirstChild();
						chk.setDisabled(isExibirBotaoReabrirMovimento());
						chk.addEventListener("onCheck", new EventListener() {
							@Override
							public void onEvent(Event event) throws Exception {
								CheckEvent checkEvent = (CheckEvent) event;
								if(checkEvent.isChecked() && boletoComissao.getLogconferenciaId() == null) {
									gravarLogConferenciaBilhete(bilhetesList, boletoComissao);
								} else if(!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesList, boletoComissao);
								}
							}
						});
					}
				}
			}
		});
		bilhetesList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				BoletoComissao boletoComissao = (BoletoComissao) bilhetesList.getSelected();
				lancarLogConferenciaBilhete(boletoComissao, bilhetesList);
			}
		});

		bilhetesCanceladosList.setItemRenderer(new RenderBoletoComissao(){
			@Override
			@SuppressWarnings("unchecked")
			public void render(Listitem lstm, Object o) throws Exception {
				super.render(lstm, o);
				final BoletoComissao boletoComissao = (BoletoComissao) o;
				List<Component> com = lstm.getChildren();
				for (Component component: com) {
					Listcell listCell = (Listcell) component;
					if(listCell.getFirstChild() instanceof Checkbox) {
						Checkbox chk = (Checkbox)component.getFirstChild();
						chk.setDisabled(isExibirBotaoReabrirMovimento());
						chk.addEventListener("onCheck", new EventListener() {
							@Override
							public void onEvent(Event event) throws Exception {
								CheckEvent checkEvent = (CheckEvent) event;
								if(checkEvent.isChecked() && boletoComissao.getLogconferenciaId() == null) {
									gravarLogConferenciaBilhete(bilhetesCanceladosList, boletoComissao);
								} else if(!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesCanceladosList, boletoComissao);
								}
							}
						});
					}
				}
			}
		});
		bilhetesCanceladosList.addEventListener("onDoubleClick", new EventListener() {
            @Override
            public void onEvent(Event event) throws Exception {
                BoletoComissao boletoComissao = (BoletoComissao) bilhetesCanceladosList.getSelected();
                lancarLogConferenciaBilhete(boletoComissao, bilhetesCanceladosList);
            }
        });
		
		bilhetesDevolvidosList.setItemRenderer(new RenderBoletoComissao(){
			@Override
			@SuppressWarnings("unchecked")
			public void render(Listitem lstm, Object o) throws Exception {
				super.render(lstm, o);
				final BoletoComissao boletoComissao = (BoletoComissao) o;
				List<Component> com = lstm.getChildren();
				for (Component component: com) {
					Listcell listCell = (Listcell) component;
					if(listCell.getFirstChild() instanceof Checkbox) {
						Checkbox chk = (Checkbox)component.getFirstChild();
						chk.setDisabled(isExibirBotaoReabrirMovimento());
						chk.addEventListener("onCheck", new EventListener() {
							@Override
							public void onEvent(Event event) throws Exception {
								CheckEvent checkEvent = (CheckEvent) event;
								if(checkEvent.isChecked() && boletoComissao.getLogconferenciaId() == null) {
									gravarLogConferenciaBilhete(bilhetesDevolvidosList, boletoComissao);
								} else if(!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesDevolvidosList, boletoComissao);
								}
							}
						});
					}
				}
			}
		});
		bilhetesDevolvidosList.addEventListener("onDoubleClick", new EventListener() {
            @Override
            public void onEvent(Event event) throws Exception {
                BoletoComissao boletoComissao = (BoletoComissao) bilhetesDevolvidosList.getSelected();
                lancarLogConferenciaBilhete(boletoComissao, bilhetesDevolvidosList);
            }
        });
		
		bilhetesGapList.setItemRenderer(new RenderBoletoComissao(){
			@Override
			@SuppressWarnings("unchecked")
			public void render(Listitem lstm, Object o) throws Exception {
				super.render(lstm, o);
				final BoletoComissao boletoComissao = (BoletoComissao) o;
				List<Component> com = lstm.getChildren();
				for (Component component: com) {
					Listcell listCell = (Listcell) component;
					if(listCell.getFirstChild() instanceof Checkbox) {
						Checkbox chk = (Checkbox)component.getFirstChild();
						chk.setDisabled(isExibirBotaoReabrirMovimento());
						chk.addEventListener("onCheck", new EventListener() {
							@Override
							public void onEvent(Event event) throws Exception {
								CheckEvent checkEvent = (CheckEvent) event;
								if(checkEvent.isChecked() && boletoComissao.getLogconferenciaId() == null) {
									gravarLogConferenciaBilhete(bilhetesGapList, boletoComissao);
								} else if(!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesGapList, boletoComissao);
								}
							}
						});
					}
				}
			}
		});
		bilhetesGapList.addEventListener("onDoubleClick", new EventListener() {
            @Override
            public void onEvent(Event event) throws Exception {
                BoletoComissao boletoComissao = (BoletoComissao) bilhetesGapList.getSelected();
                lancarLogConferenciaBilhete(boletoComissao, bilhetesGapList);
            }
        });
		
		bilhetesGapCanceladosList.setItemRenderer(new RenderBoletoComissao(){
			@Override
			@SuppressWarnings("unchecked")
			public void render(Listitem lstm, Object o) throws Exception {
				super.render(lstm, o);
				final BoletoComissao boletoComissao = (BoletoComissao) o;
				List<Component> com = lstm.getChildren();
				for (Component component: com) {
					Listcell listCell = (Listcell) component;
					if(listCell.getFirstChild() instanceof Checkbox) {
						Checkbox chk = (Checkbox)component.getFirstChild();
						chk.setDisabled(isExibirBotaoReabrirMovimento());
						chk.addEventListener("onCheck", new EventListener() {
							@Override
							public void onEvent(Event event) throws Exception {
								CheckEvent checkEvent = (CheckEvent) event;
								if(checkEvent.isChecked() && boletoComissao.getLogconferenciaId() == null) {
									gravarLogConferenciaBilhete(bilhetesGapCanceladosList, boletoComissao);
								} else if(!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesGapCanceladosList, boletoComissao);
								}
							}
						});
					}
				}
			}
		});
		bilhetesGapCanceladosList.addEventListener("onDoubleClick", new EventListener() {
            @Override
            public void onEvent(Event event) throws Exception {
                BoletoComissao boletoComissao = (BoletoComissao) bilhetesGapCanceladosList.getSelected();
                lancarLogConferenciaBilhete(boletoComissao, bilhetesCanceladosList);
            }
        });
		
		bilhetesGapDevolvidosList.setItemRenderer(new RenderBoletoComissao(){
			@Override
			@SuppressWarnings("unchecked")
			public void render(Listitem lstm, Object o) throws Exception {
				super.render(lstm, o);
				final BoletoComissao boletoComissao = (BoletoComissao) o;
				List<Component> com = lstm.getChildren();
				for (Component component: com) {
					Listcell listCell = (Listcell) component;
					if(listCell.getFirstChild() instanceof Checkbox) {
						Checkbox chk = (Checkbox)component.getFirstChild();
						chk.setDisabled(isExibirBotaoReabrirMovimento());
						chk.addEventListener("onCheck", new EventListener() {
							@Override
							public void onEvent(Event event) throws Exception {
								CheckEvent checkEvent = (CheckEvent) event;
								if(checkEvent.isChecked() && boletoComissao.getLogconferenciaId() == null) {
									gravarLogConferenciaBilhete(bilhetesGapDevolvidosList, boletoComissao);
								} else if(!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesGapDevolvidosList, boletoComissao);
								}
							}
						});
					}
				}
			}
		});
		bilhetesGapDevolvidosList.addEventListener("onDoubleClick", new EventListener() {
            @Override
            public void onEvent(Event event) throws Exception {
                BoletoComissao boletoComissao = (BoletoComissao) bilhetesGapDevolvidosList.getSelected();
                lancarLogConferenciaBilhete(boletoComissao, bilhetesDevolvidosList);
            }
        });
	}

	private void popularCombobox() {
		for (StatusLogConferencia status : StatusLogConferencia.values()) {
			Comboitem comboItem = new Comboitem(status.toString());
			comboItem.setValue(status.getValue());
			comboItem.setParent(cmbSituacaoLog);
		}
	}

	private void carregarDados() {
		try {
			List<BoletoComissao> boletosComissaos = conferenciaComissaoService.carregarBilhetesComissao(null, getConferencia(), null);
			carregarBilhetesManual(boletosComissaos);
			carregarBilhetesVendidos(boletosComissaos);
			carregarBilhetesCancelados(boletosComissaos);
			carregarBilhetesDevolvidos(boletosComissaos);
			carregarBilhetesGap(boletosComissaos);
			carregarBilhetesGapCancelados(boletosComissaos);
			carregarBilhetesGapDevolvidos(boletosComissaos);
			carregarEventosFinanceiros();
			carregarOcds();
			carregarLogsConferencia();
			carregarResumo(boletosComissaos);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}
	
	private void carregarResumo(List<BoletoComissao> boletosComissaos) throws BusinessException {
		resumo = conferenciaComissaoService.gerarResumo(conferencia, boletosComissaos, lsEventosFinanceiros, totalBilhetesManual, totalBilhetesVendidos, totalBilhetesCancelados, totalBilhetesDevolvidos, totalBilhetesGap, totalBilhetesGapCancelados, totalBilhetesGapDevolvidos, totalCreditosEventoFinanceiros, totalDebitosEventoFinanceiros, ocdTotal);
		formapagosList.setData(resumo.getTotalFormapago());
	}

	private void carregarBilhetesManual(List<BoletoComissao> boletosComissaos) throws BusinessException {
		lsBilhetesManual = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.BOLETO_MANUAL);
		totalBilhetesManual = conferenciaComissaoService.totalizarBoletoComissao(lsBilhetesManual);
		txtTotalBilhetesManual.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesManual, LocaleUtil.getLocale()));
		txtQtdeTotalBilhetesManual.setValue(String.valueOf(lsBilhetesManual.size()));
		bilhetesManualList.setData(lsBilhetesManual);
	}

	private void carregarBilhetesVendidos(List<BoletoComissao> boletosComissaos) throws BusinessException {
		lsBilhetes = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.BOLETOS_VENDIDOS);
		totalBilhetesVendidos = conferenciaComissaoService.totalizarBoletoComissao(lsBilhetes);
		txtTotalBilhetes.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesVendidos, LocaleUtil.getLocale()));
		txtQtdeTotalBilhetes.setValue(String.valueOf(lsBilhetes.size()));
		bilhetesList.setData(lsBilhetes);
	}

	private void carregarBilhetesCancelados(List<BoletoComissao> boletosComissaos) throws BusinessException {
		lsBilhetesCancelados = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.BOLETO_CANCELADO);
		totalBilhetesCancelados = conferenciaComissaoService.totalizarBoletoComissao(lsBilhetesCancelados);
		txtTotalBilhetesCancelados.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesCancelados, LocaleUtil.getLocale()));
		txtQtdeTotalBilhetesCancelados.setValue(String.valueOf(lsBilhetesCancelados.size()));
		bilhetesCanceladosList.setData(lsBilhetesCancelados);
	}

	private void carregarBilhetesDevolvidos(List<BoletoComissao> boletosComissaos) throws BusinessException {
		totalBilhetesDevolvidos = BigDecimal.ZERO;
		if(empresa.getIndcarboletosdevolvidosconf() != null && empresa.getIndcarboletosdevolvidosconf()) {
			lsBilhetesDevolvidos = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.BOLETO_DEVOLVIDO);
			Map<BoletoStatusComissao, BigDecimal> totais = conferenciaComissaoService.totalizarBoletoComissaoDevolvidosTrocaOcd(lsBilhetesDevolvidos);
			
			totalBilhetesDevolvidos = totais.get(BoletoStatusComissao.BOLETO_DEVOLVIDO);
			totalBilhetesDevolvidosOcd = totais.get(BoletoStatusComissao.BOLETO_DEVOLVIDO_OCD);
			totalBilhetesDevolvidosTroca = totais.get(BoletoStatusComissao.BOLETO_DEVOLVIDO_TROCADO);
			
			txtTotalBilhetesDevolvidos.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesDevolvidos, LocaleUtil.getLocale()));
			txtTotalBilhetesDevolvidosTroca.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesDevolvidosTroca, LocaleUtil.getLocale()));
			txtTotalBilhetesDevolvidosOcd.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesDevolvidosOcd, LocaleUtil.getLocale()));
			txtQtdeTotalBilhetesDevolvidos.setValue(String.valueOf(lsBilhetesDevolvidos.size()));
			
			bilhetesDevolvidosList.setData(lsBilhetesDevolvidos);
		}
	}

	private void carregarBilhetesGap(List<BoletoComissao> boletosComissaos) throws BusinessException {
		lsBilhetesGap = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.GAP_VENDIDOS);
		totalBilhetesGap = conferenciaComissaoService.totalizarBoletoComissao(lsBilhetesGap);
		txtTotalBilhetesGap.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesGap, LocaleUtil.getLocale()));
		txtQtdeTotalBilhetesGap.setValue(String.valueOf(lsBilhetesGap.size()));
		bilhetesGapList.setData(lsBilhetesGap);
	}

	private void carregarBilhetesGapCancelados(List<BoletoComissao> boletosComissaos) throws BusinessException {
		lsBilhetesGapCancelados = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.GAP_CANCELADO);
		totalBilhetesGapCancelados = conferenciaComissaoService.totalizarBoletoComissao(lsBilhetesGapCancelados);
		txtTotalBilhetesGapCancelados.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesGapCancelados, LocaleUtil.getLocale()));
		txtQtdeTotalBilhetesGapCancelados.setValue(String.valueOf(lsBilhetesGapCancelados.size()));
		bilhetesGapCanceladosList.setData(lsBilhetesGapCancelados);	
	}

	private void carregarBilhetesGapDevolvidos(List<BoletoComissao> boletosComissaos) throws BusinessException {
		lsBilhetesGapDevolvidos = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.GAP_DEVOLVIDO);
		
		Map<BoletoStatusComissao, BigDecimal> totais = conferenciaComissaoService.totalizarBoletoComissaoDevolvidosTrocaOcd(lsBilhetesGapDevolvidos);
		
		totalBilhetesGapDevolvidos = totais.get(BoletoStatusComissao.BOLETO_DEVOLVIDO);
		totalBilhetesGapDevolvidosOcd = totais.get(BoletoStatusComissao.BOLETO_DEVOLVIDO_OCD);
		totalBilhetesGapDevolvidosTroca = totais.get(BoletoStatusComissao.BOLETO_DEVOLVIDO_TROCADO);
		
		txtTotalBilhetesGapDevolvidos.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesGapDevolvidos, LocaleUtil.getLocale()));
		txtTotalBilhetesGapDevolvidosOcd.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesGapDevolvidosOcd, LocaleUtil.getLocale()));
		txtTotalBilhetesGapDevolvidosTroca.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesGapDevolvidosTroca, LocaleUtil.getLocale()));
		
		txtQtdeTotalBilhetesGapDevolvidos.setValue(String.valueOf(lsBilhetesGapDevolvidos.size()));
		bilhetesGapDevolvidosList.setData(lsBilhetesGapDevolvidos);
	}

	private void carregarLogsConferencia() throws BusinessException {
		lsLogsConferencia = conferenciaComissaoService.carregarLogConferencia(conferencia);
		logsConferenciaList.setData(lsLogsConferencia);
	}

	private void carregarEventosFinanceiros() throws BusinessException {
		lsEventosFinanceiros = conferenciaComissaoService.carregarEventosFinanceiros(conferencia);
		eventosFinanceirosList.setData(lsEventosFinanceiros);
		
		totalCreditosEventoFinanceiros = BigDecimal.ZERO;
		totalDebitosEventoFinanceiros = BigDecimal.ZERO;
		
		for (EventosFinanceirosVO eventoFinanceiro : lsEventosFinanceiros) {
			if(eventoFinanceiro.isCredito()) {
				totalCreditosEventoFinanceiros = totalCreditosEventoFinanceiros.add(eventoFinanceiro.getImpingreso());
			} else {
				totalDebitosEventoFinanceiros = totalDebitosEventoFinanceiros.add(eventoFinanceiro.getImpingreso());
			}
		}
		
		txtTotalCreditosEventoFinanceiros.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalCreditosEventoFinanceiros, LocaleUtil.getLocale()));
		txtTotalDebitosEventoFinanceiros.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalDebitosEventoFinanceiros, LocaleUtil.getLocale()));
		txtTotalDiferencaEventoFinanceiros.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalCreditosEventoFinanceiros.subtract(totalDebitosEventoFinanceiros), LocaleUtil.getLocale()));
	}
	
	private void carregarOcds() throws BusinessException {
		lsOcds = conferenciaComissaoService.carregarOcds(conferencia);
		ocdTotal = conferenciaComissaoService.totalizarOcd(lsOcds);
		
		if(ocdTotal != null) {
			txtTotalOcdValorPagar.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(ocdTotal.getValorPagar(), LocaleUtil.getLocale()));
			txtQtdeTotalOcd.setValue(String.valueOf(lsOcds.size()));
		}
		ocdsList.setData(lsOcds);
	}

	public void onClick$btnChegadaMalote(Event event) throws InterruptedException {
		try {
			conferencia = conferenciaComissaoService.confirmarChegadaMalote(conferencia);

            Messagebox.show(Labels.getLabel("conferenciaController.msg.confirmarChegadaMalote"),
            				Labels.getLabel("conferenciaController.window.title"),
            				Messagebox.OK,Messagebox.INFORMATION);
            
            closeWindow();

		} catch (Exception e) {
			log.error(e.getMessage(), e);
            Messagebox.show(Labels.getLabel("MSG.Error"),
            				Labels.getLabel("conferenciaController.window.title"),
            				Messagebox.OK,Messagebox.ERROR);
		}
	}

	public void onClick$btnEncerrarMovimentoDiario(Event event) throws InterruptedException {
		try {
			if(conferenciaComissaoService.isBilhetesSemConferencia(conferencia)) {
	            Messagebox.show(Labels.getLabel("conferenciaController.MSG.bilheteSemConferenciaFormapagoCategoria"),
        				Labels.getLabel("conferenciaController.window.title"),
        				Messagebox.OK,Messagebox.EXCLAMATION);
	            return;
			}

			if(conferenciaComissaoService.isEventosFinanceirosSemConferencia(conferencia)) {
				Messagebox.show(Labels.getLabel("conferenciaController.MSG.eventosFinanceirosSemConferenciaFormapago"),
						Labels.getLabel("conferenciaController.window.title"),
						Messagebox.OK,Messagebox.EXCLAMATION);
				return;
			}
			
			conferencia = conferenciaComissaoService.encerrarMovimentoDiario(conferencia);

            Messagebox.show(Labels.getLabel("conferenciaController.msg.encerrarMovimentoDiario"),
            				Labels.getLabel("conferenciaController.window.title"),
            				Messagebox.OK,Messagebox.INFORMATION);
            
            closeWindow();

		} catch (Exception e) {
			log.error(e.getMessage(), e);
            Messagebox.show(Labels.getLabel("MSG.Error"),
            				Labels.getLabel("conferenciaController.window.title"),
            				Messagebox.OK,Messagebox.ERROR);
		}
	}

	public void onClick$btnReabrirMovimentoDiario(Event event) throws InterruptedException {
		try {
			conferencia = conferenciaComissaoService.reabrirMovimentoDiario(conferencia);
			
			Messagebox.show(Labels.getLabel("conferenciaController.msg.reabrirMovimentoDiario"),
					Labels.getLabel("conferenciaController.window.title"),
					Messagebox.OK,Messagebox.INFORMATION);
			
			closeWindow();
			
		} catch (Exception e) {
			log.error(e.getMessage(), e);
			Messagebox.show(Labels.getLabel("MSG.Error"),
					Labels.getLabel("conferenciaController.window.title"),
					Messagebox.OK,Messagebox.ERROR);
		}
	}
	
	private void recuperarConferencia(Long conferenciaId) throws ParseException, BusinessException {
		if(conferenciaId != null) {
			conferencia = conferenciaComissaoService.obtenerID(conferenciaId);
		}
		
		if(conferencia == null) {
			conferencia = conferenciaComissaoService.obtenerConferenciaDataMovimento(DateUtil.getDateFromString(datamovimento, "dd/MM/yyyy"), puntoventaId, empresa.getEmpresaId());
		}
		
		if(conferencia == null) {
			conferencia = new Conferencia();
			conferencia.setActivo(Boolean.TRUE);
			conferencia.setFecmodif(new Date());
			conferencia.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
			conferencia.setEmpresa(empresa);
			conferencia.setPuntoVenta(new PuntoVenta(puntoventaId));
			conferencia.setDatamovimento(DateUtil.getDateFromString(datamovimento, "dd/MM/yyyy"));
		}
	}
	
	public void onClick$btnAdicionarObservacaoLog(Event event) throws InterruptedException {
		try {
			if(validarCamposObservacao()) {
			
				LogConferencia logConferencia = new LogConferencia();
				logConferencia.setPreco(txtPrecoLog.getValueDecimal());
				logConferencia.setObservacao(txtObservacaoLog.getValue());
				logConferencia.setConferencia(conferencia);
				logConferencia.setStatus(StatusLogConferencia.getStatusLogConferencia((Integer)cmbSituacaoLog.getSelectedItem().getValue()));
				logConferencia.setTipo(TipoLogConferencia.AVULSO);
				logConferencia.setIndcredito(!rDebito.isChecked());
				conferenciaComissaoService.suscribirLogConferencia(logConferencia);
	
				carregarLogsConferencia();
				
	            Messagebox.show(Labels.getLabel("conferenciaController.msg.adicionarLogConferencia"),
	    				Labels.getLabel("conferenciaController.window.title"),
	    				Messagebox.OK,Messagebox.INFORMATION);
            
			}

		} catch (Exception e) {
			log.error(e.getMessage(), e);
		    Messagebox.show(Labels.getLabel("MSG.Error"),
		    				Labels.getLabel("conferenciaController.window.title"),
		    				Messagebox.OK,Messagebox.ERROR);
		}
	}
	
	private boolean validarCamposObservacao() throws InterruptedException {
		try {
			if(StringUtils.isBlank(txtObservacaoLog.getValue())) {
				Messagebox.show(Labels.getLabel("conferenciaController.MSG.observacaoObrigatorio"),
						Labels.getLabel("conferenciaController.window.title"),
						Messagebox.OK,Messagebox.ERROR);
				return false;
			}
		} catch (Exception e) {
		    Messagebox.show(Labels.getLabel("conferenciaController.MSG.observacaoObrigatorio"),
    						Labels.getLabel("conferenciaController.window.title"),
    						Messagebox.OK,Messagebox.ERROR);
		    return false;
		}
		return true;
	}

	public void onClick$btnRemoverObservacaoLog(Event event) throws InterruptedException {
		try {
			int resp = Messagebox.show(
					Labels.getLabel("conferenciaController.MSG.borrarLogConferenciaPergunta"),
					Labels.getLabel("conferenciaController.window.title"),
					Messagebox.YES | Messagebox.NO, Messagebox.QUESTION);

			if (resp == Messagebox.YES) {
				LogConferenciaVO logConferenciaVO = (LogConferenciaVO) logsConferenciaList.getSelected();
				LogConferencia logConferencia = conferenciaComissaoService.obtenerLogConferenciaID(logConferenciaVO.getLogconferenciaId());
				conferenciaComissaoService.borrarLogConferencia(logConferencia);
				
				carregarDados();
				
	            Messagebox.show(Labels.getLabel("conferenciaController.msg.removerLogConferencia"),
	    				Labels.getLabel("conferenciaController.window.title"),
	    				Messagebox.OK,Messagebox.INFORMATION);				
			}
			
		} catch (Exception e) {
			log.error(e.getMessage(), e);
		    Messagebox.show(Labels.getLabel("MSG.Error"),
		    				Labels.getLabel("conferenciaController.window.title"),
		    				Messagebox.OK,Messagebox.ERROR);
		}
	}
	
	private void lancarLogConferenciaBilhete(BoletoComissao boletoComissao, MyListbox localBilhetesList) {
		if (boletoComissao == null || isObservacaoLancada(boletoComissao) || isMovimentoEncerrado()) {
            return;
        }

        Map<String, Object> args = new HashMap<String, Object>();
        args.put("boletoComissao", boletoComissao);
        args.put("logsConferenciaList", logsConferenciaList);
        args.put("bilhetesList", localBilhetesList);
        args.put("conferencia", conferencia);

        openWindow("/gui/comissao/editarLogConferenciaComissao.zul",
        	Labels.getLabel("editarLogConferenciaComissaoController.window.title"), args, MODAL);
    }
	
	private void lancarLogConferenciaEventosFinanceiros(EventosFinanceirosVO eventosFinanceiros, MyListbox eventosFinanceirosList) {
        if (eventosFinanceiros == null || isObservacaoLancada(eventosFinanceiros) || isMovimentoEncerrado()) {
            return;
        }

        Map<String, Object> args = new HashMap<String, Object>();
        args.put("eventosFinanceiros", eventosFinanceiros);
        args.put("logsConferenciaList", logsConferenciaList);
        args.put("eventosFinanceirosList", eventosFinanceirosList);
        args.put("conferencia", conferencia);

        openWindow("/gui/comissao/editarLogConferenciaComissao.zul",
        	Labels.getLabel("editarLogConferenciaComissaoController.window.title"), args, MODAL);
	}
	
	private void lancarLogConferenciaOcd(OcdVO ocd, MyListbox ocdsList) {
        if (ocd == null || isObservacaoLancada(ocd) || isMovimentoEncerrado()) {
            return;
        }

        Map<String, Object> args = new HashMap<String, Object>();
        args.put("ocd", ocd);
        args.put("logsConferenciaList", logsConferenciaList);
        args.put("ocdsList", ocdsList);
        args.put("conferencia", conferencia);

        openWindow("/gui/comissao/editarLogConferenciaComissao.zul",
        	Labels.getLabel("editarLogConferenciaComissaoController.window.title"), args, MODAL);
	}
	
	private boolean isObservacaoLancada(BoletoComissao boletoComissao) {
		for (LogConferenciaVO logConferencia : lsLogsConferencia) {
			if(boletoComissao.getBoletoId().equals(logConferencia.getBoletoId())) {
				return true;
			}
		}
		return false;
	}
	
	private boolean isObservacaoLancada(EventosFinanceirosVO eventosFinanceiros) {
		for (LogConferenciaVO logConferencia : lsLogsConferencia) {
			if(eventosFinanceiros.getEventoextraId().equals(logConferencia.getEventoextraId())) {
				return true;
			}
		}
		return false;
	}
	
	private boolean isObservacaoLancada(OcdVO ocd) {
		for (LogConferenciaVO logConferencia : lsLogsConferencia) {
			if(ocd.getOcdId().equals(logConferencia.getOcdId())) {
				return true;
			}
		}
		return false;
	}
	
	private void carregarDadosConferencia() {
		try {
			List<ConferenciaComissaoVO> lsConferenciaComissao = conferenciaComissaoService.carregarConferenciaComissao(DateUtil.getStringDate(conferencia.getDatamovimento(), "MM/yyyy"), conferencia.getEmpresa(), puntoventaFiltro);
			conferenciaList.setData(lsConferenciaComissao);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}
	
	public void onClick$btnPesquisaBoletoDevolvido(Event event) throws InterruptedException {
		try {
			if((empresa.getIndcarboletosdevolvidosconf() == null || !empresa.getIndcarboletosdevolvidosconf()) &&
				StringUtils.isBlank(conferencia.getNumfoliosistema())) {
				 Messagebox.show(Labels.getLabel("conferenciaController.msg.numfoliosistemaNaoInformado"),
		    				Labels.getLabel("conferenciaController.window.title"),
		    				Messagebox.OK,Messagebox.INFORMATION);
				 return;
			}
			lsBilhetesDevolvidos = conferenciaComissaoService.carregarBilhetesComissao(null, conferencia, BoletoStatusComissao.BOLETO_DEVOLVIDO);
			txtTotalBilhetesDevolvidos.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(conferenciaComissaoService.totalizarBoletoComissao(lsBilhetesDevolvidos), LocaleUtil.getLocale()));
			txtQtdeTotalBilhetesDevolvidos.setValue(String.valueOf(lsBilhetesDevolvidos.size()));
			bilhetesDevolvidosList.setData(lsBilhetesDevolvidos);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}

	public String getDatamovimento() {
		return datamovimento;
	}

	public void setDatamovimento(String datamovimento) {
		this.datamovimento = datamovimento;
	}

	public Empresa getEmpresa() {
		return empresa;
	}

	public void setEmpresa(Empresa empresa) {
		this.empresa = empresa;
	}

	public String getPuntoventa() {
		return puntoventa;
	}

	public void setPuntoventa(String puntoventa) {
		this.puntoventa = puntoventa;
	}

	public Conferencia getConferencia() {
		return conferencia;
	}

	public void setConferencia(Conferencia conferencia) {
		this.conferencia = conferencia;
	}
	
	public Boolean isMovimentoNaoEncerrado() {
		return conferencia.getIndconferido() == null || !conferencia.getIndconferido();
	} 
	
	public Boolean isMovimentoEncerrado() {
		return conferencia.getIndconferido() != null && conferencia.getIndconferido();
	} 
	
	public Boolean isPermissaoEncerrarMovimento() {
		return UsuarioLogado.getUsuarioLogado().isPermisoClave(Constantes.CLAVE_ENCERRAR_MOVIMENTODIARIO);
	} 

	public Boolean isPermissaoReabrirMovimento() {
		return UsuarioLogado.getUsuarioLogado().isPermisoClave(Constantes.CLAVE_REABRIR_MOVIMENTODIARIO);
	} 

	public Boolean isExibirBotaoReabrirMovimento() {
		return isMovimentoEncerrado() && isPermissaoReabrirMovimento();
	} 

	public Boolean isExibirBotaoEncerrarMovimento() {
		return isMovimentoNaoEncerrado() && isPermissaoEncerrarMovimento();
	} 

	public Boolean isExibirBotaoChegadaMalote() {
		return (conferencia.getIndmaloterecebido() == null || !conferencia.getIndmaloterecebido()) && isMovimentoNaoEncerrado();
	}

	public void onClick$btnCerrar() throws InterruptedException {
		validarConferencia();
		this.closeWindow();
	}

	private void validarConferencia() throws InterruptedException {
		try {
			validarBilhetes();
			validarEventosFinanceiros();
			validarOcds();
		} catch (Exception e) {
			log.error(e.getMessage(), e);
            Messagebox.show(Labels.getLabel("MSG.Error"),
            				Labels.getLabel("conferenciaController.window.title"),
            				Messagebox.OK,Messagebox.ERROR);
		}
	}
	
	private void validarOcds() {
	}

	private void validarEventosFinanceiros() {
	}

	private void validarBilhetes() throws BusinessException {
		/*validarListBilhetes(bilhetesManualList);
		validarListBilhetes(bilhetesList);
		validarListBilhetes(bilhetesCanceladosList);
		validarListBilhetes(bilhetesDevolvidosList);
		validarListBilhetes(bilhetesGapCanceladosList);
		validarListBilhetes(bilhetesGapDevolvidosList);
		validarListBilhetes(bilhetesGapList);*/
	}

	/*@SuppressWarnings("unchecked")
	private void validarListBilhetes(MyListbox bilhetes) throws BusinessException {
		int index = 0;
		List<Listitem> itens = bilhetes.getItems();
		List<BoletoComissao> boletoComissaos = bilhetes.getListData();
		for (Listitem item: itens) {
			BoletoComissao boletoComissao = boletoComissaos.get(index++);
			boletoComissao.setConferido(validarListitemMarcado(item, boletoComissao));
			if(boletoComissao.isConferido() && boletoComissao.getLogconferenciaId() == null) {
				LogConferencia logConferencia = gravarLogConferencia(TipoLogConferencia.BOLETO, boletoComissao.getBoletoId(), boletoComissao.getNumFolioSistema());
				boletoComissao.setLogconferenciaId(logConferencia.getLogconferenciaId());
				boletoComissao.setStatus(logConferencia.getStatus().getValue());
				boletoComissao.setConferido(Boolean.TRUE);
				bilhetes.updateItem(boletoComissao);
			} else if(!boletoComissao.isConferido() && boletoComissao.getLogconferenciaId() != null) {
				LogConferencia logConferencia = conferenciaComissaoService.obtenerLogConferenciaID(boletoComissao.getLogconferenciaId());
				conferenciaComissaoService.borrarLogConferencia(logConferencia);
				boletoComissao.setLogconferenciaId(null);
				boletoComissao.setStatus(null);
				boletoComissao.setConferido(Boolean.FALSE);
				removerLogConferencia(logConferencia);
				bilhetes.updateItem(boletoComissao);
			}
		}
	}*/

	private void removerLogConferencia(Long logconferenciaId) {
		logsConferenciaList.removeItem(new LogConferenciaVO(logconferenciaId));
	}

	private LogConferencia gravarLogConferencia(TipoLogConferencia tipo, Long id, String numfoliosistema) throws BusinessException {
		LogConferencia logConferencia = new LogConferencia();
		logConferencia.setObservacao("OK");
		logConferencia.setConferencia(conferencia);
		logConferencia.setStatus(StatusLogConferencia.CONFERIDO);
		logConferencia.setTipo(tipo);
		logConferencia.setIndcredito(Boolean.TRUE);
		
		if(tipo.equals(TipoLogConferencia.BOLETO)) {
			logConferencia.setBoletoId(id);
		}
		if(tipo.equals(TipoLogConferencia.OCD)) {
			logConferencia.setOcdId(id);
		}
		if(tipo.equals(TipoLogConferencia.EVENTO_FINANCEIRO)) {
			logConferencia.setEventoextraId(id);
		}
		
		logConferencia = conferenciaComissaoService.suscribirLogConferencia(logConferencia);
		atualizarLogConferenciaList(logConferencia, numfoliosistema);
		
		return logConferencia;
	}
	
	private void atualizarLogConferenciaList(LogConferencia logConferencia, String numfoliosistema) {
		LogConferenciaVO logConferenciaVO = new LogConferenciaVO();
		logConferenciaVO.setLogconferenciaId(logConferencia.getLogconferenciaId());
		logConferenciaVO.setBoletoId(logConferencia.getBoletoId());
		logConferenciaVO.setEventoextraId(logConferencia.getEventoextraId());
		logConferenciaVO.setOcdId(logConferencia.getOcdId());
		logConferenciaVO.setFecmodif(logConferencia.getFecmodif());
		logConferenciaVO.setNombusuario(UsuarioLogado.getUsuarioLogado().getNombusuario());
		logConferenciaVO.setNumfoliosistema(numfoliosistema);
		logConferenciaVO.setObservacao(logConferencia.getObservacao());
		logConferenciaVO.setPreco(logConferencia.getPreco());
		logConferenciaVO.setStatus(logConferencia.getStatus().getValue());
		logConferenciaVO.setTipo(logConferencia.getTipo().getValue());
		logsConferenciaList.updateItem(logConferenciaVO);
	}

	/*@SuppressWarnings("unchecked")
	private void addCheckboxEventListenerBilhetes(MyListbox bilhetes) {
		int index = 0;
		List<Listitem> itens = bilhetes.getItems();
		List<BoletoComissao> boletoComissaos = bilhetes.getListData();
		for (Listitem item: itens) {
			List<Component> com = item.getChildren();
			for (Component component: com) {
				Listcell listCell = (Listcell) component;
				System.out.println(listCell.getFirstChild());
				if(listCell.getFirstChild() instanceof Checkbox) {
					Checkbox chk = (Checkbox)component.getFirstChild();
					chk.setId(boletoComissaos.get(index++).getBoletoId()+"");
					chk.addEventListener("onCheck", new EventListener() {
						@Override
						public void onEvent(Event arg0) throws Exception {
							System.out.println("EXECUTOU");
						}
					});
				}
			}
		}
	}*/
	
	private void gravarLogConferenciaBilhete(MyListbox bilhetes, BoletoComissao boletoComissao) {
		try {
			LogConferencia logConferencia = gravarLogConferencia(TipoLogConferencia.BOLETO, boletoComissao.getBoletoId(), boletoComissao.getNumFolioSistema());
			boletoComissao.setLogconferenciaId(logConferencia.getLogconferenciaId());
			boletoComissao.setStatus(logConferencia.getStatus().getValue());
			boletoComissao.setConferido(Boolean.TRUE);
			bilhetes.updateItem(boletoComissao);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}
	
	private void removerLogConferenciaBilhete(MyListbox bilhetes, BoletoComissao boletoComissao) {
		try {
			LogConferencia logConferencia = conferenciaComissaoService.obtenerLogConferenciaID(boletoComissao.getLogconferenciaId());
			conferenciaComissaoService.borrarLogConferencia(logConferencia);
			boletoComissao.setLogconferenciaId(null);
			boletoComissao.setStatus(null);
			boletoComissao.setConferido(Boolean.FALSE);
			removerLogConferencia(logConferencia.getLogconferenciaId());
			bilhetes.updateItem(boletoComissao);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}
	
	private void gravarLogConferenciaEventoFinanceiro(EventosFinanceirosVO eventoFinanceiro) {
		try {
			LogConferencia logConferencia = gravarLogConferencia(TipoLogConferencia.EVENTO_FINANCEIRO, eventoFinanceiro.getEventoextraId(), null);
			eventoFinanceiro.setLogconferenciaId(logConferencia.getLogconferenciaId());
			eventoFinanceiro.setStatus(logConferencia.getStatus().getValue());
			eventoFinanceiro.setConferido(Boolean.TRUE);
			eventosFinanceirosList.updateItem(eventoFinanceiro);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}
	
	private void removerLogConferenciaEventoFinanceiro(EventosFinanceirosVO eventoFinanceiro) {
		try {
			LogConferencia logConferencia = conferenciaComissaoService.obtenerLogConferenciaID(eventoFinanceiro.getLogconferenciaId());
			conferenciaComissaoService.borrarLogConferencia(logConferencia);
			eventoFinanceiro.setLogconferenciaId(null);
			eventoFinanceiro.setStatus(null);
			eventoFinanceiro.setConferido(Boolean.FALSE);
			removerLogConferencia(logConferencia.getLogconferenciaId());
			eventosFinanceirosList.updateItem(eventoFinanceiro);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}

	@Override
	public void closeWindow() {
		carregarDadosConferencia();
		super.closeWindow();
	}

	public ResumoComissao getResumo() {
		return resumo;
	}

	public void setResumo(ResumoComissao resumo) {
		this.resumo = resumo;
	}

	public MyListbox getFormapagosList() {
		return formapagosList;
	}

	public void setFormapagosList(MyListbox formapagosList) {
		this.formapagosList = formapagosList;
	} 

}
