#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <memory>
#include <map>
#include <functional>
extern "C" {
  #include <lua.h>
  #include <lauxlib.h>
  #include <lualib.h>
}
#include <btBulletDynamicsCommon.h>
#include <irrlicht.h>
#include <client/lua_api/gameparts.hpp>
#include <shared/lua_api/phys/bphysbox.hpp>
#include "bphysmodel.hpp"
#include "../scene/igeneric.hpp"
#include <shared/lua_api/common.hpp>

using namespace irr;
using namespace scene;
using namespace core;
using namespace video;

extern IrrlichtDevice* device;

extern btDiscreteDynamicsWorld* World;
extern core::list<btRigidBody*> Objects;

static LBPhysNode* checkisbphysmodel(lua_State* L, int index){
  void* ud = luaL_checkudata(L,index,"phys.physmodel");
  luaL_argcheck(L,ud != NULL, index, "'phys.physmodel' expected");
  return (LBPhysNode*) ud;
}

//iscenecamera.new(Vector position, Vector lookat, parrent)
// {} {} 0 1
static int newbphysmodel(lua_State* L){
	printf("Createing bphysbox!\n");
	int nargs = lua_gettop(L);
	if(nargs != 3){
		printf("Incorrect # of args to create a physmodel!");
	}
	//The model for the mesh
	//const char* modelpath = luaL_optstring(L,1,"error");

	double x,y,z;
	popvector3d(L,&x,&y,&z);
	printf("Found position for phys model: %f %f %f\n",x,y,z);
	
	//Find the vector scale
	double sx,sy,sz;
	popvector3d(L,&sx,&sy,&sz);
	printf("Found scale for phys model: %f %f %f\n",sx,sy,sz);
	
	//find the model path
	const char* mpath = luaL_optstring(L,3,"error.obj");
	
	printf("I want to use model %s\n", mpath);
	
	ISceneManager* smgr = device->getSceneManager();
	IMesh* amesh = smgr->getMesh(mpath);
	IMeshBuffer* bf = amesh->getMeshBuffer(0);
	u32 ni = bf->getIndexCount();

	btTriangleMesh* trimesh = new btTriangleMesh();
	for(u32 i = 0; i < ni; i+=3){
		vector3df p1 = bf->getPosition(i + 0);
		vector3df p2 = bf->getPosition(i + 1);
		vector3df p3 = bf->getPosition(i + 2);
		btVector3 b1 = btVector3(p1.X,p1.Y,p1.Z);
		btVector3 b2 = btVector3(p2.X,p2.Y,p2.Z);
		btVector3 b3 = btVector3(p3.X,p3.Y,p3.Z);
		trimesh->addTriangle(b1,b2,b3);
	}
	btCollisionShape* shape = new btConvexTriangleMeshShape(trimesh,true);
	core::vector3df scale = core::vector3df(sx,sy,sz);
	btVector3 pos = btVector3(x,y,z);
	core::vector3df ipos = core::vector3df(x,y,z);
	shape->setLocalScaling(btVector3(sx,sy,sz));
	//Find the mass
	float mass = luaL_optint(L,4,0);
	printf("Found mass for physbox:%f\n",mass);

	

	// Create an Irrlicht cube
	scene::ISceneNode* Node = smgr->addMeshSceneNode(
		amesh,
		(ISceneNode*)0,
		(s32)-1,
		ipos,
		vector3df(0,0,0),
		scale
	);
	//Node->setScale(scale);
    
    printf("Added cube scene node and set it's scale\n");

    //Node->setMaterialFlag(video::EMF_WIREFRAME,true)
	//Node->setMaterialFlag(video::EMF_NORMALIZE_NORMALS, true);
    Node->setMaterialFlag(video::EMF_LIGHTING,true);
	//Node->setMaterialTexture(0, device->getVideoDriver()->getTexture("../data/wall.jpg"));

    printf("Set node's lighting stuff...\n");

	// Set the initial position of the object
	btTransform Transform;
	Transform.setIdentity();
	Transform.setOrigin(pos);
    
    printf("Created transform at pos...\n");

	// Give it a default MotionState
	btDefaultMotionState *MotionState = new btDefaultMotionState(Transform);

	// Create the shape
	// btVector3 HalfExtents(sx * 0.5f, sy * 0.5f, sz * 0.5f);
	// btCollisionShape *Shape = new btBoxShape(HalfExtents);

    printf("Created collision shape...");
    
	// Add mass
	btVector3 LocalInertia;
	shape->calculateLocalInertia(mass, LocalInertia);

	// Create the rigid body object
	btRigidBody *RigidBody = new btRigidBody(mass, MotionState, shape, LocalInertia);
    
    printf("Created rigidboxy...");

	// Store a pointer to the irrlicht node so we can update it later
	RigidBody->setUserPointer((void *)(Node));

    printf("Set user pointer");

	// Add it to the world
	World->addRigidBody(RigidBody);
    printf("Added to world");
	Objects.push_back(RigidBody);

	//Register it's callback
    printf("Everything created, makeing the lua representation\n");

	//Create it's lua representation
	LBPhysNode* pnode = (LBPhysNode*)lua_newuserdata(L, sizeof(LBPhysNode));
	int tref = luaL_ref(L,LUA_REGISTRYINDEX);
	//iguielements[lcam] = tref;
	lua_rawgeti(L,LUA_REGISTRYINDEX,tref);//Put it back on the stack since luaL_ref pops the object.

	//Set it's metatable
	luaL_getmetatable(L, "phys.physmodel");
	lua_setmetatable(L, -2);

	//Create the struct
	pnode->n = Node;
	pnode->r = RigidBody;
	pnode->funcmap = hashmap_new();
	pnode->type = "bphysbox";

    printf("Done createing lua representation!\n");
	//Free up anything made in this function
    //free(label);

	//Put it on top and return it
  lua_rawgeti(L,LUA_REGISTRYINDEX,tref);
  return 1;
}


static const luaL_reg bphysbuffer_f[] = {
  //{"new",           newbphysmodel},
//  {"gethandeler",   guigethandeler},
//  {"sethandeler",   guisethandeler},
  {0,0},
};

static const luaL_reg bphysbuffer_m[] = {
  //{"setmaterial",          iscenesetmaterial},
  //{"getpos",               bphysgetpos},
  //{"setpos",               bphyssetpos},
//  {"settext",       setiguitext},
//  {"remove",        removeiguielement},
  {0, 0},
};

void bphysbuffer_register(lua_State* L, IrrlichtDevice* d){

    device = d;

	luaL_newmetatable(L, "phys.physbuffer");//{m_physbuffer}
	lua_newtable(L);//{m_physbuffer},{}
	luaL_register(L,"physbuffer",bphysbuffer_m);//{m_physbuffer},{physbuffer}
	lua_setfield(L,-2,"__index");//{m_physbuffer}
	lua_pop(L,1);
}