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

// Define types based on your AddOn entity
export interface AddOn {
    id: number;
    name: string;
    description: string | null;
    vehicleModels: Array<{
        id: number;
        name: string;
        vehicle_manufacture_id: number;
        vehicle_type_id: number;
    }>;
    created_at: string;
    updated_at: string;
    deleted_at: string | null;
}

interface AddOnsState {
    items: AddOn[];
    status: 'idle' | 'loading' | 'succeeded' | 'failed';
    error: string | null;
    filters: {
        search: string;
        sortBy?: string;
        sortOrder?: 'ASC' | 'DESC';
        vehicle_model_ids: number[];
    };
    totalCount: number;
    tripAddOns: [];
}

// Initial state
const initialState: AddOnsState = {
    items: [],
    status: 'idle',
    error: null,
    filters: {
        search: '',
        sortBy: '',
        sortOrder: 'DESC',
        vehicle_model_ids: [],
    },
    totalCount: 0,
    tripAddOns: [],
};

// Async thunks for API calls
export const fetchAddOns = createAsyncThunk(
    'addOns/fetchAddOns',
    async (params: {
        skip?: number;
        limit?: number;
        search?: string;
        vehicle_model_ids?: number[];
        sortBy?: string;
        sortOrder?: 'ASC' | 'DESC';
    }) => {
        try {
            const response = await api.get(`/addons`, {
                params: {
                    skip: params.skip || 0,
                    limit: params.limit || 10,
                    search: params.search || '',
                    sortBy: params.sortBy,
                    sortOrder: params.sortOrder,
                    'vehicle_model_ids[]': params.vehicle_model_ids,
                },
            });
            return response.data.data;
        } catch (error: any) {
            return error.response;
        }
    },
);

export const tripAddOns = createAsyncThunk('trips-addOns/addOns', async (params: any) => {
    try {
        const response = await api.get('/addons/trip-addons', { params });

        return response?.data;
    } catch (error: any) {
        return error?.response;
    }
});

export const addAddOn = createAsyncThunk(
    'addOns/addAddOn',
    async (data: { name: string; description?: string; vehicle_model_ids: number[] }) => {
        try {
            const response = await api.post(`/addons`, data);
            return response;
        } catch (error: any) {
            return error.response;
        }
    },
);

export const updateAddOn = createAsyncThunk(
    'addOns/updateAddOn',
    async ({
        id,
        data,
    }: {
        id: number;
        data: {
            name: string;
            description?: string;
            vehicle_model_ids: number[];
        };
    }) => {
        try {
            const response = await api.patch(`/addons/${id}`, data);
            return response.data;
        } catch (error: any) {
            return error.response;
        }
    },
);

export const deleteAddOn = createAsyncThunk('addOns/deleteAddOn', async (id: number) => {
    try {
        const response = await api.delete(`/addons/${id}`);
        return response;
    } catch (error: any) {
        return error.response;
    }
});

export const fetchAddOnDetails = createAsyncThunk('addOns/fetchDetails', async (id: number) => {
    try {
        const response = await api.get(`/addons/${id}`);
        return response.data;
    } catch (error: any) {
        toast.error(error.response?.data?.message || messages.toasts.error.failed_to_fetch_addon);
        throw error;
    }
});

// Create the slice
const addOnsSlice = createSlice({
    name: 'addOns',
    initialState,
    reducers: {
        updateFilters: (state, action: PayloadAction<Partial<AddOnsState['filters']>>) => {
            state.filters = { ...state.filters, ...action.payload };
        },
        resetFilters: (state) => {
            state.filters = initialState.filters;
        },
    },
    extraReducers: (builder) => {
        builder
            .addCase(fetchAddOns.pending, (state) => {
                state.status = 'loading';
            })
            .addCase(fetchAddOns.fulfilled, (state, action) => {
                state.status = 'succeeded';

                if (action.payload && typeof action.payload === 'object' && 'data' in action.payload) {
                    state.items = Array.isArray(action.payload.data) ? action.payload.data : [];
                    state.totalCount = action.payload.count || 0;
                } else if (Array.isArray(action.payload)) {
                    state.items = action.payload;
                    state.totalCount = action.payload.length || 0;
                } else {
                    state.items = [];
                    state.totalCount = 0;
                }
            })
            .addCase(fetchAddOns.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            })
            .addCase(addAddOn.fulfilled, (state, action) => {
                const code = action.payload?.data?.code;

                if (code === 200 || code === 201) {
                    toast.success(messages.toasts.success.addon_added);
                } else if (code === 422) {
                    toast.error(messages.toasts.error.addon_exists);
                } else {
                    toast.error(messages.toasts.error.generic);
                }
            })
            .addCase(updateAddOn.fulfilled, (state, action) => {
                const code = action.payload?.code;

                if (code === 200 || code === 201) {
                    toast.success(messages.toasts.success.addon_updated);
                } else if (code === 422) {
                    toast.error(messages.toasts.error.addon_exists);
                } else {
                    toast.error(messages.toasts.error.generic);
                }
            })
            .addCase(deleteAddOn.fulfilled, (state, action) => {
                const code = action.payload?.data?.code;

                if (code === 200) {
                    toast.success(messages.toasts.success.addon_deleted);
                } else {
                    toast.error(messages.toasts.error.generic);
                }
            })
            .addCase(fetchAddOnDetails.pending, (state) => {
                state.status = 'loading';
            })
            .addCase(fetchAddOnDetails.fulfilled, (state, action) => {
                state.status = 'succeeded';
            })
            .addCase(fetchAddOnDetails.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.error.message || 'Failed to fetch add-on details';
            })
            .addCase(tripAddOns.pending, (state) => {
                state.status = 'loading';
            })
            .addCase(tripAddOns.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.tripAddOns = action.payload.data;
            })
            .addCase(tripAddOns.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            });
    },
});

export const { updateFilters, resetFilters } = addOnsSlice.actions;

export default addOnsSlice.reducer;