module os

// low level operations with file descriptors/handles

$if !windows {
    #include <sys/select.h>
    #include <sys/ioctl.h>
}

$if windows {
    #include <winsock2.h>
}

#flag windows -lws2_32

// fd_close closes the file descriptor. It returns 0 on success.
pub fn fd_close(fd int) int {
    if fd == -1 {
        return 0
    }
    return C.close(fd)
}

// fd_write writes the given string to the file descriptor.
// It blocks until all the data in the string is written.
pub fn fd_write(fd int, s string) {
    if fd == -1 {
        return
    }
    mut sp := s.str
    mut remaining := s.len
    for remaining > 0 {
        written := int(C.write(fd, sp, remaining))
        if written < 0 {
            return
        }
        remaining = remaining - written
        sp = unsafe { voidptr(usize(sp) + usize(written)) }
    }
}

// fd_slurp reads all the remaining data from the file descriptor.
pub fn fd_slurp(fd int) []string {
    mut res := []string{}
    if fd == -1 {
        return res
    }
    for {
        s, b := fd_read(fd, 4096)
        if b <= 0 {
            break
        }
        res << s
    }
    return res
}

// fd_read reads data from the file descriptor. It returns the read data, and how many bytes were read.
// On signal interruption (EINTR), the read is retried so callers do not see spurious empty results
// when a signal (for example a Boehm GC stop-the-world signal in a multi-threaded program) interrupts
// a blocking read.
pub fn fd_read(fd int, maxbytes int) (string, int) {
    if fd == -1 {
        return '', 0
    }
    unsafe {
        mut buf := malloc_noscan(maxbytes + 1)
        mut nbytes := 0
        for {
            $if !windows {
                C.errno = 0
            }
            nbytes = int(C.read(fd, buf, maxbytes))
            if nbytes >= 0 {
                break
            }
            $if !windows {
                if C.errno == C.EINTR {
                    continue
                }
            }
            break
        }
        if nbytes < 0 {
            free(buf)
            return '', nbytes
        }
        buf[nbytes] = 0
        return tos(buf, nbytes), nbytes
    }
}

@[typedef]
pub struct C.fd_set {}

pub struct C.timeval {
pub:
    tv_sec  u64
    tv_usec u64
}

fn C.select(ndfs i32, readfds &C.fd_set, writefds &C.fd_set, exceptfds &C.fd_set, timeout &C.timeval) i32

$if !windows {
    fn C.ioctl(fd i32, request u64, args ...voidptr) i32
}

$if windows {
    fn C._get_osfhandle(fd int) voidptr
    fn C.PeekNamedPipe(hNamedPipe voidptr, lpBuffer voidptr, nBufferSize i32, lpBytesRead voidptr, lpTotalBytesAvail voidptr, lpBytesLeftThisMessage voidptr) bool
}

// These are C macros, but from the V's point of view, can be treated as C functions:
fn C.FD_ZERO(fdset &C.fd_set)
fn C.FD_SET(fd i32, fdset &C.fd_set)
fn C.FD_ISSET(fd i32, fdset &C.fd_set) i32

// fd_is_pending returns true, when there is pending data, waiting to be read from file descriptor `fd`.
// If the file descriptor is closed, or if reading from it, will block (there is no data), fd_is_pending returns false.
pub fn fd_is_pending(fd int) bool {
    if fd == -1 {
        return false
    }
    mut bytes_avail := int(0)
    $if windows {
        handle := voidptr(C._get_osfhandle(fd))
        if handle != voidptr(-1) {
            if C.PeekNamedPipe(handle, unsafe { nil }, int(0), unsafe { nil },
                voidptr(&bytes_avail), unsafe { nil })
            {
                return bytes_avail > 0
            }
        }
    } $else {
        if C.ioctl(fd, u64(C.FIONREAD), &bytes_avail) == 0 {
            return bytes_avail > 0
        }
    }
    read_set := C.fd_set{}
    C.FD_ZERO(&read_set)
    C.FD_SET(fd, &read_set)
    mut ts := C.timeval{
        tv_sec:  0
        tv_usec: 0
    }
    res := C.select(fd + 1, &read_set, C.NULL, C.NULL, &ts)
    if res > 0 {
        if C.FD_ISSET(fd, &read_set) != 0 {
            return true
        }
    }
    return false
}