import ApiService from "./ApiService";

// Budget breakdown interfaces
export interface BudgetBreakdownByActivity {
  activity_name: string;
  total_hours: number;
  total_amount: number;
}

export interface BudgetBreakdownByEmployee {
  employee_name: string;
  total_hours: number;
  total_amount: number;
}

export interface BudgetBreakdownByParty {
  party_type: "CONTRACTOR" | "CONSULTANT" | "VENDOR";
  party_name: string;
  total_amount: number;
}

// Project interfaces
export interface Project {
  id: string;
  client_id: string;
  name: string;
  managed_by?: string;
  budget: number;
  threshold_percentage?: number;
  remaining_budget?: number;
  used_budget?: number;
  status: "Planning" | "In Progress" | "On Hold" | "Completed";
  address: string;
  description: string;
  start_date?: string;
  end_date?: string;
  created_at?: string;
  updated_at?: string;
  client?: {
    name: string;
  };
  user: {
    id: string;
    first_name: string;
    last_name: string;
  };
  project_manager?: {
    id: string;
    first_name: string;
    last_name: string;
  };
  budget_breakdown_by_activity?: BudgetBreakdownByActivity[];
  budget_breakdown_by_employee?: BudgetBreakdownByEmployee[];
  budget_breakdown_by_party?: BudgetBreakdownByParty[];
  completion_percentage?: number | null;
}

export interface ProjectFilters {
  search?: string;
  status?: string;
  statuses?: string;
  column_name?: string;
  order?: "ASC" | "DESC";
  page?: number;
  limit?: number;
  client_id?: string;
  filter_by?: string;
  is_time_tracking?: string;
  managed_by?: string;
}

export interface CreateProjectData {
  client_id: string;
  name: string;
  managed_by?: string;
  budget: number;
  threshold_percentage: number;
  status: "Planning" | "In Progress" | "On Hold" | "Completed";
  address: string;
  description: string;
  start_date?: string;
  end_date?: string;
}

export interface UpdateProjectData {
  id: string;
  client_id: string;
  name: string;
  managed_by?: string;
  budget: number;
  threshold_percentage: number;
  status: "Planning" | "In Progress" | "On Hold" | "Completed";
  address: string;
  description: string;
  start_date?: string;
  end_date?: string;
}

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

export interface ProjectResponse {
  success: boolean;
  message?: string;
  data: Project;
}

// Create Project
export async function createProject(data: CreateProjectData) {
  return ApiService.request<ProjectResponse>({
    url: "/projects",
    method: "post",
    data,
  });
}

// Get Projects with filters
export async function getProjects(filters?: ProjectFilters) {
  const params: any = {
    search: filters?.search || "",
    page: filters?.page || 1,
    limit: filters?.limit || 10,
  };

  // Only add status to params if it's defined and not "All"
  if (filters?.status && filters.status !== "All") {
    params.status = filters.status;
  }

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

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

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

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

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

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

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

  return ApiService.request<ProjectListResponse>({
    url: "/projects",
    method: "get",
    params,
  });
}

// Get Project by ID
export async function getProjectById(id: string) {
  return ApiService.request<ProjectResponse>({
    url: `/projects/${id}`,
    method: "get",
  });
}

export async function updateCompletionPercentage(
  projectId: string,
  completion_percentage: number
) {
  return ApiService.request<
    ProjectResponse & { data?: { completion_percentage: number } }
  >({
    url: `/projects/${projectId}/completion-percentage`,
    method: "patch",
    data: { completion_percentage },
  });
}

// Update Project
export async function updateProject(data: UpdateProjectData) {
  const { id, ...updateData } = data;
  return ApiService.request<ProjectResponse>({
    url: `/projects/${id}`,
    method: "put",
    data: updateData,
  });
}

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

// Project Employee interfaces
export interface ProjectEmployee {
  id: string;
  project_id: string;
  employee_id: string;
  assigned_by: string;
  assigned_at: string;
  employee: {
    id: string;
    first_name: string;
    last_name: string;
    email: string;
    contact_no: string;
    spent_hours: number;
    total_cost: number;
    department: {
      id: number;
      name: string;
    };
    role: {
      id: number;
      name: string;
    };
    user: {
      id: string;
      first_name: string;
      last_name: string;
    };
  };
}

export interface AssignEmployeeData {
  employee_id: string;
}

export interface ProjectEmployeesResponse {
  success: boolean;
  message?: string;
  data: ProjectEmployee[];
}

export interface AssignEmployeeResponse {
  success: boolean;
  message?: string;
  data: ProjectEmployee;
}

// Delete Project
export async function deleteProject(id: string) {
  return ApiService.request<DeleteProjectResponse>({
    url: `/projects/${id}`,
    method: "delete",
  });
}

// Get Project Employees
export async function getProjectEmployees(projectId: string, params?: any) {
  return ApiService.request<ProjectEmployeesResponse>({
    url: `/projects/${projectId}/employees`,
    method: "get",
    params,
  });
}

// Assign Employee to Project
export async function assignEmployeeToProject(
  projectId: string,
  data: AssignEmployeeData
) {
  return ApiService.request<AssignEmployeeResponse>({
    url: `/projects/${projectId}/assign-employee`,
    method: "post",
    data,
  });
}

// Delete Assigned Employee
export async function deleteAssignedEmployee(
  projectId: string,
  assignmentId: string
) {
  return ApiService.request<DeleteProjectResponse>({
    url: `/projects/${projectId}/assigned-employees/${assignmentId}`,
    method: "delete",
  });
}