import { pages, subPackages } from '@/pages.json'
import { isMpWeixin } from './platform'

export function getLastPage() {
  // getCurrentPages() 至少有1个元素，所以不再额外判断
  // const lastPage = getCurrentPages().at(-1)
  // 上面那个在低版本安卓中打包会报错，所以改用下面这个【虽然我加了 src/interceptions/prototype.ts，但依然报错】
  const pages = getCurrentPages()
  return pages[pages.length - 1]
}

/**
 * 获取当前页面路由的 path 路径和 redirectPath 路径
 * path 如 '/pages/login/index'
 * redirectPath 如 '/pages/demo/base/route-interceptor'
 */
export function currRoute() {
  const lastPage = getLastPage()
  const currRoute = (lastPage as any).$page
  // console.log('lastPage.$page:', currRoute)
  // console.log('lastPage.$page.fullpath:', currRoute.fullPath)
  // console.log('lastPage.$page.options:', currRoute.options)
  // console.log('lastPage.options:', (lastPage as any).options)
  // 经过多端测试，只有 fullPath 靠谱，其他都不靠谱
  const { fullPath } = currRoute as { fullPath: string }
  // console.log(fullPath)
  // eg: /pages/login/index?redirect=%2Fpages%2Fdemo%2Fbase%2Froute-interceptor (小程序)
  // eg: /pages/login/index?redirect=%2Fpages%2Froute-interceptor%2Findex%3Fname%3Dfeige%26age%3D30(h5)
  return getUrlObj(fullPath)
}

function ensureDecodeURIComponent(url: string) {
  if (url.startsWith('%')) {
    return ensureDecodeURIComponent(decodeURIComponent(url))
  }
  return url
}
/**
 * 解析 url 得到 path 和 query
 * 比如输入url: /pages/login/index?redirect=%2Fpages%2Fdemo%2Fbase%2Froute-interceptor
 * 输出: {path: /pages/login/index, query: {redirect: /pages/demo/base/route-interceptor}}
 */
export function getUrlObj(url: string) {
  const [path, queryStr] = url.split('?')
  // console.log(path, queryStr)

  if (!queryStr) {
    return {
      path,
      query: {},
    }
  }
  const query: Record<string, string> = {}
  queryStr.split('&').forEach((item) => {
    const [key, value] = item.split('=')
    // console.log(key, value)
    query[key] = ensureDecodeURIComponent(value) // 这里需要统一 decodeURIComponent 一下，可以兼容h5和微信y
  })
  return { path, query }
}
/**
 * 得到所有的需要登录的 pages，包括主包和分包的
 * 这里设计得通用一点，可以传递 key 作为判断依据，默认是 needLogin, 与 route-block 配对使用
 * 如果没有传 key，则表示所有的 pages，如果传递了 key, 则表示通过 key 过滤
 */
export function getAllPages(key = 'needLogin') {
  // 这里处理主包
  const mainPages = pages
    .filter(page => !key || page[key])
    .map(page => ({
      ...page,
      path: `/${page.path}`,
    }))

  // 这里处理分包
  const subPages: any[] = []
  subPackages.forEach((subPageObj) => {
    // console.log(subPageObj)
    const { root } = subPageObj

    subPageObj.pages
      .filter(page => !key || page[key])
      .forEach((page: { path: string } & Record<string, any>) => {
        subPages.push({
          ...page,
          path: `/${root}/${page.path}`,
        })
      })
  })
  const result = [...mainPages, ...subPages]
  // console.log(`getAllPages by ${key} result: `, result)
  return result
}

/**
 * 得到所有的需要登录的 pages，包括主包和分包的
 * 只得到 path 数组
 */
export const getNeedLoginPages = (): string[] => getAllPages('needLogin').map(page => page.path)

/**
 * 得到所有的需要登录的 pages，包括主包和分包的
 * 只得到 path 数组
 */
export const needLoginPages: string[] = getAllPages('needLogin').map(page => page.path)

/**
 * 根据微信小程序当前环境，判断应该获取的 baseUrl
 */
export function getEnvBaseUrl() {
  // 请求基准地址
  let baseUrl = import.meta.env.VITE_SERVER_BASEURL

  // 微信小程序端环境区分
  if (isMpWeixin) {
    const {
      miniProgram: { envVersion },
    } = uni.getAccountInfoSync()

    switch (envVersion) {
      case 'develop':
        baseUrl = import.meta.env.VITE_SERVER_BASEURL__WEIXIN_DEVELOP || baseUrl
        break
      case 'trial':
        baseUrl = import.meta.env.VITE_SERVER_BASEURL__WEIXIN_TRIAL || baseUrl
        break
      case 'release':
        baseUrl = import.meta.env.VITE_SERVER_BASEURL__WEIXIN_RELEASE || baseUrl
        break
    }
  }

  return baseUrl
}

