import ApiService from "./ApiService";

// Report filters interface
export interface ReportFilters {
  client_id?: string;
  project_id?: string;
  activity_type_id?: string;
  user_id?: string;
  date_from?: string; // Legacy support
  date_to?: string; // Legacy support
  start_date?: string; // Preferred for custom range
  end_date?: string; // Preferred for custom range
  date_range?: string; // For preset ranges: 'today', 'yesterday', 'this_week', 'last_week', 'this_month', 'last_month'
  show_all?: string;
}

// Summary interface
export interface ReportSummary {
  total_hours: number;
  total_cost: number;
  total_clients: number;
  total_projects: number;
  total_employees: number;
}

// Chart data interfaces
export interface ChartDataPoint {
  name: string;
  hours?: number;
  cost?: number;
  date?: string;
}

export interface ReportCharts {
  hours_by_project: ChartDataPoint[];
  cost_by_project: ChartDataPoint[];
  hours_by_activity_type: ChartDataPoint[];
  hours_by_employee: ChartDataPoint[];
  daily_hours_trend: ChartDataPoint[];
}

// Report response interface
export interface ProjectReportResponse {
  success: boolean;
  code: number;
  message: string;
  data: {
    summary: ReportSummary;
    charts: ReportCharts;
  };
}

// Get project report
export async function getProjectReport(filters?: ReportFilters) {
  const params: any = {};

  if (filters?.client_id) {
    params.client_id = filters.client_id;
  }
  if (filters?.project_id) {
    params.project_id = filters.project_id;
  }
  if (filters?.activity_type_id) {
    params.activity_type_id = filters.activity_type_id;
  }
  if (filters?.user_id) {
    params.user_id = filters.user_id;
  }

  // If date_range is provided (preset), use it
  if (filters?.date_range) {
    params.date_range = filters.date_range;
  }

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

  // Always send start_date and end_date (converted to dd-MM-yyyy format)
  // Prioritize start_date/end_date if available, otherwise fallback to date_from/date_to
  if (filters?.start_date) {
    params.start_date = convertDateFormat(filters.start_date);
  } else if (filters?.date_from) {
    params.start_date = convertDateFormat(filters.date_from);
  }

  if (filters?.end_date) {
    params.end_date = convertDateFormat(filters.end_date);
  } else if (filters?.date_to) {
    params.end_date = convertDateFormat(filters.date_to);
  }

  return ApiService.request<ProjectReportResponse>({
    url: "/reports/project",
    method: "get",
    params,
  });
}

// PM Report interfaces
export interface PMReportItem {
  name: string; // Employee name
  employee_id?: string;
  inProgress: number;
  onHold: number;
  completed: number;
  totalTasks: number;
}

export interface PMReportResponse {
  success: boolean;
  code: number;
  message: string;
  data: {
    pm_report: PMReportItem[];
    summary: {
      total_tasks: number;
      in_progress: number;
      on_hold: number;
      completed: number;
    };
  };
}

// Get PM Report - Task status by employee
export async function getPMReport(filters?: ReportFilters) {
  const params: any = {};

  if (filters?.client_id) {
    params.client_id = filters.client_id;
  }
  if (filters?.project_id) {
    params.project_id = filters.project_id;
  }
  if (filters?.activity_type_id) {
    params.activity_type_id = filters.activity_type_id;
  }

  // If date_range is provided (preset), use it
  if (filters?.date_range) {
    params.date_range = filters.date_range;
  }

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

  // Always send start_date and end_date (converted to dd-MM-yyyy format)
  if (filters?.start_date) {
    params.start_date = convertDateFormat(filters.start_date);
  }

  if (filters?.end_date) {
    params.end_date = convertDateFormat(filters.end_date);
  }

  return ApiService.request<PMReportResponse>({
    url: "/reports/pm-report",
    method: "get",
    params,
  });
}

// Project Management Report - /reports/project-management
export interface ProjectManagementMeta {
  total_hours: number;
  total_cost: number;
  total_clients: number;
  total_projects: number;
  total_employees: number;
}

export interface ProjectManagementDataItem {
  project_managed_by_first_name: string;
  project_managed_by_last_name: string;
  project_managed_by_designation?: string;
  total_planning_projects: number;
  total_in_progress_projects: number;
  total_completed_projects: number;
  total_on_hold_projects: number;
}

