import Cookies from 'js-cookie'
import config from '@/config'
import Storage from './storage'
import { cloneDeep } from 'lodash'

declare const window: any

// 用户信息 cookie key
export const USER_INFO = 'userInfo'
// 登录域名 cookie key
// 谷神的 token
const GU_SHEN_TOKEN = 'GuShen_Token'
// 用于刷新的token
const GU_SHEN_REFRESH_TOKEN = 'Gushen_Refresh_token'
// it 系统设置的 token
const IT_TOKEN = 'token'
const PWD_KEY = 'GuShen-PS'
const LANG_KEY = 'GS_LANG'
// cookie 失效时间
const TOKEN_INVALID = 'tokenInvalid'
const storage = new Storage('GUSHEN')
const { cookieExpires, systemCode } = config
// token失效的缓存地址
export const TOKEN_OUT_ROUTE = 'tokenOutRoute'
// 之前的环境变量
export const PRE_ENV = 'preEnv'
// 页签缓存 key,单体应用页签缓存要根据系统区分，否则会污染基座的页签信息
const VISITED_STORE_KEY = `${systemCode}_visited_views`

// 分钟转小时
export function getDays(value?:number | string) {
  const tokenInvalid = Cookies.get(TOKEN_INVALID) || value
  if (!tokenInvalid) return
  return (tokenInvalid * 1) / 60 / 24
}

// 设置cookie
export function cookieSet(name, value, overtime) {
  const domain = getCookieDomain()
  const expires = overtime || cookieExpires
  Cookies.set(name, value, { expires, domain })
}

// 获取cookie
export function cookieGet(name) {
  return Cookies.get(name, { domain: getCookieDomain() })
}

// 获取token
export function getToken() {
  return Cookies.get(GU_SHEN_TOKEN)
}
// 获取 it 系统的 token
export function getItToken() {
  return Cookies.get(IT_TOKEN, { domain: '.chinasie.com' })
}

// 设置 token
export const setToken = (token, refreshToken) => {
  const domain = getCookieDomain()
  const expires = getDays() || 0.5
  Cookies.set(GU_SHEN_TOKEN, token, { expires, domain })
  Cookies.set(GU_SHEN_REFRESH_TOKEN, refreshToken, { expires, domain })
}
// 设置页签缓存
export function setVisitedViews(data) {
  localStorage.setItem(VISITED_STORE_KEY, JSON.stringify(data))
}
// 获取页签缓存
export function getVisitedViews() {
  return localStorage.getItem(VISITED_STORE_KEY)
}
// 清除页签缓存
export function removeVisitedViews() {
  return localStorage.removeItem(VISITED_STORE_KEY)
}

// 获取系统语言
export function getLanguage() {
  return Cookies.get(LANG_KEY, { domain: getCookieDomain() })
}
// 设置系统语言
export function setLanguage(value) {
  return Cookies.set(LANG_KEY, value, {
    domain: getCookieDomain(),
    expires: 30,
  })
}

// 缓存菜单信息
export const setMenuList = (data) => {
  data && localStorage.setItem('menuList', JSON.stringify(data))
}

// 缓存用户信息
export const setUserInfo = (userInfo) => {
  if (userInfo) {
    const info = JSON.stringify(userInfo)
    // cookie存不了那么多的数据，只能改用storage
    // Cookies.set(USER_INFO, userInfo, { expires: cookieExpires })
    storage.setItem(USER_INFO, info, 1)
  }
}

export const getRefreshToken = () => {
  return Cookies.get(GU_SHEN_REFRESH_TOKEN) || ''
}

// 缓存token失效后当前的路由
export const setTokenOutRoute = (href) => {
  const redirectURL = getQuery('redirectURL')
  // 20230228 修改为 cookie 存储，解决跨域无法获取数据的问题
  // sessionStorage.setItem('tokenOutRoute', redirectURL || href)
  cookieSet(TOKEN_OUT_ROUTE, redirectURL || href, null)
  cookieSet(PRE_ENV, window.VUE_ENV, null)
}
// 获取缓存token失效时的路由
export const getTokenOutRoute = () => {
  const outRoute = cookieGet(TOKEN_OUT_ROUTE)
  return outRoute ? decodeURIComponent(outRoute) : ''
}

export const setPwdVal = (pwd) => {
  const expires = cookieExpires
  Cookies.set(PWD_KEY, pwd, {
    expires,
    domain: getCookieDomain(),
  })
}

// 获取用户信息
export const getUserInfo = () => {
  // const userInfo = Cookies.get(USER_INFO)
  const userInfo = storage.getItem(USER_INFO)
  // console.log('userInfo', typeof (userInfo))
  let userInfoJson =
    typeof userInfo == 'object' ? userInfo : JSON.parse(userInfo || '')
  // if (userInfo) return JSON.parse(userInfo)
  // else return ''
  return userInfoJson || ''
}

export function getPwd() {
  return Cookies.get(PWD_KEY)
}

