import {
  SimilarQueryItem,
  GroupSimilarQueryItem,
  FilterRightHelperType,
  SearchFilterItem,
  UserTagItem,
  CategoryTagValueItem,
  CategoryTag,
  CategoryFilter,
  SemiAutoCategoryFilter,
  RangeUnitFilter,
  NameValueItem,
} from '../types/searchSelect'
import { LabeledValue } from 'antd/lib/select'
import { store } from '../store'
import { SearchType } from '../types/searchTypeSelect'

export function transformTypeName(similarQuery: SimilarQueryItem[]) {
  return similarQuery.map(_ => ({
    ..._,
    type_name: _.type_name === '关键词' ? '工作经历' : _.type_name,
  }))
}

export function transformOptionToValueOption(option: LabeledValue[]) {
  return option.map(({ value }) => ({
    label: value,
    value,
  }))
}

export function mergeSameTypeSimilarQuery(
  similarQuery: SimilarQueryItem[]
): GroupSimilarQueryItem[] {
  const typeNames = Array.from(new Set(similarQuery.map(({ type_name }) => type_name)))

  return typeNames.map(_ => ({
    typeName: _,
    group: similarQuery.filter(({ type_name }) => type_name === _),
  }))
}

export function calcAnalysisFilterRightHelperType<T>(
  isMultiple: boolean,
  values: T[]
): FilterRightHelperType {
  return isMultiple ? (values.length ? 'SUBMIT_BTN' : 'MULTIPLE_TIP') : 'SINGLE_TIP'
}

export function calcUserTagDict(userTag: UserTagItem[]): Map<string, string> {
  return new Map(userTag.map(({ id, content }) => [id + '', content]))
}

export function analysisCategoryFilterSubmit(filter: SearchFilterItem, selectedKeys: string[]) {
  const { tag } = filter
  const { values = [] } = tag
  store.main.appendFilter({
    ...filter,
    tag: {
      ...tag,
      values: (values as CategoryTagValueItem[]).filter(({ name }) => selectedKeys.includes(name)),
    } as CategoryTag,
  })
}

export function getChannelDict() {
  return new Map([
    ['dajie', '大街'],
    ['chinahr', '中华英才网'],
    ['lagou', '拉勾'],
    ['lagou.com', '拉勾'],
    ['highpin.cn', '智联卓聘'],
    ['maimai.cn', '脉脉'],
    ['zhaopin.com', '智联招聘'],
    ['liepin.com', '猎聘'],
    ['51job.com', '前程无忧'],
    ['linkedin.com', '领英'],
    ['51jingying.com', '无忧精英'],
    ['58.com', '58同城'],
    ['jobuy.com', '猎才医药网'],
    ['shixiseng.com', '实习僧'],
  ])
}

export function transformChannel(
  filter: SearchFilterItem[],
  dict: Map<string, string>
): SearchFilterItem[] {
  return filter.map(_ => {
    if (_.tag.name !== '渠道') return _

    return {
      ..._,
      tag: {
        ..._.tag,
        values: (_.tag.values as NameValueItem[]).map(({ name }) => ({
          name: dict.get(name) || name,
        })),
      },
    } as SearchFilterItem
  })
}

export function getSelectedFilterText(filter: SearchFilterItem): string {
  if (
    (filter as CategoryFilter).tag.type === 'CategoryTag' ||
    (filter as SemiAutoCategoryFilter).tag.type === 'SemiAutoCategoryTag'
  )
    return getSelectedCategoryFilterText(filter as CategoryFilter | SemiAutoCategoryFilter)

  if ((filter as RangeUnitFilter).tag.type === 'RangeUnitTag')
    return getSelectedRangeFilterText(filter as RangeUnitFilter)

  return 'UNKONW_FILTER'
}

export function getSelectedCategoryFilterText({
  tag: { name, values = [] },
}: CategoryFilter | SemiAutoCategoryFilter): string {
  const value = values.map(({ name }) => name).join('、')

  return `${name}: ${value}`
}

