import { createSlice, createAsyncThunk, type PayloadAction } from '@reduxjs/toolkit';
import api from '@/lib/axios';
import { toast } from 'sonner';
import messages from '../../../messages/en.json';

export const VEHICLE_PRICING_ENDPOINT = '/vehicle-pricing/plan';

export const ADD_ON_PRICING_ENDPOINT = '/add-ons-pricing/plan';

export const SERVICE_PRICING_ENDPOINT = '/service-pricing';

export const MEET_GREET_PRICING_ENDPOINT = '/meet-greet-pricing/plan';

export const fetchVehiclePricingData = async (
    planId: number,
    filters?: {
        city_id?: number | null;
        service_type_id?: number | null;
    },
) => {
    try {
        const params: any = {};
        if (filters?.city_id !== undefined && filters.city_id !== null) {
            params.city_id = filters.city_id;
        }
        if (filters?.service_type_id !== undefined && filters.service_type_id !== null) {
            params.service_type_id = filters.service_type_id;
        }

        const response = await api.get(`${VEHICLE_PRICING_ENDPOINT}/${planId}`, { params });
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_fetch_vehicle_pricing_data);
    }
};

export const fetchAddOnPricingData = async (
    planId: number,
    filters?: {
        city_id?: number | null;
        vehicle_type_id?: number | null;
    },
) => {
    try {
        const params: any = {};

        if (filters?.city_id !== undefined && filters.city_id !== null) {
            params.city_id = filters.city_id;
        }
        if (filters?.vehicle_type_id !== undefined && filters.vehicle_type_id !== null) {
            params.vehicle_type_id = filters.vehicle_type_id;
        }

        const response = await api.get(`${ADD_ON_PRICING_ENDPOINT}/${planId}`, { params });
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_fetch_addon_pricing_data);
    }
};

export const fetchServicePricingData = async (
    planId: number,
    filters?: {
        city_id?: number | null;
        service_type_id?: number | null;
    },
) => {
    try {
        const params: any = { plan_id: planId };

        if (filters?.city_id !== undefined && filters.city_id !== null) {
            params.city_id = filters.city_id;
        }
        if (filters?.service_type_id !== undefined && filters.service_type_id !== null) {
            params.service_type_id = filters.service_type_id;
        }

        const response = await api.get(SERVICE_PRICING_ENDPOINT, { params });
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_fetch_service_pricing_data);
    }
};

export const fetchMeetGreetPricingData = async (
    planId: number,
    filters?: {
        city_id?: number | null;
        service_type_id?: number | null;
    },
) => {
    try {
        const params: any = {};

        if (filters?.city_id !== undefined && filters.city_id !== null) {
            params.city_id = filters.city_id;
        }
        if (filters?.service_type_id !== undefined && filters.service_type_id !== null) {
            params.service_type_id = filters.service_type_id;
        }

        const response = await api.get(`${MEET_GREET_PRICING_ENDPOINT}/${planId}`, { params });
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_fetch_meet_greet_pricing_data);
    }
};

export const updateVehiclePricingData = async (id: number, updateData: Partial<CreateVehicleTypePriceDto>) => {
    try {
        const response = await api.patch(`/vehicle-pricing/${id}`, updateData);
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_update_vehicle_pricing_data);
    }
};

export const deleteVehiclePricingData = async (id: number) => {
    try {
        const response = await api.delete(`/vehicle-pricing/${id}`);
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_delete_vehicle_pricing_data);
    }
};

export const updateAddOnPricingData = async (id: number, updateData: Partial<CreateAddOnPriceDto>) => {
    try {
        const response = await api.patch(`/add-ons-pricing/${id}`, updateData);
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_update_addon_pricing_data);
    }
};

export const deleteAddOnPricingData = async (id: number) => {
    try {
        const response = await api.delete(`/add-ons-pricing/${id}`);
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_delete_addon_pricing_data);
    }
};

export const updateServicePricingData = async (id: number, updateData: Partial<CreateServiceChargeDto>) => {
    try {
        const response = await api.patch(`/service-pricing/${id}`, updateData);
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_update_service_pricing_data);
    }
};

export const deleteServicePricingData = async (id: number) => {
    try {
        const response = await api.delete(`/service-pricing/${id}`);
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_delete_service_pricing_data);
    }
};

