#include <cmath>
#include <cstdlib>
#include <iostream>
#include <string>

#include <cpPlugins/Extensions/MeshReader.h>
#include <cpPlugins/Extensions/OpenGLMeshMapper.h>

#include <cpm/DataStructures/SimplexMesh.h>
#include <cpm/Algorithms/QuadEdge/MeshToDualFilter.h>

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

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

typedef float TScalar;
typedef cpm::DataStructures::SimplexMesh< TScalar, Order, Dimension > TSimplex;
typedef TSimplex::Superclass TMesh;
typedef cpPlugins::Extensions::OpenGLMeshMapper< TMesh > TMeshMapper;

// -------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
  if( argc < 2 )
  {
    std::cerr
      << "Usage: " << argv[ 0 ]
      << " input_mesh"
      << std::endl;
    return( 1 );

  } // fi

  typedef cpPlugins::Extensions::MeshReader< TMesh > TReader;
  TReader::Pointer reader = TReader::New( );
  reader->SetFileName( argv[ 1 ] );

  typedef
    cpm::Algorithms::QuadEdge::MeshToDualFilter< TMesh, TSimplex >
    TDualFilter;
  TDualFilter::Pointer dual_filter = TDualFilter::New( );
  dual_filter->SetInput( reader->GetOutput( ) );
  dual_filter->Update( );
  TSimplex::Pointer simplex = dual_filter->GetOutput( );

  std::cout
    << " --> Read " << simplex->GetNumberOfPoints( )
    << " simplex points."
    << std::endl;

  bool finish = false;
  while( !finish )
  {
    std::cout
      << " --> Delete an edge between a and b (-1 to finish) : "
      << std::flush;
    int a, b;
    std::cin >> a;
    if( a == -1 )
    {
      finish = true;
      continue;

    } // fi
    std::cin >> b;
    if( simplex->OperatorDeleteEdge( a, b ) )
      std::cout << "Deleted" << std::endl;
    else
      std::cout << "Not present" << std::endl;
    
  } // elihw

  // Map mesh
  vtkSmartPointer< TMeshMapper > mapper =
    vtkSmartPointer< TMeshMapper >::New( );
  mapper->SetInputData( reader->GetOutput( ) );

  // Map dual mesh
  vtkSmartPointer< TMeshMapper > dual_mapper =
    vtkSmartPointer< TMeshMapper >::New( );
  dual_mapper->SetInputData( dual_filter->GetOutput( ) );

  // Create actor
  vtkSmartPointer< vtkActor > actor =
    vtkSmartPointer< vtkActor >::New( );
  actor->SetMapper( mapper );
  actor->GetProperty( )->SetColor( 1, 1, 0 );
  actor->GetProperty( )->SetOpacity( 0.5 );

  // Create dual actor
  vtkSmartPointer< vtkActor > dual_actor =
    vtkSmartPointer< vtkActor >::New( );
  dual_actor->SetMapper( dual_mapper );
  dual_actor->GetProperty( )->SetColor( 1, 0, 0 );
  dual_actor->GetProperty( )->SetOpacity( 1 );
  dual_actor->GetProperty( )->SetLineWidth( 2 );
  dual_actor->GetProperty( )->SetRepresentationToWireframe( );

  // Configure visualization objects
  vtkSmartPointer< vtkRenderer > renderer =
    vtkSmartPointer< vtkRenderer >::New( );
  renderer->SetBackground( 0.1, 0.3, 0.5 );

  vtkSmartPointer< vtkRenderWindow > window =
    vtkSmartPointer< vtkRenderWindow >::New( );
  window->AddRenderer( renderer );
  window->SetSize( 800, 800 );

  // Set up the interaction
  vtkSmartPointer< vtkRenderWindowInteractor > interactor =
    vtkSmartPointer< vtkRenderWindowInteractor >::New( );
  window->SetInteractor( interactor );

  // Associate actors
  //renderer->AddActor( actor );
  renderer->AddActor( dual_actor );

  // Begin interaction
  window->Render( );
  interactor->Start( );

  return( 0 );
}

// eof - $RCSfile$