/**
 * Enable the I2C bus on 2 GPIO pins. Expect two integer
 * arguments, this first is the SDA gpio pin number and
 * the second is the SCL gpio pin number.
 * @param ctx the duktape context.
 * @return the name of the created i2c device.
 */
duk_ret_t i2c_enable_device(duk_context *ctx)
{
    char* buff[256];

    // Expect 2 arguments
    int n = duk_get_top(ctx);
    if(n != 2) {
        return DUK_RET_API_ERROR;
    }

    // Get the SDA and SDL pin number
    int sda_pin = duk_to_int(ctx, 0);
    int scl_pin = duk_to_int(ctx, 1);

    // Generate the insmod command
    sprintf(buff, "insmod i2c-gpio-custom bus0=0,%d,%d > /dev/null", sda_pin, scl_pin);

    // Insert the kernel modules
    system("insmod i2c-dev > /dev/null");
    system(buff);

    // Push the name of the i2c device to the stack.
    duk_push_string(ctx, "/dev/i2c-0");
    return 1;
}

static duk_ret_t duk_btnp(duk_context* duk)
{
	tic_machine* machine = getDukMachine(duk);
	tic_mem* memory = (tic_mem*)machine;

	if (duk_is_null_or_undefined(duk, 0))
	{
		duk_push_uint(duk, memory->api.btnp(memory, -1, -1, -1));
	}
	else if(duk_is_null_or_undefined(duk, 1) && duk_is_null_or_undefined(duk, 2))
	{
		s32 index = duk_to_int(duk, 0) & 0x1f;

		duk_push_boolean(duk, memory->api.btnp(memory, index, -1, -1));
	}
	else
	{
		s32 index = duk_to_int(duk, 0) & 0x1f;
		u32 hold = duk_to_int(duk, 1);
		u32 period = duk_to_int(duk, 2);

		duk_push_boolean(duk, memory->api.btnp(memory, index, hold, period));
	}

	return 1;
}

static int sys1_poll(duk_context *ctx)
{
	int nfds = duk_to_int(ctx, 1);
	int timeout = duk_to_int(ctx, 2);
	int i, rc;
	struct pollfd *fds;

	fds = malloc(sizeof(struct pollfd)*nfds);
	memset(fds, 0, sizeof(struct pollfd)*nfds);
	
	for(i=0;i<nfds;i++) {
		duk_get_prop_index(ctx, 0, i);
		duk_get_prop_string(ctx, 3, "fd");	
		fds[i].fd = duk_to_int(ctx, 4);
		duk_get_prop_string(ctx, 3, "events");	
		fds[i].events = duk_to_int(ctx, 5);
		duk_pop_n(ctx, 3);
	}

	rc = poll(fds, nfds, timeout);
	duk_push_object(ctx);
	duk_push_int(ctx, rc);
	duk_put_prop_string(ctx, -2, "rc");
	duk_dup(ctx, 0); // dup reference to arg0 array
	for(i=0;i<nfds;i++) {
		duk_get_prop_index(ctx, -1, i); // fetch object from array at i
		duk_push_int(ctx, fds[i].revents);
		duk_put_prop_string(ctx, -2, "revents"); // put revents into object
		duk_pop(ctx); // remove object from stack
	}
	duk_put_prop_string(ctx, -2, "fds");

	return 1;
}

static s32 duk_keyp(duk_context* duk)
{
	tic_machine* machine = getDukMachine(duk);
	tic_mem* tic = &machine->memory;

	if (duk_is_null_or_undefined(duk, 0))
	{
		duk_push_boolean(duk, tic->api.keyp(tic, tic_key_unknown, -1, -1));
	}
	else
	{
		tic_key key = duk_to_int(duk, 0);

		if(key >= tic_key_escape)
		{
			return duk_error(duk, DUK_ERR_ERROR, "unknown keyboard code\n");
		}
		else
		{
			if(duk_is_null_or_undefined(duk, 1) && duk_is_null_or_undefined(duk, 2))
			{
				duk_push_boolean(duk, tic->api.keyp(tic, key, -1, -1));
			}
			else
			{
				u32 hold = duk_to_int(duk, 1);
				u32 period = duk_to_int(duk, 2);

				duk_push_boolean(duk, tic->api.keyp(tic, key, hold, period));
			}
		}
	}

	return 1;
}

