plum

module std
import std/List
import std/Result
import std/Str
import std/Uuid
import std/Bool
import std/Number

# NOTE: the original file modeled `stdin`/`stdout`/`stderr` as bare top-level
# variable bindings and a `File(...)` constructor, but this language has no
# top-level `let` and `File` is never defined anywhere in the stdlib. Reduced
# to the underlying path so this at least parses; a real `File` type is
# still needed here.
fun stdin() -> Str =
  "/dev/stdin"

fun stdout() -> Str =
  "/dev/stdout"

fun stderr() -> Str =
  "/dev/stderr"

# Writes the specified data, followed by the current line terminator, to the
# standard output stream. `extern` means this compiles to a genuine wasm import
# (`plum::printLn`) instead of a Plum body — printing isn't expressible in wasm
# on its own; the embedding host (`plum-cli run`/`plum build`) provides it.
extern fun printLn(s: Str)

# Raw host-provided filesystem primitives — each maps to a genuine wasm
# import backed by a real OS call in the embedder (`plum-cli`/`plum-runtime`),
# not something expressible in wasm on its own (same idea as `printLn`).
# Returns `Int` (0/1), not `Bool`, for the success/failure ones — the host
# closure that satisfies a wasm import runs BEFORE the module is instantiated
# (it's part of setting up the imports an instance needs), so it has no way
# to reach the instance's own `True`/`False` singleton globals that `Bool`
# values are represented as in this codegen; a plain `i64` has no such
# problem. `rawReadFile` returns `""` for a file that doesn't exist or can't
# be read (there's no way to signal an error through a bare `Str` return);
# callers needing to tell "empty file" apart from "missing file" should check
# `exists` first, which every wrapper below does.
extern fun rawReadFile(path: Str) -> Str
extern fun rawWriteFile(path: Str, data: Str) -> Int
extern fun rawExists(path: Str) -> Int
extern fun rawMkdir(path: Str) -> Int
extern fun rawRemove(path: Str) -> Int
extern fun rawRemoveDir(path: Str) -> Int
extern fun rawRename(old_path: Str, new_path: Str) -> Int
extern fun rawTruncate(path: Str, len: Int) -> Int
extern fun rawLink(existing_path: Str, new_path: Str) -> Int
extern fun rawSymlink(target: Str, path: Str) -> Int
extern fun rawReadlink(path: Str) -> Str
extern fun rawRealpath(path: Str) -> Str
extern fun rawChmod(path: Str, mode: Int) -> Int
# Every directory entry's name (not full path), joined with `\n`; `""` for a
# missing/unreadable directory (same ambiguity `rawReadFile` already has with
# an empty file — `exists`/`readdir` below both check existence first).
extern fun rawReadDir(path: Str) -> Str

# Reads the whole file at `path` as a `Str` (`Str` is a byte array here — see
# `libs/std/str.plum` — so this works for binary content too, not just text).
fun readFile(path: Str) -> Result[Str, Str] =
  if !exists(path)
    return Err("no such file: '{path}'")
  return Ok(rawReadFile(path))

# Writes `data` to `path`, replacing its previous contents (or creating it).
fun writeFile(path: Str, data: Str) -> Result[Bool, Str] =
  if rawWriteFile(path, data) == 1
    return Ok(True)
  return Err("failed to write file: '{path}'")

fun exists(path: Str) -> Bool =
  return rawExists(path) == 1

fun mkdir(path: Str) -> Result[Bool, Str] =
  if rawMkdir(path) == 1
    return Ok(True)
  return Err("failed to create directory: '{path}'")

# Removes the file (not directory) at `path`.
fun remove(path: Str) -> Result[Bool, Str] =
  if !exists(path)
    return Err("no such file: '{path}'")
  if rawRemove(path) == 1
    return Ok(True)
  return Err("failed to remove: '{path}'")

# Whether `path` exists and is reachable — this VM has no notion of a
# process' effective uid/gid, so (unlike POSIX `access(2)`) there is no mode
# argument to check permission bits against.
fun access(path: Str) -> Bool =
  return exists(path)

# Appends `data` to the file at `path`, creating it (with just `data` as its
# contents) if it doesn't already exist. There's no host-level "open for
# append" primitive, so this reads the existing bytes and writes the
# concatenation back — not atomic, and O(existing file size) per call.
fun appendFile(path: Str, data: Str) -> Result[Bool, Str] =
  if exists(path)
    match readFile(path)
      Ok(existing) =>
        return writeFile(path, existing + data)
      Err(e) =>
        return Err(e)
  return writeFile(path, data)