export interface ProjectManagementReportResponse {
  success: boolean;
  code: number;
  message: string;
  data: {
    meta: ProjectManagementMeta;
    data: ProjectManagementDataItem[];
  };
}

export async function getProjectManagementReport(filters?: ReportFilters) {
  const params: any = {};

  if (filters?.client_id) {
    params.client_id = filters.client_id;
  }
  if (filters?.project_id) {
    params.project_id = filters.project_id;
  }
  // Backend uses activities_id (Swagger) - send both for compatibility
  if (filters?.activity_type_id) {
    params.activity_type_id = filters.activity_type_id;
    params.activities_id = filters.activity_type_id;
  }
  if (filters?.date_range) {
    params.date_range = filters.date_range;
  }
  if (filters?.show_all) {
    params.show_all = filters.show_all;
  }
  // Backend expects yyyy-MM-dd (Swagger shows 2025-01-01 format)
  if (filters?.start_date) {
    params.start_date = convertToYyyyMmDd(filters.start_date);
  }
  if (filters?.end_date) {
    params.end_date = convertToYyyyMmDd(filters.end_date);
  }

  return ApiService.request<ProjectManagementReportResponse>({
    url: "/reports/project-management",
    method: "get",
    params,
  });
}

// Time Entry interface for reports - API returns flat structure
export interface TimeEntryReport {
  id: string | number;
  employee_name?: string;
  project_name?: string;
  client_name?: string;
  activity_type?: string;
  description?: string;
  start_time: string;
  end_time: string | null;
  total_hours?: number;
  total_seconds?: number;
  hourly_rate: number;
  total_cost: number;
  date?: string;
  created_at?: string;
  updated_at?: string;
  // Legacy fields for backward compatibility
  project_id?: string;
  activity_type_id?: string;
  user_id?: string;
  project?: {
    id: string;
    name: string;
    client?: {
      id: string;
      name: string;
    };
  };
  activityType?: {
    id: string;
    name: string;
  };
  employee?: {
    id: string;
    first_name: string;
    last_name: string;
    name?: string;
  };
  user?: {
    id: string;
    first_name: string;
    last_name: string;
    name?: string;
  };
}

// Time Entries Report Response
export interface TimeEntriesReportResponse {
  success: boolean;
  code: number;
  message: string;
  data: {
    summary: {
      total_entries: number;
      total_hours: number;
      total_cost: number;
    };
    entries: TimeEntryReport[];
    total_count: number;
    current_page: number;
    per_page: number;
    total_pages: number;
  };
}

// Helper function to convert date from yyyy-MM-dd to dd-MM-yyyy
function convertDateFormat(dateStr: string): string {
  if (!dateStr) return dateStr;
  // If already in dd-MM-yyyy format, return as is
  if (dateStr.match(/^\d{2}-\d{2}-\d{4}$/)) {
    return dateStr;
  }
  // Convert from yyyy-MM-dd to dd-MM-yyyy
  if (dateStr.match(/^\d{4}-\d{2}-\d{2}$/)) {
    const [year, month, day] = dateStr.split("-");
    return `${day}-${month}-${year}`;
  }
  return dateStr;
}

// Convert dd-MM-yyyy to yyyy-MM-dd (for APIs that expect ISO-style dates)
function convertToYyyyMmDd(dateStr: string): string {
  if (!dateStr) return dateStr;
  if (dateStr.match(/^\d{4}-\d{2}-\d{2}$/)) return dateStr;
  if (dateStr.match(/^\d{2}-\d{2}-\d{4}$/)) {
    const [day, month, year] = dateStr.split("-");
    return `${year}-${month}-${day}`;
  }
  return dateStr;
}

