plum

module std

import std/Buffer

import std/Json

import std/List

import std/Map

import std/Option

import std/Result

import std/Str

import std/Bool

import std/Number

# An HTTP response: status code, response headers, and the raw response

# body as a `Str` (a byte array, so binary bodies round-trip intact).

enum Response =

  | Response(status: Int, headers: Map[Str, Str], body: Str)

  # 2xx status codes are success; everything else (redirects, 4xx, 5xx) is

  # surfaced here rather than as an `Err` from `request` — a non-2xx

  # response is still a complete, well-formed HTTP exchange, not a failed

  # one (`request` itself only fails for transport-level problems like a

  # DNS/connection error).

  fun ok(self) -> Bool =

    self.status >= 200 && self.status < 300

  # Parses `body` as JSON. Fails the same way `Json.fromStr` does for a

  # response body that isn't valid JSON.

  fun json(self) -> Result[Json, JsonParseError] =

    return Json.fromStr(self.body)

fun emptyHeaders() -> Map[Str, Str] =

  return Map[Str, Str]()

# A single blocking network round trip — this VM has no async/event-loop

# mechanism, so `rawHttpRequest` runs to completion before returning (same

# idea as `libs/std/os.plum`'s `rawReadFile`). `headers` is `"Key: Value"`

# lines joined by `\n` (`""` for none). The result packs an outcome flag,

# then either the status code and response headers (success) or an error

# message (failure), as fields joined by `\x01`, up to the first `\x00` —

# everything after that byte is the raw response body. `\x00`/`\x01` can

# never occur in the metadata fields themselves (the flag/status are

# decimal digits, header names/values and the error message are always

# plain text), so they safely mark where the opaque body bytes start even

# when the body itself is arbitrary binary data.

extern fun rawHttpRequest(method: Str, url: Str, headers: Str, body: Str) -> Str

# Packs `headers` into the `"Key: Value"`-per-line format `rawHttpRequest`

# expects for its own `headers` argument.

fun encodeHeaders(headers: Map[Str, Str]) -> Str =

  buf := Buffer()

  headers.each(|k, v|

    if buf.length() > 0

      buf.write("\n")

    buf.write(k)

    buf.write(": ")

    buf.write(v))

  return buf.toStr()

# The reverse of `encodeHeaders`, for the response headers `rawHttpRequest`

# packs into its result.

fun decodeHeaders(raw: Str) -> Map[Str, Str] =

  result := emptyHeaders()

  if raw == ""

    return result

  raw.split("\n", 0).each(|line|

    idx := line.indexOf(": ")

    if idx >= 0

      key := line.sub(0, idx)

      val := line.sub(idx + 2, line.length())

      result.set(key, val))

  return result

# Performs a single HTTP request and waits for the full response. Fails

# only for a transport-level problem (DNS failure, connection refused, TLS

# error, ...) — an HTTP-level error status (404, 500, ...) is still a

# successful round trip, returned as `Ok(Response(...))` with that status

# (check `Response.ok()`).

fun request(method: Str, url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =

  raw := rawHttpRequest(method, url, encodeHeaders(headers), body)

  sep := raw.indexOf("\x00")

  meta := sep >= 0 ? raw.sub(0, sep) : raw

  resp_body := sep >= 0 ? raw.sub(sep + 1, raw.length()) : ""

  parts := meta.split("\x01", 3)

  flag := parts.get(0).unwrapOr("")

  if flag != "1"

    return Err(parts.get(2).unwrapOr("http request failed"))

  match parseInt(parts.get(1).unwrapOr(""))

    Ok(status) =>

      return Ok(Response(status: status, headers: decodeHeaders(parts.get(2).unwrapOr("")), body: resp_body))

    Err(e) =>

      return Err("invalid status code in http response: {e}")

fun get(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =

  return request("GET", url, headers, "")

fun head(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =

  return request("HEAD", url, headers, "")

fun delete(url: Str, headers: Map[Str, Str]) -> Result[Response, Str] =

  return request("DELETE", url, headers, "")

fun post(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =

  return request("POST", url, headers, body)

fun put(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =

  return request("PUT", url, headers, body)

fun patch(url: Str, headers: Map[Str, Str], body: Str) -> Result[Response, Str] =

  return request("PATCH", url, headers, body)

# Convenience wrapper: sends `body` as a JSON `Str`, adding a

# `Content-Type: application/json` header, and parses the response back as

# JSON via `Response.json()`.

fun postJson(url: Str, headers: Map[Str, Str], body: Json) -> Result[Response, Str] =

  headers.set("Content-Type", "application/json")

  return post(url, headers, body.toStr())

test "encodeHeaders/decodeHeaders round-trip a header map"

  h := emptyHeaders()

  h.set("Content-Type", "application/json")

  h.set("Accept", "*/*")

  decoded := decodeHeaders(encodeHeaders(h))

  assert decoded.get("Content-Type").unwrap() == "application/json"

  assert decoded.get("Accept").unwrap() == "*/*"

test "decodeHeaders returns an empty map for an empty string"

  assert decodeHeaders("").isEmpty() == True

test "get performs a real HTTP round trip"

  match get("https://httpbin.org/get", emptyHeaders())

    Ok(resp) =>

      assert resp.ok() == True

      assert resp.status == 200

    Err(_) =>

      assert True == False

test "get reports a non-2xx status without failing the request"

  match get("https://httpbin.org/status/404", emptyHeaders())

    Ok(resp) =>

      assert resp.ok() == False

      assert resp.status == 404

    Err(_) =>

      assert True == False

test "post sends a body and the server echoes it back"

  match post("https://httpbin.org/post", emptyHeaders(), "hello world")

    Ok(resp) =>

      assert resp.ok() == True

      match resp.json()

        Ok(j) =>

          assert j.asMap().unwrap().get("data").unwrap().asStr().unwrap() == "hello world"

        Err(_) =>

          assert True == False

    Err(_) =>

      assert True == False

test "request fails for an unreachable host"

  match get("http://this-host-does-not-exist.invalid/", emptyHeaders())

    Ok(_) =>

      assert True == False

    Err(_) =>

      assert True == True