#ifndef camera_h
#define camera_h

#include "Vector.h"
#include <includes.h>

enum Axis
{
	AXIS_X=0,
	AXIS_Y=1,
	AXIS_Z=2
};

class Camera
{
public:
	Camera(void);
	~Camera(void);

	Vector m_Orientation;

	Vector m_EyePosition;
	Vector m_LookAt;
	Vector m_UpVector;
	Vector m_ViewDirection;
	Vector m_RightVector;
	
protected:	double m_AspectRatio;
	double m_NearClipDistance;
	double m_FarClipDistance;
	double m_FovX;
	double m_FovY;
	double m_LeftCorner;
	double m_RightCorner;
	double m_TopCorner;
	double m_DownCorner;

public:
	void Rotate(Axis axis, double angle);
	void Rotate(Vector rotvec);

	virtual void SetPosition(Vector position)
	{
		m_EyePosition=position;
		m_ViewDirection=m_LookAt-m_EyePosition;
	//	CalculateRightVector();
	}
	virtual void SetPosition(double x,double y,double z)
	{
		m_EyePosition.x=x;
		m_EyePosition.y=y;
		m_EyePosition.z=z;

	//	m_ViewDirection=m_LookAt-m_EyePosition;
	//	CalculateRightVector();
	}

	Vector getPosition(void)
	{
		return m_EyePosition;
	}
	void getPosition(double& x,double&y,double &z)
	{
		x=m_EyePosition.x;
		y=m_EyePosition.y;
		z=m_EyePosition.z;
	}

	void setLookAt(Vector lookat)
	{
		m_LookAt=lookat;
		m_ViewDirection=m_LookAt-m_EyePosition;
	//	CalculateRightVector();
	//	CalculateUpVector();
	}

	void setLookAt(double x,double y,double z)
	{
		m_LookAt.x=x;
		m_LookAt.y=y;
		m_LookAt.z=z;
//		m_ViewDirection=m_LookAt-m_EyePosition;
//		CalculateRightVector();
//		CalculateUpVector();
	}

	Vector getLookAt()
	{
		return m_LookAt;
	}
	void  getLookAt(double& x,double&y,double &z)
	{
		x=m_LookAt.x;
		y=m_LookAt.y;
		z=m_LookAt.z;
	}

	void SetUpVector(Vector position)
	{
		m_UpVector=position;
	}
	void SetUpVector(double x,double y,double z)
	{
		m_UpVector.x=x;
		m_UpVector.y=y;
		m_UpVector.z=z;
	}

	Vector getUpVector(void)
	{
		return m_UpVector;
	}
	void getUpVector(double& x,double&y,double &z)
	{
		x=m_UpVector.x;
		y=m_UpVector.y;
		z=m_UpVector.z;
	}

	Vector getRightVector(void)
	{
		return m_RightVector;
	}

	void setRightVector(Vector v)
	{
		m_RightVector=v;
	}


	void setFovX(double angle)
	{
		m_FovX=angle;
		UpdateFovY();
	}

	void setFovY(double angle)
	{
		m_FovY=angle;
		UpdateFovX();
	}

	double getFovX(void)
	{
		return m_FovX;
	}

	double getFovY(void)
	{
		return m_FovY;
	}

	void setNearClipDistance(double distance)
	{
		m_NearClipDistance=distance;
	}

	void setFarClipDistance(double distance)
	{
		m_FarClipDistance=distance;
	}

	double getNearClipDistance(void)
	{
		return m_NearClipDistance;
	}

	double getFarClipDistance(void)
	{
		return m_FarClipDistance;
	}
	void setAspectRatio(double ratio)
	{
		m_AspectRatio=ratio;
		UpdateFovY();
	}
	void setCorners(double left,double right,double top,double bottom)
	{
		m_LeftCorner=left;
		m_RightCorner=right;
		m_TopCorner=top;
		m_DownCorner=bottom;
	}
private:
	
	void UpdateCamera(void);
	
	void UpdateFovX(void)
	{
		m_FovX=m_FovY/m_AspectRatio;
	}

	void UpdateFovY(void)
	{
		m_FovY=m_AspectRatio*m_FovX;
	}

	void CalculateRightVector(void)
	{
		Vector X = m_ViewDirection.UnitVector() % m_UpVector;
		X.Normalize();
		m_RightVector=X;
	}
	void CalculateUpVector(void)
	{
		Vector X = m_ViewDirection.UnitVector() % m_RightVector;
		X.Normalize();
		m_UpVector=X;
	}
public:
	void SetViewandProjection(void);
	void SetViewandProjectionNew(void);
	
	void SetProjection(void);
	virtual void SetViewandProjectionOrto(void);
	virtual void Move(Axis axis, double distance);
	virtual void setViewforBbox()
	{
		gluLookAt(0,0,0,
			m_ViewDirection.x,
			m_ViewDirection.y,
			m_ViewDirection.z,
			m_UpVector.x,
			m_UpVector.y,
			m_UpVector.z);
	}
};

#endif