import { RejectedActionPayload } from '@/interface/Shared';
import {
  QuizAttempt,
  QuizAttemptDetail,
  AssessmentStats,
  NonCompleter,
  QuestionAnalyticsItem,
  PaginationMeta,
} from '@/interface/Assessment';
import Helpers from '@/utilities/Helpers';
import { createAsyncThunk, createSlice, Draft, PayloadAction } from '@reduxjs/toolkit';
import { message } from 'antd';
import { ResultsActions } from './actionTypes';
import { apiGet } from '@/services/api/api';
import { AxiosResponse } from 'axios';

interface ResultsState {
  results: QuizAttempt[];
  selectedResult: QuizAttemptDetail | null;
  stats: AssessmentStats | null;
  nonCompleters: NonCompleter[];
  questionAnalytics: QuestionAnalyticsItem[];
  meta: PaginationMeta | null;
  loading: boolean;
  error: string | null;
}

const initialState: ResultsState = {
  results: [],
  selectedResult: null,
  stats: null,
  nonCompleters: [],
  questionAnalytics: [],
  meta: null,
  loading: false,
  error: null,
};

export const fetchResults = createAsyncThunk(
  ResultsActions.FETCH_RESULTS_REQUEST,
  async (params?: {
    quiz_id?: string;
    assignment_id?: string;
    status?: string;
    date_from?: string;
    date_to?: string;
    page?: number;
  }) => {
    const queryParams = new URLSearchParams();
    if (params?.quiz_id) queryParams.append('quiz_id', params.quiz_id);
    if (params?.assignment_id) queryParams.append('assignment_id', params.assignment_id);
    if (params?.status) queryParams.append('status', params.status);
    if (params?.date_from) queryParams.append('date_from', params.date_from);
    if (params?.date_to) queryParams.append('date_to', params.date_to);
    if (params?.page) queryParams.append('page', params.page.toString());
    const query = queryParams.toString() ? `?${queryParams.toString()}` : '';
    const response = (await apiGet(`/assessment/results${query}`)) as AxiosResponse<{
      data: QuizAttempt[];
      meta: PaginationMeta;
    }>;
    return response.data;
  },
);

export const fetchResult = createAsyncThunk(
  ResultsActions.FETCH_RESULT_REQUEST,
  async (id: string) => {
    const response = (await apiGet(`/assessment/results/${id}`)) as AxiosResponse<QuizAttemptDetail>;
    return response.data;
  },
);

export const fetchStats = createAsyncThunk(
  ResultsActions.FETCH_STATS_REQUEST,
  async (quizId: string) => {
    const response = (await apiGet(
      `/assessment/results/stats?quiz_id=${quizId}`,
    )) as AxiosResponse<{ data: AssessmentStats }>;
    return response.data.data;
  },
);

export const fetchNonCompleters = createAsyncThunk(
  ResultsActions.FETCH_NON_COMPLETERS_REQUEST,
  async (quizId: string) => {
    const response = (await apiGet(
      `/assessment/results/non-completers?quiz_id=${quizId}`,
    )) as AxiosResponse<{ data: NonCompleter[] }>;
    return response.data.data;
  },
);

export const fetchQuestionAnalytics = createAsyncThunk(
  ResultsActions.FETCH_QUESTION_ANALYTICS_REQUEST,
  async (quizId: string) => {
    const response = (await apiGet(
      `/assessment/results/question-analytics?quiz_id=${quizId}`,
    )) as AxiosResponse<{ data: QuestionAnalyticsItem[] }>;
    return response.data.data;
  },
);

export const ResultsSlice = createSlice({
  name: 'assessmentResults',
  initialState,
  reducers: {
    clearSelectedResult: (state: Draft<ResultsState>) => {
      state.selectedResult = null;
    },
    clearStats: (state: Draft<ResultsState>) => {
      state.stats = null;
      state.nonCompleters = [];
      state.questionAnalytics = [];
    },
  },
  extraReducers(builder) {
    builder
      .addCase(fetchResults.pending, (state: Draft<ResultsState>) => {
        state.loading = true;
        state.error = null;
      })
      .addCase(
        fetchResults.fulfilled,
        (
          state: Draft<ResultsState>,
          action: PayloadAction<{ data: QuizAttempt[]; meta: PaginationMeta }>,
        ) => {
          state.results = action.payload.data;
          state.meta = action.payload.meta;
          state.loading = false;
        },
      )
      .addCase(fetchResults.rejected, (state: Draft<ResultsState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 8);
      });

    builder
      .addCase(fetchResult.pending, (state: Draft<ResultsState>) => {
        state.loading = true;
      })
      .addCase(
        fetchResult.fulfilled,
        (state: Draft<ResultsState>, action: PayloadAction<QuizAttemptDetail>) => {
          state.selectedResult = action.payload;
          state.loading = false;
        },
      )
      .addCase(fetchResult.rejected, (state: Draft<ResultsState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 8);
      });

    builder
      .addCase(fetchStats.pending, (state: Draft<ResultsState>) => {
        state.loading = true;
      })
      .addCase(
        fetchStats.fulfilled,
        (state: Draft<ResultsState>, action: PayloadAction<AssessmentStats>) => {
          state.stats = action.payload;
          state.loading = false;
        },
      )
      .addCase(fetchStats.rejected, (state: Draft<ResultsState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 8);
      });

    builder
      .addCase(fetchNonCompleters.pending, (state: Draft<ResultsState>) => {
        state.loading = true;
      })
      .addCase(
        fetchNonCompleters.fulfilled,
        (state: Draft<ResultsState>, action: PayloadAction<NonCompleter[]>) => {
          state.nonCompleters = action.payload;
          state.loading = false;
        },
      )
      .addCase(fetchNonCompleters.rejected, (state: Draft<ResultsState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 8);
      });

    builder
      .addCase(fetchQuestionAnalytics.pending, (state: Draft<ResultsState>) => {
        state.loading = true;
      })
      .addCase(
        fetchQuestionAnalytics.fulfilled,
        (state: Draft<ResultsState>, action: PayloadAction<QuestionAnalyticsItem[]>) => {
          state.questionAnalytics = action.payload;
          state.loading = false;
        },
      )
      .addCase(fetchQuestionAnalytics.rejected, (state: Draft<ResultsState>, action: RejectedActionPayload) => {
        state.loading = false;
        message.error(Helpers.handleServerError(action.payload), 8);
      });
  },
});

export const { clearSelectedResult, clearStats } = ResultsSlice.actions;
export default ResultsSlice;
export type { ResultsState };