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

 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 <vector>

#include <Moof/Aabb.hh>
#include <Moof/Camera.hh>
#include <Moof/Entity.hh>
#include <Moof/Exception.hh>
#include <Moof/Library.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, num = 0; i < 4; ++i)
			{
				for (int j = 0; j < 3; ++j, ++num)
				{
					mVertices[num] = vertices[i][j];
				}
			}

			if (!mTilemap.getTileCoords(tileIndex, mTexCoords))
			{
				Mf::logWarning("no index %d in texture %s", tileIndex,
						texture.c_str());

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

			mAabb.encloseVertices(vertices, 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);
			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::Scalar		mVertices[12];
		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;

	Mf::Aabb				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::Status load(Mf::Script& script)
	{
		std::string filePath = Scene::getPath(getName());
		if (filePath == "") return Mf::Script::FILE_ERROR;

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


	static int loadBox(Mf::Script& script, Mf::Aabb& aabb)
	{
		Mf::Script::Value table[] =
		{
			script[1].requireTable(),
			script[2].requireTable()
		};

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

		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::Script::Value x = script[1].requireNumber();
		Mf::Script::Value y = script[2].requireNumber();
		Mf::Script::Value z = script[3].requireNumber();

		Mf::Vector3 vec;
		x.get(vec[0]);
		y.get(vec[1]);
		z.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)
	{
		Mf::Script::Value axis = script[1].requireNumber();
		Mf::Script::Value angle = script[2].requireNumber();

		size_t index = 0;
		axis.get(index);

		Mf::Scalar value;
		angle.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::Value table = script[1].requireTable();
		Mf::Script::Value top = script[-1];

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

		int width = 1;
		int height = 1;

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

		int nTiles = 0;

		//table.pushField("tiles");
		Mf::Script::Value tiles = script.getTop();
		nTiles = tiles.getLength();

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

		std::vector< std::vector<Tilemap::Index> > indices;

		int i, w, h;

		height = nTiles / width;
		indices.resize(height);

		// 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

		i = 1;
		for (h = height - 1; h >= 0; --h)
		{
			std::vector<Tilemap::Index> row;

			for (w = 0; w < width; ++w, ++i)
			{
				script.checkStack(2);
				script.push(i);
				tiles.pushField();

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

				row.push_back(index);
			}

			indices[h] = row;
		}

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

		Mf::Matrix4 transposedTransform = mTransform;
		transposedTransform.transpose();

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

		for (int h = 0; h < height; ++h)
		{
			for (int w = 0; w < width; ++w)
			{
				if (indices[h][w] == Tilemap::NO_TILE) continue;

				Mf::Vector3 demotedVertices[4];

				demotedVertices[0] = Mf::demote(vertices[h][w]);
				demotedVertices[1] = Mf::demote(vertices[h][w+1]);
				demotedVertices[2] = Mf::demote(vertices[h+1][w+1]);
				demotedVertices[3] = Mf::demote(vertices[h+1][w]);

				Quad* quad = new Quad(demotedVertices, mTexture, indices[h][w]);
				quad->setSurface(surface);

				boost::shared_ptr<Quad> quadPtr(quad);
				//mOctree->insert(quadPtr);
				mObjects.push_back(quadPtr);
			}
		}

		return 0;
	}

	int drawTile(Mf::Script& script)
	{
		Mf::Script::Value param = script[1];
		Mf::Script::Value 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::Vector4 vertices[2][width+1];

		Mf::Matrix4 transposedTransform = mTransform;
		transposedTransform.transpose();

		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::Vector4(xf, Mf::Scalar(h), 0.0, 1.0) *
					transposedTransform;
			}
		}

		for (int w = 0; w < width; ++w)
		{
			Mf::Vector3 demotedVertices[4];

			demotedVertices[0] = Mf::demote(vertices[0][w]);
			demotedVertices[1] = Mf::demote(vertices[0][w+1]);
			demotedVertices[2] = Mf::demote(vertices[1][w+1]);
			demotedVertices[3] = Mf::demote(vertices[1][w]);

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

			boost::shared_ptr<Quad> quadPtr(quad);
			//mOctree->insert(quadPtr);
			mObjects.push_back(quadPtr);
		}

		return 0;
	}
};


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


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


void Scene::draw(Mf::Scalar alpha) const
{
	//mImpl->mOctree->draw(alpha);
	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
{
	//mImpl->mOctree->drawIfVisible(alpha, frustum);
	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);
	}

	mImpl->mBounds.draw();
}


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 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: %d", collisions);
	}

	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: *************************************************/