///|
/// A message as JSON. The conversation is part of a checkpoint, so it has to survive a
/// round trip through the saver: `role`, then one entry per part, each tagged with the
/// part's kind.
fn message_to_json(message : @moonmuse.Message) -> Json {
  let parts : Array[Json] = []
  for part in message.parts {
    parts.push(part_to_json(part))
  }
  Json::object(
    Map([
      ("role", Json::string(role_code(message.role))),
      ("parts", Json::array(parts)),
    ]),
  )
}

///|
/// The wire name of a role, the same spelling the providers use.
pub fn role_code(role : @moonmuse.Role) -> String {
  match role {
    System => "system"
    User => "user"
    Assistant => "assistant"
    Tool => "tool"
  }
}

///|
/// A role from its wire name.
pub fn role_of(code : String) -> @moonmuse.Role? {
  match code {
    "system" => Some(System)
    "user" => Some(User)
    "assistant" => Some(Assistant)
    "tool" => Some(Tool)
    _ => None
  }
}

///|
/// One part as JSON, tagged with its kind.
fn part_to_json(part : @moonmuse.Part) -> Json {
  match part {
    Text(text) =>
      Json::object(
        Map([("kind", Json::string("text")), ("text", Json::string(text))]),
      )
    Image(url~, media~) => {
      let fields : Map[String, Json] = Map([
        ("kind", Json::string("image")),
        ("url", Json::string(url)),
      ])
      match media {
        Some(media) => fields["media"] = Json::string(media)
        None => ()
      }
      Json::object(fields)
    }
    Call(id~, name~, args~) =>
      Json::object(
        Map([
          ("kind", Json::string("call")),
          ("id", Json::string(id)),
          ("name", Json::string(name)),
          ("args", args),
        ]),
      )
    Result(id~, content~, error~) =>
      Json::object(
        Map([
          ("kind", Json::string("result")),
          ("id", Json::string(id)),
          ("content", Json::string(content)),
          ("error", Json::boolean(error)),
        ]),
      )
  }
}

///|
/// A message from its JSON form; the error names the field that did not read.
fn message_from_json(
  json : Json,
  path : @json.JsonPath,
) -> @moonmuse.Message raise @json.JsonDecodeError {
  guard json is Object(fields) else {
    raise @json.JsonDecodeError((path, "want an object"))
  }
  let role = match fields.get("role") {
    Some(String(code)) =>
      match role_of(code) {
        Some(role) => role
        None =>
          raise @json.JsonDecodeError(
            (path.add_key("role"), "want a known role"),
          )
      }
    Some(_) =>
      raise @json.JsonDecodeError((path.add_key("role"), "want a string"))
    None => raise @json.JsonDecodeError((path.add_key("role"), "want a role"))
  }
  let parts = match fields.get("parts") {
    Some(Array(items)) => {
      let out : Array[@moonmuse.Part] = []
      for index, item in items {
        out.push(part_from_json(item, path.add_key("parts").add_index(index)))
      }
      out
    }
    Some(_) =>
      raise @json.JsonDecodeError((path.add_key("parts"), "want an array"))
    None =>
      raise @json.JsonDecodeError((path.add_key("parts"), "want an array"))
  }
  { role, parts, }
}

///|
/// One part from its JSON form.
fn part_from_json(
  part : Json,
  path : @json.JsonPath,
) -> @moonmuse.Part raise @json.JsonDecodeError {
  guard part is Object(fields) else {
    raise @json.JsonDecodeError((path, "want an object"))
  }
  let kind = match fields.get("kind") {
    Some(String(kind)) => kind
    Some(_) =>
      raise @json.JsonDecodeError((path.add_key("kind"), "want a string"))
    None => raise @json.JsonDecodeError((path.add_key("kind"), "want a kind"))
  }
  match kind {
    "text" => Text(read_string(fields, "text", path))
    "image" =>
      Image(
        url=read_string(fields, "url", path),
        media=read_optional_string(fields, "media", path),
      )
    "call" =>
      Call(
        id=read_string(fields, "id", path),
        name=read_string(fields, "name", path),
        args=match fields.get("args") {
          Some(args) => args
          None =>
            raise @json.JsonDecodeError(
              (path.add_key("args"), "want arguments"),
            )
        },
      )
    "result" =>
      Result(
        id=read_string(fields, "id", path),
        content=read_string(fields, "content", path),
        error=match fields.get("error") {
          Some(True) => true
          Some(False) => false
          Some(_) =>
            raise @json.JsonDecodeError((path.add_key("error"), "want a bool"))
          None => false
        },
      )
    _ =>
      raise @json.JsonDecodeError(
        (path.add_key("kind"), "want a known part kind"),
      )
  }
}

///|
fn read_string(
  fields : Map[String, Json],
  key : String,
  path : @json.JsonPath,
) -> String raise @json.JsonDecodeError {
  match fields.get(key) {
    Some(String(value)) => value
    Some(_) => raise @json.JsonDecodeError((path.add_key(key), "want a string"))
    None => raise @json.JsonDecodeError((path.add_key(key), "want a string"))
  }
}

///|
fn read_optional_string(
  fields : Map[String, Json],
  key : String,
  path : @json.JsonPath,
) -> String? raise @json.JsonDecodeError {
  match fields.get(key) {
    Some(String(value)) => Some(value)
    Some(Null) | None => None
    Some(_) => raise @json.JsonDecodeError((path.add_key(key), "want a string"))
  }
}