import { createSlice, createAsyncThunk, PayloadAction } from '@reduxjs/toolkit';

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

// Define interfaces
interface Address {
    address_type: string;
    address_line_1: string;
    address_line_2?: string;
    country: string;
    contry_id?: number;
    state: string;
    state_id?: number;
    city: string;
    zipcode: string;
    city_id?: number;
}

interface IdProof {
    id: number;
    document_type: string;
    document_number: string;
    expiry_date: string;
    document_files: any;
    created_at?: string;
    updated_at?: string;
}

export interface TeamMember {
    id: number;
    first_name: string;
    last_name: string;
    email: string;
    country_code: string;
    phone_number: string;
    dob: string;
    gender: string;
    employment_type: string;
    emergency_contact_name: string;
    emergency_contact_code: string;
    emergency_contact_number: string;
    working_location: string;
    working_city_location: string;
    role_id: number;
    role: {
        id: number;
        name: string;
    };
    department_id: number;
    department: {
        id: number;
        name: string;
    };
    business_vertical_id: number | null;
    business_vertical: {
        id: number;
        name: string;
    } | null;
    reporting_to_id: number | null;
    reporting_to: TeamMember | null;
    joining_date: string;
    status: 'active' | 'inactive';
    duty_status: string;
    profile_photo: string | null;
    addresses: Address[];
    id_proofs: IdProof[];
    state?: {
        id: number;
        name: string;
        country_id: number;
        created_at: string;
        updated_at: string;
    };
    created_at: string;
    updated_at: string;
}

export interface CreateTeamMemberDto {
    first_name: string;
    last_name: string;
    email: string;
    country_code: string;
    phone_number: string;
    dob: string;
    gender: string;
    employment_type: string;
    emergency_contact_name: string;
    emergency_contact_code: string;
    emergency_contact_number: string;
    working_location: string;
    working_city_location: string;
    role_id: number;
    depaertment?: string[];
    business_vertical?: string[];
    reporting_to_id?: number;
    joining_date: string;
    status: string;
    duty_status: string;
    addresses?: Address[];
    id_proofs?: IdProof[];
    state?: {
        id: number;
        name: string;
        country_id: number;
        created_at: string;
        updated_at: string;
    };
    current_step?: number;
    form_status?: string;
    document_files?: File[];
    profile_photo?: File;
    languages?: number[];
}

interface TeamMembersState {
    items: {
        count: number;
        data: TeamMember[];
    } | null;
    status: 'idle' | 'loading' | 'succeeded' | 'failed';
    error: string | null;
    selectedMember: TeamMember | null;
    filters: {
        search: string;
        roles: string[];
        departments: string[];
        businessVerticals: string[];
        status: string[];
        limit: number;
        skip: number;
        sortBy: string;
        sortOrder: 'ASC' | 'DESC';
        role_id?: number;
        department_id?: number;
        reporting_to?: number;
    };
    driver: any;
    count: any;
    driverAvailability: any;
    driverHistory: {
        data: any[];
        count: number;
    } | null;
    driverHistoryStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
    driverVehicleHistory: {
        data: any[];
        count: number;
    } | null;
    driverVehicleHistoryStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
    driverRatings: DriverRatings | null;
    driverRatingsStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
    reportingMembers: any[];
    roleReportingStatus: 'idle' | 'loading' | 'succeeded' | 'failed';
}

// Driver Ratings Interface - Updated to match new API response
export interface DriverRatings {
    ratingCount: number;
    averageRating: number;
    topTags: string[];
}

const initialState: TeamMembersState = {
    items: null,
    status: 'idle',
    error: null,
    selectedMember: null,
    reportingMembers: [],
    roleReportingStatus: 'idle',
    filters: {
        search: '',
        roles: [],
        departments: [],
        businessVerticals: [],
        status: [],
        limit: 10,
        skip: 0,
        sortBy: 'created_at',
        sortOrder: 'DESC',
        role_id: undefined,
        department_id: undefined,
        reporting_to: undefined,
    },
    driver: [],
    count: null,
    driverAvailability: null,
    driverHistory: null,
    driverHistoryStatus: 'idle',
    driverVehicleHistory: null,
    driverVehicleHistoryStatus: 'idle',
    driverRatings: null,
    driverRatingsStatus: 'idle',
};

