import axiosClient from '../axios/axios';
import { API_ROUTES } from '@/constants/apiRoutes';
import type {
  AssignTicketPayload,
  AssignableTicketUsersResponse,
  AssignableTicketUsersParams,
  CloseTicketPayload,
  RequestTicketExtensionPayload,
  ReviewTicketExtensionPayload,
  SseTokenResponse,
  TicketAssignmentSummary,
  TicketAssignmentDetectionsParams,
  TicketAssignmentDetectionsResponse,
  TicketAssignmentsResponse,
  TicketExtensionRequestsResponse,
  TicketExtensionRequestsParams,
  TicketOverviewDetail,
  TicketListParams,
  TicketListResponse,
  TicketSummaryParams,
  TicketSummaryResponse,
  TicketTimelineResponse,
} from '@/types';

type TicketAssignmentsApiResponse =
  | TicketAssignmentSummary[]
  | TicketAssignmentsResponse
  | {
      assignments: TicketAssignmentSummary[];
      total?: number;
    };

export const ticketService = {
  getTickets: async (
    params?: TicketListParams,
  ): Promise<TicketListResponse> => {
    const response = await axiosClient.get<TicketListResponse>(
      API_ROUTES.TICKETS.BASE,
      {
        params: {
          skip: params?.skip ?? 0,
          limit: params?.limit ?? 10,
          chainage_id: params?.chainage_id,
        },
      },
    );
    return response.data;
  },

  getTicketSummary: async (
    params?: TicketSummaryParams,
  ): Promise<TicketSummaryResponse> => {
    const response = await axiosClient.get<TicketSummaryResponse>(
      API_ROUTES.TICKETS.SUMMARY,
      {
        params: {
          chainage_id: params?.chainage_id,
        },
      },
    );
    return response.data;
  },

  getTicketOverview: async (
    ticketId: string,
  ): Promise<TicketOverviewDetail> => {
    const response = await axiosClient.get<TicketOverviewDetail>(
      API_ROUTES.TICKETS.DETAIL(ticketId),
    );
    return response.data;
  },

  getTicketAssignmentDetections: async (
    ticketId: string,
    params?: TicketAssignmentDetectionsParams,
  ): Promise<TicketAssignmentDetectionsResponse> => {
    const response = await axiosClient.get<TicketAssignmentDetectionsResponse>(
      API_ROUTES.TICKETS.ASSIGNMENT_DETECTIONS(ticketId),
      {
        params: {
          assignment_status: params?.assignment_status ?? 'unassigned',
          class_name: params?.class_name,
          skip: params?.skip ?? 0,
          limit: params?.limit ?? 500,
        },
        paramsSerializer: {
          indexes: null,
        },
      },
    );
    return response.data;
  },

  getTicketTimeline: async (
    ticketId: string,
  ): Promise<TicketTimelineResponse> => {
    const response = await axiosClient.get<TicketTimelineResponse>(
      API_ROUTES.TICKETS.TIMELINE(ticketId),
    );
    return response.data;
  },

  getAssignableUsers: async (
    params?: AssignableTicketUsersParams,
  ): Promise<AssignableTicketUsersResponse> => {
    const response = await axiosClient.get<AssignableTicketUsersResponse>(
      API_ROUTES.TICKETS.ASSIGNABLE_USERS,
      {
        params: {
          skip: params?.skip ?? 0,
          limit: params?.limit ?? 20,
          search_term: params?.search_term,
        },
      },
    );
    return response.data;
  },

  assignTicket: async (
    ticketId: string,
    payload: AssignTicketPayload,
  ): Promise<TicketAssignmentSummary> => {
    const response = await axiosClient.post<TicketAssignmentSummary>(
      API_ROUTES.TICKETS.ASSIGNMENTS(ticketId),
      payload,
    );
    return response.data;
  },

  getTicketAssignments: async (
    ticketId: string,
  ): Promise<TicketAssignmentsResponse> => {
    const response = await axiosClient.get<TicketAssignmentsApiResponse>(
      API_ROUTES.TICKETS.ASSIGNMENTS(ticketId),
    );
    const data = response.data;

    if (Array.isArray(data)) {
      return { items: data, total: data.length };
    }

    if ('assignments' in data) {
      return {
        items: data.assignments,
        total: data.total ?? data.assignments.length,
      };
    }

    return data;
  },

  requestTicketExtension: async (
    ticketId: string,
    assignmentId: number,
    payload: RequestTicketExtensionPayload,
  ): Promise<unknown> => {
    const response = await axiosClient.post<unknown>(
      API_ROUTES.TICKETS.REQUEST_EXTENSION(ticketId, assignmentId),
      payload,
    );
    return response.data;
  },

  getTicketExtensionRequest: async (
    ticketId: string,
    assignmentId: number,
  ): Promise<TicketExtensionRequestsResponse> => {
    const response = await axiosClient.get<TicketExtensionRequestsResponse>(
      API_ROUTES.TICKETS.TICKET_EXTENSION_REQUESTS(ticketId),
      {
        params: { assignment_id: assignmentId },
      },
    );
    return response.data;
  },

  getTicketExtensionRequests: async (
    params: TicketExtensionRequestsParams,
  ): Promise<TicketExtensionRequestsResponse> => {
    const response = await axiosClient.get<TicketExtensionRequestsResponse>(
      API_ROUTES.TICKETS.EXTENSION_REQUESTS,
      { params },
    );
    return response.data;
  },

  reviewTicketExtension: async (
    ticketId: string,
    assignmentId: number,
    payload: ReviewTicketExtensionPayload,
  ): Promise<unknown> => {
    const response = await axiosClient.post<unknown>(
      API_ROUTES.TICKETS.REVIEW_EXTENSION_REQUEST(ticketId, assignmentId),
      payload,
    );
    return response.data;
  },

  closeTicket: async (
    ticketId: string,
    payload: CloseTicketPayload,
  ): Promise<unknown> => {
    const response = await axiosClient.post<unknown>(
      API_ROUTES.TICKETS.CLOSE(ticketId),
      payload,
    );
    return response.data;
  },

  createTicketEventsToken: async (
    ticketId: string,
  ): Promise<SseTokenResponse> => {
    const response = await axiosClient.post<SseTokenResponse>(
      API_ROUTES.TICKETS.DETAIL_EVENTS_TOKEN(ticketId),
    );
    return response.data;
  },

  createTenantTicketEventsToken: async (): Promise<SseTokenResponse> => {
    const response = await axiosClient.post<SseTokenResponse>(
      API_ROUTES.TICKET_EVENTS.TENANT_TOKEN,
    );
    return response.data;
  },

  createUserEventsToken: async (): Promise<SseTokenResponse> => {
    const response = await axiosClient.post<SseTokenResponse>(
      API_ROUTES.TICKET_EVENTS.USER_TOKEN,
    );
    return response.data;
  },
};