#include "lua_Process.h"

static DFHack::Process* GetProcessPtr(lua::state &st)
{
	return DFHack::Core::getInstance().p;
}

static int lua_Process_readDWord(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	uint32_t ret=c->readDWord( (void *) st.as<uint32_t>(1));
	st.push(ret);
	return 1;
}
static int lua_Process_writeDWord(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    c->writeDWord((void *) st.as<uint32_t>(1),st.as<uint32_t>(2));
	return 0;
}
static int lua_Process_readFloat(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    float ret=c->readFloat((void *) st.as<uint32_t>(1));
	st.push(ret);
	return 1;
}

static int lua_Process_readWord(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    uint16_t ret=c->readWord((void *) st.as<uint32_t>(1));
	st.push(ret);
	return 1;
}

static int lua_Process_writeWord(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    c->writeWord((void *) st.as<uint32_t>(1),st.as<uint16_t>(2));
	return 0;
}
static int lua_Process_readByte(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    uint8_t ret=c->readByte((void *) st.as<uint32_t>(1));
	st.push(ret);
	return 1;
}

static int lua_Process_writeByte(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    c->writeByte((void *) st.as<uint32_t>(1),st.as<uint8_t>(2));
	return 0;
}
static int lua_Process_read(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	size_t len=st.as<uint32_t>(2);
	uint8_t* buf;
	
	if(!st.is<lua::nil>(3))
		buf=(uint8_t*)lua_touserdata(st,3);
	else
		buf=new uint8_t[len];
    c->read((void *) st.as<uint32_t>(1),len,buf);
	st.pushlightuserdata(buf);
	return 1;
}
static int lua_Process_write(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    c-> write((void *) st.as<uint32_t>(1),st.as<uint32_t>(2),static_cast<uint8_t*>(lua_touserdata(st,3)));
	return 0;
}
static int lua_Process_readSTLString (lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    std::string r=c->readSTLString((void *) st.as<uint32_t>(1));
	st.push(r);
	return 1;
}

static int lua_Process_writeSTLString(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    c->writeSTLString((void *) st.as<uint32_t>(1),st.as<std::string>(2));
	return 0;
}
static int lua_Process_copySTLString(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    c->copySTLString((void *) st.as<uint32_t>(1),st.as<uint32_t>(2));
	return 0;
}
static int lua_Process_doReadClassName(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	std::string r=c->doReadClassName((void*)st.as<size_t>(1));
	st.push(r);
	return 1;
}
static int lua_Process_readClassName(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	std::string r=c->readClassName((void*)st.as<size_t>(1));
	st.push(r);
	return 1;
}
static int lua_Process_readCString (lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
    std::string r=c->readCString((void *) st.as<uint32_t>(1));
	st.push(r);
	return 1;
}
static int lua_Process_isSuspended(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	st.push(c->isSuspended());
	return 1;
}
static int lua_Process_isIdentified(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	st.push(c->isIdentified());
	return 1;
}
static int lua_Process_getThreadIDs(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	std::vector<uint32_t> threads;
	c->getThreadIDs(threads);
	st.newtable();
	for(size_t i=0;i<threads.size();i++)
	{
		st.push(i);
		st.push(threads[i]);
		st.settable();
	}
	return 1;
}
static int lua_Process_getMemRanges(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	std::vector<DFHack::t_memrange> ranges;
	c->getMemRanges(ranges);
	st.newtable();
	for(size_t i=0;i<ranges.size();i++)
	{
		st.push(i);
		st.newtable();
		st.push((uint32_t)ranges[i].start); // WARNING!! lua has only 32bit numbers, possible loss of data!!
		st.setfield("start");
        st.push((uint32_t)ranges[i].end);
		st.setfield("end");
		st.push(std::string(ranges[i].name));
		st.setfield("name");
		st.push(ranges[i].read);
		st.setfield("read");
		st.push(ranges[i].write);
		st.setfield("write");
		st.push(ranges[i].execute);
		st.setfield("execute");
		st.push(ranges[i].shared);
		st.setfield("shared");
		st.push(ranges[i].valid);
		st.setfield("valid");
		st.settable();
	}
	return 1;
}
static int lua_Process_getBase(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	uint32_t base=c->getBase();
	st.push(base);
	return 1;
}
/*static int lua_Process_getPID(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	int ret=c->getPID();
	st.push(ret);
	return 1;
}*/
static int lua_Process_getPath(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	std::string ret=c->getPath();
	st.push(ret);
	return 1;
}
static int lua_Process_setPermisions(lua_State *S)
{
	lua::state st(S);
	DFHack::Process* c=GetProcessPtr(st);
	DFHack::t_memrange range,trange;

	st.getfield("start",1);
	range.start= (void *)st.as<uint64_t>();
	st.pop();
	st.getfield("end",1);
	range.end= (void *)st.as<uint64_t>();
	st.pop();

	st.getfield("read",2);
	trange.read=st.as<bool>();
	st.pop();
	st.getfield("write",2);
	trange.write=st.as<bool>();
	st.pop();
	st.getfield("execute",2);
	trange.execute=st.as<bool>();
	st.pop();

	c->setPermisions(range,trange);

	return 0;
}
#define PROC_FUNC(name) {#name,lua_Process_ ## name}
const luaL_Reg lua_process_func[]=
{
	PROC_FUNC(readDWord),
	PROC_FUNC(writeDWord),
	PROC_FUNC(readFloat),
	PROC_FUNC(readWord),
	PROC_FUNC(writeWord),
	PROC_FUNC(readByte),
	PROC_FUNC(writeByte),
	PROC_FUNC(read),
	PROC_FUNC(write),
	PROC_FUNC(readSTLString),
	PROC_FUNC(writeSTLString),
	PROC_FUNC(copySTLString),
	PROC_FUNC(doReadClassName),
	PROC_FUNC(readClassName),
	PROC_FUNC(readCString ),
	PROC_FUNC(isSuspended),
	PROC_FUNC(isIdentified),
	PROC_FUNC(getThreadIDs),
	PROC_FUNC(getMemRanges),
	PROC_FUNC(getBase),
	//PROC_FUNC(getPID), //not implemented
	PROC_FUNC(getPath),
	PROC_FUNC(setPermisions),
	{NULL,NULL}
};
#undef PROC_FUNC
void lua::RegisterProcess(lua::state &st)
{
	st.getglobal("Process");
	if(st.is<lua::nil>())
	{
		st.pop();
		st.newtable();
	}

	lua::RegFunctionsLocal(st, lua_process_func);

	st.setglobal("Process");
}