/*]  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 <iostream>

#include <moof/log.hh>

#include "Character.hh"

	
class SpringForce
{
public:

	explicit SpringForce(moof::vector2 x) :
		location(x) {}

	const moof::vector2& operator () (const moof::linear_state<2>& state)
	{
		moof::vector2 x = state.position - location;
		moof::scalar mag = x.length();
		moof::scalar d = 0.0;

		// spring:
		//state_.force += -15.0 * x - 1.5 * state_.velocity;
		force = SCALAR(-10.0) * (mag - d) * (x / mag);// - SCALAR(2.0) * state.velocity;

		return force;
	}

private:

	moof::vector2 force;
	moof::vector2 location;
};

class ResistanceForce
{
public:

	explicit ResistanceForce(moof::scalar scale = 1.0) :
		k(scale) {}

	const moof::vector2& operator () (const moof::linear_state<2>& state)
	{
		force = -k * state.velocity;
		return force;
	}

private:

	moof::vector2	force;
	moof::scalar	k;
};


Character::Character(const std::string& name) :
	tilemap(name),
	animation(name)
{
	state_.init();

	state_.mass = 1.0;
	state_.inverse_mass = 1.0 / state_.mass;

	// forces
	state_.force = moof::vector2(0.0, 0.0);
	state_.forces.push_back(SpringForce(moof::vector2(5.0, 4.0)));
	state_.forces.push_back(ResistanceForce(2.0));
	state_.forces.push_back(moof::linear_state<2>::gravity_force(-9.8));

	// starting position
	state_.position = moof::vector2(5.0, 5.0);
	state_.momentum = moof::vector2(1.0, 0.0);
	state_.recalculate();

	prev_state_ = state_;
}


void Character::update(moof::scalar t, moof::scalar dt)
{
	moof::rigid_body2::update(t, dt); // update physics

	animation.update(t, dt);

	moof::vector3 center(state_.position[0], state_.position[1], 0.0);
	moof::vector3 a(state_.position[0] - 0.5, state_.position[1] - 0.5, 0.0);
	moof::vector3 b(state_.position[0] + 0.5, state_.position[1] + 0.5, 0.0);

	aabb_.init(a, b);
	sphere_.init(center, a);
}


void Character::draw(moof::scalar alpha) const
{
	moof::state2 state = moof::rigid_body2::state(alpha);
	moof::vector2 position = state.position;

	//glColor3f(1.0f, 1.0f, 1.0f);
	tilemap.bind();

	int frame = animation.getFrame();
	moof::texture::orientation orientation = moof::texture::normal;

	if (state_.velocity[0] < 0.0) orientation = moof::texture::reverse;

	moof::scalar coords[8];
	tilemap.tile_coordinates(frame, coords, orientation);

	moof::scalar s = 0.5;

	glBegin(GL_TRIANGLE_FAN);
		glTexCoord(coords[0], coords[1]);
		glVertex(position[0]-s, position[1]-s);
		glTexCoord(coords[2], coords[3]);
		glVertex(position[0]+s, position[1]-s);
		glTexCoord(coords[4], coords[5]);
		glVertex(position[0]+s, position[1]+s);
		glTexCoord(coords[6], coords[7]);
		glVertex(position[0]-s, position[1]+s);
	glEnd();
}


/*int Character::getOctant(const moof::Aabb<3>& aabb) const
{
	int octantNum = -1;

	moof::plane::halfspace halfspace;

	moof::plane xy = aabb.xy_plane();
	halfspace = xy.intersects(sphere_);
	if (halfspace == moof::plane::intersecting)
	{
		halfspace = xy.intersects(aabb_);
	}

	if (halfspace == moof::plane::positive)
	{
		moof::plane xz = aabb.xz_plane();
		halfspace = xz.intersects(sphere_);
		if (halfspace == moof::plane::intersecting)
		{
			halfspace = xz.intersects(aabb_);
		}

		if (halfspace == moof::plane::positive)
		{
			moof::plane yz = aabb.yz_plane();
			halfspace = yz.intersects(sphere_);
			if (halfspace == moof::plane::intersecting)
			{
				halfspace = yz.intersects(aabb_);
			}

			if (halfspace == moof::plane::positive)
			{
				octantNum = 2;
			}
			else if (halfspace == moof::plane::negative)
			{
				octantNum = 3;
			}
		}
		else if (halfspace == moof::plane::negative)
		{
			moof::plane yz = aabb.yz_plane();
			halfspace = yz.intersects(sphere_);
			if (halfspace == moof::plane::intersecting)
			{
				halfspace = yz.intersects(aabb_);
			}

			if (halfspace == moof::plane::positive)
			{
				octantNum = 1;
			}
			else if (halfspace == moof::plane::negative)
			{
				octantNum = 0;
			}
		}
	}
	else if (halfspace == moof::plane::negative)
	{
		moof::plane xz = aabb.xz_plane();
		halfspace = xz.intersects(sphere_);
		if (halfspace == moof::plane::intersecting)
		{
			halfspace = xz.intersects(aabb_);
		}

		if (halfspace == moof::plane::positive)
		{
			moof::plane yz = aabb.yz_plane();
			halfspace = yz.intersects(sphere_);
			if (halfspace == moof::plane::intersecting)
			{
				halfspace = yz.intersects(aabb_);
			}

			if (halfspace == moof::plane::positive)
			{
				octantNum = 6;
			}
			else if (halfspace == moof::plane::negative)
			{
				octantNum = 7;
			}
		}
		else if (halfspace == moof::plane::negative)
		{
			moof::plane yz = aabb.yz_plane();
			halfspace = yz.intersects(sphere_);
			if (halfspace == moof::plane::intersecting)
			{
				halfspace = yz.intersects(aabb_);
			}

			if (halfspace == moof::plane::positive)
			{
				octantNum = 5;
			}
			else if (halfspace == moof::plane::negative)
			{
				octantNum = 4;
			}
		}
	}

	return octantNum;
}
*/


void Character::addImpulse(moof::vector2 impulse)
{
	state_.momentum += impulse;
}

void Character::addForce(moof::vector2 force)
{
	state_.force += force;
}

void Character::setPosition(moof::vector2 position)
{
	state_.position = position;
}