/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2010-2012 University of Bonn. All rights reserved.
 * Copyright (C)  2013 Frederik Heber. All rights reserved.
 * 
 *
 *   This file is part of MoleCuilder.
 *
 *    MoleCuilder 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 of the License, or
 *    (at your option) any later version.
 *
 *    MoleCuilder is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with MoleCuilder.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * GLMoleculeObject_molecule.cpp
 *
 *  Created on: Mar 30, 2012
 *      Author: ankele
 */


// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "GLMoleculeObject_molecule.hpp"

#include <Qt3D/qglscenenode.h>
#include <Qt3D/qglbuilder.h>

#include "UIElements/Views/Qt4/Qt3D/GLMoleculeObject_atom.hpp"

#include "CodePatterns/MemDebug.hpp"

#include "CodePatterns/Assert.hpp"
#include "CodePatterns/IteratorAdaptors.hpp"
#include "CodePatterns/Log.hpp"

#include "LinearAlgebra/Vector.hpp"
#include "LinkedCell/PointCloudAdaptor.hpp"
#include "LinkedCell/linkedcell.hpp"
#include "Tesselation/tesselation.hpp"
#include "Tesselation/BoundaryLineSet.hpp"
#include "Tesselation/BoundaryTriangleSet.hpp"
#include "Tesselation/CandidateForTesselation.hpp"
#include "UIElements/Qt4/InstanceBoard/QtObservedInstanceBoard.hpp"
#include "Atom/TesselPoint.hpp"

static QGLSceneNode *createMoleculeMesh(const QGeometryData &_geo)
{
  // Build a mesh from the geometry.
  QGLBuilder builder;
  builder.addTriangles(_geo);
  QGLSceneNode *mesh = builder.finalizedSceneNode();
  return mesh;
}

GLMoleculeObject_molecule::GLMoleculeObject_molecule(
    QObject *parent,
    QtObservedMolecule::ptr &_ObservedMolecule) :
  GLMoleculeObject((QGLSceneNode *)NULL, parent),
  hoverAtomId(-1),
  ObservedMolecule(_ObservedMolecule)
{
  init();
}

GLMoleculeObject_molecule::GLMoleculeObject_molecule(
    QGLSceneNode *mesh[],
    QObject *parent,
    QtObservedMolecule::ptr &_ObservedMolecule) :
  GLMoleculeObject(mesh, parent),
  TesselationUptodate(false),
  hoverAtomId(-1),
  ObservedMolecule(_ObservedMolecule)
{
  init();
}

void GLMoleculeObject_molecule::init()
{
  setObjectId(ObservedMolecule->getMolIndex());
  setMaterial(getMaterial(1));

  m_selected = ObservedMolecule->getMolSelected();

  // initially, atoms and bonds should be visible
  m_visible = false;

  connect (ObservedMolecule.get(), SIGNAL(tesselationhullChanged()), this, SLOT(setTesselationOutOfDate()));
  connect (ObservedMolecule.get(), SIGNAL(boundingboxChanged()), this, SLOT(resetBoundingBox()));
  connect (ObservedMolecule.get(), SIGNAL(indexChanged()), this, SLOT(resetIndex()));
  /// these are channeled through GLWorldScene instead to ensure synchronicity
//  connect (ObservedMolecule.get(), SIGNAL(atomInserted(QtObservedAtom::ptr)),
//      this, SLOT(atomInserted(QtObservedAtom::ptr)) );
//  connect (ObservedMolecule.get(), SIGNAL(atomRemoved(const atomId_t)),
//      this, SLOT(atomRemoved(const atomId_t)) );
  connect (ObservedMolecule.get(), SIGNAL(selectedChanged()), this, SLOT(resetSelected()));
}

GLMoleculeObject_molecule::~GLMoleculeObject_molecule()
{}

