import {parse} from "acorn"
import * as walk from "acorn-walk"

function parseStack(stack) {
  let found = [], m
  let re = /([\w$]*)@(.*?):(\d+)|\bat (?:([^\s(]+) \()?(.*?):(\d+)/g
  while (m = re.exec(stack)) {
    let fn = m[1] || m[4] || null
    let file = m[2] || m[5] || null
    if (fn && /sandbox/i.test(fn)) break
    found.push({fn, file, line: m[3] || m[6]})
  }
  return found
}
function frameString(frame) {
  return "line " + frame.line + (frame.fn ? " in function " + frame.fn : "")
}

export class Sandbox {
  static async create(options) {
    this.emptyPath = options.emptyPath || "./"
    let frame = document.createElement("iframe")
    frame.src = this.emptyPath + "empty.html"
    if (options.place) {
      options.place(frame)
    } else {
      frame.style.height = "0px"
      frame.style.border = "none"
      document.body.appendChild(frame)
    }
    await awaitEvent(frame, "load")

    let box = new Sandbox(frame)
    let scripts = (options.loadFiles || []).map(file => {
      let script = box.win.document.createElement("script")
      script.src = file
      box.win.document.body.appendChild(script)
      return awaitEvent(script, "load")
    })
    await Promise.all(scripts)
    return box
  }

  constructor(frame) {
    this.startedAt = null
    this.extraSecs = 2
    this.output = null
    this.handleDeps = true

    this.callbacks = {}
    // Used to cancel existing events when new code is loaded
    this.timeouts = []; this.intervals = []; this.frames = []
    this.framePos = 0

    // Loaded CommonJS modules
    this.loaded = new Cached(name => resolved.compute(name).then(({name, code}) => this.evalModule(name, code)))

    this.frame = frame
    this.win = frame.contentWindow
    this.setupEnv()

    const resize = () => {
      if (this.frame.style.display != "none") this.resizeFrame()
    }
    this.frame.addEventListener("load", resize)
    let resizeTimeout = null
    const scheduleResize = () => {
      this.win.clearTimeout(resizeTimeout)
      this.win.__setTimeout(resize, 200)
    }
    this.win.addEventListener("keydown", scheduleResize)
    this.win.addEventListener("mousedown", scheduleResize)
  }

  async run(code, output) {
    if (output) this.output = output
    this.startedAt = Date.now()
    this.extraSecs = typeof code == "string" && /promtDirection/.test(code) ? 0.1 : 2
    this.win.__c = 0
    return this.prepare(code).then(code => this.sandbox_run(code)).catch(err => this.error(err))
  }

  // Should be above all user-run code, so that the stack trace can be
  // cut off at this point.
  sandbox_run(code) {
    return code instanceof Function ? code() : this.win.eval(code)
  }

  prepare(text) {
    let {code, dependencies} = preprocess(text, this)
    return (this.handleDeps ? Promise.all(dependencies.map(dep => this.loaded.compute(dep))) : Promise.resolve([]))
      .then(() => code)
  }

  evalModule(name, code) {
    if (/\.json$/.test(name))
      return this.loaded.store(name, {exports: JSON.parse(code)})

    let work = findDeps(code).map(dep => this.loaded.compute(resolveRelative(name, dep)))
    return Promise.all(work).then(() => {
      let f = new this.win.Function("require, exports, module, __dirname, __filename",
                                    code + "\n//# sourceURL=code" + randomID())
      let module = this.loaded.store(name, {exports: {}})
      f(dep => this.require(resolveRelative(name, dep)), module.exports, module, name, name)
      return module
    })
  }

  require(name) {
    let found = resolved.get(name)
    if (!found) throw new Error(`Could not load module '${name}'`)
    return this.loaded.get(found.name).exports
  }

  async setHTML(code, output) {
    this.clearEvents()
    let loc = String(this.win.document.location)
    if (loc != String(document.location) && !/\/empty\.html$/.test(loc)) {
      this.frame.src = this.emptyPath + "empty.html"
      await avaitEvent(this.frame, "load")
      this.setupEnv()
      return this.setHTML(code, output)
    }

    let scriptTags = [], sandbox = this, doc = this.win.document
    this.frame.style.display = "block"
    let scriptRE = /<script\b[^>]*?(?:\bsrc\s*=\s*('[^']+'|"[^"]+"|[^\s>]+)[^>]*)?>([\s\S]*?)<\/script>/g
    doc.documentElement.innerHTML = code.replace(scriptRE, function(_, src, content) {
      let tag = doc.createElement("script")
      if (src) {
        if (/["']/.test(src.charAt(0))) src = src.slice(1, src.length - 1)
        tag.src = src
      } else {
        tag.text = preprocess(content, sandbox).code
      }
      scriptTags.push(tag)
      return ""
    })

    this.frame.style.height = "80px"
    this.resizeFrame()
    if (output) this.output = output

    for (let tag of scriptTags) {
      sandbox.startedAt = Date.now()
      sandbox.extraSecs = 2
      sandbox.win.__c = 0
      if (tag.src) {
        doc.body.appendChild(tag)
        await awaitEvent(tag, "load")
      } else {
        await new Promise(ok => {
          let id = randomID()
          sandbox.callbacks[id] = () => { delete sandbox.callbacks[id]; ok() }
          tag.text += "\n;__sandbox.callbacks['" + id + "']();"
          doc.body.appendChild(tag)
        })
      }
    }

    if (scriptTags.length || doc.querySelector("img")) setTimeout(() => sandbox.resizeFrame(), 100)
  }

  setupEnv() {
    let win = this.win
    win.__sandbox = this

    win.onerror = (e, _file, line) => {
      if (!this.output) return
      this.output.out("error", [e + (line != null ? " (line " + line + ")" : "")])
      return true
    }
    win.console = {
      log: (...args) => this.out("log", args),
      error: (...args) => this.out("error", args),
      warn: (...args) => this.out("warn", args),
      info: (...args) => this.out("log", args)
    }
    win.setInterval(() => {
      this.startedAt = null
    }, 1000)

    win.__setTimeout = win.setTimeout
    win.__setInterval = win.setInterval
    win.setTimeout = (code, time, ...args) => {
      if (args.length && typeof code != "string") {
        let f = code
        code = () => f(...args)
      }
      let val = win.__setTimeout(() => this.run(code), time)
      this.timeouts.push(val)
      return val
    }
    win.setInterval = (code, time, ...args) => {
      if (args.length && typeof code != "string") {
        let f = code
        code = () => f(...args)
      }
      let val = win.__setInterval(() => this.run(code), time)
      this.intervals.push(val)
      return val
    }
    let reqAnimFrame = win.requestAnimationFrame
    win.requestAnimationFrame = f => {
      let val = reqAnimFrame.call(win, f)
      if (this.frames.length > 50)
        this.frames[this.framePos++ % 50] = val
      else
        this.frames.push(val)
      return val
    }

    win.addEventListener("unhandledrejection", e => this.error(e.reason))

    win.require = name => this.require(name)
    win.require.preload = (name, code) => resolved.store(name, {name, code})
    win.module = {exports: {}}
    win.exports = win.module.exports
  }

  resizeFrame() {
    this.frame.style.height = Math.max(80, Math.min(this.win.document.documentElement.offsetHeight + 2, 500)) + "px"
    let box = this.frame.getBoundingClientRect()
    if (box.bottom > box.top && box.top >= 0 && box.top < window.innerHeight && box.bottom > window.innerHeight) {
      window.scrollBy(0, Math.min(box.top, box.bottom - window.innerHeight))
    }
  }

  tick() {
    let now = Date.now()
    if (this.startedAt == null) this.startedAt = now
    if (now < this.startedAt + this.extraSecs * 1000) return
    let bail = confirm("This code has been running for " + this.extraSecs + " seconds. Abort it?")
    this.startedAt += Date.now() - now
    this.extraSecs += Math.max(this.extraSecs, 8)
    if (bail) throw new Error("Aborted")
  }

  out(type, args) {
    if (this.output) this.output.out(type, args)
    else console[type].apply(console, args)
  }

  error(exception) {
    if (!this.output) throw exception
    let stack = parseStack(exception.stack)
    this.output.out("error", [String(exception) + (stack.length ? " (" + frameString(stack[0]) + ")" : "")])
    if (stack.length > 1) {
      this.output.div.lastChild.appendChild(document.createTextNode(" "))
      let mark = this.output.div.lastChild.appendChild(document.createElement("span"))
      mark.innerHTML = "…"
      mark.className = "sandbox-output-etc"
      mark.addEventListener("click", () => {
        mark.className = ""
        mark.innerHTML = "\n called from " + stack.slice(1).map(frameString).join("\n called from ")
      })
    }
  }

  clearEvents() {
    while (this.timeouts.length) this.win.clearTimeout(this.timeouts.pop())
    while (this.intervals.length) this.win.clearInterval(this.intervals.pop())
    while (this.frames.length) this.win.cancelAnimationFrame(this.frames.pop())
    this.timeouts.length = this.intervals.length = this.frames.length = this.framePos = 0
  }
}

function preprocess(code, sandbox) {
  if (typeof code != "string") {
    if (code.apply) {
      let orig = code
      code = (...args) => {
        try { return orig.apply(null, args) }
        catch(e) { sandbox.error(e) }
      }
    }
    return {code, dependencies: []}
  }

  if (!/\n$/.test(code)) code += "\n"
  let strict = /^(\s|\/\/.*)*["']use strict['"]/.test(code), ast
  try { ast = parse(code, {sourceType: detectSourceType(code), ecmaVersion: "latest"}) }
  catch(e) { return {code, dependencies: []} }
  let patches = []
  let backJump = ";if (++__c % 1000 === 0) __sandbox.tick();"
  function loop(node) {
    if (node.body.type == "BlockStatement") {
      patches.push({from: node.body.end - 1, text: backJump})
    } else {
      patches.push({from: node.body.start, text: "{"},
                   {from: node.body.end, text: backJump + "}"})
    }
  }
  let dependencies = []

  walk.simple(ast, {
    ForStatement: loop,
    ForInStatement: loop,
    WhileStatement: loop,
    DoWhileStatement: loop,
    CallExpression(node) {
      if (node.callee.type == "Identifier" && node.callee.name == "require" &&
          node.arguments.length == 1 && node.arguments[0].type == "Literal" &&
          typeof node.arguments[0].value == "string" && !dependencies.includes(node.arguments[0].value))
        dependencies.push(node.arguments[0].value)
    },
    ImportDeclaration(node) {
      dependencies.push(node.source.value)
      let req = "require(" + node.source.raw + ")", text
      if (node.specifiers.length == 0) {
        text = req
      } else if (node.specifiers.length > 1 || node.specifiers[0].type == "ImportDefaultSpecifier") {
        let name = "m_" + node.source.value.replace(/\W+/g, "_") + "__"
        text = "var " + name + " = " + req
        node.specifiers.forEach(spec => {
          if (spec.type == "ImportDefaultSpecifier")
            text += ", " + spec.local.name + " = " + name + ".default || " + name
          else if (name != null)
            text += ", " + spec.local.name + " = " + name + "." + spec.imported.name
        })
      } else {
        text = "var "
        node.specifiers.forEach(spec => {
          if (spec.type == "ImportNamespaceSpecifier")
            text += spec.local.name + " = " + req
          else
            text += spec.local.name + " = " + req + "." + spec.imported.name
        })
      }
      patches.push({from: node.start, to: node.end, text: text + ";"})
    },
    ExportNamedDeclaration(node) {
      if (node.source || !node.declaration)
        patches.push({from: node.start, to: node.end, text: ""})
      else
        patches.push({from: node.start, to: node.declaration.start, text: ""})
    },
    ExportDefaultDeclaration(node) {
      if (/Declaration/.test(node.declaration.type)) {
        patches.push({from: node.start, to: node.declaration.start, text: ""})
      } else {
        patches.push({from: node.start, to: node.declaration.start, text: ";("},
                     {from: node.declaration.end, text: ")"})
      }
    },
    ExportAllDeclaration: function(node) {
      patches.push({from: node.start, to: node.end, text: ""})
    }
  })

  let tryPos = 0, catchPos = ast.end
  for (let i = strict ? 1 : 0; i < ast.body.length; i++) {
    let stat = ast.body[i]
    if (stat.type != "FunctionDeclaration") {
      if (tryPos == 0) tryPos = stat.start
      catchPos = stat.end
    }
    if (stat.type == "VariableDeclaration" && stat.kind != "var") {
      if (stat.kind == "const") {
        let found = findAssignmentsTo(stat.declarations, ast)
        if (found) patches.push({from: 0, text: `throw new TypeError("invalid assignment to const '${found}'");`})
      }
      patches.push({from: stat.start, to: stat.start + stat.kind.length, text: "var"})
    }
    if (stat.type == "ClassDeclaration")
      patches.push({from: stat.start, text: "var " + stat.id.name + " = "})
  }

  patches.push({from: tryPos, text: "try{", priority: 10})
  patches.push({from: catchPos, text: "}catch(e){__sandbox.error(e);}", priority: -10})
  patches.sort((a, b) => a.from - b.from || (a.to || a.from) - (b.to || b.from) || (b.priority || 0) - (a.priority || 0))
  let out = "", pos = 0
  for (let i = 0; i < patches.length; ++i) {
    let patch = patches[i]
    out += code.slice(pos, patch.from) + patch.text
    pos = patch.to || patch.from
  }
  out += code.slice(pos, code.length)
  out += "\n//# sourceURL=code" + randomID()
  return {code: (strict ? '"use strict";' : "") + out, dependencies}
}

function findAssignmentsTo(decls, ast) {
  let found = null
  for (let i = 0; i < decls.length; i++)
    walk.simple(decls[i].id, {
      VariablePattern(node) { if (findAssignments(node.name, ast)) found = node.name }
    }, null, null, "Pattern")
  return found
}

function findAssignments(name, ast) {
  let found = false
  walk.ancestor(ast, {
    AssignmentExpression(node, ancestors) {
      if (node.left.type != "Identifier" || node.left.name != name) return
      for (let i = 2; i < ancestors.length; i++) if (/Statement|Declaration/.test(ancestors[i].type)) return
      found = true
    }
  })
  return found
}

function detectSourceType(code) {
  return /(^|\n)\s*(im|ex)port\b/.test(code) ? "module" : "script"
}

function randomID() {
  return Math.floor(Math.random() * 0xffffffff).toString(16)
}

function findDeps(code) {
  let deps = [], ast
  try { ast = parse(code) }
  catch(e) { return deps }
  walk.simple(ast, {
    CallExpression(node) {
      if (node.callee.type == "Identifier" && node.callee.name == "require" &&
          node.arguments.length == 1 && node.arguments[0].type == "Literal" &&
          typeof node.arguments[0].value == "string" && !deps.includes(node.arguments[0].value))
        deps.push(node.arguments[0].value)
    }
  })
  return deps
}

function resolveRelative(base, path) {
  if (!/\.\.?\//.test(path)) return path
  base = base.replace(/[^\/]+$/, "")
  let m
  while (m = /^\.(\.)?\//.exec(path)) {
    if (m[1]) base = base.replace(/\/[^\/]+\/$/, "/")
    path = path.slice(m[0].length)
  }
  return base + path
}

class Cached {
  constructor(mapping) {
    this.mapping = mapping
    this.work = Object.create(null)
    this.done = Object.create(null)
  }

  compute(value) {
    return this.work[value] || (this.work[value] = this.mapping(value).then(result => this.done[value] = result))
  }

  store(value, result) {
    this.work[value] = Promise.resolve(result)
    return this.done[value] = result
  }

  get(value) {
    return this.done[value]
  }
}

// Cache for loaded code and resolved unpkg redirects
const resolved = new Cached(name => fetch("https://unpkg.com/" + name.replace(/\/$/, "")).then(resp => {
  if (resp.status >= 400) throw new Error(`Failed to resolve package '${name}'`)
  let found = resp.url.replace(/.*unpkg\.com\//, "")
  let known = resolved.get(found)
  return known || resp.text().then(code => resolved.store(found, {name: found, code}))
}))

Sandbox.Output = class {
  constructor(div) { this.div = div }

  clear() {
    let clone = this.div.cloneNode(false)
    this.div.parentNode.replaceChild(clone, this.div)
    this.div = clone
  }

  get empty() {
    return !this.div.firstChild
  }

  out(type, args) {
    let wrap = document.createElement("pre")
    wrap.className = "sandbox-output-" + type
    for (let i = 0; i < args.length; ++i) {
      let arg = args[i]
      if (i) wrap.appendChild(document.createTextNode(" "))
      if (typeof arg == "string")
        wrap.appendChild(document.createTextNode(arg))
      else
        wrap.appendChild(represent(arg, 58))
    }
    this.div.appendChild(wrap)
  }
}

function span(type, text) {
  let sp = document.createElement("span")
  sp.className = "sandbox-output-" + type
  sp.appendChild(document.createTextNode(text))
  return sp
}

function eltSize(elt) {
  return elt.textContent.length
}

function represent(val, space) {
  if (typeof val == "boolean") return span("bool", String(val))
  if (typeof val == "number") return span("number", String(val))
  if (typeof val == "string") return span("string", JSON.stringify(val))
  if (typeof val == "symbol") return span("symbol", String(val))
  if (val == null) return span("null", String(val))
  if (Array.isArray(val)) return representArray(val, space)
  else return representObj(val, space)
}

function representArray(val, space) {
  space -= 2
  let wrap = document.createElement("span")
  wrap.appendChild(document.createTextNode("["))
  for (let i = 0; i < val.length; ++i) {
    if (i) {
      wrap.appendChild(document.createTextNode(", "))
      space -= 2
    }
    let next = space > 0 && represent(val[i], space)
    let nextSize = next ? eltSize(next) : 0
    if (space - nextSize <= 0) {
      wrap.appendChild(span("etc", "…")).addEventListener("click", () => expandObj(wrap, "array", val))
      break
    }
    space -= nextSize
    wrap.appendChild(next)
  }
  wrap.appendChild(document.createTextNode("]"))
  return wrap
}

function representObj(val, space) {
  let string = typeof val.toString == "function" && val.toString(), m
  if (!string || /^\[object .*\]$/.test(string))
    return representSimpleObj(val, space)
  if (val.call && (m = string.match(/^\s*(function[^(]*\([^)]*\))/)))
    return span("fun", m[1] + "{…}")
  let elt = span("etc", string)
  elt.addEventListener("click", () => expandObj(elt, "obj", val))
  return elt
}

function constructorName(obj) {
  if (!obj.constructor) return null
  let m = String(obj.constructor).match(/^function\s*([^\s(]+)/)
  if (m && m[1] != "Object") return m[1]
}

function hop(obj, prop) {
  return Object.prototype.hasOwnProperty.call(obj, prop)
}

function representSimpleObj(val, space) {
  space -= 2
  let wrap = document.createElement("span")
  let name = constructorName(val)
  if (name) {
    space -= name.length
    wrap.appendChild(document.createTextNode(name))
  }
  wrap.appendChild(document.createTextNode("{"))
  try {
    let first = true
    for (let prop in val) if (hop(val, prop)) {
      if (first) {
        first = false
      } else {
        space -= 2
        wrap.appendChild(document.createTextNode(", "))
      }
      let next = space > 0 && represent(val[prop], space)
      let nextSize = next ? prop.length + 2 + eltSize(next) : 0
      if (space - nextSize <= 0) {
        wrap.appendChild(span("etc", "…")).addEventListener("click", () => expandObj(wrap, "obj", val))
        break
      }
      space -= nextSize
      wrap.appendChild(span("prop", prop + ": "))
      wrap.appendChild(next)
    }
  } catch (e) {
    wrap.appendChild(document.createTextNode("…"))
  }
  wrap.appendChild(document.createTextNode("}"))
  return wrap
}

function expandObj(node, type, val) {
  let wrap = document.createElement("span")
  let opening = type == "array" ? "[" : "{", cname
  if (opening == "{" && (cname = constructorName(val))) opening = cname + " {"
  wrap.appendChild(document.createTextNode(opening))
  let block = wrap.appendChild(document.createElement("div"))
  block.className = "sandbox-output-etc-block"
  let table = block.appendChild(document.createElement("table"))
  function addProp(name) {
    let row = table.appendChild(document.createElement("tr"))
    row.appendChild(document.createElement("td")).appendChild(span("prop", name + ":"))
    row.appendChild(document.createElement("td")).appendChild(represent(val[name], 40))
  }
  if (type == "array") {
    for (let i = 0; i < val.length; ++i) addProp(i)
  } else {
    for (let prop in val) if (hop(val, prop)) addProp(prop)
  }
  wrap.appendChild(document.createTextNode(type == "array" ? "]" : "}"))
  node.parentNode.replaceChild(wrap, node)
}

function awaitEvent(target, event) {
  return new Promise(accept => {
    let done = () => {
      target.removeEventListener(event, done)
      accept()
    }
    target.addEventListener(event, done)
  })
}