///|
/// A client message after framing and envelope checks, before any MCP meaning
/// is given to its method.
priv enum Message {
  Request(id~ : Json, name~ : String, params~ : Map[String, Json])
  Notification(name~ : String, params~ : Map[String, Json])
  Response
  Unparseable(String)
  Malformed(id~ : Json, reason~ : String)
}

///|
priv struct RpcError {
  code : Int32
  message : String
  data : Json?
}

///|
let parse_error_code : Int32 = -32700

///|
let invalid_request_code : Int32 = -32600

///|
let method_not_found_code : Int32 = -32601

///|
let invalid_params_code : Int32 = -32602

///|
let unsupported_version_code : Int32 = -32022

///|
fn RpcError::new(code : Int32, message : String, data? : Json) -> RpcError {
  { code, message, data, }
}

///|
fn parse_error(reason : String) -> RpcError {
  RpcError::new(parse_error_code, "Parse error: \{reason}")
}

///|
fn invalid_request(reason : String) -> RpcError {
  RpcError::new(invalid_request_code, "Invalid Request: \{reason}")
}

///|
fn method_not_found(name : String) -> RpcError {
  RpcError::new(method_not_found_code, "Method not found: \{name}")
}

///|
fn invalid_params(message : String) -> RpcError {
  RpcError::new(invalid_params_code, message)
}

///|
fn unsupported_version(requested : String) -> RpcError {
  RpcError::new(unsupported_version_code, "Unsupported protocol version", data={
    "supported": Json::array(supported_versions().map(v => Json(v))),
    "requested": Json(requested),
  })
}

///|
fn result_response(id : Json, result : Json) -> Json {
  { "jsonrpc": "2.0", "id": id, "result": result }
}

///|
fn error_response(id : Json, error : RpcError) -> Json {
  let fields : Array[(String, Json)] = [
    ("code", Json(error.code)),
    ("message", Json(error.message)),
  ]
  if error.data is Some(data) {
    fields.push(("data", data))
  }
  { "jsonrpc": "2.0", "id": id, "error": Json::object(Map::from_array(fields)) }
}

///|
fn parse_message(line : String) -> Message {
  let json = @json.parse(line) catch { err => return Unparseable("\{err}") }
  guard json is Object(fields) else {
    return Malformed(id=Json::null(), reason="a message must be a JSON object")
  }
  let id = fields.get("id")
  let usable_id = match id {
    Some(String(_) as i) | Some(Number(_) as i) => i
    _ => Json::null()
  }
  guard fields.get("jsonrpc") is Some(String("2.0")) else {
    return Malformed(id=usable_id, reason="`jsonrpc` must be \"2.0\"")
  }
  guard fields.get("method") is Some(String(name)) else {
    // A peer's response to a request this server never sent carries no method.
    return if fields.contains("result") || fields.contains("error") {
      Response
    } else {
      Malformed(id=usable_id, reason="`method` must be a string")
    }
  }
  let params = match fields.get("params") {
    None | Some(Null) => Map([])
    Some(Object(p)) => p
    Some(_) =>
      return Malformed(id=usable_id, reason="`params` must be an object")
  }
  match id {
    None => Notification(name~, params~)
    Some(String(_) as i) | Some(Number(_) as i) => Request(id=i, name~, params~)
    Some(_) =>
      Malformed(id=Json::null(), reason="`id` must be a string or a number")
  }
}