const requestClient = require('./request')
const util = require('./util')

const roleNames = {
  worker: '冲压工人',
  admin: '管理员',
  manager: '经理',
}

const defaultRolePriority = ['worker', 'admin', 'manager']

const pickDefaultRole = people => {
  const availableRoles = []
  const personList = people || []
  personList.forEach(person => {
    if (person.role) {
      availableRoles.push(person.role)
    }
    const roles = person.roles || []
    roles.forEach(role => {
      availableRoles.push(role)
    })
  })
  const uniqueRoles = Array.from(new Set(availableRoles))
  return defaultRolePriority.find(role => uniqueRoles.includes(role)) || uniqueRoles[0] || ''
}

const normalizeDeviceNo = value => {
  return String(value || '').trim()
}

const moldDisplayName = (name, processName, stampingMethod = '') => {
  const moldName = String(name || '').trim()
  const process = String(processName || '').trim()
  const stamping = String(stampingMethod || '').trim()
  if (!moldName) {
    return ''
  }
  if (stamping) {
    return `${moldName} / ${process || '-'} / ${stamping}`
  }
  return process ? `${moldName} / ${process}` : moldName
}

const normalizeProcessValue = value => {
  const text = String(value || '').trim()
  if (text === '杂活') {
    return text
  }
  const legacyMatch = text.match(/^0*(\d+)序$/)
  if (legacyMatch) {
    return String(Number(legacyMatch[1]))
  }
  const numberMatch = text.match(/^0*(\d+)$/)
  if (numberMatch) {
    return String(Number(numberMatch[1]))
  }
  return text
}

const processDisplayName = value => {
  const process = normalizeProcessValue(value)
  if (!process) {
    return ''
  }
  return process === '杂活' ? process : `${process}序`
}

const isCleaningStampingMethod = value => String(value || '').trim() === '清洗'

const isCleaningRow = row => (
  isCleaningStampingMethod(row.stamping_method || row.stampingMethod)
)

const CONTINUOUS_DIE_STAMPING_METHOD = '连续模'

const isContinuousDieStampingMethod = value => String(value || '').trim() === CONTINUOUS_DIE_STAMPING_METHOD

const isContinuousDieRow = row => (
  !!row && (
    !!row.is_continuous_die
    || !!row.isContinuousDie
    || isContinuousDieStampingMethod(row.stamping_method || row.stampingMethod)
  )
)

const MISC_WORK_PRODUCT_NAME = '处理杂活'
const MISC_WORK_PROCESS_NAME = '杂活'
const MISC_WORK_STAMPING_METHOD = '处理杂活'

const isMiscRow = row => (
  !!row && (
    row.is_misc
    || row.isMisc
    || String(row.stamping_method || row.stampingMethod || '').trim() === MISC_WORK_STAMPING_METHOD
    || (
      String(row.product_name || row.productName || row.name || row.moldName || '').trim() === MISC_WORK_PRODUCT_NAME
      && String(row.process_name || row.process || row.processName || '').trim() === MISC_WORK_PROCESS_NAME
    )
  )
)

const isMultiPersonRow = row => (
  !!row && (
    !!row.is_multi_person
    || !!row.isMultiPerson
    || Number(row.operator_count || row.operatorCount || 1) > 1
  )
)

const correctionValue = value => (
  value === null || value === undefined || value === '' ? '-' : value
)

const correctionDisplayValue = value => {
  const normalized = correctionValue(value)
  if (typeof normalized === 'string' && normalized.includes('T')) {
    return util.formatTime(normalized)
  }
  return normalized
}

const correctionPair = (corrections, key, label, currentValue) => {
  if (!corrections || corrections[key] === undefined) {
    return null
  }
  return {
    key,
    label,
    oldValue: correctionValue(corrections[key]),
    newValue: correctionValue(currentValue),
  }
}

const round1 = value => Math.round(Number(value || 0) * 10) / 10

const round2 = value => Math.round(Number(value || 0) * 100) / 100

const calculateStandardWorkload = (allocatedMinutes, standardBeat) => {
  const beat = Number(standardBeat || 0)
  if (beat <= 0) {
    return 0
  }
  return round1(Number(allocatedMinutes || 0) * 60 / beat)
}

const classifyBeat = (actualBeat, standardBeat) => {
  const actual = Number(actualBeat || 0)
  const standard = Number(standardBeat || 0)
  if (standard <= 0 || actual <= 0) {
    return { className: '', reason: '', isAbnormal: false }
  }
  if (actual > standard) {
    return { className: 'metric-danger', reason: '慢', isAbnormal: true }
  }
  if (actual < standard * 0.7) {
    return { className: 'metric-danger', reason: '快', isAbnormal: true }
  }
  if (actual < standard) {
    return { className: 'metric-success', reason: '', isAbnormal: false }
  }
  return { className: '', reason: '', isAbnormal: false }
}

const classifyWorkload = (goodQty, standardWorkload) => {
  const good = Number(goodQty || 0)
  const standard = Number(standardWorkload || 0)
  if (standard <= 0) {
    return { className: '', reason: '', isAbnormal: false }
  }
  if (good < standard) {
    return { className: 'metric-danger', reason: '小', isAbnormal: true }
  }
  if (good > standard * 1.3) {
    return { className: 'metric-danger', reason: '大', isAbnormal: true }
  }
  if (good > standard) {
    return { className: 'metric-success', reason: '', isAbnormal: false }
  }
  return { className: '', reason: '', isAbnormal: false }
}

const toCamelAttendancePoint = row => ({
  name: row.name || '',
  latitude: row.latitude === null || row.latitude === undefined ? '' : row.latitude,
  longitude: row.longitude === null || row.longitude === undefined ? '' : row.longitude,
  radiusMeters: row.radius_meters === null || row.radius_meters === undefined ? 500 : row.radius_meters,
  dayStart: row.day_start || '08:00',
  dayEnd: row.day_end || '17:20',
  lunchStart: row.lunch_start || '11:40',
  lunchEnd: row.lunch_end || '12:40',
  dinnerStart: row.dinner_start || '17:20',
  dinnerEnd: row.dinner_end || '18:00',
  overtimeStart: row.overtime_start || '18:00',
  overtimeEnd: row.overtime_end || '20:00',
  nightStart: row.night_start || '20:00',
  nightEnd: row.night_end || '06:00',
  remark: row.remark || '',
  isActive: row.is_active !== false,
  createdAt: row.created_at || '',
  updatedAt: row.updated_at || '',
  updatedAtText: row.updated_at ? util.formatTime(row.updated_at) : '',
})

const toSnakeAttendancePoint = row => ({
  name: row.name,
  latitude: row.latitude === '' || row.latitude === undefined ? null : Number(row.latitude),
  longitude: row.longitude === '' || row.longitude === undefined ? null : Number(row.longitude),
  radius_meters: row.radiusMeters === '' || row.radiusMeters === undefined ? 500 : Number(row.radiusMeters),
  day_start: row.dayStart || '08:00',
  day_end: row.dayEnd || '17:20',
  lunch_start: row.lunchStart || '11:40',
  lunch_end: row.lunchEnd || '12:40',
  dinner_start: row.dinnerStart || '17:20',
  dinner_end: row.dinnerEnd || '18:00',
  overtime_start: row.overtimeStart || '18:00',
  overtime_end: row.overtimeEnd || '20:00',
  night_start: row.nightStart || '20:00',
  night_end: row.nightEnd || '06:00',
  remark: row.remark || null,
  is_active: row.isActive !== false,
  original_name: row.originalName || null,
})

const toCamelPerson = row => {
  const roles = row.roles && row.roles.length ? row.roles : (row.role ? [row.role] : [])
  const roleNamesList = row.role_names && row.role_names.length
    ? row.role_names
    : roles.map(role => roleNames[role] || role)
  const temporaryExpiresAtText = row.temporary_expires_at ? util.formatTime(row.temporary_expires_at) : ''
  const attendancePointNames = row.attendance_point_names || []
  return {
    phone: row.phone,
    name: row.name,
    role: row.role || roles[0] || '',
    roleName: row.role_name || roleNamesList.join('、'),
    roles,
    roleNames: roleNamesList,
    attendancePointNames,
    attendancePoints: (row.attendance_points || []).map(toCamelAttendancePoint),
    attendancePointsText: attendancePointNames.join('、'),
    rolesDisplay: roles.map((role, index) => ({
      role,
      roleName: roleNamesList[index] || roleNames[role] || role,
    })),
    isTemporary: !!row.is_temporary,
    temporaryExpiresAt: row.temporary_expires_at || '',
    temporaryExpiresAtText,
    temporaryExpired: !!row.temporary_expired,
    temporaryStatusText: row.is_temporary
      ? (row.temporary_expired ? '临时工已过期' : `临时工有效至 ${temporaryExpiresAtText || '-'}`)
      : '',
  }
}

const toSnakePerson = row => ({
  phone: row.phone,
  name: row.name,
  role: row.role,
  attendance_point_names: row.attendancePointNames || [],
  original_phone: row.originalPhone || null,
})

