import { useCallback } from 'react';
import { useAppDispatch, useAppSelector } from '@/lib/redux/hooks';
import {
    fetchChargeTypes,
    fetchServiceTypes,
    fetchVehicleTypePrices,
    fetchAddOnPrices,
    fetchServiceCharges,
    fetchMeetAndGreetPrices,
    addVehicleTypePrice,
    addAddOnPrice,
    addServiceCharge,
    addMeetAndGreetPrice,
    updateVehicleTypePrice,
    updateAddOnPrice,
    updateServiceCharge,
    updateMeetAndGreetPrice,
    deleteVehicleTypePrice,
    deleteAddOnPrice,
    deleteServiceCharge,
    deleteMeetAndGreetPrice,
    clearPricingData,
    setSelectedPlan,
} from '@/lib/redux/slices/pricingSlice';

export const usePricing = () => {
    const dispatch = useAppDispatch();

    // Selectors
    const chargeTypes = useAppSelector((state) => state.pricing.chargeTypes);
    const serviceTypes = useAppSelector((state) => state.pricing.serviceTypes);
    const vehicleTypePrices = useAppSelector((state) => state.pricing.vehicleTypePrices);
    const addOnPrices = useAppSelector((state) => state.pricing.addOnPrices);
    const serviceCharges = useAppSelector((state) => state.pricing.serviceCharges);
    const meetAndGreetPrices = useAppSelector((state) => state.pricing.meetAndGreetPrices);
    const selectedPlanId = useAppSelector((state) => state.pricing.paymentPlans.selectedPlanId);
    const filters = useAppSelector((state) => state.pricing.filters);

    // Actions
    const loadChargeTypes = useCallback(() => {
        dispatch(fetchChargeTypes());
    }, [dispatch]);

    const loadServiceTypes = useCallback(() => {
        dispatch(fetchServiceTypes());
    }, [dispatch]);

    const loadVehicleTypePrices = useCallback(
        (planId: number) => {
            dispatch(fetchVehicleTypePrices(planId));
        },
        [dispatch],
    );

    const loadAddOnPrices = useCallback(
        (planId: number) => {
            dispatch(fetchAddOnPrices(planId));
        },
        [dispatch],
    );

    const loadServiceCharges = useCallback(
        (planId: number) => {
            dispatch(fetchServiceCharges(planId));
        },
        [dispatch],
    );

    const loadMeetAndGreetPrices = useCallback(
        (planId: number) => {
            dispatch(fetchMeetAndGreetPrices(planId));
        },
        [dispatch],
    );

    const loadAllPricingData = useCallback(
        (planId: number) => {
            if (planId) {
                dispatch(fetchVehicleTypePrices(planId));
                dispatch(fetchAddOnPrices(planId));
                dispatch(fetchServiceCharges(planId));
                dispatch(fetchMeetAndGreetPrices(planId));
            }
        },
        [dispatch],
    );

    const createVehicleTypePrice = useCallback(
        async (planId: number, priceData: any) => {
            try {
                await dispatch(addVehicleTypePrice({ planId, price: priceData })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const createAddOnPrice = useCallback(
        async (planId: number, priceData: any) => {
            try {
                await dispatch(addAddOnPrice({ planId, price: priceData })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const createServiceCharge = useCallback(
        async (planId: number, chargeData: any) => {
            try {
                await dispatch(addServiceCharge({ planId, charge: chargeData })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const createMeetAndGreetPrice = useCallback(
        async (planId: number, priceData: any) => {
            try {
                await dispatch(addMeetAndGreetPrice({ planId, price: priceData })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const updateVehicleTypePriceItem = useCallback(
        async (planId: number, priceId: number, updates: any) => {
            try {
                await dispatch(updateVehicleTypePrice({ planId, priceId, updates })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const updateAddOnPriceItem = useCallback(
        async (planId: number, priceId: number, updates: any) => {
            try {
                await dispatch(updateAddOnPrice({ planId, priceId, updates })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const updateServiceChargeItem = useCallback(
        async (planId: number, chargeId: number, updates: any) => {
            try {
                await dispatch(updateServiceCharge({ planId, chargeId, updates })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const updateMeetAndGreetPriceItem = useCallback(
        async (planId: number, priceId: number, updates: any) => {
            try {
                await dispatch(updateMeetAndGreetPrice({ planId, priceId, updates })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const removeVehicleTypePrice = useCallback(
        async (planId: number, priceId: number) => {
            try {
                await dispatch(deleteVehicleTypePrice({ planId, priceId })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const removeAddOnPrice = useCallback(
        async (planId: number, priceId: number) => {
            try {
                await dispatch(deleteAddOnPrice({ planId, priceId })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const removeServiceCharge = useCallback(
        async (planId: number, chargeId: number) => {
            try {
                await dispatch(deleteServiceCharge({ planId, chargeId })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const removeMeetAndGreetPrice = useCallback(
        async (planId: number, priceId: number) => {
            try {
                await dispatch(deleteMeetAndGreetPrice({ planId, priceId })).unwrap();
                return { success: true };
            } catch (error: any) {
                return { success: false, error: error.message };
            }
        },
        [dispatch],
    );

    const selectPlan = useCallback(
        (planId: number | null) => {
            dispatch(setSelectedPlan(planId));
        },
        [dispatch],
    );

    const clearData = useCallback(() => {
        dispatch(clearPricingData());
    }, [dispatch]);

    return {
        // State
        chargeTypes,
        serviceTypes,
        vehicleTypePrices,
        addOnPrices,
        serviceCharges,
        meetAndGreetPrices,
        selectedPlanId,
        filters,

        // Actions
        loadChargeTypes,
        loadServiceTypes,
        loadVehicleTypePrices,
        loadAddOnPrices,
        loadServiceCharges,
        loadMeetAndGreetPrices,
        loadAllPricingData,

        // Create
        createVehicleTypePrice,
        createAddOnPrice,
        createServiceCharge,
        createMeetAndGreetPrice,

        // Update
        updateVehicleTypePriceItem,
        updateAddOnPriceItem,
        updateServiceChargeItem,
        updateMeetAndGreetPriceItem,

        // Delete
        removeVehicleTypePrice,
        removeAddOnPrice,
        removeServiceCharge,
        removeMeetAndGreetPrice,

        // Utility
        selectPlan,
        clearData,
    };
};