// src/store/slices/customerTagsSlice.ts
import api from '@/lib/axios';
import { createAsyncThunk, createSlice, type PayloadAction } from '@reduxjs/toolkit';
import { toast } from 'sonner';

export interface CustomerTag {
    id: number;
    name: string;
    type: string | null;
    created_at?: string;
    updated_at?: string;
}

interface CustomerTagsState {
    items: CustomerTag[];
    status: 'idle' | 'loading' | 'succeeded' | 'failed';
    error: string | null;
    filters: {
        search: string;
        sortBy?: string;
        sortOrder?: 'ASC' | 'DESC';
    };
    totalCount: number;
    details: CustomerTag | null;
}

const initialState: CustomerTagsState = {
    items: [],
    status: 'idle',
    error: null,
    filters: {
        search: '',
        sortBy: '',
        sortOrder: 'ASC',
    },
    totalCount: 0,
    details: null,
};

export const fetchCustomerTags = createAsyncThunk(
    'customerTags/fetchCustomerTags',
    async (params: { skip?: number; limit?: number; search?: string; sortBy?: string; sortOrder?: 'ASC' | 'DESC' }) => {
        const response = await api.get('/customer-tags', {
            params: {
                skip: params.skip ?? 0,
                limit: params.limit ?? 10,
                search: params.search ?? '',
                sortBy: params.sortBy,
                sortOrder: params.sortOrder,
            },
        });
        return response.data.data;
    },
);

export const addCustomerTag = createAsyncThunk(
    'customerTags/addCustomerTag',
    async (data: { name: string; type?: string | null }) => {
        const response = await api.post('/customer-tags', data);
        return response;
    },
);

export const updateCustomerTag = createAsyncThunk(
    'customerTags/updateCustomerTag',
    async ({ id, data }: { id: number; data: { name: string; type?: string | null } }) => {
        const response = await api.patch(`/customer-tags/${id}`, data);
        return response.data;
    },
);

export const deleteCustomerTag = createAsyncThunk('customerTags/deleteCustomerTag', async (id: number, { rejectWithValue }) => {
    try {
        const response = await api.delete(`/customer-tags/${id}`);

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

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

export const fetchCustomerTagDetails = createAsyncThunk('customerTags/fetchCustomerTagDetails', async (id: number) => {
    const response = await api.get(`/customer-tags/${id}`);
    return response.data;
});

// ---------- Slice ----------
const customerTagsSlice = createSlice({
    name: 'customerTags',
    initialState,
    reducers: {
        updateFilters: (state, action: PayloadAction<Partial<CustomerTagsState['filters']>>) => {
            state.filters = { ...state.filters, ...action.payload };
        },
        resetFilters: (state) => {
            state.filters = initialState.filters;
        },
    },
    extraReducers: (builder) => {
        builder
            // Fetch list
            .addCase(fetchCustomerTags.pending, (state) => {
                state.status = 'loading';
            })
            .addCase(fetchCustomerTags.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.items = action.payload?.data;
                state.totalCount = action.payload?.count;
            })
            .addCase(fetchCustomerTags.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.error.message || 'Failed to fetch customer tags';
            })
            // Add
            .addCase(addCustomerTag.fulfilled, (state, action) => {
                const code = action.payload?.data?.code;
                if (code === 200 || code === 201) {
                    toast.success('Customer Tag added successfully');
                } else if (code === 422) {
                    toast.error('Customer Tag already exists');
                } else {
                    toast.error('Something went wrong');
                }
            })
            // Update
            .addCase(updateCustomerTag.fulfilled, (state, action) => {
                const code = action.payload?.code;
                if (code === 200 || code === 201) {
                    toast.success('Customer Tag updated successfully');
                } else if (code === 422) {
                    toast.error('Customer Tag already exists');
                } else {
                    toast.error('Something went wrong');
                }
            })
            // Delete
            .addCase(deleteCustomerTag.fulfilled, (state, action) => {
                state.items = state.items.filter((item) => item.id !== action.payload);
            })
            // Details
            .addCase(fetchCustomerTagDetails.pending, (state) => {
                state.status = 'loading';
            })
            .addCase(fetchCustomerTagDetails.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.details = action.payload?.data;
            })
            .addCase(fetchCustomerTagDetails.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.error.message || 'Failed to fetch customer tag details';
            });
    },
});

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

export default customerTagsSlice.reducer;