const toCamelProduct = row => ({
  attendancePointName: row.attendance_point_name || '',
  projectNo: row.project_no,
  productName: row.product_name,
  profileNo: row.profile_no || '',
  materialCode: row.material_code || '',
  materialName: row.material_name || '',
  supplier: row.supplier || '',
  productNetWeightKg: row.product_net_weight_kg === null || row.product_net_weight_kg === undefined ? '' : row.product_net_weight_kg,
  productGrossWeightKg: row.product_gross_weight_kg === null || row.product_gross_weight_kg === undefined ? '' : row.product_gross_weight_kg,
  allowedScrapRate: row.scrap_loss_rate === null || row.scrap_loss_rate === undefined ? '' : row.scrap_loss_rate,
  wastePriceYuanPerKg: row.waste_price_yuan_per_kg === null || row.waste_price_yuan_per_kg === undefined ? '' : row.waste_price_yuan_per_kg,
  deviceNo: row.device_no,
  process: normalizeProcessValue(row.process_name || ''),
  rawProcess: row.process_name || '',
  processDisplay: processDisplayName(row.process_name || ''),
  stampingMethod: row.stamping_method || '',
  isCleaning: isCleaningRow(row),
  isContinuousDie: isContinuousDieRow(row),
  isMisc: isMiscRow(row),
  isMultiPerson: isMultiPersonRow(row),
  operatorCount: row.operator_count,
  processUnitPriceYuan: row.process_unit_price_yuan || 0,
  standardBeat: row.standard_beat,
  standardWorkload: row.standard_workload,
  displayName: row.display_name || `${row.project_no} / ${moldDisplayName(row.product_name, row.process_name, row.stamping_method)}`,
  uniqueKey: `${row.attendance_point_name || ''}||${row.project_no || ''}||${row.product_name || ''}||${row.process_name || ''}`,
})

const toCamelNotice = row => ({
  id: row.id,
  title: row.title || '',
  content: row.content || '',
  attendancePointNames: row.attendance_point_names || [],
  attendancePointsText: (row.attendance_point_names || []).join('、'),
  sortOrder: row.sort_order || 0,
  isActive: !!row.is_active,
  createdBy: row.created_by || '',
  creatorName: row.creator_name || '',
  createdAt: row.created_at || '',
  updatedAt: row.updated_at || '',
  updatedAtText: row.updated_at ? util.formatTime(row.updated_at) : '',
})

const toCamelEquipment = row => ({
  attendancePointName: row.attendance_point_name || '',
  deviceNo: row.device_no || '',
  deviceType: row.device_type || '冲压设备',
  remark: row.remark || '',
  createdAt: row.created_at || '',
  updatedAt: row.updated_at || '',
  updatedAtText: row.updated_at ? util.formatTime(row.updated_at) : '',
  displayName: row.display_name || (row.remark ? `${row.device_no} / ${row.remark}` : row.device_no),
  uniqueKey: `${row.attendance_point_name || ''}||${row.device_no || ''}`,
})

const toCamelMoldOption = row => ({
  attendancePointName: row.attendance_point_name || '',
  name: row.name || row.device_no || '',
  moldName: row.name || row.device_no || '',
  processName: row.process_name || '',
  stampingMethod: row.stamping_method || '',
  operatorCount: row.operator_count || 1,
  isCleaning: !!row.is_cleaning || isCleaningRow(row),
  isMisc: !!row.is_misc || isMiscRow(row),
  isContinuousDie: !!row.is_continuous_die || isContinuousDieRow(row),
  isMultiPerson: isMultiPersonRow(row),
  displayName: row.display_name || moldDisplayName(row.name || row.device_no, row.process_name, row.stamping_method),
  uniqueKey: `${row.attendance_point_name || ''}||${row.name || row.device_no || ''}||${row.process_name || ''}`,
})

const optionalNumber = value => (
  value === '' || value === undefined || value === null ? null : Number(value)
)

const toSnakeProduct = row => ({
  attendance_point_name: row.attendancePointName,
  project_no: row.projectNo,
  product_name: row.productName,
  profile_no: row.profileNo || null,
  material_code: row.materialCode || null,
  material_name: row.materialName || null,
  supplier: row.supplier || null,
  product_net_weight_kg: optionalNumber(row.productNetWeightKg),
  product_gross_weight_kg: optionalNumber(row.productGrossWeightKg),
  scrap_loss_rate: optionalNumber(row.allowedScrapRate),
  waste_price_yuan_per_kg: optionalNumber(row.wastePriceYuanPerKg),
  device_no: '',
  process_name: normalizeProcessValue(row.process || ''),
  stamping_method: row.stampingMethod || null,
  operator_count: Number(row.operatorCount || 1),
  process_unit_price_yuan: Number(row.processUnitPriceYuan || 0),
  standard_beat: Number(row.standardBeat || 0),
  original_project_no: row.originalProjectNo || null,
  original_attendance_point_name: row.originalAttendancePointName || null,
  original_product_name: row.originalProductName || null,
  original_device_no: row.originalDeviceNo !== undefined ? row.originalDeviceNo : '',
  original_process_name: row.originalProcess !== undefined ? row.originalProcess : null,
})

const toSnakeNotice = row => ({
  title: row.title,
  content: row.content,
  attendance_point_names: row.attendancePointNames || [],
  sort_order: Number(row.sortOrder || 0),
  is_active: !!row.isActive,
})

const toSnakeEquipment = row => ({
  attendance_point_name: row.attendancePointName,
  device_no: normalizeDeviceNo(row.deviceNo),
  device_type: row.deviceType || '冲压设备',
  remark: row.remark || null,
  original_attendance_point_name: row.originalAttendancePointName || null,
  original_device_no: row.originalDeviceNo || null,
})

const toCamelPage = (page, mapper) => ({
  rows: (page.rows || []).map(mapper),
  page: page.page,
  pageSize: page.page_size,
  total: page.total,
  totalPages: page.total_pages,
})

const toCamelUsageStatsRow = row => ({
  id: row.id === undefined || row.id === null ? '' : String(row.id),
  category: row.category || '',
  attendancePointName: row.attendance_point_name || '',
  name: row.name || '',
  objectType: row.object_type || '',
  metricKind: row.metric_kind || '',
  value: Number(row.value || 0),
  reportCount: Number(row.report_count || 0),
  productName: row.product_name || '',
  processName: row.process_name || '',
  stampingMethod: row.stamping_method || '',
  tags: Array.isArray(row.tags) ? row.tags : [],
})

const toCamelUsageStatsDailyRow = row => ({
  reportDate: row.report_date || '',
  value: Number(row.value || 0),
  reportCount: Number(row.report_count || 0),
})

const toCamelUsageStatsReportRow = row => ({
  reportId: Number(row.report_id || 0),
  reportDate: row.report_date || '',
  employeePhone: row.employee_phone || '',
  employeeName: row.employee_name || '',
  displayName: row.display_name || '',
  value: Number(row.value || 0),
  reportCount: Number(row.report_count || 0),
})

const toCamelUsageStatsDetail = data => ({
  ...toCamelUsageStatsRow(data || {}),
  dailyRows: ((data && data.daily_rows) || []).map(toCamelUsageStatsDailyRow),
  reportRows: ((data && data.report_rows) || []).map(toCamelUsageStatsReportRow),
})

const usageStatsParams = filters => ({
  category: filters.category,
  id: filters.id,
  metric_kind: filters.metricKind,
  sort_by: filters.sortBy,
  start_date: filters.startDate,
  end_date: filters.endDate,
  attendance_point_name: filters.attendancePointName,
  keyword: filters.keyword,
  name: filters.name,
  product_name: filters.productName,
  process_name: filters.processName,
  stamping_method: filters.stampingMethod,
})

const formatDurationMinutes = minutes => {
  const totalMinutes = Math.max(0, Math.round(Number(minutes || 0)))
  if (totalMinutes < 60) {
    return `${totalMinutes}分钟`
  }
  const days = Math.floor(totalMinutes / 1440)
  const hours = Math.floor((totalMinutes % 1440) / 60)
  const restMinutes = totalMinutes % 60
  const parts = []
  if (days) {
    parts.push(`${days}天`)
  }
  if (hours) {
    parts.push(`${hours}小时`)
  }
  if (restMinutes) {
    parts.push(`${restMinutes}分钟`)
  }
  return parts.join('')
}

const trimDurationNumber = value => {
  const rounded = Math.round(Number(value || 0) * 100) / 100
  return Number.isInteger(rounded) ? String(rounded) : String(rounded)
}

const formatDurationAllUnits = minutes => {
  const safeMinutes = Math.max(0, Number(minutes || 0))
  return `${trimDurationNumber(safeMinutes)}分钟（${trimDurationNumber(safeMinutes / 60)}小时 / ${trimDurationNumber(safeMinutes / 1440)}天）`
}

const toCamelMonitorLock = row => ({
  id: row.id,
  attendancePointName: row.attendance_point_name || '',
  moldName: row.mold_name || '',
  processName: row.process_name || '',
  stampingMethod: row.stamping_method || '',
  moldDisplayName: row.mold_display_name || moldDisplayName(row.mold_name, row.process_name, row.stamping_method),
  occupiedPhone: row.occupied_phone || '',
  occupiedName: row.occupied_name || '',
  occupiedStartAt: row.occupied_start_at || '',
  occupiedStartAtText: row.occupied_start_at ? util.formatTime(row.occupied_start_at) : '',
  occupiedMinutes: row.occupied_minutes || 0,
  occupiedDurationText: formatDurationMinutes(row.occupied_minutes),
})

