/* eslint-disable @typescript-eslint/no-unsafe-return */
/* eslint-disable @typescript-eslint/explicit-module-boundary-types */

import { hookNative } from './anti-detection'
import { console, getUnsafeWindow } from './utils'

const CHUNK_PUSH_FN = /^function [^r]\(\w\){/

interface Module {
  (module, exports, __webpack_require__): void;
}

type WebpackJson = [(number | string)[], { [id: string]: Module }, any[]?][]

const moduleLookup = (id: string, globalWebpackJson: WebpackJson) => {
  const pack = globalWebpackJson.find(x => x[1][id])!
  return pack[1][id]
}

/**
 * Retrieve (webpack_require) a module from the page's webpack package
 * 
 * I know this is super hacky.
 */
export const webpackHook = (moduleId: string, moduleOverrides: { [id: string]: Module } = {}, globalWebpackJson: WebpackJson = window['webpackJsonpmusescore']) => {
  const t = Object.assign((id: string, override = true) => {
    const r: any = {}
    const m: Module = (override && moduleOverrides[id])
      ? moduleOverrides[id]
      : moduleLookup(id, globalWebpackJson)
    m(r, r, t)
    if (r.exports) return r.exports
    return r
  }, {
    d (exp, name, fn) {
      return Object.prototype.hasOwnProperty.call(exp, name) ||
        Object.defineProperty(exp, name, { enumerable: true, get: fn })
    },
    n (e) {
      const m = e.__esModule ? () => e.default : () => e
      t.d(m, 'a', m)
      return m
    },
    r (r) {
      Object.defineProperty(r, '__esModule', { value: true })
    },
    e () {
      return Promise.resolve()
    },
  })

  return t(moduleId)
}

export const ALL = '*'

export const [webpackGlobalOverride, onPackLoad] = (() => {
  type OnPackLoadFn = (pack: WebpackJson[0]) => any

  const moduleOverrides: { [id: string]: Module } = {}
  const onPackLoadFns: OnPackLoadFn[] = []

  function applyOverride (pack: WebpackJson[0]) {
    let entries = Object.entries(moduleOverrides)
    // apply to all
    const all = moduleOverrides[ALL]
    if (all) {
      entries = Object.keys(pack[1]).map(id => [id, all])
    }

    entries.forEach(([id, override]) => {
      const mod = pack[1][id]
      if (mod) {
        pack[1][id] = function (n, r, t) {
          // make exports configurable
          t = Object.assign(t, {
            d (exp, name, fn) {
              return Object.defineProperty(exp, name, { enumerable: true, get: fn, configurable: true })
            },
          })
          mod(n, r, t)
          override(n, r, t)
        }
      }
    })
  }

  // hook `webpackJsonpmusescore.push` as soon as `webpackJsonpmusescore` is available
  const _w = getUnsafeWindow()
  let jsonp = _w['webpackJsonpmusescore']
  let hooked = false
  Object.defineProperty(_w, 'webpackJsonpmusescore', {
    get () { return jsonp },
    set (v: WebpackJson) {
      jsonp = v
      if (!hooked && v.push.toString().match(CHUNK_PUSH_FN)) {
        hooked = true
        hookNative(v, 'push', (_fn) => {
          return function (pack) {
            onPackLoadFns.forEach(fn => fn(pack))
            applyOverride(pack)
            return _fn.call(this, pack)
          }
        })
      }
    },
  })

  return [
    // set overrides
    (moduleId: string, override: Module) => {
      moduleOverrides[moduleId] = override
    },
    // set onPackLoad listeners
    (fn: OnPackLoadFn) => {
      onPackLoadFns.push(fn)
    },
  ] as const
})()

export const webpackContext = new Promise<any>((resolve) => {
  webpackGlobalOverride(ALL, (n, r, t) => {
    resolve(t)
  })
})

const PACK_ID_REG = /\+(\{.*?"\})\[\w\]\+/

export const loadAllPacks = () => {
  return webpackContext.then((ctx) => {
    try {
      const fn = ctx.e.toString()
      const packsData = fn.match(PACK_ID_REG)[1] as string
      // eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval
      const packs = Function(`return (${packsData})`)() as { [id: string]: string }

      Object.keys(packs).forEach((id) => {
        ctx.e(id)
      })
    } catch (err) {
      console.error(err)
    }
  })
}

const OBF_FN_REG = /\w\(".{4}"\),(\w)=(\[".+?\]);\w=\1,\w=(\d+).+?\);var (\w=.+?,\w\})/
export const OBFUSCATED_REG = /(\w)\((\d+),"(.{4})"\)/g

export const getObfuscationCtx = (mod: Module): (n: number, s: string) => string => {
  const str = mod.toString()
  const m = str.match(OBF_FN_REG)
  if (!m) return () => ''

  try {
    const arrVar = m[1]
    const arr = JSON.parse(m[2])

    let n = +m[3] + 1
    for (; --n;) arr.push(arr.shift())

    const fnStr = m[4]
    const ctxStr = `var ${arrVar}=${JSON.stringify(arr)};return (${fnStr})`
    // eslint-disable-next-line no-new-func, @typescript-eslint/no-implied-eval
    const fn = new Function(ctxStr)()

    return fn
  } catch (err) {
    console.error(err)
    return () => ''
  }
}

export default webpackHook