// Get time entries report
export async function getTimeEntriesReport(
  filters?: ReportFilters & { page?: number; limit?: number }
) {
  const params: any = {
    page: filters?.page || 1,
    limit: filters?.limit || 10,
  };

  if (filters?.client_id) {
    params.client_id = filters.client_id;
  }
  if (filters?.project_id) {
    params.project_id = filters.project_id;
  }
  if (filters?.activity_type_id) {
    params.activity_type_id = filters.activity_type_id;
  }
  if (filters?.user_id) {
    params.user_id = filters.user_id;
  }

  // If date_range is provided (preset), use it
  if (filters?.date_range) {
    params.date_range = filters.date_range;
  }

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

  // Always send start_date and end_date (converted to dd-MM-yyyy format)
  // Prioritize start_date/end_date if available, otherwise fallback to date_from/date_to
  if (filters?.start_date) {
    params.start_date = convertDateFormat(filters.start_date);
  } else if (filters?.date_from) {
    params.start_date = convertDateFormat(filters.date_from);
  }

  if (filters?.end_date) {
    params.end_date = convertDateFormat(filters.end_date);
  } else if (filters?.date_to) {
    params.end_date = convertDateFormat(filters.date_to);
  }

  return ApiService.request<TimeEntriesReportResponse>({
    url: "/reports/time-entries",
    method: "get",
    params,
  });
}

// Project Costing Filters interface
export interface ProjectCostingFilters {
  client_id?: string;
  project_id?: string;
  year?: number;
  time_frame?: "monthly" | "quarterly" | "yearly";
  start_date?: string; // For custom date ranges
  end_date?: string; // For custom date ranges
  date_range?: string; // For preset ranges: 'today', 'yesterday', 'this_week', 'last_week', 'this_month', 'last_month'
  page?: number;
  limit?: number;
  show_all?: string;
}

// Project Costing Summary interface
export interface ProjectCostingSummary {
  total_projects?: number;
  total_cost: number;
  average_cost_per_project?: number;
}

// Cost Trend Data interface
export interface CostTrendData {
  period: string;
  total_cost: number;
  start_date: string;
  end_date: string;
}

// Project Cost Data interface with monthly costs (for backward compatibility)
export interface ProjectCostData {
  project_id: number;
  project_name: string;
  client_name: string;
  jan_cost?: number;
  feb_cost?: number;
  mar_cost?: number;
  apr_cost?: number;
  may_cost?: number;
  jun_cost?: number;
  jul_cost?: number;
  aug_cost?: number;
  sep_cost?: number;
  oct_cost?: number;
  nov_cost?: number;
  dec_cost?: number;
  total_cost: number;
}

// Project Costing Response interface
export interface ProjectCostingResponse {
  success: boolean;
  code: number;
  message: string;
  data: {
    summary: ProjectCostingSummary;
    cost_trend?: CostTrendData[];
    projects?: ProjectCostData[];
    total_count?: number;
    current_page?: number;
    per_page?: number;
    total_pages?: number;
  };
}

// Get project costing report
export async function getProjectCostingReport(filters?: ProjectCostingFilters) {
  const params: any = {
    page: filters?.page || 1,
    limit: filters?.limit || 10,
  };

  console.log(filters?.year, "filters?.year");

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

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

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

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

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

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

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

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

  return ApiService.request<ProjectCostingResponse>({
    url: "/reports/project-costing-list",
    method: "get",
    params,
  });
}

// Timesheet Report Filters interface
export interface TimesheetReportFilters {
  employee_id?: string;
  department_id?: string;
  date_range?: string; // For preset ranges: 'today', 'yesterday', 'this_week', 'last_week', 'this_month', 'last_month'
  date_from?: string; // Legacy support
  date_to?: string; // Legacy support
  start_date?: string; // Preferred for custom range
  end_date?: string; // Preferred for custom range
  status?: string; // 'completed' or 'ongoing'
  search?: string; // Search query for employee name, department, date, or time
  page?: number;
  limit?: number;
  show_all?: string;
  client_id?: string;
  project_id?: string;
}

// Timesheet Entry interface
export interface TimesheetEntry {
  id?: number;
  date: string;
  employee_id: number;
  employee_name: string;
  designation: string;
  department_name: string;
  activity_type: string;
  is_productive: boolean;
  clock_in: string;
  clock_out: string | null;
  duration: string;
  description: string;
  status: string;
  project_id?: number;
  project_name?: string;
  activity_type_id?: number;
  activity_type_name?: string;
  cost?: number;
}

// Timesheet Summary interface
export interface TimesheetSummary {
  total_records: number;
  total_hours_all_records: string;
  employees_present: number;
  total_employees: number;
  average_hours_per_employee_per_day: string;
}