const toCamelMoldLockFeedback = row => ({
  id: row.id,
  attendancePointName: row.attendance_point_name || '',
  moldName: row.mold_name || '',
  processName: row.process_name || '',
  stampingMethod: row.stamping_method || '',
  moldDisplayName: row.mold_display_name || moldDisplayName(row.mold_name, row.process_name, row.stamping_method),
  lockId: row.lock_id,
  reporterPhone: row.reporter_phone || '',
  reporterName: row.reporter_name || '',
  occupiedPhone: row.occupied_phone || '',
  occupiedName: row.occupied_name || '',
  feedbackAt: row.feedback_at || '',
  feedbackAtText: row.feedback_at ? util.formatTime(row.feedback_at) : '',
  readAt: row.read_at || '',
  readAtText: row.read_at ? util.formatTime(row.read_at) : '',
  handledAt: row.handled_at || '',
  handledAtText: row.handled_at ? util.formatTime(row.handled_at) : '',
  status: row.status || '',
  statusName: row.status_name || '',
  isHandled: row.status === 'handled',
  canRelease: row.can_release !== false,
})

const toCamelSession = row => ({
  id: row.id,
  attendancePointName: row.attendance_point_name || '',
  employeePhone: row.employee_phone,
  startAt: row.start_at,
  endAt: row.end_at || '',
  status: row.status,
  devices: row.devices || [],
})

const toCamelMetrics = row => ({
  effectiveMinutes: row.effective_minutes,
  shiftDistributionText: row.shift_distribution_text || '',
  shiftDayMinutes: row.shift_day_minutes || 0,
  shiftOvertimeMinutes: row.shift_overtime_minutes || 0,
  shiftNightMinutes: row.shift_night_minutes || 0,
  shiftOtherMinutes: row.shift_other_minutes || 0,
  shiftMealBreakMinutes: row.shift_meal_break_minutes || 0,
  totalGood: row.total_good_qty,
  totalOutput: row.total_output_qty,
  actualBeat: row.actual_beat,
  standardBeat: row.standard_beat,
  expectedWorkload: row.expected_workload,
  paceRate: row.pace_rate,
  workloadRate: row.workload_rate,
})

const formatWorkTime = minutes => {
  const safeMinutes = Number(minutes || 0)
  const seconds = Math.round(safeMinutes * 60)
  if (seconds < 60) {
    return `${seconds}秒`
  }
  return `${Math.round(safeMinutes * 100) / 100}分钟`
}

const toCamelAllocation = row => ({
  allocationDate: row.allocation_date || '',
  dayMinutes: Number(row.day_minutes || 0),
  overtimeMinutes: Number(row.overtime_minutes || 0),
  nightMinutes: Number(row.night_minutes || 0),
  effectiveMinutes: Number(row.effective_minutes || 0),
  goodQty: Number(row.good_qty || 0),
  defectQty: Number(row.defect_qty || 0),
  scrapQty: Number(row.scrap_qty || 0),
  changeoverCount: Number(row.changeover_count || 0),
  referenceWage: Number(row.reference_wage || 0),
})

const toCamelReportItem = row => {
  const defectQty = Number(row.defect_qty || 0)
  const scrapQty = Number(row.scrap_qty || 0)
  const goodQty = Number(row.good_qty || 0)
  const totalDefectQty = defectQty + scrapQty
  const outputQty = goodQty + totalDefectQty
  const allocatedMinutes = Number(row.allocated_minutes || 0)
  const actualBeat = outputQty > 0 ? round2(allocatedMinutes * 60 / outputQty) : 0
  const standardBeat = Number(row.standard_beat || 0)
  const calculatedWorkload = calculateStandardWorkload(allocatedMinutes, standardBeat)
  const standardWorkload = calculatedWorkload || Number(row.standard_workload || 0)
  const paceRate = standardBeat > 0 ? round1((actualBeat - standardBeat) / standardBeat * 100) : 0
  const workloadRate = standardWorkload > 0 ? round1((goodQty - standardWorkload) / standardWorkload * 100) : 0
  const isCleaning = isCleaningRow(row)
  const isContinuousDie = isContinuousDieRow(row)
  const isMisc = isMiscRow(row)
  const noOutputMetric = isCleaning || isMisc
  const beatComparison = noOutputMetric ? classifyBeat(0, 0) : classifyBeat(actualBeat, standardBeat)
  const workloadComparison = noOutputMetric ? classifyWorkload(0, 0) : classifyWorkload(goodQty, standardWorkload)
  const corrections = row.corrections || {}
  const correctionPairs = [
    correctionPair(corrections, 'device_no', '设备号', row.device_no),
    correctionPair(corrections, 'project_no', '项目号', row.project_no),
    correctionPair(corrections, 'product_name', '产品名称', row.product_name),
    correctionPair(corrections, 'process_name', '工序', row.process_name || ''),
    correctionPair(corrections, 'stamping_method', '冲压方式', row.stamping_method || ''),
    correctionPair(corrections, 'raw_material_batch_no', '材料库存批次号', row.raw_material_batch_no || ''),
    correctionPair(corrections, 'process_unit_price_yuan', '工序单价', row.process_unit_price_yuan || 0),
    correctionPair(corrections, 'changeover_count', '换料次数', row.changeover_count || 0),
    correctionPair(corrections, 'good_qty', isCleaning ? '清洗数量' : '成品数量', goodQty),
    correctionPair(corrections, 'defect_qty', '不良数量', Math.round(totalDefectQty * 100) / 100),
    correctionPair(corrections, 'scrap_qty', '报废数量', scrapQty),
    correctionPair(corrections, 'remark', '杂活事项', row.remark || ''),
  ].filter(Boolean)
  return {
    id: row.id,
    attendancePointName: row.attendance_point_name || '',
    startAt: row.started_at || '',
    startAtText: row.started_at ? util.formatTime(row.started_at) : '',
    deviceNo: row.device_no,
    projectNo: row.project_no,
    productName: row.product_name,
    displayName: moldDisplayName(row.product_name, row.process_name, row.stamping_method),
    materialCode: row.material_code || '',
    materialName: row.material_name || '',
    rawMaterialBatchNo: row.raw_material_batch_no || '',
    process: row.process_name || '',
    stampingMethod: row.stamping_method || '',
    operatorCount: row.operator_count || 1,
    processUnitPriceYuan: row.process_unit_price_yuan || 0,
    isCleaning,
    isContinuousDie,
    changeoverCount: row.changeover_count === null || row.changeover_count === undefined ? 0 : Number(row.changeover_count || 0),
    isMisc,
    isMultiPerson: isMultiPersonRow(row),
    isMultiPersonAssistant: !!row.is_multi_person_assistant,
    standardBeat,
    standardWorkload,
    goodQty,
    defectQty: Math.round(totalDefectQty * 100) / 100,
    scrapQty,
    allocatedMinutes,
    workTimeText: isCleaning ? '不计工时' : formatWorkTime(allocatedMinutes),
    actualBeat,
    paceRate,
    workloadRate,
    paceText: noOutputMetric ? '不计节拍' : (paceRate > 0 ? `慢${Math.abs(paceRate)}%` : `快${Math.abs(paceRate)}%`),
    workloadText: noOutputMetric ? '不计标准工作量' : (workloadRate >= 0 ? `多${Math.abs(workloadRate)}%` : `少${Math.abs(workloadRate)}%`),
    beatCompareClass: beatComparison.className,
    beatReason: beatComparison.reason,
    workloadCompareClass: workloadComparison.className,
    workloadReason: workloadComparison.reason,
    remark: row.remark || '',
    corrections,
    correctionPairs,
    hasCorrections: correctionPairs.length > 0,
    allocations: (row.allocations || []).map(toCamelAllocation),
  }
}

const toCamelDeviceSegment = row => {
  const corrections = row.corrections || {}
  const correctionPairs = [
    correctionPair(corrections, 'scanned_at', '换模具时间', row.scanned_at ? util.formatTime(row.scanned_at) : ''),
  ].filter(Boolean).map(item => ({
    ...item,
    oldValue: item.oldValue === '-' ? '-' : util.formatTime(item.oldValue),
  }))
  return {
    id: row.id,
    attendancePointName: row.attendance_point_name || '',
    deviceNo: row.device_no || '',
    moldName: row.mold_name || row.device_no || '',
    process: row.process_name || '',
    stampingMethod: row.stamping_method || '',
    displayName: row.display_name || moldDisplayName(row.mold_name || row.device_no, row.process_name, row.stamping_method),
    scannedAt: row.scanned_at || '',
    scannedAtText: row.scanned_at ? util.formatTime(row.scanned_at) : '',
    releasedAt: row.released_at || '',
    releasedAtText: row.released_at ? util.formatTime(row.released_at) : '',
    sortOrder: Number(row.sort_order || 0),
    corrections,
    correctionPairs,
    hasCorrections: correctionPairs.length > 0,
  }
}

