import Vue from 'vue'
import {
  AssetTag,
  AssetTagInfo,
  AssetType,
  AssetTypeInfo,
  SCREEN_TIME_KEY,
  TimeType,
  FOREVER
} from '@/constant'

export const EventBus = new Vue()

export function parseTime (time, cFormat) {
  if (arguments.length === 0 || !time) {
    return null
  }
  const format = cFormat || '{y}-{m}-{d} {h}:{i}:{s}'
  let date
  if (typeof time === 'object') {
    date = time
  } else {
    if ((typeof time === 'string')) {
      if ((/^[0-9]+$/.test(time))) {
        // support "1548221490638"
        time = parseInt(time)
      } else {
        // support safari
        // https://stackoverflow.com/questions/4310953/invalid-date-in-safari
        time = time.replace(new RegExp(/-/gm), '/')
      }
    }

    if ((typeof time === 'number') && (time.toString().length === 10)) {
      time *= 1000
    }
    date = new Date(time)
  }
  const formatObj = {
    y: date.getFullYear(),
    m: date.getMonth() + 1,
    d: date.getDate(),
    h: date.getHours(),
    i: date.getMinutes(),
    s: date.getSeconds(),
    a: date.getDay()
  }
  const time_str = format.replace(/{([ymdhisa])+}/g, (result, key) => {
    const value = formatObj[key]
    // Note: getDay() returns 0 on Sunday
    if (key === 'a') {
      return ['日', '一', '二', '三', '四', '五', '六'][value]
    }
    return value.toString().padStart(2, '0')
  })
  return time_str
}

export function createListOptions (params) {
  return {
    list: [],
    totalCount: 0,
    loading: false,
    error: false,
    params: {
      pageNum: 1,
      pageSize: 10,
      ...params
    }
  }
}

const units = ['B', 'KB', 'M', 'G']
export function parseByte (byte) {
  byte = Number(byte)
  if (!byte) {
    return '-'
  }
  const edge = 1024
  let i = 0
  while (i < units.length - 1) {
    if (byte >= edge / 2) {
      byte /= edge
      i += 1
    } else {
      break
    }
  }
  return `${parseInt(byte * 100) / 100}${units[i]}`
}

export function parseDuration (duration, ignore = true) {
  if (!duration) {
    return ignore ? '-' : '00:00'
  }
  const seconds = `${duration % 60}`
  const minutes = `${duration / 60 | 0}`
  return `${minutes.padStart(2, '0')}:${seconds.padStart(2, '0')}`
}

function parseTimeToHHmmss (time, seconds = '00') {
  return time && time.length === 8 ? time : `${time}:${seconds}`
}

export function parseTaskTime (task) {
  if (!task) {
    return {
      type: TimeType.SCREEN,
      range: ['00:00:00', '23:59:59'],
      point: parseTime(new Date(), '{h}:{i}:{s}')
    }
  }
  const { startTime = SCREEN_TIME_KEY, endTime = SCREEN_TIME_KEY } = task
  return {
    type: startTime === SCREEN_TIME_KEY && endTime === SCREEN_TIME_KEY ? TimeType.SCREEN : endTime ? TimeType.RANGE : TimeType.POINT,
    range: [startTime === SCREEN_TIME_KEY ? '00:00:00' : parseTimeToHHmmss(startTime), !endTime || endTime === SCREEN_TIME_KEY ? '23:59:59' : parseTimeToHHmmss(endTime, '59')],
    point: startTime === SCREEN_TIME_KEY || endTime ? '00:00:00' : startTime
  }
}

export function getTaskTimeInfo ({ startTime, endTime }) {
  return startTime === SCREEN_TIME_KEY && endTime === SCREEN_TIME_KEY ? '开机期间' : endTime ? `${startTime}-${endTime}` : startTime
}

export function transformToTaskTime ({ type, range, point }) {
  switch (type) {
    case TimeType.SCREEN:
      return { startTime: SCREEN_TIME_KEY, endTime: SCREEN_TIME_KEY }
    case TimeType.RANGE:
      return { startTime: range[0], endTime: range[1] }
    case TimeType.POINT:
      return { startTime: point, endTime: '' }
    default:
      return { startTime: SCREEN_TIME_KEY, endTime: SCREEN_TIME_KEY }
  }
}

export function offsetDate (date, offset) {
  const targetDate = new Date(date)
  targetDate.setDate(targetDate.getDate() + offset - 1)
  return parseTime(targetDate, '{y}-{m}-{d}')
}

export function calculateDay (startDate, endDate) {
  return (new Date(endDate) - new Date(startDate)) / 86400000 | 0
}

export function getAssetThumb (asset) {
  switch (asset.type) {
    case AssetType.IMAGE:
      return asset.keyName
    case AssetType.VIDEO:
      return asset.screenshot === 'analyzing' ? '' : asset.screenshot
    case AssetType.PPT:
    case AssetType.PDF:
    case AssetType.DOC:
      if (asset.childrenData?.length) {
        return getAssetThumb(asset.childrenData[0])
      }
      return ''
    default:
      return ''
  }
}

export function getAssetDiff ({ duration }) {
  return parseDuration(duration)
}

export function getAssetDuration ({ type, duration }, defaultDuration = 10) {
  switch (type) {
    case AssetType.STREAMING_MEDIA:
      return Number(duration) || 60
    default:
      return Number(duration) || defaultDuration
  }
}