/**
 * 根据微信小程序当前环境，判断应该获取的 UPLOAD_BASEURL
 */
export function getEnvBaseUploadUrl() {
  // 请求基准地址
  let baseUploadUrl = import.meta.env.VITE_UPLOAD_BASEURL

  // 微信小程序端环境区分
  if (isMpWeixin) {
    const {
      miniProgram: { envVersion },
    } = uni.getAccountInfoSync()

    switch (envVersion) {
      case 'develop':
        baseUploadUrl = import.meta.env.VITE_UPLOAD_BASEURL__WEIXIN_DEVELOP || baseUploadUrl
        break
      case 'trial':
        baseUploadUrl = import.meta.env.VITE_UPLOAD_BASEURL__WEIXIN_TRIAL || baseUploadUrl
        break
      case 'release':
        baseUploadUrl = import.meta.env.VITE_UPLOAD_BASEURL__WEIXIN_RELEASE || baseUploadUrl
        break
    }
  }

  return baseUploadUrl
}

// 其他公共方法

export function extractAndRetained(obj, keys) {
  const extract = {}
  const retained = { ...obj } // 创建浅拷贝

  keys.forEach((key) => {
    if (Object.prototype.hasOwnProperty.call(retained, key)) {
      extract[key] = retained[key]
      delete retained[key]
    }
  })

  return { extract, retained }
}
// 地址栏参数拼接
/**
 * 将对象序列化为 URL 查询字符串
 * @param {object} params - 需要序列化的参数对象
 * @returns {string} 序列化后的查询字符串
 */
export function qs(params) {
  return Object.entries(params)
    .map(([key, value]) => {
      const encodedKey = encodeURIComponent(key)
      const encodedValue
        = value === undefined || value === null
          ? ''
          : encodeURIComponent(String(value))
      return `${encodedKey}=${encodedValue}`
    })
    .join('&')
}

/**
 * 解析 URL 查询字符串为对象
 * @param {string} queryString - 需要解析的查询字符串（如 "a=1&b=2"）
 * @returns {object} 解析后的参数对象
 */
export function parseQs(queryString) {
  if (!queryString)
    return {}

  // 移除开头的问号（如果有）
  const cleanQuery = queryString.startsWith('?')
    ? queryString.slice(1)
    : queryString

  return cleanQuery.split('&')
    .reduce((acc, pair) => {
      const [encodedKey, encodedValue] = pair.split('=')

      if (encodedKey === undefined)
        return acc

      const key = decodeURIComponent(encodedKey)
      const value = encodedValue === undefined
        ? undefined
        : decodeURIComponent(encodedValue)

      // 处理空字符串值
      acc[key] = value === '' ? null : value

      return acc
    }, {})
}

/**
 * 数字格式化，加逗号分隔符，支持自定义小数位数
 * @param num 要格式化的数字，支持 number 或 string 类型
 * @param decimals 小数位数，默认为 2，传入 0 表示不要小数
 * @returns 格式化后的字符串
 */
export function formatNumber(num: number | string, decimals: number = 2): string {
  // 处理空值
  if (num === undefined || num === null || num === '') {
    return decimals === 0 ? '0' : `0.${'0'.repeat(decimals)}`
  }

  // 转换为数字
  const numValue = typeof num === 'string' ? Number.parseFloat(num) : num

  // 检查是否为有效数字
  if (Number.isNaN(numValue)) {
    return decimals === 0 ? '0' : `0.${'0'.repeat(decimals)}`
  }

  // 格式化数字
  const formattedNum = decimals === 0
    ? Math.round(numValue).toString()
    : numValue.toFixed(decimals)

  // 添加千分位分隔符
  return formattedNum.replace(/\d{1,3}(?=(\d{3})+(\.\d*)?$)/g, '$&,')
}

/**
 * 销量数字格式化
 * 超过一千显示单位K，有小数保留一位，没有小数就显示整数，不超过一千正常显示
 * @param num 要格式化的销量数字，支持 number 或 string 类型
 * @returns 格式化后的字符串
 */
export function formatSales(num: number | string): string {
  // 处理空值
  if (num === undefined || num === null || num === '') {
    return '0'
  }

  // 转换为数字
  const numValue = typeof num === 'string' ? Number.parseFloat(num) : num

  // 检查是否为有效数字
  if (Number.isNaN(numValue)) {
    return '0'
  }

  // 小于1000，直接显示整数
  if (numValue < 1000) {
    return Math.round(numValue).toString()
  }

  // 大于等于1000，转换为K单位
  const kValue = numValue / 1000

  // 如果是整数，不显示小数
  if (kValue % 1 === 0) {
    return `${Math.round(kValue)}K`
  }

  // 有小数，保留一位小数
  return `${kValue.toFixed(1)}K`
}