const toCamelReport = row => {
  const paceRate = Number(row.metrics && row.metrics.pace_rate || 0)
  const workloadRate = Number(row.metrics && row.metrics.workload_rate || 0)
  const items = (row.items || []).map(toCamelReportItem)
  const deviceSegments = (row.device_segments || []).map(toCamelDeviceSegment)
  const isCleaning = items.length > 0 && items.every(item => item.isCleaning)
  const hasMisc = items.some(item => item.isMisc)
  const hasContinuousDie = items.some(item => item.isContinuousDie)
  const hasMultiPerson = items.some(item => item.isMultiPerson)
  const totalDefect = Math.round(items.reduce((sum, item) => sum + Number(item.defectQty || 0), 0) * 100) / 100
  const corrections = row.corrections || {}
  const reportCorrectionPairs = [
    correctionPair(corrections, 'start_at', '上班时间', row.start_at ? util.formatTime(row.start_at) : ''),
    correctionPair(corrections, 'end_at', '下班时间', row.end_at ? util.formatTime(row.end_at) : ''),
    correctionPair(corrections, 'review_remark', '备注', row.review_remark || ''),
  ].filter(Boolean).map(item => ({
    ...item,
    oldValue: (item.key === 'start_at' || item.key === 'end_at') && item.oldValue !== '-'
      ? util.formatTime(item.oldValue)
      : item.oldValue,
  })).concat(deviceSegments.flatMap(segment => (
    (segment.correctionPairs || []).map(pair => ({
      ...pair,
      label: `${segment.displayName} ${pair.label}`,
    }))
  )))
  return {
    id: row.id,
    attendancePointName: row.attendance_point_name || '',
    sessionId: row.session_id,
    employeePhone: row.employee_phone,
    employeeName: row.employee_name,
    reportDate: row.report_date,
    startAt: row.start_at,
    endAt: row.end_at,
    startAtText: util.formatTime(row.start_at),
    endAtText: util.formatTime(row.end_at),
    durationMinutes: row.duration_minutes,
    breakMinutes: row.break_minutes,
    status: row.status,
    statusName: row.status_name,
    reviewerPhone: row.reviewer_phone || '',
    reviewerName: row.reviewer_name || '',
    reviewedAt: row.reviewed_at || '',
    reviewedAtText: row.reviewed_at ? util.formatTime(row.reviewed_at) : '',
    rejectReason: row.reject_reason || '',
    reviewRemark: row.review_remark || '',
    submittedAt: row.submitted_at,
    submittedAtText: util.formatTime(row.submitted_at),
    isSystemAutoSubmitted: !!row.is_system_auto_submitted,
    autoSubmitReason: row.auto_submit_reason || '超时-系统自动提交',
    isMultiPersonAssistant: !!row.is_multi_person_assistant,
    multiPersonSourceReportId: row.multi_person_source_report_id || null,
    isVoided: !!row.is_voided,
    voidedAt: row.voided_at || '',
    voidedAtText: row.voided_at ? util.formatTime(row.voided_at) : '',
    voidedBy: row.voided_by || '',
    voidedByName: row.voided_by_name || '',
    unvoidDeadlineAt: row.unvoid_deadline_at || '',
    unvoidDeadlineAtText: row.unvoid_deadline_at ? util.formatTime(row.unvoid_deadline_at) : '',
    canVoid: !!row.can_void,
    canUnvoid: !!row.can_unvoid,
    canEdit: !!row.can_edit,
    isModified: !!row.is_modified,
    allocationSummaryText: row.allocation_summary_text || '',
    deviceSegments,
    items,
    isCleaning,
    hasMisc,
    hasContinuousDie,
    hasMultiPerson,
    metrics: {
      ...toCamelMetrics(row.metrics || {}),
      totalDefect,
    },
    resultText: row.result_text,
    paceText: paceRate > 0 ? `慢${Math.abs(paceRate)}%` : `快${Math.abs(paceRate)}%`,
    workloadText: workloadRate >= 0 ? `多${Math.abs(workloadRate)}%` : `少${Math.abs(workloadRate)}%`,
    corrections,
    correctionPairs: reportCorrectionPairs,
    hasCorrections: reportCorrectionPairs.length > 0 || items.some(item => item.hasCorrections) || deviceSegments.some(item => item.hasCorrections),
  }
}

const emptyDraftItem = startAt => ({
  attendancePointName: '',
  productIndex: -1,
  deviceIndex: -1,
  deviceNo: '',
  startAt: startAt || '',
  startAtText: startAt ? util.formatTime(startAt) : '',
  projectNo: '',
  productName: '',
  materialCode: '',
  materialName: '',
  rawMaterialBatchNo: '',
  rawMaterialBatchOptions: [],
  rawMaterialBatchIndex: -1,
  rawMaterialBatchError: false,
  process: '',
  stampingMethod: '',
  operatorCount: 1,
  processUnitPriceYuan: 0,
  isContinuousDie: false,
  isMultiPerson: false,
  isMisc: false,
  standardBeat: 0,
  standardWorkload: 0,
  changeoverCount: '',
  changeoverCountError: false,
  goodQty: '',
  defectQty: '',
  deviceError: false,
})

const batchIndexOf = (options = [], value = '') => {
  if (!value) {
    return -1
  }
  return (options || []).findIndex(option => String(option) === String(value))
}

const optionToDraftItem = (option, productIndex = 0, startAt = '', equipmentOptions = [], deviceNo = '', rawMaterialBatchOptions = [], rawMaterialBatchNo = '') => {
  const selectedDeviceNo = deviceNo || ''
  const deviceIndex = selectedDeviceNo
    ? Math.max(0, equipmentOptions.findIndex(item => item.deviceNo === selectedDeviceNo))
    : -1
  const batchOptions = rawMaterialBatchOptions || []
  return {
    productIndex,
    attendancePointName: option ? option.attendancePointName : '',
    deviceIndex,
    deviceNo: selectedDeviceNo,
    startAt: startAt || '',
    startAtText: startAt ? util.formatTime(startAt) : '',
    projectNo: option ? option.projectNo : '',
    productName: option ? option.productName : '',
    materialCode: option ? option.materialCode : '',
    materialName: option ? option.materialName : '',
    rawMaterialBatchNo: rawMaterialBatchNo || '',
    rawMaterialBatchOptions: batchOptions,
    rawMaterialBatchIndex: batchIndexOf(batchOptions, rawMaterialBatchNo),
    rawMaterialBatchError: false,
    process: option ? option.process : '',
    stampingMethod: option ? option.stampingMethod : '',
    operatorCount: option ? option.operatorCount : 1,
    processUnitPriceYuan: option ? option.processUnitPriceYuan : 0,
    isContinuousDie: option ? !!option.isContinuousDie : false,
    isMultiPerson: option ? !!option.isMultiPerson : false,
    isMisc: option ? !!option.isMisc : false,
    standardBeat: option ? option.standardBeat : 0,
    standardWorkload: option ? option.standardWorkload : 0,
    changeoverCount: '',
    changeoverCountError: false,
    goodQty: '',
    defectQty: '',
    deviceError: false,
  }
}

const apiDraftItemToCamel = (item, options, startAt = '', equipmentOptions = []) => {
  const rawMaterialBatchOptions = item && item.raw_material_batch_options ? item.raw_material_batch_options : []
  const rawMaterialBatchNo = item && item.raw_material_batch_no ? item.raw_material_batch_no : ''
  if (options.length >= 1 && (!item || !item.product_name)) {
    return optionToDraftItem(
      options[0],
      0,
      startAt,
      equipmentOptions,
      item && item.device_no,
      rawMaterialBatchOptions,
      rawMaterialBatchNo,
    )
  }
  const selectedDeviceNo = item.device_no || ''
  const productIndex = Math.max(0, options.findIndex(option => (
    option.projectNo === item.project_no
    && option.productName === item.product_name
    && (option.process || '') === (item.process_name || '')
  )))
  return {
    productIndex,
    attendancePointName: item.attendance_point_name || '',
    deviceNo: selectedDeviceNo,
    deviceIndex: selectedDeviceNo
      ? Math.max(0, equipmentOptions.findIndex(option => option.deviceNo === selectedDeviceNo))
      : -1,
    startAt: item.started_at || startAt || '',
    startAtText: util.formatTime(item.started_at || startAt || ''),
    projectNo: item.project_no || '',
    productName: item.product_name || '',
    materialCode: item.material_code || '',
    materialName: item.material_name || '',
    rawMaterialBatchNo,
    rawMaterialBatchOptions,
    rawMaterialBatchIndex: batchIndexOf(rawMaterialBatchOptions, rawMaterialBatchNo),
    rawMaterialBatchError: false,
    process: item.process_name || '',
    stampingMethod: item.stamping_method || '',
    operatorCount: item.operator_count || 1,
    processUnitPriceYuan: item.process_unit_price_yuan || 0,
    isContinuousDie: !!item.is_continuous_die || isContinuousDieRow(item),
    isMultiPerson: isMultiPersonRow(item),
    isMisc: !!item.is_misc || isMiscRow(item),
    standardBeat: item.standard_beat || 0,
    standardWorkload: item.standard_workload || 0,
    changeoverCount: item.changeover_count === null || item.changeover_count === undefined ? '' : String(item.changeover_count || ''),
    changeoverCountError: false,
    goodQty: '',
    defectQty: '',
    deviceError: false,
  }
}

