import { RejectedActionPayload, ServerErrorResponse } from '@/interface/Shared';
import {
    CompetencyFramework,
    CompetencyFrameworkResponse,
    CreateCompetencyFrameworkPayload,
    PaginatedCompetencyFrameworks
} from '@/interface/CompetencyFramework';
import { apiDelete, apiGet, apiPost, apiPut } from '@/services/api/api';
import Helpers from '@/utilities/Helpers';
import { createAsyncThunk, createSlice, Draft, PayloadAction } from '@reduxjs/toolkit';
import { message } from 'antd';
import axios, { AxiosResponse } from 'axios';
import { CompetencyFrameworkActions } from './actionTypes';
import { PaginationLinks, PaginationMeta } from '@/interface/Paginated';
import { GetParams, toQueryString } from '@/interface/GetParams';

interface CompetencyFrameworkState {
    competencyFrameworks: CompetencyFramework[];
    links?: PaginationLinks;
    meta?: PaginationMeta;
    loading: boolean;
    error: string | null;
}

const initialState: CompetencyFrameworkState = {
    competencyFrameworks: [],
    loading: false,
    error: null,
};

export const fetchCompetencyFrameworks = createAsyncThunk(
    CompetencyFrameworkActions.FETCH_COMPETENCY_FRAMEWORK_REQUEST,
    async (params?: GetParams) => {
        const query = toQueryString(params);
        const response = (await apiGet(`/competency-frameworks${query}`)) as AxiosResponse<PaginatedCompetencyFrameworks>;
        return response.data;
    },
);

export const createCompetencyFramework = createAsyncThunk(
    CompetencyFrameworkActions.CREATE_COMPETENCY_FRAMEWORK_REQUEST,
    async (payload: CreateCompetencyFrameworkPayload, { rejectWithValue }) => {
        try {
            const response = (await apiPost(
                '/competency-frameworks',
                payload,
            )) as AxiosResponse<CompetencyFrameworkResponse>;
            return response.data.data;
        } catch (error) {
            if (axios.isAxiosError(error) && error.response) {
                return rejectWithValue(error.response.data as ServerErrorResponse);
            }
            throw error;
        }
    },
);

export const updateCompetencyFramework = createAsyncThunk(
    CompetencyFrameworkActions.UPDATE_COMPETENCY_FRAMEWORK_REQUEST,
    async (payload: CreateCompetencyFrameworkPayload & { id: string }, { rejectWithValue }) => {
        try {
            const response = (await apiPut(
                `/competency-frameworks/${payload.id}`,
                payload,
            )) as AxiosResponse<CompetencyFrameworkResponse>;
            return response.data.data;
        } catch (error) {
            if (axios.isAxiosError(error) && error.response) {
                return rejectWithValue(error.response.data as ServerErrorResponse);
            }
            throw error;
        }
    },
);

export const deleteCompetencyFramework = createAsyncThunk(
    CompetencyFrameworkActions.DELETE_COMPETENCY_FRAMEWORK_REQUEST,
    async (payload: string, { rejectWithValue }) => {
        try {
            const response = (await apiDelete(
                `/competency-frameworks/${payload}`,
            )) as AxiosResponse<{ message: string }>;
            return {
                message: response.data.message,
                id: payload
            };
        } catch (error) {
            if (axios.isAxiosError(error) && error.response) {
                return rejectWithValue(error.response.data as ServerErrorResponse);
            }
            throw error;
        }
    },
);

export const CompetencyFrameworkSlice = createSlice({
    name: 'competencyFrameworks',
    initialState,
    reducers: {},
    extraReducers(builder) {
        builder
            .addCase(fetchCompetencyFrameworks.pending, (state: Draft<CompetencyFrameworkState>) => {
                state.loading = true;
                state.error = null;
            })
            .addCase(
                fetchCompetencyFrameworks.fulfilled,
                (state: Draft<CompetencyFrameworkState>, action: PayloadAction<CompetencyFramework[] | PaginatedCompetencyFrameworks>) => {
                    if (Array.isArray(action.payload)) {
                        state.competencyFrameworks = action.payload;
                        state.meta = undefined;
                        state.links = undefined;
                    } else {
                        state.competencyFrameworks = action.payload.data;
                        state.meta = action.payload.meta;
                        state.links = action.payload.links;
                    }
                    state.error = null;
                    state.loading = false;
                },
            )
            .addCase(fetchCompetencyFrameworks.rejected, (state: Draft<CompetencyFrameworkState>) => {
                state.loading = false;
                message.error(
                    'Failed to load Competency Frameworks. Please try again or contact support if the issue persists',
                );
            });

        builder
            .addCase(createCompetencyFramework.pending, (state: Draft<CompetencyFrameworkState>) => {
                state.loading = true;
                state.error = null;
            })
            .addCase(
                createCompetencyFramework.fulfilled,
                (state: Draft<CompetencyFrameworkState>, action: PayloadAction<CompetencyFramework>) => {
                    state.competencyFrameworks.unshift(action.payload);
                    state.error = null;
                    state.loading = false;
                },
            )
            .addCase(
                createCompetencyFramework.rejected,
                (state: Draft<CompetencyFrameworkState>, action: RejectedActionPayload) => {
                    state.loading = false;
                    message.error(Helpers.handleServerError(action.payload), 10);
                },
            );

        builder
            .addCase(updateCompetencyFramework.pending, (state: Draft<CompetencyFrameworkState>) => {
                state.loading = true;
                state.error = null;
            })
            .addCase(
                updateCompetencyFramework.fulfilled,
                (state: Draft<CompetencyFrameworkState>, action: PayloadAction<CompetencyFramework>) => {
                    state.loading = false;
                    state.error = null;
                    message.success('Successfully updated Competency Framework', 10);
                },
            )
            .addCase(
                updateCompetencyFramework.rejected,
                (state: Draft<CompetencyFrameworkState>, action: RejectedActionPayload) => {
                    state.loading = false;
                    message.error(Helpers.handleServerError(action.payload), 10);
                },
            );

        builder
            .addCase(deleteCompetencyFramework.pending, (state: Draft<CompetencyFrameworkState>) => { })
            .addCase(
                deleteCompetencyFramework.fulfilled,
                (state: Draft<CompetencyFrameworkState>, action: PayloadAction<{ message: string; id: string }>) => {
                    state.competencyFrameworks = state.competencyFrameworks.filter((item) => item.id !== action.payload.id);
                    message.success(action.payload.message, 10);
                },
            )
            .addCase(deleteCompetencyFramework.rejected, (state: Draft<CompetencyFrameworkState>, action: RejectedActionPayload) => {
                message.error(Helpers.handleServerError(action.payload), 8);
            });
    },
});

export default CompetencyFrameworkSlice;
export type { CompetencyFrameworkState };