/*******************************************************************************

 Copyright (c) 2009, Charles McGarvey
 All rights reserved.
 
 Redistribution   and   use  in  source  and  binary  forms,  with  or  without
 modification, are permitted provided that the following conditions are met:
 
   * Redistributions  of  source  code  must retain the above copyright notice,
     this list of conditions and the following disclaimer.
   * Redistributions  in binary form must reproduce the above copyright notice,
     this  list of conditions and the following disclaimer in the documentation
     and/or other materials provided with the distribution.
 
 THIS  SOFTWARE  IS  PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 AND  ANY  EXPRESS  OR  IMPLIED  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 DISCLAIMED.  IN  NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 FOR  ANY  DIRECT,  INDIRECT,  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 DAMAGES  (INCLUDING,  BUT  NOT  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 SERVICES;  LOSS  OF  USE,  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 CAUSED  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 OR  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*******************************************************************************/

#include <map>

#include <Moof/Aabb.hh>
#include <Moof/Camera.hh>
#include <Moof/Entity.hh>
#include <Moof/Exception.hh>
#include <Moof/Library.hh>
#include <Moof/Line.hh>
#include <Moof/Log.hh>
#include <Moof/Math.hh>
//#include <Moof/Octree.hh>
#include <Moof/Script.hh>
#include <Moof/Settings.hh>

#include "Character.hh"
#include "Scene.hh"
#include "Tilemap.hh"


struct Scene::Impl : public Mf::Library<Impl>
{
	struct Quad : public Mf::Entity
	{
		enum Surface
		{
			NONE	= 0,
			LEFT	= 1,
			RIGHT	= 2,
			TOP		= 3
		};

		Quad(const Mf::Vector3* vertices[4], const std::string& texture,
				Tilemap::Index tileIndex) :
			mTilemap(texture),
			mBlending(false),
			mFog(false),
			mSurface(NONE)
		{
			for (int i = 0; i < 4; ++i)
			{
				mVertices[i] = *vertices[i];
				//for (int j = 0; j < 3; ++j, ++num)
				//{
					//mVertices[num] = (*vertices[i])[j];
				//}
			}

			if (!mTilemap.getTileCoords(tileIndex, mTexCoords))
			{
				Mf::logWarning << "no index " << tileIndex <<
					" in texture " << texture << std::endl;

				mTexCoords[0] = mTexCoords[1] =
					mTexCoords[3] = mTexCoords[6] = 0.0;
				mTexCoords[2] = mTexCoords[4] =
					mTexCoords[5] = mTexCoords[7] = 1.0;
			}

			mAabb.encloseVertices(mVertices, 4);
			mSphere.point = mAabb.getCenter();
			mSphere.radius = (mAabb.min - mSphere.point).length();
		}

		void setBlending(bool blending)
		{
			mBlending = blending;
		}

		void setFog(bool fog)
		{
			mFog = fog;
		}

		void setSurface(Surface type)
		{
			mSurface = type;
		}

		Surface getSurface() const
		{
			return mSurface;
		}

		void draw(Mf::Scalar alpha = 0.0) const
		{
			if (mBlending)
			{
				glEnable(GL_BLEND);
				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
			}

			if (mFog)
			{
				glEnable(GL_FOG);
				glFogi(GL_FOG_MODE, GL_LINEAR);
			}

			//glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
			mTilemap.bind();

			glVertexPointer(3, GL_SCALAR, 0, mVertices[0].data());
			glTexCoordPointer(2, GL_SCALAR, 0, mTexCoords);

			glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

			glDisable(GL_BLEND);
			glDisable(GL_FOG);
		}

		bool isVisible(const Mf::Frustum& frustum) const
		{
			return mSphere.isVisible(frustum);
		}


		Mf::Vector3		mVertices[4];
		Mf::Scalar		mTexCoords[8];
		
		Tilemap			mTilemap;

		bool			mBlending;
		bool			mFog;
		Surface			mSurface;
	};



	Mf::Matrix4				mTransform;
	std::string				mTexture;

	//Mf::Octree<Quad>::Ptr	mOctree;
	std::list< boost::shared_ptr<Impl::Quad> >	mObjects;
	std::list< Mf::Line<2> >					mLines;

