/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package com.cosmodas.recibos;

import com.cosmodas.FacadeCosmos.AbonosFacadeLocal;
import com.cosmodas.FacadeCosmos.BancosFacadeLocal;
import com.cosmodas.FacadeCosmos.BitacorasWebFacadeLocal;
import com.cosmodas.FacadeCosmos.CargosFacadeLocal;
import com.cosmodas.FacadeCosmos.ConsultoresFacadeLocal;
import com.cosmodas.FacadeCosmos.DetalleAbonosFacadeLocal;
import com.cosmodas.FacadeCosmos.DocumentosFacadeLocal;
import com.cosmodas.FacadeCosmos.ErroresFacadeLocal;
import com.cosmodas.FacadeCosmos.PagoExtraFacadeLocal;
import com.cosmodas.FacadeCosmos.SucursalesFacadeLocal;
import com.cosmodas.FacadeCosmos.WcUsuariosFacadeLocal;
import com.cosmodas.EntCosmos.Abonos;
import com.cosmodas.EntCosmos.AbonosPK;
import com.cosmodas.EntCosmos.Bancos;
import com.cosmodas.EntCosmos.Cargos;
import com.cosmodas.EntCosmos.CargosPK;
import com.cosmodas.EntCosmos.Consultores;
import com.cosmodas.EntCosmos.ConsultoresDatos;
import com.cosmodas.EntCosmos.DetalleAbonos;
import com.cosmodas.EntCosmos.DetalleAbonosPK;
import com.cosmodas.EntCosmos.Documentos;
import com.cosmodas.EntCosmos.Errores;
import com.cosmodas.EntCosmos.PagoExtra;
import com.cosmodas.EntCosmos.PagoExtraPK;
import com.cosmodas.EntCosmos.Sucursales;
import com.cosmodas.EntCosmos.VReporterecibos;
import com.cosmodas.EntCosmos.WcUsuarios;
import com.cosmodas.FacadeCosmos.VReporterecibosFacadeLocal;
import com.cosmodas.validaciones.NumeroALetras;
import com.cosmodas.validaciones.ObtenerFecha;
import com.cosmodas.validaciones.obternerMes;

import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.Serializable;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Formatter;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.application.FacesMessage;
import javax.faces.bean.ManagedBean;
import javax.inject.Named;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.view.ViewScoped;
import javax.inject.Inject;
import javax.servlet.http.HttpSession;

import net.sf.jasperreports.engine.*;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import org.primefaces.PrimeFaces;

/**
 * @author obper
 */
@Named
@ManagedBean
@ViewScoped
public class recibosBeans implements Serializable {

    private static final long serialVersionUID = 1L;
    @EJB
    DocumentosFacadeLocal documentosFacadeLocal;
    @EJB
    AbonosFacadeLocal abonosFacadeLocal;
    @EJB
    DetalleAbonosFacadeLocal detalleAbonosFacadeLocal;
    @EJB
    BancosFacadeLocal bancosFacadeLocal;
    @EJB
    SucursalesFacadeLocal sucursalesFacadeLocal;
    @EJB
    WcUsuariosFacadeLocal usuarioFacadeLocal;
    @EJB
    ConsultoresFacadeLocal consultoresFacadeLocal;
    @EJB
    CargosFacadeLocal cargosfacadeLocal;
    @EJB
    PagoExtraFacadeLocal pagoExtaFacadeLocal;
    @EJB
    BitacorasWebFacadeLocal bitacorasWebFacadeLocal;
    @EJB
    ErroresFacadeLocal errFacadeLocal;
    @EJB
    SucursalesFacadeLocal sfl;
    @EJB
    VReporterecibosFacadeLocal vrrfl;

    private String consultorCodigo;
    private String tipoRecibo;
    private String numeroRecibo = "";
    private String bancoRecibo;
    private boolean credito;
    private boolean nuevoSelector = true;
    private boolean reciboSerieBo = true;
    private boolean textRecibos = true;
    private boolean botoncreditosBo = true;
    private boolean buscar = false;
    private JasperPrint jasperPrint;
    private List<DetalleAbonos> abonosSelections;

    @Inject
    private Consultores consultores;
    @Inject
    private ConsultoresDatos consultoresDatos;
    private Date fechaValor;
    private Date fechaDigitacion;
    @Inject
    private Bancos banco;
    private List<Bancos> listaBancos;
    private String catidadPagar;
    @Inject
    private Abonos abono;
    @Inject
    private DetalleAbonos detalleAbono;
    private List<Documentos> listaDocumentos;
    @Inject
    private Documentos documentoSelect;
    private boolean nuevo = false;
    private List<DetalleAbonos> detalleAbonos;
    private boolean bloqueo = true;
    private boolean consL10058;
    private boolean anuladoBloc = true;
    private boolean guardarBTN = true;
    private List<Cargos> cargosConsultor;
    private List<Cargos> cargosConsultorResta;
    private String consultorNombreCompleto;
    private String cantidadAPagar;
    private List<Cargos> lista_cargos = new ArrayList<>();
    private String pagoExtra = "0.00";
    private String totalPago = "0.00";
    private boolean busquedaBool = false;
    private boolean imprimirBTN = true;
    private List<Cargos> cargosGuardar = new ArrayList<>();
    private String cambioEfectivo;
    private String calculoCambioEfectivo;
    private String cargoPedienteContado;
    private String cantidadTemp;
    private List<RestaCargos> restaCargosList;
    private String cargosSistemas;
    private boolean imprimeUnaVez;
    private String cantidadAPagarAnterior;
    private String saldoPagarDialogo = "0.00";
    private String sucursalCodigoS;
    private String documentoCodigoS;
    private ExternalContext exc;
    private String numeroBanco;
    private List<VReporterecibos> listaRecibos;
    private String efectivo;
    private String boletas;
    private String sumaAbonos;
    private String sumaDetalle;
    private String sumadif;
    private String pagosExtra;
    private String pagosExtraMasDeta;
    private Date minDateIngreso, maxDateIngreso, minDatePago, maxDatePago;

    @Inject
    private WcUsuarios usuario;
    @Inject
    private Sucursales sucursal;

    public Date getMinDateIngreso() {
        return minDateIngreso;
    }

    public void setMinDateIngreso(Date minDateIngreso) {
        this.minDateIngreso = minDateIngreso;
    }

    public Date getMaxDateIngreso() {
        return maxDateIngreso;
    }

    public void setMaxDateIngreso(Date maxDateIngreso) {
        this.maxDateIngreso = maxDateIngreso;
    }

    public Date getMinDatePago() {
        return minDatePago;
    }

    public void setMinDatePago(Date minDatePago) {
        this.minDatePago = minDatePago;
    }

    public Date getMaxDatePago() {
        return maxDatePago;
    }

    public void setMaxDatePago(Date maxDatePago) {
        this.maxDatePago = maxDatePago;
    }

    public String getSumaAbonos() {
        return sumaAbonos;
    }

    public void setSumaAbonos(String sumaAbonos) {
        this.sumaAbonos = sumaAbonos;
    }

    public List<VReporterecibos> getListaRecibos() {
        return listaRecibos;
    }

    public void setListaRecibos(List<VReporterecibos> listaRecibos) {
        this.listaRecibos = listaRecibos;
    }

    public boolean isTextRecibos() {
        return textRecibos;
    }

    public void setTextRecibos(boolean textRecibos) {
        this.textRecibos = textRecibos;
    }

    public boolean isBotoncreditosBo() {
        return botoncreditosBo;
    }

    public void setBotoncreditosBo(boolean botoncreditosBo) {
        this.botoncreditosBo = botoncreditosBo;
    }

    public boolean isReciboSerieBo() {
        return reciboSerieBo;
    }

    public void setReciboSerieBo(boolean reciboSerieBo) {
        this.reciboSerieBo = reciboSerieBo;
    }

    public boolean isNuevoSelector() {
        return nuevoSelector;
    }

    public void setNuevoSelector(boolean nuevoSelector) {
        this.nuevoSelector = nuevoSelector;
    }

    public String getNumeroBanco() {
        return numeroBanco;
    }

    public void setNumeroBanco(String numeroBanco) {
        this.numeroBanco = numeroBanco;
    }

    public WcUsuarios getUsuario() {
        return usuario;
    }

    public void setUsuario(WcUsuarios usuario) {
        this.usuario = usuario;
    }

    public String getSucursalCodigoS() {
        return sucursalCodigoS;
    }

    public void setSucursalCodigoS(String sucursalCodigoS) {
        this.sucursalCodigoS = sucursalCodigoS;
    }

    public String getDocumentoCodigoS() {
        return documentoCodigoS;
    }

    public void setDocumentoCodigoS(String documentoCodigoS) {
        this.documentoCodigoS = documentoCodigoS;
    }

    public String getSaldoPagarDialogo() {
        return saldoPagarDialogo;
    }

    public void setSaldoPagarDialogo(String saldoPagarDialogo) {
        this.saldoPagarDialogo = saldoPagarDialogo;
    }

    public String getCantidadAPagarAnterior() {
        return cantidadAPagarAnterior;
    }

    public void setCantidadAPagarAnterior(String cantidadAPagarAnterior) {
        this.cantidadAPagarAnterior = cantidadAPagarAnterior;
    }

    public List<Cargos> getCargosConsultorResta() {
        return cargosConsultorResta;
    }

    public void setCargosConsultorResta(List<Cargos> cargosConsultorResta) {
        this.cargosConsultorResta = cargosConsultorResta;
    }

    public List<DetalleAbonos> getAbonosSelections() {
        return abonosSelections;
    }

    public void setAbonosSelections(List<DetalleAbonos> abonosSelections) {
        this.abonosSelections = abonosSelections;
    }

    public boolean isImprimeUnaVez() {
        return imprimeUnaVez;
    }

    public void setImprimeUnaVez(boolean imprimeUnaVez) {
        this.imprimeUnaVez = imprimeUnaVez;
    }

    public boolean isImprimirBTN() {
        return imprimirBTN;
    }

    public void setImprimirBTN(boolean imprimirBTN) {
        this.imprimirBTN = imprimirBTN;
    }

    public boolean isGuardarBTN() {
        return guardarBTN;
    }

    public void setGuardarBTN(boolean guardarBTN) {
        this.guardarBTN = guardarBTN;
    }

    public boolean isBusquedaBool() {
        return busquedaBool;
    }

    public void setBusquedaBool(boolean busquedaBool) {
        this.busquedaBool = busquedaBool;
    }

    public String getCantidadAPagar() {
        return cantidadAPagar;
    }

    public void setCantidadAPagar(String cantidadAPagar) {

        BigDecimal in = new BigDecimal(cantidadAPagar);
        BigDecimal out = in.setScale(2, in.ROUND_HALF_DOWN);

        this.cantidadAPagar = out.toString();
    }

    public List<Cargos> getCargosConsultor() {
        return cargosConsultor;
    }

    public void setCargosConsultor(List<Cargos> cargosConsultor) {
        this.cargosConsultor = cargosConsultor;
    }

    public String getTipoRecibo() {
        return tipoRecibo;
    }

    public void setTipoRecibo(String tipoRecibo) {
        this.tipoRecibo = tipoRecibo;
    }

    public Sucursales getSucursal() {
        return sucursal;
    }

    public void setSucursal(Sucursales sucursal) {
        this.sucursal = sucursal;
    }

    public String getNumeroRecibo() {
        return numeroRecibo;
    }

    public void setNumeroRecibo(String numeroRecibo) {
        this.numeroRecibo = numeroRecibo;
    }

    public boolean isCredito() {
        return credito;
    }

    public void setCredito(boolean credito) {
        this.credito = credito;
    }

    public Consultores getConsultores() {
        return consultores;
    }

    public void setConsultores(Consultores consultores) {
        this.consultores = consultores;
    }

    public ConsultoresDatos getConsultoresDatos() {
        return consultoresDatos;
    }

    public void setConsultoresDatos(ConsultoresDatos consultoresDatos) {
        this.consultoresDatos = consultoresDatos;
    }

