/*]  Copyright (c) 2009-2010, Charles McGarvey  [**************************
**]  All rights reserved.
*
* vi:ts=4 sw=4 tw=75
*
* Distributable under the terms and conditions of the 2-clause BSD license;
* see the file COPYING for a complete text of the license.
*
**************************************************************************/

#include <Moof/Error.hh>
#include <Moof/Log.hh>
#include <Moof/Math.hh>
#include <Moof/OpenGL.hh>
#include <Moof/Settings.hh>
#include <Moof/Video.hh>

#include "GameLayer.hh"

#if HAVE_CONFIG_H
#include "config.h"
#endif


void GameLayer::loadSceneLoader()
{
	mState.script.importStandardLibraries();
	importLogFunctions(mState.script);

	std::string loaderPath = Scene::getPath("loader");
	if (loaderPath == "")
	{
		throw Mf::Error(Mf::Error::RESOURCE_NOT_FOUND, "loader");
	}

	Mf::Script::Result status = mState.script.doFile(loaderPath);
	if (status != Mf::Script::SUCCESS)
	{
		std::string str;
		mState.script[-1].get(str);

		throw Mf::Error(Mf::Error::SCRIPT_ERROR, str);
	}

	mState.script.getGlobalTable().pushField("scenes");
	mState.script.getTop().get(mState.sceneList);
	if (mState.sceneList.size() == 0)
	{
		throw Mf::Error(Mf::Error::SCRIPT_ERROR,
				"no variable `scenes' within loader");
	}
}

void GameLayer::advanceScene(Mf::Settings& settings)
{
	if (mState.sceneList.size() != 0)
	{
		mState.scene = Scene::alloc(mState.sceneList[0]);
		mState.sceneList.erase(mState.sceneList.begin());

		Mf::Script::Result status = mState.scene->load(settings,
													   mState.script);
		if (status != Mf::Script::SUCCESS)
		{
			std::string str;
			mState.script[-1].get(str);

			throw Mf::Error(Mf::Error::SCRIPT_ERROR, str);
		}

		mState.script.getGlobalTable().pushField("Event");
		if (mState.script[-1].isTable())
		{
			mState.script[-1].pushField("Think");
			mState.script.set("Think", Mf::Script::REGISTRY);
			mState.script.pop(2);
		}
		else
		{
			mState.script.pop();
		}
	}
}


GameLayer::GameLayer() :
	mMusic("NightFusionIntro"),
	mPunchSound("Thump")
{
	mMusic.setLooping(true);
	mMusic.enqueue("NightFusionLoop");

	//mMusic.setPosition(Mf::Vector3(10.0, 5.0, 0.0));

	mThinkTimer.init(boost::bind(&GameLayer::thinkTimer, this),
			0.1, Mf::Timer::REPEAT);

	mState.heroine = Heroine::alloc();
	mState.heroine->animation.startSequence("FlyDiagonallyUp");

	mState.interp.init(0.0, 1.0);
	mState.interp.reset(4.0, Mf::Interp::OSCILLATE);
}


void GameLayer::didAddToView()
{
	bool isMute = false;
	settings().get("nomusic", isMute);
	if (!isMute) mMusic.play();

	loadSceneLoader();
	advanceScene(settings());		// load the first scene

	mHud = Hud::alloc(mState);
	addChild(mHud);

	mRay.direction.set(1.0, 0.0);

	mLine.a.set(20, 10);
	mLine.b.set(19, 14);

	mCircle.point.set(22, 5);
	mCircle.radius = 2;

	mRayTimer.init(boost::bind(&GameLayer::rayTimer, this),
				   1.0, Mf::Timer::REPEAT);

	setProjection();
}


void GameLayer::update(Mf::Scalar t, Mf::Scalar dt)
{
	if (!mState.scene) return;
	mState.camera.update(t, dt);
	mState.heroine->update(t, dt);

	mState.scene->checkForCollision(*mState.heroine);

	Mf::Vector3 cam= -Mf::promote(mState.heroine->getState().position, 8);
	mState.camera.setPosition(cam);

	mRay.point = mState.heroine->getState().position;

	Mf::View::update(t, dt);
}