// Timesheet Report Response interface
export interface TimesheetReportResponse {
  success: boolean;
  code: number;
  message: string;
  data: {
    summary: TimesheetSummary;
    entries: TimesheetEntry[];
    total_count: number;
    current_page: number;
    per_page: number;
    total_pages: number;
  };
}

// Get timesheet report
export async function getTimesheetReport(filters?: TimesheetReportFilters) {
  const params: any = {
    page: filters?.page || 1,
    limit: filters?.limit || 10,
  };

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

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

  if (filters?.date_range) {
    params.date_range = filters.date_range;
  }
  // Always send start_date and end_date (converted to dd-MM-yyyy format)
  // Prioritize start_date/end_date if available, otherwise fallback to date_from/date_to
  if (filters?.start_date) {
    params.start_date = convertDateFormat(filters.start_date);
  } else if (filters?.date_from) {
    params.start_date = convertDateFormat(filters.date_from);
  }

  if (filters?.end_date) {
    params.end_date = convertDateFormat(filters.end_date);
  } else if (filters?.date_to) {
    params.end_date = convertDateFormat(filters.date_to);
  }

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

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

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

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

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

  return ApiService.request<TimesheetReportResponse>({
    url: "/reports/timesheet",
    method: "get",
    params,
  });
}

// Update Timesheet Entry interface
export interface UpdateTimesheetEntryData {
  id: number;
  employee_id?: string;
  clock_in?: string;
  clock_out?: string | null;
  description?: string;
}

// Update timesheet entry
// Note: Timesheet entries are actually time tracking entries, so we use the time-tracking endpoint
export async function updateTimesheetEntry(data: UpdateTimesheetEntryData) {
  // Ensure ID is present and valid
  if (!data.id || data.id === null || data.id === undefined) {
    throw new Error("Timesheet entry ID is required for update");
  }

  const { id, ...updateData } = data;

  // Convert ID to string for URL (time tracking uses string IDs)
  const entryId = String(id);

  // Map timesheet fields to time tracking fields
  const requestData: any = {};

  // Note: employee_id is not sent as time tracking entries are user-specific
  // Only send clock_in, clock_out, and description
  if (updateData.clock_in !== undefined) {
    requestData.start_time = updateData.clock_in; // Map clock_in to start_time
  }

  if (updateData.clock_out !== undefined) {
    requestData.end_time = updateData.clock_out; // Map clock_out to end_time
  }

  if (updateData.description !== undefined) {
    requestData.description = updateData.description.trim();
  }

  // Use time-tracking endpoint like the working update
  return ApiService.request<{
    success: boolean;
    message: string;
    data: TimesheetEntry;
  }>({
    url: `/time-tracking/${entryId}`,
    method: "put",
    data: requestData,
  });
}

// Clock-in Report Filters interface
export interface ClockinReportFilters {
  employee_id?: string;
  department_id?: string;
  client_id?: string;
  project_id?: string;
  date_range?: string; // For preset ranges: 'today', 'this_week', 'this_month', 'last_month', 'custom'
  start_date?: string; // Required when date_range is 'custom'
  end_date?: string; // Required when date_range is 'custom'
  status?: string;
  search?: string; // Search query for employee name, department, date, or time
  page?: number;
  limit?: number;
  show_all?: string;
}

// Clock-in Entry interface
export interface ClockinEntry {
  date: string;
  employee_id: number;
  employee_name: string;
  department_name: string;
  clock_in: string;
  clock_out: string | null;
  duration: string;
  status: string;
}

// Clock-in Report Response interface
export interface ClockinReportResponse {
  success: boolean;
  code: number;
  message: string;
  data: {
    entries: ClockinEntry[];
    total_count: number;
    current_page: number;
    per_page: number;
    total_pages: number;
  };
}

// Get clock-in report
export async function getClockinReport(filters?: ClockinReportFilters) {
  const params: any = {
    page: filters?.page || 1,
    limit: filters?.limit || 10,
  };

  if (filters?.employee_id) {
    params.employee_id = filters.employee_id;
  }
  if (filters?.department_id) {
    params.department_id = filters.department_id;
  }
  if (filters?.date_range) {
    params.date_range = filters.date_range;
  }
  if (filters?.start_date) {
    params.start_date = filters.start_date;
  }
  if (filters?.end_date) {
    params.end_date = filters.end_date;
  }
  if (filters?.status) {
    params.status = filters.status;
  }
  if (filters?.search) {
    params.search = filters.search;
  }
  if (filters?.show_all) {
    params.show_all = filters.show_all;
  }
  if (filters?.client_id) {
    params.client_id = filters.client_id;
  }
  if (filters?.project_id) {
    params.project_id = filters.project_id;
  }

  return ApiService.request<ClockinReportResponse>({
    url: "/reports/clock-in",
    method: "get",
    params,
  });
}

