module process

fn kill(args...) {
    if len(args) < 1 || len(args) > 2 {
        return error("process.kill: wrong number of arguments. got=" + inspect(len(args)) + ", want=1 or 2")
    }
    proc := args[0]
    target := nil
    if typing.is_int(proc) {
        target = proc
    } else if type(proc) == "MAP" && has(proc, "pid") {
        target = proc["pid"]
    } else {
        return error("process.kill expects proc map or pid, got " + type(proc))
    }
    if !typing.is_int(target) {
        return error("process.kill expects integer pid, got " + type(target))
    }
    sig := 9
    if len(args) == 2 {
        sig = args[1]
        if !typing.is_int(sig) {
            return error("process.kill expects integer signal, got " + type(sig))
        }
    }
    platform_key := platform()
    if platform_key == "darwin/amd64" || platform_key == "darwin/arm64" {
        return _kill_via_command(target, sig)
    }
    result := syscall("kill", target, sig)
    if is_error(result) {
        return _kill_via_command(target, sig)
    }
    return nil
}

fn pid() {
    return syscall("getpid")
}

fn run(args...) {
    stdout_pipe := _make_pipe()
    if is_error(stdout_pipe) {
        return stdout_pipe
    }
    stderr_pipe := _make_pipe()
    if is_error(stderr_pipe) {
        _close_pipe(stdout_pipe)
        return stderr_pipe
    }
    stdin_pipe := _make_pipe()
    if is_error(stdin_pipe) {
        _close_pipe(stdout_pipe)
        _close_pipe(stderr_pipe)
        return stdin_pipe
    }
    if len(args) < 1 || len(args) > 3 {
        _close_pipe(stdout_pipe)
        _close_pipe(stderr_pipe)
        _close_pipe(stdin_pipe)
        return error("process.run: wrong number of arguments. got=" + inspect(len(args)) + ", want=1 to 3")
    }
    cmd := args[0]
    if !typing.is_str(cmd) {
        _close_pipe(stdout_pipe)
        _close_pipe(stderr_pipe)
        _close_pipe(stdin_pipe)
        return error("process.run expects string cmd, got " + type(cmd))
    }
    argv := []
    opts := {}
    if len(args) >= 2 {
        second := args[1]
        if second == nil {
            argv = []
        } else if typing.is_list(second) {
            argv = second
        } else if type(second) == "MAP" && len(args) == 2 {
            opts = second
        } else {
            _close_pipe(stdout_pipe)
            _close_pipe(stderr_pipe)
            _close_pipe(stdin_pipe)
            return error("process.run expects list args or map opts, got " + type(second))
        }
    }
    if len(args) == 3 {
        opts = args[2]
        if opts == nil {
            opts = {}
        }
        if type(opts) != "MAP" {
            _close_pipe(stdout_pipe)
            _close_pipe(stderr_pipe)
            _close_pipe(stdin_pipe)
            return error("process.run expects map opts, got " + type(opts))
        }
    }
    i := 0
    while i < len(argv) {
        if type(argv[i]) != "STRING" {
            _close_pipe(stdout_pipe)
            _close_pipe(stderr_pipe)
            _close_pipe(stdin_pipe)
            return error("process.run expects string args, got " + type(argv[i]))
        }
        i = i + 1
    }
    stdin_text := _opts_get(opts, "stdin")
    if stdin_text != nil && type(stdin_text) != "STRING" {
        _close_pipe(stdout_pipe)
        _close_pipe(stderr_pipe)
        _close_pipe(stdin_pipe)
        return error("process.run opts.stdin must be string, got " + type(stdin_text))
    }
    if stdin_text == nil {
        _close_pipe(stdin_pipe)
        stdin_pipe = nil
    }
    close_fds := [_pipe_write_fd(stdin_pipe), _pipe_read_fd(stdout_pipe), _pipe_read_fd(stderr_pipe)]
    proc := _spawn_exec(cmd, argv, opts, _pipe_read_fd(stdin_pipe), _pipe_write_fd(stdout_pipe), _pipe_write_fd(stderr_pipe), close_fds)
    if is_error(proc) {
        _close_pipe(stdout_pipe)
        _close_pipe(stderr_pipe)
        _close_pipe(stdin_pipe)
        return proc
    }
    pid := proc["pid"]
    if !typing.is_int(pid) {
        _close_pipe(stdout_pipe)
        _close_pipe(stderr_pipe)
        _close_pipe(stdin_pipe)
        return error("process.run expected integer pid from spawn")
    }
    _close_fd(_pipe_write_fd(stdout_pipe))
    _close_fd(_pipe_write_fd(stderr_pipe))
    _close_fd(_pipe_read_fd(stdin_pipe))
    if stdin_text != nil {
        wrote := io.write(_pipe_write_fd(stdin_pipe), stdin_text)
        _close_fd(_pipe_write_fd(stdin_pipe))
        if is_error(wrote) {
            _close_fd(_pipe_read_fd(stdout_pipe))
            _close_fd(_pipe_read_fd(stderr_pipe))
            return wrote
        }
    }
    // Drain BOTH pipes to end of file before reaping the child. Waiting first
    // deadlocked on any child that produced more than one pipe buffer: the
    // child blocked in write(2) on the full pipe and never exited, and this
    // side blocked in wait(2) and never read. The reads must also be
    // concurrent with each other, or a child interleaving both streams can
    // fill whichever pipe is not currently being read.
    outs := io.read_all_each([_pipe_read_fd(stdout_pipe), _pipe_read_fd(stderr_pipe)])
    stdout := outs[0]
    stderr := outs[1]
    _close_fd(_pipe_read_fd(stdout_pipe))
    _close_fd(_pipe_read_fd(stderr_pipe))
    if is_error(stdout) {
        return stdout
    }
    if is_error(stderr) {
        return stderr
    }
    waited := nil
    if platform() == "darwin/arm64" {
        waited = wait(-1)
    } else {
        waited = wait(pid)
    }
    if is_error(waited) {
        return waited
    }
    return _result(waited["status"], stdout, stderr)
}

fn spawn(args...) {
    parsed := _parse_spawn_args(args)
    if is_error(parsed) {
        return parsed
    }
    return _spawn_exec(parsed["cmd"], parsed["args"], parsed["opts"], nil, nil, nil, nil)
}

fn wait(args...) {
    if len(args) != 1 {
        return error("process.wait: wrong number of arguments. got=" + inspect(len(args)) + ", want=1")
    }
    proc := args[0]
    pid := nil
    if typing.is_int(proc) {
        pid = proc
    } else if typing.is_map(proc) {
        if has(proc, "pid") {
            pid = proc["pid"]
        } else {
            return error("process.wait expects proc map with pid")
        }
        if has(proc, "waited") && proc["waited"] == true {
            return error("process.wait called twice on proc")
        }
    } else {
        return error("process.wait expects proc map or pid, got " + type(proc))
    }
    if !typing.is_int(pid) {
        return error("process.wait expects integer pid, got " + type(pid))
    }
    platform_key := platform()
    status_buf := buf(8)
    waited := nil
    if platform_key == "darwin/arm64" {
        waited = _wait4_blocking(pid, status_buf)
    } else {
        waited = syscall("wait4", pid, status_buf, 0, 0)
    }
    if type(waited) == "ERROR" && platform_key == "darwin/arm64" && pid != -1 {
        waited = _wait4_blocking(-1, status_buf)
    }
    if is_error(waited) {
        return waited
    }
    status := _decode_uint32_le(status_buf)
    code := _exit_code_from_status(status)
    if typing.is_map(proc) {
        proc["waited"] = true
    }
    return {"status": code}
}