export const updateMeetGreetPricingData = async (id: number, updateData: Partial<CreateMeetAndGreetPriceDto>) => {
    try {
        const response = await api.patch(`/meet-greet-pricing/${id}`, updateData);
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_update_meet_greet_pricing_data);
    }
};

export const deleteMeetGreetPricingData = async (id: number) => {
    try {
        const response = await api.delete(`/meet-greet-pricing/${id}`);
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_delete_meet_greet_pricing_data);
    }
};

export const fetchAddOnPricingDetail = async (id: any) => {
    try {
        const response = await api.get(`/add-ons-pricing/${id}`);
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_fetch_addon_pricing_detail);
    }
};

export const fetchVehiclePricingDetail = async (id: any) => {
    try {
        const response = await api.get(`/vehicle-pricing/${id}`);
        return response.data;
    } catch (err) {
        throw new Error(messages.toasts.error.failed_to_fetch_vehicle_pricing_detail);
    }
};

// Define types for the pricing structure
export interface ChargeType {
    id: number;
    name: string;
    uom: string; // Unit of Measure (per hour, per mile, flat, percentage, etc.)
    is_default: boolean;
    description?: string;
    status?: 'active' | 'inactive';
    created_at?: string;
    updated_at?: string;
}

export interface ServiceType {
    id: number;
    name: string;
    description?: string;
    is_default: boolean;
    status?: 'active' | 'inactive';
    created_at?: string;
    updated_at?: string;
}

export interface VehicleTypePrice {
    id: number;
    planId: number;
    vehicleTypeId: number;
    vehicleTypeName: string;
    basePrice: number;
    serviceTypeId: number;
    serviceTypeName: string;
    cityId?: number | null;
    cityName?: string | null;
    status?: 'active' | 'inactive';
    created_at?: string;
    updated_at?: string;
}

export interface AddOnPrice {
    id: number;
    planId: number;
    addOnId: number;
    addOnName: string;
    price: number | null;
    vehicleTypeId: number;
    vehicleTypeName: string;
    cityId?: number | null;
    cityName?: string | null;
    status?: 'active' | 'inactive';
    created_at?: string;
    updated_at?: string;
}

export interface ServiceCharge {
    id: number;
    planId: number;
    chargeTypeId: number;
    chargeTypeName: string;
    chargeTypeUom: string;
    value: number;
    serviceTypeId: number;
    serviceTypeName: string;
    cityId?: number | null;
    cityName?: string | null;
    status?: 'active' | 'inactive';
    created_at?: string;
    updated_at?: string;
}

export interface MeetAndGreetPrice {
    id: number;
    planId: number;
    serviceTypeId: number;
    serviceTypeName: string;
    locationTypeId?: number;
    locationTypeName?: string;
    price: number;
    cityId?: number | null;
    cityName?: string | null;
    status?: 'active' | 'inactive';
    created_at?: string;
    updated_at?: string;
}

export interface PaymentPlan {
    id: number;
    name: string;
    description?: string;
    is_default: boolean;
    status?: 'active' | 'inactive';
    vehicleTypePrices: VehicleTypePrice[];
    addOnPrices: AddOnPrice[];
    serviceCharges: ServiceCharge[];
    meetAndGreetPrices: MeetAndGreetPrice[];
    created_at?: string;
    updated_at?: string;
}

// DTOs for creating and updating
export interface CreateChargeTypeDto {
    name: string;
    uom: string;
    is_default: boolean;
    description?: string;
}

export interface CreateServiceTypeDto {
    name: string;
    description?: string;
    is_default: boolean;
}

export interface CreateVehicleTypePriceDto {
    plan_id: number;
    vehicle_type_id: number;
    price: number;
    service_type_id: number;
    city_id?: number | null;
}

export interface CreateAddOnPriceDto {
    plan_id: number;
    add_on_id: number;
    price: number;
    vehicle_type_id: number;
    city_id?: number | null;
}

export interface CreateServiceChargeDto {
    plan_id: number;
    charge_type_id: number;
    price: number;
    service_type_id: number;
    city_id?: number | null;
}

export interface CreateMeetAndGreetPriceDto {
    plan_id: number;
    service_type_id: number;
    location_type_id?: number;
    price: number;
    city_id?: number | null;
}

// Filter interfaces
export interface PricingFilters {
    search?: string;
    cityId?: number;
    vehicleTypeId?: number;
    serviceTypeId?: number;
    planId?: number;
    limit?: number;
    skip?: number;
}

export interface VehicleTypePriceFilters extends PricingFilters {
    planId: number;
}