// Async thunks
export const fetchTeamMembers = createAsyncThunk(
    'teamMembers/fetchTeamMembers',
    async (
        params: {
            search?: string;
            limit?: number;
            skip?: number;
            sortBy?: string;
            sortOrder?: 'ASC' | 'DESC';
            roles?: string;
            departments?: string;
            status?: string;
            reportingTo?: string;
        } = {},
        { rejectWithValue },
    ) => {
        try {
            const queryParams = new URLSearchParams();

            // Add all parameters to query string
            if (params.search) queryParams.append('search', params.search);
            if (params.limit !== undefined) queryParams.append('limit', params.limit.toString());
            if (params.skip !== undefined) queryParams.append('skip', params.skip.toString()); // This was missing proper handling
            if (params.sortBy) queryParams.append('sortBy', params.sortBy);
            if (params.sortOrder) queryParams.append('sortOrder', params.sortOrder);
            if (params.roles) queryParams.append('role_id', params.roles);
            if (params.departments) queryParams.append('department_id', params.departments);
            if (params.reportingTo) queryParams.append('reporting_to', params.reportingTo);
            if (params.status) queryParams.append('status', params.status);

            const response = await api.get(`/team-member/list?${queryParams.toString()}`);

            return response.data.data;
        } catch (error) {
            return rejectWithValue(error.message || 'Failed to fetch team members');
        }
    },
);

