/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package com.arrebol.taxiservicios.beans.admin;

import com.arrebol.taxiservicios.beans.TaxiGenericBean;
import com.arrebol.taxiservicios.controller.cobranza.CobranzaController;
import com.arrebol.taxiservicios.controller.predio.AbonoLoteController;
import com.arrebol.taxiservicios.controller.predio.CambiaLoteController;
import com.arrebol.taxiservicios.controller.predio.PredioController;
import com.arrebol.taxiservicios.model.enums.EstatusLote;
import com.arrebol.taxiservicios.model.enums.EstatusSolicitud;
import com.arrebol.taxiservicios.model.enums.GenericEnumType;
import com.arrebol.taxiservicios.model.enums.PeriodoPago;
import com.arrebol.taxiservicios.model.enums.TipoAbono;
import com.arrebol.taxiservicios.model.predio.AbonoLote;
import com.arrebol.taxiservicios.model.predio.Lote;
import com.arrebol.taxiservicios.model.predio.SolicitudTrasferenciaLote;
import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.List;
import javax.annotation.PostConstruct;
import javax.faces.application.FacesMessage;
import javax.faces.view.ViewScoped;
import javax.inject.Named;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 *
 * @author pc one
 */
@Named("aprobarTrasferenciaBean")
@ViewScoped
public class AprobarTrasferenciaBean extends TaxiGenericBean implements Serializable {

    private static final long serialVersionUID = -7284027390656669184L;
    final Logger logger = LogManager.getLogger(getClass());

    private CambiaLoteController cambiarLoteController;
    private PredioController predioController;
    private CobranzaController cobranzaController;
    private AbonoLoteController abonoLoteController;
    private List<SolicitudTrasferenciaLote> solcitudesList;
    private SolicitudTrasferenciaLote selectedSolicitud;
    private List<AbonoLote> abonoLoteList;
    private Boolean print;
    private Boolean pagoExtra;
    private Double actualizarPago;

    @PostConstruct
    public void init() {
        logger.info("init aprobarTrasferenciaBean");
        try {
            setCambiaLoteController(new CambiaLoteController());
            setSolcitudesList(getCambiaLoteController().fillAllSolicitudesTrasferenciaByLocation(getLoggedUser().getLocation()));
        } catch (Exception e) {
            logger.error("aprobarTrasferenciaBean init", e);
        }
    }

    public void aprobarTrasferencia() {
        logger.info("Trasfiriéndose al lote : ");
        try {
            if (getSelectedSolicitud().getLoteDestino().getCosto() > 0) {
                // se cancela la compra del lote de origen 
                cancelarComparaLote(getSelectedSolicitud().getLoteOrigen());
                // se compara el lote destino
                comprarLote(getSelectedSolicitud().getLoteDestino(), getSelectedSolicitud());
                // Se cambia es estatus de la solicitud
                setCambiaLoteController(new CambiaLoteController());
                getSelectedSolicitud().setEstatusSolicitud(EstatusSolicitud.APROBADO);
                getCambiaLoteController().addSolcitudTrasferencia(getSelectedSolicitud(), getLoggedUser(), false);
                //se actualiza la lista de solitudes
                setSolcitudesList(getCambiaLoteController().fillAllSolicitudesTrasferenciaByLocation(getLoggedUser().getLocation()));
                showMessage(FacesMessage.SEVERITY_INFO, "Trasferencia exitosa", "La trasferencia del lote se realizó correctamente");
                logger.info("La trasferencia del lote se realizó correctamente");
            } else {
                showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Asigne un consto mayor a 0 para el lote a trasferir para realizar la trasferencia");
            }
        } catch (Exception e) {
            logger.error("aprobarTrasferencia: " + e);
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar de trasferir el lote");
        }
    }

    public void rechazarTrasferencia() {
        try {
            setCambiaLoteController(new CambiaLoteController());
            getSelectedSolicitud().setEstatusSolicitud(EstatusSolicitud.CANCELADO);
            getCambiaLoteController().addSolcitudTrasferencia(getSelectedSolicitud(), getLoggedUser(), false);
            showMessage(FacesMessage.SEVERITY_INFO, "Rechazo exitoso", "Solitud rechazada correctamente");
            logger.info("aprobarTrasferenciaBean init");
        } catch (Exception e) {
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Error al rechazar la solicitud");
            logger.error("aprobarTrasferenciaBean init", e);
        }
    }

