#include <inc/lib.h>

const char *msg = "This is the NEW message of the day!\n\n";

#define FVA ((struct Fd*)0xCCCCC000)

static int
xopen(const char *path, int mode)
{
	extern union Fsipc fsipcbuf;
	envid_t fsenv;
	
	strcpy(fsipcbuf.open.req_path, path);
	fsipcbuf.open.req_omode = mode;

	fsenv = ipc_find_env(ENV_TYPE_FS);
	ipc_send(fsenv, FSREQ_OPEN, &fsipcbuf, PTE_P | PTE_W | PTE_U);
	return ipc_recv(NULL, FVA, NULL);
}

void
umain(int argc, char **argv)
{
	int r, f, i;
	struct Fd *fd;
	struct Fd fdcopy;
	struct Stat st;
	char buf[512];

	// We open files manually first, to avoid the FD layer
	if ((r = xopen("/not-found", O_RDONLY)) < 0 && r != -E_NOT_FOUND)
		panic("serve_open /not-found: %e", r);
	else if (r >= 0)
		panic("serve_open /not-found succeeded!");

	if ((r = xopen("/newmotd", O_RDONLY)) < 0)
		panic("serve_open /newmotd: %e", r);
	if (FVA->fd_dev_id != 'f' || FVA->fd_offset != 0 || FVA->fd_omode != O_RDONLY)
		panic("serve_open did not fill struct Fd correctly\n");
	cprintf("serve_open is good\n");

	if ((r = devfile.dev_stat(FVA, &st)) < 0)
		panic("file_stat: %e", r);
	if (strlen(msg) != st.st_size)
		panic("file_stat returned size %d wanted %d\n", st.st_size, strlen(msg));
	cprintf("file_stat is good\n");

	memset(buf, 0, sizeof buf);
	if ((r = devfile.dev_read(FVA, buf, sizeof buf)) < 0)
		panic("file_read: %e", r);
	if (strcmp(buf, msg) != 0)
		panic("file_read returned wrong data");
	cprintf("file_read is good\n");

	if ((r = devfile.dev_close(FVA)) < 0)
		panic("file_close: %e", r);
	cprintf("file_close is good\n");

	// We're about to unmap the FD, but still need a way to get
	// the stale filenum to serve_read, so we make a local copy.
	// The file server won't think it's stale until we unmap the
	// FD page.
	fdcopy = *FVA;
	sys_page_unmap(0, FVA);

	if ((r = devfile.dev_read(&fdcopy, buf, sizeof buf)) != -E_INVAL)
		panic("serve_read does not handle stale fileids correctly: %e", r);
	cprintf("stale fileid is good\n");

	// Try writing
	if ((r = xopen("/new-file", O_RDWR|O_CREAT)) < 0)
		panic("serve_open /new-file: %e", r);

	if ((r = devfile.dev_write(FVA, msg, strlen(msg))) != strlen(msg))
		panic("file_write: %e", r);
	cprintf("file_write is good\n");

	FVA->fd_offset = 0;
	memset(buf, 0, sizeof buf);
	if ((r = devfile.dev_read(FVA, buf, sizeof buf)) < 0)
		panic("file_read after file_write: %e", r);
	if (r != strlen(msg))
		panic("file_read after file_write returned wrong length: %d", r);
	if (strcmp(buf, msg) != 0)
		panic("file_read after file_write returned wrong data");
	cprintf("file_read after file_write is good\n");

	// Now we'll try out open
	if ((r = open("/not-found", O_RDONLY)) < 0 && r != -E_NOT_FOUND)
		panic("open /not-found: %e", r);
	else if (r >= 0)
		panic("open /not-found succeeded!");

	if ((r = open("/newmotd", O_RDONLY)) < 0)
		panic("open /newmotd: %e", r);
	fd = (struct Fd*) (0xD0000000 + r*PGSIZE);
	if (fd->fd_dev_id != 'f' || fd->fd_offset != 0 || fd->fd_omode != O_RDONLY)
		panic("open did not fill struct Fd correctly\n");
	cprintf("open is good\n");

	// Try files with indirect blocks
	if ((f = open("/big", O_WRONLY|O_CREAT)) < 0)
		panic("creat /big: %e", f);
	memset(buf, 0, sizeof(buf));
	for (i = 0; i < (NDIRECT*3)*BLKSIZE; i += sizeof(buf)) {
		*(int*)buf = i;
		if ((r = write(f, buf, sizeof(buf))) < 0)
			panic("write /big@%d: %e", i, r);
	}
	close(f);

	if ((f = open("/big", O_RDONLY)) < 0)
		panic("open /big: %e", f);
	for (i = 0; i < (NDIRECT*3)*BLKSIZE; i += sizeof(buf)) {
		*(int*)buf = i;
		if ((r = readn(f, buf, sizeof(buf))) < 0)
			panic("read /big@%d: %e", i, r);
		if (r != sizeof(buf))
			panic("read /big from %d returned %d < %d bytes",
			      i, r, sizeof(buf));
		if (*(int*)buf != i)
			panic("read /big from %d returned bad data %d",
			      i, *(int*)buf);
	}
	close(f);
	cprintf("large file is good\n");
}