package main_package;

import java.io.Serializable;
import java.time.Instant;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.Comparator;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import javax.servlet.http.HttpSession;

import org.apache.poi.ss.formula.functions.Na;

import com.itextpdf.text.log.SysoCounter;

import natch_package.EnachTransactionSummaryKJ.PaymentStatusResponse;

//
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;

@ManagedBean(name = "paymentsFromMandate")
@ViewScoped
public class paymentsFromMandateBean implements Serializable {

    private static final long serialVersionUID = 5L;
    private static final String TIME_ZONE = "Asia/Kolkata";


    private String viewType = "ALL";
    private String datePreset = "THIS_WEEK";

    private Date fromDate;
    private Date toDate;

    // BRANCH / EMPLOYEE
    private int selectedBranchId = -1;
    private String selectedEmpCode = "all"; 
    private int userBranchId;
    private String branchUserId;

    private List<SelectItem> branchList = new ArrayList<SelectItem>();
    ArrayList<SelectItem> employeeList = new ArrayList<SelectItem>();
    private boolean showDateList = false;

    // TABLE

    ArrayList<NachMandateData> activeSubscriptions =new ArrayList<NachMandateData>();

    // DATABASE

    private DataBaseMethods dbm = new DataBaseMethods();
    private DataBaseMethodTaheer dbmt = new DataBaseMethodTaheer();
    private DataBaseMethodsNaman dbn = new DataBaseMethodsNaman();


	 public paymentsFromMandateBean() {
	     try {
	         HttpSession ss = (HttpSession) FacesContext.getCurrentInstance()
	                 .getExternalContext().getSession(true);
	
	         // ----------------------------------------------------
	         // USER BRANCH
	         // ----------------------------------------------------
	         if (ss.getAttribute("branchId") != null) {
	             Object branchObj = ss.getAttribute("branchId");
	             if (branchObj instanceof Integer) {
	                 userBranchId = ((Integer) branchObj).intValue();
	             } else {
	                 try {
	                     userBranchId = Integer.parseInt(branchObj.toString());
	                 } catch (Exception e) {
	                     userBranchId = -1;
	                 }
	             }
	         }
	
	         // ----------------------------------------------------
	         // USER ID
	         // ----------------------------------------------------
	         Object branchUserObj = ss.getAttribute("branchUserId");
	         branchUserId = branchUserObj != null ? branchUserObj.toString() : "";
	
	         // ----------------------------------------------------
	         // BRANCH LIST
	         // ----------------------------------------------------
	         try (Connection conn = DataBaseConnection.JAVAConnection()) {
	             branchList = dbm.branchList(branchUserId, conn);
	         } catch (Exception e) {
	             e.printStackTrace();
	         }
	
	         // ----------------------------------------------------
	         // DEFAULT SELECTED BRANCH & EMPLOYEES
	         // ----------------------------------------------------
	         selectedBranchId = userBranchId;
	         loadEmployeesForBranch();
	
	         // ----------------------------------------------------
	         // DEFAULT DATE & INITIAL LOAD
	         // ----------------------------------------------------
	         applyDatePresetWithoutFetch();
	        // fetchPaymentList();
	
	     } catch (Exception e) {
	         e.printStackTrace();
	     }
	 }


   
 

	 private void loadEmployeesForBranch() {
	     selectedEmpCode = "all";
	     employeeList = dbn.employeeList(selectedBranchId);
	 }

 	 // MAIN 
	 public void fetchPaymentList() {
		 System.out.println("selectedEmpCode:"+selectedEmpCode);
	     Connection conn=DataBaseConnection.JAVAConnection();
	     SimpleDateFormat inputTsFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	     SimpleDateFormat displaySdf = new SimpleDateFormat("dd-MM-yyyy HH:mm");		 
	     activeSubscriptions = fetchAllActiveCashfreeSubscriptions(conn,fromDate,toDate);
	     
	     
	  
	  // 2. Sort the list from newest to oldest, handling nulls properly
	     DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yyyy");

	     activeSubscriptions.sort(Comparator.comparing(
	         (NachMandateData data) -> {
	             String timeStr = data.getTime();
	             if (timeStr == null || timeStr.trim().isEmpty()) {
	                 return null;
	             }
	             return LocalDate.parse(timeStr.trim(), formatter);
	         },
	         Comparator.nullsLast(Comparator.naturalOrder())
	     ).reversed());	     
	 }


