import ApiService from "./ApiService";

// Leave Type interfaces
export interface LeaveType {
  id: string;
  name: string;
  code: string;
  annual_allowed_days: number;
  is_paid: boolean;
  carry_forward: boolean;
  status: boolean;
  parent_id?: number | null;
  level?: number;
  parentLeave?: LeaveType;
  subLeave?: LeaveType[];
  has_sub_leave?: boolean;
  is_selectable?: boolean;
  created_at?: string;
  updated_at?: string;
}

export interface LeaveTypeFilters {
  search?: string;
  status?: number;
  column_name?: string;
  order?: "ASC" | "DESC";
  page?: number;
  limit?: number;
  parent_id?: number;
  level?: number;
  selectable_only?: boolean;
  hierarchy?: boolean;
}

export interface CreateLeaveTypeData {
  name: string;
  code: string;
  annual_allowed_days?: number;
  is_paid: number;
  carry_forward: number;
  status?: boolean;
  parent_id?: number;
}

export interface UpdateLeaveTypeData {
  id: string;
  name: string;
  code: string;
  annual_allowed_days?: number;
  is_paid: number;
  carry_forward: number;
  status?: boolean;
  parent_id?: number;
}

export interface LeaveTypeListResponse {
  success: boolean;
  message?: string;
  data: {
    data: LeaveType[];
    count: number;
  };
}

export interface LeaveTypeResponse {
  success: boolean;
  message?: string;
  data: LeaveType;
}

export interface DeleteLeaveTypeResponse {
  success: boolean;
  message?: string;
}

// Create Leave Type
export async function createLeaveType(data: CreateLeaveTypeData) {
  return ApiService.request<LeaveTypeResponse>({
    url: "/leave-types",
    method: "post",
    data,
  });
}

// Get Leave Types with filters
export async function getLeaveTypes(filters?: LeaveTypeFilters) {
  const params: any = {
    search: filters?.search || "",
    page: filters?.page || 1,
    limit: filters?.limit || 10,
  };

  // Only add status to params if it's defined (1 or 0)
  if (filters?.status !== undefined) {
    params.status = filters.status;
  }

  if (filters?.column_name) {
    params.column_name = filters.column_name;
  }

  if (filters?.order) {
    params.order = filters.order;
  }

  if (filters?.parent_id !== undefined) {
    params.parent_id = filters.parent_id;
  }

  if (filters?.level !== undefined) {
    params.level = filters.level;
  }

  if (filters?.selectable_only !== undefined) {
    params.selectable_only = filters.selectable_only;
  }

  if (filters?.hierarchy !== undefined) {
    params.hierarchy = filters.hierarchy;
  }

  return ApiService.request<LeaveTypeListResponse>({
    url: "/leave-types",
    method: "get",
    params,
  });
}

// Get Leave Type by ID
export async function getLeaveTypeById(id: string) {
  return ApiService.request<LeaveTypeResponse>({
    url: `/leave-types/${id}`,
    method: "get",
  });
}

// Update Leave Type
export async function updateLeaveType(data: UpdateLeaveTypeData) {
  const { id, ...updateData } = data;
  return ApiService.request<LeaveTypeResponse>({
    url: `/leave-types/${id}`,
    method: "put",
    data: updateData,
  });
}

// Delete Leave Type
export async function deleteLeaveType(id: string) {
  return ApiService.request<DeleteLeaveTypeResponse>({
    url: `/leave-types/${id}`,
    method: "delete",
  });
}

// Toggle Leave Type Status
export async function toggleLeaveTypeStatus(id: string) {
  return ApiService.request<LeaveTypeResponse>({
    url: `/leave-types/active-inactive/${id}`,
    method: "patch",
  });
}

// Get Leave Types Hierarchy
export async function getLeaveTypesHierarchy() {
  return ApiService.request<LeaveTypeListResponse>({
    url: "/leave-types",
    method: "get",
    params: { hierarchy: true },
  });
}

// Get Selectable Leave Types (for leave request forms)
export async function getSelectableLeaveTypes() {
  return ApiService.request<LeaveTypeListResponse>({
    url: "/leave-types",
    method: "get",
    params: { selectable_only: true },
  });
}

// Get Sub Leave Types for a parent
export async function getSubLeaveTypes(parentId: number) {
  return ApiService.request<LeaveTypeListResponse>({
    url: "/leave-types",
    method: "get",
    params: { parent_id: parentId },
  });
}

// Get Main Leave Types only (level 0)
export async function getMainLeaveTypes() {
  return ApiService.request<LeaveTypeListResponse>({
    url: "/leave-types",
    method: "get",
    params: { level: 0 },
  });
}