    public Date getFechaValor() {
        return fechaValor;
    }

    public void setFechaValor(Date fechaValor) {
        this.fechaValor = fechaValor;
    }

    public Date getFechaDigitacion() {
        return fechaDigitacion;
    }

    public void setFechaDigitacion(Date fechaDigitacion) {
        this.fechaDigitacion = fechaDigitacion;
    }

    public Bancos getBanco() {
        return banco;
    }

    public void setBanco(Bancos banco) {
        this.banco = banco;
    }

    public boolean isBloqueo() {
        return bloqueo;
    }

    public void setBloqueo(boolean bloqueo) {
        this.bloqueo = bloqueo;
    }

    public String getCatidadPagar() {
        return catidadPagar;
    }

    public void setCatidadPagar(String catidadPagar) {
        this.catidadPagar = catidadPagar;
    }

    public List<Documentos> getListaDocumentos() {
        return listaDocumentos;
    }

    public void setListaDocumentos(List<Documentos> listaDocumentos) {
        this.listaDocumentos = listaDocumentos;
    }

    public Documentos getDocumentoSelect() {
        return documentoSelect;
    }

    public void setDocumentoSelect(Documentos documentoSelect) {
        this.documentoSelect = documentoSelect;
    }

    public boolean isNuevo() {
        return nuevo;
    }

    public void setNuevo(boolean nuevo) {
        this.nuevo = nuevo;
    }

    public Abonos getAbono() {
        return abono;
    }

    public void setAbono(Abonos abono) {
        this.abono = abono;
    }

    public DetalleAbonos getDetalleAbono() {
        return detalleAbono;
    }

    public void setDetalleAbono(DetalleAbonos detalleAbono) {
        this.detalleAbono = detalleAbono;
    }

    public List<DetalleAbonos> getDetalleAbonos() {
        return detalleAbonos;
    }

    public void setDetalleAbonos(List<DetalleAbonos> detalleAbonos) {
        this.detalleAbonos = detalleAbonos;
    }

    public List<Bancos> getListaBancos() {
        return listaBancos;
    }

    public void setListaBancos(List<Bancos> listaBancos) {
        this.listaBancos = listaBancos;
    }

    public boolean isAnuladoBloc() {
        return anuladoBloc;
    }

    public void setAnuladoBloc(boolean anuladoBloc) {
        this.anuladoBloc = anuladoBloc;
    }

    public String getConsultorCodigo() {
        return consultorCodigo;
    }

    public void setConsultorCodigo(String consultorCodigo) {
        this.consultorCodigo = consultorCodigo.toUpperCase();
        consL10058 = consultorCodigo.equals("L10058");
        this.consultores = consultoresFacadeLocal.find(consultorCodigo.toUpperCase());
        Date i = new Date();
        this.abono.setAbonoFecha(i);
        this.abono.setBanco("00");
    }

    public String getConsultorNombreCompleto() {
        return consultorNombreCompleto;
    }

    public void setConsultorNombreCompleto(String consultorNombreCompleto) {
        this.consultorNombreCompleto = consultorNombreCompleto;
    }

    public List<Cargos> getLista_cargos() {
        return lista_cargos;
    }

    public void setLista_cargos(List<Cargos> lista_cargos) {
        this.lista_cargos = lista_cargos;
    }

    public String getPagoExtra() {
        return pagoExtra;
    }

    public void setPagoExtra(String pagoExtra) {
        this.pagoExtra = pagoExtra;
    }

    public String getTotalPago() {
        return totalPago;
    }

    public void setTotalPago(String totalPago) {
        this.totalPago = totalPago;
    }

    public String getCambioEfectivo() {
        return cambioEfectivo;
    }

    public void setCambioEfectivo(String cambioEfectivo) {
        this.cambioEfectivo = cambioEfectivo;
    }

    public String getCalculoCambioEfectivo() {
        return calculoCambioEfectivo;
    }

    public void setCalculoCambioEfectivo(String calculoCambioEfectivo) {
        this.calculoCambioEfectivo = calculoCambioEfectivo;
    }

    public String getEfectivo() {
        return efectivo;
    }

    public void setEfectivo(String efectivo) {
        this.efectivo = efectivo;
    }

    public String getBoletas() {
        return boletas;
    }

    public void setBoletas(String boletas) {
        this.boletas = boletas;
    }

    public String getSumaDetalle() {
        return sumaDetalle;
    }

    public void setSumaDetalle(String sumaDetalle) {
        this.sumaDetalle = sumaDetalle;
    }

    public String getSumadif() {
        return sumadif;
    }

    public void setSumadif(String sumadif) {
        this.sumadif = sumadif;
    }

    public String getPagosExtra() {
        return pagosExtra;
    }

    public void setPagosExtra(String pagosExtra) {
        this.pagosExtra = pagosExtra;
    }

    public String getPagosExtraMasDeta() {
        return pagosExtraMasDeta;
    }

    public void setPagosExtraMasDeta(String pagosExtraMasDeta) {
        this.pagosExtraMasDeta = pagosExtraMasDeta;
    }

    public boolean isConsL10058() {
        return consL10058;
    }

    public void setConsL10058(boolean consL10058) {
        this.consL10058 = consL10058;
    }

