#if defined(__mips__)
#include "../int.h"

void exit(int8_t status){
  asm ( 
    "move $a0, %0\n"
    "li $v0, 4001\n"
    "syscall\n"
    :
    : "r" (status)
    : "a0", "v0"
  );
  for(;;);
}

intptr_t write(int32_t fd, const void* buf, intptr_t size){
  intptr_t n_written = 0;
  asm volatile ( 
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "li $v0, 4004\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(n_written)
    : "r"(fd), "r"(buf), "r"(size)
    : "a0", "a1", "a2", "v0" //TODO: temp registers clobbered by syscall should probably also be listed but this fn returns right away so it should be fine?
  );
  return n_written;
}
intptr_t read(int32_t fd, const void* buf, intptr_t size){
  intptr_t n_read = 0;
  asm volatile ( 
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "li $v0, 4003\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(n_read)
    : "r"(fd), "r"(buf), "r"(size)
    : "a0", "a1", "a2", "v0", "memory" //TODO: temp registers clobbered by syscall should probably also be listed but this fn returns right away so it should be fine?
  );
  return n_read;
}

uint32_t fork(){
  int rtn;
  asm ( 
    "li $v0, 4002\n"
    "syscall\n"
    "move %0, $v0"
    :"=r" (rtn)
    : 
    : "a0", "v0"
  );
  return (uint32_t)rtn;
}

int32_t openat(int32_t fd, const char* filename, uint32_t flags, uint32_t mode) {
  int32_t file = 0;
  asm volatile (
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "move $a3, %4\n"
    "li $v0, 4288\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(file)
    : "r"(fd), "r"(filename), "r"(flags), "r"(mode)
    : "a0", "a1", "a2", "a3", "v0"
  );
  return file;
}

int close(unsigned int fd){
  int rtn = 0;
  asm ( 
    "move $a0, %1\n"
    "li $v0, 4006\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r" (fd)
    : "a0", "v0"
  );
  return rtn;
}

int fsync(unsigned int fd){
  int rtn = 0;
  asm ( 
    "move $a0, %1\n"
    "li $v0, 4118\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r" (fd)
    : "a0", "v0"
  );
  return rtn;
}

int socket(int domain, int type, int protocol){
  int sockfd = 0;
  asm volatile ( 
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "li $v0, 4183\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(sockfd)
    : "r"(domain), "r"(type), "r"(protocol)
    : "a0", "a1", "a2", "v0", "memory"
  );
  return sockfd;
}

int setsockopt(int sockfd, int level, int optname, const void* optval, socklen_t optlen){
  int rtn = 0;
  asm volatile (
    "li $v0, 4181\n"
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "move $a3, %4\n"
    "addiu $sp, $sp, -32\n"
    "sw %5, 16($sp)\n"
    "syscall\n"
    "addiu   $sp, $sp, 32\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r"(sockfd), "r"(level), "r"(optname), "r"(optval), "r"(optlen)
    : "a0", "a1", "a2", "a3", "t0", "v0"
  );
  return rtn;
}

int bind(int sockfd, const void* sockaddr, socklen_t addrlen) {
  int rtn = 0;
  asm volatile ( 
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "li $v0, 4169\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r"(sockfd), "r"(sockaddr), "r"(addrlen)
    : "a0", "a1", "a2", "v0"
  );
  return rtn;
}

int listen(int fd, int backlog) {
  int rtn = 0;
  asm volatile ( 
    "move $a0, %1\n"
    "move $a1, %2\n"
    "li $v0, 4174\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r"(fd), "r"(backlog)
    : "a0", "a1", "v0"
  );
  return rtn;
}

int accept(int sockfd, void* addr, socklen_t* addrlen) {
  int connfd = 0;
  asm volatile ( 
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "li $v0, 4168\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(connfd)
    : "r"(sockfd), "r"(addr), "r"(addrlen)
    : "a0", "a1", "a2", "v0", "memory"
  );
  return connfd;
}

int connect(int sockfd, void* addr, socklen_t addrlen) {
  int connfd = 0;
  asm volatile ( 
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "li $v0, 4170\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(connfd)
    : "r"(sockfd), "r"(addr), "r"(addrlen)
    : "a0", "a1", "a2", "v0"
  );
  return connfd;
}

ssize_t sendto(int sockfd, const void* buf, size_t size, int flags, const void* sockaddr, socklen_t addrlen){
  ssize_t rtn = 0;
  asm volatile (
    "li $v0, 4180\n"
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "move $a3, %4\n"
    "addiu $sp, $sp, -32\n"
    "sw %5, 16($sp)\n"
    "sw %6, 20($sp)\n"
    "syscall\n"
    "addiu   $sp, $sp, 32\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r"(sockfd), "r"(buf), "r"(size), "r"(flags), "r"(sockaddr), "r"(addrlen)
    : "a0", "a1", "a2", "a3", "t0", "t1", "v0"
  );
  return rtn;
}
ssize_t recvfrom(int sockfd, const void* buf, size_t size, int flags, const void* sockaddr, socklen_t addrlen){
  ssize_t rtn = 0;
  asm volatile (
    "li $v0, 4176\n"
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "move $a3, %4\n"
    "addiu $sp, $sp, -32\n"
    "sw %5, 16($sp)\n"
    "sw %6, 20($sp)\n"
    "syscall\n"
    "addiu   $sp, $sp, 32\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r"(sockfd), "r"(buf), "r"(size), "r"(flags), "r"(sockaddr), "r"(addrlen)
    : "a0", "a1", "a2", "a3", "t0", "t1", "v0", "memory"
  );
  return rtn;
}

int clock_settime(clockid_t clockid, const struct timespec *tp){
  int rtn = 0;
  asm volatile ( 
    "move $a0, %1\n"
    "move $a1, %2\n"
    "li $v0, 4262\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r"(clockid), "r"(tp)
    : "a0", "a1", "v0"
  );
  return rtn;
}
int clock_gettime(clockid_t clockid, struct timespec *tp){
  int rtn = 0;
  asm volatile ( 
    "move $a0, %1\n"
    "move $a1, %2\n"
    "li $v0, 4263\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r"(clockid), "r"(tp)
    : "a0", "a1", "v0", "memory"
  );
  return rtn;
}
int clock_getres(clockid_t clockid, struct timespec *res){
  int rtn = 0;
  asm volatile ( 
    "move $a0, %1\n"
    "move $a1, %2\n"
    "li $v0, 4264\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r"(clockid), "r"(res)
    : "a0", "a1", "v0", "memory"
  );
  return rtn;
}
int clock_nanosleep(clockid_t clockid, int flags, const struct timespec *t, struct timespec* remain){
  int rtn = 0;
  asm volatile (
    "move $a0, %1\n"
    "move $a1, %2\n"
    "move $a2, %3\n"
    "move $a3, %4\n"
    "li $v0, 4265\n"
    "syscall\n"
    "move %0, $v0\n"
    : "=r"(rtn)
    : "r"(clockid), "r"(flags), "r"(t), "r"(remain)
    : "a0", "a1", "a2", "a3", "v0", "memory"
  );
  return rtn;
}

#endif