#include "SimpleX3DGLScene.h"
#include "X3D_Loader.h"
#include "X3D_InlineLoader.h"
#include "X3D_BBoxUpdater.h"
#include "X3D_GLBuilder.h"
#include "GL_Renderer.h"
#include "MemReleaser.h"
#include "X3D_FileValidator.h"
#include "X3D_Scene.h"
#include "GL_Scene.h"
#include "BBox.h"

#include <iostream>
#include <time.h>

using namespace std;

namespace X3DTK {

SimpleX3DGLScene::SimpleX3DGLScene()
: scene(0), glscene(0)
{
  _loader = Singleton<X3D::Loader>::getInstance();
  _inlineLoader = Singleton<X3D::InlineLoader>::getInstance();
  _bboxupdater = Singleton<X3D::BBoxUpdater>::getInstance();
  _builder = Singleton<X3D::GLBuilder>::getInstance();
  _renderer = Singleton<GL::Renderer>::getInstance();
  _releaser = Singleton<MemReleaser>::getInstance();
}

SimpleX3DGLScene::~SimpleX3DGLScene()
{
  // releasing the GL scene graph before the X3D one, because of node dependencies.
  _releaser->release(glscene);
  _releaser->release(scene);
  scene = 0;
  glscene = 0;
}

void SimpleX3DGLScene::setLoader(X3D::Loader *loader)
{
  _loader = loader;
}

void SimpleX3DGLScene::setBBoxUpdater(X3D::BBoxUpdater *bboxUpdater)
{
  _bboxupdater = bboxUpdater;
}

void SimpleX3DGLScene::setGLBuilder(X3D::GLBuilder *builder)
{
  _builder = builder;
}

void SimpleX3DGLScene::setGLRenderer(GL::Renderer *renderer)
{
  _renderer = renderer;
}

void SimpleX3DGLScene::setMemReleaser(MemReleaser *memReleaser)
{
  _releaser = memReleaser;
}
  
void SimpleX3DGLScene::setFileValidator(X3D::FileValidator *fileValidator)
{
  _loader->setFileValidator(fileValidator);
}
  
void SimpleX3DGLScene::load(const char *file, bool fileValidation)
{
  loadFile(file, fileValidation);
  computeBBox();
  buildGLScene();
}

void SimpleX3DGLScene::draw()
{
  _renderer->render(glscene);
}

void SimpleX3DGLScene::select(double x, double y)
{
  _renderer->select(glscene, x, y);
}

void SimpleX3DGLScene::release()
{
  // releasing the GL scene graph before the X3D one, because of node dependencies.
  _releaser->release(glscene);
  _releaser->release(scene);
  scene = 0;
  glscene = 0;  
}

void SimpleX3DGLScene::loadFile(const char *file, bool fileValidation)
{
  // releasing the GL scene graph before the X3D one, because of node dependencies.
  _releaser->release(glscene);  
  _releaser->release(scene);
  scene = 0;
  glscene = 0;
  
  scene = _loader->load(file, fileValidation);
  _inlineLoader->load(scene, true);
}

void SimpleX3DGLScene::computeBBox()
{
  _bboxupdater->update(scene, true);
  
  if (scene != 0)
  {
    SFVec3f center = scene->getBBoxCenter();
    SFVec3f size = scene->getBBoxSize();

    SFVec3f A = center + 0.5f*size;
    SFVec3f B = center - 0.5f*size;

    if (A.x < B.x)
    {
      min.x = A.x;
      max.x = B.x;
    }  
    else
    {
      min.x = B.x;  
      max.x = A.x;
    }  
  
    if (A.y < B.y)
    {
      min.y = A.y;
      max.y = B.y;
    }  
    else
    {
      min.y = B.y;  
      max.y = A.y;
    }
  
    if (A.z < B.z)
    {
      min.z = A.z;
      max.z = B.z;
    }  
    else
    {
      min.z = B.z;  
      max.z = A.z;
    }  
  }  
}

void SimpleX3DGLScene::buildGLScene()
{
  glscene = _builder->build(scene);
}


}