import ApiService from "./ApiService";

// Activity Type interfaces
export interface ActivityType {
  id: string;
  name: string;
  location_required: number;
  status: boolean;
  is_productive?: number;
  is_business_task?: number;
  is_technical_task?: number;
  is_personal_task?: number;
  maximum_threshold_limit?: number | null;
  created_at?: string;
  updated_at?: string;
}

export interface ActivityTypeFilters {
  search?: string;
  status?: number;
  page?: number;
  limit?: number;
  column_name?: string;
  order?: "ASC" | "DESC";
  project_id?: string;
  show_only_assigned_activity?: boolean;
}

export interface CreateActivityTypeData {
  name: string;
  location_required: boolean;
  status: boolean;
  is_productive: number;
  maximum_threshold_limit: number | null;
  is_business_task?: number;
  is_technical_task?: number;
  is_personal_task?: number;
}

export interface UpdateActivityTypeData extends Partial<CreateActivityTypeData> {
  id: string;
}

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

export interface ActivityTypeResponse {
  success?: boolean;
  message?: string;
  data: ActivityType;
}

// Create Activity Type
export async function createActivityType(data: CreateActivityTypeData) {
  return ApiService.request<ActivityTypeResponse>({
    url: "/activity-types",
    method: "post",
    data,
  });
}

// Get Activity Types with filters
export async function getActivityTypes(filters?: ActivityTypeFilters) {
  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;
  }

  // Add project_id filter if provided
  if (filters?.project_id) {
    params.project_id = filters.project_id;
  }

  // Add sorting parameters if provided
  if (filters?.column_name) {
    params.column_name = filters.column_name;
  }
  if (filters?.order) {
    params.order = filters.order;
  }

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

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

// Get Activity Type by ID
export async function getActivityTypeById(id: string) {
  return ApiService.request<ActivityTypeResponse>({
    url: `/activity-types/${id}`,
    method: "get",
  });
}

// Update Activity Type
export async function updateActivityType(data: UpdateActivityTypeData) {
  const { id, ...updateData } = data;
  return ApiService.request<ActivityTypeResponse>({
    url: `/activity-types/${id}`,
    method: "put",
    data: updateData,
  });
}

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

// Delete Activity Type
export async function deleteActivityType(id: string) {
  return ApiService.request<DeleteActivityTypeResponse>({
    url: `/activity-types/${id}`,
    method: "delete",
  });
}

// Project Activity Assignment interfaces
export interface AssignActivitiesToProjectData {
  activity_type_ids: string[];
}

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

// Assign activities to project
export async function assignActivitiesToProject(
  projectId: string,
  data: AssignActivitiesToProjectData,
) {
  return ApiService.request<AssignActivitiesToProjectResponse>({
    url: `/projects/${projectId}/activities`,
    method: "post",
    data,
  });
}

// Remove activity from project
export async function removeActivityFromProject(
  projectId: string,
  activityTypeId: string,
) {
  return ApiService.request<AssignActivitiesToProjectResponse>({
    url: `/projects/${projectId}/activities/${activityTypeId}`,
    method: "delete",
  });
}