    private void cancelarComparaLote(Lote lote) {
        logger.info("Cancelando compradel lote: " + lote.getId());
        try {
            setCobranzaController(new CobranzaController());
            setPredioController(new PredioController());
            setAbonoLoteList(getCobranzaController().fillAbonoLoteByLote(lote));
            //Desactivando abonos lote
            for (AbonoLote abono : getAbonoLoteList()) {
                abono.setEstatusActivo(GenericEnumType.DISABLED);
                getCobranzaController().addAbonoLote(abono, getLoggedUser(), false);
            }
            //Actualizacion del estatus de lote
            lote.setEstatusLote(EstatusLote.DISPONIBLE);
            lote.setLastUpdatedOn(new Date());
            getPredioController().addLote(lote, getLoggedUser(), false);
            logger.info("La compra del lote fue cancelado correctamente: " + lote.getId());
        } catch (Exception e) {
            logger.error("cancelarCompra: " + e);
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar cancelar la trasferencia del lote");
        }
    }

    private void comprarLote(Lote lote, SolicitudTrasferenciaLote solicitud) {
        logger.info("Comprando lote: " + lote.getId());
        try {
            setPredioController(new PredioController());
            lote.setCliente(solicitud.getCliente());
            lote.setLastUpdatedBy(getLoggedUser());
            lote.setLastUpdatedOn(new Date());
            lote.setEstatusLote(EstatusLote.VENDIDO);
            lote.setPeriodoPago(solicitud.getPeriodoPago());
            lote.setDiaAPagar(solicitud.getFechaIncioPagos());
            lote.setPlazoMeses(solicitud.getNumeroPagos().toString());
            lote.setAnticipo(solicitud.getAnticipoTrasferencia());
            getPredioController().addLote(lote, getLoggedUser(), false);
            // Inicia el proceso de generación de abonos
            crearCorrida(lote, getSelectedSolicitud());
            logger.info("El lote fue comparado correctamente: " + lote.getId());
        } catch (IOException e) {
            logger.error("comprarLote: " + e);
            showMessage(FacesMessage.SEVERITY_ERROR, "Error", "Ocurrió un error al tratar cancelar la trasferencia del lote");
        }
    }

