///|
/// MapLibre's events: mouse events (on a layer's features with `Map::on_layer`, where alone `MouseEnter`
/// and `MouseLeave` come), `Load` (first view drawn), `Render` (each frame), `Idle` (settled, also right
/// after `Load`), `Error`, `StyleData`, `SourceData`, and the camera's moving, zooming, rotating, pitching.
pub(all) enum EventType {
  MouseDown
  MouseUp
  MouseOver
  MouseOut
  MouseMove
  Click
  DblClick
  ContextMenu
  MouseEnter
  MouseLeave
  Load
  StyleData
  SourceData
  Render
  Idle
  Error
  MoveStart
  Move
  MoveEnd
  ZoomStart
  Zoom
  ZoomEnd
  RotateStart
  Rotate
  RotateEnd
  PitchStart
  Pitch
  PitchEnd
}

///|
/// The name the npm package uses for `self`.
pub fn EventType::name(self : EventType) -> String {
  match self {
    MouseDown => "mousedown"
    MouseUp => "mouseup"
    MouseOver => "mouseover"
    MouseOut => "mouseout"
    MouseMove => "mousemove"
    Click => "click"
    DblClick => "dblclick"
    ContextMenu => "contextmenu"
    MouseEnter => "mouseenter"
    MouseLeave => "mouseleave"
    Load => "load"
    StyleData => "styledata"
    SourceData => "sourcedata"
    Render => "render"
    Idle => "idle"
    Error => "error"
    MoveStart => "movestart"
    Move => "move"
    MoveEnd => "moveend"
    ZoomStart => "zoomstart"
    Zoom => "zoom"
    ZoomEnd => "zoomend"
    RotateStart => "rotatestart"
    Rotate => "rotate"
    RotateEnd => "rotateend"
    PitchStart => "pitchstart"
    Pitch => "pitch"
    PitchEnd => "pitchend"
  }
}

///|
/// A feature under the pointer or found by a query, as GeoJSON with where it was drawn: `layer`
/// and `source` (and `source_layer` of a vector source), its `id` if it has one.
pub(all) struct Feature {
  id : Json?
  layer : String
  source : String
  source_layer : String?
  properties : Json
  geometry : Json
}

///|
/// What an event carries: mouse events their `point` (CSS pixels), its `lnglat` and the `features`
/// of the layers listened to; `Error` its `error` message; `SourceData` the `source` id.
pub(all) struct Event {
  kind : EventType
  point : Point?
  lnglat : LngLat?
  features : Array[Feature]
  error : String?
  source : String?
}

///|
fn optional_string(v : JsValue) -> String? {
  if js_is_nullish(v) {
    None
  } else {
    Some(js_as_string(v))
  }
}

///|
fn feature_of(f : JsValue) -> Feature {
  let layer = js_get(f, "layer")
  let id = js_get(f, "id")
  {
    id: if js_is_nullish(id) {
      None
    } else {
      Some(id.to_json())
    },
    layer: js_as_string(js_get(layer, "id")),
    source: js_as_string(js_get(f, "source")),
    source_layer: optional_string(js_get(f, "sourceLayer")),
    properties: js_get(f, "properties").to_json(),
    geometry: js_get(f, "geometry").to_json(),
  }
}

///|
fn event_of(kind : EventType, e : JsValue) -> Event {
  let p = js_get(e, "point")
  let ll = js_get(e, "lngLat")
  let error = js_get(e, "error")
  {
    kind,
    point: if js_is_nullish(p) {
      None
    } else {
      Some({ x: js_as_number(js_get(p, "x")), y: js_as_number(js_get(p, "y")), })
    },
    lnglat: if js_is_nullish(ll) {
      None
    } else {
      Some({
        lng: js_as_number(js_get(ll, "lng")),
        lat: js_as_number(js_get(ll, "lat")),
      })
    },
    features: js_items(js_get(e, "features")).iter().map(feature_of).collect(),
    error: if js_is_nullish(error) {
      None
    } else {
      Some(js_as_string(js_get(error, "message")))
    },
    source: optional_string(js_get(e, "sourceId")),
  }
}

///|
/// A listener `Map::on` added; `off` removes it.
pub struct Listener {
  priv map : Map
  priv args : FixedArray[JsValue]
}

///|
extern "js" fn js_listener(f : (JsValue) -> Unit) -> JsValue =
  #|(f) => (e) => f(e)

///|
/// Calls `f` with each `kind` event from now on.
pub fn Map::on(self : Map, kind : EventType, f : (Event) -> Unit) -> Listener {
  let args : FixedArray[JsValue] = [
    js_string(kind.name()),
    js_listener(e => f(event_of(kind, e))),
  ]
  self.call("on", args) |> ignore
  { map: self, args, }
}

///|
/// Calls `f` with each `kind` mouse event on the features of `layers` (with those features).
pub fn Map::on_layer(
  self : Map,
  kind : EventType,
  layers : Array[String],
  f : (Event) -> Unit,
) -> Listener {
  let ids = json_to_js(Json::array(layers.map(Json::string)))
  let args : FixedArray[JsValue] = [
    js_string(kind.name()),
    ids,
    js_listener(e => f(event_of(kind, e))),
  ]
  self.call("on", args) |> ignore
  { map: self, args, }
}

///|
/// Stops the listener.
pub fn Listener::off(self : Listener) -> Unit {
  self.map.call("off", self.args) |> ignore
}

///|
/// `f` with what `p` resolves to, or with an empty array (the error logged) when it rejects.
extern "js" fn js_then(p : JsValue, f : (JsValue) -> Unit) -> Unit =
  #|(p, f) => { p.then(f, (e) => { console.error(e); f([]); }); }

///|
/// The features drawn at `point` (or in the whole view without it), topmost first, of `layers` if
/// given, handed to `done` once the workers answered (MapLibre's `queryRenderedFeatures`); none when the
/// query fails (an unknown layer), the error logged.
pub fn Map::query_rendered_features(
  self : Map,
  point? : Point,
  layers? : Array[String],
  done : (Array[Feature]) -> Unit,
) -> Unit {
  let options : @builtin.Map[String, Json] = @builtin.Map([])
  if layers is Some(ids) {
    options["layers"] = Json::array(ids.map(Json::string))
  }
  let args : FixedArray[JsValue] = match point {
    Some(p) => [json_to_js([p.x, p.y]), json_to_js(Json::object(options))]
    None => [json_to_js(Json::object(options))]
  }
  js_then(self.call("queryRenderedFeatures", args), r => {
    done(js_items(r).iter().map(feature_of).collect())
  })
}