# Unix permission bits only (e.g. `0o644`) — this VM has no Windows ACL
# equivalent to fall back to.
fun chmod(path: Str, mode: Int) -> Result[Bool, Str] =
  if rawChmod(path, mode) == 1
    return Ok(True)
  return Err("failed to chmod: '{path}'")

# There is no host primitive for changing file ownership (it needs a uid/gid
# syscall this VM doesn't expose), unlike the permission-bits-only `chmod`.
fun chown(path: Str, uid: Int, gid: Int) =
  todo

fun copyFile(src: Str, dest: Str) -> Result[Bool, Str] =
  match readFile(src)
    Ok(data) => writeFile(dest, data)
    Err(e) => Err(e)

fun cp(src: Str, dest: Str) -> Result[Bool, Str] =
  return copyFile(src, dest)

# Symlinks aren't modeled separately from regular files/dirs by this VM's
# host primitives (`rawChmod` always follows them), so this is the same as
# `chmod`.
fun lchmod(path: Str, mode: Int) -> Result[Bool, Str] =
  return chmod(path, mode)

# See `chown` — no uid/gid syscall exposed by this VM.
fun lchown(path: Str, uid: Int, gid: Int) =
  todo

# Setting a file's atime/mtime needs a syscall (`utimensat`/`SetFileTime`)
# this VM doesn't expose (`std::fs` itself has no equivalent either).
fun lutimes(path: Str, atime: Int, mtime: Int) =
  todo

fun link(existing_path: Str, new_path: Str) -> Result[Bool, Str] =
  if rawLink(existing_path, new_path) == 1
    return Ok(True)
  return Err("failed to link '{existing_path}' -> '{new_path}'")

# Would need a real `Stat` struct type (size/mode/mtime/uid/gid/...) to
# return anything useful — no such type exists in the stdlib yet.
fun lstat(path: Str) =
  todo

# Creates a fresh directory named `prefix` followed by a random suffix,
# retrying on the (astronomically unlikely) chance of a collision, and
# returns the path actually created.
fun mkdtemp(prefix: Str) -> Result[Str, Str] =
  path := prefix + v4().toStr()
  if exists(path)
    return mkdtemp(prefix)
  match mkdir(path)
    Ok(_) =>
      return Ok(path)
    Err(e) =>
      return Err(e)

# Would need a host-side open-file-descriptor table (this VM's other file
# ops are all one-shot: open+read/write+close in a single host call) plus a
# `File` handle type — neither exists yet.
fun open(path: Str, flags: Int) =
  todo

# See `open` — same missing handle-table/type problem, for directories.
fun opendir(path: Str) =
  todo

# The names of `path`'s directory entries (not full paths).
fun readdir(path: Str) -> Result[List[Str], Str] =
  if !exists(path)
    return Err("no such directory: '{path}'")
  # `reject`ing empty names handles both a genuinely empty directory (whose
  # joined `""` would otherwise split into one bogus `""` entry) and
  # `rawReadDir`'s "unreadable" fallback (already ruled out by the `exists`
  # check above) the same way — no directory entry is ever named `""`.
  return Ok(rawReadDir(path).split("\n", 0).reject(|n| n == ""))

fun readlink(path: Str) -> Result[Str, Str] =
  if !exists(path)
    return Err("no such file: '{path}'")
  return Ok(rawReadlink(path))

fun realpath(path: Str) -> Result[Str, Str] =
  if !exists(path)
    return Err("no such file: '{path}'")
  return Ok(rawRealpath(path))

fun rename(old_path: Str, new_path: Str) -> Result[Bool, Str] =
  if !exists(old_path)
    return Err("no such file: '{old_path}'")
  if rawRename(old_path, new_path) == 1
    return Ok(True)
  return Err("failed to rename '{old_path}' -> '{new_path}'")

# Removes an empty directory. (`remove` above covers plain files.)
fun rmdir(path: Str) -> Result[Bool, Str] =
  if !exists(path)
    return Err("no such directory: '{path}'")
  if rawRemoveDir(path) == 1
    return Ok(True)
  return Err("failed to remove directory: '{path}'")

# See `lstat` — needs a `Stat` struct type.
fun stat(path: Str) =
  todo

# Needs a filesystem-info struct type, same gap as `stat`.
fun statfs(path: Str) =
  todo

