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

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

import org.apache.logging.log4j.LogManager;
import org.apache.logging.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.Combobox;
import org.zkoss.zul.Comboitem;
import org.zkoss.zul.Listcell;
import org.zkoss.zul.Listitem;
import org.zkoss.zul.Radio;
import org.zkoss.zul.Row;
import org.zkoss.zul.Tab;

import com.rjconsultores.ventaboletos.constantes.ConstantesFuncionSistema;
import com.rjconsultores.ventaboletos.entidad.Conferencia;
import com.rjconsultores.ventaboletos.entidad.ConferenciaPendencia;
import com.rjconsultores.ventaboletos.entidad.Empresa;
import com.rjconsultores.ventaboletos.entidad.LogConferencia;
import com.rjconsultores.ventaboletos.entidad.PtovtaComissao;
import com.rjconsultores.ventaboletos.entidad.PuntoVenta;
import com.rjconsultores.ventaboletos.entidad.TipoInformativoComissao;
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.service.ConferenciaPendenciaService;
import com.rjconsultores.ventaboletos.service.PtovtaComissaoService;
import com.rjconsultores.ventaboletos.service.TipoInformativoComissaoService;
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.DiaConferenciaComissaoVO;
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")
@SuppressWarnings({"unchecked", "rawtypes"})
public class ConferenciaController extends MyGenericForwardComposer {

	private static final long serialVersionUID = 1L;

	private static Logger log = LogManager.getLogger(ConferenciaController.class);

	@Autowired
	private ConferenciaComissaoService conferenciaComissaoService;

	@Autowired
	private TipoInformativoComissaoService tipoInformativoComissaoService;

	@Autowired
	private ConferenciaPendenciaService conferenciaPendenciaService;

	@Autowired
	private PtovtaComissaoService ptovtaComissaoService;
	
	private String datamovimento;
	private Empresa empresa;
	private Integer puntoventaId;
	private PuntoVenta puntoventaFiltro;
	private String puntoventa;
	private Conferencia conferencia;
	
	//Variavel de controle que indica se ja passou pela criacao do grid.
	private Boolean jaPassou = false;

	private MyListbox ecfListBox;

	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 Hbox hboxValoresCaixaComissao;
	
	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 Radio rCredito;
	private Radio rInformativo;

	private Radio rMsmDia;
	private Radio rDiaPosterior;

	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;

	private ConferenciaComissaoVO conferenciaComissao;

	private Combobox cmbTipoInformativo;
	private Combobox cmbConferenciaDia;

	private List<TipoInformativoComissao> lsTipoInformativo;

	private MyComboboxEstandar cmbConferenciaPendencia;
	private List<ConferenciaPendencia> lsConferenciaPendencia;

	private Tab tabBilhetesManual;
	private Tab tabBilhetesVenda;
	private Tab tabBilhetesCancelados;
	private Tab tabBilhetesDevolvidos;
	private Tab tabGapVenda;
	private Tab tabGapCancelado;
	private Tab tabGapDevolvido;
	private Tab tabEventosFinanceiros;
	private Tab tabOcd;

	private Date dataInicial;
	private Date dataFinal;
	private List<Conferencia> conferencias;
	Boolean isPeriodo;
	private Row rowDataMovimento;

	@Override
	public void doAfterCompose(Component comp) throws Exception {

		isPeriodo = (Boolean) Executions.getCurrent().getArg().get("isPeriodo");

		if (isPeriodo) {
			dataInicial = (Date) Executions.getCurrent().getArg().get("dataInicial");
			dataFinal = (Date) Executions.getCurrent().getArg().get("dataFinal");

			SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
			datamovimento = formato.format(dataInicial) + " - " + formato.format(dataFinal);
		} else {
			datamovimento = (String) Executions.getCurrent().getArg().get("datamovimento");
		}

		conferenciaComissao = (ConferenciaComissaoVO) Executions.getCurrent().getArg().get("conferenciaComissao");
		lsTipoInformativo = tipoInformativoComissaoService.obtenerTodos();
		conferenciaList = (MyListbox) Executions.getCurrent().getArg().get("conferenciaList");
		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);

		lsConferenciaPendencia = new ArrayList<ConferenciaPendencia>();
		lsConferenciaPendencia.add(new ConferenciaPendencia(-1, " "));
		lsConferenciaPendencia.addAll(conferenciaPendenciaService.obtenerTodos());

		if (isPeriodo) {
			dataInicial = (Date) Executions.getCurrent().getArg().get("dataInicial");
			dataFinal = (Date) Executions.getCurrent().getArg().get("dataFinal");
			recuperarConferencias(conferenciaComissao);
		} else {
			Long conferenciaId = (Long) Executions.getCurrent().getArg().get("conferenciaId");
			recuperarConferencia(conferenciaId);
		}

		super.doAfterCompose(comp);
		rowDataMovimento.setVisible(isPeriodo);

		logsConferenciaList.setItemRenderer(new RenderLogConferencia());

