import { API_ENDPOINTS } from '@/shared/constants/apiEndpoints';
import { api } from '@/shared/utils/api';
import { isPaginatedResponse } from '@/shared/types/pagination.types';

export interface TicketStatusRecord {
  id: string;
  department_id: string;
  name_en: string;
  name_ar: string;
  color: string;
  is_default: boolean;
  is_closed: boolean;
  is_resolved: boolean;
  sort_order: number;
}

export interface TicketPriorityRecord {
  id: string;
  department_id: string;
  name_en: string;
  name_ar: string;
  color: string;
  sort_order: number;
}

function unwrapStatuses(raw: unknown): TicketStatusRecord[] {
  if (isPaginatedResponse(raw, isStatus)) {
    return raw.data;
  }
  if (typeof raw === 'object' && raw !== null && 'data' in raw) {
    const data = (raw as { data: unknown }).data;
    if (Array.isArray(data) && data.every(isStatus)) {
      return data;
    }
  }
  return [];
}

function isStatus(v: unknown): v is TicketStatusRecord {
  return typeof v === 'object' && v !== null && typeof (v as TicketStatusRecord).name_en === 'string';
}

function isPriority(v: unknown): v is TicketPriorityRecord {
  return typeof v === 'object' && v !== null && typeof (v as TicketPriorityRecord).name_en === 'string';
}

export async function listStatuses(departmentId: string): Promise<TicketStatusRecord[]> {
  const raw: unknown = await api.get(
    `${API_ENDPOINTS.TICKET_STATUSES.LIST}?department_id=${encodeURIComponent(departmentId)}`,
  );
  return unwrapStatuses(raw);
}

export async function createStatus(payload: Partial<TicketStatusRecord>): Promise<TicketStatusRecord> {
  const raw: unknown = await api.post(API_ENDPOINTS.TICKET_STATUSES.CREATE, payload);
  return unwrapOneStatus(raw);
}

export async function updateStatus(id: string, payload: Partial<TicketStatusRecord>): Promise<TicketStatusRecord> {
  const raw: unknown = await api.patch(API_ENDPOINTS.TICKET_STATUSES.UPDATE(id), payload);
  return unwrapOneStatus(raw);
}

export async function deleteStatus(id: string): Promise<void> {
  await api.delete(API_ENDPOINTS.TICKET_STATUSES.DELETE(id));
}

export async function listPriorities(departmentId: string): Promise<TicketPriorityRecord[]> {
  const raw: unknown = await api.get(
    `${API_ENDPOINTS.TICKET_PRIORITIES.LIST}?department_id=${encodeURIComponent(departmentId)}`,
  );
  if (isPaginatedResponse(raw, isPriority)) {
    return raw.data;
  }
  if (typeof raw === 'object' && raw !== null && 'data' in raw) {
    const data = (raw as { data: unknown }).data;
    if (Array.isArray(data) && data.every(isPriority)) {
      return data;
    }
  }
  return [];
}

export async function createPriority(payload: Partial<TicketPriorityRecord>): Promise<TicketPriorityRecord> {
  const raw: unknown = await api.post(API_ENDPOINTS.TICKET_PRIORITIES.CREATE, payload);
  return unwrapOnePriority(raw);
}

export async function updatePriority(
  id: string,
  payload: Partial<TicketPriorityRecord>,
): Promise<TicketPriorityRecord> {
  const raw: unknown = await api.patch(API_ENDPOINTS.TICKET_PRIORITIES.UPDATE(id), payload);
  return unwrapOnePriority(raw);
}

export async function deletePriority(id: string): Promise<void> {
  await api.delete(API_ENDPOINTS.TICKET_PRIORITIES.DELETE(id));
}

function unwrapOneStatus(raw: unknown): TicketStatusRecord {
  if (isStatus(raw)) {
    return raw;
  }
  if (typeof raw === 'object' && raw !== null && 'data' in raw) {
    const data = (raw as { data: unknown }).data;
    if (isStatus(data)) {
      return data;
    }
  }
  throw new Error('Invalid status response');
}

function unwrapOnePriority(raw: unknown): TicketPriorityRecord {
  if (isPriority(raw)) {
    return raw;
  }
  if (typeof raw === 'object' && raw !== null && 'data' in raw) {
    const data = (raw as { data: unknown }).data;
    if (isPriority(data)) {
      return data;
    }
  }
  throw new Error('Invalid priority response');
}