import { baseApi } from "./baseApi";
import { API_ENDPOINTS } from "./constant";
import {
  IAnswerComment,
  IAnswerListResponse,
  IBookmarkListResponse,
  IQuestionDetail,
  IQuestionListResponse,
} from "./types/questions";

export interface IQuestionListParams {
  page?: number;
  perPage?: number;
  sortBy?: string;
  sortDirection?: string;
  isTrending?: boolean;
  isGoodQuestion?: boolean;
  myQuestions?: boolean;
  /** Filter to a specific user's questions (public profile view). */
  userId?: number;
  categoryIds?: number[];
  answerFilter?: string[];
  searchText?: string;
  status?: string;
  goodQuestionsOnTopRandom?: boolean;
}

export interface IAnswerListParams {
  page?: number;
  perPage?: number;
  sortBy?: string;
  sortDirection?: string;
  status?: string;
  myAnswers?: boolean;
  /** Filter to a specific user's answers (public profile view). */
  userId?: number;
  drafts?: boolean;
  includeQuestion?: boolean;
}

export interface ICreateQuestionRequest {
  title: string;
  description: string;
  categoryIds: number[];
}

export type AnswerStatus = "draft" | "pending_approval";

export interface ICreateAnswerRequest {
  questionId: number;
  slug: string;
  body: string;
  status: AnswerStatus;
}

export interface IUpdateAnswerRequest {
  answerId: number;
  slug: string;
  body: string;
  status: AnswerStatus;
}

export interface ICreateAnswerCommentRequest {
  answerId: number;
  content: string;
  parentId?: number | null;
}

export interface ILikeEntityRequest {
  entityType: "question" | "answer";
  entityId: number;
}

export interface IBookmarkEntityRequest {
  entityType: "question" | "answer";
  entityId: number;
}

export interface IBookmarkListParams {
  entityType: "question" | "answer";
  page?: number;
  perPage?: number;
  sortBy?: string;
  sortDirection?: string;
}

export const seaqaApi = baseApi.injectEndpoints({
  endpoints: (builder) => ({
    getQuestionList: builder.query<IQuestionListResponse, IQuestionListParams>({
      query: (params) => ({
        url: API_ENDPOINTS.questionList,
        method: "GET",
        params: {
          sortBy: "id",
          sortDirection: "desc",
          myQuestions: false,
          perPage: 20,
          ...params,
        },
      }),
    }),
    getAnswerList: builder.query<IAnswerListResponse, IAnswerListParams>({
      query: (params) => ({
        url: API_ENDPOINTS.answerList,
        method: "GET",
        params: {
          sortBy: "id",
          sortDirection: "desc",
          perPage: 20,
          myAnswers: false,
          includeQuestion: false,
          ...params,
        },
      }),
      providesTags: ["Answer"],
    }),
    getQuestionBySlug: builder.query<IQuestionDetail, string>({
      query: (slug) => ({
        url: `${API_ENDPOINTS.questionBySlug}/${slug}`,
        method: "GET",
      }),
      providesTags: (_result, _error, slug) => [
        { type: "QuestionDetail", id: slug },
      ],
    }),
    createQuestion: builder.mutation<unknown, ICreateQuestionRequest>({
      query: (body) => ({
        url: API_ENDPOINTS.createQuestion,
        method: "POST",
        body,
      }),
    }),
    createAnswer: builder.mutation<unknown, ICreateAnswerRequest>({
      query: ({ questionId, body, status }) => ({
        url: `${API_ENDPOINTS.createAnswer}/${questionId}/answer`,
        method: "POST",
        body: { body, status },
      }),
      invalidatesTags: (_result, _error, { slug }) => [
        { type: "QuestionDetail", id: slug },
      ],
    }),
    updateAnswer: builder.mutation<unknown, IUpdateAnswerRequest>({
      query: ({ answerId, body, status }) => ({
        url: `${API_ENDPOINTS.answer}/${answerId}`,
        method: "PATCH",
        body: { body, status },
      }),
      invalidatesTags: (_result, _error, { slug }) => [
        { type: "QuestionDetail", id: slug },
        "Answer",
      ],
    }),
    deleteAnswer: builder.mutation<unknown, number>({
      query: (answerId) => ({
        url: `${API_ENDPOINTS.answer}/${answerId}`,
        method: "DELETE",
      }),
      // Refreshes the My Content answer/draft lists and their count queries.
      invalidatesTags: ["Answer"],
    }),

    getAnswerComments: builder.query<IAnswerComment[], number>({
      query: (answerId) => ({
        url: `${API_ENDPOINTS.answer}/${answerId}/comments`,
        method: "GET",
      }),
      providesTags: (_result, _error, answerId) => [
        { type: "AnswerComment", id: answerId },
      ],
    }),
    createAnswerComment: builder.mutation<unknown, ICreateAnswerCommentRequest>(
      {
        query: ({ answerId, content, parentId }) => ({
          url: `${API_ENDPOINTS.answer}/${answerId}/comment`,
          method: "POST",
          body: parentId != null ? { content, parentId } : { content },
        }),
        invalidatesTags: (_result, _error, { answerId }) => [
          { type: "AnswerComment", id: answerId },
          "QuestionDetail",
        ],
      },
    ),
    likeEntity: builder.mutation<unknown, ILikeEntityRequest>({
      query: ({ entityType, entityId }) => ({
        url: `/sea-qa/like/${entityType}/${entityId}`,
        method: "POST",
      }),
      invalidatesTags: ["QuestionDetail"],
    }),
    bookmarkEntity: builder.mutation<unknown, IBookmarkEntityRequest>({
      query: ({ entityType, entityId }) => ({
        url: `/sea-qa/bookmark/${entityType}/${entityId}`,
        method: "POST",
      }),
      invalidatesTags: ["Bookmark"],
    }),
    getBookmarkList: builder.query<IBookmarkListResponse, IBookmarkListParams>({
      query: (params) => ({
        url: `/sea-qa/bookmark/list`,
        method: "GET",
        // Most-recently bookmarked first; matches the question/answer lists.
        params: { sortBy: "id", sortDirection: "desc", perPage: 20, ...params },
      }),
      providesTags: ["Bookmark"],
    }),
  }),
});

export const {
  useGetQuestionListQuery,
  useGetAnswerListQuery,
  useGetQuestionBySlugQuery,
  useCreateQuestionMutation,
  useCreateAnswerMutation,
  useUpdateAnswerMutation,
  useDeleteAnswerMutation,
  useGetAnswerCommentsQuery,
  useCreateAnswerCommentMutation,
  useLikeEntityMutation,
  useBookmarkEntityMutation,
  useGetBookmarkListQuery,
} = seaqaApi;