#include "syscalls.h"

#include <stdint.h>
#include <stdio.h>
#include <string.h>

#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/termios.h>
#include <sys/dirent.h>

#include <errno.h>

// TODO ? all funct not preceeded with underscore should go as #defines
// inside headers! for newlib we define both here now ... //
// TODO: do we want all the wrappers here?
// TODO: how does the underscored and non-underscored versions work in gcc-linux
// lookup : ELF symbol interposion!

// FIRST SOME TRIVIAL BASICS //
// They do not even call the kernel at all //

/** everybody is root in Fool Os */
uid_t getuid(void)
{
    return 0;
}

/** everybody is root in Fool Os */
uid_t getgid(void)
{
    return 0;
}

/** everybody is root in Fool Os */
char *getlogin(void)
{
    return "root";
}

/** The hostname is hardcoded here. 
 *  Just recompile if you want to change this ;)
 */
int gethostname(char *name, size_t len)
{
    strcpy(name,"foolbox"); 
    return 0; //success
}

/** no sync required by our ram-image **/
void sync(void)
{
}

/** set working directory.
 *  We save it in PWD environment var */
int chdir(const char *path)
{
        char buf[256];
        sprintf(buf,"PWD=%s",path);
        putenv(buf);
        return 0; // assume success
}

/** get working dir (see chdir) */
char* getwd(char *buf)
{
        return strcpy(buf,getenv("PWD"));
}

/** HELPER for flushing stdout down the toilet when main exits.
    newlib does not do this ? TODO: check what the standard says. */
void _flushing()
{
    fflush(stdout);
}

// C NEWLIB // 

// here we have a few posix syscalls, mostly required by newlib 
// (we use version newlib-3.0.0.20180802)
// https://sourceware.org/newlib/libc.html#Syscalls
// just check liunx man-pages, how they SHOULD work.

/** holds environment variables */
extern char **environ;

// terminate caller
void _exit(int status)
{
    return syscall(SYSCALL_EXIT,status,0,0);
}

// close file
int _close(int file) 
{
    return syscall(SYSCALL_CLOSE,file,0,0);
}
int close(int file) 
{
    return syscall(SYSCALL_CLOSE,file,0,0);
}

// execute programm
int _execve(const char *filename, char *const argv[], char *const envp[]) 
{
    return syscall(SYSCALL_EXECVE,filename,argv,envp);
}
int execve(const char *filename, char *const argv[], char *const envp[]) 
{
    return syscall(SYSCALL_EXECVE,filename,argv,envp);
}

// create a child process
pid_t _fork(void)
{
    return syscall(SYSCALL_FORK,0,0,0);
}
pid_t fork(void)
{
    return syscall(SYSCALL_FORK,0,0,0);
}

int _fstat(int file, struct stat *st)
{
    return syscall(SYSCALL_FSTAT,file,st,0);
}
int fstat(int file, struct stat *st)
{
    return syscall(SYSCALL_FSTAT,file,st,0);
}

int _getpid(void)
{
    return syscall(SYSCALL_GETPID,0,0,0);
}
int getpid(void)
{
    return syscall(SYSCALL_GETPID,0,0,0);
}

int _isatty(int file) 
{
    return syscall(SYSCALL_ISATTY,file,0,0);
}
int isatty(int file) 
{
    return syscall(SYSCALL_ISATTY,file,0,0);
}

int _kill(int pid, int sig)
{
    return syscall(SYSCALL_KILL,pid,sig,0);
}
int kill(int pid, int sig)
{
    return syscall(SYSCALL_KILL,pid,sig,0);
}

int _link(char *old, char *ne)
{
    return syscall(SYSCALL_LINK,old,ne,0);
}
int link(char *old, char *ne)
{
    return syscall(SYSCALL_LINK,old,ne,0);
}

int _lseek(int file, int ptr, int dir) 
{
    return syscall(SYSCALL_LSEEK,file,ptr,dir);
}
int lseek(int file, int ptr, int dir) 
{
    return syscall(SYSCALL_LSEEK,file,ptr,dir);
}

int _open(const char *name, int flags, int mode)
{
    return syscall(SYSCALL_OPEN,name,flags,mode);
}
int open(const char *name, int flags, int mode)
{
    return syscall(SYSCALL_OPEN,name,flags,mode);
}

int _read(int file, char *ptr, int len)
{
    return syscall(SYSCALL_READ,file,ptr,len);
}
int read(int file, char *ptr, int len)
{
    return syscall(SYSCALL_READ,file,ptr,len);
}

uint32_t _sbrk(int incr) 
{
    return syscall(SYSCALL_SBRK,incr,0,0);
}
uint32_t sbrk(int incr) 
{
    return syscall(SYSCALL_SBRK,incr,0,0);
}

int _stat(const char *file, struct stat *st)
{
    return syscall(SYSCALL_STAT,file,st,0);
}
int stat(const char *file, struct stat *st)
{
    return syscall(SYSCALL_STAT,file,st,0);
}

int _times(struct tms *buf)
{
    return syscall(SYSCALL_TIMES,buf,0,0);
}
int times(struct tms *buf)
{
    return syscall(SYSCALL_TIMES,buf,0,0);
}

int _unlink(char *name)
{
    return syscall(SYSCALL_UNLINK,name,0,0);
}
int unlink(char *name)
{
    return syscall(SYSCALL_UNLINK,name,0,0);
}

int _wait(int *status)
{
    return syscall(SYSCALL_WAIT,status,0,0);
}
int wait(int *status)
{
    return syscall(SYSCALL_WAIT,status,0,0);
}

