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

// Types for Treatment Plan based on actual API response
interface TreatmentPlanImage {
    id: number;
    treatment_plan_id: number;
    plan_image: string;
    created_at: string;
    updated_at: string;
    deleted_at: string | null;
}

interface Customer {
    id: number;
    customer_name: string;
    country_code: string;
    phone_number: string;
    email: string;
}

interface TreatmentPlan {
    id: number;
    customer_id: number;
    comments: string;
    created_at: string;
    updated_at: string;
    deleted_at: string | null;
    customer: Customer;
    images: TreatmentPlanImage[];
}

interface TreatmentPlanState {
    items: TreatmentPlan[];
    totalCount: number;
    status: 'idle' | 'loading' | 'succeeded' | 'failed';
    error: string | null;
}

const initialState: TreatmentPlanState = {
    items: [],
    totalCount: 0,
    status: 'idle',
    error: null,
};

// Async thunks
export const fetchTreatmentPlansByCustomerId = createAsyncThunk(
    'treatmentPlans/fetchByCustomerId',
    async (
        params: {
            customerId: number;
            limit?: number;
            skip?: number;
            search?: string;
            sortBy?: string;
            sortOrder?: string;
        },
        { rejectWithValue },
    ) => {
        try {
            const { customerId, limit = 10, skip = 0, search, sortBy, sortOrder } = params;
            const queryParams = new URLSearchParams({
                customer_id: customerId.toString(),
                limit: limit.toString(),
                skip: skip.toString(),
            });

            if (search) queryParams.append('search', search);
            if (sortBy) queryParams.append('sortBy', sortBy);
            if (sortOrder) queryParams.append('sortOrder', sortOrder);

            const url = `/customer-treatment-plan/admin?${queryParams.toString()}`;
            const response = await api.get(url);
            return response.data;
        } catch (error: any) {
            const errorMessage = handleToastError(error);
            return rejectWithValue(errorMessage);
        }
    },
);

const treatmentPlanSlice = createSlice({
    name: 'treatmentPlans',
    initialState,
    reducers: {
        clearError: (state) => {
            state.error = null;
        },
    },
    extraReducers: (builder) => {
        builder
            // Fetch treatment plans by customer ID
            .addCase(fetchTreatmentPlansByCustomerId.pending, (state) => {
                state.status = 'loading';
                state.error = null;
            })
            .addCase(fetchTreatmentPlansByCustomerId.fulfilled, (state, action) => {
                state.status = 'succeeded';
                // Handle the actual API response structure: { data: { count: number, data: TreatmentPlan[] } }
                if (action.payload.data) {
                    state.items = action.payload.data.data || [];
                    state.totalCount = action.payload.data.count || 0;
                } else {
                    state.items = action.payload.items || action.payload;
                    state.totalCount = action.payload.totalCount || action.payload.length || 0;
                }
                state.error = null;
            })
            .addCase(fetchTreatmentPlansByCustomerId.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            });
    },
});

export const { clearError } = treatmentPlanSlice.actions;
export default treatmentPlanSlice.reducer;

// Export types
export type { TreatmentPlan, TreatmentPlanImage, Customer };