export interface AddOnPriceFilters extends PricingFilters {
    planId: number;
}

export interface MeetAndGreetPriceFilters extends PricingFilters {
    planId: number;
}

// Response interfaces
export interface PricingResponse<T> {
    data: T[];
    count?: number;
}

// Define the state type
interface PricingState {
    chargeTypes: ChargeType[];
    chargeTypesStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
    chargeTypesError: string | null;

    serviceTypes: ServiceType[];
    serviceTypesStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
    serviceTypesError: string | null;

    paymentPlans: PaymentPlan[];
    paymentPlansStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
    paymentPlansError: string | null;
    selectedPlanId: number | null;

    vehicleTypePrices: VehicleTypePrice[];
    vehicleTypePricesStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
    vehicleTypePricesError: string | null;
    vehicleTypePricesTotalCount: number;

    addOnPrices: AddOnPrice[];
    addOnPricesStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
    addOnPricesError: string | null;
    addOnPricesTotalCount: number;

    serviceCharges: ServiceCharge[];
    serviceChargesStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
    serviceChargesError: string | null;
    serviceChargesTotalCount: number;

    meetAndGreetPrices: MeetAndGreetPrice[];
    meetAndGreetPricesStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
    meetAndGreetPricesError: string | null;
    meetAndGreetPricesTotalCount: number;

    filters: PricingFilters;
}

// Initial state
const initialState: PricingState = {
    chargeTypes: [],
    chargeTypesStatus: 'idle',
    chargeTypesError: null,

    serviceTypes: [],
    serviceTypesStatus: 'idle',
    serviceTypesError: null,

    paymentPlans: [],
    paymentPlansStatus: 'idle',
    paymentPlansError: null,
    selectedPlanId: null,

    vehicleTypePrices: [],
    vehicleTypePricesStatus: 'idle',
    vehicleTypePricesError: null,
    vehicleTypePricesTotalCount: 0,

    addOnPrices: [],
    addOnPricesStatus: 'idle',
    addOnPricesError: null,
    addOnPricesTotalCount: 0,

    serviceCharges: [],
    serviceChargesStatus: 'idle',
    serviceChargesError: null,
    serviceChargesTotalCount: 0,

    meetAndGreetPrices: [],
    meetAndGreetPricesStatus: 'idle',
    meetAndGreetPricesError: null,
    meetAndGreetPricesTotalCount: 0,

    filters: {
        search: '',
        cityId: undefined,
        vehicleTypeId: undefined,
        serviceTypeId: undefined,
        planId: undefined,
        limit: 10,
        skip: 0,
    },
};

// Async thunks for API calls

// Charge Types
export const fetchChargeTypes = createAsyncThunk('pricing/fetchChargeTypes', async (_, { rejectWithValue }) => {
    try {
        const response = await api.get('/charge-types');
        return response.data;
    } catch (err) {
        return rejectWithValue(messages.toasts.error.failed_to_fetch_charge_types);
    }
});

export const createChargeType = createAsyncThunk(
    'pricing/createChargeType',
    async (chargeType: CreateChargeTypeDto, { rejectWithValue }) => {
        try {
            const response = await api.post('/charge-types', chargeType);
            return response.data;
        } catch (err) {
            return rejectWithValue(messages.toasts.error.failed_to_create_charge_type);
        }
    },
);

// Service Types
export const fetchServiceTypes = createAsyncThunk('pricing/fetchServiceTypes', async (_, { rejectWithValue }) => {
    try {
        const response = await api.get('/service-types');
        return response.data;
    } catch (err) {
        return rejectWithValue(messages.toasts.error.failed_to_fetch_service_types);
    }
});

export const createServiceType = createAsyncThunk(
    'pricing/createServiceType',
    async (serviceType: CreateServiceTypeDto, { rejectWithValue }) => {
        try {
            const response = await api.post('/service-types', serviceType);
            return response.data;
        } catch (err) {
            return rejectWithValue(messages.toasts.error.failed_to_create_service_type);
        }
    },
);

// Payment Plans
export const fetchPaymentPlans = createAsyncThunk('pricing/fetchPaymentPlans', async (_, { rejectWithValue }) => {
    try {
        const response = await api.get('/payment-plans');
        return response.data;
    } catch (err) {
        return rejectWithValue(messages.toasts.error.failed_to_fetch_payment_plans);
    }
});

