;(function () {
  var defaultGatewayBase = 'http://192.168.110.66:1100'
  var defaultGatewayPrefix = '/go'
  var defaultLocalGoBase = 'http://127.0.0.1:2900'
  var hostApiBaseMap = {
    'h5.haiyihy.com': 'https://jvapi.haiyihy.com/go'
  }
  var defaultSysOrigin = 'LIKEI'
  var defaultReqClient = 'Android'
  var defaultReqAppIntel = {
    version: '1.0.0',
    build: '1',
    model: 'SM-G9550',
    sysVersion: '9',
    channel: 'Google'
  }
  var defaultReqImei = '8fa54d728ab449e04f9292329ed44bda'
  var defaultReqVersion = 'V2'
  var legacyGoldImage = 'assets/common/yumi_coin.png'
  var legacySemanticRoutes = {
    'Action/TreasureHunt.getPrizeList': '/h5/smash-golden-egg/config',
    'Action/TreasureHunt.startHunt': '/h5/smash-golden-egg/draw',
    'Action/TreasureHunt.getMyHuntRecord': '/h5/smash-golden-egg/records',
    'Action/TreasureHunt.getHuntRecord': '/h5/smash-golden-egg/notices',
    'Action/TreasureHunt.getDayRank': '/h5/smash-golden-egg/rank/day'
  }
  var semanticLegacyActions = {
    '/h5/smash-golden-egg/config': 'Action/TreasureHunt.getPrizeList',
    '/h5/smash-golden-egg/draw': 'Action/TreasureHunt.startHunt',
    '/h5/smash-golden-egg/records': 'Action/TreasureHunt.getMyHuntRecord',
    '/h5/smash-golden-egg/notices': 'Action/TreasureHunt.getHuntRecord',
    '/h5/smash-golden-egg/rank/day': 'Action/TreasureHunt.getDayRank'
  }
  var sysOriginAliases = {
    ATYOU: 'LIKEI',
    YUMI: 'LIKEI',
    SOULLA: 'LIKEI',
    '4PARTY': 'LIKEI',
    FOURPARTY: 'LIKEI'
  }

  function readParams() {
    var pairs = []
    if (window.location.search) pairs.push(window.location.search.slice(1))
    var hash = window.location.hash || ''
    var hashQueryIndex = hash.indexOf('?')
    if (hashQueryIndex >= 0) pairs.push(hash.slice(hashQueryIndex + 1))

    var params = {}
    pairs.forEach(function (query) {
      query.split('&').forEach(function (item) {
        if (!item) return
        var index = item.indexOf('=')
        var key = index >= 0 ? item.slice(0, index) : item
        var value = index >= 0 ? item.slice(index + 1) : ''
        try {
          key = decodeURIComponent(key)
          value = decodeURIComponent(value.replace(/\+/g, ' '))
        } catch (error) {}
        if (key) params[key] = value
      })
    })
    return params
  }

  function normalizeBase(value) {
    return String(value || '').replace(/\/+$/, '')
  }

  function normalizePrefix(value) {
    value = String(value || '')
    if (!value) return ''
    if (value.charAt(0) !== '/') value = '/' + value
    return value.replace(/\/+$/, '')
  }

  function resolveHostApiBase() {
    var host = ''
    try {
      host = String(window.location.hostname || '').toLowerCase()
    } catch (error) {}
    return hostApiBaseMap[host] || ''
  }

  function storageGet(storage, key) {
    try {
      return storage.getItem(key) || ''
    } catch (error) {
      return ''
    }
  }

  function storageSet(storage, key, value) {
    try {
      if (value) storage.setItem(key, value)
    } catch (error) {}
  }

  function bearer(value) {
    value = String(value || '').trim()
    if (!value) return ''
    return /^bearer\s+/i.test(value) ? value : 'Bearer ' + value
  }

  function bearerToken(value) {
    return String(value || '').replace(/^bearer\s+/i, '').trim()
  }

  function sameOrigin(rawUrl) {
    try {
      return new URL(rawUrl, window.location.href).origin === window.location.origin
    } catch (error) {
      return false
    }
  }

  function parseHeaderPairs(value) {
    var result = {}
    String(value || '').split(';').forEach(function (item) {
      var index = item.indexOf('=')
      if (index < 0) return
      var key = item.slice(0, index).trim()
      var val = item.slice(index + 1).trim()
      if (key) result[key] = val
    })
    return result
  }

  function parseReqSysOrigin(value) {
    var result = { origin: '', originChild: '' }
    value = String(value || '').trim()
    if (!value) return result
    if (value.indexOf('=') === -1) {
      result.origin = value
      result.originChild = value
      return result
    }
    value.split(';').forEach(function (item) {
      var index = item.indexOf('=')
      if (index < 0) return
      var key = item.slice(0, index).trim().toLowerCase()
      var val = item.slice(index + 1).trim()
      if (key === 'origin') result.origin = val
      if (key === 'originchild' || key === 'origin_child') result.originChild = val
    })
    if (result.origin && !result.originChild) result.originChild = result.origin
    return result
  }

  function normalizeSysOrigin(value) {
    value = String(value || '').trim()
    if (!value) return ''
    if (value.indexOf('=') >= 0) value = parseReqSysOrigin(value).origin
    value = String(value || '').trim().toUpperCase()
    return sysOriginAliases[value] || value
  }

  function decodeBase64(value) {
    value = String(value || '').replace(/-/g, '+').replace(/_/g, '/')
    while (value.length % 4) value += '='
    try {
      return decodeURIComponent(escape(window.atob(value)))
    } catch (error) {
      try {
        return window.atob(value)
      } catch (innerError) {
        return ''
      }
    }
  }

  function tokenSysOrigin(value) {
    var token = bearerToken(value)
    if (!token) return ''

    var payload = ''
    var dotIndex = token.indexOf('.')
    if (dotIndex >= 0) {
      payload = token.slice(dotIndex + 1)
    } else {
      payload = token
    }
    payload = decodeBase64(payload)
    if (!payload) return ''

    var parts = payload.split(':')
    if (parts.length < 3) return ''
    return normalizeSysOrigin(parts[2])
  }

  function normalizeReqClient(value) {
    value = String(value || '').trim()
    if (/^ios$/i.test(value)) return 'iOS'
    if (/^android$/i.test(value)) return 'Android'
    if (/^h5$/i.test(value)) return 'H5'
    if (/^ops$/i.test(value)) return 'Ops'
    return ''
  }

  function resolveReqClient() {
    return normalizeReqClient(params.reqClient || params.client) || defaultReqClient
  }

  function resolveReqAppIntel() {
    var raw = parseHeaderPairs(params.reqAppIntel)
    var version = String(params.appVersion || raw.version || defaultReqAppIntel.version).trim()
    var build = String(params.buildVersion || params.build || raw.build || defaultReqAppIntel.build).trim()
    var model = String(params.model || raw.model || defaultReqAppIntel.model).trim()
    var sysVersion = String(params.sysVersion || raw.sysVersion || defaultReqAppIntel.sysVersion).trim()
    var channel = String(params.appChannel || params.channel || raw.channel || defaultReqAppIntel.channel).trim()
    if (!/^[1-9]\d*$/.test(build)) build = defaultReqAppIntel.build
    return [
      'version=' + (version || defaultReqAppIntel.version),
      'build=' + build,
      'model=' + (model || defaultReqAppIntel.model),
      'sysVersion=' + (sysVersion || defaultReqAppIntel.sysVersion),
      'channel=' + (channel || defaultReqAppIntel.channel)
    ].join(';')
  }

  function resolveReqLang() {
    return String(params.appLanguage || params.lang || navigator.language || 'en').trim() || 'en'
  }

  function resolveReqZone() {
    var timezone = ''
    try {
      timezone = Intl.DateTimeFormat().resolvedOptions().timeZone || ''
    } catch (error) {}
    return String(params.reqZone || params.timeZone || timezone || 'Asia/Shanghai').trim()
  }

  function resolveSysOrigin() {
    return (
      tokenSysOrigin(explicitToken) ||
      tokenSysOrigin(explicitAuthorization) ||
      normalizeSysOrigin(params.sysOrigin || params.originSys || params.reqSysOrigin || window.__SMASH_EGG_SYS_ORIGIN__) ||
      defaultSysOrigin
    )
  }

  function resolveUID() {
    return String(params._login_uid || params.uid || params.userId || params.loginUid || '').trim()
  }

  function setHeader(headers, name, value) {
    if (!headers || !value) return
    var exists = false
    Object.keys(headers).forEach(function (key) {
      if (String(key).toLowerCase() === String(name).toLowerCase()) exists = true
    })
    if (!exists) headers[name] = value
  }

  function removeHeader(headers, name) {
    if (!headers) return
    Object.keys(headers).forEach(function (key) {
      if (String(key).toLowerCase() === String(name).toLowerCase()) {
        delete headers[key]
      }
    })
  }

  function ensureQueryParam(url, key, value) {
    if (!value || url.searchParams.get(key)) return
    url.searchParams.set(key, value)
  }

  function hasIdempotencyKey(url) {
    return !!(
      url.searchParams.get('idempotencyKey') ||
      url.searchParams.get('idempotency_key') ||
      url.searchParams.get('requestId') ||
      url.searchParams.get('request_id') ||
      url.searchParams.get('nonce')
    )
  }

  function randomPart() {
    try {
      if (window.crypto && window.crypto.getRandomValues) {
        var values = new Uint32Array(2)
        window.crypto.getRandomValues(values)
        return values[0].toString(16) + values[1].toString(16)
      }
    } catch (error) {}
    return Math.floor(Math.random() * 0x100000000).toString(16) +
      Math.floor(Math.random() * 0x100000000).toString(16)
  }

  function createIdempotencyKey(activity) {
    return ['h5', activity, resolveUID() || 'guest', Date.now(), randomPart()].join('-').slice(0, 128)
  }

  function isLegacySmashUrl(url) {
    return (
      url.pathname === '/index.php' &&
      String(url.searchParams.get('action') || '').indexOf('Action/TreasureHunt.') === 0
    )
  }

  function isAppSmashUrl(url) {
    return (
      url.pathname.indexOf('/app/smash-golden-egg/') === 0 ||
      url.pathname.indexOf('/h5/smash-golden-egg/') === 0
    )
  }

  function isSmashDrawUrl(url) {
    return (
      (url.pathname === '/index.php' && url.searchParams.get('action') === 'Action/TreasureHunt.startHunt') ||
      url.pathname === '/app/smash-golden-egg/draw' ||
      url.pathname === '/h5/smash-golden-egg/draw'
    )
  }

  function ensureDrawIdempotency(url) {
    if (!isSmashDrawUrl(url) || hasIdempotencyKey(url)) return
    url.searchParams.set('idempotencyKey', createIdempotencyKey('smash-egg'))
  }

  function rewriteLegacyActionToSemanticPath(url) {
    var action = String(url.searchParams.get('action') || '')
    var pathname = legacySemanticRoutes[action]
    if (!pathname) return
    if (action === 'Action/TreasureHunt.startHunt') {
      var num = url.searchParams.get('num')
      if (num && !url.searchParams.get('times')) url.searchParams.set('times', num)
      url.searchParams.delete('num')
    }
    if (action === 'Action/TreasureHunt.getMyHuntRecord') {
      var start = url.searchParams.get('start')
      var limit = url.searchParams.get('num')
      if (start && !url.searchParams.get('offset')) url.searchParams.set('offset', start)
      if (limit && !url.searchParams.get('limit')) url.searchParams.set('limit', limit)
      url.searchParams.delete('start')
      url.searchParams.delete('num')
    }
    url.searchParams.delete('action')
    url.pathname = pathname
  }

  function rewriteSemanticPathToLegacyAction(url) {
    var pathname = url.pathname.replace(/^\/app\/smash-golden-egg/, '/h5/smash-golden-egg')
    var action = semanticLegacyActions[pathname]
    if (!action) return
    if (action === 'Action/TreasureHunt.startHunt') {
      var times = url.searchParams.get('times')
      if (times && !url.searchParams.get('num')) url.searchParams.set('num', times)
      url.searchParams.delete('times')
    }
    if (action === 'Action/TreasureHunt.getMyHuntRecord') {
      var offset = url.searchParams.get('offset')
      var limit = url.searchParams.get('limit')
      if (offset && !url.searchParams.get('start')) url.searchParams.set('start', offset)
      if (limit && !url.searchParams.get('num')) url.searchParams.set('num', limit)
      url.searchParams.delete('offset')
      url.searchParams.delete('limit')
    }
    url.searchParams.set('action', action)
    url.pathname = '/index.php'
  }

  function shouldUseSemanticLegacyRoutes() {
    var explicit = String(params.semanticApi || window.__SMASH_EGG_SEMANTIC_API__ || '').trim().toLowerCase()
    if (explicit === '1' || explicit === 'true' || explicit === 'yes') return true
    if (explicit === '0' || explicit === 'false' || explicit === 'no') return false
    if (resolveHostApiBase()) return true
    return !!gatewayPrefix
  }

  function replaceQueryPlaceholders(url) {
    var uid = resolveUID()
    var rid = String(params.rid || params.room_id || '').trim()
    var replacements = {
      uid: uid,
      userId: uid,
      _login_uid: uid,
      token: explicitToken,
      rid: rid
    }
    Object.keys(replacements).forEach(function (key) {
      var value = url.searchParams.get(key)
      if (/^\{[^}]+\}$/.test(value || '')) {
        url.searchParams.set(key, replacements[key] || '')
      }
    })
  }

  function resolveBase() {
    var explicitBase = params.gatewayBase || window.__SMASH_EGG_GATEWAY_BASE__ || ''
    var apiBase = params.apiBase || window.__SMASH_EGG_API_BASE__ || ''
    var hostBase = resolveHostApiBase()
    if (explicitBase) return normalizeBase(explicitBase)
    if (apiBase && !sameOrigin(apiBase)) return normalizeBase(apiBase)
    if (hostBase) return normalizeBase(hostBase)
    return explicitToken || explicitAuthorization ? defaultGatewayBase : defaultLocalGoBase
  }

  function resolvePrefix() {
    if (params.gatewayBase || window.__SMASH_EGG_GATEWAY_BASE__) {
      return normalizePrefix(params.gatewayPrefix || window.__SMASH_EGG_GATEWAY_PREFIX__ || defaultGatewayPrefix)
    }
    if (gatewayBase === defaultGatewayBase) {
      return normalizePrefix(params.gatewayPrefix || window.__SMASH_EGG_GATEWAY_PREFIX__ || defaultGatewayPrefix)
    }
    return normalizePrefix(params.gatewayPrefix || window.__SMASH_EGG_GATEWAY_PREFIX__ || '')
  }

  var params = readParams()
  var explicitAuthorization = bearer(
    params.Authorization ||
      params.authorization ||
      params.auth ||
      storageGet(window.sessionStorage, 'Authorization') ||
      storageGet(window.localStorage, 'smashEggAuthorization') ||
      ''
  )
  var explicitToken = String(
    params.token ||
      storageGet(window.sessionStorage, 'token') ||
      storageGet(window.localStorage, 'smashEggToken') ||
      ''
  ).trim()

  if (explicitAuthorization && !explicitToken) explicitToken = bearerToken(explicitAuthorization)
  if (explicitToken && !explicitAuthorization) explicitAuthorization = bearer(explicitToken)

  storageSet(window.sessionStorage, 'Authorization', explicitAuthorization)
  storageSet(window.sessionStorage, 'token', explicitToken)
  storageSet(window.localStorage, 'smashEggAuthorization', explicitAuthorization)
  storageSet(window.localStorage, 'smashEggToken', explicitToken)

  var gatewayBase = normalizeBase(resolveBase())
  var gatewayPrefix = normalizePrefix(resolvePrefix())

  function rewriteUrl(rawUrl) {
    if (!gatewayBase) return rawUrl

    var parsed
    try {
      parsed = new URL(rawUrl, window.location.href)
    } catch (error) {
      return rawUrl
    }

    if (!isLegacySmashUrl(parsed) && !isAppSmashUrl(parsed)) return rawUrl

    var uid = resolveUID()
    var legacyUrl = isLegacySmashUrl(parsed)
    var appUrl = isAppSmashUrl(parsed)
    if (legacyUrl || appUrl) {
      ensureQueryParam(parsed, 'sysOrigin', resolveSysOrigin())
      ensureQueryParam(parsed, 'originSys', resolveSysOrigin())
      ensureQueryParam(parsed, '_login_uid', uid)
      ensureQueryParam(parsed, 'uid', uid)
      ensureQueryParam(parsed, 'token', explicitToken)
    }
    if (legacyUrl) {
      if (shouldUseSemanticLegacyRoutes()) rewriteLegacyActionToSemanticPath(parsed)
    } else if (appUrl && !shouldUseSemanticLegacyRoutes()) {
      rewriteSemanticPathToLegacyAction(parsed)
    }
    replaceQueryPlaceholders(parsed)
    ensureDrawIdempotency(parsed)

    return gatewayBase + gatewayPrefix + parsed.pathname + parsed.search
  }

  function injectHeaders(config) {
    config.headers = config.headers || {}
    if (!gatewayPrefix && !explicitToken && !explicitAuthorization) {
      removeHeader(config.headers, 'sign')
      removeHeader(config.headers, 'timestamp')
    }
    setHeader(config.headers, 'Authorization', explicitAuthorization)
    setHeader(config.headers, 'token', explicitToken)
    setHeader(config.headers, 'req-sys-origin', 'origin=' + resolveSysOrigin() + ';originChild=' + resolveSysOrigin())
    setHeader(config.headers, 'req-client', resolveReqClient())
    setHeader(config.headers, 'req-app-intel', resolveReqAppIntel())
    setHeader(config.headers, 'req-imei', params.reqImei || defaultReqImei)
    if (gatewayPrefix || explicitToken || explicitAuthorization) {
      setHeader(config.headers, 'req-version', params.reqVersion || defaultReqVersion)
    }
    setHeader(config.headers, 'req-zone', resolveReqZone())
    setHeader(config.headers, 'req-lang', resolveReqLang())
  }

  function normalizeLegacyPrizeImage(item) {
    if (!item || typeof item !== 'object') return
    if (item.type === 1 || !item.image) {
      item.image = legacyGoldImage
    }
    if (item.type === 1) {
      var displayGold = Number(item.price || item.goldAmount || item.value || 0)
      if ((!item.num || Number(item.num) <= 1) && displayGold > 1) {
        item.num = displayGold
      }
    }
  }

  function normalizeLegacyPrizeList(list) {
    if (!Array.isArray(list)) return
    list.forEach(function (item) {
      normalizeLegacyPrizeImage(item)
      if (Array.isArray(item && item.prizeList)) normalizeLegacyPrizeList(item.prizeList)
    })
  }

  function normalizeLegacyResponse(data) {
    var payload = data && data.response_data
    if (!payload || typeof payload !== 'object') return
    normalizeLegacyPrizeList(payload.normalList)
    normalizeLegacyPrizeList(payload.superList)
    normalizeLegacyPrizeList(payload.list)
    normalizeLegacyPrizeList(payload.notices)
  }

  if (window.axios && window.axios.interceptors) {
    window.axios.interceptors.request.use(function (config) {
      if (config && typeof config.url === 'string') {
        var nextUrl = rewriteUrl(config.url)
        if (nextUrl !== config.url) {
          window.__SMASH_EGG_LAST_API_REWRITE__ = {
            from: config.url,
            to: nextUrl,
            at: Date.now()
          }
          config.url = nextUrl
          injectHeaders(config)
        }
      }
      return config
    })
    window.axios.interceptors.response.use(function (response) {
      normalizeLegacyResponse(response && response.data)
      return response
    })
  }

  window.__SMASH_EGG_GATEWAY__ = {
    base: gatewayBase,
    prefix: gatewayPrefix,
    reqSysOrigin: function () {
      return 'origin=' + resolveSysOrigin() + ';originChild=' + resolveSysOrigin()
    },
    rewriteUrl: rewriteUrl
  }
})()