static void remapCallback(void* data, s32 x, s32 y, RemapResult* result)
{

	RemapData* remap = (RemapData*)data;
	duk_context* duk = remap->duk;

	duk_push_heapptr(duk, remap->remap);
	duk_push_int(duk, result->index);
	duk_push_int(duk, x);
	duk_push_int(duk, y);
	duk_pcall(duk, 3);

	if(duk_is_array(duk, -1))
	{
		duk_get_prop_index(duk, -1, 0);
		result->index = duk_to_int(duk, -1);
		duk_pop(duk);

		duk_get_prop_index(duk, -1, 1);
		result->flip = duk_to_int(duk, -1);
		duk_pop(duk);

		duk_get_prop_index(duk, -1, 2);
		result->rotate = duk_to_int(duk, -1);
		duk_pop(duk);
	}
	else
	{
		result->index = duk_to_int(duk, -1);		
	}

	duk_pop(duk);
}

/**
 * fd, buffer, offset, length, position
 */
static int
es_file_read(duk_context *ctx)
{
  es_fd_t *efd = es_fd_get(ctx, 0);
  duk_size_t bufsize;
  char *buf = duk_require_buffer_data(ctx, 1, &bufsize);

  const int offset = duk_to_int(ctx, 2);
  const int len = duk_to_int(ctx, 3);

  if(offset + len > bufsize)
    duk_error(ctx, DUK_ERR_ERROR, "Buffer too small %zd < %d + %d",
              bufsize, offset + len);

  if(!duk_is_null(ctx, 4)) {
    // Seek
    fa_seek(efd->efd_fh, duk_require_number(ctx, 4), SEEK_SET);
  }

  int r = fa_read(efd->efd_fh, buf + offset, len);
  if(r < 0)
    duk_error(ctx, DUK_ERR_ERROR, "Read error from '%s'", efd->efd_path);

  duk_push_int(ctx, r);
  return 1;
}

/**
 * fd, buffer, offset, length, position
 */
static int
es_file_write(duk_context *ctx)
{
  es_fd_t *efd = es_fd_get(ctx, 0);
  duk_size_t bufsize;
  char *buf = duk_to_buffer(ctx, 1, &bufsize);
  int len;

  const int offset = duk_to_int(ctx, 2);
  if(duk_is_null(ctx, 3)) {
    len = bufsize;
  } else {
    len = duk_to_int(ctx, 3);
  }

  // Don't read past buffer end
  if(offset + len > bufsize)
    len = bufsize - offset;

  if(!duk_is_null(ctx, 4)) {
    // Seek
    fa_seek(efd->efd_fh, duk_require_number(ctx, 4), SEEK_SET);
  }

  int r = fa_write(efd->efd_fh, buf + offset, len);
  if(r < 0)
    duk_error(ctx, DUK_ERR_ERROR, "Write error to '%s'", efd->efd_path);

  duk_push_int(ctx, r);
  return 1;
}

static int sys1_kill(duk_context *ctx)
{
	int pid = duk_to_int(ctx, 0);
	int sig = duk_to_int(ctx, 1);
	int rc;
	
	rc = kill(pid, sig);
	duk_push_int(ctx, rc);
	return 1;
}

static int ncurses_mvprintw(duk_context *ctx) {
	int y = duk_to_int(ctx, 0);
	int x = duk_to_int(ctx, 1);
	const char *str = duk_to_string(ctx, 2);
	int rc;

	rc = mvprintw(y, x, "%s", str);
	duk_push_int(ctx, rc);
	return 1;
}

static duk_ret_t duk_mget(duk_context* duk)
{
	s32 x = duk_is_null_or_undefined(duk, 0) ? 0 : duk_to_int(duk, 0);
	s32 y = duk_is_null_or_undefined(duk, 1) ? 0 : duk_to_int(duk, 1);

	tic_mem* memory = (tic_mem*)getDukMachine(duk);

	u8 value = memory->api.map_get(memory, &memory->ram.map, x, y);
	duk_push_uint(duk, value);
	return 1;
}

static int sys1_fchmod(duk_context *ctx)
{
	int fd = duk_to_int(ctx, 0);
	mode_t mode = duk_to_int(ctx, 1);
	int rc;

	rc = fchmod(fd, mode);

	duk_push_int(ctx, rc);
	return 1;
}

static int sys1_lseek(duk_context *ctx)
{
	int fd = duk_to_int(ctx, 0);
	off_t offset = duk_to_int(ctx, 1);
	int whence = duk_to_int(ctx, 2);
	off_t rc;

	rc = lseek(fd, offset, whence);

	duk_push_int(ctx, rc);
	return 1;
}