const toCamelDraft = row => ({
  sessionId: row.session_id,
  attendancePointName: row.attendance_point_name || '',
  employeePhone: row.employee_phone,
  employeeName: row.employee_name,
  startAt: row.start_at,
  endAt: row.end_at,
  startAtText: util.formatTime(row.start_at),
  endAtText: util.formatTime(row.end_at),
  durationMinutes: row.duration_minutes,
  breakMinutes: 0,
  deviceBlocks: (row.device_blocks || []).map(block => {
    const options = (block.options || []).map(toCamelProduct)
    const equipmentOptions = (block.equipment_options || []).map(toCamelEquipment)
    const rawItems = block.items && block.items.length ? block.items : [{}]
    return {
      deviceNo: block.device_no,
      attendancePointName: block.attendance_point_name || row.attendance_point_name || '',
      moldName: block.mold_name || block.device_no,
      process: block.process_name || '',
      stampingMethod: block.stamping_method || '',
      moldDisplayName: block.display_name || moldDisplayName(block.mold_name || block.device_no, block.process_name, block.stamping_method),
      blockKey: `${block.device_no || ''}||${block.process_name || ''}`,
      isMisc: !!block.is_misc || isMiscRow({ product_name: block.mold_name || block.device_no, process_name: block.process_name }),
      isContinuousDie: !!block.is_continuous_die || isContinuousDieRow(block),
      startAt: block.start_at,
      endAt: block.end_at,
      durationMinutes: block.duration_minutes || 0,
      startAtText: util.formatTime(block.start_at),
      endAtText: util.formatTime(block.end_at),
      options,
      canAddItem: new Set(options.map(option => `${option.projectNo}||${option.productName}||${option.process}`)).size > 1,
      equipmentOptions,
      items: rawItems.map(item => apiDraftItemToCamel(item, options, block.start_at, equipmentOptions)),
    }
  }),
})

const toSubmitPayload = draft => ({
  session_id: Number(draft.sessionId),
  device_blocks: (draft.deviceBlocks || []).map(block => ({
    attendance_point_name: block.attendancePointName || draft.attendancePointName || '',
    device_no: block.deviceNo,
    process_name: block.process || '',
    items: (block.items || []).map(item => ({
      device_no: normalizeDeviceNo(item.deviceNo),
      attendance_point_name: item.attendancePointName || block.attendancePointName || draft.attendancePointName || '',
      project_no: item.projectNo,
      product_name: item.productName,
      material_code: item.materialCode || null,
      material_name: item.materialName || null,
      raw_material_batch_no: item.rawMaterialBatchNo || null,
      process_name: item.process || null,
      stamping_method: item.stampingMethod || null,
      operator_count: Number(item.operatorCount || 1),
      process_unit_price_yuan: Number(item.processUnitPriceYuan || 0),
      changeover_count: item.isContinuousDie ? Number(item.changeoverCount || 0) : 0,
      is_continuous_die: !!item.isContinuousDie,
      is_misc: !!item.isMisc,
      remark: item.remark || null,
      standard_beat: Number(item.standardBeat || 0),
      standard_workload: Number(item.standardWorkload || 0),
      good_qty: Number(item.goodQty || 0),
      defect_qty: Number(item.defectQty || 0),
      scrap_qty: 0,
      started_at: item.startAt || null,
    })),
  })),
})

const getCurrentUser = () => {
  const auth = requestClient.getAuth()
  return auth && auth.user ? auth.user : null
}

const refreshCurrentUser = async () => {
  const auth = requestClient.getAuth()
  if (!auth || !auth.accessToken) {
    return null
  }
  const user = toCamelPerson(await requestClient.request({
    url: '/api/auth/me',
  }))
  requestClient.setAuth({ ...auth, user })
  return user
}

const saveAuth = data => {
  const auth = {
    accessToken: data.access_token,
    user: toCamelPerson(data.user),
  }
  requestClient.setAuth(auth)
  return auth.user
}

const normalizeLoginResult = data => {
  if (data.needs_temporary_worker) {
    return {
      needsTemporaryWorker: true,
      temporaryToken: data.temporary_token,
      temporaryPhone: data.temporary_phone,
      temporaryExpiresAt: data.temporary_expires_at || '',
    }
  }
  if (data.needs_selection) {
    return {
      needsSelection: true,
      selectionToken: data.selection_token,
      matchedPeople: (data.matched_people || []).map(toCamelPerson),
    }
  }
  return saveAuth(data)
}

const autoSelectDefaultRole = async result => {
  if (!result || !result.needsSelection) {
    return result
  }
  const role = pickDefaultRole(result.matchedPeople)
  if (!role || !result.selectionToken) {
    return result
  }
  return selectRole(result.selectionToken, role)
}

const loginWithPhoneCode = async (phoneCode, selectedRole = '') => {
  const data = await requestClient.request({
    url: '/api/auth/wechat-login',
    method: 'POST',
    data: {
      phone_code: phoneCode,
      selected_role: selectedRole || null,
    },
  })
  return autoSelectDefaultRole(normalizeLoginResult(data))
}

const toCamelErpLoginPreview = data => ({
  sessionId: data.session_id,
  systemName: data.system_name || '嘉恒智能五金 ERP',
  startedAt: data.started_at || '',
  startedAtText: data.started_at ? util.formatTime(data.started_at) : '',
  expiresAt: data.expires_at || '',
  expiresAtText: data.expires_at ? util.formatTime(data.expires_at) : '',
  requestIpHint: data.request_ip_hint || '',
  userAgentHint: data.user_agent_hint || '',
})

const toCamelErpLoginAction = data => ({
  status: data.status || '',
  failureReason: data.failure_reason || '',
})

const getErpLoginPreview = async (ticket, sessionId) => toCamelErpLoginPreview(await requestClient.request({
  url: `/api/erp-login/sessions/${encodeURIComponent(ticket)}`,
  params: {
    session_id: sessionId,
  },
}))

const confirmErpLogin = async (ticket, sessionId, phoneCode) => toCamelErpLoginAction(await requestClient.request({
  url: `/api/erp-login/sessions/${encodeURIComponent(ticket)}/confirm`,
  method: 'POST',
  params: {
    session_id: sessionId,
  },
  data: {
    phone_code: phoneCode,
  },
}))

const cancelErpLogin = async (ticket, sessionId) => toCamelErpLoginAction(await requestClient.request({
  url: `/api/erp-login/sessions/${encodeURIComponent(ticket)}/cancel`,
  method: 'POST',
  params: {
    session_id: sessionId,
  },
}))

const createTemporaryWorker = async (temporaryToken, temporaryName = '', attendancePoint = null) => {
  const data = await requestClient.request({
    url: '/api/auth/wechat-login',
    method: 'POST',
    data: {
      create_temporary_worker: true,
      temporary_token: temporaryToken,
      temporary_name: temporaryName,
      temporary_attendance_point_name: attendancePoint && attendancePoint.factory ? attendancePoint.factory.name : null,
      temporary_latitude: attendancePoint && attendancePoint.current ? attendancePoint.current.latitude : null,
      temporary_longitude: attendancePoint && attendancePoint.current ? attendancePoint.current.longitude : null,
    },
  })
  return normalizeLoginResult(data)
}

const selectRole = async (selectionToken, role) => saveAuth(await requestClient.request({
  url: '/api/auth/select-role',
  method: 'POST',
  data: {
    selection_token: selectionToken,
    role,
  },
}))

const switchRole = async role => saveAuth(await requestClient.request({
  url: '/api/auth/switch-role',
  method: 'POST',
  data: {
    role,
  },
}))

const logout = () => requestClient.clearAuth()

const listAttendancePoints = async (filters = {}) => {
  const data = await requestClient.request({
    url: '/api/attendance-points',
    params: {
      keyword: filters.keyword,
      page: filters.page || 1,
      page_size: filters.pageSize || 100,
    },
  })
  return toCamelPage(data, toCamelAttendancePoint)
}

const listAccessibleAttendancePoints = async () => {
  const data = await requestClient.request({
    url: '/api/attendance-points/accessible',
  })
  return (data || []).map(toCamelAttendancePoint)
}

const listPublicAttendancePoints = async () => {
  const data = await requestClient.request({
    url: '/api/attendance-points/public',
  })
  return (data || []).map(toCamelAttendancePoint)
}

const saveAttendancePoint = async payload => toCamelAttendancePoint(await requestClient.request({
  url: '/api/attendance-points',
  method: 'POST',
  data: toSnakeAttendancePoint(payload),
}))

const deleteAttendancePoint = name => requestClient.request({
  url: `/api/attendance-points/${encodeURIComponent(name)}`,
  method: 'DELETE',
})

const listPeople = async (filters = {}) => {
  const data = await requestClient.request({
    url: '/api/people',
    params: {
      keyword: filters.keyword,
      page: filters.page,
      page_size: filters.pageSize,
    },
  })
  return toCamelPage(data, toCamelPerson)
}

const savePerson = async payload => toCamelPerson(await requestClient.request({
  url: '/api/people',
  method: 'POST',
  data: toSnakePerson(payload),
}))

const deletePerson = (phone, role = '') => requestClient.request({
  url: `/api/people/${encodeURIComponent(phone)}`,
  method: 'DELETE',
  params: {
    role,
  },
})

