/*

 Plan9 io interface routines
 

*/

#define _DEFAULT_SOURCE

#include <unistd.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <time.h>
#include <string.h>

#include "lil.h"

#define VAL_T size_t
#define smatch strcasecmp
#define RETERROR 0
#define PRINTMSG(STR) 
#define ERRORRETURN(i,MSG) {lil_set_error(i,MSG); return 0;}

static LILCALLBACK lil_value_t 
fnc_sleep(lil_t lil, size_t argc, lil_value_t* argv)
{ 
    int ret;
    lil_value_t retval;
	struct timespec req;

	if(argc != 1 ) {
        lil_set_error(lil, "sleep: specify ms of sleep time");
        return NULL;
    }
	size_t time = lil_to_integer(*argv++);
	if( time < 1)
		ERRORRETURN(lil,"Invalid time");
	req.tv_sec=time/1000;
	req.tv_nsec=(time-req.tv_sec)*1000;
	nanosleep(&req,NULL);	
	return 0;
}

static LILCALLBACK lil_value_t 
fnc_open(lil_t lil, size_t argc, lil_value_t* argv)
{ 
    lil_value_t retval;

	if(argc != 2 ) {
        lil_set_error(lil, "open: file mode");
        return NULL;
    }
	char *f = lil_to_string(*argv++);
	int mode = lil_to_integer(*argv++);
	int ret =open(f,mode);
	if( ret < 0) 
		ERRORRETURN(lil,"open failed");
    retval = lil_alloc_integer(ret);
    return retval;
}

static LILCALLBACK lil_value_t 
fnc_close(lil_t lil, size_t argc, lil_value_t* argv)
{ 
	if(argc != 1) {
        lil_set_error(lil, "close: fd");
        return NULL;
    }
	int fd = lil_to_integer(*argv);
	int ret =close(fd);
	if( ret < 0) 
		ERRORRETURN(lil,"close failed");
    return 0;
}


static LILCALLBACK lil_value_t 
fnc_read(lil_t lil, size_t argc, lil_value_t* argv)
{ 
    lil_value_t retval;

	if(argc != 2 )
		ERRORRETURN(lil,"read : fd len");
	int fd = lil_to_integer(*argv++);
	int len = lil_to_integer(*argv++);
	if( len < 1) 
		ERRORRETURN(lil,"Invalid read length");
	char *buff = malloc(len+2);

	int ret =read(fd,buff,len);
	if(ret == -1) 
		ERRORRETURN(lil,"read failed");
	buff[ret]=0;
    retval = lil_alloc_string(buff);
	free(buff);
    return retval;
}

static LILCALLBACK lil_value_t 
fnc_write(lil_t lil, size_t argc, lil_value_t* argv)
{ 
    lil_value_t retval;

	if(argc != 2 ) {
        lil_set_error(lil, "write: fd data");
        return NULL;
    }
	int fd = lil_to_integer(*argv++);
	char *data = lil_to_string(*argv++);
	if( fd < 0) 
		ERRORRETURN(lil,"Invalid fd");
	int ret =write(fd,data,strlen(data));
	if(ret == -1) 
		ERRORRETURN(lil,"write failed");
    retval = lil_alloc_integer(ret);
    return retval;
}

/*

 libp9 routines cause linker confusion so can't be compiled here
 bind is problematic either way

static LILCALLBACK lil_value_t 
fnc_mount(lil_t lil, size_t argc, lil_value_t* argv)
{
    size_t len = 0, size = 64;
    char* buffer;
    int ch;
    lil_value_t retval;

	if(argc < 3) {
        lil_set_error(lil, "Not enough arguments");
        return NULL;
    }

    buffer[len] = 0;
    retval = lil_alloc_string(buffer);
    return retval;
}

static LILCALLBACK lil_value_t 
fnc_unmount(lil_t lil, size_t argc, lil_value_t* argv)
{
    size_t len = 0, size = 64;
    char* buffer;
    int ch;
    lil_value_t retval;

	if(argc < 3) {
        lil_set_error(lil, "Not enough arguments");
        return NULL;
    }

    buffer[len] = 0;
    retval = lil_alloc_string(buffer);
    return retval;
}
*/

void
ioinit(lil_t lil) {

    lil_register(lil, "openfd", fnc_open);
    lil_register(lil, "closefd", fnc_close);
    lil_register(lil, "readfd", fnc_read);
    lil_register(lil, "writefd", fnc_write);
    lil_register(lil, "sleep", fnc_sleep);
}