/* 
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2004 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

   ### File Specific:
   main-programmer: Christian Meyer
   co-programmer: ...
*/

#include "camera.h"
#include "world.h"
#include "world_entity.h"

using namespace std;

/**
   \brief creates a Camera
   
   This standard constructor sets all parameters to zero
*/
Camera::Camera (World* world)
{
  this->world = world;
  bound = NULL;
  /* give it some physical live */
  m = 10;
  a = new Vector(0.0, 0.0, 0.0);
  v = new Vector(0.0, 0.0, 0.0);
  fs = new Vector(0.0, 0.0, 0.0);
  cameraMode = NORMAL;
  deltaTime = 3000.0;
  cameraOffset = 1.0;
  cameraOffsetZ = 10.0;
  t = 0.0;

  actual_place.pos.x = 0.0;
  actual_place.pos.y = 10.0;
  actual_place.pos.z = -5.0;
}

/**
   \brief default destructor
*/
Camera::~Camera ()
{
}

/**
   \brief time based actualisation of camera parameters
   \param deltaT: The amount of time that has passed in milliseconds
   
   This is called by the World in every time_slice, use it to do fancy time dependant effects (such 
   as smooth camera movement or swaying).
*/
void Camera::time_slice (Uint32 deltaT)
{
  if(t <= deltaTime)
    {t += deltaT;}
  //printf("time is: t=%f\n", t );
  update_desired_place ();
  jump (NULL);
}

/**
   \brief this calculates the location where the track wants the camera to be
   
   This refreshes the placement the camera should have according to the 
   bound entity's position on the track.
*/
void Camera::update_desired_place ()
{
  switch(cameraMode)
    {
      
    case ELLIPTICAL:
      {
	//r = actual_place.r 
	Orxonox *orx = Orxonox::getInstance();
	Location lookat;  
	Placement plFocus;
	if( bound != NULL)
	  {
	    bound->get_lookat (&lookat);
	    orx->get_world()->calc_camera_pos (&lookat, &plFocus);
	    Quaternion *fr;
	    if(t < 20.0)
	      {
		Vector *start = new Vector(0.0, 1.0, 0.0);
		//r = /*actual_place.r*/ *start - plFocus.r;
		r = *(new Vector(0.0, 5.0, 0.0));

		Vector up(0.0, 0.0, 1.0);
		
		Vector op(1.0, 0.0, 0.0);
		float angle = angle_deg(op, *start);
		printf("angle is: %f\n", angle);

		//if in one plane
		from = new Quaternion(angle, up);

		//from = new Quaternion(*start, *up);
		//&from = &plFocus.w;
		//fr = &plFocus.w; real quaternion use
		


		Vector vDirection(1.0, 0.0, 0.0);
		//vDirection = plFocus.w.apply(vDirection);
		to = new Quaternion(vDirection, *start);
		res = new Quaternion();
	      }
	    //printf("vector r = %f, %f, %f\n",r.x, r.y, r.z );
	    rAbs = r.len();
	    if(t < 30.0) /* FIXME!!*/
	      {
		ka = rAbs / deltaTime*deltaTime;
	      }
	    /* this is the new length of the vector */
	    //float len = ka * powf((deltaTime - t), 2);
	    
	    /* calc the rotation */
	    /*
	    Vector axis(0.0, 0.0, 1.0);
	    if(t < 30.0)
	      a0 = PI/4 - atanf(fabs(r.x) / fabs(r.y));
	    printf("a0 = %f\n", a0);
	    float angle = a0/deltaTime * (deltaTime - t);
	    printf("angle is: %f\n", angle);
	    Quaternion q(angle, axis);
	    */
	    //r = q.apply(r);
	    //r = r * (len/r.len());
	    
	    //res->quatSlerp(from, to, t/deltaTime, res);
	    res->quatSlerp(to, from, t/deltaTime, res);

	    Vector ursp(0.0, 0.0, 0.0);
	    desired_place.pos = /*plFocus.r -*/ ursp - res->apply(r); 

	    printf("desired place is: %f, %f, %f\n", desired_place.pos.x, desired_place.pos.y, desired_place.pos.z);
	    //plLastBPlace = *bound->get_placement();
	  } 
      }
      break;
    case SMOTH_FOLLOW:
      {
	Placement *plBound = bound->get_placement();
	Location lcBound;
	if(bound != null)
	  {
	    bound->get_lookat(&lcBound);
	    Vector vDirection(0.0, 0.0, 1.0);
	    vDirection = plBound->rot.apply(vDirection);
	    desired_place.pos = (vDirection * ((lcBound.dist-10.0)/* / l*/)) + Vector(0,0,5.0);
	  }
	break;
      }
      /* this is a camera mode that tries just to follow the entity. */
    case STICKY:
      {
	if(bound != null)
	  {
	    Placement *plBound = bound->get_placement();
	    Vector vDirection(0.0, 0.0, 1.0);
	    Vector eclipticOffset(0.0, 0.0, 5.0);
	    vDirection = plBound->rot.apply(vDirection);
	    desired_place.pos = plBound->pos - vDirection*10 + eclipticOffset;
	  }
	break;
      }
      /* the camera is handled like an entity and rolls on the track */
    case NORMAL:
      Location lookat;  
      if( bound != NULL && world != NULL )
	{
	  bound->get_lookat (&lookat);
	  world->calc_camera_pos (&lookat, &desired_place);
	} 
      else
	{
	  desired_place.pos = Vector (0,0,0);
	  desired_place.rot = Quaternion (); 
	}
      break;
    }
}

