#include <stdlib.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <unistd.h>

#include <dirent.h>

#include <errno.h>

#include <math.h>

#include <time.h>

#include <lua.h>

#include <lualib.h>

#include <lauxlib.h>

#define DIRCLASSNAME "dir*"

static void

setfield(lua_State *L, const char *attr, const char *key, lua_Integer n)

{

	if (attr == NULL || strcmp(attr, key) == 0)

		lua_pushinteger(L, n);

	if (attr == NULL)

		lua_setfield(L, -2, key);

}

static int

setstat(lua_State *L, int result, struct stat *s, const char *attr)

{

	if (result != 0)

	{

		lua_pushnil(L);

		lua_pushstring(L, strerror(errno));

		return 2;

	}

	if (attr == NULL)

		lua_newtable(L);

	setfield(L, attr, "dev", s->st_dev);

	setfield(L, attr, "ino", s->st_ino);

	if (attr == NULL || strcmp(attr, "mode") == 0)

	{

		if (S_ISREG(s->st_mode))

			lua_pushstring(L, "file");

		else if (S_ISDIR(s->st_mode))

			lua_pushstring(L, "directory");

		else if (S_ISLNK(s->st_mode))

			lua_pushstring(L, "link");

		else if (S_ISSOCK(s->st_mode))

			lua_pushstring(L, "socket");

		else if (S_ISFIFO(s->st_mode))

			lua_pushstring(L, "named pipe");

		else if (S_ISCHR(s->st_mode))

			lua_pushstring(L, "char device");

		else if (S_ISBLK(s->st_mode))

			lua_pushstring(L, "block device");

		else

			lua_pushstring(L, "other");

		if (attr == NULL)

			lua_setfield(L, -2, "mode");

	}

	setfield(L, attr, "nlink", s->st_nlink);

	setfield(L, attr, "uid", s->st_uid);

	setfield(L, attr, "gid", s->st_gid);

	setfield(L, attr, "rdev", s->st_rdev);

	setfield(L, attr, "access", s->st_atime);

	setfield(L, attr, "modifications", s->st_mtime);

	setfield(L, attr, "change", s->st_ctime);

	setfield(L, attr, "size", s->st_size);

	setfield(L, attr, "blocks", s->st_blocks);

	setfield(L, attr, "blksize", s->st_blksize);

	return 1;

}

static int 

posix_stat(lua_State *L)

{

	const char *path = luaL_checkstring(L, 1);

	const char *attr = luaL_optstring(L, 2, NULL);

	struct stat s;

	return setstat(L, stat(path, &s), &s, attr);

}	

static int 

posix_lstat(lua_State *L)

{

	const char *path = luaL_checkstring(L, 1);

	const char *attr = luaL_optstring(L, 2, NULL);

	struct stat s;

	return setstat(L, lstat(path, &s), &s, attr);

}

static int 

posix_opendir(lua_State *L)

{

	const char *path = luaL_checkstring(L, 1);

	DIR **pdir = lua_newuserdata(L, sizeof(void *));

	*pdir = NULL;

	lua_pushvalue(L, lua_upvalueindex(2)); /* class metatable */

	/* attach metatable to the userdata object */

	lua_setmetatable(L, -2); /* s: udata */

	/* create class instance */

	*pdir = opendir(path);

	if (*pdir == NULL)

	{

		lua_pushnil(L);

		lua_pushstring(L, strerror(errno));

		return 2;

	}

	return 1;

}

static DIR **

getinstptr(lua_State *L, int narg, const char *classname)

{

	DIR **pinst = luaL_checkudata(L, narg, classname);

	if (*pinst) return pinst;

	luaL_argerror(L, narg, "Closed handle");

	return NULL;

}

static int 

posix_closedir(lua_State *L)

{

	DIR **pdir = getinstptr(L, 1, DIRCLASSNAME);

	closedir(*pdir);

	*pdir = NULL;

	return 0;

}

static int 

posix_readdir(lua_State *L)

{

	DIR *dir = *getinstptr(L, 1, DIRCLASSNAME);

	struct dirent *de = readdir(dir);

	if (de)

		lua_pushstring(L, de->d_name);

	else

		lua_pushnil(L);

	return 1;

}

static int 

posix_readlink(lua_State *L)

{

	const char *path = luaL_checkstring(L, 1);

	char buf[PATH_MAX + 1];

	ssize_t len = readlink(path, buf, sizeof(buf) - 1);

	if (len < 0)

	{

		lua_pushnil(L);

		lua_pushstring(L, strerror(errno));

		return 2;

	}

	buf[len] = 0;

	lua_pushstring(L, buf);

	return 1;

}

static int 

posix_mkdir(lua_State *L)

{

	const char *path = luaL_checkstring(L, 1);

	if (mkdir(path, 0775) == 0)

	{

		lua_pushboolean(L, 1);

		return 1;

	}

	lua_pushnil(L);

	lua_pushstring(L, strerror(errno));

	return 2;

}

static int 

posix_symlink(lua_State *L)

{

	const char *oldpath = luaL_checkstring(L, 1);

	const char *newpath = luaL_checkstring(L, 2);

	if (symlink(oldpath, newpath) == 0)

	{

		lua_pushboolean(L, 1);

		return 1;

	}

	lua_pushnil(L);

	lua_pushstring(L, strerror(errno));

	return 2;

}