    @PostConstruct
    public void init() {
        this.exc = FacesContext.getCurrentInstance().getExternalContext();
        this.imprimeUnaVez = false;
        this.numeroBanco = "00";
        this.listaRecibos = new ArrayList<>();
        this.consL10058 = true;
        //this.maxDateIngreso = intervaloFecha(0);
        // this.maxDatePago = intervaloFecha(0);
        //  this.minDateIngreso = intervaloFecha(0);
        //   this.minDatePago = intervaloFecha(0);
        abonosSelections = new ArrayList<>();

        this.listaBancos = bancosFacadeLocal.buscarBancos();
        this.usuario = (WcUsuarios) exc.getSessionMap().get("usuario");
        this.sucursal = (Sucursales) exc.getSessionMap().get("sucursal");

        this.listaDocumentos = new ArrayList<>();

        Date fechaRecibo = new Date();
        String cambios = null;

        try {
            fechaRecibo = (Date) exc.getSessionMap().get("fechaRecibo");
            cambios = (String) exc.getSessionMap().get("cambioConsultor");

            if (cambios == null) {
                this.calculoCambioEfectivo = "0.00";
            } else {
                this.calculoCambioEfectivo = cambios;
            }
        } catch (Exception e) {
        }

        this.fechaValor = fechaRecibo;
        this.fechaDigitacion = new Date();

        switch (sucursal.getSucursalCodigo()) {
            case "02":
                if (usuario.getUsuarioCodigo().equals("032") || usuario.getUsuarioCodigo().equals("002")) {
                    listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("CE"));
                    listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("17"));
                    listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("08"));
                    listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("20"));
                    listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("21"));

                } else {
                    this.listaDocumentos = documentosFacadeLocal.buscar_documentos();
                }

                break;
            case "03":

                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("SY"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("09"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("08"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("20"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("21"));
                break;

            case "04":
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("SM"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("17"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("08"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("20"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("21"));
                break;

            case "05":
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("US"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("17"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("08"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("20"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("21"));
                break;

            case "06":
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("ZA"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("17"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("08"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("20"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("21"));
                break;

            case "07":
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("SA"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("17"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("08"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("20"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("21"));
                break;
            case "08":
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("SO"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("17"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("08"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("20"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("21"));
                break;
            case "11":
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("AP"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("17"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("08"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("20"));
                listaDocumentos.add(documentosFacadeLocal.busquedaDocumento("21"));
                break;
            default:
                break;

        }
        //        if ("03".equals(u.getSucursal())) {
        //            d.stream().filter((d1) -> (d1.getDocumentoCodigo().equalsIgnoreCase("09") || d1.getDocumentoCodigo().equalsIgnoreCase("08"))).forEach((d1) -> {
        //                listaDocumentos.add(d1);
        //            });
        //        } else if (!"01".equals(u.getSucursal())) {
        //
        //            d.stream().filter((d1) -> (d1.getDocumentoCodigo().equalsIgnoreCase("17") || d1.getDocumentoCodigo().equalsIgnoreCase("08"))).forEach((d1) -> {
        //                listaDocumentos.add(d1);
        //            }); // System.out.println("osuario" + getUser().getNombreEmpleado());
        //        } else {
        //            this.listaDocumentos = d;
        //        }

        listaRecibos.addAll(vrrfl.ObtenerReportes(sucursal.getSucursalCodigo(), new Date()));
        sumaAbonos = "0.00";
        sumaDetalle = "0.00";
        sumadif = "0.00";
        efectivo = "0.00";
        boletas = "0.00";
        pagosExtra = "0.00";

        calculosSumasTotales(listaRecibos);

        this.numeroRecibo = "";
    }


    public recibosBeans() {
    }

    public void calculosSumasTotales(List<VReporterecibos> re) {

        Double se = 0.00;
        Double sb = 0.00;
        Double sd = 0.00;
        Double sa = 0.00;
        Double sdf = 0.00;
        Double spe = 0.00;

        for (VReporterecibos v : re) {

            if (v.getEstado().contains("OK")) {
                sd = sd + v.getValorDetalle().doubleValue();
                sa = sa + v.getAbonoValor().doubleValue();
                sdf = sdf + v.getDiferiencia().doubleValue();
                spe = spe + v.getPex().doubleValue();
            }

            if (v.getCodigoBanco().equals("00") && v.getEstado().contains("OK")) {
                se = se + v.getAbonoValor().doubleValue();
            }

            if (!v.getCodigoBanco().equals("00") && v.getEstado().contains("OK")) {
                sb = sb + v.getAbonoValor().doubleValue();
            }

        }

        BigDecimal seBD = new BigDecimal(se);
        BigDecimal seBDS = seBD.setScale(2, seBD.ROUND_HALF_DOWN);
        BigDecimal sbBD = new BigDecimal(sb);
        BigDecimal sbBDS = sbBD.setScale(2, sbBD.ROUND_HALF_DOWN);
        BigDecimal sdBD = new BigDecimal(sd);
        BigDecimal sdBDS = sdBD.setScale(2, sdBD.ROUND_HALF_DOWN);

        BigDecimal saBD = new BigDecimal(sa);
        BigDecimal saBDS = saBD.setScale(2, saBD.ROUND_HALF_DOWN);

        BigDecimal sdfBD = new BigDecimal(sdf);
        BigDecimal sdfBDS = sdfBD.setScale(2, sdfBD.ROUND_HALF_DOWN);

        BigDecimal speBD = new BigDecimal(spe);
        BigDecimal speBDS = speBD.setScale(2, speBD.ROUND_HALF_DOWN);
        BigDecimal dmpBD = new BigDecimal(spe + sd);
        BigDecimal dmpBDS = dmpBD.setScale(2, dmpBD.ROUND_HALF_DOWN);

        efectivo = seBDS.toString();
        boletas = sbBDS.toString();
        sumaDetalle = sdBDS.toString();
        sumaAbonos = saBDS.toString();
        sumadif = sdfBDS.toString();
        pagosExtra = speBDS.toString();
        pagosExtraMasDeta = dmpBDS.toString();

    }

    public void nuevoReciboBun() {

        this.nuevoSelector = false;
        this.busquedaBool = true;
        this.calculoCambioEfectivo = "0.00";

    }

    public void buscaRecibosN() {

        if (numeroRecibo.length() == 6 && !nuevo) {
            this.imprimirBTN = false;
            Documentos doc = this.documentoSelect;
            // Sucursales su = sucursalesFacadeLocal.find(getUser().getSucursal());
            try {
                if (!getDocumentoSelect().getDocumentoCodigo().isEmpty() && !getNumeroRecibo().isEmpty() && !isNuevo()) {
                    //String d */= String.format("%010d", numeroRecibo);            
                    AbonosPK aboPK = new AbonosPK();
                    aboPK.setAbonoCodigo(getNumeroRecibo());
                    aboPK.setAbonoTipo(documentoSelect.getDocumentoCodigo());
                    aboPK.setAbonoAnulado("F");
                    this.abono = abonosFacadeLocal.find(aboPK);
                    detalleAbonos = detalleAbonosFacadeLocal.obternerDetalles(aboPK.getAbonoCodigo(), aboPK.getAbonoTipo());
                    this.consultorCodigo = getAbono().getConsultorCodigo().getConsultorCodigo();
                    setConsultorNombreCompleto(consultoresFacadeLocal.ObtenerNombreCompleto(getConsultorCodigo()));
                    this.sucursal = getAbono().getSucursalCodigo();
                    this.setCantidadAPagar(abono.getAbonoValor().toString());
                    consultores = abono.getConsultorCodigo();
                    setTotalPago(abono.getAbonoSaldoAnterior().toString());
                    try {

                        PagoExtra pag = pagoExtaFacadeLocal.find(new PagoExtraPK(getAbono().getConsultorCodigo().getConsultorCodigo(), getNumeroRecibo(), getAbono().getAbonosPK().getAbonoTipo()));

                        setPagoExtra(pag.getPagoExtraValor().toString());

                    } catch (Exception e) {

                    }

                }
            } catch (Exception e) {

            }
            this.bloqueo = true;
        } else if (numeroRecibo.length() == 6 && nuevo) {

            try {
                if (!getDocumentoSelect().getDocumentoCodigo().isEmpty() && !getNumeroRecibo().isEmpty() && isNuevo()) {
                    //String d */= String.format("%010d", numeroRecibo);   
                    Abonos abos = new Abonos();
                    AbonosPK aboPK = new AbonosPK();
                    aboPK.setAbonoCodigo(getNumeroRecibo());
                    aboPK.setAbonoTipo(documentoSelect.getDocumentoCodigo());
                    aboPK.setAbonoAnulado("F");
                    abos = abonosFacadeLocal.find(aboPK);
                    if (abos.hashCode() == 0) {

                        FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_ERROR, "RECIBOS", "NUMERO DE RECIBO POSSE DATOS");
                        PrimeFaces.current().dialog().showMessageDynamic(message);
                        this.numeroRecibo = "";
                    }
                    // this.sucursal = sucursalesFacadeLocal.find(getUser().getSucursal());
                }
            } catch (Exception e) {
                //this.sucursal = sucursalesFacadeLocal.find(getUser().getSucursal());
            }
            // this.bloqueo = true;

        }
        PrimeFaces.current().executeScript("focusField('recibos:consultorCodigoRecibo);");

    }

    public void buscaRecibos() {
        if (numeroRecibo.length() == 6 && buscar) {
            this.imprimirBTN = false;
            String doc = documentoSelect.getDocumentoCodigo();
            String numeroRec = numeroRecibo;
            boolean busqr = buscar;
            System.out.println("ss " + doc);

            // Sucursales su = sucursalesFacadeLocal.find(getUser().getSucursal());
            try {
                if (!numeroRec.isEmpty() && busqr && doc.length() > 1) {
                    //String d */= String.format("%010d", numeroRecibo);            
                    AbonosPK aboPK = new AbonosPK();
                    aboPK.setAbonoCodigo(getNumeroRecibo());
                    aboPK.setAbonoTipo(documentoSelect.getDocumentoCodigo());
                    aboPK.setAbonoAnulado("F");
                    this.abono = abonosFacadeLocal.find(aboPK);
                    detalleAbonos = detalleAbonosFacadeLocal.obternerDetalles(aboPK.getAbonoCodigo(), aboPK.getAbonoTipo());
                    this.consultorCodigo = getAbono().getConsultorCodigo().getConsultorCodigo();
                    this.numeroBanco = getAbono().getBanco();
                    setConsultorNombreCompleto(consultoresFacadeLocal.ObtenerNombreCompleto(getConsultorCodigo()));
                    this.sucursal = getAbono().getSucursalCodigo();
                    this.setCantidadAPagar(abono.getAbonoValor().toString());
                    consultores = abono.getConsultorCodigo();
                    setTotalPago(abono.getAbonoSaldoAnterior().toString());
                    try {

                        PagoExtra pag = pagoExtaFacadeLocal.find(new PagoExtraPK(getAbono().getConsultorCodigo().getConsultorCodigo(), getNumeroRecibo(), getAbono().getAbonosPK().getAbonoTipo()));

                        setPagoExtra(pag.getPagoExtraValor().toString());

                    } catch (Exception e) {

                    }

                }
            } catch (Exception e) {
                System.out.println("err " + e);
            }
            this.bloqueo = true;
        } else if (numeroRecibo.length() == 6 && !buscar) {

            try {
                if (!documentoSelect.getDocumentoCodigo().isEmpty() && !numeroRecibo.isEmpty() && buscar) {
                    //String d */= String.format("%010d", numeroRecibo);   
                    Abonos abos = new Abonos();
                    AbonosPK aboPK = new AbonosPK();
                    aboPK.setAbonoCodigo(getNumeroRecibo());
                    aboPK.setAbonoTipo(documentoSelect.getDocumentoCodigo());
                    aboPK.setAbonoAnulado("F");
                    abos = abonosFacadeLocal.find(aboPK);
                    if (abos.hashCode() == 0) {

                        FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_ERROR, "RECIBOS", "NUMERO DE RECIBO POSSE DATOS");
                        PrimeFaces.current().dialog().showMessageDynamic(message);
                        this.numeroRecibo = "";
                    }
                    // this.sucursal = sucursalesFacadeLocal.find(getUser().getSucursal());
                }
            } catch (Exception e) {
                //this.sucursal = sucursalesFacadeLocal.find(getUser().getSucursal());
            }
            // this.bloqueo = true;

        }
        PrimeFaces.current().executeScript("focusField('recibos:consultorCodigoRecibo);");
    }
    // *****aplica cantidad nuevo*****************************************************************

    public void aplicaCantidadD() {

        if (!cantidadAPagar.equals(cantidadAPagarAnterior) || cantidadAPagarAnterior.isEmpty()) {
          //  aplicaCantidadDls();
           if (!consL10058) {
                aplicaCantidadDls();
            } else {
                aplicaCantidadL10058();
            }
        }

    }

    public void aplicaCantidadL10058() {


        buscarCargos2("out");
        detalleAbonos = new ArrayList<>();
        AbonosPK aboPk = new AbonosPK();
        Abonos abo = new Abonos();
        List<Cargos> cargoLista = new ArrayList<>();
        List<Cargos> lc = new ArrayList<>();
        List<Cargos> rs = new ArrayList<>();
        List<RestaCargos> restaCargos = new ArrayList<>();

        if (!cantidadAPagar.isEmpty() || !cantidadAPagar.equalsIgnoreCase("") || Double.parseDouble(cantidadAPagar) > 0) {

            if (!cantidadAPagar.equalsIgnoreCase(cantidadTemp)) {

                Double sumaTemp = 0.00;
                List<DetalleAbonos> detalleAbo = new ArrayList<>();
                sumaTemp = Double.valueOf(totalPago);

                if (!cantidadAPagar.isEmpty()) {
///---------------------------------------------------------------------------------------------------------------------------------------------
                    Double cantidaPagar = Double.valueOf(getCantidadAPagar());
                    lc = cargosConsultor;
                    int contador = 0;
                    Double cantPagar;
                    if (Double.valueOf(cantidadAPagar) > Double.valueOf(cargosSistemas)) {
                        Double d = Double.valueOf(cantidadAPagar) - Double.valueOf(cargosSistemas);
                        cantPagar = Double.valueOf(cargosSistemas);

                        BigDecimal d1 = new BigDecimal(d);
                        BigDecimal ds = d1.setScale(2, d1.ROUND_HALF_DOWN);

                        this.pagoExtra = ds.toString();
                    } else {
                        this.pagoExtra = "0.00";
                        cantPagar = Double.valueOf(cantidadAPagar);
                    }
                    Collections.sort(lc, new Comparator<Cargos>() {

                        @Override
                        public int compare(Cargos o1, Cargos o2) {
                            if (o1.getCargoFechaFactura() == null || o2.getCargoFechaFactura() == null) {
                                return 0;
                            }
                            return o1.getCargoFechaFactura().compareTo(o2.getCargoFechaFactura());
                        }
                    });

                    if (!lc.isEmpty()) {

                        //  Double cargosPendiente = lc.get(contador).getCargoPendiente().doubleValue();
                        do {
                            Double salidacargo = lc.get(contador).getCargoPendiente().doubleValue() - cantPagar;

                            if (salidacargo > 0.000 && cantPagar < 0.000) {
                                // lc.get(contador).setCargos(0.00);
                            } else {
                                ///----------detalle abono----
                                BigDecimal car;
                                BigDecimal carFull;
                                String nuevoCargoPendiente;

                                if (lc.get(contador).getCargoPendiente().doubleValue() < cantPagar) {
                                    nuevoCargoPendiente = "0.00";
                                    car = new BigDecimal(lc.get(contador).getCargoPendiente().doubleValue());
                                    carFull = car.setScale(2, car.ROUND_HALF_DOWN);
                                } else {
                                    nuevoCargoPendiente = String.valueOf(lc.get(contador).getCargoPendiente().doubleValue() - cantPagar);
                                    car = new BigDecimal((cantPagar - lc.get(contador).getCargoPendiente().doubleValue()) + lc.get(contador).getCargoPendiente().doubleValue());
                                    carFull = car.setScale(2, car.ROUND_HALF_DOWN);
                                }

                                if (!carFull.toString().equals("0.00")) {

                                    cargoLista.add(lc.get(contador));
                                    //   cargoLista.add(cargosEditar(lc.get(contador), nuevoCargoPendiente));
                                    DetalleAbonosPK detalleAbosPk = new DetalleAbonosPK();
                                    detalleAbosPk.setAbonoAnulado('F');
                                    detalleAbosPk.setAbonoCodigo(getNumeroRecibo());
                                    detalleAbosPk.setAbonoTipo(documentoSelect.getDocumentoCodigo());
                                    detalleAbosPk.setFacturaCodigo(lc.get(contador).getCargosPK().getFacturaCodigo());
                                    detalleAbosPk.setFacturaSerie(lc.get(contador).getCargosPK().getFacturaSerie());
                                    //------------------------------------------------------------------------------------------

                                    DetalleAbonos detalleAbos = new DetalleAbonos();
                                    detalleAbos.setDetalleAbonosPK(detalleAbosPk);
                                    detalleAbos.setDocumentoCodigo(lc.get(contador).getCargosPK().getDocumentoCodigo());
                                    detalleAbos.setProgramaCodigo(lc.get(contador).getProgramaCodigo());
                                    detalleAbos.setDetalleAbonoCantidad(carFull);
                                    detalleAbos.setDetalleAbonoFecha(lc.get(contador).getCargoFechaFactura());
                                    detalleAbos.setDocumentoCodigo(lc.get(contador).getCargosPK().getDocumentoCodigo());

                                    detalleAbo.add(detalleAbos);

                                    ////-----------------------------
                                }
                            }
                            cantPagar = cantPagar - lc.get(contador).getCargoPendiente().doubleValue();

                            contador = contador + 1;

                        } while (contador != lc.size());
                    }
                }
///----------------------------------------------------------------------------
                aboPk.setAbonoAnulado("F");
                aboPk.setAbonoCodigo(getNumeroRecibo());
                aboPk.setAbonoTipo(getTipoRecibo());

                abo.setAbonoEnvio("F");
                abo.setAbonoFecha(getFechaDigitacion());
                abo.setAbonoFechaValor(getFechaValor());
                abo.setAbonoInventario(false);
                abo.setAbonoSaldoAnterior(new BigDecimal(sumaTemp.toString()));
                abo.setAbonoValor(new BigDecimal(getCantidadAPagar()));
                abo.setAbonosPK(aboPk);
                abo.setBanco(numeroBanco);
                abo.setConsultorCodigo(consultores);
                abo.setSucursalCodigo(getSucursal());
                double cargoPagar = 0.00;
                double cargoPagar2 = 0.00;
                cargoPagar = Double.valueOf(getCantidadAPagar());
                cargoPagar2 = Double.valueOf(getCantidadAPagar());

                detalleAbonos = new ArrayList<>();
                this.abono = abo;
                this.detalleAbonos = detalleAbo;
                this.restaCargosList = restaCargos;
                this.cargosConsultorResta = cargoLista;
                //setDetalleAbonos(detalleAbo);
                System.out.println("listo");
                this.guardarBTN = false;
            }
            cantidadTemp = cantidadAPagar;
            cantidadAPagarAnterior = cantidadAPagar;
        }

    }

    public void aplicaCantidadDls() {


        String boletaAnterior = cargosfacadeLocal.validaBoleta(consultorCodigo, Double.valueOf(cantidadAPagar), numeroBanco);
        System.out.println("boleta anterior " + boletaAnterior);

        if (!boletaAnterior.equals("000000")) {

            FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_FATAL, "DUPLICADA", "Boleta Duplicada");
            PrimeFaces.current().dialog().showMessageDynamic(message);

        } else {

            buscarCargos2("out");
            detalleAbonos = new ArrayList<>();
            AbonosPK aboPk = new AbonosPK();
            Abonos abo = new Abonos();
            List<Cargos> cargoLista = new ArrayList<>();
            List<Cargos> lc = new ArrayList<>();
            List<Cargos> rs = new ArrayList<>();
            List<RestaCargos> restaCargos = new ArrayList<>();

            if (!cantidadAPagar.isEmpty() || !cantidadAPagar.equalsIgnoreCase("") || Double.parseDouble(cantidadAPagar) > 0) {

                if (!cantidadAPagar.equalsIgnoreCase(cantidadTemp)) {

                    Double sumaTemp = 0.00;
                    List<DetalleAbonos> detalleAbo = new ArrayList<>();
                    sumaTemp = Double.valueOf(totalPago);

                    if (!cantidadAPagar.isEmpty()) {
///---------------------------------------------------------------------------------------------------------------------------------------------
                        Double cantidaPagar = Double.valueOf(getCantidadAPagar());
                        lc = cargosConsultor;
                        int contador = 0;
                        Double cantPagar;
                        if (Double.valueOf(cantidadAPagar) > Double.valueOf(cargosSistemas)) {
                            Double d = Double.valueOf(cantidadAPagar) - Double.valueOf(cargosSistemas);
                            cantPagar = Double.valueOf(cargosSistemas);

                            BigDecimal d1 = new BigDecimal(d);
                            BigDecimal ds = d1.setScale(2, d1.ROUND_HALF_DOWN);

                            this.pagoExtra = ds.toString();
                        } else {
                            this.pagoExtra = "0.00";
                            cantPagar = Double.valueOf(cantidadAPagar);
                        }
                        Collections.sort(lc, new Comparator<Cargos>() {

                            @Override
                            public int compare(Cargos o1, Cargos o2) {
                                if (o1.getCargoFechaFactura() == null || o2.getCargoFechaFactura() == null) {
                                    return 0;
                                }
                                return o1.getCargoFechaFactura().compareTo(o2.getCargoFechaFactura());
                            }
                        });

                        if (!lc.isEmpty()) {

                            //  Double cargosPendiente = lc.get(contador).getCargoPendiente().doubleValue();
                            do {
                                Double salidacargo = lc.get(contador).getCargoPendiente().doubleValue() - cantPagar;

                                if (salidacargo > 0.000 && cantPagar < 0.000) {
                                    // lc.get(contador).setCargos(0.00);
                                } else {
                                    ///----------detalle abono----
                                    BigDecimal car;
                                    BigDecimal carFull;
                                    String nuevoCargoPendiente;

                                    if (lc.get(contador).getCargoPendiente().doubleValue() < cantPagar) {
                                        nuevoCargoPendiente = "0.00";
                                        car = new BigDecimal(lc.get(contador).getCargoPendiente().doubleValue());
                                        carFull = car.setScale(2, car.ROUND_HALF_DOWN);
                                    } else {
                                        nuevoCargoPendiente = String.valueOf(lc.get(contador).getCargoPendiente().doubleValue() - cantPagar);
                                        car = new BigDecimal((cantPagar - lc.get(contador).getCargoPendiente().doubleValue()) + lc.get(contador).getCargoPendiente().doubleValue());
                                        carFull = car.setScale(2, car.ROUND_HALF_DOWN);
                                    }

                                    if (!carFull.toString().equals("0.00")) {

                                        cargoLista.add(lc.get(contador));
                                        //   cargoLista.add(cargosEditar(lc.get(contador), nuevoCargoPendiente));
                                        DetalleAbonosPK detalleAbosPk = new DetalleAbonosPK();
                                        detalleAbosPk.setAbonoAnulado('F');
                                        detalleAbosPk.setAbonoCodigo(getNumeroRecibo());
                                        detalleAbosPk.setAbonoTipo(documentoSelect.getDocumentoCodigo());
                                        detalleAbosPk.setFacturaCodigo(lc.get(contador).getCargosPK().getFacturaCodigo());
                                        detalleAbosPk.setFacturaSerie(lc.get(contador).getCargosPK().getFacturaSerie());
                                        //------------------------------------------------------------------------------------------

                                        DetalleAbonos detalleAbos = new DetalleAbonos();
                                        detalleAbos.setDetalleAbonosPK(detalleAbosPk);
                                        detalleAbos.setDocumentoCodigo(lc.get(contador).getCargosPK().getDocumentoCodigo());
                                        detalleAbos.setProgramaCodigo(lc.get(contador).getProgramaCodigo());
                                        detalleAbos.setDetalleAbonoCantidad(carFull);
                                        detalleAbos.setDetalleAbonoFecha(lc.get(contador).getCargoFechaFactura());
                                        detalleAbos.setDocumentoCodigo(lc.get(contador).getCargosPK().getDocumentoCodigo());

                                        detalleAbo.add(detalleAbos);

                                        ////-----------------------------
                                    }
                                }
                                cantPagar = cantPagar - lc.get(contador).getCargoPendiente().doubleValue();

                                contador = contador + 1;

                            } while (contador != lc.size());
                        }
                    }
///----------------------------------------------------------------------------
                    aboPk.setAbonoAnulado("F");
                    aboPk.setAbonoCodigo(getNumeroRecibo());
                    aboPk.setAbonoTipo(getTipoRecibo());

                    abo.setAbonoEnvio("F");
                    abo.setAbonoFecha(getFechaDigitacion());
                    abo.setAbonoFechaValor(getFechaValor());
                    abo.setAbonoInventario(false);
                    abo.setAbonoSaldoAnterior(new BigDecimal(sumaTemp.toString()));
                    abo.setAbonoValor(new BigDecimal(getCantidadAPagar()));
                    abo.setAbonosPK(aboPk);
                    abo.setBanco(numeroBanco);
                    abo.setConsultorCodigo(consultores);
                    abo.setSucursalCodigo(getSucursal());
                    double cargoPagar = 0.00;
                    double cargoPagar2 = 0.00;
                    cargoPagar = Double.valueOf(getCantidadAPagar());
                    cargoPagar2 = Double.valueOf(getCantidadAPagar());

                    detalleAbonos = new ArrayList<>();
                    this.abono = abo;
                    this.detalleAbonos = detalleAbo;
                    this.restaCargosList = restaCargos;
                    this.cargosConsultorResta = cargoLista;
                    //setDetalleAbonos(detalleAbo);
                    System.out.println("listo");
                    this.guardarBTN = false;
                }
                cantidadTemp = cantidadAPagar;
                cantidadAPagarAnterior = cantidadAPagar;
            }
        }
    }

    // *****aplica cantidad Originla*****************************************************************
    public void aplicaCantidad() {
        buscarCargos("out");
        this.guardarBTN = false;
        detalleAbonos = new ArrayList<>();
        AbonosPK aboPk = new AbonosPK();
        Abonos abo = new Abonos();
        List<Cargos> cargoLista = new ArrayList<>();
        List<Cargos> listaTempCargos = new ArrayList<>();
        List<RestaCargos> restaCargos = new ArrayList<>();
        if (!cantidadAPagar.isEmpty() || !cantidadAPagar.equalsIgnoreCase("") || Double.parseDouble(cantidadAPagar) > 0) {

            if (!cantidadAPagar.equalsIgnoreCase(cantidadTemp)) {

                Double sumaTemp = 0.00;
                List<DetalleAbonos> detalleAbo = new ArrayList<>();
                List<Cargos> cargosSinRepetidos = new ArrayList<>();
//                Collections.sort(cagosConsultor, new Comparator<Cargos>() {
//
//                    @Override
//                    public int compare(Cargos o1, Cargos o2) {
//                        if (o1.getCargoFechaFactura() == null || o2.getCargoFechaFactura() == null) {
//                            return 0;
//                        }
//                        return o1.getCargoFechaFactura().compareTo(o2.getCargoFechaFactura());
//                    }
//                });

                if (!cantidadAPagar.isEmpty()) {
///---------------------------------------------------------------------------------------------------------------------------------------------
                    Double cantidaPagar = Double.valueOf(getCantidadAPagar());
                    listaTempCargos = cargosConsultor;
                    int contador = 0;
                    Double cantPagar;
                    if (Double.valueOf(cantidadAPagar) > Double.valueOf(cargosSistemas)) {
                        Double d = Double.valueOf(cantidadAPagar) - Double.valueOf(cargosSistemas);
                        cantPagar = Double.valueOf(cargosSistemas);

                        BigDecimal d1 = new BigDecimal(d);
                        BigDecimal ds = d1.setScale(2, d1.ROUND_HALF_DOWN);

                        this.pagoExtra = ds.toString();
                    } else {
                        this.pagoExtra = "0.00";
                        cantPagar = Double.valueOf(cantidadAPagar);
                    }
                    if (!listaTempCargos.isEmpty()) {
                        do {
                            Double valorTempCargos = listaTempCargos.get(contador).getCargoPendiente().doubleValue();
                            sumaTemp = sumaTemp + valorTempCargos;
                            cargoLista.add(getCargosConsultor().get(contador));
                            RestaCargos recs = new RestaCargos();
                            Double cargoPendiente = Double.valueOf(getCargosConsultor().get(contador).getCargoPendiente().toString());
                            //  recs.setAbonoCodigo(getCagosConsultor().get(contador).get);
                            recs.setFacturaCodigo(getCargosConsultor().get(contador).getCargosPK().getFacturaCodigo());
                            recs.setFechaCargo(getCargosConsultor().get(contador).getCargoFechaFactura());
                            recs.setVarlorCargo(cargoPendiente);
                            recs.setCargo(getCargosConsultor().get(contador));
                            cantPagar = cantPagar - cargoPendiente;
                            if (cantPagar <= cargoPendiente) {
                                recs.setValorFinal(cargoPendiente);
                                if (cantPagar < 0) {
                                    recs.setValorFinal(cargoPendiente + cantPagar);
                                }
                            } else {
                                if (cantPagar >= cargoPendiente) {
                                    recs.setValorFinal(cargoPendiente);
                                } else if (cantPagar < 0) {
                                    recs.setValorFinal(cargoPendiente + cantPagar);
                                }
                            }
                            restaCargos.add(recs);

                            contador = contador + 1;
                            //  key = sumaTemp >= cantidaPagar;
                        } while (sumaTemp <= cantidaPagar && cargosConsultor.size() > contador);
                    }
                }
///----------------------------------------------------------------------------
                aboPk.setAbonoAnulado("F");
                aboPk.setAbonoCodigo(getNumeroRecibo());
                aboPk.setAbonoTipo(getTipoRecibo());

                abo.setAbonoEnvio("F");
                abo.setBanco(numeroBanco);
                abo.setAbonoFecha(getFechaDigitacion());
                abo.setAbonoFechaValor(getFechaValor());
                abo.setAbonoInventario(false);
                abo.setAbonoSaldoAnterior(new BigDecimal(sumaTemp.toString()));
                abo.setAbonoValor(new BigDecimal(getCantidadAPagar()));
                abo.setAbonosPK(aboPk);
                abo.setBanco(numeroBanco);
                abo.setConsultorCodigo(consultores);
                abo.setSucursalCodigo(getSucursal());
                double cargoPagar = 0.00;
                double cargoPagar2 = 0.00;
                cargoPagar = Double.valueOf(getCantidadAPagar());
                cargoPagar2 = Double.valueOf(getCantidadAPagar());

                for (RestaCargos restaCargos1 : restaCargos) {
//                    BigDecimal apagarBD = new BigDecimal(cargoPagar);
//                    BigDecimal salidaAPagar = apagarBD.setScale(2, apagarBD.ROUND_HALF_DOWN);
//
                    BigDecimal car = new BigDecimal(restaCargos1.getValorFinal());
                    BigDecimal carFull = car.setScale(2, car.ROUND_HALF_DOWN);

                    DetalleAbonosPK detalleAbosPk = new DetalleAbonosPK();
                    detalleAbosPk.setAbonoAnulado('F');
                    detalleAbosPk.setAbonoCodigo(getNumeroRecibo());
                    detalleAbosPk.setAbonoTipo(documentoSelect.getDocumentoCodigo());
                    detalleAbosPk.setFacturaCodigo(restaCargos1.getCargo().getCargosPK().getFacturaCodigo());
                    detalleAbosPk.setFacturaSerie(restaCargos1.getCargo().getCargosPK().getFacturaSerie());
                    //------------------------------------------------------------------------------------------

                    DetalleAbonos detalleAbos = new DetalleAbonos();
                    detalleAbos.setDetalleAbonosPK(detalleAbosPk);
                    detalleAbos.setDocumentoCodigo(restaCargos1.getCargo().getCargosPK().getDocumentoCodigo());
                    detalleAbos.setProgramaCodigo(restaCargos1.getCargo().getProgramaCodigo());
                    detalleAbos.setDetalleAbonoCantidad(carFull);
                    detalleAbos.setDetalleAbonoFecha(restaCargos1.getCargo().getCargoFechaFactura());
                    detalleAbos.setDocumentoCodigo(restaCargos1.getCargo().getCargosPK().getDocumentoCodigo());

                    detalleAbo.add(detalleAbos);

                }

                Map<CargosPK, Cargos> mapPersonas = new HashMap<CargosPK, Cargos>(cargoLista.size());

                for (Cargos p : cargoLista) {
                    mapPersonas.put(p.getCargosPK(), p);
                }

                System.out.println("Lista sin repetidos:");
                for (Map.Entry<CargosPK, Cargos> p : mapPersonas.entrySet()) {
                    cargosSinRepetidos.add(p.getValue());
                    //     System.out.println(p.getValue());
                }

                for (Cargos cargoLista1 : cargosSinRepetidos) {
                    BigDecimal car = new BigDecimal(cargoPagar);
                    BigDecimal carFull = car.setScale(2, car.ROUND_HALF_DOWN);
                    Cargos j = new Cargos();
                    j = cargoLista1;

                    j.setCargoPendiente(carFull);

                    cargosGuardar.add(j);
                }

                detalleAbonos = new ArrayList<>();
                this.abono = abo;
                this.detalleAbonos = detalleAbo;
                this.restaCargosList = restaCargos;
                //setDetalleAbonos(detalleAbo);
                System.out.println("listo");
            }
            cantidadTemp = cantidadAPagar;
        }

    }

    public void guardarRecibo() throws IOException {

        boolean error = false;

        if (!restaCargosList.isEmpty() && !detalleAbonos.isEmpty()) {

            if (getNumeroRecibo().length() == 0) {
                setNumeroRecibo(cargosfacadeLocal.obtenerUltimoRecibo(getSucursalCodigoS(), getSucursalCodigoS()));
            }

            this.guardarBTN = true;

            int contador = 0;
            AbonosPK abonoPk = new AbonosPK();
            abonoPk.setAbonoAnulado("F");
            abonoPk.setAbonoTipo(documentoSelect.getDocumentoCodigo());
            abonoPk.setAbonoCodigo(getNumeroRecibo());
            Abonos abonof = new Abonos();
            abonof.setBanco(numeroBanco);
            abonof.setAbonosPK(abonoPk);
            abonof.setAbonoComentario("");
            abonof.setConsultorCodigo(getConsultores());
            abonof.setSucursalCodigo(sucursal);
            abonof.setAbonoFecha(getAbono().getAbonoFecha());
            abonof.setAbonoValor(new BigDecimal(cantidadAPagar));
            abonof.setAbonoFechaValor(getAbono().getAbonoFechaValor());
            abonof.setAbonoInventario(false);

            if (isCredito()) {
                abonof.setAbonoSaldoAnterior(new BigDecimal(totalPago));

            } else {
                abonof.setAbonoSaldoAnterior(new BigDecimal(cargoPedienteContado));
            }

            abonof.setBanco(numeroBanco);
            abonof.setAbonoEnvio("F");

            Collections.sort(restaCargosList, new Comparator<RestaCargos>() {

                @Override
                public int compare(RestaCargos o1, RestaCargos o2) {
                    if (o1.getFechaCargo() == null || o2.getFechaCargo() == null) {
                        return 0;
                    }
                    return o1.getFechaCargo().compareTo(o2.getFechaCargo());
                }
            });

            abonosFacadeLocal.create(abonof);
            for (DetalleAbonos det : detalleAbonos) {
                try {

                    detalleAbonosFacadeLocal.create(det);
                    System.out.println("numero de abono" + det);
                    //System.out.println("numero de abono"+det.getAbonos().getAbonosPK().getAbonoCodigo());
                } catch (Exception e) {
                    Errores es = new Errores();

                    es.setNumeroDoc(numeroRecibo);
                    es.setMontos("erroes");
                    es.setObservaciones("revise");
                    es.setDimension(String.valueOf(getDetalleAbonos().size()));

                    errFacadeLocal.create(es);
                    System.err.println("error al guardar ");
                }

            }

            if (!pagoExtra.equalsIgnoreCase("0.00")) {

                BigDecimal pagoExtrain = new BigDecimal(pagoExtra);
                BigDecimal pagoExtrout = pagoExtrain.setScale(2, pagoExtrain.ROUND_HALF_DOWN);
                PagoExtraPK pagPK = new PagoExtraPK();

                pagPK.setAbonoCodigo(numeroRecibo);
                pagPK.setAbonoTipo(documentoSelect.getDocumentoCodigo());
                pagPK.setConsultorCodigo(consultorCodigo);

                PagoExtra pag = new PagoExtra();
                pag.setDocumentoCodigo("06");
                pag.setPagoExtraFecha(abono.getAbonoFecha());
                pag.setPagoExtraPK(pagPK);
                pag.setPagoExtraValor(pagoExtrout);

//new PagoExtra(pagPK, getConsultorCodigo(), abono.getAbonoFechaValor(), pagoExtrout);
                pagoExtaFacadeLocal.create(pag);

            }

            System.out.println("numero de cargos " + cargosGuardar.size());
            for (RestaCargos cr : restaCargosList) {

                Cargos car = new Cargos();
                car = cargosfacadeLocal.find(cr.getCargo().getCargosPK());

                DetalleAbonosPK detalleAbonosPK = new DetalleAbonosPK('F', getNumeroRecibo(),
                        abonoPk.getAbonoTipo(), cr.getCargo().getCargosPK().getFacturaCodigo(),
                        cr.getCargo().getCargosPK().getFacturaSerie());
                DetalleAbonos detalleAbonos1 = new DetalleAbonos(detalleAbonosPK,
                        cr.getCargo().getCargosPK().getFacturaCodigo(), cr.getCargo().getProgramaCodigo(),
                        getAbono().getAbonoFechaValor(), cr.getCargo().getCargoPendiente());
                // System.out.println("cargo Valor = " + detalleAbonos.get(contador).getDetalleAbonoCantidad() + "Cargo Pendiente" + cargos01.getCargoPendiente());

                Double cargoPendiente = Double.valueOf(car.getCargoPendiente().toString());
                //Double abonoCargo = Double.valueOf(detalleAbonos.get(contador).getDetalleAbonoCantidad().toString());
                Double cargosValida = (cr.getValorFinal());

                if (cargosValida.equals(cargoPendiente)) {
                    cr.getCargo().setCargoPendiente(new BigDecimal("0.00"));
                } else {
                    cr.getCargo().setCargoPendiente(new BigDecimal(cargoPendiente - cargosValida));
                }
                ;
                try {
                    cargosfacadeLocal.edit(cr.getCargo());
                    //  System.out.println("Numero Recibo "+cr.getAbonoCodigo());                   
                    System.out.println(cr.getCargo());
                    Errores es = new Errores();
                    es.setNumeroDoc(cr.getFacturaCodigo() + "a recibo:" + getNumeroRecibo());
                    es.setMontos("sin erroes en guardar cargos" + cargosValida.toString());
                    es.setObservaciones("observa");
                    es.setDimension(String.valueOf(getDetalleAbonos().size()));
                    errFacadeLocal.create(es);
                } catch (Exception e) {
                    Errores es = new Errores();

                    es.setNumeroDoc(cr.getFacturaCodigo());
                    es.setMontos("con erroes en guardar cargos" + cargosValida.toString());
                    es.setObservaciones("revise");
                    es.setDimension(String.valueOf(getDetalleAbonos().size()));
                    errFacadeLocal.create(es);
                    System.err.println("error al guardar cargos" + e);
                }

            }

            List<DetalleAbonos> ds = getDetalleAbonos();
            if (detalleAbonos.size() > 0) {
                System.out.println("abonos correctos");
            } else {
                System.err.println("detalle abono tiene falta revisar " + ds.size());
            }

            Errores es = new Errores();

            es.setNumeroDoc(numeroRecibo);
            es.setMontos("fuera de detalle");
            es.setObservaciones("observar");
            es.setDimension(String.valueOf(detalleAbonos.size()));

            errFacadeLocal.create(es);

            System.out.println("que bien");

            if (documentoSelect.getDocumentoCodigo().equalsIgnoreCase("08") || documentoSelect.getDocumentoCodigo().equalsIgnoreCase("20") || documentoSelect.getDocumentoCodigo().equalsIgnoreCase("21")) {
                refresh();
            } else {
                this.imprimirBTN = false;
            }
        } else {

            Errores es = new Errores();

            es.setNumeroDoc(numeroRecibo);
            es.setMontos("fuera de detalle");
            es.setObservaciones("error de habilita guardado");
            es.setDimension(String.valueOf(detalleAbonos.size()));

            error = true;
            errFacadeLocal.create(es);

        }

        if (error || detalleAbonos.isEmpty()) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_FATAL, "Fatal!", "Error LLAME A SISTEMAS"));
        } else {

            if (documentoSelect.getDocumentoCodigo().equalsIgnoreCase("08") || documentoSelect.getDocumentoCodigo().equalsIgnoreCase("20") || documentoSelect.getDocumentoCodigo().equalsIgnoreCase("21")) {
                refresh();
            } else {
                this.imprimirBTN = false;
            }
        }

    }

    public void guardarReciboN() throws IOException {

        boolean error = false;
        boolean salidaRecibo = false;

        if (!cargosConsultorResta.isEmpty() && !detalleAbonos.isEmpty()) {

            String numeroReciboG = "";
            String tipoReciboG = documentoSelect.getDocumentoCodigo();
            if (tipoReciboG.equals("08") || tipoReciboG.equals("20") || tipoReciboG.equals("21")) {
                numeroReciboG = numeroRecibo;
            } else {
                salidaRecibo = true;
                numeroReciboG = abonosFacadeLocal.ObtenerProximoRecibo(tipoReciboG);
                numeroRecibo = numeroReciboG;
            }


            this.guardarBTN = true;

            int contador = 0;
            AbonosPK abonoPk = new AbonosPK();
            abonoPk.setAbonoAnulado("F");
            abonoPk.setAbonoTipo(documentoSelect.getDocumentoCodigo());
            abonoPk.setAbonoCodigo(numeroReciboG);
            Abonos abonof = new Abonos();
            abonof.setAbonosPK(abonoPk);
            abonof.setAbonoComentario("");
            abonof.setConsultorCodigo(getConsultores());
            abonof.setSucursalCodigo(sucursal);
            abonof.setAbonoFecha(getAbono().getAbonoFecha());
            abonof.setAbonoValor(new BigDecimal(cantidadAPagar));
            abonof.setAbonoFechaValor(getAbono().getAbonoFechaValor());
            abonof.setAbonoInventario(false);

            if (isCredito()) {
                abonof.setAbonoSaldoAnterior(new BigDecimal(totalPago));

            } else {
                abonof.setAbonoSaldoAnterior(new BigDecimal(cargoPedienteContado));
            }

            abonof.setBanco(numeroBanco);
            abonof.setAbonoEnvio("F");

            if (numeroBanco.equals("00")) {
                abonof.setAbonoFechaValor(getAbono().getAbonoFechaValor());
            }

            abonosFacadeLocal.create(abonof);

            for (DetalleAbonos det : detalleAbonos) {
                try {
                    det.getDetalleAbonosPK().setAbonoCodigo(numeroReciboG);
                    detalleAbonosFacadeLocal.create(det);
                    System.out.println("numero de abono" + det);
                    //System.out.println("numero de abono"+det.getAbonos().getAbonosPK().getAbonoCodigo());
                } catch (Exception e) {
                    Errores es = new Errores();

                    es.setNumeroDoc(numeroReciboG);
                    es.setMontos("erroes");
                    es.setObservaciones("revise");
                    es.setDimension(String.valueOf(getDetalleAbonos().size()));

                    errFacadeLocal.create(es);
                    System.err.println("error al guardar ");
                }

            }

            if (!pagoExtra.equalsIgnoreCase("0.00")) {

                PagoExtraPK pagPK = new PagoExtraPK();

                pagPK.setAbonoCodigo(numeroReciboG);
                pagPK.setAbonoTipo(documentoSelect.getDocumentoCodigo());
                pagPK.setConsultorCodigo(consultorCodigo);

                PagoExtra pag = new PagoExtra();
                pag.setDocumentoCodigo("06");
                pag.setPagoExtraFecha(abono.getAbonoFecha());
                pag.setPagoExtraPK(pagPK);
                pag.setPagoExtraValor(new BigDecimal(getPagoExtra()));

                pagoExtaFacadeLocal.create(pag);
            }

            System.out.println("numero de cargos " + cargosGuardar.size());
            Double apagar = Double.valueOf(cantidadAPagar);
            for (Cargos car : cargosConsultorResta) {

                Double salidacargo = car.getCargoPendiente().doubleValue() - apagar;
                apagar = apagar - car.getCargoPendiente().doubleValue();

                if (salidacargo < 0) {
                    car.setCargoPendiente(new BigDecimal(0.00));
                } else {
                    car.setCargoPendiente(new BigDecimal(salidacargo));
                }
                cargosfacadeLocal.edit(car);
            }

            Errores es = new Errores();

            es.setNumeroDoc(numeroReciboG);
            es.setMontos("fuera de detalle");
            es.setObservaciones("observar");
            es.setDimension(String.valueOf(detalleAbonos.size()));

            errFacadeLocal.create(es);

            System.out.println("que bien");

            if (documentoSelect.getDocumentoCodigo().equalsIgnoreCase("08") || documentoSelect.getDocumentoCodigo().equalsIgnoreCase("20") || documentoSelect.getDocumentoCodigo().equalsIgnoreCase("21")) {
                sucursal.setSalaRecibo(numeroReciboG);
                sucursalesFacadeLocal.edit(sucursal);
                refresh();
            } else {
                this.imprimirBTN = false;
            }
            if (salidaRecibo) {
                PrimeFaces.current().executeScript("PF('numeroReciboDi').show();");
            }

        } else {

            Errores es = new Errores();

            es.setNumeroDoc(numeroRecibo);
            es.setMontos("fuera de detalle");
            es.setObservaciones("error de habilita guardado");
            es.setDimension(String.valueOf(detalleAbonos.size()));

            error = true;
            errFacadeLocal.create(es);

        }

        if (error || detalleAbonos.isEmpty()) {
            FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(FacesMessage.SEVERITY_FATAL, "Fatal!", "Error LLAME A SISTEMAS"));
        } else {

            if (documentoSelect.getDocumentoCodigo().equalsIgnoreCase("08") || documentoSelect.getDocumentoCodigo().equalsIgnoreCase("20") || documentoSelect.getDocumentoCodigo().equalsIgnoreCase("21")) {
                sucursal.setSalaRecibo(numeroRecibo);
                sucursalesFacadeLocal.edit(sucursal);
                refresh();
            } else {
                this.imprimirBTN = false;
            }
        }
    }

    public void testGuardar() {

        System.out.println("guar");

    }

    public void nuevoRecibo() {

        setCredito(true);
        this.bloqueo = false;
        this.nuevo = true;
        this.abono = new Abonos();
        Documentos doc = this.documentoSelect;
        Sucursales su = sucursal;
        Abonos abo = new Abonos();
        List<Documentos> docs = new ArrayList<>();
        docs.addAll(listaDocumentos);

        if ((doc.getDocumentoCodigo().equals("08") || doc.getDocumentoCodigo().equals("20") || doc.getDocumentoCodigo().equals("21")) && !buscar) {
            this.textRecibos = false;
        } else if (buscar) {
            this.textRecibos = false;
        }

        AbonosPK aboPk = new AbonosPK();

        if (buscar) {
            buscaRecibos();
        } else {

            if (!docs.isEmpty() && isNuevo() && (doc.getDocumentoCodigo().equals("08") | doc.getDocumentoCodigo().equals("20") || doc.getDocumentoCodigo().equals("21"))) {
                numeroRecibo = cargosfacadeLocal.obtenerUltimoRecibo(su.getSucursalCodigo(), doc.getDocumentoCodigo());
                sucursalCodigoS = su.getSucursalCodigo();
                documentoCodigoS = doc.getDocumentoCodigo();

                if (numeroRecibo != null) {
                    Integer numeroReciboin = Integer.parseInt(numeroRecibo) + 1;
                    Formatter fmt = new Formatter();

                    numeroRecibo = fmt.format("%06d", numeroReciboin).toString();

                    aboPk.setAbonoAnulado("F");
                    aboPk.setAbonoCodigo(doc.getDocumentoCodigo());
                    aboPk.setAbonoCodigo(getNumeroRecibo());

                    abo.setSucursalCodigo(su);
                    try {
                        if (getAbono().getConsultorCodigo().getConsultorCodigo() == null) {
                            abo.setConsultorCodigo(consultoresFacadeLocal.find(getAbono().getConsultorCodigo().getConsultorCodigo()));
                        }
                    } catch (Exception e) {
                        //   abo.setConsultorCodigo(consultoresFacadeLocal.find(getAbono().getConsultorCodigo().getConsultorCodigo()));
                    }

                } else {
                    mensaje();
                }

            } else if (!docs.isEmpty() && isNuevo()) {
                //  numeroRecibo = cargosfacadeLocal.obtenerUltimoRecibo(su.getSucursalCodigo(), doc.getDocumentoCodigo());
                sucursalCodigoS = su.getSucursalCodigo();
                documentoCodigoS = doc.getDocumentoCodigo();
                numeroRecibo = "NUM. AUTOMATICA";

                aboPk.setAbonoAnulado("F");
                aboPk.setAbonoCodigo(doc.getDocumentoCodigo());
                aboPk.setAbonoCodigo(getNumeroRecibo());

                abo.setSucursalCodigo(su);
                try {
                    if (getAbono().getConsultorCodigo().getConsultorCodigo() == null) {
                        abo.setConsultorCodigo(consultoresFacadeLocal.find(getAbono().getConsultorCodigo().getConsultorCodigo()));
                    }
                } catch (Exception e) {
                    //   abo.setConsultorCodigo(consultoresFacadeLocal.find(getAbono().getConsultorCodigo().getConsultorCodigo()));
                }

            }
        }

    }

    public String totalPago() {
        BigDecimal retu = new BigDecimal("0.00");
        Double d = 0.00;
        try {
            for (DetalleAbonos de : getDetalleAbonos()) {

                d = d + Double.valueOf((de.getDetalleAbonoCantidad().toString()));

            }
            BigDecimal rs = new BigDecimal(d);
            retu = rs.setScale(2, rs.ROUND_HALF_DOWN);

        } catch (Exception e) {
        }
        // this.totalPago = retu.toString();
        return retu.toString();

    }

    public void addMessage() {
        String msje;
        if (credito) {
            msje = "es Credito";
            // this.credito = false;
        } else {
            msje = "es Contado";
            // this.credito = true;
        }
        FacesContext.getCurrentInstance().addMessage(null, new FacesMessage(msje));
    }

    public void buscarCargos(String a) {//////////////////////////////////////////////////////////////////////////////////////////////

        if (getConsultorCodigo().length() == 6) {
            this.cargosConsultor = new ArrayList<>();
            this.detalleAbonos = new ArrayList<>();

            setConsultorNombreCompleto(consultoresFacadeLocal.ObtenerNombreCompleto(getConsultorCodigo()));
            if (isCredito()) {
                //  cagosConsultor = cargosfacadeLocal.cargosPorConsultor(getConsultorCodigo());
                Consultores cos = sfl.findConsultor(getConsultorCodigo());
                List<Cargos> cac = new ArrayList<>(cos.getCargosCollection()); // cargos de contado
                List<Cargos> cargosACobrar = new ArrayList<>();
                Double suma = 0.00;
                AbonosPK aboPK = new AbonosPK();
                List<Abonos> rs = new ArrayList<>();

                for (Cargos cac1 : cac) {
                    if (cac1.getCargoPendiente().doubleValue() > (new BigDecimal("0.00").doubleValue())) {
                        cargosACobrar.add(cac1);
                        suma = suma + cac1.getCargoPendiente().doubleValue();
                    } else {
                        // System.out.println("cargos cancelado");
                    }
                }

                BigDecimal cargo1 = new BigDecimal(suma);
                BigDecimal cargoSalida = cargo1.setScale(2, cargo1.ROUND_HALF_UP);

                // Date d = new Date();
                setCatidadPagar(cargoSalida.toString());
                this.cargosConsultor = cargosACobrar;
                System.out.println("cargos = : " + cargosACobrar.size());
                if (a.equalsIgnoreCase("in")) {
                    this.cargosSistemas = cargoSalida.toString();
                    FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_INFO, "MONTO DE PAGO", "El CONSULTOR DEBE $" + cargoSalida.toString());/////////////////////////////////////////////////////////////////
                    PrimeFaces.current().dialog().showMessageDynamic(message);
                }
                this.totalPago = cargoSalida.toString();
            } else {

                Calendar cal = Calendar.getInstance();
                Date h = new Date();
                cal.setTime(h);
                cal.set(Calendar.DAY_OF_MONTH, -1);
                cal.set(Calendar.HOUR, 24);

                // System.out.println(cal);
                //  cagosConsultor = cargosfacadeLocal.cargosPorConsultor(getConsultorCodigo());
                Consultores cos = sfl.findConsultor(getConsultorCodigo());
                List<Cargos> cac = new ArrayList<>(cos.getCargosCollection()); // cargos de contado
                List<Cargos> cargosACobrar = new ArrayList<>();
                Double suma = 0.00;
                Double suma2 = 0.00;

                AbonosPK aboPK = new AbonosPK();
                List<Abonos> rs = new ArrayList<>();

                for (Cargos cac1 : cac) {

                    Calendar cal2 = Calendar.getInstance();
                    cal2.setTime(cac1.getCargoFechaFactura());
                    cal2.set(Calendar.HOUR, 3);
                    // cac1.getCargoFechaFactura().setHours(3);
                    if (cac1.getCargoPendiente().doubleValue() > (new BigDecimal("0.00").doubleValue()) && !cac1.getCredito() && cal2.after(cal)) {
                        cargosACobrar.add(cac1);
                        suma = suma + cac1.getCargoPendiente().doubleValue();
                    } else {

                    }
                    suma2 = suma2 + cac1.getCargoPendiente().doubleValue();
                }

                BigDecimal cargo1 = new BigDecimal(suma);
                BigDecimal cargoSalida = cargo1.setScale(2, cargo1.ROUND_HALF_UP);

                // Date d = new Date();
                setCatidadPagar(cargoSalida.toString());
                this.cargosConsultor = cargosACobrar;
                System.out.println("cargos = : " + cargosACobrar.size());
                if (a.equalsIgnoreCase("in")) {

                    this.cargosSistemas = cargoSalida.toString();

                    saldoPagarDialogo = cargoSalida.toString();

                    PrimeFaces.current().executeScript("PF('valorMontorDi').show();");
//                    FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_INFO, "MONTO DE PAGO", "El CONSULTOR DEBE $" + cargoSalida.toString());
//                    RequestContext.getCurrentInstance().showMessageInDialog(message);
                }

                this.totalPago = cargoSalida.toString();
                this.cargoPedienteContado = String.valueOf(suma2);

            }
        } else if (getConsultorCodigo().length() == 4) {

            this.cargosConsultor = new ArrayList<>();
            this.lista_cargos = new ArrayList<>();
            this.pagoExtra = "0.00";
            this.totalPago = "0.00";

        }
        this.abono.setAbonoFecha(fechaValor);
        this.abono.setAbonoFechaValor(new Date());
    }

    public void buscarCargos2(String a) {

        boolean salidaTrue = false;
        if (getConsultorCodigo().length() == 6 && !salidaTrue) {

            validaFechas();
            this.cargosConsultor = new ArrayList<>();
            this.detalleAbonos = new ArrayList<>();

            setConsultorNombreCompleto(consultoresFacadeLocal.ObtenerNombreCompleto(getConsultorCodigo()));

            if (getConsultorCodigo().equals("P10254")) {

                consL10058 = false;
                List<Cargos> cac = cargosfacadeLocal.ObtenerCargos(consultorCodigo, 1, sucursal.getSucursalCodigo());
                // List<Cargos> cargosACobrar = new ArrayList<>();
                Double suma = 0.00;
                AbonosPK aboPK = new AbonosPK();
                List<Abonos> rs = new ArrayList<>();

                for (Cargos cac1 : cac) {
                    if (cac1.getCargoPendiente().doubleValue() > (new BigDecimal("0.00").doubleValue())) {
                        suma = suma + cac1.getCargoPendiente().doubleValue();
                    }
                }

                BigDecimal cargo1 = new BigDecimal(suma);
                BigDecimal cargoSalida = cargo1.setScale(2, cargo1.ROUND_HALF_UP);

                setCatidadPagar(cargoSalida.toString());
                this.cargosConsultor = cac;
                if (a.equalsIgnoreCase("in")) {
                    this.cargosSistemas = cargoSalida.toString();
                    saldoPagarDialogo = cargoSalida.toString();

                    PrimeFaces.current().executeScript("PF('valorMontorDi').show();");
                }
                this.totalPago = cargoSalida.toString();

            } else {
                if (isCredito()) {

                    List<Cargos> cac = cargosfacadeLocal.ObtenerCargos(consultorCodigo, 1);
                    // List<Cargos> cargosACobrar = new ArrayList<>();
                    Double suma = 0.00;
                    AbonosPK aboPK = new AbonosPK();
                    List<Abonos> rs = new ArrayList<>();

                    for (Cargos cac1 : cac) {
                        if (cac1.getCargoPendiente().doubleValue() > (new BigDecimal("0.00").doubleValue())) {
                            suma = suma + cac1.getCargoPendiente().doubleValue();
                        }
                    }

                    BigDecimal cargo1 = new BigDecimal(suma);
                    BigDecimal cargoSalida = cargo1.setScale(2, cargo1.ROUND_HALF_UP);

                    setCatidadPagar(cargoSalida.toString());
                    this.cargosConsultor = cac;
                    if (a.equalsIgnoreCase("in")) {
                        this.cargosSistemas = cargoSalida.toString();
                        saldoPagarDialogo = cargoSalida.toString();

                        PrimeFaces.current().executeScript("PF('valorMontorDi').show();");
                    }
                    this.totalPago = cargoSalida.toString();
                } else {

                    List<Cargos> cac = cargosfacadeLocal.ObtenerCargos(consultorCodigo, 0, sucursal.getSucursalCodigo());
                    Double suma = 0.00;

                    AbonosPK aboPK = new AbonosPK();
                    List<Abonos> rs = new ArrayList<>();

                    for (Cargos cac1 : cac) {
                        suma = suma + cac1.getCargoPendiente().doubleValue();
                    }

                    BigDecimal cargo1 = new BigDecimal(suma);
                    BigDecimal cargoSalida = cargo1.setScale(2, cargo1.ROUND_HALF_UP);

                    setCatidadPagar(cargoSalida.toString());
                    this.cargosConsultor = cac;
                    if (a.equalsIgnoreCase("in")) {
                        this.cargosSistemas = cargoSalida.toString();
                        saldoPagarDialogo = cargoSalida.toString();

                        PrimeFaces.current().executeScript("PF('valorMontorDi').show();");
                    }

                    this.totalPago = cargoSalida.toString();
                    this.cargoPedienteContado = String.valueOf(suma);

                }

            }


        } else if (getConsultorCodigo().length() == 4) {

            this.cargosConsultor = new ArrayList<>();
            this.lista_cargos = new ArrayList<>();
            this.pagoExtra = "0.00";
            this.totalPago = "0.00";

        }

        if (salidaTrue) {
            salidaTrue = true;

            PrimeFaces.current().executeScript("PF('valorMontorDi').hide();");
            PrimeFaces.current().executeScript("focusField('recibos:ingresoCantidadPagar);");
        }

    }

    public String validaPulseBoton() {
        String rs = "recibo:guardarB";
        if (!guardarBTN) {
            rs = "recibo:guardarB";
        } else if (!imprimirBTN) {
            rs = "recibo:imprimirB";
        }

        return rs;
    }

    public void asisgnarVariables() {

        this.abono.setAbonoFecha(fechaDigitacion);
        this.abono.setAbonoFechaValor(new Date());
        this.abono.setBanco(numeroBanco);

    }

    public void busqeda() {

        this.nuevo = true;
        this.busquedaBool = true;
        this.buscar = true;
        this.nuevoSelector = false;
        this.numeroRecibo = "";
        this.consultorCodigo = "";
        this.consultorNombreCompleto = "";
        this.detalleAbonos = new ArrayList<>();
    }

    public Cargos cargosContado() {

        List<Cargos> cac = new ArrayList<>(getConsultores().getCargosCollection()); // cargos de contado
        Date d = new Date();

        System.out.println("cargos = : " + cac.size());
        //   cac = cargosfacadeLocal.cargos_pendiente_by_codigo_decimal(getAbono().getConsultorCodigo().getConsultorCodigo(), getCredito)

        return null;
    }

    public void mensaje() {
        FacesMessage message = new FacesMessage(FacesMessage.SEVERITY_FATAL, "INGRESO MANUAL", "Ingrese recibo manualmente");
        PrimeFaces.current().dialog().closeDynamic(message);

    }

    public void imprimeNuevo() throws IOException {

        String sucurCod = sucursal.getSucursalCodigo();

        if (buscar) {
            try {
                String cmd = "rm -rf /opt/recibos/R" + numeroRecibo + "-" + getDocumentoSelect().getDocumentoCodigo() + ".txt"; //Comando de apagado en linux
                Runtime.getRuntime().exec(cmd);
            } catch (IOException ioe) {
                System.out.println(ioe);
            }
        }

        if (!imprimeUnaVez) {

            imprimirBTN = true;
            String numeroReciboOut = this.numeroRecibo;
            String cargosPendientes = "0.00";
            buscaRecibos();
            String ruta = "/opt/recibos/R" + numeroReciboOut + "-" + getDocumentoSelect().getDocumentoCodigo() + ".txt";
            String rutaDestino = "/media/print/Recepcion/";
            File archivo = new File(ruta);
            DateFormat fechaForm = new SimpleDateFormat("dd/MM/yyyy");

            boolean error = false;
            Calendar fecha = Calendar.getInstance();
            Calendar fechaValorIm = Calendar.getInstance();
            fechaValorIm.setTime(abono.getAbonoFechaValor());
            fecha.setTime(abono.getAbonoFecha());

            obternerMes obt = new obternerMes();
            NumeroALetras nu = new NumeroALetras();
            String Impresor = "RECIBOS" + sucursal.getSucursalCodigo();

            BigDecimal apagarBD = new BigDecimal(getCantidadAPagar());
            BigDecimal salidaAPagar = apagarBD.setScale(2, apagarBD.ROUND_HALF_DOWN);

            cargosPendientes = cargosfacadeLocal.obtenerCargos(abono.getConsultorCodigo().getConsultorCodigo()).toString();
            BigDecimal cargosNuevosBD = new BigDecimal(cargosPendientes);
            BigDecimal cargosNuevos = cargosNuevosBD.setScale(2, cargosNuevosBD.ROUND_HALF_UP);

            BigDecimal c1;
            if (isCredito()) {
                c1 = new BigDecimal(Double.valueOf(getTotalPago()) - Double.valueOf(getCantidadAPagar()));
            } else {
                c1 = new BigDecimal(Double.valueOf(cargoPedienteContado) - Double.valueOf(getCantidadAPagar()));
            }
            BigDecimal cs = c1.setScale(2, c1.ROUND_HALF_UP);

            String sucursalNombre = "";
            String sucurDestino = "";

            switch (sucurCod) {
                case "02":
                    sucursalNombre = "CENTRAL";
                    break;
                case "03":
                    sucursalNombre = "SOYAPANGO";
                    break;
                case "04":
                    sucursalNombre = "SAN_MIGUEL";
                    break;
                case "05":
                    sucursalNombre = "USULUTAN";
                    break;
                case "06":
                    sucursalNombre = "ZACATECOLUCA";
                    break;
                case "07":
                    sucursalNombre = "SANTA_ANA";
                    break;
                case "08":
                    sucursalNombre = "SONSONATE";
                    break;
                case "09":
                    sucursalNombre = "CHALATENANGO";
                    break;
                default:
                    break;

            }

            if (sucursal.getSucursalDescarga().equalsIgnoreCase("02")) {
                sucurDestino = "01";
            } else {
                sucurDestino = sucursal.getSucursalDescarga();
            }

            BufferedWriter bw;
            if (!archivo.exists()) {
                bw = new BufferedWriter(new FileWriter(archivo));
                bw.write("%!");
                bw.newLine();
                bw.write("(rcb.jdt) STARTLM");
                bw.newLine();
                bw.write("CODEMPRES|MARLEN " + sucurDestino);
                bw.newLine();
                bw.write("TIPODOCUM|RECIBOCLIENTE");
                bw.newLine();
                bw.write("FECHAEMIS|" + fechaForm.format(abono.getAbonoFecha()));//
                bw.newLine();
                bw.write("IMPRESDST|" + sucursalNombre);
                bw.newLine();
                bw.write("DIRECSALA|" + sucursal.getSalaDireccion());///AÑADIRdIRECCION
                bw.newLine();
                bw.write("SERIEREBC|" + getDocumentoSelect().getDocumentoCodigo());
                bw.newLine();
                bw.write("NUMEFACTU|" + numeroReciboOut);
                bw.newLine();
                bw.write("FECHABONO|" + fechaForm.format(abono.getAbonoFechaValor())); //String.valueOf(fecha.get(Calendar.DAY_OF_MONTH)) + " DE " + obt.obtenerMes(fecha.get(Calendar.MONTH) + 1) + " DE " + String.valueOf(fecha.get(Calendar.YEAR)));//       
                bw.newLine();
                bw.write("CONSCODIG|" + getConsultorCodigo());
                bw.newLine();
                bw.write("NOMCLIENT|" + getConsultorNombreCompleto());
                bw.newLine();
                bw.write("PAGOLETRA|" + nu.Convertir(salidaAPagar.toString(), true));
                bw.newLine();
                bw.write("MONTODEUD|" + getTotalPago());
                bw.newLine();
                bw.write("MONTOCANC|" + salidaAPagar.toString());
                bw.newLine();
                bw.write("MONTOPEND|" + cargosNuevos.toString());
                bw.newLine();
                bw.write("NOMBBANCO|" + bancosFacadeLocal.find(numeroBanco).getNombreBanco());
                bw.newLine();
                bw.write("TERRITORI|" + consultores.getTerritorioCodigo().getCodigoTerritorio());
                bw.newLine();
                bw.write("FECHAIMPR|" + fechaForm.format(fechaValorIm.getTime()));
                bw.newLine();
                bw.write("NUMERONRC|" + "3893-8");
                bw.newLine();
                bw.write("%%EOF");
                bw.close();
            } else {

                try {
                    String cmd = "rm -rf " + ruta; //Comando de apagado en linux
                    Runtime.getRuntime().exec(cmd);
                } catch (IOException ioe) {
                    System.out.println(ioe);
                }

                if (sucursal.getSucursalDescarga().equalsIgnoreCase("02")) {
                    sucurDestino = "01";
                } else {
                    sucurDestino = sucursal.getSucursalDescarga();
                }

                bw = new BufferedWriter(new FileWriter(archivo));
                bw.write("%!");
                bw.newLine();
                bw.write("(rcb.jdt) STARTLM");
                bw.newLine();
                bw.write("CODEMPRES|MARLEN " + sucurDestino);
                bw.newLine();
                bw.write("TIPODOCUM|RECIBOCLIENTE");
                bw.newLine();
                bw.write("FECHAEMIS|" + fechaForm.format(abono.getAbonoFecha()));//
                bw.newLine();
                bw.write("IMPRESDST|" + sucursalNombre);
                bw.newLine();
                bw.write("DIRECSALA|" + sucursal.getSalaDireccion());///AÑADIRdIRECCION
                bw.newLine();
                bw.write("SERIEREBC|" + getDocumentoSelect().getDocumentoCodigo());
                bw.newLine();
                bw.write("NUMEFACTU|" + numeroReciboOut);
                bw.newLine();
                bw.write("FECHABONO|" + fechaForm.format(abono.getAbonoFechaValor())); //String.valueOf(fecha.get(Calendar.DAY_OF_MONTH)) + " DE " + obt.obtenerMes(fecha.get(Calendar.MONTH) + 1) + " DE " + String.valueOf(fecha.get(Calendar.YEAR)));//       
                bw.newLine();
                bw.write("CONSCODIG|" + getConsultorCodigo());
                bw.newLine();
                bw.write("NOMCLIENT|" + getConsultorNombreCompleto());
                bw.newLine();
                bw.write("PAGOLETRA|" + nu.Convertir(salidaAPagar.toString(), true));
                bw.newLine();
                bw.write("MONTODEUD|" + getTotalPago());
                bw.newLine();
                bw.write("MONTOCANC|" + salidaAPagar.toString());
                bw.newLine();
                bw.write("MONTOPEND|" + cargosNuevos.toString());
                bw.newLine();
                bw.write("NOMBBANCO|" + bancosFacadeLocal.find(numeroBanco).getNombreBanco());
                bw.newLine();
                bw.write("TERRITORI|" + consultores.getTerritorioCodigo().getCodigoTerritorio());
                bw.newLine();
                bw.write("FECHAIMPR|" + fechaForm.format(fechaValorIm.getTime()));
                bw.newLine();
                bw.write("NUMERONRC|" + "3893-8");
                bw.newLine();
                bw.write("%%EOF");
                bw.close();

            }

            try {
                String cmd = "cp " + ruta + " " + rutaDestino; //Comando de apagado en linux
                Runtime.getRuntime().exec(cmd);
            } catch (IOException ioe) {
                System.out.println(ioe);
            }

            if (!error) {
                FacesMessage msg = null;
                HttpSession session = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
                session.setAttribute("fechaRecibo", abono.getAbonoFecha());

            }
            refresh();

        }

    }


    public void imprimirJasper() throws JRException, IOException {

        String sucurCod = sucursal.getSucursalCodigo();
        imprimirBTN = true;
        String numeroReciboOut = this.numeroRecibo;
        String cargosPendientes = "0.00";
        buscaRecibos();
        String ruta = "/opt/recibos/R" + numeroReciboOut + "-" + getDocumentoSelect().getDocumentoCodigo() + ".txt";
        String rutaDestino = "/media/print/Recepcion/";
        File archivo = new File(ruta);
        DateFormat fechaForm = new SimpleDateFormat("dd/MM/yyyy");
        List<CuerpoRecibo> listRecibo = new ArrayList<>();

        boolean error = false;
        Calendar fecha = Calendar.getInstance();
        Calendar fechaValorIm = Calendar.getInstance();
        fechaValorIm.setTime(abono.getAbonoFechaValor());
        fecha.setTime(abono.getAbonoFecha());

        obternerMes obt = new obternerMes();
        NumeroALetras nu = new NumeroALetras();
        String Impresor = "RECIBOS" + sucursal.getSucursalCodigo();

        BigDecimal apagarBD = new BigDecimal(getCantidadAPagar());
        BigDecimal salidaAPagar = apagarBD.setScale(2, apagarBD.ROUND_HALF_DOWN);

        cargosPendientes = cargosfacadeLocal.obtenerCargos(abono.getConsultorCodigo().getConsultorCodigo()).toString();
        BigDecimal cargosNuevosBD = new BigDecimal(cargosPendientes);
        BigDecimal cargosNuevos = cargosNuevosBD.setScale(2, cargosNuevosBD.ROUND_HALF_UP);

        BigDecimal c1;
        if (isCredito()) {
            c1 = new BigDecimal(Double.valueOf(getTotalPago()) - Double.valueOf(getCantidadAPagar()));
        } else {
            c1 = new BigDecimal(Double.valueOf(cargoPedienteContado) - Double.valueOf(getCantidadAPagar()));
        }
        BigDecimal cs = c1.setScale(2, c1.ROUND_HALF_UP);

        String impresorDst = "";
        String sucurDestino = "";

        switch (sucurCod) {
            case "01":
                impresorDst = "RECIBOS_CENTRAL";
            case "02":
                impresorDst = "RECIBOS_CENTRAL";
                break;
            case "03":
                impresorDst = "RECIBOS_SOYAPANGO";
                break;
            case "04":
                impresorDst = "RECIBOS_SAN_MIGUEL";
                break;
            case "05":
                impresorDst = "RECIBOS_USULUTAN";
                break;
            case "06":
                impresorDst = "RECIBOS_ZACATECOLUCA";
                break;
            case "07":
                impresorDst = "RECIBOS_SANTA_ANA";
                break;
            case "08":
                impresorDst = "RECIBOS_SONSONATE";
                break;
            case "11":
                impresorDst = "RECIBOS_APOPA";
                break;
            default:
                break;

        }

        if (sucursal.getSucursalDescarga().equalsIgnoreCase("02")) {
            sucurDestino = "01";
        } else {
            sucurDestino = sucursal.getSucursalDescarga();
        }

        CuerpoRecibo rec = new CuerpoRecibo();

        rec.setCodigoConsultor(consultorCodigo);
        rec.setFechaEmision(fechaForm.format(abono.getAbonoFecha()));
        rec.setFechaAbono(fechaForm.format(abono.getAbonoFechaValor()));
        rec.setFechaImpresion(fechaForm.format(abono.getAbonoFechaValor()));
        rec.setMontoCancelar("$" + salidaAPagar.toString());
        rec.setTerriotorio("T." + consultores.getTerritorioCodigo().getCodigoTerritorio());
        rec.setNombreBanco(bancosFacadeLocal.find(numeroBanco).getNombreBanco());
        rec.setMontoDeuda("$" + getTotalPago());
        rec.setMontoPendiente("$" + cargosNuevos.toString());
        rec.setPagoEnLetras(nu.Convertir(salidaAPagar.toString(), true) + " " + "por abono a su cuenta.".toUpperCase());
        rec.setNombreCliente(getConsultorNombreCompleto());
        rec.setNumeroRecibo(numeroReciboOut + "-" + getDocumentoSelect().getDocumentoCodigo());
        rec.setReciboSerie(getDocumentoSelect().getDocumentoCodigo());
        rec.setSala(sucursal.getSalaNombreCorto());
        listRecibo.add(rec);

        JRBeanCollectionDataSource beanCollectionDataSource = new JRBeanCollectionDataSource(listRecibo);
        String reportPath = "/opt/reportesJasper/recibos.jrxml";
        JasperReport jasperReport = JasperCompileManager.compileReport(reportPath);
        //this.salida = jasperReport.toString();
        Map parametros = new HashMap();
        jasperPrint = JasperFillManager.fillReport(jasperReport, parametros, beanCollectionDataSource);
        JasperExportManager.exportReportToPdfFile(jasperPrint, "/opt/recibosJasper/" + getNumeroRecibo() + "-" + getDocumentoSelect().getDocumentoCodigo() + ".pdf");
        try {
            Runtime.getRuntime().exec("lp -d " + impresorDst + " " + "/opt/recibosJasper/" + getNumeroRecibo() + "-" + getDocumentoSelect().getDocumentoCodigo() + ".pdf");
        } catch (IOException e) {
            System.out.println("EXCEPTION: " + e.getMessage());
        }
        refresh();
    }


    public void refresh() throws IOException {
        ExternalContext context = FacesContext.getCurrentInstance().getExternalContext();
        context.redirect("recibosApp.jsf");

    }

    public void calculaCambioEfectivo() {

        try {

            if (!cantidadAPagar.isEmpty()) {

                BigDecimal apagarBD = new BigDecimal(getCantidadAPagar());
                BigDecimal salidaAPagar = apagarBD.setScale(2, apagarBD.ROUND_HALF_DOWN);

                BigDecimal cambioBD = new BigDecimal(Double.valueOf(cambioEfectivo) - Double.valueOf(getCantidadAPagar()));
                BigDecimal salidaCambio = cambioBD.setScale(2, cambioBD.ROUND_HALF_DOWN);

                HttpSession session = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
                session.setAttribute("cambioConsultor", salidaCambio.toString());
                this.calculoCambioEfectivo = salidaCambio.toString();
            }
        } catch (Exception e) {
            System.err.println(e.toString());
        }

    }

    public void validaFechas() {

        if (documentoSelect.getDocumentoCodigo().equals("08") && numeroBanco.equals("00")) {
            this.minDatePago = intervaloFecha(-4);
            this.maxDatePago = intervaloFecha(1);
            this.minDateIngreso = new Date();
            this.maxDateIngreso = new Date();

        } else if (numeroBanco.equals("00")) {
            this.minDatePago = intervaloFecha(0);
            this.maxDatePago = intervaloFecha(1);
            this.minDateIngreso = intervaloFecha(0);
            this.maxDateIngreso = intervaloFecha(0);
        } else {
            this.minDatePago = intervaloFecha(-100);
            this.maxDatePago = intervaloFecha(1);
            this.minDateIngreso = intervaloFecha(-10);
            this.maxDateIngreso = intervaloFecha(3);
        }

    }

    public boolean validaFecha(int menos, int mas, Date fecha) {
        long from = intervaloFecha(menos).getTime();  // From some date

        long to = intervaloFecha(mas).getTime();     // To Some Date

        long check = fecha.getTime();
        boolean rsProcede = false;

        if ((check - from) > 0 && (to - check) > 0) {
            rsProcede = true;
        }

        return rsProcede;
    }

    public Date intervaloFecha(int dias) {

        ObtenerFecha ob = new ObtenerFecha();
        return ob.intervaloFecha(dias);
    }

    public void anulaRecibo() {

    }

    ;

}