const importPeople = filePath => requestClient.upload({
  url: '/api/people/import',
  filePath,
})

const exportPeople = () => requestClient.download({
  url: '/api/people/export',
})

const listProducts = async (filters = {}) => {
  const data = await requestClient.request({
    url: '/api/products',
    params: {
      keyword: filters.keyword,
      attendance_point_name: filters.attendancePointName,
      device_no: filters.deviceNo,
      product_name: filters.productName,
      page: filters.page,
      page_size: filters.pageSize,
    },
  })
  return toCamelPage(data, toCamelProduct)
}

const listMoldNames = async (filters = {}) => {
  const data = await requestClient.request({
    url: '/api/products/molds',
    params: {
      keyword: filters.keyword,
      limit: filters.limit || 200,
    },
  })
  return (data || []).map(toCamelMoldOption)
}

const saveProduct = async payload => toCamelProduct(await requestClient.request({
  url: '/api/products',
  method: 'POST',
  data: toSnakeProduct(payload),
}))

const deleteProduct = product => requestClient.request({
  url: '/api/products',
  method: 'DELETE',
  params: {
    attendance_point_name: product.attendancePointName,
    project_no: product.projectNo,
    product_name: product.productName,
    device_no: product.deviceNo,
    process_name: product.rawProcess || product.process,
  },
})

const importProducts = filePath => requestClient.upload({
  url: '/api/products/import',
  filePath,
})

const exportProducts = () => requestClient.download({
  url: '/api/products/export',
  params: { t: Date.now() },
})

const listEquipment = async (filters = {}) => {
  const data = await requestClient.request({
    url: '/api/equipment',
    params: {
      keyword: filters.keyword,
      attendance_point_name: filters.attendancePointName,
      device_type: filters.deviceType,
      page: filters.page,
      page_size: filters.pageSize,
    },
  })
  return toCamelPage(data, toCamelEquipment)
}

const saveEquipment = async payload => toCamelEquipment(await requestClient.request({
  url: '/api/equipment',
  method: 'POST',
  data: toSnakeEquipment(payload),
}))

const deleteEquipment = equipment => {
  const deviceNo = typeof equipment === 'object' ? equipment.deviceNo : equipment
  const attendancePointName = typeof equipment === 'object' ? equipment.attendancePointName : ''
  return requestClient.request({
    url: `/api/equipment/${encodeURIComponent(normalizeDeviceNo(deviceNo))}`,
    method: 'DELETE',
    params: {
      attendance_point_name: attendancePointName,
    },
  })
}

const listNotices = async (filters = {}) => {
  const data = await requestClient.request({
    url: '/api/notices',
    params: {
      include_inactive: filters.includeInactive ? 1 : undefined,
      page: filters.page,
      page_size: filters.pageSize,
    },
  })
  return toCamelPage(data, toCamelNotice)
}

const saveNotice = async payload => {
  const noticeId = payload.id
  const data = await requestClient.request({
    url: noticeId ? `/api/notices/${noticeId}` : '/api/notices',
    method: noticeId ? 'PUT' : 'POST',
    data: toSnakeNotice(payload),
  })
  return toCamelNotice(data)
}

const deleteNotice = noticeId => requestClient.request({
  url: `/api/notices/${noticeId}`,
  method: 'DELETE',
})

const locationPayload = location => ({
  latitude: location && location.latitude !== undefined ? location.latitude : undefined,
  longitude: location && location.longitude !== undefined ? location.longitude : undefined,
})

const getClockState = async (moldName, processName = '', attendancePointName = '', location = null) => {
  const row = await requestClient.request({
    url: '/api/clock/state',
    params: {
      mold_name: String(moldName || '').trim(),
      process_name: String(processName || '').trim(),
      attendance_point_name: String(attendancePointName || '').trim(),
      ...locationPayload(location),
    },
  })
  return {
    action: row.action,
    actionText: row.action_text,
    attendancePointName: row.attendance_point_name || '',
    deviceNo: row.device_no,
    moldName: row.mold_name || row.device_no,
    processName: row.process_name || '',
    stampingMethod: row.stamping_method || '',
    isCleaning: !!row.is_cleaning || isCleaningRow(row),
    isMisc: !!row.is_misc || isMiscRow(row),
    displayName: row.display_name || moldDisplayName(row.mold_name || row.device_no, row.process_name, row.stamping_method),
    currentMoldName: row.current_mold_name || '',
    currentProcessName: row.current_process_name || '',
    session: row.session_id ? { id: row.session_id } : null,
    startAtText: row.start_at ? util.formatTime(row.start_at) : '',
    endAtText: row.end_at ? util.formatTime(row.end_at) : '',
    devices: row.devices || [],
    autoSubmitHours: row.auto_submit_hours || 15,
  }
}

const startWork = async (moldName, processName = '', attendancePointName = '', location = null) => toCamelSession(await requestClient.request({
  url: '/api/clock/start',
  method: 'POST',
  data: {
    mold_name: String(moldName || '').trim(),
    process_name: String(processName || '').trim(),
    attendance_point_name: String(attendancePointName || '').trim(),
    ...locationPayload(location),
  },
}))

const switchDevice = async (moldName, processName = '', attendancePointName = '', location = null) => toCamelSession(await requestClient.request({
  url: '/api/clock/switch-device',
  method: 'POST',
  data: {
    mold_name: String(moldName || '').trim(),
    process_name: String(processName || '').trim(),
    attendance_point_name: String(attendancePointName || '').trim(),
    ...locationPayload(location),
  },
}))

const finishWork = async (moldName, processName = '', attendancePointName = '', location = null) => toCamelSession(await requestClient.request({
  url: '/api/clock/finish',
  method: 'POST',
  data: {
    mold_name: String(moldName || '').trim(),
    process_name: String(processName || '').trim(),
    attendance_point_name: String(attendancePointName || '').trim(),
    ...locationPayload(location),
  },
}))

const continueWork = async sessionId => toCamelSession(await requestClient.request({
  url: '/api/clock/continue-work',
  method: 'POST',
  data: { session_id: Number(sessionId) },
}))

const createMoldLockFeedback = async lockId => toCamelMoldLockFeedback(await requestClient.request({
  url: '/api/monitor/feedbacks',
  method: 'POST',
  data: { lock_id: Number(lockId) },
}))

const listMonitorLocks = async () => (await requestClient.request({
  url: '/api/monitor/locks',
})).map(toCamelMonitorLock)

const listMoldLockFeedbacks = async (filters = {}) => toCamelPage(await requestClient.request({
  url: '/api/monitor/feedbacks',
  params: {
    box: filters.box || 'unread',
    page: filters.page || 1,
    page_size: filters.pageSize || 10,
  },
}), toCamelMoldLockFeedback)

const readMoldLockFeedback = async feedbackId => toCamelMoldLockFeedback(await requestClient.request({
  url: `/api/monitor/feedbacks/${feedbackId}/read`,
  method: 'POST',
}))

const releaseMoldLock = async lockId => requestClient.request({
  url: `/api/monitor/locks/${lockId}/release`,
  method: 'POST',
})

const releaseMoldLockByFeedback = async feedbackId => toCamelMoldLockFeedback(await requestClient.request({
  url: `/api/monitor/feedbacks/${feedbackId}/release`,
  method: 'POST',
}))

const buildReportDraft = async sessionId => toCamelDraft(await requestClient.request({
  url: '/api/reports/draft',
  params: { session_id: sessionId },
}))

const submitReport = async draft => toCamelReport(await requestClient.request({
  url: '/api/reports',
  method: 'POST',
  data: toSubmitPayload(draft),
}))

const submitCleaningReport = async (items, location = null) => toCamelReport(await requestClient.request({
  url: '/api/reports/cleaning',
  method: 'POST',
  data: {
    ...locationPayload(location),
    items: (items || []).map(item => ({
      attendance_point_name: item.attendancePointName || '',
      device_no: normalizeDeviceNo(item.deviceNo),
      device_nos: item.deviceNos && item.deviceNos.length ? item.deviceNos.map(normalizeDeviceNo).filter(Boolean) : [],
      product_name: item.moldName || item.productName || item.name || '',
      process_name: item.processName || '',
      stamping_method: item.stampingMethod || '',
      quantity: Number(item.quantity || 0),
    })),
  },
}))

const getReport = async reportId => toCamelReport(await requestClient.request({
  url: `/api/reports/${reportId}`,
}))

const listReports = async (filters = {}) => {
  let url = '/api/reports/mine'
  if (filters.status === 'pending' && !filters.employeePhone) {
    url = '/api/reviews/pending'
  }
  if (filters.reviewerPhone && url !== '/api/reviews/pending') {
    url = '/api/reviews/mine'
  }

  const params = {
    start_date: filters.startDate,
    end_date: filters.endDate,
    page: filters.page,
    page_size: filters.pageSize,
    include_voided: filters.includeVoided ? 1 : undefined,
  }
  if (url === '/api/reports/mine' && filters.status) {
    params.status = filters.status
  }
  if (url === '/api/reviews/mine' && filters.status) {
    params.status = filters.status
  }

  const data = await requestClient.request({ url, params })
  return toCamelPage(data, toCamelReport)
}

