//! Unix-specific system calls and utilities.

use std::intrinsics;

/// File access modes.

// TODO: Use unlabeled struct.

pub record OpenFlags {

    value: i32,

}

/// Open file for reading only.

pub const O_RDONLY: OpenFlags = OpenFlags { value: 0 };

/// Open file for writing only.

pub const O_WRONLY: OpenFlags = OpenFlags { value: 1 };

/// Open file for reading and writing.

pub const O_RDWR: OpenFlags = OpenFlags { value: 2 };

/// Create file if it doesn't exist.

pub const O_CREAT: OpenFlags = OpenFlags { value: 64 };

/// Truncate file to zero length.

pub const O_TRUNC: OpenFlags = OpenFlags { value: 512 };

/// Standard file descriptor for stdin.

pub const STDIN: i32 = 0;

/// Standard file descriptor for stdout.

pub const STDOUT: i32 = 1;

/// Standard file descriptor for stderr.

pub const STDERR: i32 = 2;

/// Special value representing current working directory for `openat()`.

const AT_FDCWD: i32 = -100;

/// Opens a file at the given path and returns a file descriptor.

/// Returns a negative value on error.

pub fn open(path: *[u8], flags: OpenFlags) -> i32 {

    return intrinsics::ecall(56, AT_FDCWD, path.ptr as i32, flags.value, 0);

}

/// Opens a file at the given path with mode, returns a file descriptor.

pub fn openOpts(path: *[u8], flags: OpenFlags, mode: i32) -> i32 {

    return intrinsics::ecall(56, AT_FDCWD, path.ptr as i32, flags.value, mode);

}

/// Reads from a file descriptor into the provided buffer.

/// Returns the number of bytes read, or a negative value on error.

pub fn read(fd: i32, buf: *mut [u8]) -> i32 {

    return intrinsics::ecall(63, fd, buf.ptr as i32, buf.len as i32, 0);

}

/// Reads from a file descriptor until EOF or buffer is full.

/// Returns the total number of bytes read, or a negative value on error.

pub fn readToEnd(fd: i32, buf: *mut [u8]) -> i32 {

    let mut total: u32 = 0;

    while total < buf.len {

        let chunk = &mut buf[total..];

        let n = read(fd, chunk);

        if n < 0 {

            return n;

        }

        if n == 0 {

            break;

        }

        total += n as u32;

    }

    return total as i32;

}

/// Writes to a file descriptor from the provided buffer.

/// Returns the number of bytes written, or a negative value on error.

pub fn write(fd: i32, buf: *[u8]) -> i32 {

    return intrinsics::ecall(64, fd, buf.ptr as i32, buf.len as i32, 0);

}

/// Closes a file descriptor.

/// Returns `0` on success, or a negative value on error.

pub fn close(fd: i32) -> i32 {

    return intrinsics::ecall(57, fd, 0, 0, 0);

}

/// Reads the entire contents of a file at the given path into the provided buffer.

/// Returns a slice containing the data read, or `nil` on error.

pub fn readFile(path: *[u8], buf: *mut [u8]) -> ?*[u8] {

    let fd = open(path, O_RDONLY);

    if fd < 0 {

        return nil;

    }

    let n = readToEnd(fd, buf);

    if close(fd) < 0 {

        return nil;

    }

    if n < 0 {

        return nil;

    }

    return &buf[..(n as u32)];

}

/// Exit the current process with the given status code.

pub fn exit(status: i32) {

    intrinsics::ecall(93, status, 0, 0, 0);

}

/// Writes the entire contents of a buffer to a file at the given path.

/// Creates the file if it doesn't exist, truncates if it does.

/// Returns `true` on success.

pub fn writeFile(path: *[u8], data: *[u8]) -> bool {

    let flags = OpenFlags {

        value: O_WRONLY.value | O_CREAT.value | O_TRUNC.value

    };

    let fd = openOpts(path, flags, 420); // 0644 in octal.

    if fd < 0 {

        return false;

    }

    let mut written: u32 = 0;

    while written < data.len {

        let chunk = &data[written..];

        let n = write(fd, chunk);

        if n <= 0 {

            close(fd);

            return false;

        }

        written += n as u32;

    }

    close(fd);

    return true;

}