int _write(int file, char *ptr, int len) 
{
    return syscall(SYSCALL_WRITE,file,ptr,len);
}
int write(int file, char *ptr, int len) 
{
    return syscall(SYSCALL_WRITE,file,ptr,len);
}

int _gettimeofday(struct timeval *tv, void *tz)
{
    return syscall(SYSCALL_GETTIMEOFDAY,tv,tz,0);
}
int gettimeofday(struct timeval *tv, void *tz)
{
    return syscall(SYSCALL_GETTIMEOFDAY,tv,tz,0);
}

int _lstat(const char *file, struct stat *st)
{
    return syscall(SYSCALL_LSTAT,file,st,0);
}
int lstat(const char *file, struct stat *st)
{
    return syscall(SYSCALL_LSTAT,file,st,0);
}

/** works like fork() but keeps running mostly on the same memory so we 
 * have multithreading as well. */
int _clone(void)
{
    return syscall(SYSCALL_CLONE,0,0,0);
}

// DIRENT //
DIR *opendir(const char *name)
{
    DIR *dir=malloc(sizeof(struct dirent));
    return syscall(SYSCALL_OPENDIR,name,dir,0);
}

struct dirent *readdir(DIR *dirp)
{
    return syscall(SYSCALL_READDIR,dirp,0,0);
}

// TERMIOS //

int tcgetattr(int fd, struct termios *termios_p)
{
    return syscall(SYSCALL_TCGETATTR,fd,termios_p,0);
}

int tcsetattr(int fd, int optional_actions, const struct termios *termios_p)
{
    return syscall(SYSCALL_TCSETATTR,fd,termios_p,0);
}

speed_t cfgetospeed(const struct termios *termios_p)
{
    return B230400;
}

// I/O STUFF - Pipes et al // 

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
{
        // pack all our sets togehter
        fd_set *fd_sets[3];

        fd_sets[0]=readfds;
        fd_sets[1]=writefds;
        fd_sets[2]=exceptfds;

        return syscall(SYSCALL_SELECT,nfds,timeout,fd_sets);
}

int _pipe(uint32_t fds[2])
{
    return syscall(SYSCALL_PIPE,fds,0,0);
}
int pipe(uint32_t fds[2])
{
    return syscall(SYSCALL_PIPE,fds,0,0);
}
int _dup2(uint32_t oldfd,uint32_t newfd)
{
    return syscall(SYSCALL_DUP2,oldfd,newfd,0);
}
int dup2(uint32_t oldfd,uint32_t newfd)
{
    return syscall(SYSCALL_DUP2,oldfd,newfd,0);
}
int dup(int oldfd)
{
    return _dup2(oldfd,0xffffffff); // dup emulation mode 
}

// PRIMITIVE GUI SYSCALLS // 

/** create window for running process */
int _gui_win(uint32_t xy, uint32_t wh,uint32_t f)
{
    return syscall(SYSCALL_GUI_WIN,xy,wh,f);
}

/** invalidate screen rectangle and set user framebuffer addy
 *  we pack x,y and width,height togehter */
int _gui_inval(uint32_t xy, uint32_t wh, uint32_t addr)
{
    return syscall(SYSCALL_GUI_RECT,xy,wh,addr);
}

////////////////////////////////////////// move along fool ///////////
//
// ALL calls under this lines are just stubs to let some 3rd party  stuff
// compile and fail silently during runtime where applicable.
//
/////

long fpathconf(int fd, int name)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"fpathconf",0,0);
}

int tcflush(int fd, int queue_selector)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"tcflush",0,0);
}

int access(const char *pathname, int mode)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"access",0,0);
}

mode_t umask(mode_t mask)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"umask",0,0);
}

int mkdir(const char *pathname, mode_t mode)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"mkdir",0,0);
}

char *ttyname(int fd)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"ttyname",0,0);
}

int closedir(DIR *dirp)
{   
    return syscall(SYSCALL_UNIMPLEMENTED,"closedir",0,0);
}

unsigned int sleep(unsigned int seconds)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"sleep",0,0);
}

int pclose(FILE *stream)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"pclose",0,0);
}

FILE *popen(const char *command, const char *type)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"popen",0,0);
}

ssize_t readlink(const char *pathname, char *buf, size_t bufsiz)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"readlink",pathname,0);
}

int rmdir(const char *pathname)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"rmdir",0,0);
}

int fcntl(int fd, int cmd, ... /* arg */ )
{
    return syscall(SYSCALL_UNIMPLEMENTED,"fcntl",0,0);
}

pid_t waitpid(pid_t pid, int *wstatus, int options)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"waitpid",0,0);
}

int execl(const char *path, const char *arg, ...)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"execl",0,0);
}

int execvp(const char *file, char *const argv[])
{
    return syscall(SYSCALL_UNIMPLEMENTED,"execvp",0,0);
}

long sysconf(int name)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"sysconf",name,0);
}

int chmod(const char *pathname, mode_t mode)
{
    return syscall(SYSCALL_UNIMPLEMENTED,"chmod",pathname,mode);
}

/*
int tcsendbreak(int fd, int duration);
int tcdrain(int fd);
int tcflow(int fd, int action);
void cfmakeraw(struct termios *termios_p);
speed_t cfgetispeed(const struct termios *termios_p);
int cfsetispeed(struct termios *termios_p, speed_t speed);
int cfsetospeed(struct termios *termios_p, speed_t speed);
int cfsetspeed(struct termios *termios_p, speed_t speed);
*/