/**
   \brief initialize rendering perspective according to this camera
   
   This is called immediately before the rendering cycle starts, it sets all global
   rendering options as well as the GL_PROJECTION matrix according to the camera.
*/
void Camera::apply ()
{
  glMatrixMode (GL_PROJECTION);
  glLoadIdentity ();
  // view
  // TO DO: implement options for frustum generation
  glFrustum(-1.0, 1.0, -1.0, 1.0, 1.5, 250.0);
  //Vector up(0,0,1);
  //Vector dir(1,0,0);
  //Quaternion q(dir,up);
  //float matrix[4][4];
  //q.conjugate().matrix (matrix);
  //glMultMatrixf ((float*)matrix);
  //glTranslatef (10,0,-5);
  //
  //dir = Vector(-1,-1,0);
  //q = Quaternion( dir, up);
  //glMatrixMode (GL_MODELVIEW);
  //glLoadIdentity ();
  //q.matrix (matrix);
  //glMultMatrixf ((float*)matrix);
  //glTranslatef (2,2,0);
  //
  //glBegin(GL_TRIANGLES);
  //glColor3f(1,0,0);
  //glVertex3f(0,0,0.5);
  //glColor3f(0,1,0);
  //glVertex3f(-0.5,0,-1);
  //glColor3f(0,0,1);
  //glVertex3f(0.5,0,-1);
  //glEnd();	

  // ===== first camera control calculation option
  // rotation
  float matrix[4][4];
  actual_place.rot.conjugate().matrix (matrix);
  /* orientation and */
  glMultMatrixf ((float*)matrix);
  /*  translation */
  glTranslatef (-actual_place.pos.x, -actual_place.pos.y,- actual_place.pos.z);
  //Placement *plBound = bound->get_placement();

  // ===== second camera control calculation option
  /*
    gluLookAt(actual_place.r.x, actual_place.r.y, actual_place.r.z, 
              plBound->r.x, plBound->r.y, plBound->r.z,
              0.0, 0.0, 1.0);
  */

  glMatrixMode (GL_MODELVIEW);
  glLoadIdentity ();
}

/**
  \brief set the camera position
  \param plc: The Placement to set the camera to 
	
	This will set the actual and desired placement of the camera to plc
*/
void Camera::jump (Placement* plc = NULL)
{
  if( plc == NULL)
    {
      actual_place = desired_place;
      //printf("Camera|jump: camer@ %f, %f, %f\n\n", actual_place.r.x, actual_place.r.y, actual_place.r.z);
    }
  else
    {
      desired_place = *plc;
      actual_place = *plc;
    }
}

/**
  \brief bind the camera to an entity
  \param entity: The enitity to bind the camera to
	
	This sets the focus of the camera to the given entity. This means that it will use the given WorldEntity's
	Location and get_lookat() to determine the viewpoint the camera will render from.
	Note that you cannot bind a camera to a free entity.
*/
void Camera::bind (WorldEntity* entity)
{
  if( entity != NULL)
    {
      if( entity->isFree ()) printf("Cannot bind camera to free entity");
      else 
	{
	  bound = entity;
	}
    } 
}


void Camera::setWorld(World* world)
{
  this->world = world;
}