	Mf::Aabb<3>				mBounds;


	enum AXIS
	{
		X = 0,
		Y = 1,
		Z = 2
	};


	explicit Impl(const std::string& name) :
		Mf::Library<Impl>(name) {}

	void importSceneBindings(Mf::Script& script)
	{
		script.importFunction("SetBounds",
				boost::bind(&Impl::setBounds, this, _1));
		script.importFunction("ResetTransform",
				boost::bind(&Impl::resetTransform, this, _1));
		script.importFunction("Translate",
				boost::bind(&Impl::translate, this, _1));
		script.importFunction("Scale",
				boost::bind(&Impl::scale, this, _1));
		script.importFunction("Rotate",
				boost::bind(&Impl::rotate, this, _1));
		script.importFunction("SetTexture",
				boost::bind(&Impl::setTexture, this, _1));
		script.importFunction("DrawTilemap",
				boost::bind(&Impl::drawTilemap, this, _1));
		script.importFunction("DrawTile",
				boost::bind(&Impl::drawTile, this, _1));

		int detail = 3;
		Mf::Settings::getInstance().get("detail", detail);
		script.push(detail); script.set("detail");

		script.push(1); script.set("LOW");
		script.push(2); script.set("MEDIUM");
		script.push(3); script.set("HIGH");

		script.push(X); script.set("X");
		script.push(Y); script.set("Y");
		script.push(Z); script.set("Z");

		script.push(Quad::LEFT);  script.set("LEFT");
		script.push(Quad::RIGHT); script.set("RIGHT");
		script.push(Quad::TOP);   script.set("TOP");
	}


	Mf::Script::Result load(Mf::Script& script)
	{
		std::string filePath = Scene::getPath(getName());
		if (filePath == "")
		{
			script.push("the scene file could not be found");
			return Mf::Script::FILE_ERROR;
		}

		importSceneBindings(script);
		return script.doFile(filePath);
	}


	static int loadBox(Mf::Script& script, Mf::Aabb<3>& aabb)
	{
		script[1].requireTable();
		script[2].requireTable();
		script.setSize(2);

		for (int i = 1; i <= 2; ++i)
		{
			for (int j = 1; j <= 3; ++j)
			{
				script[i].pushField(j);
			}
		}

		script[3].get(aabb.min[0]);
		script[4].get(aabb.min[1]);
		script[5].get(aabb.min[2]);
		script[6].get(aabb.max[0]);
		script[7].get(aabb.max[1]);
		script[8].get(aabb.max[2]);

		return 0;
	}

	int setBounds(Mf::Script& script)
	{
		int ret = loadBox(script, mBounds);
		//mOctree = Mf::Octree<Quad>::alloc(mBounds);
		return ret;
	}

	int resetTransform(Mf::Script& script)
	{
		mTransform.identity();
		return 0;
	}

	int translate(Mf::Script& script)
	{
		Mf::Vector3 vec;

		script[1].requireNumber().get(vec[0]);
		script[2].requireNumber().get(vec[1]);
		script[3].requireNumber().get(vec[2]);

		Mf::Matrix4 translation;
		cml::matrix_translation(translation, vec);
		mTransform = translation * mTransform;

		return 0;
	}

	int scale(Mf::Script& script)
	{
		if (script.getSize() == 3)
		{
			Mf::Vector3 vec;
			script[1].requireNumber().get(vec[0]);
			script[2].requireNumber().get(vec[1]);
			script[3].requireNumber().get(vec[2]);

			Mf::Matrix4 scaling;
			cml::matrix_scale(scaling, vec);
			mTransform = scaling * mTransform;
		}
		else if (script.getSize() == 1)
		{
			Mf::Scalar value = 1.0;
			script[1].requireNumber().get(value);

			Mf::Matrix4 scaling;
			cml::matrix_uniform_scale(scaling, value);
			mTransform = scaling * mTransform;
		}
		else
		{
			script.getTop().throwError("wrong number of arguments");
		}

		return 0;
	}

	int rotate(Mf::Script& script)
	{
		size_t index = 0;
		script[1].requireNumber().get(index);

		Mf::Scalar value;
		script[2].requireNumber().get(value);

		cml::matrix_rotate_about_world_axis(mTransform, index, cml::rad(value));

		return 0;
	}