static int

resolvepath(const char *src, char *dest)

{

	int len = strlen(src);

	const char *sp = src + len;

	char *dp = dest;

	int dc = 0, slc = 0, eac = 0, wc = 0;

	int i, c;

	while (len--)	

	{

		c = *(--sp);

		switch (c)

		{

			case '/':

				if (dc == 2)

					eac++;

				dc = 0;

				slc = 1;

				wc = 0;

				break;

			case '.':

				if (slc)

				{

					dc++;

					break;

				}

				/* fallthru: */

			default:

				if (wc)

					break;

				if (slc)

				{

					slc = 0;

					if (eac > 0)

					{

						/* resolve one eatcount */

						eac--;

						/* now wait for next path part */

						wc = 1;

						break;

					}

					*dp++ = '/';

				}

				while (dc == 2 || dc == 1)

				{

					*dp++ = '.';

					dc--;

				}

				dc = 0;

				*dp++ = c;

				break;

		}

	}

	/* unresolved eatcount */

	if (eac)

		return 0;

	/* resolve remaining slash */

	if (slc)

		*dp++ = '/';

	*dp = 0;

	len = dp - dest;

	for (i = 0; i < len / 2; ++i)

	{

		char t = dest[i];

		dest[i] = dest[len - i - 1]; 

		dest[len - i - 1] = t;

	}

	return 1;

}

static int 

posix_abspath(lua_State *L)

{

	const char *path = luaL_checkstring(L, 1);

	char *pwd = NULL;

	size_t pwdsize = 16;

	for (;;)

	{

		char *newpwd = realloc(pwd, pwdsize);

		if (newpwd == NULL)

			break;

		pwd = newpwd;

		if (getcwd(pwd, pwdsize))

		{

			size_t len1 = strlen(pwd);

			size_t len2 = strlen(path);

			char *srcpath = malloc(len1 + 1 + len2 + 1);

			char *dstpath = malloc(len1 + 1 + len2 + 1);

			if (srcpath && dstpath)

			{

				int res;

				strcpy(srcpath, pwd);

				free(pwd);

				srcpath[len1] = '/';

				strcpy(srcpath + len1 + 1, path);

				res = resolvepath(srcpath, dstpath);

				free(srcpath);

				if (res)

				{

					lua_pushstring(L, dstpath);

					free(dstpath);

					return 1;			

				}

				free(dstpath);

				lua_pushnil(L);

				lua_pushstring(L, "Not a valid path");

				return 2;

			}

			free(srcpath);

			free(dstpath);

			break;

		}

		if (errno == ERANGE)

		{

			pwdsize <<= 1;

			continue;

		}

		lua_pushnil(L);

		lua_pushstring(L, strerror(errno));

		return 2;

	}

	free(pwd);

	luaL_error(L, "Out of memory");

	return 0;

}

static int 

posix_nanosleep(lua_State *L)

{

	struct timespec req;

	lua_Number d = luaL_checknumber(L, 1);

	req.tv_sec = (time_t) d;

	req.tv_nsec = (long) ((d - req.tv_sec) * 1000000000);

	if (nanosleep(&req, NULL) == 0)

	{

		lua_pushboolean(L, 1);

		return 1;

	}

	lua_pushnil(L);

	lua_pushstring(L, strerror(errno));

	return 2;

}

static const luaL_Reg lib[] =

{

	{ "stat", posix_stat },

	{ "lstat", posix_lstat },

	{ "opendir", posix_opendir },

	{ "closedir", posix_closedir },

	{ "readdir", posix_readdir },

	{ "mkdir", posix_mkdir },

	{ "readlink", posix_readlink },

	{ "symlink", posix_symlink },

	{ "abspath", posix_abspath },

	{ "nanosleep", posix_nanosleep },

	{ NULL, NULL }

};

static const luaL_Reg methods[] =

{

	{"read", posix_readdir },

	{"close", posix_closedir },

	{"__gc", posix_closedir },

	{NULL, NULL}

};

static void

addclass(lua_State *L, const char *libname, const char *classname,

	luaL_Reg *functions, luaL_Reg *methods, void *userdata)

{

	luaL_newmetatable(L, classname); /* classtab */

	lua_pushliteral(L, "__index"); /* classtab, "__index" */

	/* insert self: classtab.__index = classtab */

	lua_pushvalue(L, -2); /* classtab, "__index", classtab */

	lua_rawset(L, -3); /* classtab */

	/* insert methods. consume 1 userdata. do not create a new tab */

	lua_pushlightuserdata(L, userdata); /* classtab, userdata */

	luaL_openlib(L, NULL, methods, 1); /* classtab */

	/* first upvalue: userdata */

	lua_pushlightuserdata(L, userdata); /* classtab, userdata */

	/* duplicate table argument to be used as second upvalue for cclosure */

	lua_pushvalue(L, -2); /* classtab, userdata, classtab */

	/* insert functions */

	luaL_openlib(L, libname, functions, 2);	/* classtab, libtab */

	/* adjust stack */

	lua_pop(L, 2);	

}

int luaopen_tek_posix(lua_State *L)

{

	addclass(L, "tek.posix", DIRCLASSNAME,

		(luaL_Reg *) lib, (luaL_Reg *) methods, NULL);

	return 0;

}