    private void crearCorrida(Lote lote, SolicitudTrasferenciaLote solicitud) throws IOException {
        logger.info("Creación de abonos");

        //GENERACIÓN DE FECHAS DE PAGO
        //Definición de la fecha de inicio y numero de pagos
        Calendar fechaInicial = Calendar.getInstance();
        fechaInicial.setTime(solicitud.getFechaIncioPagos());
        fechaInicial.add(Calendar.DATE, 1);

        //showMessage(FacesMessage.SEVERITY_FATAL, "Error", "Error al capturar el abono del dia (" + fechaInicial.getTime() + ")");
        int numeroPagos = solicitud.getNumeroPagos();
        //lista de fechas de pago
        List<Calendar> fechasDePago = new ArrayList<>();

        // pago extra
         Boolean valPagoExtra = false;
         if (solicitud.getMontoPagoExtra()!=null && solicitud.getMontoPagoExtra()>0.0) {
            valPagoExtra= true;
        }
        // pago extra                   
        Double montoPagoExtra = 0.0;
        int contadorPagosExtra = 0;        
        Double totalPagoExtra = 0.0;
        int mesPagoExtra = 0;
        int diaPagoExtra = 0;
        
        // se valida el perido de pago
        Boolean mensual;
        mensual = solicitud.getPeriodoPago() == PeriodoPago.MENSUAL;
        
        // se genera la lista de fechas
        if (valPagoExtra == true) {
            // se asigna el pago extra
            montoPagoExtra = solicitud.getMontoPagoExtra();
            // se extrae el dia y mes del pago extra
            Date fechaDate = solicitud.getFechaPagosExtra();
            Calendar calendar = Calendar.getInstance();
            calendar.setTime(fechaDate);
            calendar.add(Calendar.DATE, 1);
            mesPagoExtra = calendar.get(Calendar.MONTH);//int mesDeseado = Calendar.OCTOBER; // Mes deseado: octubre
            diaPagoExtra = calendar.get(Calendar.DAY_OF_MONTH);//int diaDeseado = 15; // Día deseado: 15  
            fechasDePago = generarFechasDePagoExtra(fechaInicial, numeroPagos, mensual, mesPagoExtra, diaPagoExtra);
            // Verifico cuantos pagos extra se daran       
            for (Calendar fecha : fechasDePago) {
                int mesFecha = fecha.get(Calendar.MONTH);
                int diaFecha = fecha.get(Calendar.DAY_OF_MONTH);
                if (mesFecha == mesPagoExtra && diaFecha == diaPagoExtra) {
                    contadorPagosExtra++;
                }
            }                        
        } else {
            fechasDePago = generarFechasDePago(fechaInicial, numeroPagos, mensual);
        }
                          
        // Total a pagar por pagos extra 
       totalPagoExtra = montoPagoExtra*contadorPagosExtra;
         
        // CALCULOS DE TOTALES 
        Double InteresMensualPago = lote.getCosto() * (lote.getManzana().getPredio().getInteresMensual() / 100);
        Double Intereses = InteresMensualPago * solicitud.getNumeroPagos();
        Double TotalAPagar = lote.getCosto() + Intereses;
        Double TotalCreadito = TotalAPagar + lote.getManzana().getPredio().getComisionMensual();
        //se extrae los anticipos previos en caso de haber dado alguno durante la reserva 
        setAbonoLoteController(new AbonoLoteController());
        List<AbonoLote> anticiposR = getAbonoLoteController().fillAbonoLoteByLoteAndTipoAbono(lote, TipoAbono.ANTICIPO);
        Double totalAnticipoR = 0.0;
        if (anticiposR != null) {
            for (AbonoLote anticipo : anticiposR) {
                totalAnticipoR = totalAnticipoR + anticipo.getPago();
            }
        }
        // se calcula el anticipo total
        Double totalAnticipo = solicitud.getAnticipoTrasferencia() + totalAnticipoR;
        Double TotalCreaditoA = TotalCreadito - totalAnticipo;
        Double pagoPorMes = (TotalCreaditoA - totalPagoExtra) / Integer.parseInt(lote.getPlazoMeses());

        //ACTUALIZACIÓN DEL LOS DATOS DEL LOTE 
        try {
            lote.setAnticipo(totalAnticipo);
            lote.setTotalAPagar(TotalCreadito);
            lote.setTotalPago(TotalCreaditoA);
            lote.setMensualidad(pagoPorMes);
            if (lote.getPeriodoPago().equals(PeriodoPago.QUINCENAL)) {
                Calendar fechaActual = (Calendar) Calendar.getInstance();
                if (fechaActual.get(Calendar.DAY_OF_MONTH) != 15) {
                    if (fechaActual.get(Calendar.DAY_OF_MONTH) < 15) {
                        fechaActual.set(Calendar.DAY_OF_MONTH, 15);
                    } else {
                        fechaActual.add(Calendar.MONTH, 1);
                        fechaActual.set(Calendar.DAY_OF_MONTH, 15);
                    }
                } else {
                    fechaActual.add(Calendar.MONTH, 1);
                    fechaActual.set(Calendar.DAY_OF_MONTH, fechaActual.getActualMaximum(Calendar.DAY_OF_MONTH));
                }
                lote.setDiaAPagar(fechaActual.getTime());
            }
            lote.setLastUpdatedBy(getLoggedUser());
            lote.setLastUpdatedOn(new Date());
            setPredioController(new PredioController());
            getPredioController().addLote(lote, getLoggedUser(), false);
        } catch (Exception e) {
            logger.error("Error al actualizar  los datos del pago en lote: " + e);
            showMessage(FacesMessage.SEVERITY_FATAL, "Error", "Error al actualizar  los datos del pago en lote");
        }

        //SE CREA UN PRIMER ABONO CON EL TOTAL DE LOS ANTICIPOS SI LOS HUBO 
        if (lote.getAnticipo() > 0) {
            try {
                Date fechaActual = new Date();
                Calendar calendar2 = Calendar.getInstance();
                calendar2.setTime(fechaActual);
                calendar2.add(Calendar.DAY_OF_YEAR, 1);
                Date fechaNueva = calendar2.getTime();
                AbonoLote anticipo = new AbonoLote();
                anticipo.setLote(lote);
                anticipo.setCliente(lote.getCliente());
                anticipo.setTipoAbono(TipoAbono.ANTICIPO);
                anticipo.setEstatusActivo(GenericEnumType.ENABLED);
                anticipo.setPagoEstatus(GenericEnumType.ENABLED);
                anticipo.setFechaAPagar(fechaNueva);
                anticipo.setPago(lote.getAnticipo());
                anticipo.setSaldoAnterior(TotalCreadito);
                anticipo.setSaldoNuevo(TotalCreaditoA);
                anticipo.setCreatedBy(getLoggedUser());
                anticipo.setCreatedOn(fechaNueva);
                anticipo.setLastUpdatedBy(getLoggedUser());
                anticipo.setLastUpdatedOn(fechaNueva);
                anticipo.setCantidadPagada(lote.getAnticipo() - totalAnticipoR < 0 ? 0.0 : lote.getAnticipo() - totalAnticipoR);
                anticipo.setMandadoPagado(0.0);
                anticipo.setMandadoPagar(0.0);
                anticipo.setCobranzaPagada(0.0);
                anticipo.setCobranzaPagar(0.0);
                getAbonoLoteController().addAbonoLote(anticipo, getLoggedUser());
            } catch (Exception e) {
                logger.error("Error al capturar el primer abono del tipo anticipo : " + e);
                showMessage(FacesMessage.SEVERITY_FATAL, "Error", "Error al capturar el anticipo ");
            }
        }

        // CREACIÓN DE PAGOS POR FECHA
        setActualizarPago(TotalCreaditoA);
        recorrerFechas(fechasDePago, lote, pagoPorMes, mesPagoExtra, diaPagoExtra, montoPagoExtra);
    }