// Vehicle Type Prices
export const fetchVehicleTypePrices = createAsyncThunk(
    'pricing/fetchVehicleTypePrices',
    async (params: VehicleTypePriceFilters, { rejectWithValue }) => {
        try {
            const { planId, ...filters } = params;
            const response = await api.get(`${VEHICLE_PRICING_ENDPOINT}/${planId}`, { params: filters });
            return response.data;
        } catch (err) {
            return rejectWithValue(messages.toasts.error.failed_to_fetch_vehicle_type_prices);
        }
    },
);

export const createVehicleTypePrice = createAsyncThunk(
    'pricing/createVehicleTypePrice',
    async (price: CreateVehicleTypePriceDto, { rejectWithValue }) => {
        try {
            const response = await api.post('/vehicle-pricing', price);
            return response.data;
        } catch (err) {
            return rejectWithValue(messages.toasts.error.failed_to_create_vehicle_type_price);
        }
    },
);

// Add-On Prices - Updated to match API response
export const fetchAddOnPrices = createAsyncThunk(
    'pricing/fetchAddOnPrices',
    async (params: AddOnPriceFilters, { rejectWithValue }) => {
        try {
            const { planId, ...filters } = params;
            const response = await api.get(`/add-ons-pricing/plan/${planId}`, { params: filters });
            return response.data;
        } catch (err) {
            return rejectWithValue(messages.toasts.error.failed_to_fetch_addon_prices);
        }
    },
);

export const createAddOnPrice = createAsyncThunk(
    'pricing/createAddOnPrice',
    async (price: CreateAddOnPriceDto, { rejectWithValue }) => {
        try {
            const response = await api.post('/add-ons-pricing', price);
            return response.data;
        } catch (err) {
            return rejectWithValue(messages.toasts.error.failed_to_create_addon_price);
        }
    },
);

// Service Charges
export const fetchServiceCharges = createAsyncThunk(
    'pricing/fetchServiceCharges',
    async (params: PricingFilters, { rejectWithValue }) => {
        try {
            const response = await api.get(`/service-pricing/${params.planId}`, { params });
            return response.data;
        } catch (err) {
            return rejectWithValue('Failed to fetch service charges');
        }
    },
);

export const createServiceCharge = createAsyncThunk(
    'pricing/createServiceCharge',
    async (charge: CreateServiceChargeDto, { rejectWithValue }) => {
        try {
            const response = await api.post('/service-pricing', charge);
            return response.data;
        } catch (err) {
            return rejectWithValue('Failed to create service charge');
        }
    },
);

// Meet and Greet Prices - Updated to match API response
export const fetchMeetAndGreetPrices = createAsyncThunk(
    'pricing/fetchMeetAndGreetPrices',
    async (params: MeetAndGreetPriceFilters, { rejectWithValue }) => {
        try {
            const { planId, ...filters } = params;
            const response = await api.get(`/meet-greet-pricing/plan/${planId}`, { params: filters });
            return response.data;
        } catch (err) {
            return rejectWithValue('Failed to fetch meet and greet prices');
        }
    },
);

export const createMeetAndGreetPrice = createAsyncThunk(
    'pricing/createMeetAndGreetPrice',
    async (price: CreateMeetAndGreetPriceDto, { rejectWithValue }) => {
        try {
            const response = await api.post('/meet-greet-pricing', price);
            return response.data;
        } catch (err) {
            return rejectWithValue('Failed to create meet and greet price');
        }
    },
);

// Transform API response to match expected format
const transformAddOnPrices = (apiData: any[]): AddOnPrice[] => {
    return apiData.map((item) => ({
        id: item.id,
        planId: item.plan_id,
        addOnId: item.add_on_id,
        addOnName: item.add_on?.name || '',
        price: item.price ? parseFloat(item.price) : 0,
        vehicleTypeId: item.vehicle_type_id,
        vehicleTypeName: item.vehicle_type?.name || '',
        cityId: item.city_id,
        cityName: item.city?.name || null,
        created_at: item.created_at,
        updated_at: item.updated_at,
    }));
};

const transformMeetAndGreetPrices = (apiData: any[]): MeetAndGreetPrice[] => {
    return apiData.map((item) => ({
        id: item.id,
        planId: item.plan_id,
        serviceTypeId: item.service_type_id,
        serviceTypeName: item.service_type?.name || '',
        price: item.price ? parseFloat(item.price) : 0,
        cityId: item.city_id || null,
        cityName: item.city?.name || null,
        created_at: item.created_at,
        updated_at: item.updated_at,
    }));
};