fun symlink(target: Str, path: Str) -> Result[Bool, Str] =
  if rawSymlink(target, path) == 1
    return Ok(True)
  return Err("failed to symlink '{path}' -> '{target}'")

# Resizes the file at `path` to exactly `len` bytes — truncated if shorter,
# zero-padded if longer.
fun truncate(path: Str, len: Int) -> Result[Bool, Str] =
  if !exists(path)
    return Err("no such file: '{path}'")
  if rawTruncate(path, len) == 1
    return Ok(True)
  return Err("failed to truncate: '{path}'")

# See `lutimes` — same missing syscall.
fun utimes(path: Str, atime: Int, mtime: Int) =
  todo

# Would need an async/callback mechanism to deliver filesystem change events
# into a running Plum program — nothing like that exists in this VM (every
# host call here is a synchronous, one-shot request/response).
fun watch(filename: Str) =
  todo

test "writeFile/readFile/appendFile/remove round-trip on a real file"
  match mkdtemp("/tmp/plum_os_test_")
    Ok(dir) =>
      path := dir + "/a.txt"
      assert writeFile(path, "hello").isOk() == True
      assert readFile(path).unwrap() == "hello"
      assert appendFile(path, " world").isOk() == True
      assert readFile(path).unwrap() == "hello world"
      assert exists(path) == True
      assert remove(path).isOk() == True
      assert exists(path) == False
      assert rmdir(dir).isOk() == True
    Err(_) =>
      assert True == False

test "copyFile/cp/rename move and duplicate file contents correctly"
  match mkdtemp("/tmp/plum_os_test_")
    Ok(dir) =>
      a := dir + "/a.txt"
      b := dir + "/b.txt"
      c := dir + "/c.txt"
      writeFile(a, "data")
      assert copyFile(a, b).isOk() == True
      assert readFile(b).unwrap() == "data"
      assert rename(b, c).isOk() == True
      assert exists(b) == False
      assert readFile(c).unwrap() == "data"
      remove(a)
      remove(c)
      rmdir(dir)
    Err(_) =>
      assert True == False

test "readdir lists the entries created in a fresh directory"
  match mkdtemp("/tmp/plum_os_test_")
    Ok(dir) =>
      assert readdir(dir).unwrap().length() == 0
      writeFile(dir + "/only.txt", "x")
      names := readdir(dir).unwrap()
      assert names.length() == 1
      assert names.join(",") == "only.txt"
      remove(dir + "/only.txt")
      rmdir(dir)
    Err(_) =>
      assert True == False

test "symlink/readlink/realpath resolve a linked file correctly"
  match mkdtemp("/tmp/plum_os_test_")
    Ok(dir) =>
      target := dir + "/target.txt"
      link_path := dir + "/link.txt"
      writeFile(target, "linked")
      assert symlink(target, link_path).isOk() == True
      assert readlink(link_path).unwrap() == target
      assert readFile(link_path).unwrap() == "linked"
      assert realpath(link_path).isOk() == True
      remove(link_path)
      remove(target)
      rmdir(dir)
    Err(_) =>
      assert True == False

test "truncate resizes a file's contents"
  match mkdtemp("/tmp/plum_os_test_")
    Ok(dir) =>
      path := dir + "/a.txt"
      writeFile(path, "hello world")
      assert truncate(path, 5).isOk() == True
      assert readFile(path).unwrap() == "hello"
      remove(path)
      rmdir(dir)
    Err(_) =>
      assert True == False

test "chmod changes a file's permission bits"
  match mkdtemp("/tmp/plum_os_test_")
    Ok(dir) =>
      path := dir + "/a.txt"
      writeFile(path, "x")
      assert chmod(path, 384).isOk() == True # 0o600
      remove(path)
      rmdir(dir)
    Err(_) =>
      assert True == False

test "link creates a second name for the same file"
  match mkdtemp("/tmp/plum_os_test_")
    Ok(dir) =>
      a := dir + "/a.txt"
      b := dir + "/b.txt"
      writeFile(a, "shared")
      assert link(a, b).isOk() == True
      assert readFile(b).unwrap() == "shared"
      remove(a)
      remove(b)
      rmdir(dir)
    Err(_) =>
      assert True == False

test "readFile/remove/rmdir report errors for missing paths"
  assert readFile("/tmp/plum_os_test_does_not_exist.txt").isErr() == True
  assert remove("/tmp/plum_os_test_does_not_exist.txt").isErr() == True
  assert rmdir("/tmp/plum_os_test_does_not_exist_dir").isErr() == True