void GameLayer::thinkTimer()
{
	mState.script.getRegistryTable().pushField("Think");
	if (mState.script[-1].isFunction()) mState.script.call();
	else                                mState.script.pop();
}


void GameLayer::rayTimer()
{
	Mf::Ray2::Contact meh;
	std::list<Mf::Ray2::Contact> hits;
	Mf::Vector2 point;

	bool bam = mLine.intersectRay(mRay, meh);
	if (bam)
	{
		//meh.normal.normalize();
		//hits.push_back(meh);
		mRay.solve(point, meh.distance);
		Mf::logInfo << "line: d = " << meh.distance << std::endl;
		Mf::logInfo << "      P = " << point << std::endl;
		Mf::logInfo << "      n = " << meh.normal << std::endl;
	}

	bam = mCircle.intersectRay(mRay, meh);
	if (bam)
	{
		meh.normal.normalize();
		hits.push_back(meh);
	}

	if (mState.scene->castRay(mRay, hits))
	{
		hits.front().normal.normalize();
		mRay.solve(point, hits.front().distance);
		Mf::logInfo << "scene: d = " << hits.front().distance << std::endl;
		Mf::logInfo << "       P = " << point << std::endl;
		Mf::logInfo << "       n = " << hits.front().normal << std::endl;
	}
}


void GameLayer::draw(Mf::Scalar alpha) const
{
	if (!mState.scene) return;
	mState.camera.uploadToGL(alpha);

	// DRAW THE SCENE
	Mf::Texture::resetBind();

	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);

	mState.scene->drawIfVisible(alpha, mState.camera.getFrustum());
	mState.heroine->draw(alpha);

	mRay.draw();
	mLine.draw();
	mCircle.draw();

	Mf::View::draw(alpha);
}

bool GameLayer::handleEvent(const Mf::Event& event)
{
	if (Mf::View::handleEvent(event)) return true;

	switch (event.type)
	{
		case SDL_KEYDOWN:
			if (event.key.keysym.sym == SDLK_SPACE)
			{
				mState.heroine->animation.startSequence("Flattened");
				Mf::logInfo("thump!");
				mPunchSound.play();
				return true;
			}
			else if (event.key.keysym.sym == SDLK_m)
			{
				mMusic.toggle();
				return true;
			}
			else if (event.key.keysym.sym == SDLK_PAGEUP)
			{
				mRay.direction = cml::rotate_vector_2D(mRay.direction,
						cml::rad(10.0));
				return true;
			}
			else if (event.key.keysym.sym == SDLK_PAGEDOWN)
			{
				mRay.direction = cml::rotate_vector_2D(mRay.direction,
						cml::rad(-10.0));
				return true;
			}
			else if (event.key.keysym.sym == SDLK_r)
			{
				loadSceneLoader();
				advanceScene(settings());
				return true;
			}
			return mState.heroine->handleEvent(event);

		case SDL_KEYUP:
			if (event.key.keysym.sym == SDLK_ESCAPE)
			{
				parent().removeChild(this);
				return true;
			}
			else if (event.key.keysym.sym == SDLK_h)
			{
				addChild(mHud);
				return true;
			}
			return mState.heroine->handleEvent(event);

		case SDL_MOUSEMOTION:
		case SDL_MOUSEBUTTONDOWN:
			mState.camera.handleEvent(event);
			return true;

		case SDL_VIDEORESIZE:
			setProjection(event.resize.w, event.resize.h);
			break;
	}

	return false;
}


void GameLayer::setProjection()
{
	setProjection(video().getWidth(), video().getHeight());
}

void GameLayer::setProjection(Mf::Scalar width, Mf::Scalar height)
{
	mState.camera.setProjection(cml::rad(45.0), width / height, 1.0, 200.0);
}