    private void recorrerFechas(List<Calendar> fechas, Lote lote, Double pagoPorMes, int mesPagoExtra, int diaPagoExtra, Double montoPagoExtra) {
        logger.info("Insertando abonos por fecha");
        // Usamos Collections.sort() para ordenar la lista de fechas
        Collections.sort(fechas, new Comparator<Calendar>() {
            @Override
            public int compare(Calendar fecha1, Calendar fecha2) {
                // Comparamos las fechas usando el método compareTo()
                return fecha1.compareTo(fecha2);
            }
        });

        // recorre las fechas ordenadas
        for (Calendar fecha : fechas) {
            establecerHoraAMedianoche(fecha);
            try {
                setAbonoLoteController(new AbonoLoteController());
                AbonoLote abono = new AbonoLote();
                abono.setLote(lote);
                abono.setCliente(lote.getCliente());
                abono.setTipoAbono(TipoAbono.ABONO);
                abono.setEstatusActivo(GenericEnumType.ENABLED);
                abono.setPagoEstatus(GenericEnumType.DISABLED);
                abono.setFechaAPagar(fecha.getTime());
                abono.setSaldoAnterior(getActualizarPago());
                if (fecha.get(Calendar.MONTH) == mesPagoExtra && fecha.get(Calendar.DAY_OF_MONTH) == diaPagoExtra) {
                    abono.setPago(montoPagoExtra);
                    setActualizarPago(getActualizarPago() - montoPagoExtra);
                    abono.setSaldoNuevo(getActualizarPago());
                } else {
                    abono.setPago(pagoPorMes);
                    setActualizarPago(getActualizarPago() - pagoPorMes);
                    abono.setSaldoNuevo(getActualizarPago());
                }
                abono.setCreatedBy(getLoggedUser());
                abono.setCreatedOn(new Date());
                getAbonoLoteController().addAbonoLote(abono, getLoggedUser());
            } catch (Exception e) {
                logger.error("Error al capturar el abono del dia: (" + fecha + ") " + e);
                showMessage(FacesMessage.SEVERITY_FATAL, "Error", "Error al capturar el abono del dia (" + fecha + ")");
            }
        }
    }
    
