import {AllCells, JVXETypes} from '@/components/jeecg/JVxeTable'
import JVxeCellMixins from '../mixins/JVxeCellMixins'

export const JVXERenderType = {
  editer: 'editer',
  spaner: 'spaner',
  default: 'default',
}

/** 安装所有vxe组件 */
export function installAllCell(VXETable) {
  // 遍历所有组件批量注册
  Object.keys(AllCells).forEach(type => installOneCell(VXETable, type))
}

/** 安装单个vxe组件 */
export function installOneCell(VXETable, type) {
  const switches = getEnhancedMixins(type, 'switches')
  if (switches.editRender === false) {
    installCellRender(VXETable, type, AllCells[type])
  } else {
    installEditRender(VXETable, type, AllCells[type])
  }
}

/** 注册可编辑组件 */
export function installEditRender(VXETable, type, comp, spanComp) {
  // 获取当前组件的增强
  const enhanced = getEnhancedMixins(type)
  // span 组件
  if (!spanComp && AllCells[type + ':span']) {
    spanComp = AllCells[type + ':span']
  } else {
    spanComp = AllCells[JVXETypes.normal]
  }
  // 添加渲染
  VXETable.renderer.add(JVXETypes._prefix + type, {
    // 可编辑模板
    renderEdit: createRender(comp, enhanced, JVXERenderType.editer),
    // 显示模板
    renderCell: createRender(spanComp, enhanced, JVXERenderType.spaner),
    // 增强注册
    ...enhanced.installOptions,
  })
}

/** 注册普通组件 */
export function installCellRender(VXETable, type, comp = AllCells[JVXETypes.normal]) {
  // 获取当前组件的增强
  const enhanced = getEnhancedMixins(type)
  VXETable.renderer.add(JVXETypes._prefix + type, {
    // 默认显示模板
    renderDefault: createRender(comp, enhanced, JVXERenderType.default),
    // 增强注册
    ...enhanced.installOptions,
  })
}

function createRender(comp, enhanced, renderType) {
  return function (h, renderOptions, params) {
    return [h(comp, {
      props: {
        value: params.row[params.column.property],
        row: params.row,
        column: params.column,
        params: params,
        renderOptions: renderOptions,
        renderType: renderType,
      }
    })]
  }
}

// 已混入的组件增强
const AllCellsMixins = new Map()

/** 获取某个组件的增强 */
export function getEnhanced(type) {
  let cell = AllCells[type]
  if (cell && cell.enhanced) {
    return cell.enhanced
  }
  return null
}

/**
 * 获取某个组件的增强（混入默认值）
 *
 * @param type JVXETypes
 * @param name 可空，增强名称，留空返回所有增强
 */
export function getEnhancedMixins(type, name) {
  const getByName = (e) => name ? e[name] : e
  if (AllCellsMixins.has(type)) {
    return getByName(AllCellsMixins.get(type))
  }
  let defEnhanced = JVxeCellMixins.enhanced
  let enhanced = getEnhanced(type)
  if (enhanced) {
    Object.keys(defEnhanced).forEach(key => {
      let def = defEnhanced[key]
      if (enhanced.hasOwnProperty(key)) {
        // 方法如果存在就不覆盖
        if (typeof def !== 'function' && typeof def !== 'string') {
          enhanced[key] = Object.assign({}, def, enhanced[key])
        }
      } else {
        enhanced[key] = def
      }
    })
    AllCellsMixins.set(type, enhanced)
    return getByName(enhanced)
  }
  AllCellsMixins.set(type, defEnhanced)
  return getByName(defEnhanced)
}


/** 辅助方法：替换${...}变量 */
export function replaceProps(col, value) {
  if (value && typeof value === 'string') {
    let text = value
    text = text.replace(/\${title}/g, col.title)
    text = text.replace(/\${key}/g, col.key)
    text = text.replace(/\${defaultValue}/g, col.defaultValue)
    return text
  }
  return value
}