(function engine() {  
prosperon.DOC = Symbol('+documentation+') // Symbol for documentation references

var listeners = new Map()

prosperon.on = function(type, callback) {
  if (!listeners.has(type)) listeners.set(type, [])
  listeners.get(type).push(callback)

  return function() {
    var arr = listeners.get(type)
    if (!arr) return
    var idx = arr.indexOf(callback)
    if (idx >= 0) arr.splice(idx,1)
  }
}

prosperon.dispatch = function(type, data) {
  var arr = listeners.get(type)
  if (!arr) return
  for (var callback of arr) callback(data)
}

var os = use_embed('os')
var tracy = use_embed('tracy')

os.trace = true;

if (os.trace)
  tracy.level(1);

var js = use_embed('js')

prosperon.on('SIGINT', function() {
  os.exit(1)
})

prosperon.on('SIGABRT', function() {
  console.error(new Error('SIGABRT'))
  os.exit(1)
})

prosperon.on('SIGSEGV', function() {
  console.error(new Error('SIGSEGV'))
  os.exit(1)
})

Object.defineProperty(Function.prototype, "hashify", {
  value: function () {
    var hash = new Map()
    var fn = this
    function hashified(...args) {
      var key = args[0]
      if (!hash.has(key)) hash.set(key, fn(...args))
      return hash.get(key)
    }
    return hashified
  },
})

var io = use_embed('io')

var RESPATH = 'scripts/modules/resources.js'
var canonical = io.realdir(RESPATH) + 'resources.js'
var content = io.slurp(RESPATH)
var resources = js.eval(RESPATH, `(function setup_resources(){${content}})`).call({})

var use_cache = {}

use_cache[resources.canonical('resources.js')] = resources

function print_api(obj) {
  for (var prop in obj) {
    if (!obj.hasOwnProperty(prop)) continue
    var val = obj[prop]
    console.log(prop)
    if (typeof val === 'function') {
      var m = val.toString().match(/\(([^)]*)\)/)
      if (m) console.log('  function: ' + prop + '(' + m[1].trim() + ')')
    }
  }
}

prosperon.PATH = [
  "/",
  "scripts/modules/",
  "scripts/modules/ext/",
]

// path is the path of a module or script to resolve
var script_fn = function script_fn(path) {
  var parsed = {}
  var file = resources.find_script(path)
  
  if (!file) {
    parsed.module_ret = bare_load(path)
    if (!parsed.module_ret) throw new Error(`Module ${path} could not be created`)
    return parsed
  }

  var content = io.slurp(file)
  var parsed = parse_file(content, file)
  var module_name = file.name()
  parsed.module_ret = bare_load(path)
  parsed.module_ret ??= {}

  if (parsed.module) {
    var mod_script = `(function setup_${module_name}_module(){ var self = this; var $ = this; var exports = {}; var module = {exports: exports}; var define = undefined; ${parsed.module}})`
    var module_fn = js.eval(file, mod_script)
    parsed.module_ret = module_fn.call(parsed.module_ret)
    if (parsed.module_ret === undefined || parsed.module_ret === null)
      throw new Error(`Module ${module_name} must return a value`)
    parsed.module_fn = module_fn
  }
  
  parsed.program ??= ""
  var prog_script = `(function use_${module_name}() { var self = this; var $ = this.__proto__; ${parsed.program}})`
  parsed.prog_fn = js.eval(file, prog_script)

  return parsed
}.hashify()

function bare_load(file) {
  try {
    return use_embed(file)
  } catch (e) { }
  try {
    return use_dyn(file + so_ext)
  } catch(e) { }
  return undefined
}



var res_cache = {}

function console_rec(category, priority, line, file, msg) {
  var now = time.now()

  var id = prosperon.name ? prosperon.name : prosperon.id
  id = id.substring(0,6)

  return `[${id}] [${time.text(now, "mb d yyyy h:nn:ss")}] ${file}:${line}: [${category} ${priority}]: ${msg}\n`
}

io.mkdir('.prosperon')
var logfile = io.open('.prosperon/log.txt')

function pprint(msg, lvl = 0) {
  if (!logfile) return
  
  var file = "nofile"
  var line = 0

  var caller = new Error().stack.split("\n")[2]
  if (caller) {
    var md = caller.match(/\((.*)\:/)
    var m = md ? md[1] : "SCRIPT"
    if (m) file = m
    md = caller.match(/\:(\d*)\)/)
    m = md ? md[1] : 0
    if (m) line = m
  }
  var fmt = console_rec("script", lvl, line, file, msg)
  console.print(fmt)

  if (logfile)
    logfile.write(fmt)

  if (tracy) tracy.message(fmt)
}

console.spam = function spam(msg) {
  pprint(msg, 0)
}
console.debug = function debug(msg) {
  pprint(msg, 1)
}
console.info = function info(msg) {
  pprint(msg, 2)
}
console.warn = function warn(msg) {
  pprint(msg, 3)
}
console.log = function log(msg) {
  pprint(msg, 2)
}
console.error = function error(e) {
  if (!e)
    e = new Error()

  if (e instanceof Error)
    pprint(`${e.name} : ${e.message}
${e.stack}`, 4)
  else
    pprint(e,4)
}
console.panic = function panic(e) {
  pprint(e, 5)
  os.quit()
}
console.assert = function assert(op, str = `assertion failed [value '${op}']`) {
  if (!op) console.panic(str)
}

//os.on('uncaught_exception', function(e) { console.error(e); })

console[prosperon.DOC] = {
  doc:       "The console object provides various logging, debugging, and output methods.",
  spam:      "Output a spam-level message for very verbose logging.",
  debug:     "Output a debug-level message.",
  info:      "Output info level message.",
  warn:      "Output warn level message.",
  error:     "Output error level message, and print stacktrace.",
  panic:     "Output a panic-level message and exit the program.",
  assert:    "If the condition is false, print an error and panic.",
  critical:  "Output critical level message, and exit game immediately.",
  write:     "Write raw text to console.",
  say:       "Write raw text to console, plus a newline.",
  log:       "Output directly to in game console.",
  level:     "Set level to output logging to console.",
  stack:     "Output a stacktrace to console.",
  clear:     "Clear console."
}

var BASEPATH = 'scripts/core/base.js'
var script = io.slurp(BASEPATH)
var fnname = "base"
script = `(function ${fnname}() { ${script}; })`
js.eval(BASEPATH, script)()

function add_timer(obj, fn, seconds) {
  var timers = obj[TIMERS]
  
  var stop = function () {
    if (!timer) return
    timers.delete(stop)
    timer.fn = undefined
    timer = undefined
  }

  function execute() {
    if (fn) timer.remain = fn(stop.seconds)
    if (!timer) return
    if (!timer.remain) stop()
    else stop.seconds = timer.remain
  }

//  var timer = os.make_timer(execute)
  timer.remain = seconds

  stop.remain = seconds
  stop.seconds = seconds
  
  timers.push(stop)
  return stop
}

var DEAD = Symbol()
var GARBAGE = Symbol()
var FILE = Symbol()
var TIMERS = Symbol()
var REGGIES = Symbol()
var UNDERLINGS = Symbol()
var OVERLING = Symbol()

var actor = {}
globalThis.actor = actor

var so_ext
switch(os.platform()) {
  case 'Windows':
    so_ext = '.dll'
    break
  default:
    so_ext = '.so'
    break
}

var use_cache = {}
var inProgress = {}
var loadingStack = []

globalThis.use = function use(file) {
  // If we've already begun loading this file in this chain, show the cycle
  if (loadingStack.includes(file)) {
    // Find where in the stack this file first appeared
    let cycleIndex = loadingStack.indexOf(file)
    // Extract just the modules in the cycle
    let cyclePath = loadingStack.slice(cycleIndex).concat(file)

    throw new Error(
      `Circular dependency detected while loading "${file}".\n` +
      `Module chain: ${loadingStack.join(" -> ")}\n` +
      `Cycle specifically: ${cyclePath.join(" -> ")}`
    )
  }

  // Already fully loaded? Return it
  if (use_cache[file]) {
    return use_cache[file]
  }

  // If it's loading (but not on the stack), mark it as a new chain entry
  // (This is optional if you just rely on loadingStack. 
  //  But if you'd like a simple “already loading” check, keep 'inProgress'.)
  if (inProgress[file]) {
    throw new Error(`Circular dependency detected while loading "${file}"`)
  }
  inProgress[file] = true

  // Push onto loading stack for chain tracking
  loadingStack.push(file)

  // Actually load the module
  var mod = script_fn(file)

  // Done loading, remove from the chain and mark as loaded
  loadingStack.pop()
  delete inProgress[file]

  // Cache and return
  use_cache[file] = mod.module_ret
  return use_cache[file]
}

globalThis.json = use('json')
var time = use('time')

function parse_file(content, file) {
  if (!content) return {}
  if (!/^\s*---\s*$/m.test(content)) {
    var part = content.trim()
    if (part.match(/return\s+[^;]+;?\s*$/)) {
      return { module: part }
    }
    return { program: part }
  }
  var parts = content.split(/\n\s*---\s*\n/)
  var module = parts[0]
  if (!/\breturn\b/.test(module))
    throw new Error(`Malformed file: ${file}. Module section must end with a return statement.`)

  try {
    new Function(module)()
  } catch (e) {
    throw new Error(`Malformed file: ${file}. Module section must end with a return statement.\n` + e.message)
  }

  var pad = '\n'.repeat(module.split('\n').length + 4)
  return {
    module,
    program: pad + parts[1]
  }
}

globalThis.Register = {
  registries: [],

  add_cb(name) {
    var n = {}
    var fns = []

    n.register = function (fn, oname) {
      if (typeof fn !== 'function') return

      var dofn = function (...args) {
        fn(...args)
      }
      Object.defineProperty(dofn, 'name', {value:`do_${oname}`})

      var left = 0
      var right = fns.length - 1
      dofn.layer = fn.layer
      dofn.layer ??= 0

      while (left <= right) {
        var mid = Math.floor((left + right) / 2)
        if (fns[mid] === dofn.layer) {
          left = mid
          break
        } else if (fns[mid].layer < dofn.layer) left = mid + 1
        else right = mid - 1
      }

      fns.splice(left, 0, dofn)
      return function () {
        fns.delete(dofn)
      }
    }

    prosperon[name] = function (...args) {
      fns.forEach(fn => {
        fn(...args)
      })
    }
    Object.defineProperty(prosperon[name], 'name', {value:name})
    prosperon[name].fns = fns

    n.clear = function () {
      fns = []
    }

    Register[name] = n
    Register.registries[name] = n
    return n
  },
}

Register.pull_registers = function pull_registers(obj) {
  var reggies = []
  for (var reg in Register.registries) {
    if (typeof obj[reg] === "function")
      reggies.push(reg)
  }
  return reggies
}

Register.register_obj = function register_obj(obj, reg) {
  var fn = obj[reg].bind(obj)
  fn.layer = obj[reg].layer
  var name = obj.ur ? obj.ur.name : obj.toString()
  obj[TIMERS].push(Register.registries[reg].register(fn, name))
  if (!obj[reg].name) Object.defineProperty(obj[reg], 'name', {value:`${obj._file}_${reg}`})
}

Register.check_registers = function check_registers(obj) {
  if (obj[REGGIES]) {
    if (obj[REGGIES].length == 0) return
    for (var reg of obj[REGGIES])
      Register.register_obj(obj,reg)
    return
  }
  for (var reg in Register.registries) {
    if (typeof obj[reg] === "function")
      Register.register_obj(obj,reg)
  }
}

Register.add_cb("appupdate")
Register.add_cb("update").doc = "Called once per frame."
Register.add_cb("physupdate")
Register.add_cb("gui")
Register.add_cb("hud")
Register.add_cb("draw")
Register.add_cb("imgui")
Register.add_cb("app")

function cant_kill() {
  throw Error("Can't kill an object in its spawning code. Move the kill command to awake.")
}

actor.toString = function() { return this[FILE] }

actor.spawn = function spawn(script, config) {
  if (this[DEAD]) throw new Error("Attempting to spawn on a dead actor")
  var prog
  if (!script) {
    prog = {}
    prog.module_ret = {}
    prog.prog_fn = function() {}
  } else {
    prog = script_fn(script)
    if (!prog.prog_fn) throw new Error(`Script ${script} is not an actor script or has no actor component`)
  }

  var underling
  prog.module_ret.__proto__ = actor
  underling = Object.create(prog.module_ret)
  underling[OVERLING] = this
  underling[FILE] = script
  underling[TIMERS] = []
  underling[UNDERLINGS] = new Set()

  Object.defineProperty(underling, 'overling', {
    get() { return this[OVERLING] },
    enumerable:true,
    configurable:false
  })

  Object.defineProperty(underling, 'underlings', {
    get() { return new Set(this[UNDERLINGS]) },
    enumerable:true,
    configurable:false
  })

  Object.defineProperty(underling, 'spawn', {
    value: actor.spawn,
    writable:false,
    enumerable:true,
    configurable:false
  })

  Object.defineProperty(underling, 'kill', {
    value: actor.kill,
    writable:false,
    enumerable:true,
    configurable:false
  })

  Object.defineProperty(underling, 'delay', {
    value: actor.delay,
    writable:false,
    enumerable:true,
    configurable:false
  })

  try {
    prog.prog_fn.call(underling)
  } catch(e) { throw e; }

  if (underling[DEAD]) return undefined;

  if (typeof config === 'object') Object.assign(underling, config)

  if (!underling[REGGIES])
    underling.__proto__[REGGIES] = Register.pull_registers(underling)

  Register.check_registers(underling)
  if (underling.awake) underling.awake()

  this[UNDERLINGS].add(underling)
  if (underling.tag) act.tag_add(underling.tag, underling)

  underling[GARBAGE] = underling.garbage
  return underling
}



actor.clear = function actor_clear() {
  this[UNDERLINGS].forEach(p => {
    p.kill()
  })
  this[UNDERLINGS].clear()
}

var input = use('input')

actor.kill = function kill() {
  if (this[DEAD]) return
  this[DEAD] = true
  this[TIMERS].slice().forEach(t => t())
  delete this[TIMERS]
  input.do_uncontrol(this)

  this.clear()
  this[OVERLING][UNDERLINGS].delete(this)
  delete this[UNDERLINGS]

  if (typeof this.garbage === "function") this.garbage()
  if (typeof this.then === "function") this.then()

  act.tag_clear_guid(this)
}
actor.kill.doc = `Remove this actor and all its underlings from existence.`

actor.delay = function(fn, seconds) {
  if (this[DEAD]) return
  add_timer(this, fn, seconds)
}
actor.delay.doc = `Call 'fn' after 'seconds' with 'this' set to the actor.`



var act = use('actor')
actor[UNDERLINGS] = new Set()

globalThis.mixin("color")

var DOCPATH = 'scripts/core/doc.js'
var script = io.slurp(DOCPATH)
var fnname = "doc"
script = `(function ${fnname}() { ${script}; })`
//js.eval(DOCPATH, script)()

/*
  When handling a message, the message appears like this:
  {
    type: type of message
      - contact: used for contact messages
      - stop: used to issue stop command
      - etc
    reply: ID this message will respond to (callback saved on the actor)
    replycc: the actor that is waiting for the reply
    target: ID of the actor that's supposed to receive the message. Only added to non direct sends (out of portals)
    return: reply ID so the replycc actor can know what callback to send the message to
    
    data: the actual content of the message
  }

  actors look like
  {
    id: the GUID of this actor
    address: the IP this actor can be found at
    port: the port of the IP the actor can be found at
  }
*/

var enet = use('enet')
var util = use('util')
var math = use('math')
var crypto = use('crypto')
var nota = use('nota')

var dying = false

var HEADER = Symbol()

var $actor = {
  toString: print_actor
}

function print_actor() {
  return json.encode(this.__ACTORDATA__, 1)
}

function create_actor(data = {}) {
  var newactor = Object.create($actor)
  Object.defineProperty(data, 'address', {
    get: function() { return local_address },
    set: function(x) {},
    enumerable: true
  })

  Object.defineProperty(data, 'port', {
    get: function() { return local_port },
    set: function(x) {},
    enumerable: true
  })

  newactor.__ACTORDATA__ = data
  return newactor
}

var $_ = create_actor()

$_.random = crypto.random
$_.random[prosperon.DOC] = "returns a number between 0 and 1. There is a 50% chance that the result is less than 0.5."

$_.clock = function(fn) { return os.now() }
$_.clock[prosperon.DOC] = "takes a function input value that will eventually be called with the current time in number form."

var underlings = new Set()
var overling = undefined
var root = undefined

globalThis.$_ = $_

var receive_fn = undefined
var greeters = {}

$_.is_actor = function(actor) {
  return actor.__ACTORDATA__
}

function peer_connection(peer) {
  return {
    latency: peer.rtt,
    bandwidth: {
      incoming: peer.incoming_bandwidth,
      outgoing: peer.outgoing_bandwidth
    },
    activity: {
      last_sent: peer.last_send_time,
      last_received: peer.last_receive_time
    },
    mtu: peer.mtu,
    data: {
      incoming_total: peer.incoming_data_total,
      outgoing_total: peer.outgoing_data_total,
      reliable_in_transit: peer.reliable_data_in_transit
    },
    latency_variance: peer.rtt_variance,
    packet_loss: peer.packet_loss,
    state: peer.state
  }
}

$_.connection = function(callback, actor, config) {
  var peer = peers[actor.__ACTORDATA__.id]
  if (peer) {
    callback(peer_connection(peer))
    return
  }
  if (os.mailbox_exist(actor.__ACTORDATA__.id)) {
    callback({type:"local"})
    return
  }
  throw new Error(`Could not get connection information for ${actor}`)
}
$_.connection[prosperon.DOC] = "takes a callback function, an actor object, and a configuration record..."

var peers = {}
var id_address = {}
var peer_queue = new WeakMap()
var portal = undefined
var portal_fn = undefined
var local_address = undefined
var local_port = undefined

var service_delay = 0.01

$_.portal = function(fn, port) {
  if (portal) throw new Error(`Already started a portal listening on ${portal.port}`)
  if (!port) throw new Error("Requires a valid port.")
  console.log(`starting a portal on port ${port}`)
  portal = enet.create_host({address: "any", port})
  local_address = 'localhost'
  local_port = port
  portal_fn = fn
  console.log(`I am now ${$_}`)
}
$_.portal[prosperon.DOC] = "starts a public address that performs introduction services..."

function handle_host(e) {
  switch (e.type) {
    case "connect":
      console.log(`connected a new peer: ${e.peer.address}:${e.peer.port}`)
      peers[`${e.peer.address}:${e.peer.port}`] = e.peer
      var queue = peer_queue.get(e.peer)
      if (queue) {
        for (var msg of queue) e.peer.send(nota.encode(msg))
        console.log(`sent ${json.encode(msg)} out of queue`)
        peer_queue.delete(e.peer)
      }
      break
    case "disconnect":
      peer_queue.delete(e.peer)
      for (var id in peers) if (peers[id] === e.peer) delete peers[id]
      console.log('portal got disconnect')
      break
    case "receive":
      var data = nota.decode(e.data)
      if (data.replycc && !data.replycc.address) {
        data.replycc.__ACTORDATA__.address = e.peer.address
        data.replycc.__ACTORDATA__.port = e.peer.port
      }
      handle_message(data)
      break
  }
}

var contactor = undefined
$_.contact = function(callback, record) {
  $_.send({
    __ACTORDATA__: {
      address: record.address,
      port: record.port
    }
  }, record, callback)
}

$_.contact[prosperon.DOC] = "The contact function sends a message to a portal..."

$_.receiver = function(fn) {
  receive_fn = fn
}
$_.receiver[prosperon.DOC] = "registers a function that will receive all messages..."

$_.start = function(cb, prg, arg) {
  if (dying) {
    console.warn(`Cannot start an underling in the same turn as we're stopping`)
    return
  }
  var id = util.guid()
  greeters[id] = cb
  var argv = ["./prosperon", "spawn", "--id", id, "--overling", prosperon.id, "--root", root]
  if (prg) argv = argv.concat(['--program', prg])
  if (arg) argv = argv.concat(cmd.encode(arg))
  underlings.add(id)
  os.createactor(argv)
}
$_.start[prosperon.DOC] = "The start function creates a new actor..."

$_.stop = function(actor) {
  if (!actor) {
    destroyself()
    return
  }
  if (!$_.is_actor(actor))
    throw new Error('Can only call stop on an actor.')
  if (!underlings.has(actor.__ACTORDATA__.id))
    throw new Error('Can only call stop on an underling or self.')
    
  actor_prep(actor, {type:"stop", id: prosperon.id})
}
$_.stop[prosperon.DOC] = "The stop function stops an underling."

$_.unneeded = function(fn, seconds) {
  os.unneeded(fn, seconds)
}
$_.unneeded[prosperon.DOC] = "registers a function that is called when the actor..."

$_.delay = function(fn, seconds) {
  var id = os.delay(fn, seconds)
  return function() { os.removetimer(id) }
}
$_.delay[prosperon.DOC] = "used to schedule the invocation of a function..."

var couplings = new Set()
$_.couple = function(actor) {
  console.log(`coupled to ${actor.__ACTORDATA__.id}`)
  couplings.add(actor.__ACTORDATA__.id)
}
$_.couple[prosperon.DOC] = "causes this actor to stop when another actor stops."

function actor_prep(actor, send) {
  message_queue.push({actor,send});
}

function actor_send(actor, message) {
  if (!$_.is_actor(actor)) throw new Error(`Must send to an actor object. Attempted send to ${json.encode(actor)}`)
  if (typeof message !== 'object') throw new Error('Must send an object record.')

  if (actor.__ACTORDATA__.id === prosperon.id) {
    if (receive_fn) receive_fn(message.data)
    return
  }
  if (actor.__ACTORDATA__.id && os.mailbox_exist(actor.__ACTORDATA__.id)) {
    os.mailbox_push(actor.__ACTORDATA__.id, message)
    return
  }
  if (actor.__ACTORDATA__.address) {
    if (actor.__ACTORDATA__.id) message.target = actor.__ACTORDATA__.id
    else message.type = "contact"
    var peer = peers[actor.__ACTORDATA__.address + ":" + actor.__ACTORDATA__.port]
    if (!peer) {
      if (!contactor && !portal) {
        console.log(`creating a contactor ...`)
        contactor = enet.create_host()
      }
      peer = (contactor || portal).connect(actor.__ACTORDATA__.address, actor.__ACTORDATA__.port)
      peer_queue.set(peer, [message])
    } else {
      peer.send(nota.encode(message))
    }
    return
  }
  throw new Error(`Unable to send message to actor ${json.encode(actor)}`)
}

// Holds all messages queued during the current turn.
var message_queue = []

function send_messages() {
  // Attempt to flush the queued messages. If one fails, keep going anyway.
  var errors = []
  while (message_queue.length > 0) {
    var item = message_queue.shift()
    var actor = item.actor
    var send = item.send
    try {
      actor_send(actor, send)
    } catch (err) {
      errors.push(err)
    }
  }
  if (errors.length > 0) console.error("Some messages failed to send:", errors)
}

var replies = {}

$_.send = function(actor, message, reply) {
  if (typeof message !== 'object')
    throw new Error('Message must be an object')
  var send = {type:"user", data: message}

  if (actor[HEADER] && actor[HEADER].replycc) {
    var header = actor[HEADER]
    if (!header.replycc || !$_.is_actor(header.replycc))
      throw new Error(`Supplied actor had a return, but it's not a valid actor! ${json.encode(actor[HEADER])}`)

    actor = header.replycc
    send.return = header.reply
  }

  if (reply) {
    var id = util.guid()
    replies[id] = reply
    send.reply = id
    send.replycc = $_
  }

  // Instead of sending immediately, queue it
  actor_prep(actor,send);
}
$_.send[prosperon.DOC] = "sends a message to another actor..."

$_.blast = $_.send;

var cmd = use('cmd')
cmd.process(prosperon.argv.slice())

if (!prosperon.args.id) prosperon.id = util.guid()
else prosperon.id = prosperon.args.id

os.register_actor(prosperon.id, function(msg) {
  try {
    handle_message(msg)
    send_messages()
  } catch (err) {
    message_queue = []
    throw err
  }
}, prosperon.args.main)

$_.__ACTORDATA__.id = prosperon.id

if (prosperon.args.overling) overling = {__ACTORDATA__: {id: prosperon.args.overling}}
if (prosperon.args.root) root = json.decode(prosperon.args.root)
else root = $_

if (overling) actor_prep(overling, {type:'greet', id: prosperon.id})

if (!prosperon.args.program)
  os.exit(1)

if (typeof prosperon.args.program !== 'string')
  prosperon.args.program = 'main.js';
  
actor.spawn(prosperon.args.program)

function destroyself() {
  console.log(`Got the message to destroy self.`)
  dying = true
  for (var i of underlings) {
    var act = {
      __ACTORDATA__: {id: i}
    }
    $_.stop(act);
  }
  os.destroy()
}

function handle_actor_disconnect(id) {
  var greeter = greeters[id]
  if (greeter) {
    greeter({type: "stopped", id})
    delete greeters[id]
  }
  console.log(`actor ${id} disconnected`)
  if (couplings.has(id)) $_.stop()
  delete peers[id]
}

function handle_message(msg) {
  if (msg.target) {
    if (msg.target !== prosperon.id) {
      os.mailbox_push(msg.target, msg)
      return
    }
  }
  switch (msg.type) {
    case "user":
      var letter = msg.data
      delete msg.data
      letter[HEADER] = msg
      if (msg.return) {
        console.log(`Received a message for the return id ${msg.return}`)
        var fn = replies[msg.return]
        if (!fn) throw new Error(`Could not find return function for message ${msg.return}`)
        fn(letter)
        delete replies[msg.return]
        return
      }
      if (receive_fn) receive_fn(letter)
      break
    case "stop":
      if (msg.id !== overling.__ACTORDATA__.id)
        throw new Error(`Got a message from an actor ${msg.id} to stop...`)
      destroyself()
      break
    case "contact":
      if (portal_fn) {
        var letter2 = msg.data
        letter2[HEADER] = msg
        delete msg.data
        portal_fn(letter2)
      } else throw new Error('Got a contact message, but no portal is established.')
      break
    case "stopped":
      handle_actor_disconnect(msg.id)
      break
    case "greet":
      var greeter = greeters[msg.id]
      if (greeter) greeter({type: "actor_started", actor: create_actor(msg)})
      break;
    default:
      if (receive_fn) receive_fn(msg)
      break;
  }
};

function enet_check()
{
  if (portal) portal.service(handle_host)
  if (contactor) contactor.service(handle_host)
  
  $_.delay(enet_check, service_delay);
}

send_messages();

})()