export function getAIState ({ aiAuditState: status, aiAuditMsg: msg }) {
  switch (status) {
    case 1:
      return {
        type: 'danger',
        label: '不合规'
      }
    case 2:
      return {
        type: 'warning',
        label: '疑似',
        msg
      }
    case 3:
      return {
        type: 'info',
        label: '审核失败',
        msg
      }
    case 4:
    case 5:
    case 6:
      return {
        type: 'primmary',
        label: '审核中'
      }
    case 7:
      return {
        type: 'success',
        label: '通过'
      }
    case 8:
      return {
        type: 'info',
        label: '无法审核',
        msg
      }
    case 9:
      return {
        type: 'info',
        label: '未开启'
      }
    default:
      return null
  }
}

export function transformOrderAssetToAsset ({ keyName, type, adDuration, thumb }) {
  if (type) {
    const isImage = type === AssetType.IMAGE
    return {
      tagInfo: AssetTagInfo[AssetTag.AD],
      typeInfo: AssetTypeInfo[type],
      file: {
        type,
        url: keyName,
        thumb: isImage ? keyName : thumb,
        origin: !isImage
      },
      adDuration: parseDuration(adDuration)
    }
  }
  return {
    tagInfo: '资源已删除',
    adDuration: parseDuration(adDuration)
  }
}

export function transformContractAssetToAsset ({ duration, minioData }) {
  if (minioData) {
    const { tag, type, keyName } = minioData
    return {
      tagInfo: AssetTagInfo[tag],
      typeInfo: AssetTypeInfo[type],
      file: {
        type,
        url: keyName,
        thumb: getAssetThumb(minioData)
      },
      name: minioData.originalName,
      adDuration: parseDuration(duration)
    }
  }
  return {
    tagInfo: '资源已删除',
    adDuration: parseDuration(duration)
  }
}

export function transformContractAssetToDraggableAsset ({ id, keyName, duration, minioData }) {
  if (minioData) {
    const { tag, type, originalName } = minioData
    return {
      id,
      keyName,
      tag,
      type,
      duration,
      key: id,
      disabled: type === AssetType.VIDEO,
      info: `${AssetTagInfo[tag]} ${AssetTypeInfo[type]}`,
      name: originalName,
      file: {
        type,
        url: keyName
      }
    }
  }
  return {
    id,
    keyName,
    duration,
    key: id,
    disabled: true,
    name: '资源已删除'
  }
}

export function transfromDatasetAssetToDraggableAsset ({ relationId, tag, type, keyName, adDuration, minioData }) {
  if (minioData) {
    const { originalName, size } = minioData
    return {
      relationId,
      tag,
      type,
      keyName,
      size,
      duration: adDuration,
      key: relationId,
      disabled: type === AssetType.VIDEO,
      info: `${AssetTagInfo[tag]} ${AssetTypeInfo[type]}`,
      name: originalName,
      file: {
        type,
        url: keyName
      }
    }
  }
  return {
    relationId,
    tag,
    type,
    keyName,
    duration: adDuration,
    key: relationId,
    disabled: true,
    name: '资源已删除'
  }
}

export function transformDatasetAssetToAsset (asset) {
  if (asset.minioData) {
    asset.tagInfo = AssetTagInfo[asset.tag]
    asset.typeInfo = AssetTypeInfo[asset.type]
    asset.file = {
      type: asset.type,
      url: asset.keyName,
      thumb: asset.minioData ? getAssetThumb(asset.minioData) : null
    }
    asset.name = asset.minioData.originalName
  } else {
    asset.tagInfo = '-'
    asset.typeInfo = '-'
    asset.name = '资源已删除'
  }
  return asset
}

// dayOfWeek，周日为起始，对应1~7
// 最终cron数据对应的为秒、分、时、日、月、星期、年，例如'30 0 12 14 11 ? 2022'
export function transformToCron (startDate, endDate, dayOfWeek, executeTime) {
  let suffix = null
  if (startDate === endDate) {
    suffix = startDate.split('-').reverse()
    suffix.splice(2, 0, '?')
  } else if (dayOfWeek === '?') {
    suffix = ['*', '*', '?', '*']
  } else {
    suffix = ['?', '*', dayOfWeek, '*']
  }
  return executeTime
    .split(':')
    .map(val => Number(val))
    .reverse()
    .concat(suffix)
    .join(' ')
}

export function transformCron (cron) {
  const strArr = cron[0].split(' ')
  return {
    dayOfWeek: strArr[5],
    executeTime: `${strArr[2].padStart(2, '0')}:${strArr[1].padStart(2, '0')}:${strArr[0].padStart(2, '0')}`
  }
}

export function transformScreenTaskInfo (startDate, endDate, dayOfWeek, executeTime) {
  return {
    date: endDate === FOREVER
      ? '永久生效'
      : startDate === endDate
        ? startDate
        : `${startDate} - ${endDate}`,
    day: startDate === endDate
      ? '一次性任务'
      : parseCronWeekToInfo(dayOfWeek),
    time: executeTime.map(({ start, end }) => start && end
      ? `[${start.replace(/:\d{2}$/, '')} - ${end.replace(/:\d{2}$/, '')}]`
      : start
        ? `${start.replace(/:\d{2}$/, '')} 开启屏幕`
        : `${end.replace(/:\d{2}$/, '')} 关闭屏幕`).join(', ')
  }
}

export function getCronWeekOptions () {
  return [
    { value: '2', label: '一' },
    { value: '3', label: '二' },
    { value: '4', label: '三' },
    { value: '5', label: '四' },
    { value: '6', label: '五' },
    { value: '7', label: '六' },
    { value: '1', label: '日' }
  ]
}

export function parseCronWeekToInfo (dayOfWeek) {
  return dayOfWeek === '?'
    ? '每天'
    : `每周${dayOfWeek.split(',').map(val => ['', '日', '一', '二', '三', '四', '五', '六'][val]).join('、')}`
}