#include <iostream>
#include <string>
#include <utility>

#include <vtkActor.h>
#include <vtkInteractorStyleSwitch.h>
#include <vtkProperty.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSmartPointer.h>

#include <cpm/DataStructures/QuadEdgeMesh.h>
#include <cpm/DataStructures/SimplexMesh.h>
#include <cpm/Algorithms/QuadEdge/MeshToDualFilter.h>
#include <cpm/Algorithms/Simplex/DeformationFilter.h>
#include <cpm/Algorithms/Simplex/InternalForceFunction.h>
#include <cpm/IO/MeshReader.h>
#include <cpm/VTK/MeshMapper.h>
#include <cpm/VTK/ThreadedDeformation.h>

// -------------------------------------------------------------------------
const unsigned int Dim = 3;
const unsigned int Order = 2;

typedef float TScalar;
typedef cpm::DataStructures::QuadEdgeMesh< TScalar, Dim >       TTriangulation;
typedef cpm::DataStructures::SimplexMesh< TScalar, Order, Dim > TSimplex;

typedef cpm::IO::MeshReader< TTriangulation > TTriangulationReader;
typedef cpm::VTK::MeshMapper< TSimplex >      TSimplexMapper;
typedef
cpm::Algorithms::QuadEdge::MeshToDualFilter< TTriangulation, TSimplex >
TTriangulationToSimplexFilter;
typedef
cpm::Algorithms::Simplex::DeformationFilter< TSimplex >
TDeformationFilter;
typedef
cpm::Algorithms::Simplex::InternalForceFunction< TSimplex >
TInternalForce;
typedef
cpm::VTK::ThreadedDeformation< TDeformationFilter >
TThreadedExecution;

// -------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
  // WARNING: Always call this static method FIRST!!!
  TThreadedExecution::InitThreadSupport( );

  // Input parameters
  if( argc < 2 )
  {
    std::cerr
      << "Usage: " << argv[ 0 ]
      << " input_triangulation"
      << std::endl;
    return( 1 );

  } // fi
  std::string input_triangulation_fn = argv[ 1 ];

  // Read triangulation
  TTriangulationReader::Pointer input_triangulation_reader =
    TTriangulationReader::New( );
  input_triangulation_reader->SetFileName( input_triangulation_fn );

  // Compute the simplex (i.e. the triangulation's dual) mesh
  TTriangulationToSimplexFilter::Pointer triangl2simplex =
    TTriangulationToSimplexFilter::New( );
  triangl2simplex->SetInput( input_triangulation_reader->GetOutput( ) );
  triangl2simplex->Update( );
  TSimplex::Pointer simplex = triangl2simplex->GetOutput( );
  simplex->DisconnectPipeline( );

  // Map it to VTK
  vtkSmartPointer< TSimplexMapper > simplex_mapper =
    vtkSmartPointer< TSimplexMapper >::New( );
  simplex_mapper->SetInputData( simplex );

  vtkSmartPointer< vtkActor > simplex_actor =
    vtkSmartPointer< vtkActor >::New( );
  simplex_actor->SetMapper( simplex_mapper );
  simplex_actor->GetProperty( )->SetColor( 1, 0, 0 );
  simplex_actor->GetProperty( )->SetOpacity( 1 );
  simplex_actor->GetProperty( )->SetLineWidth( 2 );
  simplex_actor->GetProperty( )->SetRepresentationToWireframe( );

  // Create visualization stuff
  vtkSmartPointer< vtkRenderer > renderer =
    vtkSmartPointer< vtkRenderer >::New( );
  vtkSmartPointer< vtkRenderWindow > window =
    vtkSmartPointer< vtkRenderWindow >::New( );
  vtkSmartPointer< vtkRenderWindowInteractor > interactor =
    vtkSmartPointer< vtkRenderWindowInteractor >::New( );
  vtkInteractorStyleSwitch* iswitch =
    dynamic_cast< vtkInteractorStyleSwitch* >(
      interactor->GetInteractorStyle( )
      );
  renderer->SetBackground( 0.1, 0.3, 0.5 );
  window->AddRenderer( renderer );
  window->SetSize( 800, 800 );
  window->SetInteractor( interactor );
  if( iswitch != NULL )
    iswitch->SetCurrentStyleToTrackballCamera( );

  // Associate actors
  renderer->AddActor( simplex_actor );

  // Interact for a while
  renderer->ResetCamera( );
  window->Render( );
  interactor->Start( );

  // Ok, now configure deformation objects...
  TInternalForce::Pointer int_force = TInternalForce::New( );
  int_force->SetPhiConstraintToC0( );

  TDeformationFilter::Pointer deform = TDeformationFilter::New( );
  deform->AddForce( int_force, TScalar( 1 ) );
  deform->SetDamping( TScalar( 1 ) );
  deform->SetInput( simplex );

  // Threaded execution...
  vtkSmartPointer< TThreadedExecution > thread =
    vtkSmartPointer< TThreadedExecution >::New( );
  int thId = thread->ExecuteFilter( deform, window );

  // ... with active interaction
  interactor->Start( );

  std::cout << "-----> " << thread->IsThreadActive( thId ) << std::endl;
  return( 0 );
}

// eof - $RCSfile$