	int setTexture(Mf::Script& script)
	{
		script[1].requireString().get(mTexture);
		return 0;
	}

	int drawTilemap(Mf::Script& script)
	{
		Mf::Script::Slot table = script[1].requireTable();
		Mf::Script::Slot top = script[-1];

		int				width = 1;
		int				height = 1;
		int				nTiles = 0;

		table.pushField("width");
		top.get(width);
		script.pop();

		nTiles = table.getLength();
		if (nTiles % width != 0) table.throwError("invalid number of tiles");

		if (width == 0) table.throwError("width field must not be zero");
		height = nTiles / width;

		Mf::Vector3		vertices[height+1][width+1];

		// the indices are stored upside-down in the scene file so that they are
		// easier to edit as text, so we'll need to load them last row first

		// do first row and first column of vertices

		for (int w = 0; w <= width; ++w)
		{
			vertices[height][w] = Mf::demote(mTransform *
					Mf::Vector4(w, height, 0.0, 1.0));
		}
		for (int h = 0; h < height; ++h)
		{
			vertices[h][0] = Mf::demote(mTransform *
					Mf::Vector4(0.0, h, 0.0, 1.0));
		}

		size_t i = 1;
		for (int h = height - 1; h >= 0; --h)
		{
			for (int w = 0; w < width; ++w, ++i)
			{
				int wPlus1 = w + 1;
				int hPlus1 = h + 1;

				table.pushField(i);

				Tilemap::Index index;
				top.get(index);

				script.pop();

				vertices[h][wPlus1] = Mf::demote(mTransform *
						Mf::Vector4(wPlus1, h, 0.0, 1.0));

				if (index == Tilemap::NO_TILE) continue;

				const Mf::Vector3* corners[4] = {
					&vertices[h][w],
					&vertices[h][wPlus1],
					&vertices[hPlus1][wPlus1],
					&vertices[hPlus1][w]
				};

				Quad* quad = new Quad(corners, mTexture, index);
				//quad->setSurface(surface);

				boost::shared_ptr<Quad> quadPtr(quad);
				mObjects.push_back(quadPtr);
			}
		}

		Quad::Surface	surface = Quad::NONE;

		table.pushField("surface");
		top.get(surface);
		script.pop();

		if (surface != Quad::NONE)
		{
			// need a 2d line for collisions
			// assuming the camera always looks directly to -z when the
			// scene is built, simply demoting the vector again should
			// project the points to the xy-plane

			Mf::Vector2 bl = Mf::demote(vertices[0][0]);
			Mf::Vector2 tr = Mf::demote(vertices[height][width]);

			mLines.push_back(Mf::Line<2>(bl, tr));
			Mf::logDebug("new line");
		}

		return 0;
	}

	int drawTile(Mf::Script& script)
	{
		Mf::Script::Slot param = script[1];
		Mf::Script::Slot top = script[-1];

		Tilemap::Index	index = 0;
		int				width = 1;
		bool			blending = false;
		bool			fog = false;

		if (param.isTable())
		{
			script.push(1);
			param.pushField();
			top.get(index);

			param.pushField("u_scale");
			top.get(width);

			param.pushField("blend");
			top.get(blending);

			param.pushField("fog");
			top.get(fog);
		}
		else if (param.isNumber())
		{
			param.get(index);
		}

		Mf::Vector3 vertices[2][width+1];

		Mf::Scalar xf;
		Mf::Scalar increment = 1.0 / Mf::Scalar(width);

		for (int h = 0; h <= 1; ++h)
		{
			xf = 0.0;
			for (int w = 0; w <= width; ++w, xf += increment)
			{
				vertices[h][w] = Mf::demote(mTransform *
						Mf::Vector4(xf, Mf::Scalar(h), 0.0, 1.0));
			}
		}

		for (int w = 0; w < width; ++w)
		{
			int wPlus1 = w + 1;

			const Mf::Vector3* corners[4] = {
				&vertices[0][w],
				&vertices[0][wPlus1],
				&vertices[1][wPlus1],
				&vertices[1][w]
			};

			Quad* quad = new Quad(corners, mTexture, index);
			quad->setBlending(blending);
			quad->setFog(fog);

			boost::shared_ptr<Quad> quadPtr(quad);
			mObjects.push_back(quadPtr);
		}

		return 0;
	}
};