	 public ArrayList<NachMandateData> fetchAllActiveCashfreeSubscriptions(Connection conn, Date fromDate, Date toDate) {
		    StringBuilder queryBuilder = new StringBuilder(
		        "SELECT s.subscription_id, s.plan_type, s.loan_no, s.rd_connected, s.rd_number, "
		        + "s.customer_name, s.customer_phone, s.customer_email, s.authorization_reference, "
		        + "s.subscription_first_charge_time, s.subscription_expiry_time, "
		        + "s.plan_interval_type, s.plan_intervals, s.plan_max_cycles, s.plan_recurring_amount "
		        + "FROM subscriptions_overview s "
		        + "LEFT JOIN personalloan pl ON s.loan_no = pl.loanNo AND s.loan_no LIKE 'PL%' "
		        + "LEFT JOIN secure_loan sl ON s.loan_no = sl.loanNo AND s.loan_no LIKE 'SL%' "
		        + "LEFT JOIN grouploan gl ON s.loan_no = gl.loanNo AND s.loan_no LIKE 'GL%' "
		        + "WHERE s.subscription_status = 'Active'"
		    );

		    boolean filterByEmp = selectedEmpCode != null && !"all".equalsIgnoreCase(selectedEmpCode.trim());
		    if (filterByEmp) {
		        queryBuilder.append(" AND ( "
		            + "(s.loan_no LIKE 'PL%' AND pl.dsacode = ?) OR "
		            + "(s.loan_no LIKE 'SL%' AND sl.dsacode = ?) OR "
		            + "(s.loan_no LIKE 'GL%' AND gl.dsacode = ?) "
		            + ")");
		    }

		    ArrayList<NachMandateData> masterList = new ArrayList<>();

		    try (PreparedStatement psmt = conn.prepareStatement(queryBuilder.toString())) {
		        if (filterByEmp) {
		            String empCodeVal = selectedEmpCode.trim();
		            psmt.setString(1, empCodeVal);
		            psmt.setString(2, empCodeVal);
		            psmt.setString(3, empCodeVal);
		        }
		        try (ResultSet rs = psmt.executeQuery()) {
		            while (rs.next()) {
		                String subscriptionId = rs.getString("subscription_id");
		                String planType = rs.getString("plan_type");
		                String loanNo = rs.getString("loan_no");
		                boolean rdConnected = rs.getBoolean("rd_connected");
		                String rdNumber = rs.getString("rd_number");
		                String customerName = rs.getString("customer_name");
		                String customerPhone = rs.getString("customer_phone");
		                String umrn = rs.getString("authorization_reference");

		                // Plan details
		                Timestamp firstChargeTime = rs.getTimestamp("subscription_first_charge_time");
		                Timestamp expiryTime = rs.getTimestamp("subscription_expiry_time");
		                String planIntervalType = rs.getString("plan_interval_type");
		                int planIntervals = rs.getInt("plan_intervals");
		                int planMaxCycles = rs.getInt("plan_max_cycles");
		                double planRecurringAmount = rs.getDouble("plan_recurring_amount");

		                ArrayList<NachMandateData> matchingEmis = new ArrayList<>();
		                if ("ON_DEMAND".equals(planType)) {
		                    matchingEmis = fetchEmisForLoanInRange(
		                        conn, fromDate, toDate, loanNo, planType, subscriptionId, rdConnected, rdNumber, customerName, customerPhone, umrn
		                    );
		                } else {
		                    matchingEmis = fetchEmisforPerodic(
		                        conn, fromDate, toDate, loanNo, planType, subscriptionId, rdConnected, rdNumber, customerName, customerPhone, umrn,
		                        firstChargeTime, expiryTime, planIntervalType, planIntervals, planMaxCycles, planRecurringAmount
		                    );
		                }

		                // Add all matching installment records to the master list
		                if (matchingEmis != null && !matchingEmis.isEmpty()) {
		                    masterList.addAll(matchingEmis);
		                }
		            }
		        }
		    } catch (SQLException e) {
		        e.printStackTrace();
		    }

		    return masterList;
		}
		private ArrayList<NachMandateData> fetchEmisforPerodic(Connection conn, Date fromDate2, Date toDate2, String loanNo,
			String planType, String subscriptionId, boolean rdConnected, String rdNumber, String customerName,
			String customerPhone, String umrn, Timestamp firstChargeTime, Timestamp expiryTime, String planIntervalType, int planIntervals, int planMaxCycles, double planRecurringAmount) {
		
			List<ScheduledEmi> se=calculatePeriodicEmiDates(firstChargeTime,expiryTime,fromDate2,toDate2,planIntervalType,planIntervals,planMaxCycles);
			
			
			
			
		return null;
	}

		

