///|
fn build_command_host(
  manifest : @manifest.AppManifest,
  command_extensions : Map[String, @proton_command.AppCommandExtensionSpec],
  base_dir : String?,
) -> Result[CommandHostRuntime?, String] {
  let host = @core.AppCommandHost::new()
  let destroy_hooks : Array[() -> Unit] = []
  let mut has_commands = false
  let ordered_ids = match
    enabled_command_extension_order(manifest, command_extensions) {
    Err(error) => {
      close_command_host_runtime(host, destroy_hooks)
      return Err(error)
    }
    Ok(ids) => ids
  }
  for id in ordered_ids {
    let spec = command_extensions[id]
    let setting = manifest.extension_setting(id).unwrap()
    let context = @proton_command.AppCommandExtensionContext::new(
      host,
      id,
      spec.js_namespace(),
      options=setting.options(),
      base_dir~,
    )
    match spec.register(context) {
      Err(error) => {
        close_command_host_runtime(host, destroy_hooks)
        return Err(error)
      }
      Ok(_) => {
        has_commands = true
        destroy_hooks.push(fn() { spec.destroy(context) })
      }
    }
  }
  if has_commands {
    host.seal_registrations()
    Ok(Some(CommandHostRuntime::{ host, destroy_hooks, closed: false }))
  } else {
    close_command_host_runtime(host, destroy_hooks)
    Ok(None)
  }
}

