#ifndef STIM_GL_SPIDER_H
#define STIM_GL_SPIDER_H

#include <GL/glut.h>
//#include <GL/glew.h>
#include "gl_texture.h"
#include "../visualization/camera.h"
#include "./error.h"
#include "../math/vector.h"
#include "../math/rect.h"

namespace stim
{

template<typename T>
class gl_spider : public virtual gl_texture<T>
{
	//doen't use gl_texture really, just needs the GLuint id.
	//doesn't even need the texture iD really.
	private:
		stim::camera rotator;
		stim::vec<float> position;  	//vector designating the position of the spider.
		stim::vec<float> direction;	//vector designating the orientation of the spider
						//always a unit vector.
		stim::vec<float> magnitude;	//magnitude of the direction vector.
						//mag[0] = length.
						//mag[1] = width.
		//				Also maybe we some texture representation of
		//				of the spider i.e [WH_pxl, BL_pxl, WH_pxl].
		using gl_texture<T>::texID;


		void
		findOptimalDirection()
		{
			/* Method for finding the best direction for the spider.
			   Uses the camera to rotate. Then Calls Evaluate to find new cost.
			*/
		}

		void
		findOptimalPosition()
		{
			/* Method for finding the best direction for the spider.
			   Not sure if necessary since the next position for the spider
			   will be at direction * magnitude. */
		}
	
		void
		findOptimalScale()
		{
			/* Method for finding the best scale for the spider.
			   changes the x, y, z size of the spider to minimize the cost
			   function. */
		}

		void
		Evaluate()
		{	
			/* Uses uniform sampler2D in order to take a difference between
			   the colors of two textures. 1st texture is the spider template,
			   the 2nd is the location of the spider's overlap with the
			   gl_template 
	
			   does the spider need to track it's location? Prob not since
			   position can be set with gl_texture coordinates */
		
		}

		void
		Optimize()
		{
			/*find the optimum direction and scale */ 
		}
		/*
		void
		Step()
		{
			// move to the new position 
		}
		*/
	public:

		stim::rect<float> hor;
		stim::rect<float> ver;	



		gl_spider
		()
		{
			setPosition(0.0,0.0,0.0);
			setDirection(1.0,1.0,1.0);
			setMagnitude(0.1,0.1);
			stim::vec<float> Y(1.0,0.0,0.0);
			if(cos(Y.dot(direction))< 0.087){
				Y[0] = 0.0; Y[1] = 1.0;}
			/*
			hor = stim::rect<float>(position, direction, Y);
			hor.scale(magnitude[0], magnitude[1]);
			ver = stim::rect<float>(position, direction, (Y.cross(direction)).norm());
			ver.scale(magnitude[0], magnitude[1]);
			*/
			hor = stim::rect<float>(magnitude, position, direction, Y);
			ver = stim::rect<float>(magnitude, position, direction,
				 (Y.cross(direction)).norm());
		}

		gl_spider
		(vec<float> pos, vec<float> dir, vec<float> mag)
		{
			position = pos;
			direction = dir;
			magnitude = mag;
			vec<float> Y(1.0,0.0,0.0);
			if(cos(Y.dot(direction))< 0.087){
				Y[0] = 0.0; Y[1] = 1.0;}
			/*
			hor = stim::rect<float>(position, direction, Y);
			hor.scale(magnitude[0], magnitude[1]);
			ver = stim::rect<float>(position, direction, (Y.cross(direction)).norm());
			ver.scale(magnitude[0], magnitude[1]);
			*/
			hor = stim::rect<float>(magnitude, position, direction, Y);
			ver = stim::rect<float>(magnitude, position, direction,
				 (Y.cross(direction)).norm());
		}
		//temporary cost for convenience.	
		gl_spider
		(float pos_x, float pos_y, float pos_z, float dir_x, float dir_y, float dir_z,
			float mag_x, float mag_y)
		{
			setPosition(pos_x, pos_y, pos_z);
			setDirection(dir_x, dir_y, dir_z);
			setMagnitude(mag_x, mag_y);
			vec<float> Y(1.0,0.0,0.0);
			if(cos(Y.dot(direction))< 0.087){
				Y[0] = 0.0; Y[1] = 1.0;}
			/*
			hor = stim::rect<float>(position, direction, Y);
			hor.scale(magnitude[0], magnitude[1]);
			ver = stim::rect<float>(position, direction, (Y.cross(direction)).norm());
			ver.scale(magnitude[0], magnitude[1]);
			*/
			hor = stim::rect<float>(magnitude, position, direction.norm(),
				((Y.cross(direction)).cross(direction)).norm());
			ver = stim::rect<float>(magnitude, position, direction.norm(),
				 hor.n());
		}

		vec<float>
		getCurrentPosition()
		{
			return position;
		}
	
		vec<float>
		getCurrentDirection()
		{
			return direction;
		}

		vec<float>
		getCurrentMagnitude()
		{
			return magnitude;
		}
	
		void
		setPosition(vec<float> pos)
		{
			position = pos;
		}
		
		void
		setPosition(float x, float y, float z)
		{
			position[0] = x;
			position[1] = y;
			position[2] = z;
		}

		void
		setDirection(vec<float> dir)
		{
			direction = dir;
		}
		
		void
		setDirection(float x, float y, float z)
		{
			direction[0] = x;
			direction[1] = y;
			direction[2] = z;
		}
		
		void
		setMagnitude(vec<float> mag)
		{
			magnitude = mag;
		}
		
		void
		setMagnitude(float x, float y)
		{
			magnitude[0] = x;
			magnitude[1] = y;
		}

		void
		Step()
		{
			std::cout << position[0] << "," << position[1] << "," << position[1]
				<< std::endl;
			setPosition(direction*magnitude[1]+position);
			vec<float> Y(1.0,0.0,0.0);
			if(cos(Y.dot(direction))< 0.087){
				Y[0] = 0.0; Y[1] = 1.0;}
			hor = stim::rect<float>(magnitude, position, direction.norm(),
				((Y.cross(direction)).cross(direction)).norm());
			ver = stim::rect<float>(magnitude, position, direction.norm(),
				 hor.n());
			std::cout << position[0] << "," << position[1] << "," << position[1]
				<< std::endl;
			
		}
};
}
#endif