@finspringinnovations/fdsdk 0.0.1

package/src/screens/FDList.tsx

@@ -0,0 +1,1284 @@
+import React, { useState, useEffect, useCallback } from 'react';
+import {
+    View,
+    Text,
+    StyleSheet,
+    ScrollView,
+    TouchableOpacity,
+    ActivityIndicator,
+    Alert,
+    Platform,
+    BackHandler,
+    StatusBar,
+    Image,
+} from 'react-native';
+import { useFocusEffect } from '@react-navigation/native';
+import { Header, ActiveFDCard, FDCard, PendingFDBottomSheet } from '../components';
+import { useColors, useTypography, useSpacing, useTheme } from '../theme/ThemeContext';
+import { useGetInterestRatesMutation } from '../api/interestRateApi';
+import { useGetCustomerApplicationsMutation } from '../api/customerApi';
+import { useGetMasterDataQuery } from '../api/masterDataApi';
+import { useMasterData } from '../providers/MasterDataProvider';
+import { useTerminateWorkflowMutation } from '../api/workflowApi';
+import { usePaymentReverseFeedMutation } from '../api/fdApi';
+import type { ColorScheme, ThemeName } from '../theme';
+import SafeAreaWrapper from '../components/SafeAreaWrapper';
+import { getUserInfoForAPI, getAppData } from '../config/appDataConfig';
+import { navigate } from '../navigation/helpers';
+import { useAppDispatch, useAppSelector } from '../store';
+import { setOnboardingIds } from '../store/onboardingSlice';
+import { setFDListSelected } from '../store/fdListSelectedSlice';
+import { handleWorkflowNavigation } from '../navigation/workflowNavigator';
+import { WORKFLOW_STATES } from '../config/workflowConstants';
+import { setGlobalData } from '../utils/globalData';
+import { FD_STRINGS } from '../constants/strings';
+import { base64Images } from '../constants/strings/base64Images';
+
+var completeFDData: any = null;
+
+export interface FDItem {
+    id: string;
+    providerId: string; // Added providerId field
+    name: string;
+    accountNumber: string;
+    roi: string;
+    tenure: string;
+    amount: number;
+    maturityDate: string;
+    status: 'active' | 'matured' | 'pending';
+    creditRating: string;
+    interestPayout?: string; // Optional interest payout field
+}
+
+export interface FDListProps {
+    onGoBack?: () => void;
+    onSelectFD?: (fdId: string) => void;
+    onNavigateToFDCalculator?: (fdData?: any) => void;
+    customStyles?: {
+        container?: object;
+        header?: object;
+        title?: object;
+        fdCard?: object;
+    };
+}
+
+const FDList: React.FC<FDListProps> = ({
+    onGoBack,
+    onSelectFD,
+    onNavigateToFDCalculator,
+    customStyles = {},
+}) => {
+    const [activeTab, setActiveTab] = useState<string>(FD_STRINGS.ALL_FDS_TAB);
+    const [showPendingFDBottomSheet, setShowPendingFDBottomSheet] = useState(false);
+    const [selectedFD, setSelectedFD] = useState<FDItem | null>(null);
+    const [isInitialized, setIsInitialized] = useState(false);
+    const colors = useColors();
+    const typography = useTypography();
+    const spacing = useSpacing();
+    const { themeName } = useTheme();
+    const dispatch = useAppDispatch();
+    const hasFetchedRatesRef = React.useRef(false);
+    const isCallingInterestRatesRef = React.useRef(false);
+
+    // API calls to fetch 
+    const [getInterestRates, {
+        data: interestRates,
+        error: interestRatesError,
+        isLoading: isLoadingRates,
+    }] = useGetInterestRatesMutation();
+
+    const [getCustomerApplications, {
+        data: customerApplications,
+        error: customerApplicationsError,
+        isLoading: isLoadingApplications,
+    }] = useGetCustomerApplicationsMutation();
+
+    const [terminateWorkflow, {
+        data: terminateWorkflowData,
+        error: terminateWorkflowError,
+        isLoading: isTerminatingWorkflow,
+    }] = useTerminateWorkflowMutation();
+
+    // Payment Reverse Feed API
+    const [paymentReverseFeed, {
+        data: paymentReverseFeedResponse,
+        error: paymentReverseFeedError,
+        isLoading: isLoadingPaymentReverseFeed,
+    }] = usePaymentReverseFeedMutation();
+
+    const styles = createStyles(colors, typography, spacing, themeName);
+    const { setMasterData } = useMasterData();
+
+    // Redux selectors for workflow IDs
+    const workflowInstanceId = useAppSelector((state: any) => state?.onboarding?.workflowInstanceId);
+    const applicationId = useAppSelector((state: any) => state?.onboarding?.applicationId);
+    const entityId = useAppSelector((state: any) => state?.onboarding?.entityid);
+    const providerId = useAppSelector((state: any) => state?.onboarding?.providerId);
+
+    // Helper function to check if customer applications is empty
+    const isCustomerApplicationsEmpty = () => {
+        if (!customerApplications) {
+            return true;
+        }
+
+        // Handle direct array response
+        if (Array.isArray(customerApplications)) {
+            const isEmpty = customerApplications.length === 0;
+            return isEmpty;
+        }
+
+        // Handle response with data property
+        if (customerApplications.data && Array.isArray(customerApplications.data)) {
+            const isEmpty = customerApplications.data.length === 0;
+            return isEmpty;
+        }
+
+        // Handle response with applications property
+        if (customerApplications.applications && Array.isArray(customerApplications.applications)) {
+            const isEmpty = customerApplications.applications.length === 0;
+            return isEmpty;
+        }
+
+        // If customerApplications exists but doesn't match expected structure, consider it not empty
+        return false;
+    };
+
+    // Helper function to get provider ID from interest rates response (robust to varying shapes)
+    const getProviderIdFromInterestRates = () => {
+        try {
+            const data = interestRates?.data;
+            if (!data) return undefined;
+
+            const extractId = (rate: any) => {
+                return (
+                    rate?.providerId ||
+                    rate?.provider_id ||
+                    rate?.fd_provider_id ||
+                    rate?.fdProviderId ||
+                    rate?.provider?.id ||
+                    undefined
+                );
+            };
+
+            // Prefer SDR
+            const sdr = Array.isArray(data?.sdrScheme) ? data.sdrScheme : [];
+            for (const r of sdr) {
+                const id = extractId(r);
+                if (id) {
+                    return id;
+                }
+            }
+
+            // Fallback to FDR
+            const fdr = Array.isArray(data?.fdrScheme) ? data.fdrScheme : [];
+            for (const r of fdr) {
+                const id = extractId(r);
+                if (id) {
+                    return id;
+                }
+            }
+
+            return undefined;
+        } catch (e) {
+            return undefined;
+        }
+    };
+
+    // Helper function to filter FDs based on tenure
+    const filterFDsByTenure = (fdList: FDItem[], filter: string): FDItem[] => {
+        if (filter === FD_STRINGS.ALL_FDS_TAB) return fdList;
+
+        return fdList.filter(fd => {
+            // Extract tenure in months from the fd.tenure string (e.g., "12 Months" -> 12)
+            const tenureMatch = fd.tenure.match(/(\d+)\s*Months?/i);
+            if (!tenureMatch) return false;
+
+            const tenureMonths = parseInt(tenureMatch[1], 10);
+            const tenureYears = tenureMonths / 12;
+
+            switch (filter) {
+                case '<1Y':
+                    return tenureYears <= 1;
+                case '<1-3Y':
+                    return tenureYears > 1 && tenureYears <= 3;
+                case '<3-5Y':
+                    return tenureYears > 3 && tenureYears <= 5;
+                case '>5Y':
+                    return tenureYears > 5;
+                default:
+                    return true;
+            }
+        });
+    };
+
+
+
+    // Master data fetch - use default providerId first, then update with rates data
+    const defaultProviderId = ''; // Default provider ID for initial call
+    const inferredProviderId = React.useMemo(() => {
+        if (interestRates?.data?.sdrScheme?.[0]?.providerId) return interestRates.data.sdrScheme[0].providerId;
+        if (interestRates?.data?.fdrScheme?.[0]?.providerId) return interestRates.data.fdrScheme[0].providerId;
+        return defaultProviderId; // Use default if no rates data yet
+    }, [interestRates]);
+
+    const { data: masterData, isLoading: isLoadingMaster } = useGetMasterDataQuery(
+        { providerId: inferredProviderId },
+        { skip: !inferredProviderId }
+    );
+
+    // Only render once all three API calls have completed (success or error)
+    // Show loading initially until all APIs have completed
+    const isAllDataReady = React.useMemo(() => {
+        // If not initialized yet, show loading
+        if (!isInitialized) return false;
+
+        // Step 1: Check if interest rates API has been called and completed
+        // If currently loading, show loading
+        if (isLoadingRates) return false;
+        // If not loading but no data and no error, API hasn't been called yet - show loading
+        if (!interestRates && !interestRatesError) return false;
+
+        // Step 2: Once interest rates are done, customer applications should be called
+        // If currently loading, show loading
+        if (isLoadingApplications) return false;
+        // If interest rates succeeded, we must wait for customer applications
+        // If interest rates failed, we can still proceed (but applications might not be called)
+        if (interestRates) {
+            // Interest rates succeeded, so applications should be called
+            // If not loading but no data and no error, applications haven't been called yet - show loading
+            if (!customerApplications && !customerApplicationsError) return false;
+        }
+
+        // Step 3: Check master data - only required if providerId is available
+        const masterShouldRun = !!inferredProviderId;
+        if (masterShouldRun) {
+            // Master data should be done (either loaded or error, but not loading)
+            if (isLoadingMaster) return false;
+        }
+
+        return true;
+    }, [isInitialized, interestRates, interestRatesError, isLoadingRates, customerApplications, customerApplicationsError, isLoadingApplications, inferredProviderId, isLoadingMaster]);
+
+    useEffect(() => {
+        if (masterData) {
+            setMasterData(masterData);
+        }
+    }, [masterData, setMasterData]);
+
+    // Function to refresh all data - Required sequence: Interest -> Applications -> Master
+    const refreshData = useCallback(async () => {
+        if (!isInitialized) {
+            return;
+        }
+
+        // Prevent multiple simultaneous calls
+        if (isCallingInterestRatesRef.current || isLoadingRates) {
+            return;
+        }
+
+        try {
+            isCallingInterestRatesRef.current = true;
+            // Add 500ms delay before calling interest rate API
+            await new Promise(resolve => setTimeout(resolve, 500));
+            await getInterestRates({});
+        } catch (error) {
+            // Handle error silently
+        } finally {
+            isCallingInterestRatesRef.current = false;
+        }
+    }, [getInterestRates, isInitialized, isLoadingRates]);
+
+    // Initialize component after mount
+    useEffect(() => {
+        const initializeComponent = async () => {
+            // Validate required user data before proceeding
+            const appData = getAppData();
+
+            const requiredFields = [
+                { field: 'id', label: 'User ID' },
+                { field: 'name', label: 'User Name' },
+                { field: 'dob', label: 'Date of Birth' },
+                { field: 'gender', label: 'Gender' },
+                { field: 'mobNo', label: 'Mobile Number' },
+                { field: 'email', label: 'Email' },
+            ];
+
+            const missingFields: string[] = [];
+
+            requiredFields.forEach(({ field, label }) => {
+                const value = appData?.[field as keyof typeof appData];
+                if (!value || (typeof value === 'string' && !value.trim())) {
+                    missingFields.push(label);
+                }
+            });
+
+            // Show alert if required fields are missing
+            if (missingFields.length > 0) {
+                Alert.alert(
+                    'Cannot Proceed with FD Booking',
+                    `The following required information is missing from the main app:\n\n${missingFields.join('\n')}\n\nPlease provide all required user information to proceed.`,
+                    [
+                        {
+                            text: 'Cancel FD Booking',
+                            onPress: () => {
+                                // Redirect back to main app
+                                if (onGoBack) {
+                                    onGoBack();
+                                } else {
+                                    // No-op when onGoBack is not provided
+                                }
+                            },
+                            style: 'cancel',
+                        },
+                    ],
+                    { cancelable: false }
+                );
+                return; // Don't initialize if validation fails
+            }
+
+            // Additional value validation (case-insensitive): gender, maritalStatus, typeOfAccount
+            const errors: string[] = [];
+
+            // Gender must be Male, Female, or Other (case-insensitive)
+            const gender = String(appData?.gender || '').trim().toLowerCase();
+            const allowedGenders = ['male', 'female', 'other'];
+            if (gender && !allowedGenders.includes(gender)) {
+                errors.push("Gender must be one of: Male, Female, Other");
+            }
+
+            // Marital status must be Married, Unmarried, or Other (case-insensitive)
+            const maritalStatus = String(appData?.maritalStatus || '').trim().toLowerCase();
+            const allowedMarital = ['married', 'unmarried', 'other'];
+            if (maritalStatus && !allowedMarital.includes(maritalStatus)) {
+                errors.push("Marital Status must be one of: Married, Unmarried, Other");
+            }
+
+            // Account type must be 'Saving A/c' or 'Current A/c' (case-insensitive, tolerate spaces)
+            const typeOfAccountRaw = String(appData?.typeOfAccount || '').trim();
+            const typeOfAccount = typeOfAccountRaw.replace(/\s+/g, ' ').toLowerCase();
+            const allowedAccounts = ['saving a/c', 'current a/c'];
+            if (typeOfAccountRaw && !allowedAccounts.includes(typeOfAccount)) {
+                errors.push("Type of Account must be one of: 'Saving A/c', 'Current A/c'");
+            }
+
+            if (errors.length > 0) {
+                Alert.alert(
+                    'Invalid User Data',
+                    `${errors.join('\n')}`,
+                    [
+                        {
+                            text: 'OK',
+                            onPress: () => {
+                                if (onGoBack) {
+                                    onGoBack();
+                                }
+                            },
+                            style: 'cancel',
+                        },
+                    ],
+                    { cancelable: false }
+                );
+                return; // Stop initialization on invalid values
+            }
+
+            // Small delay to ensure component is fully mounted
+            await new Promise(resolve => setTimeout(resolve, 100));
+            setIsInitialized(true);
+        };
+
+        initializeComponent();
+    }, [onGoBack]);
+
+    // Handle Android hardware back button - use same navigation as header back button
+    useEffect(() => {
+        if (Platform.OS !== 'android') return;
+
+        const onHardwareBackPress = () => {
+            // Call onGoBack which triggers onExit in RootNavigator
+            if (onGoBack) {
+                onGoBack();
+            }
+            return true; // Prevent default behavior
+        };
+
+        const backHandler = BackHandler.addEventListener(
+            'hardwareBackPress',
+            onHardwareBackPress
+        );
+
+        return () => backHandler.remove();
+    }, [onGoBack]);
+
+    // Removed init-time fetch to avoid duplicate calls; we'll fetch on first focus only
+
+    // Refresh data when screen comes into focus (only if initialized)
+    useFocusEffect(
+        useCallback(() => {
+            if (!isInitialized) return;
+            if (hasFetchedRatesRef.current) return; // ensure called only once when screen first shows
+            // Prevent multiple simultaneous calls
+            if (isCallingInterestRatesRef.current || isLoadingRates) return;
+            hasFetchedRatesRef.current = true;
+            refreshData();
+        }, [refreshData, isInitialized, isLoadingRates])
+    );
+
+    // After interest rates are received, call Customer Applications
+    useEffect(() => {
+        if (!interestRates) return;
+        try {
+            const userInfo = getUserInfoForAPI();
+            getCustomerApplications({ userReferenceId: userInfo.id });
+        } catch (e) {
+        }
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [!!interestRates]);
+
+    // Handle API errors
+    useEffect(() => {
+        if (interestRatesError) {
+            Alert.alert(
+                'API Error',
+                'Failed to fetch interest rates. Please try again.',
+                [
+                    {
+                        text: 'Retry',
+                        onPress: async () => {
+                            // Prevent multiple simultaneous calls
+                            if (isCallingInterestRatesRef.current || isLoadingRates) {
+                                return;
+                            }
+                            try {
+                                isCallingInterestRatesRef.current = true;
+                                // Add 500ms delay before retrying interest rate API
+                                await new Promise(resolve => setTimeout(resolve, 500));
+                                await getInterestRates({});
+                            } catch (error) {
+                                // Handle error silently
+                            } finally {
+                                isCallingInterestRatesRef.current = false;
+                            }
+                        }
+                    },
+                    { text: 'Continue', style: 'cancel' }
+                ]
+            );
+        }
+    }, [interestRatesError, getInterestRates]);
+
+    // Log successful data fetch
+    useEffect(() => {
+        if (interestRates && interestRates.data?.sdrScheme?.length > 0) {
+            // Interest rates loaded successfully
+        }
+    }, [interestRates]);
+
+    // Persist providerId to onboarding store as soon as we have rates
+    useEffect(() => {
+        const pid = getProviderIdFromInterestRates();
+        if (pid) {
+            try {
+                dispatch(setOnboardingIds({ providerId: pid }));
+            } catch (e) {
+                // Handle error silently
+            }
+        }
+    }, [interestRates, dispatch]);
+
+    useEffect(() => {
+        if (customerApplications) {
+            // Customer applications loaded successfully
+
+            // Persist onboarding identifiers globally for subsequent API calls (like FDCalculator)
+            try {
+                // Extract workflow parameters from response
+                const responseData = customerApplications?.data || customerApplications;
+                let applicationData = Array.isArray(responseData) ? responseData[0] : responseData;
+
+                // Prefer the application with wf_status === 'Active'
+                if (Array.isArray(responseData)) {
+                    const activeOnly = responseData.find((app: any) => {
+                        const status = (app.wf_status || app.status || '').toString();
+                        return status === 'Active';
+                    });
+                    if (activeOnly) applicationData = activeOnly;
+                }
+
+                if (Array.isArray(responseData)) {
+                    completeFDData = responseData.find((app: any) => {
+                        const status = (app.wf_status || app.status || '').toString();
+                        return status === 'Completed';
+                    });
+                    setGlobalData({ completeFDData: !!completeFDData });
+                }
+                if (applicationData) {
+                    const ids = {
+                        workflowInstanceId: applicationData.workflow_instance_id,
+                        applicationId: applicationData.application_id,
+                        entityid: applicationData.entity_id,
+                        customerId: applicationData.customer_id,
+                        fdId: applicationData.fd_id,
+                        currentState: applicationData.current_state,
+                        currentTask: applicationData.current_task,
+                        // Persist providerId from interest-rate API (prefers SDR, fallback FDR)
+                        providerId: getProviderIdFromInterestRates(),
+                        wfStatus: applicationData.wf_status,
+                    };
+                    if (dispatch && setOnboardingIds) {
+                        dispatch(setOnboardingIds(ids));
+                    } else {
+                        // Dispatch or setOnboardingIds unavailable
+                    }
+                }
+            } catch (error) {
+                // Handle error silently
+            }
+        }
+    }, [customerApplications, dispatch]);
+
+    // Unified handler: behave like bottom sheet Continue flow
+    const handlePendingFDContinue = async () => {
+        // Persist active FD data to store for use across screens
+        try {
+            if (activeFD) {
+                const fdListSelectedData = {
+                    id: selectedFD?.id || 'active-fd',
+                    providerId: selectedFD?.providerId || '',
+                    name: activeFD.name,
+                    accountNumber: selectedFD?.accountNumber || '',
+                    roi: `${activeFD.returns}% p.a.`,
+                    tenure: activeFD.maturityDate || '-',
+                    amount: Number(activeFD.invested) || 0,
+                    maturityDate: activeFD.maturityDate || '-',
+                    status: 'active' as const,
+                    creditRating: selectedFD?.creditRating || 'NA',
+                    companyName: activeFD.name,
+                    fdRate: `${activeFD.returns}% p.a.`,
+                    interestPayout: activeFD.interestPayout || '',
+                };
+                dispatch(setFDListSelected(fdListSelectedData));
+            }
+        } catch (e) {
+            // Handle error silently
+        }
+
+        // Get current state from customer applications for workflow navigation
+        let currentState: any = null;
+        let transactionId: string | undefined = undefined;
+        try {
+            if (customerApplications && !isCustomerApplicationsEmpty()) {
+                // Normalize list
+                let applicationsData: any[] = [];
+                if (Array.isArray(customerApplications)) {
+                    applicationsData = customerApplications;
+                } else if (customerApplications.data && Array.isArray(customerApplications.data)) {
+                    applicationsData = customerApplications.data;
+                } else if (customerApplications.applications && Array.isArray(customerApplications.applications)) {
+                    applicationsData = customerApplications.applications;
+                }
+
+                if (applicationsData.length > 0) {
+                    // Prefer the active application
+                    const appData = applicationsData.find((a: any) => {
+                        const s = (a.wf_status || a.status || '').toString();
+                        return s === 'Active';
+                    }) || applicationsData[0];
+                    currentState = appData.current_state;
+
+                    // Extract transactionId from application data
+                    transactionId = appData.transaction_id || appData.transactionId;
+                }
+            }
+        } catch (error) {
+            // Handle error silently
+        }
+
+        // If current state is payment and transactionId is available, call payment reverse feed API
+        if (currentState === WORKFLOW_STATES.PAYMENT && transactionId) {
+            try {
+                // Get user info and required IDs
+                const userInfo = getUserInfoForAPI();
+
+                // Prepare payment reverse feed request
+                const paymentReverseFeedRequest = {
+                    // Headers
+                    providerId: providerId,
+                    workflowInstanceId: workflowInstanceId,
+                    userreferenceid: userInfo.id,
+                    applicationid: applicationId,
+                    entityid: entityId,
+                    // Body
+                    transactionId: transactionId,
+                };
+
+                const response = await paymentReverseFeed(paymentReverseFeedRequest).unwrap();
+
+                // Handle the response based on payment status
+                const paymentStatus = (response?.data?.paymentStatus || '').toLowerCase();
+                const statusParam = paymentStatus === 'success' ? 'success' : paymentStatus === 'failed' ? 'failed' : 'pending';
+
+                // Build fdData for display
+                const fdDataParam = activeFD ? {
+                    companyName: activeFD.name,
+                    amount: Number(activeFD.invested) || 0,
+                    fdRate: `${activeFD.returns}% p.a.`,
+                    tenure: activeFD.maturityDate ? `${activeFD.maturityDate}` : '-',
+                    interestPayout: activeFD.interestPayout || 'Yearly',
+                } : undefined;
+
+                navigate('PaymentStatus', { status: statusParam, transactionId, fdData: fdDataParam } as any);
+                return;
+
+            } catch (error) {
+                // Handle error silently
+
+                // On error, navigate with pending status as fallback
+                const fdDataParam = activeFD ? {
+                    companyName: activeFD.name,
+                    amount: Number(activeFD.invested) || 0,
+                    fdRate: `${activeFD.returns}% p.a.`,
+                    tenure: activeFD.maturityDate ? `${activeFD.maturityDate}` : '-',
+                    interestPayout: activeFD.interestPayout || 'Yearly',
+                } : undefined;
+                navigate('PaymentStatus', { status: 'pending', transactionId, fdData: fdDataParam } as any);
+                return;
+            }
+        }
+
+        // Use workflow navigation based on current state (non-payment states or no transactionId)
+        if (currentState && Object.values(WORKFLOW_STATES).includes(currentState)) {
+            handleWorkflowNavigation({
+                workflowState: currentState,
+                investmentData: undefined,
+                customerData: undefined,
+                appData: undefined,
+                fdData: undefined,
+                completedApplications: [],
+                transactionId,
+            });
+        } else {
+            navigate('Employee');
+        }
+    };
+
+    // Derive identifiers for workflow termination from applications API
+    const terminateIdentifiers = React.useMemo(() => {
+        try {
+            if (!customerApplications || isCustomerApplicationsEmpty()) {
+                return {
+                    applicationId: undefined as string | undefined,
+                    workflowInstanceId: undefined as string | undefined,
+                    entityId: undefined as string | undefined,
+                    providerIdFromApp: undefined as string | undefined,
+                };
+            }
+
+            // Normalize list
+            let applicationsData: any[] = [];
+            if (Array.isArray(customerApplications)) {
+                applicationsData = customerApplications;
+            } else if (customerApplications.data && Array.isArray(customerApplications.data)) {
+                applicationsData = customerApplications.data;
+            } else if (customerApplications.applications && Array.isArray(customerApplications.applications)) {
+                applicationsData = customerApplications.applications;
+            }
+
+            if (applicationsData.length === 0) {
+                return {
+                    applicationId: undefined,
+                    workflowInstanceId: undefined,
+                    entityId: undefined,
+                    providerIdFromApp: undefined,
+                };
+            }
+
+            // Prefer a pending/in-progress one for termination, else first
+            const appForTerminate = applicationsData.find((a: any) => {
+                const s = (a.wf_status || a.status || '').toString().toLowerCase();
+                return s === 'pending' || s === 'in_progress' || s === 'in-progress';
+            }) || applicationsData[0];
+
+            const applicationId: string | undefined =
+                appForTerminate.application_id || appForTerminate.applicationId || appForTerminate.id;
+            const workflowInstanceId: string | undefined =
+                appForTerminate.workflow_instance_id || appForTerminate.workflowInstanceId || appForTerminate.workflow?.instanceId;
+            const entityId: string | undefined =
+                appForTerminate.entity_id || appForTerminate.entityId || appForTerminate.entity?.id;
+            const providerIdFromApp: string | undefined =
+                appForTerminate.provider_id || appForTerminate.providerId || appForTerminate.fd_provider_id || appForTerminate.fdProviderId;
+
+            return { applicationId, workflowInstanceId, entityId, providerIdFromApp };
+        } catch (e) {
+            return {
+                applicationId: undefined,
+                workflowInstanceId: undefined,
+                entityId: undefined,
+                providerIdFromApp: undefined,
+            };
+        }
+    }, [customerApplications]);
+
+
+    // Derive Active FD card data from customer applications response
+    const activeFD = React.useMemo(() => {
+        try {
+            if (!customerApplications || isCustomerApplicationsEmpty()) {
+                return {
+                    name: 'Shriram Finance Ltd',
+                    invested: 0,
+                    value: 0,
+                    returns: 0,
+                    maturityDate: '--',
+                    interestPayout: 'Yearly'
+                };
+            }
+
+            // Normalize list
+            let applicationsData: any[] = [];
+            if (Array.isArray(customerApplications)) {
+                applicationsData = customerApplications;
+            } else if (customerApplications.data && Array.isArray(customerApplications.data)) {
+                applicationsData = customerApplications.data;
+            } else if (customerApplications.applications && Array.isArray(customerApplications.applications)) {
+                applicationsData = customerApplications.applications;
+            }
+
+            if (applicationsData.length === 0) {
+                return {
+                    name: 'Shriram Finance Ltd',
+                    invested: 0,
+                    value: 0,
+                    returns: 0,
+                    maturityDate: '--',
+                    interestPayout: 'Yearly'
+                };
+            }
+
+            // Pick an active application if available, otherwise first
+            const activeApp = applicationsData.find((a: any) => {
+                const s = (a.wf_status || a.status || '').toString();
+                return s === 'Active';
+            }) || applicationsData[0];
+
+            const invested = Number(
+                activeApp.investment_amount ?? activeApp.amount ?? activeApp.investmentAmount ?? 0
+            );
+            const rate = Number(
+                activeApp.interest_rate ?? activeApp.interestRate ?? 0
+            );
+
+            // Prefer a provided current value, then maturity amount
+            const value = Number(
+                activeApp.current_value ?? activeApp.currentValue ?? activeApp.maturity_amount ?? activeApp.maturityAmount ?? 0
+            );
+
+            const returns = rate || 0; // display interest rate as returns %
+
+            // Format maturity date to 'Mon YYYY'
+            const maturityDateStr: string = activeApp.maturity_date || activeApp.maturityDate || '';
+            let maturityDate = '--';
+            if (maturityDateStr) {
+                const d = new Date(maturityDateStr);
+                if (!isNaN(d.getTime())) {
+                    const months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
+                    maturityDate = `${months[d.getMonth()]} ${d.getFullYear()}`;
+                }
+            }
+
+            // Get interest payout term from activeApp
+            const interestPayout = activeApp.interest_payout_term || activeApp.interestPayoutTerm || activeApp.payout_term || 'Yearly';
+
+            return {
+                name: activeApp.fd_provider_name || activeApp.providerName || 'Shriram Finance Ltd',
+                invested,
+                value,
+                returns,
+                maturityDate,
+                interestPayout,
+            };
+        } catch (e) {
+            return {
+                name: 'Shriram Finance Ltd',
+                invested: 0,
+                value: 0,
+                returns: 0,
+                maturityDate: '--',
+                interestPayout: 'Yearly'
+            };
+        }
+    }, [customerApplications]);
+
+    // Helper function to check if there's an active FD
+    const hasActiveFD = React.useMemo(() => {
+        try {
+            if (!customerApplications || isCustomerApplicationsEmpty()) {
+                return false;
+            }
+
+            // Normalize list
+            let applicationsData: any[] = [];
+            if (Array.isArray(customerApplications)) {
+                applicationsData = customerApplications;
+            } else if (customerApplications.data && Array.isArray(customerApplications.data)) {
+                applicationsData = customerApplications.data;
+            } else if (customerApplications.applications && Array.isArray(customerApplications.applications)) {
+                applicationsData = customerApplications.applications;
+            }
+
+            if (applicationsData.length === 0) {
+                return false;
+            }
+
+            // Check if any application has wf_status as "Active"
+            const hasActive = applicationsData.some((a: any) => {
+                const s = (a.wf_status || a.status || '').toString();
+                return s === 'Active';
+            });
+
+            return hasActive;
+        } catch (e) {
+            return false;
+        }
+    }, [customerApplications]);
+
+    // Build FD options list from interest-rate API (show all FDs)
+    const fdList = React.useMemo(() => {
+        if (interestRates && (interestRates.data?.sdrScheme?.length > 0 || interestRates.data?.fdrScheme?.length > 0)) {
+            const sdr = Array.isArray(interestRates.data?.sdrScheme) ? interestRates.data.sdrScheme : [];
+            const fdr = Array.isArray(interestRates.data?.fdrScheme) ? interestRates.data.fdrScheme : [];
+            const combined = [...sdr, ...fdr];
+
+            // Building FD options from rates
+
+            return combined.map((rate: any, index: number) => ({
+                id: `${rate.providerId || 'provider'}-${rate.perdMonth || index}`,
+                providerId: rate.providerId || `provider-${index}`,
+                name: rate.providerName || '', // Use actual provider name from API
+                accountNumber: `FD${String(index + 1).padStart(9, '0')}`,
+                roi: `${Number(rate.rate ?? rate.interestRate ?? 0).toFixed(2)}% p.a.`,
+                tenure: `${rate.perdMonth} Months`,
+                amount: 5000,
+                maturityDate: '2025-12-31',
+                status: 'active' as const,
+                creditRating: rate.creditRating || 'AA+',
+                interestPayout: rate.interestPayout || rate.interest_payout_term || rate.payout_term || 'Yearly'
+            }));
+        }
+
+        // If rates are not available yet, show empty list
+        return [];
+    }, [interestRates]);
+
+
+    // Get filtered FD list based on active tab
+    const filteredFDList = React.useMemo(() => {
+        if (!fdList || fdList.length === 0) return [];
+
+        // Always create a new filtered array
+        const filtered = filterFDsByTenure([...fdList], activeTab); // spread to ensure new array
+
+        return filtered;
+    }, [fdList, activeTab]);
+
+
+    const tabs = [FD_STRINGS.ALL_FDS_TAB, FD_STRINGS.LESS_THAN_1Y_TAB, FD_STRINGS.LESS_THAN_1_3Y_TAB, FD_STRINGS.LESS_THAN_3_5Y_TAB, FD_STRINGS.GREATER_THAN_5Y_TAB];
+
+    if (!isAllDataReady) {
+        return (
+            <SafeAreaWrapper
+                style={customStyles.container}
+                includeTop={false}
+                statusBarColor="#000000"
+                statusBarStyle="light-content"
+            >
+                <View style={{ flex: 1, alignItems: 'center', justifyContent: 'center' }}>
+                    <ActivityIndicator size="large" color={colors.primary} />
+                    <Text style={{ marginTop: 12, color: colors.textSecondary }}>{FD_STRINGS.LOADING_FD_DATA}</Text>
+                </View>
+            </SafeAreaWrapper>
+        );
+    }
+
+    return (
+        <SafeAreaWrapper
+            style={customStyles.container}
+            includeTop={false}
+            statusBarColor="#0A1929"
+            statusBarStyle="light-content"
+        >
+            {/* Custom FDList Header */}
+            <View style={styles.customHeader}>
+                <TouchableOpacity
+                    style={styles.backButton}
+                    onPress={onGoBack}
+                    activeOpacity={0.7}
+                >
+                    <Image
+                        source={{ uri: base64Images.backArrow }}
+                        style={styles.backIcon}
+                        resizeMode="contain"
+                    />
+                </TouchableOpacity>
+
+                <View style={styles.headerContent}>
+                    <Text style={styles.headerTitle}>{FD_STRINGS.CORPORATE_FDS_TITLE}</Text>
+                    <View style={styles.poweredByContainer}>
+                        <Text style={styles.poweredByText}>Powered by</Text>
+                        <Image
+                            source={{ uri: base64Images.simplfylogo }}
+                            style={styles.simplifyLogo}
+                            resizeMode="contain"
+                        />
+                    </View>
+                </View>
+            </View>
+
+            <ScrollView style={styles.content}>
+
+                {/* Active FDs Section - Only show if there's an active FD */}
+                {hasActiveFD && (
+                    <View style={styles.section}>
+                        <Text style={styles.sectionTitle}>{FD_STRINGS.ACTIVE_FDS_SECTION}</Text>
+
+                        <TouchableOpacity activeOpacity={0.8} onPress={handlePendingFDContinue}>
+                            <ActiveFDCard
+                                name={activeFD.name}
+                                invested={activeFD.invested}
+                                value={activeFD.value}
+                                returns={activeFD.returns}
+                                maturityDate={activeFD.maturityDate}
+                            />
+                        </TouchableOpacity>
+                    </View>
+                )}
+
+                {/* Tabs */}
+                <View style={styles.tabsContainer}>
+                    <View style={styles.tabsRow}>
+                        {tabs.map((tab) => (
+                            <TouchableOpacity
+                                key={tab}
+                                style={[
+                                    styles.tab,
+                                    activeTab === tab && styles.activeTab
+                                ]}
+                                onPress={() => {
+                                    // Other tabs filter the data
+                                    setActiveTab(tab);
+                                }}
+                            >
+                                <Text style={[
+                                    styles.tabText,
+                                    activeTab === tab && styles.activeTabText
+                                ]}>
+                                    {tab}
+                                </Text>
+                            </TouchableOpacity>
+                        ))}
+                    </View>
+                </View>
+
+                {/* Filter Status removed as requested */}
+
+                {/* FD List */}
+                <View style={styles.fdOptionsContainer}>
+                    {filteredFDList.length > 0 ? (
+                        filteredFDList.map((fd: FDItem) => (
+                            <FDCard
+                                key={fd.id}
+                                id={fd.id}
+                                name={fd.name}
+                                accountNumber={fd.accountNumber}
+                                roi={fd.roi}
+                                tenure={fd.tenure}
+                                amount={fd.amount}
+                                maturityDate={fd.maturityDate}
+                                status={fd.status as 'active' | 'matured' | 'pending'}
+                                creditRating={fd.creditRating}
+                                onPress={(fdId) => {
+                                    // Log the selection
+                                    onSelectFD?.(fdId);
+
+                                    // Store the selected FD data locally
+                                    setSelectedFD(fd);
+
+                                    // Store the selected FD data in Redux for PayNow screen
+                                    const fdListSelectedData = {
+                                        id: fd.id,
+                                        providerId: fd.providerId,
+                                        name: fd.name,
+                                        accountNumber: fd.accountNumber,
+                                        roi: fd.roi,
+                                        tenure: fd.tenure,
+                                        amount: fd.amount,
+                                        maturityDate: fd.maturityDate,
+                                        status: fd.status as 'active' | 'matured' | 'pending',
+                                        creditRating: fd.creditRating,
+                                        // Additional fields for PayNow display
+                                        companyName: fd.name,
+                                        fdRate: fd.roi,
+                                        interestPayout: fd.interestPayout || 'Yearly', // Use FD's interest payout or default
+                                    };
+
+                                    dispatch(setFDListSelected(fdListSelectedData));
+
+                                    // Check if there's an active FD
+                                    if (hasActiveFD) {
+                                        // If there's an active FD, show bottom sheet
+                                        setShowPendingFDBottomSheet(true);
+                                    } else {
+                                        // If no active FD, redirect to FD calculator
+                                        onNavigateToFDCalculator?.(fd);
+                                    }
+                                }}
+                                customStyles={customStyles}
+                            />
+                        ))
+                    ) : (
+                        <View style={styles.noDataContainer}>
+                            <Text style={styles.noDataText}>
+                                {isLoadingRates || isLoadingApplications ? FD_STRINGS.LOADING_FD_DATA :
+                                    interestRatesError || customerApplicationsError ? FD_STRINGS.FAILED_TO_LOAD_FD_DATA :
+                                        fdList.length === 0 ? (!isCustomerApplicationsEmpty() ? FD_STRINGS.NO_CUSTOMER_FDS_FOUND : FD_STRINGS.NO_FD_OPTIONS_AVAILABLE) :
+                                            `${FD_STRINGS.NO_FDS_FOUND_FOR_TENURE} "${activeTab}" tenure range.`}
+                            </Text>
+
+                        </View>
+                    )}
+                </View>
+            </ScrollView>
+
+            {/* Pending FD Bottom Sheet */}
+            <PendingFDBottomSheet
+                visible={showPendingFDBottomSheet}
+                onClose={() => setShowPendingFDBottomSheet(false)}
+                pendingFDData={activeFD}
+                isBookingNewLoading={isTerminatingWorkflow}
+                onContinue={async () => {
+                    setShowPendingFDBottomSheet(false);
+                    await handlePendingFDContinue();
+                }}
+                onBookNew={async () => {
+                    try {
+
+                        // Pull identifiers from application API response, with last-resort placeholders
+                        const requestParams = {
+                            providerId: inferredProviderId,
+                            workflowInstanceId: terminateIdentifiers.workflowInstanceId || 'wf-instance-unknown',
+                            entityId: terminateIdentifiers.entityId || 'entity-unknown',
+                            applicationId: terminateIdentifiers.applicationId || 'application-unknown',
+                        } as const;
+
+
+                        // Call workflow terminate API
+                        await terminateWorkflow(requestParams);
+
+                        // Dismiss bottom sheet
+                        setShowPendingFDBottomSheet(false);
+
+                        // Navigate to FD calculator
+                        onNavigateToFDCalculator?.();
+
+                    } catch (error) {
+                        // Handle error silently
+
+                        // Still dismiss bottom sheet and navigate even if API fails
+                        // setShowPendingFDBottomSheet(false);
+                        // onNavigateToFDCalculator?.();
+
+                        // Show error alert
+                        Alert.alert(
+                            'Warning',
+                            'Failed to terminate existing workflow, but continuing with new FD booking.',
+                            [{ text: 'OK' }]
+                        );
+                    }
+                }}
+            />
+        </SafeAreaWrapper>
+    );
+};
+
+const createStyles = (colors: ColorScheme, typography: any, spacing: any, themeName: ThemeName) => StyleSheet.create({
+    container: {
+        flex: 1,
+        backgroundColor: colors.surface,
+    },
+    customHeader: {
+        backgroundColor: '#0A1929',
+        paddingTop: Platform.OS === 'ios' ? 50 : 20,
+        paddingBottom: spacing.md,
+        paddingHorizontal: spacing.lg,
+        flexDirection: 'row',
+        alignItems: 'center',
+    },
+    backButton: {
+        width: 40,
+        height: 40,
+        alignItems: 'center',
+        justifyContent: 'center',
+    },
+    backIcon: {
+        width: 24,
+        height: 24,
+        tintColor: '#FFFFFF',
+    },
+    headerContent: {
+        flex: 1,
+        alignItems: 'flex-start',
+        marginRight: 40, // Balance the back button width
+    },
+    headerTitle: {
+        ...typography.styles.h3,
+        color: '#FFFFFF',
+        marginBottom: spacing.xs,
+    },
+    poweredByContainer: {
+        flexDirection: 'row',
+        alignItems: 'center',
+    },
+    poweredByText: {
+        ...typography.styles.text10Regular,
+        color: '#FFFFFF',
+        opacity: 0.7,
+        marginRight: 0,
+    },
+    simplifyLogo: {
+        width: 70,
+        height: 20,
+    },
+    content: {
+        flex: 1,
+    },
+    section: {
+        paddingHorizontal: spacing.lg,
+        paddingTop: spacing.xl,
+    },
+    sectionTitle: {
+        ...typography.styles.h3,
+        color: colors.text,
+        marginBottom: spacing.lg,
+    },
+    tabsContainer: {
+        paddingHorizontal: spacing.lg,
+        paddingTop: spacing.xxl,
+        paddingBottom: spacing.lg,
+    },
+    tabsRow: {
+        flexDirection: 'row',
+        justifyContent: 'space-around',
+        alignItems: 'center',
+    },
+    tab: {
+        flex: 1,
+        paddingHorizontal: spacing.sm,
+        paddingVertical: spacing.md,
+        marginHorizontal: 2,
+        borderBottomWidth: 3,
+        borderBottomColor: 'white',
+        borderBottomLeftRadius: 8,
+        borderBottomRightRadius: 8,
+        backgroundColor: 'transparent',
+    },
+    activeTab: {
+        borderBottomColor: colors.tabSelected,
+        backgroundColor: themeName === 'dark' ? '#000000' : '#fff',
+        borderBottomLeftRadius: 12,
+        borderBottomRightRadius: 12,
+    },
+    tabText: {
+        ...typography.styles.text12Medium,
+        color: colors.textSecondary,
+        textAlign: 'center',
+    },
+    activeTabText: {
+        color: colors.tabSelected,
+        fontWeight: '600',
+        textAlign: 'center',
+    },
+    filterStatusContainer: {
+        paddingHorizontal: spacing.lg,
+        paddingVertical: spacing.sm,
+        backgroundColor: colors.background + '80', // 50% opacity
+        borderBottomWidth: 1,
+        borderBottomColor: colors.border + '20', // 20% opacity
+    },
+    filterStatusText: {
+        ...typography.styles.text12Regular,
+        color: colors.textSecondary,
+        textAlign: 'center',
+        fontStyle: 'italic',
+    },
+    fdOptionsContainer: {
+        paddingHorizontal: spacing.lg,
+        paddingBottom: spacing.xl,
+    },
+    // API Status Styles
+    apiStatusContainer: {
+        flexDirection: 'row',
+        justifyContent: 'space-between',
+        alignItems: 'center',
+        paddingHorizontal: spacing.lg,
+        paddingVertical: spacing.sm,
+        backgroundColor: colors.background,
+        borderBottomWidth: 1,
+        borderBottomColor: colors.border + '20', // 20% opacity
+    },
+    apiStatusIndicator: {
+        flexDirection: 'row',
+        alignItems: 'center',
+        flex: 1,
+    },
+    apiStatusText: {
+        ...typography.styles.text10Regular,
+        color: colors.textSecondary,
+        marginLeft: spacing.xs,
+    },
+    apiSuccessText: {
+        ...typography.styles.text10Regular,
+        color: colors.success,
+        marginLeft: spacing.xs,
+    },
+    apiErrorText: {
+        ...typography.styles.text10Regular,
+        color: colors.error,
+        marginLeft: spacing.xs,
+    },
+    refreshButton: {
+        paddingHorizontal: spacing.sm,
+        paddingVertical: spacing.xs,
+        backgroundColor: colors.primary + '20', // 20% opacity
+        borderRadius: spacing.xs,
+    },
+    refreshButtonText: {
+        ...typography.styles.text10Medium,
+        color: colors.primary,
+    },
+    noDataContainer: {
+        padding: spacing.lg,
+        alignItems: 'center',
+        justifyContent: 'center',
+        minHeight: 200,
+    },
+    noDataText: {
+        ...typography.styles.text14Regular,
+        color: colors.textSecondary,
+        textAlign: 'center',
+        lineHeight: 20,
+        marginBottom: spacing.md,
+    },
+    showAllButton: {
+        backgroundColor: colors.primary,
+        paddingHorizontal: spacing.lg,
+        paddingVertical: spacing.sm,
+        borderRadius: spacing.sm,
+        marginTop: spacing.md,
+    },
+    showAllButtonText: {
+        ...typography.styles.text14Medium,
+        color: '#ffffff', // Use white color directly
+        textAlign: 'center',
+    },
+});
+
+export default FDList;