package natch_package;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.Serializable;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.UUID;

import javax.faces.application.FacesMessage;
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.primefaces.context.RequestContext;
import org.primefaces.json.JSONArray;
import org.primefaces.json.JSONObject;

import HdfcEmandate.RequestType;
import cashfree.LoanEmiSummary;
import main_package.DataBaseAutoCompAndDuplicate;
import main_package.DataBaseConnection;
import main_package.DataBaseMethods;
import main_package.DataBaseMethodsNaman;

@ManagedBean(name = "cfMandateBean")
@ViewScoped
public class GenerateCfMandateBean implements Serializable {

    private static final long serialVersionUID = 1L;

    private CashfreeDetails cashfreeDetails = new CashfreeDetails();
    private ArrayList<SelectItem> bankCodeList = new ArrayList<>();
    private ArrayList<SelectItem> planList = new ArrayList<>();
    private ArrayList<SubscriptionOverview> allSubscriptionsList = new ArrayList<>();
    private int activeStep = 0;	
    private boolean editBankMode = false;
    private BankDetailsBackup bankBackup;
    private String loanNo;
    private String shareHolderNo;
    private ArrayList<String> list;
    private ArrayList<SelectItem> loanNumList = new ArrayList<>();
    private ArrayList<SelectItem> rdList = new ArrayList<>();
    private boolean subscriptionForm = false;
    private String userId = null;   
    private boolean rd = false;
    private String customerRdNumber;
    
    

  
	// Dynamic / Inline Plan details
    private String planName;
    private String planType = "ON_DEMAND"; // PERIODIC or ON_DEMAND
    private Double planAmount;             // Periodic recurring amount
    private Double planMaxAmount,remainingDueAmount;          // Maximum debit limit
    private Integer planMaxCycles,remainingCycles;         // Max billing cycles
    private Integer planIntervals;      // e.g., 1
    private String planIntervalType; // DAY, WEEK, MONTH, YEAR
    private String planNote;

    private String key_id;
    private String key_secret;
    private boolean showOptionalBankDetails = false;
    
    private String paymentMethod = "all"; // Default to eNACH
    
    private boolean includeBankDetails = true; // Default state

    // Getter & Setter
    public boolean isIncludeBankDetails() {
        return includeBankDetails;
    }
    public void setIncludeBankDetails(boolean includeBankDetails) {
        this.includeBankDetails = includeBankDetails;
    }

    public void toggleBankDetailsFlag() {
        System.out.println("=== DEBUG: toggleBankDetailsFlag() called ===");
        System.out.println("DEBUG: Previous includeBankDetails state = " + this.includeBankDetails);

        // Toggle the state
        includeBankDetails = !includeBankDetails;
        
        System.out.println("DEBUG: New includeBankDetails state = " + this.includeBankDetails);

        if (includeBankDetails) {
            System.out.println("DEBUG: Executing cancelEditBankMode()");
            cancelEditBankMode();
        } else {
            System.out.println("DEBUG: Executing removeBankDeatils()");
            removeBankDeatils(); 
        }
        
        System.out.println("=== DEBUG: toggleBankDetailsFlag() finished ===");
    }
 // Getter and Setter
 public String getPaymentMethod() {
     return paymentMethod;
 }

 public void setPaymentMethod(String paymentMethod) {
	    this.paymentMethod = (paymentMethod != null) ? paymentMethod.toLowerCase() : null;
	}

 // Optional listener if you need custom server-side logic when the payment type changes
 public void onPaymentMethodChange() {
	 double pma=this.planMaxAmount;
     // If user switches to UPI Autopay, you can reset or clear bank fields if needed
     if ("UPI".equalsIgnoreCase(paymentMethod)) {
        this.planMaxAmount=planAmount;
        
     }else {
    	 this.planMaxAmount=pma;
    	
     }
 }

 // Getter and Setter
 public boolean isShowOptionalBankDetails() {
	 
     return showOptionalBankDetails;
 }
 

 public void setShowOptionalBankDetails(boolean showOptionalBankDetails) {
     this.showOptionalBankDetails = showOptionalBankDetails;
 }
    public GenerateCfMandateBean() {
        HttpSession ss = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
        if (ss != null) {
            userId = (String) ss.getAttribute("username");        
        }
        bankCodeList = new DataBaseMethods().fetchBankCodeByNpci();
     //   planList = allActivePlanList();
        allSubscriptionsList = new SubscriptionDAO().fetchAllSubscriptions();
    }
    
    public boolean isSearchVisible() {
        return !subscriptionForm;
    }

    public void fetchRdList() {
        if (shareHolderNo == null) {
            return;
        }

        rdList = new DataBaseMethods().fetchRdForNachByMemberId(shareHolderNo);

        if (rdList == null || rdList.isEmpty()) {
            rdList = new DataBaseMethods().fetchAllRdForNach();
            return;
        }

        if (cashfreeDetails == null) {
            return;
        }

        if (!rdList.isEmpty()) {
            SelectItem ss = rdList.get(0);
            String rdNumber = (String) ss.getValue();
            customerRdNumber = rdNumber;
        }
    }

