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

// Define a type for the vehicle type
export interface VehicleType {
    id: number;
    name: string;
    status: number;
}

// Define the state type
interface VehicleTypesState {
    items: VehicleType[];
    filteredItems: VehicleType[];
    status: 'idle' | 'loading' | 'succeeded' | 'failed';
    error: string | null;
    filters: {
        search: string;
        sortBy?: string;
        sortOrder?: 'ASC' | 'DESC';
    };
    totalCount: number;
}

// Initial state
const initialState: VehicleTypesState = {
    items: [],
    filteredItems: [],
    status: 'idle',
    error: null,
    filters: {
        search: '',
        sortBy: '',
        sortOrder: 'ASC',
    },
    totalCount: 0,
};

// Async thunks for API calls
export const fetchVehicleTypes = createAsyncThunk(
    'vehicleTypes/fetchVehicleTypes',
    async (
        params: { skip?: number; limit?: number; search?: string; sortBy?: string; sortOrder?: 'ASC' | 'DESC' },
        { rejectWithValue },
    ) => {
        try {
            const response = await api.get(`/vehicle-types`, {
                params: {
                    skip: params.skip || 0,
                    limit: params.limit || 10,
                    search: params.search || '',
                    sortBy: params.sortBy,
                    sortOrder: params.sortOrder,
                },
            });
            return response.data.data;
        } catch (error: any) {
            return rejectWithValue(error.response?.data?.message || 'Failed to fetch vehicle types');
        }
    },
);

export const addVehicleType = createAsyncThunk('vehicleTypes/addVehicleType', async (name: string) => {
    try {
        const response = await api.post(`/vehicle-types`, { name });
        return response;
    } catch (error: any) {
        return error.response;
    }
});

export const updateVehicleType = createAsyncThunk(
    'vehicleTypes/updateVehicleType',
    async ({ id, name }: { id: number; name: string }) => {
        try {
            const response = await api.patch(`/vehicle-types/${id}`, {
                name,
            });
            return response;
        } catch (error: any) {
            return error.response;
        }
    },
);

export const deleteVehicleType = createAsyncThunk('vehicleTypes/deleteVehicleType', async (id: number, { rejectWithValue }) => {
    try {
        const response = await api.delete(`/vehicle-types/${id}`);

        if (response?.data?.success === false) {
            toast.error(response.data.message || 'Failed to delete vehicle type');
            return rejectWithValue(response.data.message || 'Deletion failed');
        }

        toast.success('Vehicle type deleted successfully');
        return id;
    } catch (error) {
        return rejectWithValue(error instanceof Error ? error.message : 'Failed to delete vehicle type');
    }
});

export const fetchVehicleTypeDetails = createAsyncThunk('vehicleTypes/fetchDetails', async (id: number) => {
    try {
        const response = await api.get(`/vehicle-types/${id}`);
        return response.data;
    } catch (error: any) {
        throw error.response?.data || error.message;
    }
});

export const fetchVehicleTypesByAddOn = createAsyncThunk(
    'vehicleTypes/fetchVehicleTypesByAddOn',
    async (params: { add_on_id: number; limit?: number; skip?: number }, { rejectWithValue }) => {
        try {
            const response = await api.get(`/vehicle-types/add-on`, {
                params: {
                    add_on_id: params.add_on_id,
                    limit: params.limit || 10,
                    skip: params.skip || 0,
                },
            });
            return response.data.data;
        } catch (error: any) {
            return rejectWithValue(error.response?.data?.message || 'Failed to fetch vehicle types for add-on');
        }
    },
);

const vehicleTypesSlice = createSlice({
    name: 'vehicleTypes',
    initialState,
    reducers: {
        updateFilters: (state, action: PayloadAction<Partial<VehicleTypesState['filters']>>) => {
            state.filters = { ...state.filters, ...action.payload };
        },
        resetFilters: (state) => {
            state.filters = initialState.filters;
        },
    },
    extraReducers: (builder) => {
        builder
            .addCase(fetchVehicleTypes.pending, (state) => {
                state.status = 'loading';
            })
            .addCase(fetchVehicleTypes.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.items = action.payload.data;
                state.totalCount = action.payload.count;
            })
            .addCase(fetchVehicleTypes.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            })

            .addCase(addVehicleType.fulfilled, (state, action) => {
                const code = action.payload?.data?.code;

                if (code === 200 || code === 201) {
                    state.items.push(action.payload.data.data);

                    toast.success('Vehicle Type added successfully');
                } else if (code === 422) {
                    toast.error('Vehicle already exists');
                } else {
                    toast.error('Something went wrong');
                }
            })

            .addCase(updateVehicleType.fulfilled, (state, action) => {
                const code = action.payload?.data?.code;

                if (code === 200 || code === 201) {
                    state.items.push(action.payload.data.data);

                    toast.success('Vehicle Type updated successfully');
                } else if (code === 422) {
                    toast.error('Vehicle already exists');
                } else {
                    toast.error('Something went wrong');
                }
            })
            .addCase(deleteVehicleType.fulfilled, (state, action) => {
                state.items = state.items.filter((item) => item.id !== action.payload);
            })
            .addCase(fetchVehicleTypesByAddOn.pending, (state) => {
                state.status = 'loading';
            })
            .addCase(fetchVehicleTypesByAddOn.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.filteredItems = action.payload.data || [];
            })
            .addCase(fetchVehicleTypesByAddOn.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
                state.filteredItems = [];
            });
    },
});

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

export default vehicleTypesSlice.reducer;