		private List<ScheduledEmi> calculatePeriodicEmiDates(
		        Timestamp firstChargeTime,
		        Timestamp expiryTime,
		        Date fromDate2,
		        Date toDate2,
		        String planIntervalType,
		        int planIntervals,
		        int planMaxCycles) {

		    if (firstChargeTime == null || expiryTime == null || fromDate2 == null || toDate2 == null ||
		            planIntervalType == null || planIntervals <= 0 || planMaxCycles <= 0 ||
		            fromDate2.after(toDate2) || toDate2.before(firstChargeTime) || fromDate2.after(expiryTime)) {
		        return new ArrayList<>();
		    }

		    int calendarField;
		    switch (planIntervalType.trim().toLowerCase(java.util.Locale.ROOT)) {
		        case "day":
		            calendarField = Calendar.DAY_OF_MONTH;
		            break;
		        case "week":
		            calendarField = Calendar.WEEK_OF_YEAR;
		            break;
		        case "month":
		            calendarField = Calendar.MONTH;
		            break;
		        case "year":
		            calendarField = Calendar.YEAR;
		            break;
		        default:
		            return new ArrayList<>();
		    }

		    // Set ending date to the very end of the day
		    Calendar toCal = Calendar.getInstance();
		    toCal.setTime(toDate2);
		    toCal.set(Calendar.HOUR_OF_DAY, 23);
		    toCal.set(Calendar.MINUTE, 59);
		    toCal.set(Calendar.SECOND, 59);
		    toCal.set(Calendar.MILLISECOND, 999);

		    Calendar paymentCal = Calendar.getInstance();
		    paymentCal.setTimeInMillis(firstChargeTime.getTime());

		    long expiryMillis = expiryTime.getTime();
		    long fromMillis = fromDate2.getTime();
		    long toMillis = toCal.getTimeInMillis();

		    List<ScheduledEmi> emiList = new ArrayList<>();

		    for (int i = 0; i < planMaxCycles; i++) {
		        long paymentMillis = paymentCal.getTimeInMillis();

		        // Stop checking if payment exceeds expiry or the requested window end
		        if (paymentMillis > expiryMillis || paymentMillis > toMillis) {
		            break;
		        }

		        // Collect if the payment falls within or after the 'from' date
		        if (paymentMillis >= fromMillis) {
		            LocalDate emiDate = Instant.ofEpochMilli(paymentMillis)
		                    .atZone(ZoneId.systemDefault())
		                    .toLocalDate();
		            
		            emiList.add(new ScheduledEmi(emiDate, "PENDING"));
		        }

		        paymentCal.add(calendarField, planIntervals);
		    }

		    return emiList;
		}