const approveReport = async (reportId, user, patch = {}) => toCamelReport(await requestClient.request({
  url: `/api/reviews/${reportId}/approve`,
  method: 'POST',
  data: {
    start_at: patch.startAt || null,
    end_at: patch.endAt || null,
    device_corrections: (patch.deviceCorrections || []).map(item => ({
      id: item.id,
      scanned_at: item.scannedAt || null,
    })),
    item_corrections: patch.itemCorrections || [],
    review_remark: Object.prototype.hasOwnProperty.call(patch, 'reviewRemark') ? (patch.reviewRemark || null) : undefined,
    remark: patch.remark || null,
  },
}))

const voidReport = async reportId => toCamelReport(await requestClient.request({
  url: `/api/reviews/${reportId}/void`,
  method: 'POST',
}))

const unvoidReport = async reportId => toCamelReport(await requestClient.request({
  url: `/api/reviews/${reportId}/unvoid`,
  method: 'POST',
}))

const toCamelWorkSchedule = row => ({
  id: row.id,
  dayStart: row.day_start,
  dayEnd: row.day_end,
  lunchStart: row.lunch_start,
  lunchEnd: row.lunch_end,
  dinnerStart: row.dinner_start,
  dinnerEnd: row.dinner_end,
  overtimeStart: row.overtime_start,
  overtimeEnd: row.overtime_end,
  nightStart: row.night_start,
  nightEnd: row.night_end,
  attendanceLatitude: row.attendance_latitude === null || row.attendance_latitude === undefined ? '' : row.attendance_latitude,
  attendanceLongitude: row.attendance_longitude === null || row.attendance_longitude === undefined ? '' : row.attendance_longitude,
  attendanceRadiusMeters: row.attendance_radius_meters === null || row.attendance_radius_meters === undefined ? '' : row.attendance_radius_meters,
  autoSubmitHours: row.auto_submit_hours === null || row.auto_submit_hours === undefined ? 15 : row.auto_submit_hours,
  attendancePoints: (row.attendance_points || []).map(toCamelAttendancePoint),
  updatedBy: row.updated_by || '',
  updatedAt: row.updated_at || '',
  updatedAtText: row.updated_at ? util.formatTime(row.updated_at) : '',
})

const toSnakeWorkSchedule = row => ({
  day_start: row.dayStart,
  day_end: row.dayEnd,
  lunch_start: row.lunchStart,
  lunch_end: row.lunchEnd,
  dinner_start: row.dinnerStart,
  dinner_end: row.dinnerEnd,
  overtime_start: row.overtimeStart,
  overtime_end: row.overtimeEnd,
  night_start: row.nightStart,
  night_end: row.nightEnd,
  attendance_latitude: row.attendanceLatitude === '' || row.attendanceLatitude === undefined ? null : Number(row.attendanceLatitude),
  attendance_longitude: row.attendanceLongitude === '' || row.attendanceLongitude === undefined ? null : Number(row.attendanceLongitude),
  attendance_radius_meters: row.attendanceRadiusMeters === '' || row.attendanceRadiusMeters === undefined ? null : Number(row.attendanceRadiusMeters),
  auto_submit_hours: row.autoSubmitHours === '' || row.autoSubmitHours === undefined ? 15 : Number(row.autoSubmitHours),
})

const getWorkSchedule = async () => toCamelWorkSchedule(await requestClient.request({
  url: '/api/work-schedule',
}))

const saveWorkSchedule = async payload => toCamelWorkSchedule(await requestClient.request({
  url: '/api/work-schedule',
  method: 'PUT',
  data: toSnakeWorkSchedule(payload),
}))

const saveWorkScheduleSettings = async payload => toCamelWorkSchedule(await requestClient.request({
  url: '/api/work-schedule/settings',
  method: 'PUT',
  data: {
    ...toSnakeWorkSchedule(payload),
    attendance_points: (payload.attendancePoints || []).map(toSnakeAttendancePoint),
  },
}))

const listDashboard = async (filters = {}) => {
  const data = await requestClient.request({
    url: '/api/dashboard/reports',
    params: {
      start_date: filters.startDate,
      end_date: filters.endDate,
      page: filters.page,
      page_size: filters.pageSize,
      include_voided: filters.includeVoided ? 1 : undefined,
    },
  })
  return toCamelPage(data, row => {
    const isMisc = !!row.is_misc || isMiscRow(row)
    const noOutputMetric = isMisc || isCleaningRow(row)
    const beatComparison = noOutputMetric ? classifyBeat(0, 0) : classifyBeat(row.actual_beat, row.standard_beat)
    const workloadComparison = noOutputMetric ? classifyWorkload(0, 0) : classifyWorkload(row.total_good_qty, row.expected_workload)
    return {
      id: row.id,
      attendancePointName: row.attendance_point_name || '',
      reportDate: row.report_date,
      employeePhone: row.employee_phone,
      employeeName: row.employee_name,
      projectNo: row.project_no,
      productName: row.product_name,
      processName: row.process_name,
      processDisplayName: moldDisplayName(row.product_name, row.process_name, row.stamping_method),
      rawMaterialBatchNo: row.raw_material_batch_no || '',
      stampingMethod: row.stamping_method || '',
      isCleaning: isCleaningRow(row),
      isContinuousDie: isContinuousDieRow(row),
      changeoverCount: row.changeover_count || 0,
      isMisc,
      isSystemAutoSubmitted: !!row.is_system_auto_submitted,
      isVoided: !!row.is_voided,
      isMultiPerson: isMultiPersonRow(row),
      isMultiPersonAssistant: !!row.is_multi_person_assistant,
      workerType: row.worker_type || '正式工',
      reportCount: row.report_count,
      effectiveMinutes: row.effective_minutes,
      shiftDistributionText: row.shift_distribution_text || '',
      sourceReportDate: row.source_report_date || '',
      sourceReportDates: row.source_report_dates || [],
      sourceReportDatesText: (row.source_report_dates || []).join('、'),
      shiftDayMinutes: row.shift_day_minutes || 0,
      shiftOvertimeMinutes: row.shift_overtime_minutes || 0,
      shiftNightMinutes: row.shift_night_minutes || 0,
      shiftOtherMinutes: row.shift_other_minutes || 0,
      totalGood: row.total_good_qty,
      totalDefect: row.total_defect_qty,
      totalOutput: row.total_output_qty,
      actualBeat: row.actual_beat,
      standardBeat: row.standard_beat,
      processUnitPriceYuan: row.process_unit_price_yuan || 0,
      referenceWage: round2(row.reference_wage || 0),
      expectedWorkload: row.expected_workload,
      paceRate: row.pace_rate,
      workloadRate: row.workload_rate,
      paceText: row.pace_text,
      workloadText: row.workload_text,
      beatCompareClass: beatComparison.className,
      beatReason: beatComparison.reason,
      workloadCompareClass: workloadComparison.className,
      workloadReason: workloadComparison.reason,
      reviewRemark: row.review_remark || '',
      correctionPairs: (row.correction_pairs || []).map(pair => ({
        key: pair.key,
        label: pair.label,
        oldValue: correctionDisplayValue(pair.old_value),
        newValue: correctionDisplayValue(pair.new_value),
      })),
    }
  })
}

const listUsageStats = async (filters = {}) => {
  const data = await requestClient.request({
    url: '/api/usage-stats/summary',
    params: {
      ...usageStatsParams(filters),
      page: filters.page,
      page_size: filters.pageSize,
    },
  })
  return toCamelPage(data, toCamelUsageStatsRow)
}

const getUsageStatsDetail = async (filters = {}) => toCamelUsageStatsDetail(await requestClient.request({
  url: '/api/usage-stats/detail',
  params: usageStatsParams(filters),
}))

const listReconciliationYears = async () => {
  const data = await requestClient.request({
    url: '/api/reconciliation/years',
  })
  return {
    years: data.years || [],
    currentYear: data.current_year,
  }
}

const listReconciliationLedger = async year => {
  const data = await requestClient.request({
    url: '/api/reconciliation',
    params: { year },
  })
  return {
    year: data.year,
    currentYear: data.current_year,
    currentMonth: data.current_month,
    rows: (data.rows || []).map(row => ({
      attendancePointName: row.attendance_point_name || '',
      productName: row.product_name,
      uniqueKey: `${row.attendance_point_name || ''}||${row.product_name || ''}`,
      months: (row.months || []).map(month => ({
        month: month.month,
        reportedGoodQty: month.reported_good_qty || 0,
        reconciledGoodQty: month.reconciled_good_qty || 0,
        returnQty: month.return_qty || 0,
      })),
    })),
  }
}

const saveReconciliationEntry = async payload => {
  const data = await requestClient.request({
    url: '/api/reconciliation/entry',
    method: 'PUT',
    data: {
      year: Number(payload.year),
      month: Number(payload.month),
      attendance_point_name: payload.attendancePointName || '',
      product_name: payload.productName,
      reconciled_good_qty: payload.reconciledGoodQty === undefined ? undefined : Number(payload.reconciledGoodQty || 0),
      return_qty: payload.returnQty === undefined ? undefined : Number(payload.returnQty || 0),
    },
  })
  return {
    month: data.month,
    reconciledGoodQty: data.reconciled_good_qty || 0,
    returnQty: data.return_qty || 0,
  }
}