// Timesheet Bulk Upload interfaces
export interface TimesheetBulkUploadError {
  row_number: number;
  project_name?: string;
  employee_email?: string;
  error_message: string;
}

export interface TimesheetBulkUploadResponse {
  total_records: number;
  success_count: number;
  failure_count: number;
  errors: TimesheetBulkUploadError[];
  error_file_name?: string;
  error_file_base64?: string;
  error_file?: Blob; // Added by service after base64 conversion
}

// Leave Analytics interfaces
export interface LeaveAnalyticsFilters {
  year?: number;
}

export interface LeaveTypeData {
  leave_type_code: string;
  leave_type_name: string;
  total_days: number;
}

export interface EmployeeLeaveData {
  employee_id: number;
  employee_name: string;
  total_days: number;
  leave_types: LeaveTypeData[];
}

export interface MonthlyLeaveData {
  month: number;
  month_name: string;
  total_days: number;
  leave_types?: LeaveTypeData[];
}

export interface LeaveAnalyticsData {
  employee_wise_leaves: EmployeeLeaveData[];
  monthly_leave_count: MonthlyLeaveData[];
  year: number;
  total_leave_days: number;
}

export interface LeaveAnalyticsResponse {
  success: boolean;
  code: number;
  message: string;
  data: LeaveAnalyticsData;
}

// Get leave analytics report
export async function getLeaveAnalytics(filters?: LeaveAnalyticsFilters) {
  const params: any = {};

  if (filters?.year) {
    params.year = filters.year;
  } else {
    // Default to current year
    params.year = new Date().getFullYear();
  }

  return ApiService.request<LeaveAnalyticsResponse>({
    url: "/reports/dashboard/leave-analytics",
    method: "get",
    params,
  });
}

// Performance Report interfaces
export interface ProjectCompletionData {
  project_name: string;
  completion_percentage: number;
}

export interface HoursByProjectData {
  project_name: string;
  hours: number;
}

export interface HoursByActivityData {
  activity_type: string;
  hours: number;
}

export interface DailyHoursTrendData {
  date: string;
  hours: number;
}

export interface ProductiveVsNonProductiveData {
  employee_name: string;
  productive_hours: number;
  non_productive_hours: number;
}

export interface PerformanceReportData {
  summary: {
    total_hours: number;
    total_cost: number;
    total_clients: number;
    total_projects: number;
    total_employees: number;
  };
  project_completion: ProjectCompletionData[];
  hours_by_project: HoursByProjectData[];
  hours_by_activity_type: HoursByActivityData[];
  daily_hours_trend: DailyHoursTrendData[];
  productive_vs_non_productive: ProductiveVsNonProductiveData[];
}

export interface PerformanceReportResponse {
  success: boolean;
  code: number;
  message: string;
  data: PerformanceReportData;
}

// Get performance report
export async function getPerformanceReport(filters?: ReportFilters) {
  const params: any = {};

  if (filters?.client_id) {
    params.client_id = filters.client_id;
  }
  if (filters?.project_id) {
    params.project_id = filters.project_id;
  }
  if (filters?.activity_type_id) {
    params.activity_type_id = filters.activity_type_id;
  }

  // If date_range is provided (preset), use it
  if (filters?.date_range) {
    params.date_range = filters.date_range;
  }

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

  // Always send start_date and end_date (converted to dd-MM-yyyy format)
  if (filters?.start_date) {
    params.start_date = convertDateFormat(filters.start_date);
  }

  if (filters?.end_date) {
    params.end_date = convertDateFormat(filters.end_date);
  }

  return ApiService.request<PerformanceReportResponse>({
    url: "/reports/performance",
    method: "get",
    params,
  });
}