QGeometryData GLMoleculeObject_molecule::updateTesselationHull() const
{
  QGeometryData geo;

  const molecule * const molref =
      QtObservedMolecule::getMolecule(ObservedMolecule->getMolIndex());
  if (molref == NULL) {
    ELOG(1, "Could not createMoleculeMesh, molecule with id "
        << ObservedMolecule->getMolIndex() << " already gone.");
    return geo;
  }
  double minradius = 2.; // TODO: set to maximum bond length value
  LOG(3, "DEBUG: Molecule fits into sphere of radius " << minradius);
  // check minimum bond radius in molecule
  double minlength = std::numeric_limits<double>::max();
  size_t NoAtoms = 0;
  for (molecule::const_iterator iter = molref->begin();
      iter != molref->end(); ++iter) {
    const BondList &ListOfBonds = (*iter)->getListOfBonds();
    for (BondList::const_iterator bonditer = ListOfBonds.begin();
         bonditer != ListOfBonds.end(); ++bonditer) {
      const double bond_distance = (*bonditer)->GetDistance();
      minlength = std::min(bond_distance, minlength);
    }
    ++NoAtoms;
  }
  minradius = std::max( std::max(minradius, minlength), 1.);

  // we need at least three points for tesselation
  if (NoAtoms >= 3) {
    // Tesselate the points.
    Tesselation T;
    PointCloudAdaptor<molecule> cloud(
        const_cast<molecule *>(molref),
        ObservedMolecule->getMolName());
    T(cloud, minradius);

    // Fill the points into a Qt geometry.
    LinkedCell_deprecated LinkedList(cloud, minradius);
    std::map<int, int> indices;
    std::map<int, Vector> normals;
    int index = 0;
    for (PointMap::const_iterator piter = T.PointsOnBoundary.begin();
        piter != T.PointsOnBoundary.end(); ++piter) {
      const Vector &point = piter->second->getPosition();
      // add data to the primitive
      geo.appendVertex(QVector3D(point[0], point[1], point[2]));
      Vector normalvector;
      for (LineMap::const_iterator lineiter = piter->second->lines.begin();
          lineiter != piter->second->lines.end(); ++lineiter)
        for (TriangleMap::const_iterator triangleiter = lineiter->second->triangles.begin();
            triangleiter != lineiter->second->triangles.end(); ++triangleiter)
          normalvector +=
              triangleiter->second->NormalVector;
      normalvector.Normalize();
      geo.appendNormal(QVector3D(normalvector[0], normalvector[1], normalvector[2]));
      geo.appendColor(QColor(1, 1, 1, 1));
      geo.appendTexCoord(QVector2D(0, 0));
      indices.insert( std::make_pair( piter->second->getNr(), index++));
    }

    // Fill the tesselated triangles into the geometry.
    for (TriangleMap::const_iterator runner = T.TrianglesOnBoundary.begin();
        runner != T.TrianglesOnBoundary.end(); runner++) {
      int v[3];
      for (size_t i=0; i<3; ++i)
        v[i] = runner->second->endpoints[i]->getNr();

      // Sort the vertices so the triangle is clockwise (relative to the normal vector).
      Vector cross = T.PointsOnBoundary[v[1]]->getPosition() - T.PointsOnBoundary[v[0]]->getPosition();
      cross.VectorProduct(T.PointsOnBoundary[v[2]]->getPosition() - T.PointsOnBoundary[v[0]]->getPosition());
      if (cross.ScalarProduct(runner->second->NormalVector) > 0)
        geo.appendIndices(indices[v[0]], indices[v[1]], indices[v[2]]);
      else
        geo.appendIndices(indices[v[0]], indices[v[2]], indices[v[1]]);
    }
  }

  return geo;
}

void GLMoleculeObject_molecule::setTesselationOutOfDate()
{
  TesselationUptodate = false;
}

void GLMoleculeObject_molecule::resetTesselationHull()
{
  if (!TesselationUptodate) {
    TesselationHull = updateTesselationHull();
    updateMesh(createMoleculeMesh(TesselationHull));
    TesselationUptodate = true;
  }
}

void GLMoleculeObject_molecule::resetBoundingBox()
{
  molecule::BoundingBoxInfo info = ObservedMolecule->getBoundingBox();
  setPosition(QVector3D(info.position[0], info.position[1], info.position[2]));
  setScale(info.radius + 0.3); // getBoundingSphere() only sees atoms as points, so make the box a bit bigger
}