    private String readStream(InputStream inputStream) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream, "UTF-8"));
        StringBuilder response = new StringBuilder();
        String line;
        while ((line = reader.readLine()) != null) {
            response.append(line);
        }
        reader.close();
        return response.toString();
    }
    
    public void submit() {
        FacesContext context = FacesContext.getCurrentInstance();

     // 1. VALIDATE CUSTOMER & BANK SECTION
        boolean hasBankCode = !isNullOrEmpty(cashfreeDetails.getCustomerBankCode());
        boolean hasBankIfsc = !isNullOrEmpty(cashfreeDetails.getCustomerBankIfsc());

        if("ENACH".equalsIgnoreCase(paymentMethod)) {
        	if (cashfreeDetails == null ||
                    isNullOrEmpty(cashfreeDetails.getCustomerName()) ||
                    isNullOrEmpty(cashfreeDetails.getCustomerMobile()) ||
                    isNullOrEmpty(cashfreeDetails.getCustomerEmail()) ||
                    isNullOrEmpty(cashfreeDetails.getCustomerBankAccountNumber()) ||
                    isNullOrEmpty(cashfreeDetails.getCustomerBankAccountType()) ||
                    (!hasBankCode && !hasBankIfsc)) { // Ensures at least ONE of Bank Code OR IFSC is present

                    this.editCustomer = true; // Auto-expand customer section if invalid
                    this.editBankMode = true; // Auto-expand bank section if invalid
 
                    context.addMessage(null, new FacesMessage(
                        FacesMessage.SEVERITY_ERROR, 
                        "Customer/Bank Details Incomplete", 
                        "Please ensure Name, Mobile, Email, Account No, Account Type, and either Bank Name or IFSC Code are provided."
                    ));
                    context.validationFailed();
                    return;
                }
        } 

        // Mobile Regex Validation (Ensure 10 digits)
        if (!cashfreeDetails.getCustomerMobile().matches("^\\d{10}$")) {
            this.editCustomer = true;
            context.addMessage(null, new FacesMessage(
                FacesMessage.SEVERITY_ERROR, 
                "Invalid Mobile Number", 
                "Mobile number must be exactly 10 digits."
            ));
            context.validationFailed();
            return;
        }
        

       //   2. VALIDATE PLAN SECTION
        if (isNullOrEmpty(planName) || 
            planAmount == null || planAmount <= 0 || 
            planMaxAmount == null || planMaxAmount <= 0 ||
            isNullOrEmpty(planIntervalType) || 
            planMaxCycles == null || planMaxCycles < 1) {

            this.editPlan = true; // Auto-expand plan section if invalid
            context.addMessage(null, new FacesMessage(
                FacesMessage.SEVERITY_ERROR, 
                "Plan Details Incomplete", 
                "Please ensure Plan Name, Amounts, Interval Type, and Max Cycles are correctly specified."
            ));
            context.validationFailed();
            return;
        }

        // 3. VALIDATE SCHEDULE & DATES SECTION
        if (cashfreeDetails.getSubscriptionFirstChargeTime() == null || 
            cashfreeDetails.getSubscriptionExpiryTime() == null) {

            this.editSchedule = true; // Auto-expand schedule section if invalid
            context.addMessage(null, new FacesMessage(
                FacesMessage.SEVERITY_ERROR, 
                "Schedule Incomplete", 
                "First Charge Date and Mandate Expiry Date are required."
            ));
            context.validationFailed();
            return;
        }
        
        

        // Validate First Charge Date vs Expiry Date Logic
        if (cashfreeDetails.getSubscriptionExpiryTime().before(cashfreeDetails.getSubscriptionFirstChargeTime())) {
            this.editSchedule = true;
            context.addMessage(null, new FacesMessage(
                FacesMessage.SEVERITY_ERROR, 
                "Invalid Schedule Dates", 
                "Mandate Expiry Date cannot be earlier than First Charge Date."
            ));
            context.validationFailed();
            return;
        }

        // Validate RD Selection if Linked
        if (Boolean.TRUE.equals(this.rd) && isNullOrEmpty(this.customerRdNumber)) {
            this.editSchedule = true;
            context.addMessage(null, new FacesMessage(
                FacesMessage.SEVERITY_ERROR, 
                "RD Account Required", 
                "Please select a valid RD Account number or uncheck RD Linking."
            ));
            context.validationFailed();
            return;
        }

        // 4. FETCH API CREDENTIALS & VALIDATE DB CONFIG
        fetchApiDetailsDB();
        boolean isValid = validateFields(key_id, key_secret);

        if (!isValid) { 
            context.addMessage(null, new FacesMessage(
                FacesMessage.SEVERITY_ERROR, 
                "Configuration Error",
                "Some problem while fetching API credentials from DB. If you use this service, please contact support."
            ));
            context.validationFailed();
            return;
        }

        // 5. EXECUTE CASHFREE E-MANDATE API CALL
        boolean status = sendSubscriptionRequest();
        if (status) {
            FacesMessage msg = new FacesMessage(FacesMessage.SEVERITY_INFO, "Success", "E-Mandate request submitted successfully!");
            context.addMessage(null, msg);
            allSubscriptionsList = new SubscriptionDAO().fetchAllSubscriptions();
            resetFlow();
            RequestContext.getCurrentInstance().addCallbackParam("mandateCreated", true);

            // Hide the dialog directly using the matching widgetVar name ('mandateWizardDlg')
            RequestContext.getCurrentInstance().execute("PF('mandateWizardDlg').hide();");
        } else {
            context.validationFailed(); // Keeps dialog open if API call fails
            RequestContext.getCurrentInstance().addCallbackParam("mandateCreated", false);
        }
    }

   
    
    public boolean validateFields(String key_id, String key_secret) {
        if (isNullOrEmpty(key_id)) return false;
        if (isNullOrEmpty(key_secret)) return false;
        return true;
    }
    
    private boolean isNullOrEmpty(String str) {
        return (str == null || str.trim().isEmpty());
    }
    
    public void fetchApiDetailsDB() {
        try (Connection conn = DataBaseConnection.JAVAConnection()) {
            String query = "SELECT * FROM api_keys WHERE provider_code = ? LIMIT 1";
            try (PreparedStatement psmt = conn.prepareStatement(query)) {
                psmt.setString(1, "cashfree-enatch");

                ResultSet rs = psmt.executeQuery();
                while (rs.next()) {
                    key_id = rs.getString("keyid");
                    key_secret = rs.getString("keySecret");
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void resetFlow() {
        // 1. Reset Customer & Bank Details Model
        cashfreeDetails = new CashfreeDetails();

        // 2. Reset UI View Flags & Step Controls
        showOptionalBankDetails = false;
        subscriptionForm = false;
        this.activeStep = 0; // Resets wizard tab back to Step 1 (Customer Info)

        // 3. Reset Loan / Shareholder Identifiers
        loanNo = null;
        shareHolderNo = null;
        customerRdNumber = null;
        rd = false;

        // 4. Clear Dropdown & Collection Lists (Safe null-checks)
        if (loanNumList != null) {
            loanNumList.clear();
        }
        if (rdList != null) {
            rdList.clear();
        }
        if (bankCodeList != null) {
            bankCodeList.clear();
        }

        // 5. Reset Dynamic Plan Parameters
        planName = null;
        planAmount = null;
        planMaxAmount = null;
        planIntervalType = "MONTH";
        planIntervals = 1;
        planMaxCycles = null;
        planNote = null;

        System.out.println("E-Mandate Form and Flow Successfully Reset!");
    }
    
    public List<String> completeText(String name) {
        list = new ArrayList<String>();
        HttpSession ss = (HttpSession) FacesContext.getCurrentInstance().getExternalContext().getSession(false);
        int branchId = (int) ss.getAttribute("branchId");        
        
        list = (ArrayList<String>) new DataBaseAutoCompAndDuplicate().loanListFromMemberList(branchId, name);
        System.out.println(list.size());
        return list;
    }

    public void checkTotalLoan() {
        loanNumList = new ArrayList<>();

        String input = shareHolderNo;
        shareHolderNo = extractShareholderNo(input);

        try (Connection conn = DataBaseConnection.JAVAConnection()) {

            // PERSONAL LOAN
            String queryPersonal = "SELECT loanNo FROM personalloan WHERE shareholderno = ? AND status = ? AND paidStatus = ?";
            try (PreparedStatement ps = conn.prepareStatement(queryPersonal)) {
                ps.setString(1, shareHolderNo);
                ps.setString(2, "Approve");
                ps.setString(3, "unpaid");	

                ResultSet rs = ps.executeQuery();
                while (rs.next()) {
                    loanNumList.add(new SelectItem(rs.getString("loanNo")));
                }
            }

            // SECURE LOAN
            String querySecure = "SELECT loanNo FROM secure_loan WHERE shareholderno = ? AND status = ? AND paidStatus = ?";
            try (PreparedStatement ps = conn.prepareStatement(querySecure)) {
                ps.setString(1, shareHolderNo);
                ps.setString(2, "Approve");
                ps.setString(3, "unpaid");	

                ResultSet rs = ps.executeQuery();
                while (rs.next()) {
                    loanNumList.add(new SelectItem(rs.getString("loanNo")));
                }
            }
            
            // SECURE LOAN
            String queryGroup = "SELECT sub_loan_no FROM grouploan WHERE teamLeader = ? AND status = ? AND paidStatus = ?";
            try (PreparedStatement ps = conn.prepareStatement(queryGroup)) {
                ps.setString(1, shareHolderNo);
                ps.setString(2, "Approve");
                ps.setString(3, "unpaid");	

                ResultSet rs = ps.executeQuery();
                while (rs.next()) {
                    loanNumList.add(new SelectItem(rs.getString("sub_loan_no")));
                }
            }

            // HANDLE CASES
            if (loanNumList.isEmpty()) {
                FacesContext.getCurrentInstance().addMessage(null,
                    new FacesMessage(FacesMessage.SEVERITY_ERROR,
                        "No Active Loan",
                        "Customer does not have any active loan"));

            } else if (loanNumList.size() == 1) {
                // AUTO FLOW
                loanNo = (String) loanNumList.get(0).getValue();
                fetchLoanData();
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    
    public void fetchLoanData() {
        if (loanNo == null || loanNo.trim().isEmpty()) {
            this.subscriptionForm = false;
            return;
        }

        this.loanNo = loanNo.trim();
        String table = determineTableName(this.loanNo);
        if (table == null) {
            this.subscriptionForm = false;
            return;
        }

        this.bankCodeList = (ArrayList<SelectItem>) fetchBankCodes();
        String originalShareHolderNo = prepareShareholderNo(this.shareHolderNo);

        try (Connection conn = DataBaseConnection.JAVAConnection()) {
            String query = buildLoanQuery(table);

            try (PreparedStatement ps = conn.prepareStatement(query)) {
                ps.setString(1, originalShareHolderNo);
                ps.setString(2, this.loanNo);
                ps.setString(3, "Approve");

                try (ResultSet rs = ps.executeQuery()) {
                    if (!rs.next()) {
                        this.subscriptionForm = false;
                        return;
                    }

                    processLoanResultSet(rs, conn, table, originalShareHolderNo);
                }
            }
        } catch (Exception e) {
            this.subscriptionForm = false;
        }
    }

    // -------------------------------------------------------------------------
    // Core Processors
    // -------------------------------------------------------------------------

    private String determineTableName(String loanNo) {
        if (loanNo.startsWith("PL-")) return "personalloan";
        if (loanNo.startsWith("SL-")) return "secure_loan";
        if (loanNo.startsWith("GL-")) return "grouploan";
        return null;
    }

    private List<SelectItem> fetchBankCodes() {
        try {
            return new DataBaseMethods().fetchBankCodeByNpci();
        } catch (Exception e) {
            return null;
        }
    }

    private String prepareShareholderNo(String rawShareHolderNo) {
        String extracted = extractShareholderNo(rawShareHolderNo);
        return isValidString(extracted) ? extracted.trim() : null;
    }

    
    private String buildLoanQuery(String table) {
        if ("personalloan".equalsIgnoreCase(table)) {
            return "SELECT l.shareholderno, l.loanNo, l.app_acc_no, l.app_bank_ifsc, l.app_bank_name, " +
                   "l.emi_due_date, l.frequency, l.terms, l.emi, l.loanAmount, " +
                   "s.first_applicantName, s.mobile, s.bank_accountNo, s.bank_ifsc, s.bank_name " +
                   "FROM personalloan l " +
                   "LEFT JOIN shareholder_info s ON l.shareholderno = s.shareholderno " +
                   "WHERE l.shareholderno = ? AND l.loanNo = ? AND l.status = ?";
        } else if ("secure_loan".equalsIgnoreCase(table)) {
            return "SELECT l.shareholderno, l.loanNo, l.app_acc_no, s.bank_ifsc AS app_bank_ifsc, l.app_bank_name, " +
                   "l.emi_due_date, l.frequency, l.terms, l.emi, l.loanAmount, " +
                   "s.first_applicantName, s.mobile, s.bank_accountNo, s.bank_ifsc, s.bank_name " +
                   "FROM secure_loan l " +
                   "LEFT JOIN shareholder_info s ON l.shareholderno = s.shareholderno " +
                   "WHERE l.shareholderno = ? AND l.loanNo = ? AND l.status = ?";
        } else {
            return "SELECT l.teamLeader AS shareholderno, l.sub_loan_no AS loanNo, l.app_acc_no, l.app_bank_name, " +
                   "l.emi_due_date, l.frequency, l.terms, l.emi, l.loanAmount, " +
                   "s.first_applicantName, s.mobile, s.bank_accountNo, s.bank_ifsc, s.bank_name " +
                   "FROM grouploan l " +
                   "LEFT JOIN shareholder_info s ON l.teamLeader = s.shareholderno " +
                   "WHERE l.teamLeader = ? AND l.sub_loan_no = ? AND l.status = ?";
        }
    }

    private void processLoanResultSet(ResultSet rs, Connection conn, String table, String originalShareHolderNo) throws Exception {
        String dbShareHolderNo = sanitizeString(rs.getString("shareholderno"));
        String fetchedLoanNo = sanitizeString(rs.getString("loanNo"));

        if (fetchedLoanNo != null) {
            this.loanNo = fetchedLoanNo;
        }

        cashfreeDetails.setCustomerName(rs.getString("first_applicantName"));
        cashfreeDetails.setCustomerMobile(rs.getString("mobile"));

        populateCustomerBankDetails(rs, conn, table, dbShareHolderNo, originalShareHolderNo);

        double emiValue = parseDoubleSafely(rs.getString("emi"), 0.0);
        int termsCount = Math.max(1, (int) parseDoubleSafely(rs.getString("terms"), 1.0));

        this.planAmount = emiValue;
        this.planMaxCycles = termsCount;
        this.planMaxAmount = parseDoubleSafely(rs.getString("loanAmount"), 0.0);

        String freq = sanitizeFrequency(rs.getString("frequency"));
        setPlanIntervals(freq);

        processSubscriptionDatesAndSummary(rs.getString("emi_due_date"), freq, termsCount, table, conn);
    }

    private void populateCustomerBankDetails(ResultSet rs, Connection conn, String table, String dbShareHolderNo, String originalShareHolderNo) throws SQLException {
        String rawLoanAcc = rs.getString("app_acc_no");
        String rawShAcc = rs.getString("bank_accountNo");
        String rawLoanBankName = rs.getString("app_bank_name");
        String rawShBankName = rs.getString("bank_name");

        String accountNo = getValidString(rawLoanAcc, rawShAcc);
        String lookupShareholder = isValidString(dbShareHolderNo) ? dbShareHolderNo : originalShareHolderNo;

        // Fallback query for shareholder account number and bank name if account number is missing
        if (accountNo == null && isValidString(lookupShareholder)) {
            String shareholderQuery = "SELECT bank_accountNo, bank_name FROM shareholder_info WHERE shareholderno = ? LIMIT 1";
            try (PreparedStatement shareholderPs = conn.prepareStatement(shareholderQuery)) {
                shareholderPs.setString(1, lookupShareholder);
                try (ResultSet shareholderRs = shareholderPs.executeQuery()) {
                    if (shareholderRs.next()) {
                        accountNo = getValidString(shareholderRs.getString("bank_accountNo"), null);
                        if (!isValidString(rawShBankName)) {
                            rawShBankName = shareholderRs.getString("bank_name");
                        }
                    }
                }
            }
        }

        cashfreeDetails.setCustomerBankAccountNumber(accountNo);

        // Bank Code Lookup based purely on Bank Name
        String dbBankName = getValidString(rawLoanBankName, rawShBankName);
        String matchedCode = resolveBankCodeByBankName(dbBankName);
        if (matchedCode != null) {
            cashfreeDetails.setCustomerBankCode(matchedCode);
        }
    }

    /**
     * Resolves bank code strictly using bank name matching.
     */
    private String resolveBankCodeByBankName(String dbBankName) {
        if (bankCodeList == null || !isValidString(dbBankName)) {
            return null;
        }

        for (SelectItem item : bankCodeList) {
            if (item == null || item.getLabel() == null) continue;
            
            String itemLabel = item.getLabel().trim();
            if (itemLabel.equalsIgnoreCase(dbBankName) || 
                itemLabel.toLowerCase().contains(dbBankName.toLowerCase()) || 
                dbBankName.toLowerCase().contains(itemLabel.toLowerCase())) {
                
                return item.getValue() != null ? item.getValue().toString().trim() : null;
            }
        }
        return null;
    }
    private void processSubscriptionDatesAndSummary(String startDateStr, String freq, int termsCount, String table, Connection conn) throws Exception {
        if (!isValidString(startDateStr)) return;

        startDateStr = startDateStr.trim().split(" ")[0];
        LocalDate originalDueDate;
        try {
            originalDueDate = LocalDate.parse(startDateStr);
        } catch (Exception e) {
            this.subscriptionForm = false;
            return;
        }

        LocalDate startDate = originalDueDate.isBefore(LocalDate.now()) ? LocalDate.now().plusDays(2) : originalDueDate;
        LocalDate expiryDate = calculateExpiryDate(originalDueDate, freq, termsCount).plusYears(2);

        if (expiryDate.isBefore(startDate)) {
            expiryDate = startDate.plusYears(2);
        }

        LocalDateTime firstChargeLdt = startDate.atTime(10, 0, 0);
        LocalDateTime expiryLdt = expiryDate.atTime(23, 59, 59);

        cashfreeDetails.setSubscriptionFirstChargeTime(Date.from(firstChargeLdt.atZone(ZoneId.systemDefault()).toInstant()));
        cashfreeDetails.setSubscriptionExpiryTime(Date.from(expiryLdt.atZone(ZoneId.systemDefault()).toInstant()));

        LoanEmiSummary summary = new DataBaseMethodsNaman().getLoanEmiSummary(table, loanNo, conn);
        this.remainingDueAmount = summary.getTotalDueAmount();
        this.remainingCycles = summary.getPendingEmi();
        this.planName = generateAutoPlanName();
    }

    // -------------------------------------------------------------------------
    // Helper Utilities
    // -------------------------------------------------------------------------

    private String resolveBankCode(String bankCode, String dbBankName) {
        if (bankCodeList == null) return null;

        if (isValidString(bankCode)) {
            for (SelectItem item : bankCodeList) {
                if (item != null && item.getValue() != null && item.getValue().toString().trim().equalsIgnoreCase(bankCode)) {
                    return item.getValue().toString().trim();
                }
            }
        }

        if (isValidString(dbBankName)) {
            for (SelectItem item : bankCodeList) {
                if (item == null || item.getLabel() == null) continue;
                String itemLabel = item.getLabel().trim();
                if (itemLabel.equalsIgnoreCase(dbBankName) || 
                    itemLabel.toLowerCase().contains(dbBankName.toLowerCase()) || 
                    dbBankName.toLowerCase().contains(itemLabel.toLowerCase())) {
                    return item.getValue() != null ? item.getValue().toString().trim() : null;
                }
            }
        }
        return null;
    }

    private void setPlanIntervals(String freq) {
        if (freq == null) {
            this.planIntervalType = "MONTH";
            this.planIntervals = 1;
            return;
        }
        switch (freq) {
            case "365": this.planIntervalType = "DAY";   this.planIntervals = 1;  break;
            case "52":  this.planIntervalType = "WEEK";  this.planIntervals = 1;  break;
            case "36":  this.planIntervalType = "DAY";   this.planIntervals = 10; break;
            case "26":  this.planIntervalType = "WEEK";  this.planIntervals = 2;  break;
            case "24":  this.planIntervalType = "DAY";   this.planIntervals = 15; break;
            case "13":  this.planIntervalType = "WEEK";  this.planIntervals = 4;  break;
            case "12":  this.planIntervalType = "MONTH"; this.planIntervals = 1;  break;
            case "4":   this.planIntervalType = "MONTH"; this.planIntervals = 3;  break;
            case "2":   this.planIntervalType = "MONTH"; this.planIntervals = 6;  break;
            case "1":   this.planIntervalType = "YEAR";  this.planIntervals = 1;  break;
            default:    this.planIntervalType = "MONTH"; this.planIntervals = 1;  break;
        }
    }

    private LocalDate calculateExpiryDate(LocalDate baseDate, String freq, int termsCount) {
        String switchFreq = (freq != null) ? freq : "12";
        switch (switchFreq) {
            case "365": return baseDate.plusDays(termsCount);
            case "52":  return baseDate.plusWeeks(termsCount);
            case "36":  return baseDate.plusDays(termsCount * 10L);
            case "26":  return baseDate.plusWeeks(termsCount * 2L);
            case "24":  return baseDate.plusDays(termsCount * 15L);
            case "13":  return baseDate.plusWeeks(termsCount * 4L);
            case "12":  return baseDate.plusMonths(termsCount);
            case "4":   return baseDate.plusMonths(termsCount * 3L);
            case "2":   return baseDate.plusMonths(termsCount * 6L);
            case "1":   return baseDate.plusYears(termsCount);
            default:    return baseDate.plusMonths(termsCount);
        }
    }

    private boolean isValidString(String str) {
        return str != null && !str.trim().isEmpty() && !"null".equalsIgnoreCase(str.trim());
    }

    private String sanitizeString(String str) {
        return isValidString(str) ? str.trim() : null;
    }

    private String getValidString(String primary, String secondary) {
        if (isValidString(primary)) return primary.trim();
        if (isValidString(secondary)) return secondary.trim();
        return null;
    }

    private String sanitizeFrequency(String freq) {
        if (freq == null) return null;
        freq = freq.trim();
        return freq.endsWith(".0") ? freq.substring(0, freq.length() - 2) : freq;
    }

    private double parseDoubleSafely(String value, double defaultValue) {
        if (!isValidString(value)) return defaultValue;
        try {
            return Double.parseDouble(value.trim());
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }
   
    

    private boolean isInvalidString(String str) {
        return str == null || str.trim().isEmpty() || "null".equalsIgnoreCase(str.trim());
    }

  

    private String findBankCodeByBankName(String dbBankName) {
        for (SelectItem item : bankCodeList) {
            if (item == null || item.getLabel() == null) continue;
            String itemLabel = item.getLabel().trim();
            if (itemLabel.equalsIgnoreCase(dbBankName) || 
                itemLabel.toLowerCase().contains(dbBankName.toLowerCase()) || 
                dbBankName.toLowerCase().contains(itemLabel.toLowerCase())) {
                return item.getValue() != null ? item.getValue().toString().trim() : null;
            }
        }
        return null;
    }
    
   
    
    public String getBankCodeFromIFSC(String ifsc) {
        if (ifsc == null || ifsc.length() < 4) {
            return null;
        }
        return ifsc.substring(0, 4).toUpperCase();
    }

    public void fetchSubcriptonData(String Sub_id) {
        new SubscriptionDAO().fetchsubscriptionByID(Sub_id);
    }
    
    private String extractShareholderNo(String input) {
        if (input != null && input.contains("/")) {
            return input.substring(0, input.indexOf('/')).trim();
        }
        return input != null ? input.trim() : null;
    }

    public String generateUniqueSubscriptionId() {
        String timestamp = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd_HHmmss"));
        String randomPart = UUID.randomUUID().toString().replaceAll("-", "").substring(0, 8);
        String subscriptionId = "SUB_" + timestamp + "_" + randomPart;

        if (subscriptionId.length() > 40) {
            subscriptionId = subscriptionId.substring(0, 40);
        }

        return subscriptionId;
    }

    public String generateRequestId() {
        return "REQ-" + UUID.randomUUID().toString();
    }

    public String generateIdempotencyKey() {
        return UUID.randomUUID().toString();
    }
    
    private boolean sendSubscriptionRequest() {
        boolean status = false;
        String subscriptionId = generateUniqueSubscriptionId();
        
        HttpURLConnection connection = null;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssXXX");
        String expiryTime = sdf.format(cashfreeDetails.getSubscriptionExpiryTime());
        String firstChargeTime = sdf.format(cashfreeDetails.getSubscriptionFirstChargeTime());
        
        if (cashfreeDetails.getCustomerBankAccountHolderName() == null || cashfreeDetails.getCustomerBankAccountHolderName().trim().isEmpty()) {
            cashfreeDetails.setCustomerBankAccountHolderName(cashfreeDetails.getCustomerName());
        }

        try {
            String apiUrl = "https://api.cashfree.com/pg/subscriptions";
            
            // Create the main JSON body
            JSONObject jsonBody = new JSONObject();
            jsonBody.put("subscription_id", subscriptionId);

            // CUSTOMER DETAILS 
            JSONObject customerDetails = new JSONObject();
            customerDetails.put("customer_name", cashfreeDetails.getCustomerName());
            customerDetails.put("customer_email", cashfreeDetails.getCustomerEmail());
            customerDetails.put("customer_phone", cashfreeDetails.getCustomerMobile());
            customerDetails.put("customer_bank_account_holder_name", cashfreeDetails.getCustomerBankAccountHolderName());
            customerDetails.put("customer_bank_account_number", cashfreeDetails.getCustomerBankAccountNumber());
            customerDetails.put("customer_bank_code", cashfreeDetails.getCustomerBankCode());
            customerDetails.put("customer_bank_account_type", cashfreeDetails.getCustomerBankAccountType());
            jsonBody.put("customer_details", customerDetails);

            // PLAN DETAILS
            JSONObject planDetails = new JSONObject();
           
                // 2. Pass inline plan parameters if creating a dynamic plan
                planDetails.put("plan_name", this.planName);
                planDetails.put("plan_type", this.planType);
                planDetails.put("plan_max_amount", this.planMaxAmount);
                planDetails.put("plan_currency", "INR");
                if (this.planNote != null && !this.planNote.trim().isEmpty()) {
                    planDetails.put("plan_note", this.planNote);
                }

            // Attach plan_details to the main request body
            jsonBody.put("plan_details", planDetails);
            

            // Authorization DETAILS
            JSONObject authorizationDetails = new JSONObject();
            authorizationDetails.put("authorization_amount", 1);
            authorizationDetails.put("authorization_amount_refund", true);
            JSONArray paymentMethods = new JSONArray();
            if(paymentMethod.equalsIgnoreCase("all")) {
                paymentMethods.put("enach");
            	paymentMethods.put("upi");
            }else {
            paymentMethods.put(paymentMethod);
            }
           
            authorizationDetails.put("payment_methods", paymentMethods);
            jsonBody.put("authorization_details", authorizationDetails);

            // SUBSCRIPTION META 
            JSONObject subscriptionMeta = new JSONObject();
            JSONArray channels = new JSONArray();
            channels.put("EMAIL");
            channels.put("SMS");
            subscriptionMeta.put("notification_channel", channels);

            jsonBody.put("subscription_meta", subscriptionMeta);

            // SUBSCRIPTION TIMING 
            jsonBody.put("subscription_expiry_time", expiryTime);
         //   jsonBody.put("subscription_first_charge_time", firstChargeTime);

            // SUBSCRIPTION TAGS 
            JSONObject subscriptionTags = new JSONObject();
            subscriptionTags.put("psp_note", "subscription payment");
            subscriptionTags.put("key2", "value2");
            jsonBody.put("subscription_tags", subscriptionTags);

            URL url = new URL(apiUrl);
            connection = (HttpURLConnection) url.openConnection();

            connection.setRequestMethod("POST");
            connection.setRequestProperty("Content-Type", "application/json");
            connection.setRequestProperty("x-api-version", "2025-01-01");
            connection.setRequestProperty("x-client-id", key_id);
            connection.setRequestProperty("x-client-secret", key_secret);
            connection.setRequestProperty("x-request-id", generateRequestId());
            connection.setRequestProperty("x-idempotency-key", generateIdempotencyKey());

            connection.setDoOutput(true);

            // Send JSON payload
            OutputStream os = connection.getOutputStream();
            os.write(jsonBody.toString().getBytes(StandardCharsets.UTF_8));
            os.flush();
            os.close();
            
            System.out.println("REQUEST"+jsonBody.toString());
            int responseCode = connection.getResponseCode();
            
            if (responseCode == 200) {
                String response = readStream(connection.getInputStream());
                System.out.println(response);
                SubscriptionSaver.insertSubscription(response, userId, loanNo, rd, customerRdNumber);  
                resetFlow();
                return true;
            } else {
                String errorResponse = readStream(connection.getErrorStream());
                System.out.println("Response Body: " + errorResponse);
                JSONObject errorJson = new JSONObject(errorResponse);

                String message = errorJson.optString("message");
                String code = errorJson.optString("code");
                String type = errorJson.optString("type");
                String help = errorJson.optString("help", null);
                
                FacesContext.getCurrentInstance().addMessage(null,
                        new FacesMessage(FacesMessage.SEVERITY_ERROR,
                                "Plan Creation Failed. " + message, null));

                return false;
            }
            
        } catch (Exception e) {
            e.printStackTrace();
        }
        return status;
    }
    
    

    public ArrayList<SelectItem> allActivePlanList() {
        ArrayList<SelectItem> tempList = new ArrayList<>();

        String query = "SELECT plan_id, plan_name, plan_note FROM nach_plans WHERE plan_status = 'ACTIVE' ORDER BY id DESC";

        try (Connection conn = DataBaseConnection.JAVAConnection();
             PreparedStatement psmt = conn.prepareStatement(query);
             ResultSet rs = psmt.executeQuery()) {
            
            while (rs.next()) {
                String planId = rs.getString("plan_id");
                String planNote = rs.getString("plan_note");
                if (planNote == null || planNote.trim().isEmpty()) {
                    planNote = "No note available";
                }

                String planName = rs.getString("plan_name") + " (Note: " + planNote + ")";
                tempList.add(new SelectItem(planId, planName));
            }

        } catch (Exception e) {
            e.printStackTrace();
        }

        return tempList;
    }

    // ================= GETTERS AND SETTERS =================

    public CashfreeDetails getCashfreeDetails() {
        return cashfreeDetails;
    }

    public void setCashfreeDetails(CashfreeDetails cashfreeDetails) {
        this.cashfreeDetails = cashfreeDetails;
    }

    public ArrayList<SelectItem> getBankCodeList() {
        return bankCodeList;
    }

    public void setBankCodeList(ArrayList<SelectItem> bankCodeList) {
        this.bankCodeList = bankCodeList;
    }

    public ArrayList<SelectItem> getPlanList() {
        return planList;
    }

    public void setPlanList(ArrayList<SelectItem> planList) {
        this.planList = planList;
    }

    public ArrayList<SubscriptionOverview> getAllSubscriptionsList() {
        return allSubscriptionsList;
    }

    public void setAllSubscriptionsList(ArrayList<SubscriptionOverview> allSubscriptionsList) {
        this.allSubscriptionsList = allSubscriptionsList;
    }

    public String getLoanNo() {
        return loanNo;
    }

    public void setLoanNo(String loanNo) {
        this.loanNo = loanNo;
    }

    public String getShareHolderNo() {
        return shareHolderNo;
    }

    public void setShareHolderNo(String shareHolderNo) {
        this.shareHolderNo = shareHolderNo;
    }

    public ArrayList<SelectItem> getLoanNumList() {
        return loanNumList;
    }

    public void setLoanNumList(ArrayList<SelectItem> loanNumList) {
        this.loanNumList = loanNumList;
    }

    public boolean isSubscriptionForm() {
        return subscriptionForm;
    }

    public void setSubscriptionForm(boolean subscriptionForm) {
        this.subscriptionForm = subscriptionForm;
    }

    public ArrayList<SelectItem> getRdList() {
        return rdList;
    }

    public void setRdList(ArrayList<SelectItem> rdList) {
        this.rdList = rdList;
    }

    public boolean isRd() {
        return rd;
    }

    public void setRd(boolean rd) {
        this.rd = rd;
    }

    public String getCustomerRdNumber() {
        return customerRdNumber;
    }

    public void setCustomerRdNumber(String customerRdNumber) {
        this.customerRdNumber = customerRdNumber;
    }

    public String getPlanName() {
        return planName;
    }

    public void setPlanName(String planName) {
        this.planName = planName;
    }

    public String getPlanType() {
        return planType;
    }

    public void setPlanType(String planType) {
        this.planType = planType;
    }

    public Double getPlanAmount() {
        return planAmount;
    }

    public void setPlanAmount(Double planAmount) {
        this.planAmount = planAmount;
    }

    public Double getPlanMaxAmount() {
        return planMaxAmount;
    }

    public void setPlanMaxAmount(Double planMaxAmount) {
        this.planMaxAmount = planMaxAmount;
    }

    public Integer getPlanMaxCycles() {
        return planMaxCycles;
    }

    public void setPlanMaxCycles(Integer planMaxCycles) {
        this.planMaxCycles = planMaxCycles;
    }

    public Integer getPlanIntervals() {
        return planIntervals;
    }

    public void setPlanIntervals(Integer planIntervals) {
        this.planIntervals = planIntervals;
    }

    public String getPlanIntervalType() {
        return planIntervalType;
    }

    public void setPlanIntervalType(String planIntervalType) {
        this.planIntervalType = planIntervalType;
    }

    public String getPlanNote() {
        return planNote;
    }

    public void setPlanNote(String planNote) {
        this.planNote = planNote;
    }
    
    public int getActiveStep() {
        return activeStep;
    }

    public void setActiveStep(int activeStep) {
        this.activeStep = activeStep;
    }
    
    /**
     * Auto-generates a clean Plan Name based on available loan/customer details
     * or generates a random unique string if details are missing.
     */
    public String generateAutoPlanName() {
        // FIX: Change 0-0 to 0-9 so digits 1-9 aren't stripped out!
        String cleanLoan = (loanNo != null && !loanNo.trim().isEmpty()) 
                            ? loanNo.replaceAll("[^a-zA-Z0-9]", "") 
                            : null;
                            
        String currentMonthYear = LocalDateTime.now()
                                    .format(DateTimeFormatter.ofPattern("MMM_yyyy"))
                                    .toUpperCase();

        if (cleanLoan != null) {
            // Will output: PLAN_PL001000002_AUG_2026
            return "PLAN_" + cleanLoan + "_" + currentMonthYear;
        } else if (cashfreeDetails != null && cashfreeDetails.getCustomerName() != null && !cashfreeDetails.getCustomerName().trim().isEmpty()) {
            String cleanName = cashfreeDetails.getCustomerName().trim().replaceAll("\\s+", "_").toUpperCase();
            if (cleanName.length() > 15) {
                cleanName = cleanName.substring(0, 15);
            }
            return "PLAN_" + cleanName + "_" + currentMonthYear;
        } else {
            String randomCode = UUID.randomUUID().toString().substring(0, 8).toUpperCase();
            return "PLAN_" + randomCode;
        }
    
    }
    private boolean allowManualEdit = false; // Controls input field editability

    public boolean isAllowManualEdit() {
        return allowManualEdit;
    }

    public void setAllowManualEdit(boolean allowManualEdit) {
        this.allowManualEdit = allowManualEdit;
    }
    private boolean editCustomer = false;
    private boolean editPlan = false;
    private boolean editSchedule = false;

    // GETTERS & SETTERS
    public boolean isEditCustomer() { return editCustomer; }
    public void setEditCustomer(boolean editCustomer) { this.editCustomer = editCustomer; }

    public boolean isEditPlan() { return editPlan; }
    public void setEditPlan(boolean editPlan) { this.editPlan = editPlan; }

    public boolean isEditSchedule() { return editSchedule; }
    public void setEditSchedule(boolean editSchedule) { this.editSchedule = editSchedule; }

    /**
     * Call this inside fchLoanData() / checkTotalLoan() when opening the dialog.
     * Automatically opens edit mode for any section with missing/empty required fields.
     */
    public void evaluateInitialStates() {
        this.editCustomer = isNullOrEmpty(cashfreeDetails.getCustomerName()) ||
                            isNullOrEmpty(cashfreeDetails.getCustomerMobile()) ||
                            isNullOrEmpty(cashfreeDetails.getCustomerEmail()) ||
                            isNullOrEmpty(cashfreeDetails.getCustomerBankAccountNumber()) ||
                            isNullOrEmpty(cashfreeDetails.getCustomerBankCode());

        this.editPlan = isNullOrEmpty(planName) || planAmount == null || planAmount <= 0;

        this.editSchedule = cashfreeDetails.getSubscriptionFirstChargeTime() == null || 
                            cashfreeDetails.getSubscriptionExpiryTime() == null;
        
        if (cashfreeDetails.getCustomerBankAccountNumber() != null && !cashfreeDetails.getCustomerBankAccountNumber().trim().isEmpty()) {
  	        this.editBankMode = false;
  	    } else {
  	        this.editBankMode = true; // Auto-open edit mode if missing
  	    }
    }

  

    public void toggleEditCustomer() {
        this.editCustomer = !this.editCustomer;
    }

    public void toggleEditPlan() {
        this.editPlan = !this.editPlan;
    }

    public void toggleEditSchedule() {
        this.editSchedule = !this.editSchedule;
    }
    

 // SECTION 1 TOGGLE
    public void toggleCustomerSection() {
        if (this.editCustomer) {
            if (isNullOrEmpty(cashfreeDetails.getCustomerName()) ||
                isNullOrEmpty(cashfreeDetails.getCustomerMobile()) ||
                isNullOrEmpty(cashfreeDetails.getCustomerEmail()) ||
                isNullOrEmpty(cashfreeDetails.getCustomerBankAccountNumber()) ||
                isNullOrEmpty(cashfreeDetails.getCustomerBankCode())) {
                
                FacesContext context = FacesContext.getCurrentInstance();
                context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, 
                    "Validation Error", "Please complete all required customer fields."));
                context.validationFailed();
                return;
            }
        }
        this.editCustomer = !this.editCustomer;
    }

    public void togglePlanSection() {
        if (this.editPlan) {
            if (isNullOrEmpty(planName) || 
                planAmount == null || planAmount <= 0 || 
                planIntervals == null || planIntervals < 1 ||
                planMaxCycles == null || planMaxCycles < 1) {
                
                FacesContext context = FacesContext.getCurrentInstance();
                context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, 
                    "Validation Error", "Please enter valid Plan Name, Amount, Interval Count, and Terms."));
                context.validationFailed();
                return;
            }
        }
        this.editPlan = !this.editPlan;
    }

    public void toggleScheduleSection() {
        if (this.editSchedule) {
            if (cashfreeDetails.getSubscriptionFirstChargeTime() == null || 
                cashfreeDetails.getSubscriptionExpiryTime() == null) {
                
                FacesContext context = FacesContext.getCurrentInstance();
                context.addMessage(null, new FacesMessage(FacesMessage.SEVERITY_ERROR, 
                    "Validation Error", "Please select valid charge and expiry dates."));
                context.validationFailed();
                return;
            }
        }
        this.editSchedule = !this.editSchedule;
    }
    
    
    private void clearValidationState() {
        FacesContext context = FacesContext.getCurrentInstance();
        // Clears validation status so other buttons function smoothly
        context.renderResponse();
    }

  

  	public void toggleEditBank() {
  	    this.editBankMode = !this.editBankMode;
  	}

  	public boolean isEditBankMode() {
  	    return editBankMode;
  	}

  	public void setEditBankMode(boolean editBankMode) {
  	    this.editBankMode = editBankMode;
  	}

	public Double getRemainingDueAmount() {
		return remainingDueAmount;
	}

	public void setRemainingDueAmount(Double remainingDueAmount) {
		this.remainingDueAmount = remainingDueAmount;
	}

	public Integer getRemainingCycles() {
		return remainingCycles;
	}

	public void setRemainingCycles(Integer remainingCycles) {
		this.remainingCycles = remainingCycles;
	}
	
	private int currentStep = 1;

	public int getCurrentStep() {
	    return currentStep;
	}

	public void goToNextStep() {
	    this.currentStep = 2;
	}

	public void goToPrevStep() {
	    this.currentStep = 1;
	}

	public void enableEditBankMode() {
        if (this.cashfreeDetails != null) {
            this.bankBackup = new BankDetailsBackup(
                this.cashfreeDetails.getCustomerBankAccountNumber(),
                this.cashfreeDetails.getCustomerBankAccountType(),
                this.cashfreeDetails.getCustomerBankCode(),
                this.cashfreeDetails.getCustomerBankIfsc()
            );
        }
        this.editBankMode = true;
    }
	
	public void removeBankDeatils() {
        if (this.cashfreeDetails != null) {
            this.bankBackup = new BankDetailsBackup(
                this.cashfreeDetails.getCustomerBankAccountNumber(),
                this.cashfreeDetails.getCustomerBankAccountType(),
                this.cashfreeDetails.getCustomerBankCode(),
                this.cashfreeDetails.getCustomerBankIfsc()
            );
            
            this.cashfreeDetails.setCustomerBankAccountNumber(null);
            this.cashfreeDetails.setCustomerBankAccountType(null);
            this.cashfreeDetails.setCustomerBankCode(null);
            this.cashfreeDetails.setCustomerBankIfsc(null);
        }
        
    }

    /**
     * Save action listener invoked by the 'Save' button.
     */
    public void saveBankDetails() {
        // Validate inputs if necessary
        if (cashfreeDetails.getCustomerBankAccountNumber() == null || cashfreeDetails.getCustomerBankAccountNumber().trim().isEmpty()) {
            FacesContext.getCurrentInstance().addMessage(null, 
                new FacesMessage(FacesMessage.SEVERITY_ERROR, "Validation Error", "Account number is required."));
            return;
        }

        // Persist edits, clear backup, and exit edit mode
        this.bankBackup = null;
        this.editBankMode = false;

        FacesContext.getCurrentInstance().addMessage(null, 
            new FacesMessage(FacesMessage.SEVERITY_INFO, "Success", "Bank account details updated locally."));
    }

    /**
     * Cancel action listener invoked by the 'Cancel' button.
     * Reverts input fields to original values stored in backup.
     */
    public void cancelEditBankMode() {
        if (this.bankBackup != null && this.cashfreeDetails != null) {
            this.cashfreeDetails.setCustomerBankAccountNumber(this.bankBackup.getAccountNumber());
            this.cashfreeDetails.setCustomerBankAccountType(this.bankBackup.getAccountType());
            this.cashfreeDetails.setCustomerBankCode(this.bankBackup.getBankCode());
            this.cashfreeDetails.setCustomerBankIfsc(this.bankBackup.getIfscCode());
        }
        this.bankBackup = null;
        this.editBankMode = false;
    }

    

    // Inner class or helper class for snapshot backups
 // Make the inner static class implement Serializable
    public static class BankDetailsBackup implements java.io.Serializable {
        private static final long serialVersionUID = 1L;

        private final String accountNumber;
        private final String accountType;
        private final String bankCode;
        private final String ifscCode;

        public BankDetailsBackup(String accountNumber, String accountType, String bankCode, String ifscCode) {
            this.accountNumber = accountNumber;
            this.accountType = accountType;
            this.bankCode = bankCode;
            this.ifscCode = ifscCode;
        }

        public String getAccountNumber() { return accountNumber; }
        public String getAccountType() { return accountType; }
        public String getBankCode() { return bankCode; }
        public String getIfscCode() { return ifscCode; }
    }
   
}