import { createSlice, createAsyncThunk, type PayloadAction } from '@reduxjs/toolkit';
import { redirect } from 'next/navigation';

import api from '@/lib/axios';
import { handleAuthentication } from '@/lib/utils';

// Define a type for the business vertical
export interface BusinessVertical {
    id: number;
    name: string;
    teamMembersCount: number;
}

// Define the state type
interface BusinessVerticalsState {
    items: BusinessVertical[];
    status: 'idle' | 'loading' | 'succeeded' | 'failed';
    error: string | null;
    selectedVertical: BusinessVertical | null;
    dropdownItems: BusinessVertical[] | null;
    token: string | null;
    totalCount: number;
    filters: {
        search?: { [key: string]: string };
        sortBy?: string;
        sortOrder?: 'ASC' | 'DESC';
    };
}

// Initial state
const initialState: BusinessVerticalsState = {
    items: [],
    status: 'idle',
    error: null,
    selectedVertical: null,
    dropdownItems: null,
    token: null,
    totalCount: 0,
    filters: {
        search: {},
        sortBy: 'id',
        sortOrder: 'ASC',
    },
};

// Async thunks for API calls
export const fetchBusinessVerticals = createAsyncThunk(
    'businessVerticals/fetchBusinessVerticals',
    async (pagination: { skip?: number; limit?: number } = {}, { getState, rejectWithValue }) => {
        try {
            const state = getState() as { businessVerticals: BusinessVerticalsState };

            const { search, sortBy, sortOrder } = state?.businessVerticals?.filters;
            const limit = pagination.limit || 10;
            const skip = pagination.skip || 0;

            // Build query parameters object
            const params = {
                limit,
                skip,
                ...(sortBy && { sortBy }),
                ...(sortOrder && { sortOrder }),
                ...(search && typeof search === 'object' && search.name ? { search: search.name } : {}),
                ...(search && typeof search === 'string' ? { search } : {}),
            };

            // Convert params object to URL query string
            const queryParams = new URLSearchParams();
            Object.entries(params).forEach(([key, value]) => {
                if (value !== undefined) {
                    queryParams.append(key, value.toString());
                }
            });

            const response = await api.get(`/business-vertical/list?${queryParams.toString()}`, {});
            return response.data;
        } catch (error) {
            return rejectWithValue(error instanceof Error ? error.message : 'Failed to fetch business Verticals');
        }
    },
);

export const getBusinessVerticalsDropdown = createAsyncThunk(
    'businessVerticals/getBusinessVerticalsDropdown',
    async (_, { getState, rejectWithValue }) => {
        try {
            const response = await api.get(`/business-vertical/dropdown`);
            return response.data;
        } catch (error) {
            return rejectWithValue(error instanceof Error ? error.message : 'Failed to fetch business Vertical dropdown');
        }
    },
);

export const createBusinessVertical = createAsyncThunk(
    'businessVerticals/createBusinessVerticals',
    async (businessVerticalsData: Partial<BusinessVertical>, { getState, rejectWithValue }) => {
        try {
            const response = await api.post(`/business-vertical/create`, businessVerticalsData);
            return response;
        } catch (error) {
            return rejectWithValue(error instanceof Error ? error.message : 'Failed to create business Vertical');
        }
    },
);

export const getBusinessVerticalsById = createAsyncThunk(
    'businessVerticals/getBusinessVerticalsById',
    async (id: number, { getState, rejectWithValue }) => {
        try {
            const response = await api.get(`/business-vertical/list/${id}`);
            return response.data;
        } catch (error) {
            return rejectWithValue(error instanceof Error ? error.message : 'Failed to fetch business Vertical details');
        }
    },
);

export const updateBusinessVertical = createAsyncThunk(
    'businessVerticals/updateBusinessVertical',
    async ({ id, ...businessVerticalsData }: { id: number } & Partial<BusinessVertical>, { getState, rejectWithValue }) => {
        try {
            const response = await api.put(`/business-vertical/update/${id}`, businessVerticalsData);
            return response.data;
        } catch (error) {
            return rejectWithValue(error instanceof Error ? error.message : 'Failed to update business Vertical');
        }
    },
);

export const deleteBusinessVertical = createAsyncThunk(
    'businessVerticals/deleteBusinessVertical',
    async (id: number, { getState, rejectWithValue }) => {
        try {
            await api.delete(`/business-vertical/delete/${id}`);
            return id;
        } catch (error) {
            return rejectWithValue(error instanceof Error ? error.message : 'Failed to delete business Vertical');
        }
    },
);

// Create the slice
const businessVerticalsSlice = createSlice({
    name: 'businessVerticals',
    initialState,
    reducers: {
        setSelectedVertical: (state, action: PayloadAction<BusinessVertical | null>) => {
            state.selectedVertical = action.payload;
        },
        updateFilters: (state, action: PayloadAction<Partial<BusinessVerticalsState['filters']>>) => {
            state.filters = { ...state.filters, ...action.payload };
        },
        resetFilters: (state) => {
            state.filters = initialState.filters;
        },
    },
    extraReducers: (builder) => {
        builder
            .addCase(fetchBusinessVerticals.pending, (state) => {
                state.status = 'loading';
            })
            .addCase(fetchBusinessVerticals.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.items = action.payload;
            })
            .addCase(fetchBusinessVerticals.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            })
            .addCase(getBusinessVerticalsById.fulfilled, (state, action) => {
                state.selectedVertical = action.payload;
            })
            .addCase(createBusinessVertical.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            })
            .addCase(getBusinessVerticalsDropdown.pending, (state) => {
                state.status = 'loading';
                state.error = null;
            })
            .addCase(getBusinessVerticalsDropdown.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.dropdownItems = action.payload;
            })
            .addCase(getBusinessVerticalsDropdown.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            });
    },
});

export const { setSelectedVertical, updateFilters, resetFilters } = businessVerticalsSlice.actions;

export default businessVerticalsSlice.reducer;