import {
  args_get,
  args_sizes_get,
  environ_get,
  environ_sizes_get,
  proc_exit,
  fd_write,
  fd_close,
  fd_read,
  clock_time_get,
  clockid,
  errnoToString,
  fd
} from "bindings/wasi_snapshot_preview1";

import {
  E_INDEXOUTOFRANGE
} from "util/error";

// @ts-ignore: decorator
@lazy const iobuf = memory.data(4 * sizeof<usize>());

export namespace process {

  // @ts-ignore: decorator
  @lazy export const arch = sizeof<usize>() == 4 ? "wasm32" : "wasm64";

  // @ts-ignore: decorator
  @lazy export const platform = "wasm";

  // @ts-ignore: decorator
  @lazy export const argv = lazyArgv();

  // @ts-ignore: decorator
  @lazy export const env = lazyEnv();

  // @ts-ignore: decorator
  @lazy export var exitCode = 0;

  export function exit(code: i32 = exitCode): void {
    proc_exit(code);
  }

  // @ts-ignore: decorator
  @lazy export const stdin = changetype<ReadableStream>(0);
  // @ts-ignore: decorator
  @lazy export const stdout = changetype<WritableStream>(1);
  // @ts-ignore: decorator
  @lazy export const stderr = changetype<WritableStream>(2);

  export function time(): i64 {
    var err = clock_time_get(clockid.REALTIME, 1000000, iobuf);
    if (err) throw new Error(errnoToString(err));
    return load<u64>(iobuf) / 1000000;
  }

  export function hrtime(): u64 {
    var err = clock_time_get(clockid.MONOTONIC, 0, iobuf);
    if (err) throw new Error(errnoToString(err));
    return load<u64>(iobuf);
  }
}

function lazyArgv(): string[] {
  var err = args_sizes_get(iobuf, iobuf + sizeof<usize>());
  if (err) throw new Error(errnoToString(err));
  var count = load<usize>(iobuf);
  var ptrsSize = count * sizeof<usize>();
  var dataSize = load<usize>(iobuf, sizeof<usize>());
  var bufSize = ptrsSize + dataSize;
  var buf = __alloc(bufSize);
  err = args_get(buf, buf + ptrsSize);
  if (err) throw new Error(errnoToString(err));
  var count32 = <i32>count;
  var argv = new Array<string>(count32);
  for (let i = 0; i < count32; ++i) {
    let ptr = load<usize>(buf + i * sizeof<usize>());
    let str = String.UTF8.decodeUnsafe(ptr, ptr + bufSize - buf, true);
    argv[i] = str;
  }
  __free(buf);
  return argv;
}

function lazyEnv(): Map<string,string> {
  var err = environ_sizes_get(iobuf, iobuf + 4);
  if (err) throw new Error(errnoToString(err));
  var count = load<usize>(iobuf);
  var ptrsSize = count * sizeof<usize>();
  var dataSize = load<usize>(iobuf, sizeof<usize>());
  var bufSize = ptrsSize + dataSize;
  var buf = __alloc(bufSize);
  err = environ_get(buf, buf + ptrsSize);
  if (err) throw new Error(errnoToString(err));
  var env = new Map<string,string>();
  for (let i: usize = 0; i < count; ++i) {
    let ptr = load<usize>(buf + i * sizeof<usize>());
    let str = String.UTF8.decodeUnsafe(ptr, ptr + bufSize - buf, true);
    let pos = str.indexOf("=");
    if (~pos) {
      env.set(str.substring(0, pos), str.substring(pos + 1));
      // __dispose(changetype<usize>(str));
    } else {
      env.set(str, "");
    }
  }
  __free(buf);
  return env;
}

@unmanaged
abstract class Stream {
  close(): void {
    var err = fd_close(<u32>changetype<usize>(this));
    if (err) throw new Error(errnoToString(err));
  }
}

@unmanaged
abstract class WritableStream extends Stream {
  write<T>(data: T): void {
    if (isString<T>()) {
      writeString(<u32>changetype<usize>(this), changetype<string>(data));
    } else if (data instanceof ArrayBuffer) {
      writeBuffer(<u32>changetype<usize>(this), data);
    } else {
      ERROR("String or ArrayBuffer expected");
    }
  }
}

@unmanaged
abstract class ReadableStream extends Stream {
  read(buffer: ArrayBuffer, offset: isize = 0): i32 {
    var end = <usize>buffer.byteLength;
    if (offset < 0 || <usize>offset > end) {
      throw new Error(E_INDEXOUTOFRANGE);
    }
    store<usize>(iobuf, changetype<usize>(buffer) + offset);
    store<usize>(iobuf, end - offset, sizeof<usize>());
    var err = fd_read(<u32>changetype<usize>(this), iobuf, 1, iobuf + 2 * sizeof<usize>());
    if (err) throw new Error(errnoToString(err));
    return <i32>load<isize>(iobuf, 2 * sizeof<usize>());
  }
}

function writeBuffer(fd: fd, data: ArrayBuffer): void {
  store<usize>(iobuf, changetype<usize>(data));
  store<usize>(iobuf, data.byteLength, sizeof<usize>());
  var err = fd_write(<u32>fd, iobuf, 1, iobuf + 2 * sizeof<usize>());
  if (err) throw new Error(errnoToString(err));
}

function writeString(fd: fd, data: string): void {
  var char2 = -1;
  var char3 = -1;
  var char4 = -1;
  switch (data.length) {
    case 4: { // "null"
      char4 = <i32>load<u16>(changetype<usize>(data), 6);
      if (char4 >= 0x80) break;
    }
    case 3: { // "ms\n"
      char3 = <i32>load<u16>(changetype<usize>(data), 4);
      if (char3 >= 0x80) break;
    }
    case 2: { // "\r\n"
      char2 = <i32>load<u16>(changetype<usize>(data), 2);
      if (char2 >= 0x80) break;
    }
    case 1: { // "\n"
      let char1 = <i32>load<u16>(changetype<usize>(data));
      if (char1 >= 0x80) break;
      store<usize>(iobuf, iobuf + 2 * sizeof<usize>());
      store<usize>(iobuf, <i32>1 + i32(char2 != -1) + i32(char3 != -1) + i32(char4 != -1), sizeof<usize>());
      store<u32>(iobuf, char1 | char2 << 8 | char3 << 16 | char4 << 24, 2 * sizeof<usize>());
      let err = fd_write(<u32>fd, iobuf, 1, iobuf + 3 * sizeof<usize>());
      if (err) throw new Error(errnoToString(err));
    }
    case 0: return;
  }
  var utf8len = <usize>String.UTF8.byteLength(data);
  var utf8buf = __alloc(utf8len);
  assert(String.UTF8.encodeUnsafe(changetype<usize>(data), data.length, utf8buf) == utf8len);
  store<usize>(iobuf, utf8buf);
  store<usize>(iobuf, utf8len, sizeof<usize>());
  var err = fd_write(<u32>fd, iobuf, 1, iobuf + 2 * sizeof<usize>());
  __free(utf8buf);
  if (err) throw new Error(errnoToString(err));
}