		public ArrayList<NachMandateData> fetchEmisForLoanInRange(
		        Connection conn, Date fromDate, Date toDate, String loanNo, String planType, 
		        String subscriptionId, boolean rdConnected, String rdNumber, String customerName, String customerPhone,String umrn) {
		    
		    ArrayList<NachMandateData> emiList = new ArrayList<>();
		    String loanType = resolveLoanType(loanNo);
		    if (loanType == null) {
		        System.err.println("Unknown loan type for loan no: " + loanNo);
		        return emiList;
		    }

		    try {
		        ArrayList<LoanInfo> scheduleList = new DataBaseMethods().loanInstallment(loanType, loanNo, conn);
		        if (scheduleList == null || scheduleList.isEmpty()) {
		            return emiList;
		        }

		        DataBaseMethodsNaman dbn = new DataBaseMethodsNaman();

		        for (LoanInfo info : scheduleList) {
		            // Check if installment date falls between range
		            if (!isMatchingbetweenDate(info.getStrInstlmntDate(), fromDate, toDate)) {
		                continue;
		            }

		            double emiAmount = info.getInstallAmount();
		            if (emiAmount <= 0) {
		                System.err.println("Invalid EMI amount: " + emiAmount);
		               
		            }
		            
		            double dueEmiAmount=info.getDueAmount();

		            double rdInstallmentAmount = 0.00;
		            if (rdConnected && rdNumber != null && !rdNumber.trim().isEmpty()) {
		                rdInstallmentAmount = dbn.getRdInstallmentAmount(rdNumber, conn);
		                if (rdInstallmentAmount <= 0) {
		                    System.err.println("Invalid RD installment amount for RD number: " + rdNumber);
		                  
		                }
		            }

		            double penaltyAmount = 0.00;
		            double totalAmount = emiAmount + penaltyAmount + rdInstallmentAmount;

		            //  Create a NEW NachMandateData instance for EVERY matching installment
		            NachMandateData data = new NachMandateData();
		            data.setSubscriptionId(subscriptionId);
		            data.setPlanType(planType);
		            data.setLoanNo(loanNo);
		            data.setRdConnected(rdConnected);
		            data.setRdNumber(rdNumber);
		            data.setCustomerName(customerName);
		            data.setMobile(customerPhone);
		            data.setDueEmiAmount(dueEmiAmount); 
		            data.setEmiAmount(emiAmount);
		            data.setAmount(totalAmount);
		            data.setRdAmount(rdInstallmentAmount);
		            data.setSno(info.getSno()); // Installment Serial Number
		            data.setTime(info.getStrInstlmntDate());
		            
		            PaymentStatusResponse ps = fetchPaymentStatus(conn, umrn,data.getTime(),planType);

		            data.setStatus(ps.getStatus());
		            if("Received".equalsIgnoreCase(ps.getStatus())) {
		            	data.setMerchantTrxnRefId(ps.getMerchantTrxnRefId());
		            	data.setDescription(ps.getDescription());
		            	data.setPaymentReceivedAt(ps.getReceivedAt());
		            }else {
		            	data.setDescription(ps.getDescription());

		            }
		            emiList.add(data);
		        }

		    } catch (Exception e) {
		        e.printStackTrace();
		    }

		    return emiList;
		}
		