// Employee Productivity Report - /reports/employee-productivity
export interface EmployeeProductivityItem {
  employee_name: string;
  productive_percentage?: number;
  non_productive_percentage?: number;
  productive_hours?: number;
  non_productive_hours?: number;
  total_hours?: number;
}

export interface EmployeeProductivityResponse {
  success: boolean;
  code: number;
  message: string;
  data: EmployeeProductivityItem[] | EmployeeProductivityItem;
}

export interface EmployeeProductivityFilters {
  from_month?: number;
  from_year?: number;
  to_month?: number;
  to_year?: number;
  start_date?: string; // dd-MM-yyyy - will be parsed to from_/to_month/year
  end_date?: string;
  date_range?: string;
  show_all?: string;
}

function parseDateToMonthYear(
  dateStr: string
): { month: number; year: number } | null {
  if (!dateStr) return null;
  const match = dateStr.match(/^(\d{2})-(\d{2})-(\d{4})$/);
  if (match) {
    return { month: parseInt(match[2], 10), year: parseInt(match[3], 10) };
  }
  const yyyyMatch = dateStr.match(/^(\d{4})-(\d{2})-(\d{2})$/);
  if (yyyyMatch) {
    return {
      month: parseInt(yyyyMatch[2], 10),
      year: parseInt(yyyyMatch[1], 10),
    };
  }
  return null;
}

export async function getEmployeeProductivity(
  filters?: EmployeeProductivityFilters
) {
  const params: Record<string, number | string> = {};
  const startDate = filters?.start_date || filters?.end_date;
  const endDate = filters?.end_date || filters?.start_date;

  if (filters?.from_month != null && filters?.from_year != null) {
    params.from_month = filters.from_month;
    params.from_year = filters.from_year;
  } else if (startDate) {
    const fromParsed = parseDateToMonthYear(
      typeof startDate === "string" ? startDate : ""
    );
    if (fromParsed) {
      params.from_month = fromParsed.month;
      params.from_year = fromParsed.year;
    }
  }

  if (filters?.to_month != null && filters?.to_year != null) {
    params.to_month = filters.to_month;
    params.to_year = filters.to_year;
  } else if (endDate) {
    const toParsed = parseDateToMonthYear(
      typeof endDate === "string" ? endDate : ""
    );
    if (toParsed) {
      params.to_month = toParsed.month;
      params.to_year = toParsed.year;
    }
  }

  if (!params.to_month && params.from_month) {
    params.to_month = params.from_month;
    params.to_year = params.from_year;
  }
  if (!params.from_month && params.to_month) {
    params.from_month = params.to_month;
    params.from_year = params.to_year;
  }
  if (Object.keys(params).length === 0) {
    const now = new Date();
    params.from_month = now.getMonth() + 1;
    params.from_year = now.getFullYear();
    params.to_month = now.getMonth() + 1;
    params.to_year = now.getFullYear();
  }

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

  return ApiService.request<EmployeeProductivityResponse>({
    url: "/reports/employee-productivity",
    method: "get",
    params,
  });
}

// Bulk upload timesheet entries
export async function bulkUploadTimesheet(file: File) {
  try {
    const formData = new FormData();
    formData.append("file", file);

    const response = await ApiService.request<{
      success: boolean;
      message: string;
      data: TimesheetBulkUploadResponse;
    }>({
      url: "/reports/timesheet/bulk-upload",
      method: "post",
      data: formData,
      headers: {
        "Content-Type": "multipart/form-data",
      },
    });

    // Handle error file download if present in response
    if (
      response.data?.data?.error_file_base64 &&
      response.data?.data?.error_file_name
    ) {
      // Convert base64 to blob
      try {
        const base64Data = response.data.data.error_file_base64;
        const byteCharacters = atob(base64Data);
        const byteNumbers = new Array(byteCharacters.length);
        for (let i = 0; i < byteCharacters.length; i++) {
          byteNumbers[i] = byteCharacters.charCodeAt(i);
        }
        const byteArray = new Uint8Array(byteNumbers);
        const blob = new Blob([byteArray], {
          type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
        });

        // Store the blob in the response data for download
        response.data.data.error_file = blob;
      } catch (conversionError) {
        console.error("Error converting base64 to blob:", conversionError);
      }
    }

    return response;
  } catch (error) {
    console.error("Error in bulkUploadTimesheet:", error);
    throw error;
  }
}