    // Método para establecer la hora a medianoche (0:00) de un objeto Calendar
    private void establecerHoraAMedianoche(Calendar fecha) {
        fecha.set(Calendar.HOUR_OF_DAY, 0);
        fecha.set(Calendar.MINUTE, 0);
        fecha.set(Calendar.SECOND, 0);
        fecha.set(Calendar.MILLISECOND, 0);
    }

    private List<Calendar> generarFechasDePagoExtra(Calendar fechaInicial, int numeroPagos, Boolean mensual, int mesPagoExtra, int diaPagoExtra) {
        logger.info("Generación fechas con pago extra");
        //lista de fechas
        List<Calendar> fechasDePago = new ArrayList<>();

        fechasDePago.add(fechaInicial);
        Calendar fechaActual = (Calendar) fechaInicial.clone();
        //captura el dia de una fecha en caso de que no se encuntre en le mes siguinte 
        boolean detenerFecha = false;
        Calendar fechaDetenida = Calendar.getInstance();
        // almacena el estatus del pago extra
        boolean fechaDeseadaAgregada = false;

        int pagosGenerados = 0;
        // se verifica el tipo de pago
        if (mensual) {
            for (int i = 1; i < numeroPagos; i++) {
                // Verifica si el mes actual coincide con el mes deseado
                if (fechaActual.get(Calendar.MONTH) == mesPagoExtra) {
                    // Agrega un registro extra con la fecha específica
                    Calendar fechaExtra = Calendar.getInstance();
                    fechaExtra.set(fechaActual.get(Calendar.YEAR), mesPagoExtra, diaPagoExtra);
                    fechasDePago.add(fechaExtra);
                    fechaDeseadaAgregada = true;
                }

                Calendar fechaSiguiente = (Calendar) fechaActual.clone();
                fechaSiguiente.add(Calendar.MONTH, 1);
                if (detenerFecha == false) {
                    if (fechaActual.get(Calendar.DAY_OF_MONTH) > fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH)) {
                        detenerFecha = true;
                        fechaDetenida = (Calendar) fechaActual.clone();
                        fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH));
                    }
                } else {
                    if (fechaSiguiente.get(Calendar.DAY_OF_MONTH) <= fechaDetenida.get(Calendar.DAY_OF_MONTH)) {
                        detenerFecha = false;
                        fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaDetenida.get(Calendar.DAY_OF_MONTH));
                    } else {
                        fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH));
                    }
                }
                fechasDePago.add(fechaSiguiente);
                fechaActual = fechaSiguiente;
                pagosGenerados++;
            }

        } else {
              for (int i = 0; i < numeroPagos; ) {
                Calendar fechaSiguiente = (Calendar) fechaActual.clone();
                fechaSiguiente.set(Calendar.DAY_OF_MONTH, 15);
                fechasDePago.add(fechaSiguiente);
                i++;

                if (i < numeroPagos) {
                    fechaSiguiente = (Calendar) fechaActual.clone();
                    fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH));
                    fechasDePago.add(fechaSiguiente);
                    i++;
                }

                if (!fechaDeseadaAgregada) {
                    // Agrega la fecha extra con la fecha específica
                    Calendar fechaExtra = Calendar.getInstance();
                    fechaExtra.set(fechaActual.get(Calendar.YEAR), mesPagoExtra, diaPagoExtra);
                    fechasDePago.add(fechaExtra);
                    fechaDeseadaAgregada = true;
                }

                fechaActual.add(Calendar.MONTH, 1);
            }

            // Ordenar la lista de fechas de pago
            Collections.sort(fechasDePago);
        }

        // Si el número de pagos generado es menor que el número de pagos deseado y aún no se ha agregado la fecha deseada, la agregamos al final
        if (pagosGenerados <= numeroPagos && !fechaDeseadaAgregada) {
            Calendar fechaExtra = Calendar.getInstance();
            fechaExtra.set(fechaActual.get(Calendar.YEAR), mesPagoExtra, diaPagoExtra);
            fechasDePago.add(fechaExtra);
        }

        return fechasDePago;
    }

    private List<Calendar> generarFechasDePago(Calendar fechaInicial, int numeroPagos, Boolean mensual) {
        logger.info("Generación fechas");
        //lista de fechas
        List<Calendar> fechasDePago = new ArrayList<>();

        fechasDePago.add(fechaInicial);
        Calendar fechaActual = (Calendar) fechaInicial.clone();
        //captura el dia de una fecha en caso de que no se encuntre en le mes siguinte 
        boolean detenerFecha = false;
        Calendar fechaDetenida = Calendar.getInstance();

        if (mensual) {
            for (int i = 1; i < numeroPagos; i++) {
                Calendar fechaSiguiente = (Calendar) fechaActual.clone();
                fechaSiguiente.add(Calendar.MONTH, 1);
                if (detenerFecha == false) {
                    if (fechaActual.get(Calendar.DAY_OF_MONTH) > fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH)) {
                        detenerFecha = true;
                        fechaDetenida = (Calendar) fechaActual.clone();
                        fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH));
                    }
                } else {
                    if (fechaSiguiente.get(Calendar.DAY_OF_MONTH) <= fechaDetenida.get(Calendar.DAY_OF_MONTH)) {
                        detenerFecha = false;
                        fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaDetenida.get(Calendar.DAY_OF_MONTH));
                    } else {
                        fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH));
                    }
                }
                fechasDePago.add(fechaSiguiente);
                fechaActual = fechaSiguiente;
            }
        } else {
             for (int i = 0; i < numeroPagos; ) {
                Calendar fechaSiguiente = (Calendar) fechaActual.clone();
                fechaSiguiente.set(Calendar.DAY_OF_MONTH, 15);
                fechasDePago.add(fechaSiguiente);
                i++;

                if (i < numeroPagos) {
                    fechaSiguiente = (Calendar) fechaActual.clone();
                    fechaSiguiente.set(Calendar.DAY_OF_MONTH, fechaSiguiente.getActualMaximum(Calendar.DAY_OF_MONTH));
                    fechasDePago.add(fechaSiguiente);
                    i++;
                }
                fechaActual.add(Calendar.MONTH, 1);
            }
        }
        return fechasDePago;
    }

    public CambiaLoteController getCambiaLoteController() {
        return cambiarLoteController;
    }

    public void setCambiaLoteController(CambiaLoteController cambiarLoteController) {
        this.cambiarLoteController = cambiarLoteController;
    }

    public List<SolicitudTrasferenciaLote> getSolcitudesList() {
        return solcitudesList;
    }

    public void setSolcitudesList(List<SolicitudTrasferenciaLote> solcitudesList) {
        this.solcitudesList = solcitudesList;
    }

    public SolicitudTrasferenciaLote getSelectedSolicitud() {
        return selectedSolicitud;
    }

    public void setSelectedSolicitud(SolicitudTrasferenciaLote selectedSolicitud) {
        this.selectedSolicitud = selectedSolicitud;
    }

    public PredioController getPredioController() {
        return predioController;
    }

    public void setPredioController(PredioController predioController) {
        this.predioController = predioController;
    }

    public CobranzaController getCobranzaController() {
        return cobranzaController;
    }

    public void setCobranzaController(CobranzaController cobranzaController) {
        this.cobranzaController = cobranzaController;
    }

    public List<AbonoLote> getAbonoLoteList() {
        return abonoLoteList;
    }

    public void setAbonoLoteList(List<AbonoLote> abonoLoteList) {
        this.abonoLoteList = abonoLoteList;
    }

    public AbonoLoteController getAbonoLoteController() {
        return abonoLoteController;
    }

    public void setAbonoLoteController(AbonoLoteController abonoLoteController) {
        this.abonoLoteController = abonoLoteController;
    }

    public Boolean getPrint() {
        return print;
    }

    public void setPrint(Boolean print) {
        this.print = print;
    }

    public Boolean getPagoExtra() {
        return pagoExtra;
    }

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

    public Double getActualizarPago() {
        return actualizarPago;
    }

    public void setActualizarPago(Double actualizarPago) {
        this.actualizarPago = actualizarPago;
    }

}