void GLMoleculeObject_molecule::resetIndex()
{
  const atomId_t newId = ObservedMolecule->getMolIndex();
  const size_t oldId = objectId();
  ASSERT( newId != oldId,
      "GLMoleculeObject_molecule::resetIndex() - index "+toString(newId)+" did not change.");
  LOG(4, "INFO: GLMoleculeObject_molecule: new index is "+toString(newId)+".");
  setObjectId(newId);
}

void GLMoleculeObject_molecule::resetSelected()
{
  const bool new_selected = ObservedMolecule->getMolSelected();
  m_selected = new_selected;

  emit changed();
}

void GLMoleculeObject_molecule::initialize(QGLView *view, QGLPainter *painter)
{
  // Initialize all of the mesh objects that we have as children.
  if (m_visible) {
    GLMoleculeObject::initialize(view, painter);
  } else {
   foreach (QObject *obj, children()) {
     GLMoleculeObject *meshobj = qobject_cast<GLMoleculeObject *>(obj);
       if (meshobj)
         meshobj->initialize(view, painter);
   }
  }
}

void GLMoleculeObject_molecule::draw(QGLPainter *painter, const QVector4D &cameraPlane)
{
  // draw either molecule's mesh or all atoms and bonds
  if (m_visible) {
    resetTesselationHull();

    painter->modelViewMatrix().push();

    // Apply the material and effect to the painter.
    QGLMaterial *material;
    if (m_hovering)
        material = m_hoverMaterial;
    else if (m_selected)
        material = m_selectionMaterial;
    else
        material = m_material;

    ASSERT(material, "GLMoleculeObject::draw: chosen material is NULL");

    painter->setColor(material->diffuseColor());
    painter->setFaceMaterial(QGL::AllFaces, material);
    if (m_effect)
        painter->setUserEffect(m_effect);
    else
        painter->setStandardEffect(QGL::LitMaterial);

    // Mark the object for object picking purposes.
    int prevObjectId = painter->objectPickId();
    if (m_objectId != -1)
        painter->setObjectPickId(m_objectId);

    m_mesh[0]->draw(painter);

    // Turn off the user effect, if present.
    if (m_effect)
        painter->setStandardEffect(QGL::LitMaterial);

    // Revert to the previous object identifier.
    painter->setObjectPickId(prevObjectId);

    // Restore the modelview matrix.
    painter->modelViewMatrix().pop();

    //    GLMoleculeObject::draw(painter, cameraPlane);
  } else {
    // Draw all of the mesh objects that we have as children.
    foreach (QObject *obj, children()) {
      GLMoleculeObject *meshobj = qobject_cast<GLMoleculeObject *>(obj);
      if (meshobj)
        meshobj->draw(painter, cameraPlane);
    }

    // update bounding box prior to selection
    resetBoundingBox();

    painter->modelViewMatrix().push();
    painter->modelViewMatrix().translate(m_position);
    if (m_rotationAngle != 0.0f)
      painter->modelViewMatrix().rotate(m_rotationAngle, m_rotationVector);
    if ((m_scaleX != 1.0f) || (m_scaleY != 1.0f) || (m_scaleZ != 1.0f))
      painter->modelViewMatrix().scale(m_scaleX, m_scaleY, m_scaleZ);

    // Draw a box around the mesh, if selected.
    if (m_selected)
      drawSelectionBox(painter);

    // Restore the modelview matrix.
    painter->modelViewMatrix().pop();
  }
}

void GLMoleculeObject_molecule::setVisible(bool value)
{
  // first update the mesh if we are going to be visible now
  if (value)
    updateTesselationHull();
  // then emit onward
  GLMoleculeObject::setVisible(value);

  emit changed();
  emit changeOccured();
}

std::ostream &operator<<(std::ostream &ost, const GLMoleculeObject_molecule::BondIds &t)
{
  ost << t.first << "," << t.second;
  return ost;
}