static int sys1_listen(duk_context *ctx)
{
	int rc;

	int fd = duk_to_int(ctx, 0);
	int backlog = duk_to_int(ctx, 1);

	rc = listen(fd, backlog);
	
	duk_push_number(ctx, rc);
	return 1;	
}

static int sys1_dup2(duk_context *ctx)
{
	int rc;

	int oldfd = duk_to_int(ctx, 0);
	int newfd = duk_to_int(ctx, 1);

	rc = dup2(oldfd, newfd);
	
	duk_push_number(ctx, rc);
	return 1;	
}

static duk_ret_t duk_rectb(duk_context* duk)
{
	s32 x = duk_to_int(duk, 0);
	s32 y = duk_to_int(duk, 1);
	s32 w = duk_to_int(duk, 2);
	s32 h = duk_to_int(duk, 3);
	s32 color = duk_to_int(duk, 4);

	tic_mem* memory = (tic_mem*)getDukMachine(duk);
	memory->api.rect_border(memory, x, y, w, h, color);

	return 0;
}

static duk_ret_t duk_clip(duk_context* duk)
{
	s32 x = duk_to_int(duk, 0);
	s32 y = duk_to_int(duk, 1);
	s32 w = duk_is_null_or_undefined(duk, 2) ? TIC80_WIDTH : duk_to_int(duk, 2);
	s32 h = duk_is_null_or_undefined(duk, 3) ? TIC80_HEIGHT : duk_to_int(duk, 3);

	tic_mem* memory = (tic_mem*)getDukMachine(duk);
	
	memory->api.clip(memory, x, y, w, h);

	return 0;
}

static int sys1_socket(duk_context *ctx)
{
	int fd;

	int domain = duk_to_int(ctx, 0);
	int type = duk_to_int(ctx, 1);
	int protocol = duk_to_int(ctx, 2);

	fd = socket(domain, type, protocol);
	
	duk_push_number(ctx, fd);
	return 1;	
}

static int sys1_write(duk_context *ctx)
{
	int fd = duk_to_int(ctx, 0);
	size_t bufsize;
	void *buf = duk_to_buffer(ctx, 1, &bufsize);
	int len = duk_to_int(ctx, 2);
	ssize_t rc;
	
	rc = write(fd, buf, len);

	duk_push_int(ctx, rc);
	return 1;
}

static duk_ret_t duk_map(duk_context* duk)
{
	s32 x = duk_is_null_or_undefined(duk, 0) ? 0 : duk_to_int(duk, 0);
	s32 y = duk_is_null_or_undefined(duk, 1) ? 0 : duk_to_int(duk, 1);
	s32 w = duk_is_null_or_undefined(duk, 2) ? TIC_MAP_SCREEN_WIDTH : duk_to_int(duk, 2);
	s32 h = duk_is_null_or_undefined(duk, 3) ? TIC_MAP_SCREEN_HEIGHT : duk_to_int(duk, 3);
	s32 sx = duk_is_null_or_undefined(duk, 4) ? 0 : duk_to_int(duk, 4);
	s32 sy = duk_is_null_or_undefined(duk, 5) ? 0 : duk_to_int(duk, 5);
	u8 chromakey = duk_is_null_or_undefined(duk, 6) ? -1 : duk_to_int(duk, 6);
	s32 scale = duk_is_null_or_undefined(duk, 7) ? 1 : duk_to_int(duk, 7);

	tic_mem* memory = (tic_mem*)getDukMachine(duk);

	if (duk_is_null_or_undefined(duk, 8))
		memory->api.map(memory, &memory->ram.map, &memory->ram.tiles, x, y, w, h, sx, sy, chromakey, scale);
	else
	{
		void* remap = duk_get_heapptr(duk, 8);

	 	RemapData data = {duk, remap};

	 	memory->api.remap((tic_mem*)getDukMachine(duk), &memory->ram.map, &memory->ram.tiles, x, y, w, h, sx, sy, chromakey, scale, remapCallback, &data);
	}

	return 0;
}

static duk_ret_t duk_line(duk_context* duk)
{
	s32 x0 = duk_to_int(duk, 0);
	s32 y0 = duk_to_int(duk, 1);
	s32 x1 = duk_to_int(duk, 2);
	s32 y1 = duk_to_int(duk, 3);
	s32 color = duk_to_int(duk, 4);

	tic_mem* memory = (tic_mem*)getDukMachine(duk);

	memory->api.line(memory, x0, y0, x1, y1, color);

	return 0;
}