		public PaymentStatusResponse fetchPaymentStatus(Connection conn, String umrn, String installmentDateStr,String planType) {
			PaymentStatusResponse ps = new PaymentStatusResponse();
			ps.setStatus("PENDING");
		   
		    
		    if ("ON_DEMAND".equalsIgnoreCase(planType)) {
		        // Handle ON_DEMAND specific status logic here if needed
		        
		    } else {
		    	if (installmentDateStr != null && !installmentDateStr.trim().isEmpty()) {
		    	    LocalDate installmentDate = parseInstallmentDateQuickly(installmentDateStr);
		    	    LocalDate today = LocalDate.now();
		    	    
		    	    if (installmentDate != null) {
		    	        if (installmentDate.isAfter(today)) {
		    	        	ps.setStatus("UPCOMING");
		    	        } else {
		    	        	java.util.Date utilDate = java.util.Date.from(installmentDate.atStartOfDay(ZoneId.systemDefault()).toInstant());
		    	        	 ps = isPaymentReceivedWithUmrn(conn, umrn, utilDate);
		    	        	return ps;
		    	        }
		    	    }
		    	}
		    }
		    return ps;
		}
		
		
		 public PaymentStatusResponse isPaymentReceivedWithUmrn(Connection conn, String umrn, Date date) {
		        PaymentStatusResponse response = new PaymentStatusResponse();

		        if (conn == null || umrn == null || date == null) {
		            response.setStatus("ERROR");
		            response.setMessage("Parameters must not be null.");
		            return response;
		        }

		        try {
		            ZoneId zoneId = ZoneId.of(TIME_ZONE);
		            LocalDate calculatedDate = date.toInstant().atZone(zoneId).toLocalDate();
		            LocalDate today = LocalDate.now(zoneId);

		            // 1. Future date check
		            if (calculatedDate.isAfter(today)) {
		                response.setStatus("Upcoming");
		                response.setMessage("Payment date is in the future.");
		                return response;
		            }

		            // 2. Fetch latest status record matching UMRN from database
		            String query = "SELECT merchant_trxn_ref_id, status, code, description, received_at " +
		                    "FROM nach_payments " +
		                    "WHERE umrn = ? " +
		                    "AND received_at >= ? " +
		                    "AND received_at < DATE_ADD(?, INTERVAL 3 DAY) " +
		                    "ORDER BY id DESC LIMIT 1";

		            try (PreparedStatement ps= conn.prepareStatement(query)) {
		                ps.setString(1, umrn.trim());
		                ps.setDate(2, new java.sql.Date(date.getTime()));
		                ps.setDate(3, new java.sql.Date(date.getTime()));

		                try (ResultSet rs = ps.executeQuery()) {
		                    if (rs.next()) {
		                        String rawDbStatus = rs.getString("status");
		                        String refId = rs.getString("merchant_trxn_ref_id");
		                        String code = rs.getString("code");
		                        String desc = rs.getString("description");
		                        String received_at=rs.getString("received_at");

		                        if (rawDbStatus != null && !rawDbStatus.trim().isEmpty()) {
		                            String cleanStatus = rawDbStatus.trim().toUpperCase();
		                            switch (cleanStatus) {
		                                case "SUCCESS":
		                                case "SUCCESSFUL":
		                                case "PAID":
		                                    response.setStatus("Received");
		                                    break;
		                                case "FAILED":
		                                case "FAILURE":
		                                case "REJECTED":
		                                case "CANCEL":
		                                case "CANCELLED":
		                                    response.setStatus("Failed");
		                                    break;
		                                case "PENDING":
		                                    response.setStatus("Pending");
		                                    break;
		                                default:
		                                    response.setStatus(rawDbStatus);
		                                    break;
		                            }
		                        } else {
		                            response.setStatus("Received");
		                        }

		                        response.setMerchantTrxnRefId(refId);
		                        response.setPaymentStatus(rawDbStatus);
		                        response.setCode(code);
		                        response.setDescription(desc);
		                        response.setReceivedAt(received_at);
		                    } else {
		                        // 3. Fallback if no clearing record exists in database
		                        LocalDate maxAllowedDate = calculatedDate.plusDays(2);
		                        if (today.isAfter(maxAllowedDate)) {
		                            response.setStatus("Failed");
		                            response.setMessage("No clearing record received within 2 days of schedule date.");
		                        } else {
		                            response.setStatus("Pending");
		                            response.setMessage("Awaiting NACH response file.");
		                        }
		                    }
		                }
		            }
		        } catch (Exception e) {
		            e.printStackTrace();
		            response.setStatus("ERROR");
		            response.setMessage("Processing error: " + e.getMessage());
		        }

		        return response;
		    }
		    