Scene::Scene(const std::string& name) :
	// pass through
	mImpl(Scene::Impl::getInstance(name)) {}


Mf::Script::Result Scene::load(Mf::Script& script)
{
	// pass through
	return mImpl->load(script);
}


void Scene::draw(Mf::Scalar alpha) const
{
	std::list< boost::shared_ptr<Impl::Quad> >& objects = mImpl->mObjects;
	std::list< boost::shared_ptr<Impl::Quad> >::const_iterator it;

	for (it = objects.begin(); it != objects.end(); ++it)
	{
		(*it)->draw(alpha);
	}

	mImpl->mBounds.draw();
}

void Scene::drawIfVisible(Mf::Scalar alpha, const Mf::Frustum& frustum) const
{
	std::list< boost::shared_ptr<Impl::Quad> >& objects = mImpl->mObjects;
	std::list< boost::shared_ptr<Impl::Quad> >::const_iterator it;

	for (it = objects.begin(); it != objects.end(); ++it)
	{
		(*it)->drawIfVisible(alpha, frustum);
	}

	std::list< Mf::Line<2> >& lines = mImpl->mLines;
	std::list< Mf::Line<2> >::const_iterator lit;

	for (lit = lines.begin(); lit != lines.end(); ++lit)
	{
		(*lit).draw(alpha);
	}

	mImpl->mBounds.draw();
}


bool Scene::castRay(const Mf::Ray<2>& ray,
		std::list<Mf::Ray<2>::Intersection>& hits) const
{
	std::list< Mf::Line<2> >& lines = mImpl->mLines;
	std::list< Mf::Line<2> >::const_iterator it;

	for (it = lines.begin(); it != lines.end(); ++it)
	{
		Mf::Ray<2>::Intersection hit;
		Mf::Scalar d = (*it).intersectRay(ray, hit);
		if (d > 0.0)
		{
			hits.push_back(hit);
			//return true;
		}
	}

	hits.sort();
	return !hits.empty();
	//return false;
}

bool Scene::checkForCollision(Character& character)
{
	return false;
	//std::list< boost::shared_ptr<Impl::Quad> > objects;
	//std::list<Mf::Octree<Impl::Quad>::InsertableP> objects;
	//mImpl->mOctree->getNearbyObjects(objects, character);

	std::list< boost::shared_ptr<Impl::Quad> >& objects = mImpl->mObjects;
	std::list< boost::shared_ptr<Impl::Quad> >::const_iterator it;

	int collisions = 0;
	Mf::Sphere<3> sphere = character.getSphere();

	for (it = objects.begin(); it != objects.end(); ++it)
	{
		Impl::Quad::Surface type = (*it)->getSurface();
		if (type == Impl::Quad::NONE) continue;

		if (Mf::checkCollision(sphere, (*it)->getSphere()))
		{
			++collisions;

			Mf::Vector2 impulse(0.0, 0.0);
			Mf::Vector2 p = character.getState().momentum;

			Mf::State2 state = character.getState(1.0);
			sphere = character.getSphere();
			Mf::Scalar alpha = 1.0;
			while (Mf::checkCollision(sphere, (*it)->getSphere()))
			{
				alpha -= 0.05;
				state = character.getState(alpha);
			}

			character.setPosition(state.position);

			//switch (type)
			//{
				//case Impl::Quad::TOP:
					//if (p[1] < 0.0) impulse[1] = -p[1];
					//break;
				//case Impl::Quad::LEFT:
					//if (p[0] > 0.0) impulse[0] = 1.5*-p[0];
					//break;
				//case Impl::Quad::RIGHT:
					//if (p[0] < 0.0) impulse[0] = 1.5*-p[0];
					//break;
			//}

			//character.addImpulse(impulse);
		}
	}

	if (collisions > 0)
	{
		Mf::logInfo << "collisions: " << collisions << std::endl;
	}

	return false;
}


std::string Scene::getPath(const std::string& name)
{
	return Mf::Resource::getPath("scenes/" + name + ".lua");
}


/** vim: set ts=4 sw=4 tw=80: *************************************************/