// ===================================================================
// $Id$

// Qt headers
#include <QtGui>
#include <QtOpenGL>

// C++ standard headers
#include <cmath>

// local headers
#include "common.h"
#include "QtGlViewer.h"
#include "QtGlRenderer.h"
#include "Trackball.h"
#include "RssPreprocessor.h"
#include "SceneGraph.h"
#include "ViewCellsManager.h"


namespace GtpVisibilityPreprocessor {

QtGlRendererWidget *renderer;

QtGlViewer::QtGlViewer(QWidget *parent,
					   QtGlRendererWidget *renderer):
  QGLWidget(parent), mRenderer(renderer)
{
	scale = 1.0f;
	mWireframe = false;
	mModelMatrix = IdentityMatrix();

	trackball(manipulatorLastQuat, 0.0f, 0.0f, 0.0f, 0.0f);
	//connect(renderer, SIGNAL(PvsUpdated()), this, SLOT(updateGL()));
	//connect(renderer, SIGNAL(cutupdated), this, SLOT(updateGL()));

	const int delay = 250; // in milliseconds
	timerId = startTimer(delay);
}
  
QSize
QtGlViewer::minimumSizeHint() const
{
  return QSize(100, 100);
}

QSize
QtGlViewer::sizeHint() const {
  return QSize(500, 500);
}
  
// This method has to be rendefined by all renderer implementations
void QtGlViewer::RenderScene()
{
	GLfloat mat_ambient[] = {0.1, 0.1, 0.1, 1.0};

	// mat_specular and mat_shininess are NOT default values
	GLfloat mat_diffuse[] = {0.5, 1.0, 0.5, 1.0};
	GLfloat mat_specular[] = {0.3, 0.3, 0.3, 1.0};
	GLfloat mat_shininess[] = {1.0};

	GLfloat light_ambient[] = {0.1, 0.1, 0.1, 1.0};
	GLfloat light_diffuse[] = {0.5, 0.5, 0.5, 1.0};
	GLfloat light_specular[] = {0.0, 0.0, 0.0, 1.0};

	GLfloat lmodel_ambient[] = {0.2, 0.2, 0.2, 1.0};


	// default material
	/*glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, mat_ambient);
	glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, mat_diffuse);
	glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, mat_specular);
	glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, mat_shininess);
*/
	// a light
	glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
	glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
	glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
	glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);

	
	//GLfloat infinite_light2[] = {-0.3, 1.5f, 1.0f, 0.0f};
	//glLightfv (GL_LIGHT1, GL_POSITION, infinite_light2);
	glColor3f(0.8f, 0.8f, 0.8f);
	
	glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
	glDisable(GL_COLOR_MATERIAL);
	//glEnable(GL_COLOR_MATERIAL);

	++ mRenderer->mFrame;
	
	glEnable(GL_DEPTH_TEST);
	glDepthMask(GL_TRUE);

	glCullFace(GL_BACK);
	glShadeModel(GL_FLAT);

	glDisable(GL_BLEND);

	mRenderer->mDummyViewPoint = mDummyViewPoint;
	
	//glEnable(GL_LIGHTING);

	mRenderer->RenderPvs();
	
	glDisable(GL_LIGHTING);

 	if (0 && mRenderer->mShowRays) 
	{
 		mRenderer->RenderRays(mRenderer->mViewCellsManager->mVizBuffer.GetRays());
 	}

	if (mRenderer->mShowRenderCost) 
	  mRenderer->RenderRenderCost();

	// render into the right side of the window buffer
	if (mRenderer->mRenderViewCells)
		mRenderer->RenderViewCells();

	mRenderer->RenderViewPoint();

	glColor3f(1.0f, 1.0f, 1.0f);
	mRenderer->RenderInfo();
}


void
QtGlViewer::initializeGL()
{  
  const char *vendorString, *rendererString, *versionString, *extString;

  // get GL info
  vendorString = (const char *) glGetString(GL_VENDOR);
  rendererString = (const char *) glGetString(GL_RENDERER);
  versionString = (const char *) glGetString(GL_VERSION);
  extString = (const char *) glGetString(GL_EXTENSIONS);
  
  Debug << "Info: GL Vendor = "<<vendorString<<endl
        << "Info: GL Renderer = "<<rendererString<<endl
        << "Info: GL Version = "<<versionString<<endl
        << "Info: GL Extensions = "<<extString<<endl<<flush;


	glEnable(GL_LIGHTING);
	glEnable(GL_LIGHT0);
	//glEnable(GL_LIGHT1);

	// set position of the light
	GLfloat infinite_light[] = {0, -1.0, 0, 1.0f};
	glLightfv(GL_LIGHT0, GL_POSITION, infinite_light);

  return;
}

void
QtGlViewer::paintGL()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();

	//float m[4][4];
	Matrix4x4 m;

	glLoadIdentity();
	gluLookAt(0.0, 0.0, 1.0,  /* eye is at (0,0,30) */
		      0.0, 0.0, 0.0,  /* center is at (0,0,0) */
		      0.0, 1.0, 0.);  /* up is in positive Y direction */

	build_rotmatrix(m.x, manipulatorLastQuat);
	glMultMatrixf((float *)m.x);

	float s = scale * 20.0f / Magnitude(mRenderer->mSceneGraph->GetBox().Diagonal());
	glScalef(s, s, s);

	// TODO: determine model matrix for establishing right rendering order for transparency
	Vector3 t = -mRenderer->mSceneGraph->GetBox().Center();
	glTranslatef(t.x, t.y, t.z);

	/*mDummyViewPoint = -t;
	mDummyViewPoint /= s;

	//glGetFloatv(GL_MODELVIEW_MATRIX, m1);
*/
	m.Invert();

	mModelMatrix *= m;
	mDummyViewPoint = mModelMatrix * Vector3(0, 0, 0);

	//mDummyViewPoint 
	//cout << "view point: " << mDummyViewPoint << endl;
	RenderScene();
}

void
QtGlViewer::resizeGL(int width, int height)
{
  glViewport(0, 0, width, height);
  
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluPerspective(70.0, 1.0, 0.1, 100.0);
  //  glOrtho(-0.5*width/height, +0.5*width/height, 0.5, -0.5, 4.0, 15.0);
  glMatrixMode(GL_MODELVIEW);
}


void
QtGlViewer::mousePressEvent(QMouseEvent *event)
{
  lastPos = event->pos();
}

void
QtGlViewer::keyPressEvent ( QKeyEvent * e )
{
  switch (e->key()) {
  case Qt::Key_W:
		mWireframe  = !mWireframe;
		updateGL();
  default:
		e->ignore();
		break;
  }
  updateGL();
}

void
QtGlViewer::mouseMoveEvent(QMouseEvent *event)
{
  int dx = event->x() - lastPos.x();
  int dy = event->y() - lastPos.y();  
  
  if (event->modifiers() & Qt::CTRL)
		{
			scale = scale*(1.0f - dy/(float)height());
			if (scale < 0.01f)
				scale = 0.01f;
			updateGL();
		}
  else {
		float W = width();
		float H = height();
		int x = event->x();
		int lastX = lastPos.x();
		int y = event->y();
		int lastY = lastPos.y();
	
		float quat[4];
		trackball(quat,
							(2.0 * lastX - W) / W,
							(H - 2.0 * lastY) / H,
							(2.0 * x - W) / W,
							(H - 2.0 * y) / H
							);
		add_quats(quat, manipulatorLastQuat, manipulatorLastQuat);
  }
  
  lastPos = event->pos();
  updateGL();
}

void QtGlViewer::timerEvent(QTimerEvent *event) 
{
	update();
}


}