const exportDashboard = filters => requestClient.download({
  url: '/api/dashboard/reports/export',
  params: {
    start_date: filters && filters.startDate,
    end_date: filters && filters.endDate,
    include_voided: filters && filters.includeVoided ? 1 : undefined,
  },
})

const exportUsageStats = (filters = {}) => requestClient.download({
  url: '/api/usage-stats/export',
  params: usageStatsParams(filters),
})

const generateMoldQr = async mold => {
  const original = typeof mold === 'object' ? String(mold.moldName || mold.name || '').trim() : String(mold || '').trim()
  const processName = typeof mold === 'object' ? String(mold.processName || '').trim() : ''
  const attendancePointName = typeof mold === 'object' ? String(mold.attendancePointName || '').trim() : ''
  const data = await requestClient.request({
    url: '/api/devices/molds/qrcode',
    method: 'POST',
    data: {
      attendance_point_name: attendancePointName,
      product_name: original,
      process_name: processName,
    },
  })
  return {
    deviceNo: data.device_no,
    attendancePointName: data.attendance_point_name || '',
    moldName: data.mold_name || data.device_no,
    processName: data.process_name || '',
    stampingMethod: data.stamping_method || '',
    isCleaning: !!data.is_cleaning || isCleaningRow(data),
    isMisc: !!data.is_misc || isMiscRow(data),
    displayName: data.display_name || moldDisplayName(data.mold_name || data.device_no, data.process_name, data.stamping_method),
    qrPath: `${data.page}?scene=${encodeURIComponent(data.scene)}`,
    qrUrl: data.qr_url || '',
    scene: data.scene,
  }
}

const generateMoldQrBatch = async molds => {
  const data = await requestClient.request({
    url: '/api/devices/molds/qrcode/batch',
    method: 'POST',
    timeout: 120000,
    data: {
      items: (molds || []).map(mold => ({
        attendance_point_name: String(mold.attendancePointName || '').trim(),
        product_name: String(mold.moldName || mold.name || '').trim(),
        process_name: String(mold.processName || '').trim(),
      })),
    },
  })
  return {
    count: data.count || 0,
    fileName: data.file_name || '',
    zipUrl: data.zip_url || '',
  }
}

const toCamelQrcodeBatchTask = row => ({
  id: row.id,
  fileName: row.file_name || '',
  status: row.status || '',
  statusName: row.status_name || '',
  itemCount: Number(row.item_count || 0),
  completedCount: Number(row.completed_count || 0),
  failedCount: Number(row.failed_count || 0),
  progressPercent: Number(row.progress_percent || 0),
  zipUrl: row.zip_url || '',
  errorMessage: row.error_message || '',
  startedAt: row.started_at || '',
  startedAtText: row.started_at ? util.formatTime(row.started_at) : '',
  finishedAt: row.finished_at || '',
  finishedAtText: row.finished_at ? util.formatTime(row.finished_at) : '',
  createdAt: row.created_at || '',
  createdAtText: row.created_at ? util.formatTime(row.created_at) : '',
  updatedAt: row.updated_at || '',
  isPending: row.status === 'pending',
  isRunning: row.status === 'running',
  isPaused: row.status === 'paused',
  isCompleted: row.status === 'completed',
  isFailed: row.status === 'failed',
})

const createMoldQrBatchTask = async molds => {
  const data = await requestClient.request({
    url: '/api/devices/molds/qrcode/batch/tasks',
    method: 'POST',
    timeout: 30000,
    data: {
      items: (molds || []).map(mold => ({
        attendance_point_name: String(mold.attendancePointName || '').trim(),
        product_name: String(mold.moldName || mold.name || '').trim(),
        process_name: String(mold.processName || '').trim(),
      })),
    },
  })
  return toCamelQrcodeBatchTask(data)
}

const listMoldQrBatchTasks = async (filters = {}) => {
  const page = await requestClient.request({
    url: '/api/devices/molds/qrcode/batch/tasks',
    params: {
      page: filters.page || 1,
      page_size: filters.pageSize || 5,
    },
  })
  return toCamelPage(page, toCamelQrcodeBatchTask)
}

const stopMoldQrBatchTask = async taskId => toCamelQrcodeBatchTask(await requestClient.request({
  url: `/api/devices/molds/qrcode/batch/tasks/${taskId}/stop`,
  method: 'POST',
}))

const resumeMoldQrBatchTask = async taskId => toCamelQrcodeBatchTask(await requestClient.request({
  url: `/api/devices/molds/qrcode/batch/tasks/${taskId}/resume`,
  method: 'POST',
}))

const deleteMoldQrBatchTask = async taskId => requestClient.request({
  url: `/api/devices/molds/qrcode/batch/tasks/${taskId}`,
  method: 'DELETE',
})

const downloadFileByUrl = (url, filePath, timeout = 120000) => requestClient.downloadUrl({
  url,
  filePath,
  timeout,
})

const generateDeviceQr = generateMoldQr

const resolveMoldScene = async scene => {
  const data = await requestClient.request({
    url: '/api/devices/resolve-scene',
    params: { scene },
  })
  return {
    attendancePointName: data.attendance_point_name || '',
    moldName: data.mold_name || data.device_no || '',
    processName: data.process_name || '',
    stampingMethod: data.stamping_method || '',
    isCleaning: !!data.is_cleaning || isCleaningRow(data),
    isMisc: !!data.is_misc || isMiscRow(data),
    displayName: data.display_name || moldDisplayName(data.mold_name || data.device_no, data.process_name, data.stamping_method),
  }
}

const getHomeSummary = async user => {
  if (!user) {
    return {}
  }
  const summary = {
    productCount: 0,
    peopleCount: 0,
    pendingCount: 0,
    myToday: 0,
    approvedToday: 0,
  }
  const today = util.today()
  const tasks = [
    listProducts({ page: 1, pageSize: 1 }).then(result => { summary.productCount = result.total }),
    listReports({ startDate: today, endDate: today, page: 1, pageSize: 1 }).then(result => { summary.myToday = result.total }).catch(() => {}),
  ]
  if (['admin', 'manager'].includes(user.role)) {
    tasks.push(listPeople({ page: 1, pageSize: 1 }).then(result => { summary.peopleCount = result.total }).catch(() => {}))
  }
  if (user.role === 'admin') {
    tasks.push(listReports({
      status: 'pending',
      page: 1,
      pageSize: 1,
    }).then(result => { summary.pendingCount = result.total }).catch(() => {}))
    tasks.push(listReports({
      reviewerPhone: user.phone,
      status: 'approved',
      startDate: today,
      endDate: today,
      page: 1,
      pageSize: 1,
    }).then(result => { summary.approvedToday = result.total }).catch(() => {}))
  }
  if (user.role === 'manager') {
    tasks.push(listDashboard({ startDate: today, endDate: today, page: 1, pageSize: 1 }).then(result => { summary.approvedToday = result.total }).catch(() => {}))
  }
  await Promise.all(tasks)
  return summary
}

module.exports = {
  approveReport,
  buildReportDraft,
  calculateStandardWorkload,
  cancelErpLogin,
  classifyBeat,
  classifyWorkload,
  confirmErpLogin,
  continueWork,
  createTemporaryWorker,
  createMoldLockFeedback,
  createMoldQrBatchTask,
  deleteMoldQrBatchTask,
  deleteAttendancePoint,
  deleteEquipment,
  deletePerson,
  deleteProduct,
  deleteNotice,
  downloadFileByUrl,
  exportPeople,
  exportProducts,
  exportDashboard,
  exportUsageStats,
  formatDurationAllUnits,
  formatDurationMinutes,
  finishWork,
  generateDeviceQr,
  generateMoldQr,
  generateMoldQrBatch,
  getClockState,
  getCurrentUser,
  getErpLoginPreview,
  getHomeSummary,
  getReport,
  getUsageStatsDetail,
  getWorkSchedule,
  importPeople,
  importProducts,
  listAccessibleAttendancePoints,
  listAttendancePoints,
  listDashboard,
  listEquipment,
  listMoldNames,
  listMonitorLocks,
  listMoldLockFeedbacks,
  listMoldQrBatchTasks,
  listNotices,
  listPeople,
  listProducts,
  listPublicAttendancePoints,
  listReconciliationLedger,
  listReconciliationYears,
  listReports,
  listUsageStats,
  loginWithPhoneCode,
  logout,
  isContinuousDieRow,
  isContinuousDieStampingMethod,
  moldDisplayName,
  normalizeDeviceNo,
  normalizeProcessValue,
  processDisplayName,
  refreshCurrentUser,
  readMoldLockFeedback,
  releaseMoldLock,
  releaseMoldLockByFeedback,
  resolveMoldScene,
  roleNames,
  saveAttendancePoint,
  saveNotice,
  saveEquipment,
  savePerson,
  saveProduct,
  saveReconciliationEntry,
  saveWorkSchedule,
  saveWorkScheduleSettings,
  selectRole,
  startWork,
  resumeMoldQrBatchTask,
  stopMoldQrBatchTask,
  submitCleaningReport,
  submitReport,
  switchRole,
  switchDevice,
  unvoidReport,
  voidReport,
}