export const createTeamMember = createAsyncThunk(
    'teamMembers/createTeamMember',
    async (
        {
            data,
            profilePhoto,
            documentFiles,
        }: {
            data: CreateTeamMemberDto;
            profilePhoto?: File;
            documentFiles?: File[];
        },
        { rejectWithValue },
    ) => {
        try {
            const formData = new FormData();

            // Append team member data
            Object.keys(data).forEach((key) => {
                if (key === 'addresses' && Array.isArray(data[key])) {
                    data[key].forEach((address, index) => {
                        if (address.address_line_1 !== undefined) {
                            formData.append(`addresses[${index}][address_line_1]`, address.address_line_1 || null);
                        }

                        // Only append values that exist
                        if (address.country_id !== undefined)
                            formData.append(`addresses[${index}][country_id]`, String(address.country_id));

                        if (address.state_id !== undefined)
                            formData.append(`addresses[${index}][state_id]`, String(address.state_id));

                        if (address.city_id !== undefined)
                            formData.append(`addresses[${index}][city_id]`, String(address.city_id));

                        if (address.address_line_2 !== undefined)
                            formData.append(`addresses[${index}][address_line_2]`, address.address_line_2 || '');

                        // if (address.country) formData.append(`addresses[${index}][country]`, address.country);

                        // if (address.state) formData.append(`addresses[${index}][state]`, address.state);

                        if (address.zipcode !== undefined)
                            formData.append(`addresses[${index}][zipcode]`, address.zipcode || null);

                        if (address.address_type) formData.append(`addresses[${index}][address_type]`, address.address_type);
                    });
                } else if (key === 'id_proofs' && Array.isArray(data[key])) {
                    // Handle id_proofs specially to match the desired format
                    data[key].forEach((proof, index) => {
                        if (proof.document_type) {
                            formData.append(`id_proofs[${index}][document_type]`, proof.document_type);
                        }

                        if (proof.document_number) {
                            formData.append(`id_proofs[${index}][document_number]`, proof.document_number);
                        }

                        if (proof.document_files) {
                            formData.append(`document_files`, proof.document_files);
                        }
                    });
                } else {
                    // Append single values
                    if (data[key] !== undefined && data[key] !== null) {
                        formData.append(key, data[key].toString());
                    }
                }
            });

            if (data.status) {
                formData.append('status', data.status);
            }

            // Append profile photo if exists
            if (profilePhoto) {
                formData.append('profile_photo', profilePhoto);
            }

            // Updated document files handling
            if (documentFiles?.length) {
                // Link each document file to its corresponding id_proof
                documentFiles.forEach((file, index) => {
                    if (file instanceof File) {
                        formData.append(`id_proofs[${index}][document_files]`, file);
                    }
                });
            }
            const response = await api.post(`/team-member/create`, formData, {
                headers: {
                    'Content-Type': 'multipart/form-data',
                },
            });

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

export const createDriver = createAsyncThunk(
    'teamMembers/createDriver',
    async (
        {
            data,
            profilePhoto,
            documentFiles,
        }: {
            data: CreateTeamMemberDto;
            profilePhoto?: File;
            documentFiles?: File[];
        },
        { rejectWithValue },
    ) => {
        try {
            const formData = new FormData();

            // Append team member data
            Object.keys(data).forEach((key) => {
                if (key === 'addresses' && Array.isArray(data[key])) {
                    data[key].forEach((address, index) => {
                        if (address.address_line_1 !== undefined) {
                            formData.append(`addresses[${index}][address_line_1]`, address.address_line_1 || null);
                        }

                        // Only append values that exist
                        if (address.country_id !== undefined)
                            formData.append(`addresses[${index}][country_id]`, String(address.country_id));

                        if (address.state_id !== undefined)
                            formData.append(`addresses[${index}][state_id]`, String(address.state_id));

                        if (address.city_id !== undefined)
                            formData.append(`addresses[${index}][city_id]`, String(address.city_id));

                        if (address.address_line_2 !== undefined)
                            formData.append(`addresses[${index}][address_line_2]`, address.address_line_2 || '');

                        // if (address.country) formData.append(`addresses[${index}][country]`, address.country);

                        // if (address.state) formData.append(`addresses[${index}][state]`, address.state);

                        if (address.zipcode !== undefined)
                            formData.append(`addresses[${index}][zipcode]`, address.zipcode || null);

                        if (address.address_type) formData.append(`addresses[${index}][address_type]`, address.address_type);
                    });
                } else if (key === 'id_proofs' && Array.isArray(data[key])) {
                    // Handle id_proofs specially to match the desired format
                    data[key].forEach((proof, index) => {
                        if (proof.document_type) {
                            formData.append(`id_proofs[${index}][document_type]`, proof.document_type);
                        }

                        if (proof.document_number) {
                            formData.append(`id_proofs[${index}][document_number]`, proof.document_number);
                        }

                        if (proof.document_files) {
                            formData.append(`document_files`, proof.document_files);
                        }
                    });
                } else if (
                    (key === 'department' || key === 'business_vertical' || key === 'languages') &&
                    Array.isArray(data[key])
                ) {
                    // Handle array fields: append each value, or explicitly send empty array when none selected
                    if (data[key].length === 0) {
                        formData.append(key, '[]');
                    } else {
                        data[key].forEach((value, index) => {
                            formData.append(`${key}[${index}]`, value.toString());
                        });
                    }
                } else {
                    // Append single values
                    if (data[key] !== undefined && data[key] !== null) {
                        formData.append(key, data[key].toString());
                    }
                }
            });

            if (data.status) {
                formData.append('status', data.status);
            }

            // Append profile photo if exists
            if (profilePhoto) {
                formData.append('profile_photo', profilePhoto);
            }

            // Updated document files handling
            if (documentFiles?.length) {
                // Link each document file to its corresponding id_proof
                documentFiles.forEach((file, index) => {
                    if (file instanceof File) {
                        formData.append(`id_proofs[${index}][document_files]`, file);
                    }
                });
            }
            const response = await api.post(`/drivers/create`, formData, {
                headers: {
                    'Content-Type': 'multipart/form-data',
                },
            });

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

// In teamMembersSlice.ts
export const getTeamMemberById = createAsyncThunk('teamMembers/getTeamMemberById', async (id: number, { rejectWithValue }) => {
    try {
        const response = await api.get(`/team-member/list/${id}`);

        return response.data.data;
    } catch (error) {
        return rejectWithValue(error instanceof Error ? error.message : 'Failed to fetch team member details');
    }
});

// Fetch vehicle history for a driver
export const getDriverVehicleHistory = createAsyncThunk(
    'teamMembers/getDriverVehicleHistory',
    async (
        params: {
            driverId: number;
            skip?: number;
            limit?: number;
        },
        { rejectWithValue },
    ) => {
        try {
            const { driverId, skip = 0, limit = 10 } = params;
            const response = await api.get(`/drivers/vehicle/${driverId}`, {
                params: {
                    skip,
                    limit,
                },
            });
            return response.data;
        } catch (error) {
            return rejectWithValue(error instanceof Error ? error.message : 'Failed to fetch driver vehicle history');
        }
    },
);

// driver availability
export const getDriverAvailability = createAsyncThunk(
    'teamMembers/getDriverAvailability',
    async (driverId: number, { rejectWithValue }) => {
        try {
            const response = await api.get(`/driver-availability?driver_id=${driverId}`);
            return response.data.data; // Extract the data property from the response
        } catch (error) {
            return rejectWithValue(error instanceof Error ? error.message : 'Failed to fetch driver availability');
        }
    },
);

// driver history
// /api/driver-availability/history
export const getDriverHistory = createAsyncThunk(
    'teamMembers/getDriverHistory',
    async (driverId: number, { rejectWithValue }) => {
        try {
            const response = await api.get(`/driver-availability/history?driver_id=${driverId}`);
            return response.data.data; // Extract the data array from the response
        } catch (error) {
            return rejectWithValue(error instanceof Error ? error.message : 'Failed to fetch driver history');
        }
    },
);

export const getDriverRatings = createAsyncThunk(
    'teamMembers/getDriverRatings',
    async (driverId: number, { rejectWithValue }) => {
        try {
            const response = await api.get(`/drivers/count/ratings/${driverId}`);
            return response.data;
        } catch (error) {
            return rejectWithValue(error instanceof Error ? error.message : 'Failed to fetch driver ratings');
        }
    },
);

export const updateTeamMember = createAsyncThunk(
    'teamMembers/updateTeamMember',
    async (
        {
            id,
            data,
            profilePhoto,
            documentFiles,
        }: {
            id: number;
            data: Partial<CreateTeamMemberDto>;
            profilePhoto?: File;
            documentFiles?: File[];
        },
        { rejectWithValue },
    ) => {
        try {
            const formData = new FormData();

            // Handle id_proofs specifically if they exist
            if (data.id_proofs && Array.isArray(data.id_proofs)) {
                data.id_proofs.forEach((proof, index) => {
                    // Add ID if exists (for updates)
                    if (proof.id) {
                        formData.append(`id_proofs[${index}][id]`, proof.id.toString());
                    }

                    // Add document type
                    if (proof.document_type) {
                        formData.append(`id_proofs[${index}][document_type]`, proof.document_type);
                    }

                    // Add document number if available
                    if (proof.document_number) {
                        formData.append(`id_proofs[${index}][document_number]`, proof.document_number);
                    }

                    // Add document expiry date if available
                    if (proof.expiry_date) {
                        formData.append(`id_proofs[${index}][expiry_date]`, proof.expiry_date);
                    }

                    // ✅ FIXED: Handle document files properly
                    if (proof.document_files === null || proof.document_files === undefined) {
                        // ✅ Explicitly send empty string to signal removal
                        formData.append(`id_proofs[${index}][document_files]`, '');
                    } else if (proof.document_files instanceof File) {
                        // Create a new file with a name that includes the document type
                        const originalName = proof.document_files.name;
                        const fileExt = originalName.split('.').pop();
                        const newFileName = `${proof.document_type.replace('/', '_')}.${fileExt}`;

                        // Create a new File object with the renamed file
                        const renamedFile = new File([proof.document_files], newFileName, {
                            type: proof.document_files.type,
                        });

                        formData.append('document_files', renamedFile);
                    }
                    // ✅ If document_files is a string (URL), don't append anything - backend keeps existing file
                });
            }

            // Handle other fields separately from id_proofs
            Object.keys(data).forEach((key) => {
                // Skip id_proofs as we've already handled it
                if (key === 'id_proofs') return;

                // Handle arrays for department, business_vertical, and languages (include empty array so backend can clear)
                if ((key === 'department' || key === 'business_vertical' || key === 'languages') && Array.isArray(data[key])) {
                    if (data[key].length === 0) {
                        formData.append(key, '[]');
                    } else {
                        data[key].forEach((value, index) => {
                            formData.append(`${key}[${index}]`, value.toString());
                        });
                    }
                    return;
                }

                // Handle addresses array
                if (key === 'addresses' && Array.isArray(data[key])) {
                    data[key].forEach((address, index) => {
                        // Add address ID if exists (for updates)
                        if (address.id) {
                            formData.append(`addresses[${index}][id]`, address.id.toString());
                        }

                        // Add address type
                        if (address.address_type) {
                            formData.append(`addresses[${index}][address_type]`, address.address_type);
                        }

                        // Add address line 1
                        if (address.address_line_1 !== undefined) {
                            formData.append(`addresses[${index}][address_line_1]`, address.address_line_1 || '');
                        }

                        // Add address line 2
                        if (address.address_line_2 !== undefined) {
                            formData.append(`addresses[${index}][address_line_2]`, address.address_line_2 || '');
                        }

                        // Add country ID
                        if (address.country_id !== undefined && address.country_id !== null) {
                            formData.append(`addresses[${index}][country_id]`, String(address.country_id));
                        }

                        // Add state ID
                        if (address.state_id !== undefined && address.state_id !== null) {
                            formData.append(`addresses[${index}][state_id]`, String(address.state_id));
                        }

                        // Add city ID
                        if (address.city_id !== undefined && address.city_id !== null) {
                            formData.append(`addresses[${index}][city_id]`, String(address.city_id));
                        }

                        // Add zipcode
                        if (address.zipcode !== undefined) {
                            formData.append(`addresses[${index}][zipcode]`, address.zipcode || '');
                        }
                    });
                    return;
                }

                // Append single values (like form_status, current_step, etc.)
                if (data[key] !== undefined && data[key] !== null) {
                    formData.append(key, data[key].toString());
                }
            });

            // Append profile photo if exists
            if (profilePhoto) {
                formData.append('profile_photo', profilePhoto);
            }

            // Make the API request
            const response = await api.put(`/team-member/update/${id}`, formData, {
                headers: {
                    'Content-Type': 'multipart/form-data',
                },
            });

            // handleToastError(response);

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

export const updateDriver = createAsyncThunk(
    'teamMembers/updateDriver',
    async (
        {
            id,
            data,
            profilePhoto,
            documentFiles,
        }: {
            id: number;
            data: Partial<CreateTeamMemberDto>;
            profilePhoto?: File;
            documentFiles?: File[];
        },
        { rejectWithValue },
    ) => {
        try {
            const formData = new FormData();

            // Handle id_proofs specifically if they exist
            if (data.id_proofs && Array.isArray(data.id_proofs)) {
                data.id_proofs.forEach((proof, index) => {
                    // Add document type
                    formData.append(`id_proofs[${index}][document_type]`, proof.document_type);

                    // Add document number if available
                    if (proof.document_number) {
                        formData.append(`id_proofs[${index}][document_number]`, proof.document_number);
                    }

                    // Add document expiry date if available
                    if (proof.expiry_date) {
                        formData.append(`id_proofs[${index}][expiry_date]`, proof.expiry_date);
                    }

                    // Handle document files
                    if (proof.document_files instanceof File) {
                        // Create a new file with a name that includes the document type
                        const originalName = proof.document_files.name;
                        const fileExt = originalName.split('.').pop();
                        const newFileName = `${proof.document_type.replace('/', '_')}.${fileExt}`;

                        // Create a new File object with the renamed file
                        const renamedFile = new File([proof.document_files], newFileName, {
                            type: proof.document_files.type,
                        });

                        formData.append('document_files', renamedFile);
                    }
                });
            }

            // Handle other fields separately from id_proofs
            Object.keys(data).forEach((key) => {
                // Skip id_proofs as we've already handled it
                if (key === 'id_proofs') return;

                if ((key === 'department' || key === 'business_vertical' || key === 'languages') && Array.isArray(data[key])) {
                    if (data[key].length === 0) {
                        formData.append(key, '[]');
                    } else {
                        data[key].forEach((value, index) => {
                            formData.append(`${key}[${index}]`, value.toString());
                        });
                    }
                    return;
                }

                if (key === 'addresses' && Array.isArray(data[key])) {
                    data[key].forEach((address, index) => {
                        if (address.address_line_1 !== undefined) {
                            formData.append(`addresses[${index}][address_line_1]`, address.address_line_1 || null);
                        }

                        // Only append values that exist
                        if (address.country_id !== undefined)
                            formData.append(`addresses[${index}][country_id]`, String(address.country_id));

                        if (address.state_id !== undefined)
                            formData.append(`addresses[${index}][state_id]`, String(address.state_id));

                        if (address.city_id !== undefined)
                            formData.append(`addresses[${index}][city_id]`, String(address.city_id));

                        if (address.address_line_2 !== undefined)
                            formData.append(`addresses[${index}][address_line_2]`, address.address_line_2 || '');

                        // if (address.country) formData.append(`addresses[${index}][country]`, address.country);

                        // if (address.state) formData.append(`addresses[${index}][state]`, address.state);

                        if (address.zipcode !== undefined)
                            formData.append(`addresses[${index}][zipcode]`, address.zipcode || null);

                        if (address.address_type) formData.append(`addresses[${index}][address_type]`, address.address_type);
                    });
                } else {
                    // Append single values (like form_status, current_step, etc.)
                    if (data[key] !== undefined && data[key] !== null) {
                        formData.append(key, data[key].toString());
                    }
                }
            });

            // Append profile photo if exists
            if (profilePhoto) {
                formData.append('profile_photo', profilePhoto);
            }

            const response = await api.put(`/drivers/update/${id}`, formData, {
                headers: {
                    'Content-Type': 'multipart/form-data',
                },
            });

            handleToastError(response);

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

export const deleteTeamMember = createAsyncThunk('teamMembers/deleteTeamMember', async (id: number, { rejectWithValue }) => {
    try {
        await api.delete(`/team-member/delete/${id}`);

        return id;
    } catch (error: any) {
        handleToastError(error?.response);
        return rejectWithValue(error);
    }
});

export const getRoleReportingMembers = createAsyncThunk(
    'teamMembers/getRoleReportingMembers',
    async (id: number, { rejectWithValue }) => {
        try {
            const response = await api.get(`/team-member/reporting-by-role/${id}`);
            return response.data;
        } catch (error: any) {
            handleToastError(error?.response);
            return rejectWithValue(error);
        }
    },
);

export const deleteDocuments = createAsyncThunk(
    'teamMembers/deleteDocuments',
    async ({ teamMemberId, idProofId }: { teamMemberId: number; idProofId: number }, { rejectWithValue }) => {
        try {
            const response = await api.delete(`/team-member/${teamMemberId}/id-proof/${idProofId}`);
            return { idProofId, teamMemberId, data: response.data };
        } catch (error: any) {
            handleToastError(error?.response);
            return rejectWithValue(error?.response?.data || error.message);
        }
    },
);

export const fetchLanguages = createAsyncThunk('teamMembers/fetchLanguages', async (_, { rejectWithValue }) => {
    try {
        const response = await api.get(`/team-member/languages-dropdown`);
        return response.data.data;
    } catch (error: any) {
        handleToastError(error?.response);
        return rejectWithValue(error);
    }
});

// Slice
const teamMembersSlice = createSlice({
    name: 'teamMembers',
    initialState,
    reducers: {
        setSelectedMember: (state, action: PayloadAction<TeamMember | null>) => {
            state.selectedMember = action.payload;
        },
        setSelectedTeamMembers(state, action) {
            state.selectedMember = action.payload;
        },
        clearSelectedTeamMember(state) {
            state.selectedMember = null;
        },
        updateFilters: (state, action: PayloadAction<Partial<TeamMembersState['filters']>>) => {
            state.filters = { ...state.filters, ...action.payload };
        },
        resetFilters: (state) => {
            state.filters = initialState.filters;
        },
    },
    extraReducers: (builder) => {
        builder
            // Fetch team members
            .addCase(fetchTeamMembers.pending, (state) => {
                state.status = 'loading';
            })
            .addCase(fetchTeamMembers.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.items = action.payload;
                state.count = action.payload.count || 0;
            })
            .addCase(fetchTeamMembers.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            })

            // Create team member
            .addCase(createTeamMember.pending, (state) => {
                state.status = 'loading';
                state.error = null;
            })
            .addCase(createTeamMember.fulfilled, (state, action) => {
                // if (state.items?.data) {
                //   state.items.data.unshift(action.payload.data);
                //   state.items.count += 1;
                // }
            })

            .addCase(createDriver.pending, (state) => {
                state.status = 'loading';
                state.error = null;
            })
            .addCase(createDriver.fulfilled, (state, action) => {
                // if (state.items?.data) {
                //   state.items.data.unshift(action.payload.data);
                //   state.items.count += 1;
                // }
            })

            .addCase(updateTeamMember.pending, (state) => {
                state.status = 'loading';
                state.error = null;
            })
            .addCase(updateTeamMember.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.items = {
                    count: 1,
                    data: [action.payload],
                };
            })
            .addCase(updateTeamMember.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            })
            .addCase(updateDriver.pending, (state) => {
                state.status = 'loading';
                state.error = null;
            })
            .addCase(updateDriver.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.items = {
                    count: 1,
                    data: [action.payload],
                };
            })
            .addCase(updateDriver.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            })
            .addCase(getTeamMemberById.pending, (state) => {
                state.status = 'loading';
                state.error = null;
            })
            .addCase(getTeamMemberById.fulfilled, (state, action) => {
                state.status = 'succeeded';
                state.selectedMember = action.payload;
            })
            .addCase(getTeamMemberById.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
                state.selectedMember = null;
            })

            // Delete team member
            .addCase(deleteTeamMember.pending, (state) => {
                state.status = 'loading';
            })
            .addCase(deleteTeamMember.fulfilled, (state) => {
                state.status = 'succeeded';
                // List refresh is handled by fetchTeamMembers after delete succeeds
            })
            .addCase(deleteTeamMember.rejected, (state, action) => {
                state.status = 'failed';
                state.error = action.payload as string;
            })
            .addCase(getRoleReportingMembers.pending, (state) => {
                state.roleReportingStatus = 'loading';
            })
            .addCase(getRoleReportingMembers.fulfilled, (state, action) => {
                state.reportingMembers = action.payload?.data || [];
                state.roleReportingStatus = 'succeeded';
            })
            .addCase(getRoleReportingMembers.rejected, (state) => {
                state.roleReportingStatus = 'failed';
                state.reportingMembers = [];
            })

            .addCase(getDriverAvailability.fulfilled, (state, action) => {
                state.driverAvailability = action.payload;
            })
            .addCase(getDriverHistory.pending, (state) => {
                state.driverHistoryStatus = 'loading';
            })
            .addCase(getDriverHistory.fulfilled, (state, action) => {
                state.driverHistoryStatus = 'succeeded';
                state.driverHistory = action.payload;
            })
            .addCase(getDriverVehicleHistory.pending, (state) => {
                state.driverVehicleHistoryStatus = 'loading';
            })
            .addCase(getDriverVehicleHistory.fulfilled, (state, action) => {
                state.driverVehicleHistoryStatus = 'succeeded';

                const assignments = action.payload?.data?.data ?? [];
                const transformedData = assignments.map((assignment: any) => ({
                    id: assignment.id,
                    driverId: action.meta.arg.driverId,
                    assignmentDate: assignment.assigned_at,
                    vehicleRegistration: assignment.fleet?.registration_number ?? '',
                    vehicleMake: assignment.fleet?.vehicle_type?.name ?? '',
                    vehicleModel: `${assignment.fleet?.year ?? ''} ${assignment.fleet?.car_code ?? ''}`.trim(),
                    vehicleColor: assignment.fleet?.color ?? '',
                    status: assignment.released_at ? 'previous' : 'current',
                    unassignedDate: assignment.released_at || undefined,
                }));
                state.driverVehicleHistory = {
                    data: transformedData,
                    count: action.payload?.data?.count || 0,
                };
            })
            .addCase(getDriverVehicleHistory.rejected, (state, action) => {
                state.driverVehicleHistoryStatus = 'failed';
                state.driverVehicleHistory = null;
            })
            .addCase(getDriverHistory.rejected, (state, action) => {
                state.driverHistoryStatus = 'failed';
            })
            .addCase(getDriverRatings.pending, (state) => {
                state.driverRatingsStatus = 'loading';
            })
            .addCase(getDriverRatings.fulfilled, (state, action) => {
                state.driverRatingsStatus = 'succeeded';
                state.driverRatings = action.payload?.data;
            })
            .addCase(getDriverRatings.rejected, (state, action) => {
                state.driverRatingsStatus = 'failed';
                state.driverRatings = null;
            })
            .addCase(fetchLanguages.fulfilled, (state, action) => {
                state.languages = action.payload;
            })
            .addCase(deleteDocuments.fulfilled, (state, action) => {
                const { idProofId } = action.payload;

                // Update selected member (details page)
                if (state.selectedMember?.id_proofs) {
                    state.selectedMember.id_proofs = state.selectedMember.id_proofs.filter((proof) => proof.id !== idProofId);
                }

                // Update list data
                if (state.items?.data?.length) {
                    state.items.data = state.items.data.map((member) => {
                        if (!member.id_proofs?.length) return member;

                        return {
                            ...member,
                            id_proofs: member.id_proofs.filter((proof) => proof.id !== idProofId),
                        };
                    });
                }
            })
            .addCase(deleteDocuments.pending, (state) => {
                state.loading = true;
            })
            .addCase(deleteDocuments.rejected, (state, action) => {
                state.loading = false;
                state.error = action.payload;
            });
    },
});

export const { setSelectedMember, updateFilters, resetFilters, setSelectedTeamMembers, clearSelectedTeamMember } =
    teamMembersSlice.actions;

export default teamMembersSlice.reducer;