export const FileName = (data) =>{
    let name = data.split("/").pop()
    return name
}
export const formatTime = (time) => {
    return new Date(time).toLocaleString()
}

export const formatDate = (dateStr) => {
  if (!dateStr || dateStr === '0001-01-01T00:00:00Z' || dateStr === null) return '-'
  const date = new Date(dateStr)
  if (isNaN(date.getTime())) return '-'
  const year = date.getFullYear()
  const month = String(date.getMonth() + 1).padStart(2, '0')
  const day = String(date.getDate()).padStart(2, '0')
  const hours = String(date.getHours()).padStart(2, '0')
  const minutes = String(date.getMinutes()).padStart(2, '0')
  return `${year}-${month}-${day} ${hours}:${minutes}`
}
/**
 * 时间格式转 Unix 时间戳（秒级）
 * @param {string|Date} time - 输入时间（支持 '2025-10-28 00:00:00'、'2025/10/28'、Date 对象等）
 * @returns {number|null} 转换后的毫秒级时间戳（失败返回 null）
 */
export function timeToTimestamp(time) {
    let date;
  
    // 处理字符串格式（如 '2025-10-28 00:00:00' 或 '2025/10/28'）
    if (typeof time === 'string') {
      // 替换 '-' 为 '/'（避免 Safari 等浏览器对 '-' 格式解析失败）
      const formattedTime = time.replace(/-/g, '/');
      date = new Date(formattedTime);
    }
  
    // 处理 Date 对象
    else if (time instanceof Date) {
      date = time;
    }
  
    // 无效输入
    else {
      console.error('无效的时间格式，支持字符串（如 "2025-10-28 00:00:00"）或 Date 对象');
      return null;
    }
  
    // 验证时间是否有效
    const timestamp = date.getTime();
    if (isNaN(timestamp)) {
      console.error(`无法解析时间：${time}`);
      return null;
    }
  
    return Math.floor(timestamp / 1000); // 返回秒级时间戳（如 1751107200000）
  }


  export function reducenum(num){
    return num / 100
  }

/**
 * 分转元显示（返回 ¥xx.xx 或 '-'）
 */
export function formatPrice(fen, fallback = '-') {
  if (!fen && fen !== 0) return fallback
  return '¥' + (fen / 100).toFixed(2)
}

/**
 * 元转分（四舍五入取整）
 */
export function yuanToFen(yuan) {
  return Math.round((yuan || 0) * 100)
}

/**
 * 格式化到期时间（year < 2000 视为永久）
 */
export function formatExpireTime(t) {
  if (!t) return '-'
  const d = new Date(t)
  if (isNaN(d.getTime())) return '-'
  if (d.getFullYear() < 2000) return '永久'
  const pad = (n) => String(n).padStart(2, '0')
  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`
}

/**
 * 将 ISO 格式时间字符串转换为毫秒级时间戳（用于时间选择器）
 * @param {string|Date|number} time - 输入时间（支持 ISO 格式字符串如 '2023-11-08T01:10:00+08:00'、Date 对象、时间戳等）
 * @returns {number|null} 转换后的毫秒级时间戳（失败或无效时间返回 null）
 */
export function isoToMilliseconds(time) {
  // 处理空值
  if (!time || time === null || time === undefined) {
    return null
  }

  // 处理特殊的无效时间标识
  if (typeof time === 'string' && (time === '0001-01-01T00:00:00Z' || time === '0001-01-01T00:00:00+00:00')) {
    return null
  }

  // 如果已经是数字（时间戳），直接返回
  if (typeof time === 'number') {
    // 如果是秒级时间戳（小于 13 位），转换为毫秒
    if (time < 1000000000000) {
      return time * 1000
    }
    return time
  }

  // 处理 Date 对象
  if (time instanceof Date) {
    const timestamp = time.getTime()
    return isNaN(timestamp) ? null : timestamp
  }

  // 处理字符串格式
  if (typeof time === 'string') {
    try {
      const date = new Date(time)
      const timestamp = date.getTime()
      
      // 检查是否为有效时间
      if (isNaN(timestamp)) {
        return null
      }
      
      return timestamp
    } catch (error) {
      console.error('时间转换失败:', error)
      return null
    }
  }

  return null
}

/**
 * 格式化时间为 "YYYY-MM-DD HH:mm:ss" 格式（用于接口提交）
 * @param {string|Date|number} time
 * @returns {string} 格式化后的时间字符串，无效时返回 ''
 */
export function formatToApiTime(time) {
  if (!time) return ''
  const d = time instanceof Date ? time : new Date(time)
  if (isNaN(d.getTime())) return ''
  const pad = (n) => String(n).padStart(2, '0')
  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`
}

// ========== 虚拟机状态映射 ==========
const VM_STATUS_MAP = {
  pending:  { label: '等待中',  type: 'info' },
  creating: { label: '创建中',  type: 'warning' },
  ready:    { label: '就绪',    type: 'success' },
  running:  { label: '运行中',  type: 'success' },
  stopped:  { label: '已停止',  type: 'danger' },
  stop:     { label: '已停止',  type: 'danger' },
  shutoff:  { label: '已关闭',  type: 'danger' },
  error:    { label: '错误',    type: 'danger' },
  paused:   { label: '已暂停',  type: 'warning' },
  reboot:   { label: '重启中',  type: 'warning' },
  poweroff: { label: '已关机',  type: 'info' },
  unknown:  { label: '未知',    type: 'info' }
}

/**
 * 获取虚拟机状态标签文字
 */
export function vmStatusLabel(status) {
  return VM_STATUS_MAP[status]?.label || status || '-'
}

/**
 * 获取虚拟机状态 Tag 类型
 */
export function vmStatusType(status) {
  return VM_STATUS_MAP[status]?.type || 'info'
}

// ========== 磁盘状态映射 ==========
const VOLUME_STATUS_MAP = {
  pending:    { label: '等待中', type: 'info' },
  creating:   { label: '创建中', type: 'warning' },
  ready:      { label: '就绪',   type: 'success' },
  in_use:     { label: '使用中', type: 'success' },
  attaching:  { label: '挂载中', type: 'warning' },
  detaching:  { label: '卸载中', type: 'warning' },
  resizing:   { label: '扩容中', type: 'warning' },
  deleting:   { label: '删除中', type: 'danger' },
  error:      { label: '错误',   type: 'danger' },
  unknown:    { label: '未知',   type: 'info' }
}

/**
 * 获取磁盘状态标签文字
 */
export function volumeStatusLabel(status) {
  return VOLUME_STATUS_MAP[status]?.label || status || '-'
}

/**
 * 获取磁盘状态 Tag 类型
 */
export function volumeStatusType(status) {
  return VOLUME_STATUS_MAP[status]?.type || 'info'
}