export function getSelectedRangeFilterText({
  tag: { name, values = [] },
}: RangeUnitFilter): string {
  const value = values.map(valueItem => {
    const { name, range, unit: _unit } = valueItem
    const { low, high } = range
    const { quantity, unit } = _unit
    const rangeArea = [low, high].filter(_ => Number.isFinite(_!)).join('-')
    const suffix = [quantity, unit].filter(_ => _).join('')

    let append = ''
    if (low && !high) append = '以上'
    if (high && !low) append = '以下'

    return `${name || '范围'}${rangeArea}${suffix}${append}`
  })

  return `${name}: ${value}`
}

export function transformQueryToQ(query: LabeledValue[]) {
  if (!query.length) return ''

  return JSON.stringify(
    query.map(({ value }) => {
      let [type_name, q] = ['', value]

      if ((value as string).includes(':')) [type_name, q] = (value as string).split(':')

      const queryItem = { q, type_name }
      if (type_name === '智能搜索' || !type_name) delete (queryItem as any).type_name
      if (type_name === '工作经历') queryItem.type_name = '关键词'
      if (type_name === '唯一搜索') queryItem.type_name = 'openid'

      return queryItem
    })
  )
}

export function transformTypeNameForShow(typeName: string) {
  if (typeName === '关键词') return '工作经历'
  if (typeName === 'openid') return '唯一搜索'
  return typeName
}

export function transformQToQuery(q: string, searchType: SearchType): LabeledValue[] {
  if (!q) return []

  const parsedQ = JSON.parse(q) as SimilarQueryItem[]

  return parsedQ.map(({ q: _q, type_name }) => ({
    value: searchType === 'resume' ? `${transformTypeNameForShow(type_name)}:${_q}` : `${_q}`,
    label: searchType === 'resume' ? `${transformTypeNameForShow(type_name)}:${_q}` : `${_q}`,
  }))
}

export function getSavedSearchParamsText(
  q: string,
  filter: SearchFilterItem[],
  dict: Map<string, string>
): string {
  const parsedQ = JSON.parse(q) as SimilarQueryItem[]

  const qStr = parsedQ
    .map(({ q: _q, type_name }) => `${transformTypeNameForShow(type_name)}:${_q}`)
    .join('|')
  const filterStr = transformChannel(filter, dict)
    .map(_ => getSelectedFilterText(_))
    .join('|')

  return [qStr, filterStr].filter(_ => _).join('-')
}

export function filterTagByShowUserTag({ tag: { key } }: SearchFilterItem, show: boolean) {
  return show ? true : key !== 'user_tag'
}

export function transformDefaultQToQuery(q: string): LabeledValue[] {
  const defaultQuery = [{ label: `智能搜索:${q}`, value: `智能搜索:${q}` }]

  if (!q.includes(`"type_name":"`)) return defaultQuery

  return (JSON.parse(q) as SimilarQueryItem[]).map<LabeledValue>(({ q, type_name }) => ({
    label: `${type_name}:${q}`,
    value: `${type_name}:${q}`,
  }))
}

// 启用搜索建议的租户
export const showSuggestDropdownTenant = [
  'jinronghangyedemo',
  'hulianwanghangyedemo',
  'dichanjinronghangyedemo',
  'yiliaohangyedemo',
  'wangfeng1553247455086',
  'xinyanshishiyong1543216588315',
  'fplustest',
  'bingjian',
  'tghumanresourceservicespteltd1559887251532',
  'bosirencai1555308783929',
  'yinggemajinrong1557929256710',
  'duidianzixun1554345043642',
  'maifu',
  'xuzhuping1553745497200',
  'ruizida',
  '800hrresource',
  'xiangchen1552017228227',
  'zeenlietou',
  'maimai',
  'zhitongmeihan',
  'gaofanlietou',
  'dolphin',
  'beijingyibohezixunyouxiangongsi1563259287882',
  'shanghaiguzhengrencaizixunyouxiangongsi1563417150088',
  'zeshi',
  'fplussimple',
  'suzhouboxun1557911842991',
  'vivi1551680835874',
  'lige',
  'xugongzi',
]