import { RejectedActionPayload, ServerErrorResponse } from '@/interface/Shared';
import {
  CheckInAgendaItem,
  AgendaItemResponse,
  CreateAgendaItemPayload,
} from '@/interface/CheckIn';
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 { CheckInAgendaItemActions } from './actionTypes';

interface CheckInAgendaItemState {
  agendaItems: CheckInAgendaItem[];
  loading: boolean;
  error: string | null;
}

const initialState: CheckInAgendaItemState = {
  agendaItems: [],
  loading: false,
  error: null,
};

export const fetchAgendaItems = createAsyncThunk(
  CheckInAgendaItemActions.FETCH_AGENDA_ITEMS_REQUEST,
  async (checkInId: string) => {
    const response = (await apiGet(`/check-ins/${checkInId}/agenda-items`)) as AxiosResponse<{ data: CheckInAgendaItem[] }>;
    return response.data.data;
  },
);

export const createAgendaItem = createAsyncThunk(
  CheckInAgendaItemActions.CREATE_AGENDA_ITEM_REQUEST,
  async ({ checkInId, ...payload }: CreateAgendaItemPayload & { checkInId: string }, { rejectWithValue }) => {
    try {
      const response = (await apiPost(`/check-ins/${checkInId}/agenda-items`, payload)) as AxiosResponse<AgendaItemResponse>;
      return response.data.data;
    } catch (error) {
      if (axios.isAxiosError(error) && error.response) {
        return rejectWithValue(error.response.data as ServerErrorResponse);
      }
      throw error;
    }
  },
);

export const updateAgendaItem = createAsyncThunk(
  CheckInAgendaItemActions.UPDATE_AGENDA_ITEM_REQUEST,
  async ({ checkInId, id, ...payload }: Partial<CreateAgendaItemPayload> & { checkInId: string; id: string }, { rejectWithValue }) => {
    try {
      const response = (await apiPut(`/check-ins/${checkInId}/agenda-items/${id}`, payload)) as AxiosResponse<AgendaItemResponse>;
      return response.data.data;
    } catch (error) {
      if (axios.isAxiosError(error) && error.response) {
        return rejectWithValue(error.response.data as ServerErrorResponse);
      }
      throw error;
    }
  },
);

export const deleteAgendaItem = createAsyncThunk(
  CheckInAgendaItemActions.DELETE_AGENDA_ITEM_REQUEST,
  async ({ checkInId, id }: { checkInId: string; id: string }, { rejectWithValue }) => {
    try {
      const response = (await apiDelete(`/check-ins/${checkInId}/agenda-items/${id}`)) as AxiosResponse<{ message: string }>;
      return { message: response.data.message, id };
    } catch (error) {
      if (axios.isAxiosError(error) && error.response) {
        return rejectWithValue(error.response.data as ServerErrorResponse);
      }
      throw error;
    }
  },
);

export const CheckInAgendaItemSlice = createSlice({
  name: 'checkInAgendaItems',
  initialState,
  reducers: {
    clearAgendaItems: (state: Draft<CheckInAgendaItemState>) => {
      state.agendaItems = [];
    },
  },
  extraReducers(builder) {
    builder
      .addCase(fetchAgendaItems.pending, (state: Draft<CheckInAgendaItemState>) => {
        state.loading = true;
      })
      .addCase(fetchAgendaItems.fulfilled, (state: Draft<CheckInAgendaItemState>, action: PayloadAction<CheckInAgendaItem[]>) => {
        state.agendaItems = action.payload;
        state.loading = false;
      })
      .addCase(fetchAgendaItems.rejected, (state: Draft<CheckInAgendaItemState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 8);
      });

    builder
      .addCase(createAgendaItem.pending, (state: Draft<CheckInAgendaItemState>) => {
        state.loading = true;
      })
      .addCase(createAgendaItem.fulfilled, (state: Draft<CheckInAgendaItemState>, action: PayloadAction<CheckInAgendaItem>) => {
        state.agendaItems.push(action.payload);
        state.loading = false;
        message.success('Agenda item added successfully', 10);
      })
      .addCase(createAgendaItem.rejected, (state: Draft<CheckInAgendaItemState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 10);
      });

    builder
      .addCase(updateAgendaItem.pending, (state: Draft<CheckInAgendaItemState>) => {
        state.loading = true;
      })
      .addCase(updateAgendaItem.fulfilled, (state: Draft<CheckInAgendaItemState>, action: PayloadAction<CheckInAgendaItem>) => {
        const idx = state.agendaItems.findIndex((a) => a.id === action.payload.id);
        if (idx !== -1) state.agendaItems[idx] = action.payload;
        state.loading = false;
        message.success('Agenda item updated successfully', 10);
      })
      .addCase(updateAgendaItem.rejected, (state: Draft<CheckInAgendaItemState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 10);
      });

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

export const { clearAgendaItems } = CheckInAgendaItemSlice.actions;
export default CheckInAgendaItemSlice;
export type { CheckInAgendaItemState };