///|
fn close_command_host_runtime(
  host : @core.AppCommandHost,
  destroy_hooks : Array[() -> Unit],
) -> Unit {
  let hook_count = destroy_hooks.length()
  for index in 0.. Result[Array[String], String] {
  let visit_state : Map[String, Int] = Map([])
  let ordered : Array[String] = []
  for id, _spec in command_extensions {
    match manifest.extension_setting(id) {
      Some(setting) if setting.is_enabled() =>
        match
          visit_enabled_command_extension(
            id,
            None,
            manifest,
            command_extensions,
            visit_state,
            ordered,
          ) {
          Err(error) => return Err(error)
          Ok(_) => ()
        }
      None => ()
      _ => ()
    }
  }
  Ok(ordered)
}

///|
fn visit_enabled_command_extension(
  id : String,
  requested_by : String?,
  manifest : @manifest.AppManifest,
  command_extensions : Map[String, @proton_command.AppCommandExtensionSpec],
  visit_state : Map[String, Int],
  ordered : Array[String],
) -> Result[Unit, String] {
  match visit_state.get(id) {
    Some(2) => return Ok(())
    Some(1) =>
      return Err("command extension dependency cycle detected at: " + id)
    _ => ()
  }
  let spec = match
    require_enabled_command_extension(
      id, requested_by, manifest, command_extensions,
    ) {
    Err(error) => return Err(error)
    Ok(spec) => spec
  }
  visit_state[id] = 1
  for dependency in spec.dependencies() {
    match
      visit_enabled_command_extension(
        dependency,
        Some(id),
        manifest,
        command_extensions,
        visit_state,
        ordered,
      ) {
      Err(error) => return Err(error)
      Ok(_) => ()
    }
  }
  visit_state[id] = 2
  ordered.push(id)
  Ok(())
}

///|
fn require_enabled_command_extension(
  id : String,
  requested_by : String?,
  manifest : @manifest.AppManifest,
  command_extensions : Map[String, @proton_command.AppCommandExtensionSpec],
) -> Result[@proton_command.AppCommandExtensionSpec, String] {
  match manifest.extension_setting(id) {
    Some(setting) if setting.is_enabled() => ()
    Some(_) =>
      return Err(
        command_extension_dependency_error(id, requested_by, "disabled"),
      )
    None =>
      return Err(
        command_extension_dependency_error(id, requested_by, "missing"),
      )
  }
  match command_extensions.get(id) {
    Some(spec) => Ok(spec)
    None =>
      Err(command_extension_dependency_error(id, requested_by, "unregistered"))
  }
}

///|
fn command_extension_dependency_error(
  id : String,
  requested_by : String?,
  state : String,
) -> String {
  match requested_by {
    Some(parent) =>
      "command extension " + parent + " requires " + state + " dependency " + id
    None => "enabled command extension is " + state + ": " + id
  }
}

///|
fn build_command_proxy_script(
  manifest : @manifest.AppManifest,
  command_extensions : Map[String, @proton_command.AppCommandExtensionSpec],
) -> Result[String?, String] {
  let specs : Array[Json] = []
  let scripts : Array[String] = []
  let ordered_ids = match
    enabled_command_extension_order(manifest, command_extensions) {
    Err(error) => return Err(error)
    Ok(ids) => ids
  }
  for id in ordered_ids {
    let spec = command_extensions[id]
    let js_namespace = spec.js_namespace()
    if command_proxy_name_is_invalid(js_namespace) {
      return Err(
        "command extension namespace cannot be exposed to JavaScript: " +
        js_namespace,
      )
    }
    let apis : Array[Json] = []
    for api in spec.apis() {
      let api_name = api.api_name()
      if command_proxy_name_is_invalid(api_name) {
        return Err(
          "command extension API cannot be exposed to JavaScript: " +
          js_namespace +
          "." +
          api_name,
        )
      }
      apis.push(Json::string(api_name))
    }
    specs.push(
      Json::object({
        "namespace": Json::string(js_namespace),
        "apis": Json::array(apis),
      }),
    )
    for script in spec.scripts() {
      scripts.push(script)
    }
  }
  if specs.length() == 0 {
    Ok(None)
  } else {
    let script = command_proxy_bootstrap_script(Json::array(specs).stringify())
    if scripts.length() == 0 {
      Ok(Some(script))
    } else {
      Ok(Some(script + "\n" + scripts.join("\n")))
    }
  }
}

///|
fn command_proxy_name_is_invalid(name : String) -> Bool {
  name.trim().to_owned() == "" ||
  name == "core" ||
  name == "events" ||
  @proton_command.app_command_js_property_is_reserved(name)
}

///|
fn command_proxy_bootstrap_script(specs_json : String) -> String {
  "(function(){\n" +
  "  var specs = " +
  specs_json +
  ";\n" +
  "  var existing = window.__MoonBit__;\n" +
  "  var root = existing && typeof existing === 'object' ? existing : {};\n" +
  "  var exactListeners = root['@@exactListeners'] && typeof root['@@exactListeners'] === 'object' ? root['@@exactListeners'] : Object.create(null);\n" +
  "  root['@@exactListeners'] = exactListeners;\n" +
  "  var events = root.events && typeof root.events === 'object' ? root.events : {};\n" +
  "  function ensureExactListeners(name) {\n" +
  "    if (!Array.isArray(exactListeners[name])) { exactListeners[name] = []; }\n" +
  "    return exactListeners[name];\n" +
  "  }\n" +
  "  function emitExact(name, event) {\n" +
  "    var listeners = ensureExactListeners(name).slice();\n" +
  "    for (var index = 0; index < listeners.length; index += 1) {\n" +
  "      listeners[index](event);\n" +
  "    }\n" +
  "    return event;\n" +
  "  }\n" +
  "  events.emit = function(name, event) { return emitExact(String(name), event); };\n" +
  "  events['@@emitExtensionEvent'] = function(namespace, eventName, payload) {\n" +
  "    var event = {\n" +
  "      extension: String(namespace),\n" +
  "      name: String(eventName),\n" +
  "      payload: payload === undefined ? null : payload\n" +
  "    };\n" +
  "    return emitExact(event.extension + '.' + event.name, event);\n" +
  "  };\n" +
  "  events.on = function(name, listener) {\n" +
  "    if (typeof listener !== 'function') {\n" +
  "      throw new TypeError('MoonBit.events.on expects a listener function');\n" +
  "    }\n" +
  "    var key = String(name);\n" +
  "    ensureExactListeners(key).push(listener);\n" +
  "    return function() {\n" +
  "      var listeners = ensureExactListeners(key);\n" +
  "      exactListeners[key] = listeners.filter(function(candidate) { return candidate !== listener; });\n" +
  "    };\n" +
  "  };\n" +
  "  root.events = events;\n" +
  "  function invokeExtension(namespace, apiName, payload) {\n" +
  "    var current = window.__MoonBit__;\n" +
  "    var core = current && current.core;\n" +
  "    if (!core || typeof core.invokeOp !== 'function') {\n" +
  "      return Promise.reject(new Error('MoonBit bridge is not available'));\n" +
  "    }\n" +
  "    return core.invokeOp('ext:' + namespace + '/' + apiName, payload);\n" +
  "  }\n" +
  "  var extensions = root['@@extensions'] && typeof root['@@extensions'] === 'object' ? root['@@extensions'] : Object.create(null);\n" +
  "  root['@@extensions'] = extensions;\n" +
  "  root['@@ensureExtension'] = function(extensionName) {\n" +
  "    var existingExtension = extensions[extensionName];\n" +
  "    if (existingExtension && typeof existingExtension === 'object') {\n" +
  "      return existingExtension;\n" +
  "    }\n" +
  "    var target = {};\n" +
  "    target.invoke = function(apiName, payload) {\n" +
  "      return invokeExtension(String(extensionName), String(apiName), payload);\n" +
  "    };\n" +
  "    target.on = function(eventName, listener) {\n" +
  "      return events.on(String(extensionName) + '.' + String(eventName), listener);\n" +
  "    };\n" +
  "    Object.defineProperty(target, 'name', { value: String(extensionName), enumerable: true });\n" +
  "    extensions[extensionName] = target;\n" +
  "    root[extensionName] = target;\n" +
  "    return target;\n" +
  "  };\n" +
  "  for (var i = 0; i < specs.length; i += 1) {\n" +
  "    var namespace = String(specs[i].namespace || '');\n" +
  "    var apis = Array.isArray(specs[i].apis) ? specs[i].apis : [];\n" +
  "    if (!namespace) { continue; }\n" +
  "    var target = root['@@ensureExtension'](namespace);\n" +
  "    target.invoke = (function(ns) {\n" +
  "      return function(apiName, payload) {\n" +
  "        return invokeExtension(ns, String(apiName), payload);\n" +
  "      };\n" +
  "    })(namespace);\n" +
  "    target.on = (function(ns) {\n" +
  "      return function(eventName, listener) {\n" +
  "        return events.on(ns + '.' + String(eventName), listener);\n" +
  "      };\n" +
  "    })(namespace);\n" +
  "    for (var j = 0; j < apis.length; j += 1) {\n" +
  "      var apiName = String(apis[j] || '');\n" +
  "      if (!apiName || apiName === 'then') { continue; }\n" +
  "      target[apiName] = (function(ns, api) {\n" +
  "        return function(payload) { return invokeExtension(ns, api, payload); };\n" +
  "      })(namespace, apiName);\n" +
  "    }\n" +
  "    root[namespace] = target;\n" +
  "  }\n" +
  "  window.__MoonBit__ = root;\n" +
  "})();"
}

///|
fn install_extension_event_sender(
  window : @native.Window,
  host : @core.AppCommandHost,
  policy : BridgePagePolicy,
) -> Unit {
  host.set_event_sender(extension_event_sender(window, None, policy))
}

///|
fn extension_event_sender(
  window : @native.Window,
  page_instance : String?,
  policy : BridgePagePolicy,
) -> async (@ipc.IpcExtensionEvent) -> Unit {
  async fn(event) {
    ignore(
      window.eval(extension_event_dispatch_script(event, page_instance, policy)),
    )
    @async.sleep(0)
  }
}

///|
fn extension_event_dispatch_script(
  event : @ipc.IpcExtensionEvent,
  page_instance : String?,
  policy : BridgePagePolicy,
) -> String {
  let page_instance_check = match page_instance {
    Some(value) =>
      "  if (!root || !root.core || root.core['@@pageInstance'] !== " +
      Json::string(value).stringify() +
      ") { return; }\n"
    None => ""
  }
  "(function(){\n" +
  bridge_page_policy_guard_script(policy) +
  "  var event = " +
  ToJson::to_json(event).stringify() +
  ";\n" +
  "  var root = window.__MoonBit__;\n" +
  page_instance_check +
  "  var events = root && root.events;\n" +
  "  var emit = events && events['@@emitExtensionEvent'];\n" +
  "  if (typeof emit === 'function') {\n" +
  "    emit(event.extension_namespace, event.event_name, event.payload);\n" +
  "  }\n" +
  "})();"
}

///|
async fn dispatch_bridge_request(
  window : @native.Window,
  host : @core.AppCommandHost,
  request : @native.BridgeRequest,
  policy : BridgePagePolicy,
) -> @native.BridgeResponse {
  let request_id = request.request_id()
  let response = match
    @async.with_timeout_opt(policy.request_timeout_ms, () => {
      host.dispatch_ipc_with_event_sender(
        @ipc.IpcOpRequest::new(
          request_id.to_string(),
          request.op(),
          request.payload(),
        ),
        Some(extension_event_sender(window, request.page_instance(), policy)),
      )
    }) {
    Some(response) => response
    None =>
      return @native.BridgeResponse::Err(
        request_id~,
        code="request_timeout",
        message="bridge request timed out",
      )
  }
  if response.is_ok() {
    @native.BridgeResponse::Ok(request_id~, payload=response.body)
  } else {
    let message = match response.body {
      String(text) => text
      _ => response.body.stringify()
    }
    @native.BridgeResponse::Err(request_id~, code="op_failed", message~)
  }
}

///|
fn default_bridge_page_policy() -> BridgePagePolicy {
  BridgePagePolicy::{ dev_origin: None, request_timeout_ms: 30000 }
}

///|
fn bridge_page_policy_for_manifest(
  manifest : @manifest.AppManifest,
) -> Result[BridgePagePolicy, String] {
  if !proton_dev_mode_enabled() {
    return Ok(default_bridge_page_policy())
  }
  match manifest.entry {
    @manifest.AppEntry::Url(url) =>
      url_origin(url).map(fn(origin) {
        BridgePagePolicy::{
          dev_origin: Some(origin),
          request_timeout_ms: 30000,
        }
      })
    _ => Ok(default_bridge_page_policy())
  }
}

///|
fn url_origin(url : String) -> Result[String, String] {
  let (scheme_view, rest_view) = match url.split_once("://") {
    Some(parts) => parts
    None =>
      return Err("dev bridge URL must include http:// or https://: " + url)
  }
  let scheme = scheme_view.to_owned().to_lower()
  if scheme != "http" && scheme != "https" {
    return Err("dev bridge URL must use http or https: " + url)
  }
  let rest = rest_view.to_owned()
  if rest == "" {
    return Err("dev bridge URL is missing host: " + url)
  }
  let mut end = rest.length()
  for delimiter in ["/", "?", "#"] {
    match rest.find(delimiter) {
      Some(index) if index < end => end = index
      _ => ()
    }
  }
  if end == 0 {
    return Err("dev bridge URL is missing host: " + url)
  }
  let authority = rest.unsafe_substring(start=0, end~).to_string()
  if !dev_origin_authority_is_valid(authority) {
    return Err("dev bridge URL has invalid origin: " + url)
  }
  canonical_dev_origin_authority(authority, scheme).map(fn(authority) {
    scheme + "://" + authority
  })
}

///|
fn dev_origin_authority_is_valid(authority : String) -> Bool {
  if authority == "" || authority.contains("@") {
    return false
  }
  for ch in authority {
    let code = ch.to_int()
    if code <= 0x20 ||
      code >= 0x7f ||
      ch == '/' ||
      ch == '?' ||
      ch == '#' ||
      ch == '"' ||
      ch == '\\' {
      return false
    }
  }
  true
}

///|
fn canonical_dev_origin_authority(
  authority : String,
  scheme : String,
) -> Result[String, String] {
  if authority.has_prefix("[") {
    let (host_part, suffix) = match authority.split_once("]") {
      Some(parts) => parts
      None => return Err("dev bridge URL has invalid IPv6 origin: " + authority)
    }
    let host_text = host_part.to_owned()
    let host = host_text
      .unsafe_substring(start=1, end=host_text.length())
      .to_string()
    if host == "" {
      return Err("dev bridge URL host must not be empty")
    }
    if suffix != "" && !suffix.has_prefix(":") {
      return Err("dev bridge URL has invalid IPv6 origin: " + authority)
    }
    canonical_dev_origin_port_suffix(suffix.to_owned(), scheme).map(fn(port) {
      "[" + host.to_lower() + "]" + port
    })
  } else {
    let first_colon = authority.find(":")
    let last_colon = authority.rev_find(":")
    if first_colon != last_colon {
      return Err("dev bridge IPv6 origins must use brackets: " + authority)
    }
    match first_colon {
      None => Ok(authority.to_lower())
      Some(index) => {
        let host = authority.unsafe_substring(start=0, end=index).to_string()
        let port = authority
          .unsafe_substring(start=index + 1, end=authority.length())
          .to_string()
        if host == "" {
          return Err("dev bridge URL host must not be empty")
        }
        if port == "" {
          return Err("dev bridge URL port must not be empty")
        }
        canonical_dev_origin_port_suffix(port, scheme).map(fn(port) {
          host.to_lower() + port
        })
      }
    }
  }
}

///|
fn canonical_dev_origin_port_suffix(
  port : String,
  scheme : String,
) -> Result[String, String] {
  if port == "" {
    return Ok("")
  }
  let text = if port.has_prefix(":") { port[1:].to_owned() } else { port }
  if text == "" {
    return Err("dev bridge URL port must not be empty")
  }
  let value = @string.parse_int(text[:]) catch {
    _ => return Err("dev bridge URL port must be an integer: " + text)
  }
  if value <= 0 || value > 65535 {
    return Err("dev bridge URL port is out of range: " + text)
  }
  let default_port = if scheme == "http" { 80 } else { 443 }
  if value == default_port {
    Ok("")
  } else {
    Ok(":" + value.to_string())
  }
}

///|
fn bridge_page_policy_dev_origins(policy : BridgePagePolicy) -> Array[String] {
  match policy.dev_origin {
    Some(origin) => [origin]
    None => []
  }
}

///|
fn bridge_page_policy_guard_script(policy : BridgePagePolicy) -> String {
  match policy.dev_origin {
    None =>
      "  if (!window.location || window.location.protocol !== 'proton:') { return; }\n"
    Some(origin) =>
      "  if (!window.location) { return; }\n" +
      "  if (window.location.protocol !== 'proton:' && window.location.origin !== " +
      Json::string(origin).stringify() +
      ") { return; }\n"
  }
}