export function removeToken() {
  const domain = getCookieDomain()
  Cookies.remove(USER_INFO)
  Cookies.remove(GU_SHEN_TOKEN, { expires: -1, domain })
  Cookies.remove(GU_SHEN_REFRESH_TOKEN, { expires: -1, domain })
  // 这里把 2-5 的 domain 下的 cookies 都清一次，避免修改变量后还遗留 cookies 导致无法退出登录的情况。
  for (let i = 2; i <= 5; i++) {
    const defaultDomain = getCookieDomain(i)
    Cookies.remove(GU_SHEN_TOKEN, { expires: -1, domain: defaultDomain })
    Cookies.remove(GU_SHEN_REFRESH_TOKEN, {
      expires: -1,
      domain: defaultDomain,
    })
  }
  Cookies.remove(IT_TOKEN, { expires: -1, domain: '.chinasie.com' })
  localStorage.removeItem('GptChatList')
  localStorage.removeItem('GptSession_iotAutho')
  localStorage.removeItem('GptSession_pmo')
  localStorage.removeItem('GptSession_pidb')
}

export function setParentTenantId(parentTenantId) {
  storage.setItem('parentTenantId', parentTenantId)
}

// 从localStorage中清除租户信息
export function removeTenantInfo() {
  localStorage.removeItem('isSuperadmin')
  localStorage.removeItem('tenantId')
  localStorage.removeItem('tenantName')
  localStorage.removeItem('userId')
  localStorage.removeItem('userInfo')
}
export function getCookieDomain(level?: number) {
  if (
    process.env.NODE_ENV === 'production' ||
    process.env.NODE_ENV === 'docker'
  ) {
    const domain = document.domain
    const ipReg =
      /^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$/
    // 如果是IP地址访问直接用IP
    if (ipReg.test(domain)) return domain
    // 返回一级域名
    return document.domain
      .split('.')
      .slice(parseInt(`-${level || window.VUE_DOMAIN_LEVEL || 2}`))
      .join('.')
  }
  //本地开发环境无需指定域名
  return ''
}
// 字段权限分类
export function fieldsAuthSub(data) {
  let man = {
    hidden: [],
    encrypt: [],
  }
  if (Array.isArray(data)) {
    data.forEach((item) => {
      // 隐藏
      if (item.hiddenFlag === 1) man.hidden.push(item.name)

      // 加密
      if (item.encryptFlag === 1) man.encrypt.push(item.name)
    })
  }

  return man
}

// 清除对应cookie
export function removeCookie(name) {
  let strcookie = document.cookie
  let arrcookie = strcookie.split('; ')
  arrcookie.forEach((element) => {
    let arr = element.split('=')
    if (arr[0].indexOf(name) !== -1) {
      Cookies.remove(arr[0])
    }
  })
}

// 获取地址search字符串转为query对象
export function getQuery(key) {
  const search = window.location.search.substr(1)
  const searchList = search.split('&') || []
  let query = {}
  searchList.forEach((e) => {
    const list = e.split('=') || []
    query[list[0]] = list[1]
  })
  return key ? query[key] : query
}

// 处理退出到登录页的域名
export const handleDomainLayout = () => {
  const VUE_AUTH_API = window.VUE_AUTH_API ?? ''
  const VUE_SUBPATH = window.VUE_SUBPATH ?? '/'
  if (process.env.NODE_ENV === 'development') {
    window.location.href = `${VUE_SUBPATH}login`
    return
  }
  window.location.href = `${VUE_AUTH_API}/login`
}

/**
 * @doce 所属系统多语言
 * @param {Object} item
 * @param that
 * */
export function getSystemName(item, that) {
  try {
    const menuLanguageObject = JSON.parse(item.systemEnName)
    if (typeof menuLanguageObject === 'object') {
      return (
        menuLanguageObject[that.$i18n.locale] ||
        item.systemTitle ||
        item.systemName ||
        'no-name'
      )
    } else {
      return item.systemEnName || 'no-name'
    }
  } catch (err) {
    return that.$i18n.locale === 'en-us'
      ? item.systemEnName
      : item.systemTitle || item.systemName || 'no-name'
  }
}

/**
 * @doce 所属系统菜单树形多语言处理
 * @param {Object} item
 * @param that
 *
 * */
export function menuTitle(item, that) {
  // 获取接口菜单名称，切割[PC] & [APP]
  let menuEnName = item.menuEnName.replace(`[${item.enterType}]`, '')
  try {
    // 获取后台返回多语言翻译json，并解析
    const menuLanguageObject = JSON.parse(menuEnName)
    // 该变量的数据类型为object时
    if (typeof menuLanguageObject === 'object') {
      let menuLang = menuLanguageObject[that.$i18n.locale]
      if (menuLang) {
        return `[${item.enterType}]${menuLang}` || 'no-name'
      } else {
        return item.menuName || 'no-name'
      }
    } else {
      return `[${item.enterType}]${menuEnName}` || 'no-name'
    }
  } catch (err) {
    return that.$i18n.locale === 'en-us'
      ? `[${item.enterType}]${menuEnName}`
      : item.menuName || 'no-name'
  }
}

/**
 * 树形结构拍平到数组结构
 * @param {array} arr 树形数据
 * @return {array} 返回平铺的树形结构
 */

export function treeToArr(arr, childName = 'children') {
  let res = []
  let newArr = []
  newArr = newArr.concat(cloneDeep(arr))

  while (newArr.length) {
    let first = newArr.shift() // 每一次都取newArr的第一项出来
    if (first[childName]) {
      newArr = newArr.concat(first[childName]) // 如果第一项有children属性，那么就把这个children放到newArr的最后一项取
      delete first[childName] // 然后再删除children属性
    }
    res.push(first)
  }

  return res
}