		    private LocalDate parseInstallmentDateQuickly(String dateStr) {
		        if (dateStr == null || dateStr.trim().isEmpty()) {
		            return null;
		        }
		        
		        DateTimeFormatter[] formatters = {
		            DateTimeFormatter.ofPattern("yyyy-MM-dd"),
		            DateTimeFormatter.ofPattern("dd/MM/yyyy"),
		            DateTimeFormatter.ofPattern("dd-MM-yyyy"),
		            DateTimeFormatter.ofPattern("yyyy/MM/dd")
		        };
		        
		        String trimmed = dateStr.trim();
		        for (DateTimeFormatter formatter : formatters) {
		            try {
		                return LocalDate.parse(trimmed, formatter);
		            } catch (DateTimeParseException e) {
		                // Ignore and try the next format pattern
		            }
		        }
		        
		        // Returns null if none of the patterns matched
		        return null;
		    }
		
	 
	 
		 private String resolveLoanType(String loanNo) {
			  
			 if (loanNo == null) return null;
			    
			    String value = loanNo.trim().toUpperCase();
			    if (value.startsWith("PL")) return "personalloan";
			    if (value.startsWith("SL")) return "secure_loan";
			    if (value.startsWith("GL")) return "grouploan";
			    
			    return null;
		}
		 
		 public boolean isMatchingbetweenDate(String installmentDateStr, Date fromDateStr, Date toDateStr) {
			    if (installmentDateStr == null || installmentDateStr.trim().isEmpty() || fromDateStr == null || toDateStr == null) {
			        return false;
			    }
			    
			    DateTimeFormatter[] formatters = {
			        DateTimeFormatter.ofPattern("yyyy-MM-dd"),
			        DateTimeFormatter.ofPattern("dd/MM/yyyy"),
			        DateTimeFormatter.ofPattern("dd-MM-yyyy"),
			        DateTimeFormatter.ofPattern("yyyy/MM/dd")
			    };
			    
			    LocalDate installmentDate = null;
			    String trimmedDate = installmentDateStr.trim();
			    
			    for (DateTimeFormatter formatter : formatters) {
			        try {
			            installmentDate = LocalDate.parse(trimmedDate, formatter);
			            break;
			        } catch (DateTimeParseException e) {
			            // Ignore and try next format
			        }
			    }
			    
			    if (installmentDate == null) {
			        return false;
			    }
			    
			    try {
			        LocalDate fromDate = fromDateStr.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
			        LocalDate toDate = toDateStr.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
			        
			        return !installmentDate.isBefore(fromDate) && !installmentDate.isAfter(toDate);
			    } catch (Exception e) {
			        e.printStackTrace();
			        return false;
			    }
			}

		 
		 // DATE PRESET WITHOUT DOUBLE FETCH

		 private void applyDatePresetWithoutFetch() {
		     Calendar cal = Calendar.getInstance();
		     cal.set(Calendar.HOUR_OF_DAY, 0);
		     cal.set(Calendar.MINUTE, 0);
		     cal.set(Calendar.SECOND, 0);
		     cal.set(Calendar.MILLISECOND, 0);
		
		     // --------------------------------------------------------
		     // TODAY
		     // --------------------------------------------------------
		     if ("TODAY".equalsIgnoreCase(datePreset)) {
		         fromDate = cal.getTime();
		         cal.set(Calendar.HOUR_OF_DAY, 23);
		         cal.set(Calendar.MINUTE, 59);
		         cal.set(Calendar.SECOND, 59);
		         cal.set(Calendar.MILLISECOND, 999);
		         toDate = cal.getTime();
		     }
		     // --------------------------------------------------------
		     // THIS WEEK
		     // --------------------------------------------------------
		     else if ("THIS_WEEK".equalsIgnoreCase(datePreset)) {
		         cal.set(Calendar.DAY_OF_WEEK, cal.getFirstDayOfWeek());
		         cal.set(Calendar.HOUR_OF_DAY, 0);
		         cal.set(Calendar.MINUTE, 0);
		         cal.set(Calendar.SECOND, 0);
		         cal.set(Calendar.MILLISECOND, 0);
		         fromDate = cal.getTime();
		
		         cal.add(Calendar.DAY_OF_WEEK, 6);
		         cal.set(Calendar.HOUR_OF_DAY, 23);
		         cal.set(Calendar.MINUTE, 59);
		         cal.set(Calendar.SECOND, 59);
		         cal.set(Calendar.MILLISECOND, 999);
		         toDate = cal.getTime();
		     }
		     // --------------------------------------------------------
		     // THIS MONTH
		     // --------------------------------------------------------
		     else if ("THIS_MONTH".equalsIgnoreCase(datePreset)) {
		         cal.set(Calendar.DAY_OF_MONTH, 1);
		         cal.set(Calendar.HOUR_OF_DAY, 0);
		         cal.set(Calendar.MINUTE, 0);
		         cal.set(Calendar.SECOND, 0);
		         cal.set(Calendar.MILLISECOND, 0);
		         fromDate = cal.getTime();
		
		         cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
		         cal.set(Calendar.HOUR_OF_DAY, 23);
		         cal.set(Calendar.MINUTE, 59);
		         cal.set(Calendar.SECOND, 59);
		         cal.set(Calendar.MILLISECOND, 999);
		         toDate = cal.getTime();
		     }
		 }
		 
