#include <qapplication.h>
#include <animal/argumentParser.h>
#include <animal/X3DTK/mainScene.h>
#include <animal/X3DTK/Qt/mainControllerGUI/MainController.h>

// X3D Nodes and their associated GUI

#include <animal/X3DTK/X3D/morphingNode/morphingNode.h>
#include <animal/X3DTK/Qt/morphingEngineGUI/morphingEngineQt.h>

#include <animal/X3DTK/X3D/massSpringNode/massSpringNode.h>
#include <animal/X3DTK/Qt/massSpringEngineGUI/massSpringEngineGUI.h>

#include <animal/X3DTK/X3D/frameNode/frameNode.h>
#include <animal/X3DTK/X3D/frameNode/frameNodeGUI.h>

#include "spinningCube/spinningCubeNode.h"
#include "spinningCube/spinningCubeQt.h"

#include "spinningFrame/spinningFrameNode.h"
#include "spinningFrame/spinningFrameNodeGUI.h"

#include "particles/ParticleSystemNode.h"
#include "particles/ParticleSystemNodeQt.h"
#include "particles/SpringForceFieldNode.h"
#include "particles/SpringForceFieldNodeQt.h"
#include "particles/FixedParticleConstraintNode.h"
#include "particles/ParticleCollisionConstraintNode.h"
#include "particles/TetrahedronFEMForceFieldNode.h"
#include "particles/TetrahedronFEMForceFieldNodeQt.h"
#include "particles/TriangleFEMForceFieldNode.h"
#include "particles/TriangleFEMForceFieldNodeQt.h" 
#include "particles/ParticleMeshNode.h"
#include "particles/ParticleMeshNodeQt.h"

#include "animal/skinning/characterNode.h"
#include "animal/skinning/skinningEngineGUI.h"
#include "animal/skinning/keyFrameNode.h"


#include "animal/deformableOctree/DeformableOctreeNode.h"
#include "animal/deformableOctree/DeformableOctreeShapeNode.h"
#include "animal/deformableOctree/DeformableOctreeQt.h"
#include "animal/deformableOctree/DeformableOctreeShapeQt.h" 


int main(int argc, char* argv[]) 
{
    // Read command line arguments
    std::string fileName="";
    std::string defaultFileDirectory="./files-x3d";
    bool use_docked_windows = false;
    animal::parse("AnimX3D")
    .option(&defaultFileDirectory,'d',"dir","default x3d scenes directory") 
    .option(&fileName,'f',"file","x3d scene file")
    .option(&use_docked_windows,0,"dock","use Qt docked windows")
    (argc,argv);

    // Creation of the X3DTK::MainScene
    X3DTK::MainScene mainScene;

    // Definition of new x3d node types, so that they can be
    // read/written from/to a file.
    // insert the declaration of your nodes <---------------------------------------
    mainScene.newX4DClass<X3DTK::X3D::MorphingNode>();
    mainScene.newX4DClass<X3DTK::X3D::MassSpringNode>();
    mainScene.newX4DClass<X3DTK::X3D::SpinningCubeNode>();
    mainScene.newX4DClass<X3DTK::X3D::FrameNode>();
    mainScene.newX4DClass<X3DTK::X3D::SpinningFrameNode>();
    mainScene.newX4DClass<X3DTK::X3D::ParticleSystemNode>();
    mainScene.newX4DClass<X3DTK::X3D::ParticleMeshNode>();
    mainScene.newX4DClass<X3DTK::X3D::FixedParticleConstraintNode>();
    mainScene.newX4DClass<X3DTK::X3D::SpringForceFieldNode>();
    mainScene.newX4DClass<X3DTK::X3D::ParticleCollisionConstraintNode>();
    mainScene.newX4DClass<X3DTK::X3D::TetrahedronFEMForceFieldNode>();
    mainScene.newX4DClass<X3DTK::X3D::TriangleFEMForceFieldNode>();
    mainScene.newX4DClass<X3DTK::X3D::CharacterNode>();
    mainScene.newX4DClass<X3DTK::X3D::KeyFrameNode>();
    
   mainScene.newX4DClass<X3DTK::X3D::DeformableOctreeNode>();
   mainScene.newX4DClass<X3DTK::X3D::DeformableOctreeShapeNode>();

    // Graphics user interface (GUI). Here we use Qt.
    QApplication application(argc,argv);
    MainController* mainController = new MainController(&mainScene, use_docked_windows);
    mainController->setX3dDirectory(defaultFileDirectory);
    mainController->show();
    if (fileName=="")
        mainController->fileOpen();
    else
        mainController->fileOpen(fileName.c_str());

    // Declaration of functions which return a control widget for given node types.
    // insert the definition of your widget creation functions <----------------------
    mainController->defineQWidgetCreationFunction(X3DTK::Qt::createMorphingNodeQWidget);
    mainController->defineQWidgetCreationFunction(X3DTK::Qt::createMassSpringNodeQWidget);
    mainController->defineQWidgetCreationFunction(X3DTK::Qt::createSpinningCubeQWidget);
    mainController->defineQWidgetCreationFunction(X3DTK::Qt::createSpinningFrameQWidget);
    mainController->defineQWidgetCreationFunction(X3DTK::X3D::createParticleSystemNodeQWidget);
    mainController->defineQWidgetCreationFunction(X3DTK::X3D::createParticleMeshNodeQWidget);
    mainController->defineQWidgetCreationFunction(X3DTK::X3D::createSpringForceFieldNodeQWidget);
    mainController->defineQWidgetCreationFunction(X3DTK::X3D::createTetrahedronFEMForceFieldNodeQWidget);
    mainController->defineQWidgetCreationFunction(X3DTK::X3D::createTriangleFEMForceFieldNodeQWidget);
    mainController->defineQWidgetCreationFunction(X3DTK::Qt::createSkinningNodeQWidget);
    mainController->defineQWidgetCreationFunction(X3DTK::X3D::createParticleCollisionConstraintQWidget);

   mainController->defineQWidgetCreationFunction(X3DTK::Qt::createDeformableOctreeQWidget);
   mainController->defineQWidgetCreationFunction(X3DTK::Qt::createDeformableOctreeShapeQWidget);

    // In the following example, a SpinningHexahedronEngine is added to the scene.
    // This engine does not belong to the scenegraph, but it is animated and drawn
    // just like any engine node. You can not dynamically remove it from the scene.
    // Include "spinningHexahedron/spinningHexahedronEngine.h" to make it work.
    // This can be used to test an engine before developing the associated X3D node.
    // Uncomment and adapt this code to your own engine.    
    //  animal::SpinningHexahedronEngine * SHE = new animal::SpinningHexahedronEngine();
    //  mainController->addEngine(SHE);

    // You can also use your own viewer instead of the standard one.
    // It has to derive from X3DTK::Qt::Viewer
    // Uncomment and adapt this code to your own viewer.
    //  mainController->setViewer(new X3DTK::Qt::Viewer(mainController->centralWidget(), "viewer"));

    // Run main loop
    application.setMainWidget(mainController);
    return application.exec();
}