		ocdsList.setItemRenderer(new RenderOcd() {
			@Override
			public void render(Listitem lstm, Object o) throws Exception {
				super.render(lstm, o);
				final OcdVO ocd = (OcdVO) 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(getEnableDisableCheckBox(ocd.getConferencia()));
						chk.addEventListener("onCheck", new EventListener() {
							@Override
							public void onEvent(Event event) throws Exception {
								CheckEvent checkEvent = (CheckEvent) event;
								if (checkEvent.isChecked() && ocd.getLogconferenciaId() == null) {
									gravarLogConferenciaOcd(ocd);
								} else if (!checkEvent.isChecked() && ocd.getLogconferenciaId() != null) {
									removerLogConferenciaOcd(ocd);
								}
							}
						});
					}
				}
			}
		});
		ocdsList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				OcdVO ocd = (OcdVO) ocdsList.getSelected();
				lancarLogConferenciaOcd(ocd, ocdsList, tabOcd);
			}
		});

		eventosFinanceirosList.setItemRenderer(new RenderEventosFinanceiros() {
			@Override
			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(getEnableDisableCheckBox(eventoFinanceiro.getConferencia()));
						chk.addEventListener("onCheck", new EventListener() {
							@Override
							public void onEvent(Event event) throws Exception {
								CheckEvent checkEvent = (CheckEvent) event;
								if (checkEvent.isChecked() && eventoFinanceiro.getLogconferenciaId() == null || eventoFinanceiro.getLogconferenciaId() == 0) {
									gravarLogConferenciaEventoFinanceiro(eventoFinanceiro);
								} else if (!checkEvent.isChecked() && eventoFinanceiro.getLogconferenciaId() != null) {
									removerLogConferenciaEventoFinanceiro(eventoFinanceiro);
								}
							}
						});
						break;
					}
				}
			}
		});

		eventosFinanceirosList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				EventosFinanceirosVO eventosFinanceiros = (EventosFinanceirosVO) eventosFinanceirosList.getSelected();
				lancarLogConferenciaEventosFinanceiros(eventosFinanceiros, eventosFinanceirosList);
			}
		});

		cmbSituacaoLog.addEventListener("onSelect", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				StatusLogConferencia status = StatusLogConferencia.getStatusLogConferencia((Integer) cmbSituacaoLog.getSelectedItem().getValue());
				rMsmDia.setSelected(true);
				if (StatusLogConferencia.CONFERIDO.equals(status)) {
					txtPrecoLog.setDisabled(true);
					rDebito.setDisabled(true);
					rCredito.setDisabled(true);
					rInformativo.setDisabled(true);

					rMsmDia.setDisabled(false);
					rDiaPosterior.setDisabled(false);
					rMsmDia.setSelected(true);

				} else if (StatusLogConferencia.PENDENCIA.equals(status)) {
					txtPrecoLog.setDisabled(false);
					rDebito.setDisabled(false);
					rCredito.setDisabled(false);
					rInformativo.setDisabled(false);

					rMsmDia.setDisabled(false);
					rDiaPosterior.setDisabled(false);
				}
			}
		});

		ajustarListsBilhetes();

		rDebito.setChecked(Boolean.TRUE);
		rMsmDia.setChecked(true);

		formapagosList.setItemRenderer(new RenderFormapagoComissao());

		popularCombobox();
		carregarDados();

		ecfListBox.setItemRenderer(new RenderEcfPontoVenda());

		ecfListBox.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {

				List listNumSerie = ecfListBox.getSelectedModelItems();

				if (listNumSerie.isEmpty()) {
					Messagebox.show(Labels.getLabel("conferenciaController.MSG.nenhumaNumeroSerieEcfSelecionado"),
							Labels.getLabel("conferenciaController.window.title"),
							Messagebox.OK, Messagebox.EXCLAMATION);
					return;
				}

				Map<String, Object> args = new HashMap<String, Object>();
				args.put("puntoVentaId", puntoventaId);
				args.put("listNumSerie", listNumSerie);
				openWindow("/gui/comissao/informeIrregularidadeComissao.zul",
						Labels.getLabel("informeIrregularidadeController.window.title"), args);
			}
		});
		
	}

	private void ajustarListsBilhetes() {
		bilhetesManualList.setItemRenderer(new RenderBoletoComissao() {
			@Override
			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.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, tabBilhetesManual, "conferenciaController.tab.bilhetesManual");
								} else if (!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesManualList, boletoComissao, tabBilhetesManual, "conferenciaController.tab.bilhetesManual");
								}
							}
						});
					}
				}
			}
		});
		bilhetesManualList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				BoletoComissao boletoComissao = (BoletoComissao) bilhetesManualList.getSelected();
				lancarLogConferenciaBilhete(boletoComissao, bilhetesManualList, tabBilhetesManual);
			}
		});

		bilhetesList.setItemRenderer(new RenderBoletoComissao() {
			@Override
			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();
						if (boletoComissao.isConferido() && boletoComissao.getLogconferenciaId() == null) {
							gravarLogConferenciaBilhete(bilhetesList, boletoComissao, tabBilhetesVenda, "conferenciaController.tab.bilhetes");	
						}
						chk.setDisabled(getEnableDisableCheckBox(boletoComissao.getConferencia()));
						if(!chk.isDisabled() && boletoComissao.isBilheteEntregaConferidoVenda()) {
							chk.setDisabled(true);
						}
						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, tabBilhetesVenda, "conferenciaController.tab.bilhetes");
								} else if (!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesList, boletoComissao, tabBilhetesVenda, "conferenciaController.tab.bilhetes");
								}
							}
						});
						
					}
				}
				jaPassou = true;
			}

		});
		bilhetesList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				BoletoComissao boletoComissao = (BoletoComissao) bilhetesList.getSelected();
				lancarLogConferenciaBilhete(boletoComissao, bilhetesList, tabBilhetesVenda);
			}
		});

		bilhetesCanceladosList.setItemRenderer(new RenderBoletoComissao() {
			@Override
			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(getEnableDisableCheckBox(boletoComissao.getConferencia()));
						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, tabBilhetesCancelados, "conferenciaController.tab.bilhetesCancelados");
								} else if (!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesCanceladosList, boletoComissao, tabBilhetesCancelados, "conferenciaController.tab.bilhetesCancelados");
								}
							}
						});
					}
				}
			}
		});
		bilhetesCanceladosList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				BoletoComissao boletoComissao = (BoletoComissao) bilhetesCanceladosList.getSelected();
				lancarLogConferenciaBilhete(boletoComissao, bilhetesCanceladosList, tabBilhetesCancelados);
			}
		});

		bilhetesDevolvidosList.setItemRenderer(new RenderBoletoComissao() {
			@Override
			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(getEnableDisableCheckBox(boletoComissao.getConferencia()));
						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, tabBilhetesDevolvidos, "conferenciaController.tab.bilhetesDevolvidos");
								} else if (!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesDevolvidosList, boletoComissao, tabBilhetesDevolvidos, "conferenciaController.tab.bilhetesDevolvidos");
								}
							}
						});
					}
				}
			}
		});
		bilhetesDevolvidosList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				BoletoComissao boletoComissao = (BoletoComissao) bilhetesDevolvidosList.getSelected();
				lancarLogConferenciaBilhete(boletoComissao, bilhetesDevolvidosList, tabBilhetesDevolvidos);
			}
		});

		bilhetesGapList.setItemRenderer(new RenderBoletoComissao() {
			@Override
			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(getEnableDisableCheckBox(boletoComissao.getConferencia()));
						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, tabGapVenda, "conferenciaController.tab.gabVenda");
								} else if (!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesGapList, boletoComissao, tabGapVenda, "conferenciaController.tab.gabVenda");
								}
							}
						});
					}
				}
			}
		});
		bilhetesGapList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				BoletoComissao boletoComissao = (BoletoComissao) bilhetesGapList.getSelected();
				lancarLogConferenciaBilhete(boletoComissao, bilhetesGapList, tabGapVenda);
			}
		});

		bilhetesGapCanceladosList.setItemRenderer(new RenderBoletoComissao() {
			@Override
			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(getEnableDisableCheckBox(boletoComissao.getConferencia()));
						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, tabGapCancelado, "conferenciaController.tab.gabCancelado");
								} else if (!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesGapCanceladosList, boletoComissao, tabGapCancelado, "conferenciaController.tab.gabCancelado");
								}
							}
						});
					}
				}
			}
		});
		bilhetesGapCanceladosList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				BoletoComissao boletoComissao = (BoletoComissao) bilhetesGapCanceladosList.getSelected();
				lancarLogConferenciaBilhete(boletoComissao, bilhetesCanceladosList, tabGapCancelado);
			}
		});

		bilhetesGapDevolvidosList.setItemRenderer(new RenderBoletoComissao() {
			@Override
			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(getEnableDisableCheckBox(boletoComissao.getConferencia()));
						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, tabGapDevolvido, "conferenciaController.tab.gabDevolvido");
								} else if (!checkEvent.isChecked() && boletoComissao.getLogconferenciaId() != null) {
									removerLogConferenciaBilhete(bilhetesGapDevolvidosList, boletoComissao, tabGapDevolvido, "conferenciaController.tab.gabDevolvido");
								}
							}
						});
					}
				}
			}
		});
		bilhetesGapDevolvidosList.addEventListener("onDoubleClick", new EventListener() {
			@Override
			public void onEvent(Event event) throws Exception {
				BoletoComissao boletoComissao = (BoletoComissao) bilhetesGapDevolvidosList.getSelected();
				lancarLogConferenciaBilhete(boletoComissao, bilhetesDevolvidosList, tabGapDevolvido);
			}
		});
	}

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

		if (conferencias != null) {
			for (Conferencia c : conferencias) {
				if (!isMovimentoEncerrado(c) && (isMaloteRecebido(c) || !isNaopermiteconfsemmalote())) {
					SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
					Comboitem comboItem = new Comboitem(formato.format(c.getDatamovimento()));
					comboItem.setValue(c);
					comboItem.setParent(cmbConferenciaDia);
				}
			}
			if (cmbConferenciaDia.getItems().size() == 1) {
				cmbConferenciaDia.setSelectedIndex(0);
				cmbConferenciaDia.setDisabled(true);
			} else if (cmbConferenciaDia.getItems().size() == 0) {
				exibirBtnLogPeriodo = false;
				cmbConferenciaDia.setDisabled(true);
			}
		}

	}

	private void carregarDados() throws Exception {
		try {
			List<BoletoComissao> boletosComissaos = null;

			if (isPeriodo) {
				boletosComissaos = conferenciaComissaoService.carregarBilhetesComissao(null, conferencias, null, false);
			} else {
				boletosComissaos = conferenciaComissaoService.carregarBilhetesComissao(null, getConferencia(), null, false);
			}

			carregarBilhetesManual(boletosComissaos);
			carregarBilhetesVendidos(boletosComissaos, false);
			carregarBilhetesCancelados(boletosComissaos, false);
			carregarBilhetesDevolvidos(boletosComissaos, false);
			carregarBilhetesGap(boletosComissaos);
			carregarBilhetesGapCancelados(boletosComissaos);
			carregarBilhetesGapDevolvidos(boletosComissaos);
			carregarEventosFinanceiros(boletosComissaos);
			carregarOcds();
			carregarLogsConferencia();
			carregarResumo(boletosComissaos);
			
			PtovtaComissao ptovtaComissao = ptovtaComissaoService.buscarPuntaVentaEmpresa(puntoventaId, empresa.getEmpresaId());
			if (ptovtaComissao != null && (ptovtaComissao.getIndretercomissao() == null || !ptovtaComissao.getIndretercomissao())) {
//				hboxValoresCaixaComissao.setVisible(false);
			} else { // reter comissao
				Date dataIni = null;
				Date datafim = null;
				if (isPeriodo) {
					dataIni = (Date) Executions.getCurrent().getArg().get("dataInicial");
					datafim = (Date) Executions.getCurrent().getArg().get("dataFinal");
				} else {
					dataIni = DateUtil.getDateFromString(datamovimento, "dd/MM/yyyy");
					datafim = DateUtil.getDateFromString(datamovimento, "dd/MM/yyyy");
				}
				BigDecimal valorComissao = conferenciaComissaoService.getComissaoPuntoVenta(puntoventaId, empresa.getEmpresaId(), dataIni, datafim);
				BigDecimal valorEmCaixa = resumo.getValorDeposito();
				BigDecimal valorDeposito = valorComissao != null ? valorEmCaixa.subtract(valorComissao) : valorEmCaixa;

//				resumo.setValorEmCaixa(valorEmCaixa);
//				resumo.setComissaoRetida(valorComissao);
				resumo.setValorDeposito(valorDeposito);
			}

			this.ajustarPendentes(boletosComissaos);

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


	/**
	 * Metodo criado com o objetivo de adicionar os bilhetes não classificados previamente.
	 * 
	 * Ou seja, casos ainda existam bilhetes apos a classificacao, os mesmos serao separadas em cancelados e vendidos
	 * 
	 * @param boletosComissaos
	 * @throws BusinessException 
	 */
	private void ajustarPendentes(List<BoletoComissao> boletosComissaos) throws BusinessException {

		boletosComissaos.removeAll(this.lsBilhetes);
		boletosComissaos.removeAll(this.lsBilhetesCancelados);
		boletosComissaos.removeAll(this.lsBilhetesDevolvidos);
		boletosComissaos.removeAll(this.lsBilhetesGap);
		boletosComissaos.removeAll(this.lsBilhetesGapCancelados);
		boletosComissaos.removeAll(this.lsBilhetesGapDevolvidos);
		boletosComissaos.removeAll(this.lsBilhetesManual);

		boolean vendidosAtualizado = false;
		boolean canceladoAtualizado = false;
		boolean devolvidoAtualizado = false;

		for (BoletoComissao b : boletosComissaos) {
			log.info(b.toString());			
			if (b.getIndCancelacion()) {
				if (b.isMotivocancelacionDevolvido()) {
					this.lsBilhetesDevolvidos.add(b);
					devolvidoAtualizado = true;
				} else if (b.isMotivocancelacionCancelado()) {
					this.lsBilhetesCancelados.add(b);
					canceladoAtualizado = true;
				}
			} else if (!b.isMotivocancelacionTransferido()) {
				this.lsBilhetes.add(b);
				vendidosAtualizado = true;
			}
		}

		// recarrega as informacoes
		if (vendidosAtualizado) {
			this.carregarBilhetesVendidos(this.lsBilhetes, true);
		}

		// recarrega as informacoes
		if (canceladoAtualizado) {
			this.carregarBilhetesCancelados(this.lsBilhetesCancelados, true);
		}

		// recarrega as informacoes
		if (devolvidoAtualizado) {
			this.carregarBilhetesDevolvidos(this.lsBilhetesDevolvidos, true);
		}

	}

	private void carregarResumo(List<BoletoComissao> boletosComissaos) throws BusinessException {
		if (isPeriodo) {
			// metodo apenas usa empresa e punto venda da conferencia, entao pode ser passado o primeiro da lista
			resumo = conferenciaComissaoService.gerarResumo(conferencias.isEmpty() ? null : conferencias.get(0), boletosComissaos, lsEventosFinanceiros, totalBilhetesManual, totalBilhetesVendidos, totalBilhetesCancelados, totalBilhetesDevolvidos, totalBilhetesGap, totalBilhetesGapCancelados, totalBilhetesGapDevolvidos, totalCreditosEventoFinanceiros, totalDebitosEventoFinanceiros, ocdTotal, totalBilhetesDevolvidosTroca, totalBilhetesGapDevolvidosTroca);
		} else {
			resumo = conferenciaComissaoService.gerarResumo(conferencia, boletosComissaos, lsEventosFinanceiros, totalBilhetesManual, totalBilhetesVendidos, totalBilhetesCancelados, totalBilhetesDevolvidos, totalBilhetesGap, totalBilhetesGapCancelados, totalBilhetesGapDevolvidos, totalCreditosEventoFinanceiros, totalDebitosEventoFinanceiros, ocdTotal, totalBilhetesDevolvidosTroca, totalBilhetesGapDevolvidosTroca);
		}

		formapagosList.setData(resumo.getTotalFormapago());
		ecfListBox.setData(resumo.getListNumSerieECF());
	}
	
	private void carregarBilhetesManual(List<BoletoComissao> boletosComissaos) throws BusinessException {
		if (isPeriodo) {
			lsBilhetesManual = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencias, BoletoStatusComissao.BOLETO_MANUAL, false);
		} else {
			lsBilhetesManual = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.BOLETO_MANUAL, false);
		}
		totalBilhetesManual = conferenciaComissaoService.totalizarBoletoComissao(lsBilhetesManual);
		txtTotalBilhetesManual.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesManual, LocaleUtil.getLocale()));
		txtQtdeTotalBilhetesManual.setValue(String.valueOf(lsBilhetesManual.size()));
		bilhetesManualList.setData(lsBilhetesManual);

		verificarBilhetesSemConferencia(lsBilhetesManual, tabBilhetesManual);
	}

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

		verificarBilhetesSemConferencia(lsBilhetes, tabBilhetesVenda);
	}

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

		verificarBilhetesSemConferencia(lsBilhetesCancelados, tabBilhetesCancelados);
	}

	private void carregarBilhetesDevolvidos(List<BoletoComissao> boletosComissaos, boolean carregarDadosFaltantes) throws BusinessException {
		totalBilhetesDevolvidos = BigDecimal.ZERO;

		if (isPeriodo) {
			lsBilhetesDevolvidos = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencias, BoletoStatusComissao.BOLETO_DEVOLVIDO, carregarDadosFaltantes);
		} else {
			lsBilhetesDevolvidos = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.BOLETO_DEVOLVIDO, carregarDadosFaltantes);
		}

		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);

		verificarBilhetesSemConferencia(lsBilhetesDevolvidos, tabBilhetesDevolvidos);
	}

	private void carregarBilhetesGap(List<BoletoComissao> boletosComissaos) throws BusinessException {
		if (isPeriodo) {
			lsBilhetesGap = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencias, BoletoStatusComissao.GAP_VENDIDOS, false);
		} else {
			lsBilhetesGap = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.GAP_VENDIDOS, false);
		}

		totalBilhetesGap = conferenciaComissaoService.totalizarBoletoComissao(lsBilhetesGap);
		txtTotalBilhetesGap.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesGap, LocaleUtil.getLocale()));
		txtQtdeTotalBilhetesGap.setValue(String.valueOf(lsBilhetesGap.size()));
		bilhetesGapList.setData(lsBilhetesGap);

		verificarBilhetesSemConferencia(lsBilhetesGap, tabGapVenda);
	}

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

		verificarBilhetesSemConferencia(lsBilhetesGapCancelados, tabGapCancelado);
	}

	private void carregarBilhetesGapDevolvidos(List<BoletoComissao> boletosComissaos) throws BusinessException {
		if (isPeriodo) {
			lsBilhetesGapDevolvidos = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencias, BoletoStatusComissao.GAP_DEVOLVIDO, false);
		} else {
			lsBilhetesGapDevolvidos = conferenciaComissaoService.carregarBilhetesComissao(boletosComissaos, conferencia, BoletoStatusComissao.GAP_DEVOLVIDO, false);
		}

		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);

		verificarBilhetesSemConferencia(lsBilhetesGapDevolvidos, tabGapDevolvido);
	}

	private void carregarLogsConferencia() throws BusinessException {
		if (isPeriodo) {
			List<LogConferenciaVO> temp = new ArrayList<LogConferenciaVO>();
			lsLogsConferencia = new ArrayList<LogConferenciaVO>();

			for (Conferencia c : conferencias) {
				temp = conferenciaComissaoService.carregarLogConferencia(c);
				lsLogsConferencia.addAll(temp);
			}

		} else {
			lsLogsConferencia = conferenciaComissaoService.carregarLogConferencia(conferencia);
		}

		logsConferenciaList.setData(lsLogsConferencia);
	}

	private void carregarEventosFinanceiros(List<BoletoComissao> boletosComissaos) throws BusinessException {

		if (isPeriodo) {
			List<EventosFinanceirosVO> temp = new ArrayList<EventosFinanceirosVO>();
			if (lsEventosFinanceiros == null) {
				lsEventosFinanceiros = new ArrayList<EventosFinanceirosVO>();
			}

			for (Conferencia c : conferencias) {
				temp = conferenciaComissaoService.carregarEventosFinanceiros(c);
				lsEventosFinanceiros.addAll(temp);
			}
		} else {
			lsEventosFinanceiros = conferenciaComissaoService.carregarEventosFinanceiros(conferencia);
		}

		eventosFinanceirosList.setData(lsEventosFinanceiros);

		totalCreditosEventoFinanceiros = BigDecimal.ZERO;
		totalDebitosEventoFinanceiros = BigDecimal.ZERO;

		for (EventosFinanceirosVO eventoFinanceiro : lsEventosFinanceiros) {
			if (eventoFinanceiro.isCredito()) {
				totalCreditosEventoFinanceiros = totalCreditosEventoFinanceiros.add(eventoFinanceiro.getTotal());
			} else if (eventoFinanceiro.isDebito()) {
				totalDebitosEventoFinanceiros = totalDebitosEventoFinanceiros.add(eventoFinanceiro.getTotal().abs());
			}
		}

		txtTotalCreditosEventoFinanceiros.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalCreditosEventoFinanceiros, LocaleUtil.getLocale()));
		txtTotalDebitosEventoFinanceiros.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalDebitosEventoFinanceiros, LocaleUtil.getLocale()));
		txtTotalDiferencaEventoFinanceiros.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalCreditosEventoFinanceiros.subtract(totalDebitosEventoFinanceiros), LocaleUtil.getLocale()));

		verificarEventosFinanceirosSemConferencia(lsEventosFinanceiros, tabEventosFinanceiros);
	}

	private void carregarOcds() throws BusinessException {

		if (isPeriodo) {
			List<OcdVO> temp = new ArrayList<OcdVO>();
			if (lsOcds == null) {
				lsOcds = new ArrayList<OcdVO>();
			}

			for (Conferencia c : conferencias) {
				temp = conferenciaComissaoService.carregarOcds(c);
				lsOcds.addAll(temp);
			}
		} else {
			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);

		verificarOcdsSemConferencia(lsOcds, tabOcd);
	}

	public void onClick$btnChegadaMalote(Event event) throws InterruptedException {
		try {
			if (isPeriodo) {
				for (Conferencia c : conferencias) {
					if (!isMaloteRecebido(c) && isMovimentoNaoEncerrado(c)) {
						conferenciaComissaoService.confirmarChegadaMalote(c);
					}
				}
			} else {
				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$btnCancelarChegada(Event event) throws InterruptedException {
		conferencia = conferenciaComissaoService.cancelarChegadaMalote(conferencia);

		log.debug("Chegada de malote canelada com sucesso");
		Messagebox.show(Labels.getLabel("conferenciaController.msg.cancelarChegadaMalote"),
				Labels.getLabel("conferenciaController.window.title"),
				Messagebox.OK, Messagebox.INFORMATION);
		closeWindow();

	}

	public void onClick$btnEncerrarMovimentoDiario(Event event) throws InterruptedException {
		try {
			if (isConferenciaPendente()) {
				return;
			}

			if (isPeriodo) {
				for (Conferencia c : conferencias) {
					if ((isMaloteRecebido(c) || !isNaopermiteconfsemmalote()) && isMovimentoNaoEncerrado(c) && isPermissaoEncerrarMovimento()) {
						conferenciaComissaoService.encerrarMovimentoDiario(c);
					}
				}
			} else {
				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);
		}
	}

	private boolean isConferenciaPendente() throws InterruptedException, BusinessException {
		List<BoletoComissao> lsBoletoComissao = new ArrayList<BoletoComissao>();
		lsBoletoComissao.addAll(lsBilhetesManual);
		lsBoletoComissao.addAll(lsBilhetes);
		lsBoletoComissao.addAll(lsBilhetesCancelados);
		lsBoletoComissao.addAll(lsBilhetesDevolvidos);
		lsBoletoComissao.addAll(lsBilhetesGap);
		lsBoletoComissao.addAll(lsBilhetesGapCancelados);
		lsBoletoComissao.addAll(lsBilhetesGapDevolvidos);

		if (conferenciaComissaoService.isBilhetesSemConferencia(lsBoletoComissao)) {
			Messagebox.show(Labels.getLabel("conferenciaController.MSG.bilheteSemConferenciaFormapagoCategoria"),
					Labels.getLabel("conferenciaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);
			return true;
		}

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

		if (conferenciaComissaoService.isOcdSemConferencia(lsOcds)) {
			Messagebox.show(Labels.getLabel("conferenciaController.MSG.ocdSemConferencia"),
					Labels.getLabel("conferenciaController.window.title"),
					Messagebox.OK, Messagebox.EXCLAMATION);
			return true;
		}

		return false;
	}

	public void onClick$btnReabrirMovimentoDiario(Event event) throws InterruptedException {
		try {
			if (isPeriodo) {
				for (Conferencia c : conferencias) {
					if (isMovimentoEncerrado(c) && isPermissaoReabrirMovimento()) {
						conferenciaComissaoService.reabrirMovimentoDiario(c);
					}
				}
			} else {
				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"));
		}
	}

	private void recuperarConferencias(ConferenciaComissaoVO conferenciaComissao) throws ParseException, BusinessException {

		conferencias = new ArrayList<Conferencia>();

		if (conferenciaComissao.getDiasOrdenado() != null) {
			for (DiaConferenciaComissaoVO d : conferenciaComissao.getDiasOrdenado()) {
				Conferencia conf = null;

				if (d.getConferenciaId() != null) {
					conf = conferenciaComissaoService.obtenerID(d.getConferenciaId());
				}

				if (conf == null) {
					Calendar cal = Calendar.getInstance();
					cal.setTime(dataInicial);
					cal.set(Calendar.DAY_OF_MONTH, d.getDia());

					conf = new Conferencia();
					conf.setActivo(Boolean.TRUE);
					conf.setFecmodif(new Date());
					conf.setUsuarioId(UsuarioLogado.getUsuarioLogado().getUsuarioId());
					conf.setEmpresa(empresa);
					conf.setPuntoVenta(new PuntoVenta(puntoventaId));
					conf.setDatamovimento(cal.getTime());
				}
				conferencias.add(conf);
			}
		}
	}

	private Short getDebitoCreditoInfo() {
		if (rCredito.isSelected()) {
			return (short) 1;
		} else if (rDebito.isSelected()) {
			return (short) 0;
		} else {
			return (short) 2;
		}
	}

	public void onClick$btnAdicionarObservacaoLog(Event event) throws InterruptedException {
		try {
			if (validarCamposObservacao()) {

				LogConferencia logConferencia = new LogConferencia();
				logConferencia.setPreco(txtPrecoLog.getValueDecimal());
				logConferencia.setObservacao(txtObservacaoLog.getValue());
				if (isPeriodo) {
					logConferencia.setConferencia((Conferencia) cmbConferenciaDia.getSelectedItem().getValue());
				} else {
					logConferencia.setConferencia(conferencia);
				}
				logConferencia.setStatus(StatusLogConferencia.getStatusLogConferencia((Integer) cmbSituacaoLog.getSelectedItem().getValue()));
				logConferencia.setTipo(TipoLogConferencia.AVULSO);
				logConferencia.setIndcredito(getDebitoCreditoInfo());
				if (logConferencia.isIndcredito().equals((short) 2)) {
					logConferencia.setTipoInformativoComissao((TipoInformativoComissao) cmbTipoInformativo.getSelectedItem().getValue());
				}
				if (StatusLogConferencia.getStatusLogConferencia((Integer) cmbSituacaoLog.getSelectedItem().getValue()).getValue().equals(1)) {
					logConferencia.setIndmesmodia(rMsmDia.isSelected());
				}

				if (cmbConferenciaPendencia.getSelectedItem() != null) {
					ConferenciaPendencia conferenciaPendencia = (ConferenciaPendencia) cmbConferenciaPendencia.getSelectedItem().getValue();
					if (conferenciaPendencia.getConferenciapendenciaId() > -1) {
						logConferencia.setConferenciaPendencia(conferenciaPendencia);
					}
				}

				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 {
			txtObservacaoLog.getValue();
		} catch (Exception e) {
			Messagebox.show(Labels.getLabel("conferenciaController.MSG.observacaoObrigatorio"),
					Labels.getLabel("conferenciaController.window.title"),
					Messagebox.OK, Messagebox.ERROR);
			return false;
		}
		try {
			if (rInformativo.isSelected() && cmbTipoInformativo.getValue() == null) {
				return false;
			}

			// validacao do campo com o getValue, se tentar recuperar o valor em string e lancada excecao
			txtObservacaoLog.getValue();
		} catch (Exception e) {
			Messagebox.show(Labels.getLabel("conferenciaController.MSG.observacaoObrigatorio"),
					Labels.getLabel("conferenciaController.window.title"),
					Messagebox.OK, Messagebox.INFORMATION);
			return false;
		}

		try {
			if (cmbSituacaoLog.getSelectedItem().getValue() == null) {
				return false;
			}
		} catch (Exception e) {
			Messagebox.show(Labels.getLabel("conferenciaController.MSG.situacaoObrigatoria"),
					Labels.getLabel("conferenciaController.window.title"),
					Messagebox.OK, Messagebox.ERROR);
			return false;
		}
		
		try {
			if (rInformativo.isSelected() && cmbTipoInformativo.getValue() == null) {
				return false;
			}
		} catch (Exception e) {
			Messagebox.show(Labels.getLabel("conferenciaController.MSG.tipoInfomativoObrigatorio"),
					Labels.getLabel("conferenciaController.window.title"),
					Messagebox.OK, Messagebox.ERROR);
			return false;
		}

		if (isPeriodo
				&& cmbConferenciaDia.getSelectedItem() == null) {
			Messagebox.show(Labels.getLabel("conferenciaController.MSG.dataMovimentoObrigatorio"),
					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, Tab tab) {
		if (boletoComissao == null || isObservacaoLancada(boletoComissao) || isMovimentoEncerrado(boletoComissao.getConferencia()) || (!isMaloteRecebido(boletoComissao.getConferencia()) && isNaopermiteconfsemmalote())) {
			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);
		args.put("tab", tab);

		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(eventosFinanceiros.getConferencia()) || (!isMaloteRecebido(eventosFinanceiros.getConferencia()) && isNaopermiteconfsemmalote())) {
			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);
		args.put("tab", tabEventosFinanceiros);

		openWindow("/gui/comissao/editarLogConferenciaComissao.zul",
				Labels.getLabel("editarLogConferenciaComissaoController.window.title"), args, MODAL);
	}

	private void lancarLogConferenciaOcd(OcdVO ocd, MyListbox ocdsList, Tab tabOcd) {
		if (ocd == null || isObservacaoLancada(ocd) || isMovimentoEncerrado(ocd.getConferencia()) || (!isMaloteRecebido(ocd.getConferencia()) && isNaopermiteconfsemmalote())) {
			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);
		args.put("tab", tabOcd);

		openWindow("/gui/comissao/editarLogConferenciaComissao.zul",
				Labels.getLabel("editarLogConferenciaComissaoController.window.title"), args, MODAL);
	}

	private boolean isObservacaoLancada(BoletoComissao boletoComissao) {
		for (LogConferenciaVO logConferencia : (List<LogConferenciaVO>) logsConferenciaList.getListData()) {
			;
			if (boletoComissao.getCajaId().equals(logConferencia.getCajaId())) {
				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 {
			DiaConferenciaComissaoVO diaConferenciaComissao = conferenciaComissaoService.carregarConferenciaRegistrada(conferencia.getDatamovimento(), conferencia.getEmpresa(), puntoventaFiltro);
			if (diaConferenciaComissao != null) {
				for (DiaConferenciaComissaoVO diaConferenciaComissaoAux : conferenciaComissao.getDiasOrdenado()) {
					if (diaConferenciaComissao.equals(diaConferenciaComissaoAux)) {
						diaConferenciaComissaoAux.setIndboletogerado(diaConferenciaComissao.getIndboletogerado());
						diaConferenciaComissaoAux.setIndconferido(diaConferenciaComissao.getIndconferido());
						diaConferenciaComissaoAux.setIndmaloterecebido(diaConferenciaComissao.getIndmaloterecebido());
						diaConferenciaComissaoAux.setIndpendencia(diaConferenciaComissao.getIndpendencia());
						diaConferenciaComissaoAux.setIndsemmovimento(diaConferenciaComissao.getIndsemmovimento());
					}
				}
				if (conferenciaList != null) {
					conferenciaList.updateItem(conferenciaComissao);
				}
				
				for (Object obj: conferenciaList.getListData()) {
					ConferenciaComissaoVO conferenciaComissaoVO = (ConferenciaComissaoVO) obj;
					log.info(conferenciaComissaoVO.getNombpuntoventa());
				}
			}
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}

	public void onClick$btnPesquisaBoletoDevolvido(Event event) throws InterruptedException {
		try {
			if (isPeriodo) {
				lsBilhetesDevolvidos = conferenciaComissaoService.carregarBilhetesComissao(null, conferencias, BoletoStatusComissao.BOLETO_DEVOLVIDO, false);
			} else {
				lsBilhetesDevolvidos = conferenciaComissaoService.carregarBilhetesComissao(null, conferencia, BoletoStatusComissao.BOLETO_DEVOLVIDO, false);
			}

			Map<BoletoStatusComissao, BigDecimal> totais = conferenciaComissaoService.totalizarBoletoComissaoDevolvidosTrocaOcd(lsBilhetesDevolvidos);
			totalBilhetesDevolvidos = totais.get(BoletoStatusComissao.BOLETO_DEVOLVIDO);
			txtTotalBilhetesDevolvidos.setValue(BigDecimalUtil.getBigDecimalToStringDouble2CasasDecimaisFormatado(totalBilhetesDevolvidos, 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 isMovimentoNaoEncerrado(Conferencia c) {
		return c.getIndconferido() == null || !c.getIndconferido();
	}

	public Boolean isMovimentoEncerrado() {
		return conferencia.getIndconferido() != null && conferencia.getIndconferido();
	}

	public Boolean isMovimentoEncerrado(Conferencia c) {
		return c.getIndconferido() != null && c.getIndconferido();
	}

	public Boolean isPermissaoEncerrarMovimento() {
		return UsuarioLogado.getUsuarioLogado().isPermisoClave(ConstantesFuncionSistema.CLAVE_ENCERRAR_MOVIMENTODIARIO);
	}

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

	public Boolean isExibirBotaoReabrirMovimento() {
		if (isPeriodo) {
			for (Conferencia c : conferencias) {
				// caso exista pelo menos uma conferencia que seja possivel reabrir o movimento, habilitar
				if (isMovimentoEncerrado(c) && isPermissaoReabrirMovimento()) {
					return true;
				}
			}
		} else {
			return isMovimentoEncerrado() && isPermissaoReabrirMovimento();
		}
		return false;
	}

	private Boolean exibirBtnLogPeriodo = true;

	public Boolean isExibirBotaoLancamentoObservacao() {
		if (isPeriodo) {
			// caso Periodo, a validacao e feita no combo de dias de conferencia
			return exibirBtnLogPeriodo;
		} else {
			return !isMovimentoEncerrado() && (isMaloteRecebido() || !isNaopermiteconfsemmalote());
		}
	}

	public Boolean isExibirBotaoEncerrarMovimento() {
		if (isPeriodo) {
			for (Conferencia c : conferencias) {
				// caso exista pelo menos uma conferencia que seja possivel encerrar o movimento, habilitar
				if ((isMaloteRecebido(c) || !isNaopermiteconfsemmalote()) && isMovimentoNaoEncerrado(c) && isPermissaoEncerrarMovimento()) {
					return true;
				}
			}
		} else {
			return (isMaloteRecebido() || !isNaopermiteconfsemmalote()) && isMovimentoNaoEncerrado() && isPermissaoEncerrarMovimento();
		}
		return false;
	}

	public Boolean isExibirBotaoChegadaMalote() {
		if (isPeriodo) {
			for (Conferencia c : conferencias) {
				// caso exista pelo menos uma conferencia que seja possivel entregar malote, habilitar
				if (!isMaloteRecebido(c) && isMovimentoNaoEncerrado(c)) {
					return true;
				}
			}
		} else {
			return !isMaloteRecebido() && isMovimentoNaoEncerrado();
		}
		return false;
	}
	
	public Boolean isExibirBotaoCancelarChegadaMalote() {
		return !isExibirBotaoChegadaMalote();
	}

	private Boolean isMaloteRecebido() {
		if (conferencia != null) {
			return conferencia.getIndmaloterecebido() != null && conferencia.getIndmaloterecebido();
		}
		return false;
	}

	private Boolean isMaloteRecebido(Conferencia c) {
		if (c != null) {
			return c.getIndmaloterecebido() != null && c.getIndmaloterecebido();
		}
		return false;
	}

	public void onClick$btnCerrar() throws InterruptedException {
		validarConferencia();
		super.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 {
	}

	private void removerLogConferencia(Long logconferenciaId) {
		LogConferenciaVO log = new LogConferenciaVO(logconferenciaId);
		logsConferenciaList.removeItem(log);
		lsLogsConferencia.remove(log);
	}

	private LogConferencia gravarLogConferencia(Conferencia c, TipoLogConferencia tipo, Long id, String numfoliosistema, Long transacaoOriginalId ) throws BusinessException {
		LogConferencia logConferencia = new LogConferencia();
		logConferencia.setObservacao("OK");

		if (isPeriodo) {
			logConferencia.setConferencia(c);
		} else {
			logConferencia.setConferencia(conferencia);
		}

		logConferencia.setStatus(StatusLogConferencia.CONFERIDO);
		logConferencia.setTipo(tipo);
		logConferencia.setIndcredito((short) 1);

		if (tipo.equals(TipoLogConferencia.BOLETO)) {
			logConferencia.setCajaId(id);
		}
		
		if (tipo.equals(TipoLogConferencia.OCD)) {
			logConferencia.setOcdId(id);
		}
		
		if (tipo.equals(TipoLogConferencia.EVENTO_FINANCEIRO)) {
			logConferencia.setEventoextraId(id);
		}
		
		logConferencia.setTransacaoOriginalId(transacaoOriginalId);

		logConferencia = conferenciaComissaoService.suscribirLogConferencia(logConferencia);
		atualizarLogConferenciaList(c, logConferencia, numfoliosistema);

		return logConferencia;
	}

	private void atualizarLogConferenciaList(Conferencia conferencia, LogConferencia logConferencia, String numfoliosistema) {
		LogConferenciaVO logConferenciaVO = new LogConferenciaVO();
		logConferenciaVO.setLogconferenciaId(logConferencia.getLogconferenciaId());
		logConferenciaVO.setConferencia(conferencia);
		logConferenciaVO.setCajaId(logConferencia.getCajaId());
		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());
		logConferenciaVO.setIndcredito(logConferencia.getIndcredito());
		logConferenciaVO.setLogconferenciaId(logConferencia.getLogconferenciaId());
		logsConferenciaList.updateItem(logConferenciaVO);
		lsLogsConferencia.add(logConferenciaVO);
	}

	private void gravarLogConferenciaBilhete(MyListbox bilhetes, BoletoComissao boletoComissao, Tab tab, String label) {
		try {
			LogConferencia logConferencia = gravarLogConferencia(boletoComissao.getConferencia(), TipoLogConferencia.BOLETO, boletoComissao.getCajaId(), boletoComissao.getNumFolioSistema(), boletoComissao.getTransacaoOriginalId());
			boletoComissao.setLogconferenciaId(logConferencia.getLogconferenciaId());
			boletoComissao.setStatus(logConferencia.getStatus().getValue());
			boletoComissao.setConferido(Boolean.TRUE);
			bilhetes.updateItem(boletoComissao);

			verificarBilhetesSemConferencia((List<BoletoComissao>) bilhetes.getListData(), tab);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}

	private void removerLogConferenciaBilhete(MyListbox bilhetes, BoletoComissao boletoComissao, Tab tab, String label) {
		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);
			
			if(boletoComissao.isAbaGapVendido()) {
				conferenciaComissaoService.borrarLogConferenciaTransacaoId(boletoComissao.getTransacaoId());
			}

			verificarBilhetesSemConferencia((List<BoletoComissao>) bilhetes.getListData(), tab);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}

	private void gravarLogConferenciaEventoFinanceiro(EventosFinanceirosVO eventoFinanceiro) {
		try {
			LogConferencia logConferencia = gravarLogConferencia(eventoFinanceiro.getConferencia(), TipoLogConferencia.EVENTO_FINANCEIRO, eventoFinanceiro.getEventoextraId(), null, null);
			eventoFinanceiro.setLogconferenciaId(logConferencia.getLogconferenciaId());
			eventoFinanceiro.setStatus(logConferencia.getStatus().getValue());
			eventoFinanceiro.setConferido(Boolean.TRUE);
			eventosFinanceirosList.updateItem(eventoFinanceiro);

			verificarEventosFinanceirosSemConferencia((List<EventosFinanceirosVO>) eventosFinanceirosList.getListData(), tabEventosFinanceiros);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}

	private void removerLogConferenciaEventoFinanceiro(EventosFinanceirosVO eventoFinanceiro) {
		try {
			LogConferencia logConferencia = conferenciaComissaoService.obtenerLogConferenciaID(eventoFinanceiro.getLogconferenciaId());
			
			if(logConferencia == null) {
				return;
			}
			
			conferenciaComissaoService.borrarLogConferencia(logConferencia);
			eventoFinanceiro.setLogconferenciaId(null);
			eventoFinanceiro.setStatus(null);
			eventoFinanceiro.setConferido(Boolean.FALSE);
			removerLogConferencia(logConferencia.getLogconferenciaId());
			eventosFinanceirosList.updateItem(eventoFinanceiro);

			verificarEventosFinanceirosSemConferencia((List<EventosFinanceirosVO>) eventosFinanceirosList.getListData(), tabEventosFinanceiros);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}

	private void gravarLogConferenciaOcd(OcdVO ocd) {
		try {
			LogConferencia logConferencia = gravarLogConferencia(ocd.getConferencia(), TipoLogConferencia.OCD, ocd.getOcdId(), null, null);
			ocd.setLogconferenciaId(logConferencia.getLogconferenciaId());
			ocd.setStatus(logConferencia.getStatus().getValue());
			ocd.setConferido(Boolean.TRUE);
			ocdsList.updateItem(ocd);

			verificarOcdsSemConferencia((List<OcdVO>) ocdsList.getListData(), tabOcd);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}

	private void removerLogConferenciaOcd(OcdVO ocd) {
		try {
			LogConferencia logConferencia = conferenciaComissaoService.obtenerLogConferenciaID(ocd.getLogconferenciaId());
			conferenciaComissaoService.borrarLogConferencia(logConferencia);
			ocd.setLogconferenciaId(null);
			ocd.setStatus(null);
			ocd.setConferido(Boolean.FALSE);
			removerLogConferencia(logConferencia.getLogconferenciaId());
			ocdsList.updateItem(ocd);

			verificarOcdsSemConferencia((List<OcdVO>) ocdsList.getListData(), tabOcd);
		} catch (BusinessException e) {
			log.error(e.getMessage(), e);
		}
	}

	@Override
	public void closeWindow() {
		if (!isPeriodo) {
			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;
	}

	public void onClick$rInformativo() {
		hideShowTipoInformativo(false);
	}

	public void onClick$rDebito() {
		hideShowTipoInformativo(true);
	}

	public void onClick$rCredito() {
		hideShowTipoInformativo(true);
	}

	private void hideShowTipoInformativo(Boolean disable) {
		cmbTipoInformativo.setDisabled(disable);

		if (!disable) {
			cmbTipoInformativo.setConstraint("no empty");
		} else {
			cmbTipoInformativo.setConstraint("");
			cmbTipoInformativo.clearErrorMessage();
			cmbTipoInformativo.setValue(null);
		}
	}

	public List<TipoInformativoComissao> getLsTipoInformativo() {
		return lsTipoInformativo;
	}

	public void setLsTipoInformativo(List<TipoInformativoComissao> lsTipoInformativo) {
		this.lsTipoInformativo = lsTipoInformativo;
	}

	public List<ConferenciaPendencia> getLsConferenciaPendencia() {
		return lsConferenciaPendencia;
	}

	public void setLsConferenciaPendencia(List<ConferenciaPendencia> lsConferenciaPendencia) {
		this.lsConferenciaPendencia = lsConferenciaPendencia;
	}

	public Boolean isNaopermiteconfsemmalote() {
		return empresa.getIndnaopermiteconfsemmalote() != null && empresa.getIndnaopermiteconfsemmalote();
	}

	private void verificarBilhetesSemConferencia(List<BoletoComissao> lsBilhetes, Tab tab) throws BusinessException {
		if (conferenciaComissaoService.isBilhetesSemConferencia(lsBilhetes)) {
			setTabExigeConferencia(tab);
		} else {
			setTabNaoExigeConferencia(tab);
		}
	}

	private void verificarOcdsSemConferencia(List<OcdVO> lsOcds, Tab tab) throws BusinessException {
		if (conferenciaComissaoService.isOcdSemConferencia(lsOcds)) {
			setTabExigeConferencia(tab);
		} else {
			setTabNaoExigeConferencia(tab);
		}
	}

	private void verificarEventosFinanceirosSemConferencia(List<EventosFinanceirosVO> lsEventosFinanceiros, Tab tab) throws BusinessException {
		if (conferenciaComissaoService.isEventosFinanceirosSemConferencia(lsEventosFinanceiros)) {
			setTabExigeConferencia(tab);
		} else {
			setTabNaoExigeConferencia(tab);
		}
	}

	private void setTabNaoExigeConferencia(Tab tab) {
		tab.setSclass("semConferencia");
		tab.invalidate();
	}

	private void setTabExigeConferencia(Tab tab) {
		tab.setSclass("existeConferencia");
		tab.invalidate();
	}

	public Row getRowDataMovimento() {
		return rowDataMovimento;
	}

	public void setRowDataMovimento(Row rowDataMovimento) {
		this.rowDataMovimento = rowDataMovimento;
	}

	private boolean getEnableDisableCheckBox(Conferencia conferencia) {
		if (isPeriodo) {
			return (isMovimentoEncerrado(conferencia) && isPermissaoReabrirMovimento() || !isMaloteRecebido(conferencia) && isNaopermiteconfsemmalote());
		}
		return isExibirBotaoReabrirMovimento() || (!isMaloteRecebido() && isNaopermiteconfsemmalote());

	}

}