import ApiService from "./ApiService";

// Payroll Cycle interfaces
export interface PayrollCycle {
  id: string;
  company_id: string;
  month: number;
  year: number;
  status: number; // 0 = Draft, 1 = Finalized, 2 = Paid
  employees_count: number;
  total_amount: number;
  month_name: string;
  created_at?: string;
  updated_at?: string;
}

export interface PayrollCycleFilters {
  search?: string;
  status?: number;
  page?: number;
  limit?: number;
}

// Payroll Entry interfaces
export interface SalaryComponent {
  name: string;
  calculated_amount: number;
}

export interface PayrollEntry {
  id: string;
  first_name: string;
  last_name: string;
  employee_id: string;
  payroll_cycle_id: string;
  email: string;
  department: {
    name: string;
  };
  payroll_cycle: {
    id: string;
    month: number;
    year: number;
  };
  basic: number;
  working_days: number;
  present_days: number;
  paid_leaves: number;
  unpaid_leaves: number;
  salary_components: SalaryComponent[];
  total_earnings: string;
  total_deductions: string;
  net_payable: string;
  created_at?: string;
  updated_at?: string;
}

export interface PayrollEntryFilters {
  page?: number;
  limit?: number;
}

// Update attendance data
export interface UpdateAttendanceData {
  employee_id: string;
  payroll_cycle_id: string | null;
  working_days: number;
  present_days: number;
  paid_leaves: number;
  unpaid_leaves: number;
}

// Process payroll data
export interface ProcessPayrollData {
  month: number;
  year: number;
}

// Salary Slip interfaces
export interface SalarySlip {
  id: number;
  payroll_entry_id: number;
  month: string;
  year: number;
  processed_date: string;
  net_salary: number;
  total_earnings: number;
  total_deductions: number;
  payroll_cycle: {
    id: number;
    month: number;
    year: number;
    status: number;
  };
}

export interface SalarySlipFilters {
  page?: number;
  limit?: number;
  search?: string;
  month?: number;
  year?: number;
}

// Salary Slip Detail interfaces
export interface SalarySlipDetail {
  company: {
    name: string;
    address: string;
  };
  employee: {
    name: string;
    employee_id: string;
    department: string;
    designation: string;
    basic: number;
    joining_date: string;
  };
  payroll_period: {
    month: string;
    year: number;
    pay_period: string;
  };
  attendance: {
    working_days: number;
    present_days: number;
    paid_leaves: number;
    unpaid_leaves: number;
    days_paid: number;
    lop_days: number;
  };
  earnings: Array<{
    component_label: string;
    amount: number;
  }>;
  deductions: Array<{
    component_label: string;
    amount: number;
  }>;
  totals: {
    total_earnings: string;
    total_deductions: string;
    net_payable: string;
  };
  payment_date: string;
}

// API Response interfaces
export interface PayrollCycleListResponse {
  success: boolean;
  message?: string;
  data: {
    data: PayrollCycle[];
    count: number;
  };
}

export interface PayrollCycleResponse {
  success: boolean;
  message?: string;
  data: PayrollCycle;
}

export interface PayrollEntryListResponse {
  success: boolean;
  message?: string;
  data: PayrollEntry[];
  total: number;
  page: number;
  limit: number;
}

export interface PayrollEntryResponse {
  success: boolean;
  message?: string;
  data: PayrollEntry;
}

export interface ProcessPayrollResponse {
  success: boolean;
  message?: string;
  data?: any;
}

export interface SalarySlipListResponse {
  success: boolean;
  message?: string;
  data: {
    data: SalarySlip[];
    total: number;
    page: number;
    limit: number;
  };
}

export interface SalarySlipDetailResponse {
  success: boolean;
  code: number;
  message?: string;
  data: SalarySlipDetail;
}

// Get Payroll Cycles
export async function getPayrollCycles(filters?: PayrollCycleFilters) {
  const params: any = {
    search: filters?.search || "",
    page: filters?.page || 1,
    limit: filters?.limit || 10,
  };

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

  return ApiService.request<PayrollCycleListResponse>({
    url: "/payroll/cycles",
    method: "get",
    params,
  });
}

// Get Payroll Cycle by ID
export async function getPayrollCycleById(id: string) {
  return ApiService.request<PayrollCycleResponse>({
    url: `/payroll/cycles/${id}`,
    method: "get",
  });
}

// Get Payroll Entries for a cycle
export async function getPayrollEntries(
  cycleId: string,
  filters?: PayrollEntryFilters
) {
  const params: any = {
    page: filters?.page || 1,
    limit: filters?.limit || 10,
  };

  return ApiService.request<PayrollEntryListResponse>({
    url: `/payroll/cycles/${cycleId}/entries`,
    method: "get",
    params,
  });
}

// Update attendance for a payroll entry
export async function updatePayrollEntryAttendance(
  entryId: string,
  data: UpdateAttendanceData
) {
  return ApiService.request<PayrollEntryResponse>({
    url: `/payroll/entries/${entryId}/attendance`,
    method: "put",
    data,
  });
}

// Process payroll
export async function processPayroll(data: ProcessPayrollData) {
  return ApiService.request<ProcessPayrollResponse>({
    url: "/payroll/process",
    method: "post",
    data,
  });
}

// Get Employee Salary Slips
export async function getEmployeeSalarySlips(filters?: SalarySlipFilters) {
  const params: any = {
    page: filters?.page || 1,
    limit: filters?.limit || 10,
  };

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

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

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

  return ApiService.request<SalarySlipListResponse>({
    url: "/payroll/employee/salary-slips",
    method: "get",
    params,
  });
}

// Get Salary Slip Detail by ID
export async function getSalarySlipById(id: string) {
  return ApiService.request<SalarySlipDetailResponse>({
    url: `/payroll/salary-slip/${id}`,
    method: "get",
  });
}