		 // Getter and Settter
		public String getViewType() {
			return viewType;
		}


		public void setViewType(String viewType) {
			this.viewType = viewType;
		}


		public String getDatePreset() {
			return datePreset;
		}


		public void setDatePreset(String datePreset) {
			this.datePreset = datePreset;
		}


		public Date getFromDate() {
			return fromDate;
		}


		public void setFromDate(Date fromDate) {
			this.fromDate = fromDate;
		}


		public Date getToDate() {
			return toDate;
		}


		public void setToDate(Date toDate) {
			this.toDate = toDate;
		}


		public int getSelectedBranchId() {
			return selectedBranchId;
		}


		public void setSelectedBranchId(int selectedBranchId) {
			this.selectedBranchId = selectedBranchId;
		}


		public String getSelectedEmpCode() {
			return selectedEmpCode;
		}


		public void setSelectedEmpCode(String selectedEmpCode) {
			this.selectedEmpCode = selectedEmpCode;
		}


		public int getUserBranchId() {
			return userBranchId;
		}


		public void setUserBranchId(int userBranchId) {
			this.userBranchId = userBranchId;
		}


		public String getBranchUserId() {
			return branchUserId;
		}


		public void setBranchUserId(String branchUserId) {
			this.branchUserId = branchUserId;
		}


		public List<SelectItem> getBranchList() {
			return branchList;
		}


		public void setBranchList(List<SelectItem> branchList) {
			this.branchList = branchList;
		}


		public ArrayList<SelectItem> getEmployeeList() {
			return employeeList;
		}


		public void setEmployeeList(ArrayList<SelectItem> employeeList) {
			this.employeeList = employeeList;
		}


		public boolean isShowDateList() {
			return showDateList;
		}


		public void setShowDateList(boolean showDateList) {
			this.showDateList = showDateList;
		}


		public DataBaseMethods getDbm() {
			return dbm;
		}


		public void setDbm(DataBaseMethods dbm) {
			this.dbm = dbm;
		}


		public DataBaseMethodTaheer getDbmt() {
			return dbmt;
		}


		public void setDbmt(DataBaseMethodTaheer dbmt) {
			this.dbmt = dbmt;
		}


		public DataBaseMethodsNaman getDbn() {
			return dbn;
		}


		public void setDbn(DataBaseMethodsNaman dbn) {
			this.dbn = dbn;
		}





		public ArrayList<NachMandateData> getActiveSubscriptions() {
			return activeSubscriptions;
		}





		public void setActiveSubscriptions(ArrayList<NachMandateData> activeSubscriptions) {
			this.activeSubscriptions = activeSubscriptions;
		}
		 
		

public class ScheduledEmi {

    private LocalDate emiDate;
    private String status;

    public ScheduledEmi(LocalDate emiDate, String status) {
        this.emiDate = emiDate;
        this.status = status;
    }

    public LocalDate getEmiDate() {
        return emiDate;
    }

    public String getStatus() {
        return status;
    }
}
		 
		 
 
}