// Create the slice
const pricingSlice = createSlice({
    name: 'pricing',
    initialState,
    reducers: {
        setFilters(state, action: PayloadAction<Partial<PricingFilters>>) {
            state.filters = { ...state.filters, ...action.payload };
        },
        resetFilters(state) {
            state.filters = initialState.filters;
        },
        setSelectedPlan(state, action: PayloadAction<number | null>) {
            state.selectedPlanId = action.payload;
        },
        clearPricingData(state) {
            state.vehicleTypePrices = [];
            state.addOnPrices = [];
            state.serviceCharges = [];
            state.meetAndGreetPrices = [];
            state.vehicleTypePricesTotalCount = 0;
            state.addOnPricesTotalCount = 0;
            state.serviceChargesTotalCount = 0;
            state.meetAndGreetPricesTotalCount = 0;
        },
        setChargeTypes(state, action: PayloadAction<ChargeType[]>) {
            state.chargeTypes = action.payload;
        },
        setServiceTypes(state, action: PayloadAction<ServiceType[]>) {
            state.serviceTypes = action.payload;
        },
        setPaymentPlans(state, action: PayloadAction<PaymentPlan[]>) {
            state.paymentPlans = action.payload;
        },
    },
    extraReducers: (builder) => {
        builder
            // Charge Types
            .addCase(fetchChargeTypes.pending, (state) => {
                state.chargeTypesStatus = 'loading';
            })
            .addCase(fetchChargeTypes.fulfilled, (state, action) => {
                state.chargeTypesStatus = 'succeeded';
                state.chargeTypes = action.payload.data?.data || [];
                state.chargeTypesError = null;
            })
            .addCase(fetchChargeTypes.rejected, (state, action) => {
                state.chargeTypesStatus = 'failed';
                state.chargeTypesError = action.payload as string;
                toast.error((action.payload as string) || messages.toasts.error.failed_to_fetch_charge_types);
            })
            .addCase(createChargeType.fulfilled, (state, action) => {
                state.chargeTypesStatus = 'succeeded';
            })
            .addCase(createChargeType.rejected, (_, action) => {
                toast.error((action.payload as string) || messages.toasts.error.failed_to_create_charge_type);
            })

            // Service Types
            .addCase(fetchServiceTypes.pending, (state) => {
                state.serviceTypesStatus = 'loading';
            })
            .addCase(fetchServiceTypes.fulfilled, (state, action) => {
                state.serviceTypesStatus = 'succeeded';
                state.serviceTypes = action.payload.data?.data || action.payload.data || [];
                state.serviceTypesError = null;
            })
            .addCase(fetchServiceTypes.rejected, (state, action) => {
                state.serviceTypesStatus = 'failed';
                state.serviceTypesError = action.payload as string;
                toast.error((action.payload as string) || messages.toasts.error.failed_to_fetch_service_types);
            })
            .addCase(createServiceType.fulfilled, (state, action) => {
                state.serviceTypesStatus = 'succeeded';
            })
            .addCase(createServiceType.rejected, (_, action) => {
                toast.error((action.payload as string) || messages.toasts.error.failed_to_create_service_type);
            })

            // Payment Plans
            .addCase(fetchPaymentPlans.pending, (state) => {
                state.paymentPlansStatus = 'loading';
            })
            .addCase(fetchPaymentPlans.fulfilled, (state, action) => {
                state.paymentPlansStatus = 'succeeded';
                state.paymentPlans = action.payload.data?.data || action.payload.data || [];
                state.paymentPlansError = null;
            })
            .addCase(fetchPaymentPlans.rejected, (state, action) => {
                state.paymentPlansStatus = 'failed';
                state.paymentPlansError = action.payload as string;
                toast.error((action.payload as string) || messages.toasts.error.failed_to_fetch_payment_plans);
            })

            // Vehicle Type Prices
            .addCase(fetchVehicleTypePrices.pending, (state) => {
                state.vehicleTypePricesStatus = 'loading';
            })
            .addCase(fetchVehicleTypePrices.fulfilled, (state, action) => {
                state.vehicleTypePricesStatus = 'succeeded';
                const responseData = action.payload.data;

                state.vehicleTypePrices = responseData?.data?.data || [];
                state.vehicleTypePricesTotalCount = responseData?.data?.count || 0;
            })
            .addCase(fetchVehicleTypePrices.rejected, (state, action) => {
                state.vehicleTypePricesStatus = 'failed';
                state.vehicleTypePricesError = action.payload as string;
                toast.error((action.payload as string) || messages.toasts.error.failed_to_fetch_vehicle_type_prices);
            })
            .addCase(createVehicleTypePrice.fulfilled, (state, action) => {
                state.vehicleTypePricesStatus = 'succeeded';
            })
            .addCase(createVehicleTypePrice.rejected, (_, action) => {
                toast.error((action.payload as string) || messages.toasts.error.failed_to_create_vehicle_type_price);
            })

            // Add-on Prices - Updated to handle API response structure
            .addCase(fetchAddOnPrices.pending, (state) => {
                state.addOnPricesStatus = 'loading';
            })
            .addCase(fetchAddOnPrices.fulfilled, (state, action) => {
                state.addOnPricesStatus = 'succeeded';
                const responseData = action.payload.data;
                if (responseData?.data) {
                    state.addOnPrices = transformAddOnPrices(responseData.data);
                    state.addOnPricesTotalCount = responseData.count || 0;
                } else {
                    state.addOnPrices = [];
                    state.addOnPricesTotalCount = 0;
                }
                state.addOnPricesError = null;
            })
            .addCase(fetchAddOnPrices.rejected, (state, action) => {
                state.addOnPricesStatus = 'failed';
                state.addOnPricesError = action.payload as string;
                toast.error((action.payload as string) || messages.toasts.error.failed_to_fetch_addon_prices);
            })
            .addCase(createAddOnPrice.fulfilled, (state, action) => {
                state.addOnPricesStatus = 'succeeded';
            })
            .addCase(createAddOnPrice.rejected, (_, action) => {
                toast.error((action.payload as string) || messages.toasts.error.failed_to_create_addon_price);
            })

            // Service Charges
            .addCase(fetchServiceCharges.pending, (state) => {
                state.serviceChargesStatus = 'loading';
            })
            .addCase(fetchServiceCharges.fulfilled, (state, action) => {
                state.serviceChargesStatus = 'succeeded';
                const responseData = action.payload.data;
                state.serviceCharges = responseData?.data || [];
                state.serviceChargesTotalCount = responseData?.count || 0;
                state.serviceChargesError = null;
            })
            .addCase(fetchServiceCharges.rejected, (state, action) => {
                state.serviceChargesStatus = 'failed';
                state.serviceChargesError = action.payload as string;
                toast.error((action.payload as string) || 'Failed to fetch service charges');
            })
            .addCase(createServiceCharge.fulfilled, (state, action) => {
                state.serviceChargesStatus = 'succeeded';
            })
            .addCase(createServiceCharge.rejected, (_, action) => {
                toast.error((action.payload as string) || 'Failed to create service charge');
            })

            // Meet and Greet Prices - Updated to handle API response structure
            .addCase(fetchMeetAndGreetPrices.pending, (state) => {
                state.meetAndGreetPricesStatus = 'loading';
            })
            .addCase(fetchMeetAndGreetPrices.fulfilled, (state, action) => {
                state.meetAndGreetPricesStatus = 'succeeded';
                const responseData = action.payload.data;
                if (responseData?.data) {
                    state.meetAndGreetPrices = transformMeetAndGreetPrices(responseData.data);
                    state.meetAndGreetPricesTotalCount = responseData.count || 0;
                } else {
                    state.meetAndGreetPrices = [];
                    state.meetAndGreetPricesTotalCount = 0;
                }
                state.meetAndGreetPricesError = null;
            })
            .addCase(fetchMeetAndGreetPrices.rejected, (state, action) => {
                state.meetAndGreetPricesStatus = 'failed';
                state.meetAndGreetPricesError = action.payload as string;
                toast.error((action.payload as string) || 'Failed to fetch meet and greet prices');
            })
            .addCase(createMeetAndGreetPrice.fulfilled, (state, action) => {
                state.meetAndGreetPricesStatus = 'succeeded';
            })
            .addCase(createMeetAndGreetPrice.rejected, (_, action) => {
                toast.error((action.payload as string) || 'Failed to create meet and greet price');
            });
    },
});

export const { setFilters, resetFilters, setSelectedPlan, clearPricingData, setChargeTypes, setServiceTypes, setPaymentPlans } =
    pricingSlice.actions;

export default pricingSlice.reducer;