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

#include <cpPlugins/Interface/Interface.h>
#include <cpPlugins/Interface/ProcessObject.h>
#include <cpPlugins/Interface/Image.h>

#include <vtkSmartPointer.h>
#include <vtkCommand.h>
#include <vtkRenderer.h>
#include <vtkRenderWindow.h>
#include <vtkRenderWindowInteractor.h>
#include <vtkSliderRepresentation2D.h>
#include <vtkSliderWidget.h>

#include <cpExtensions/Visualization/MPRActors.h>

// -------------------------------------------------------------------------
typedef cpPlugins::Interface::Interface     TInterface;
typedef cpPlugins::Interface::ProcessObject TFilter;
typedef cpPlugins::Interface::Parameters    TParameters;
typedef cpPlugins::Interface::Image         TImage;

typedef cpExtensions::Visualization::MPRActors TMPRActors;

// -------------------------------------------------------------------------
class SliderCallback
  : public vtkCommand
{
public:
  static SliderCallback* New( )
    {
      return new SliderCallback;
    }
  virtual void Execute( vtkObject* caller, unsigned long eId , void* data )
    {
      /*
      vtkSliderWidget* wdg =
        reinterpret_cast< vtkSliderWidget* >( caller );
      if( wdg == NULL )
        return;
      vtkSliderRepresentation* rep =
        static_cast< vtkSliderRepresentation* >(
          wdg->GetRepresentation( )
          );
      if( rep == NULL )
        return;
      std::string title = rep->GetTitleText( );
      if( title == "X" )
        this->Actors->SetSlice( 0, int( rep->GetValue( ) ) );
      else if( title == "Y" )
        this->Actors->SetSlice( 1, int( rep->GetValue( ) ) );
      else if( title == "Z" )
        this->Actors->SetSlice( 2, int( rep->GetValue( ) ) );
      else if( title == "Window" )
        this->Actors->SetWindow( 0, rep->GetValue( ) );
      else if( title == "Level" )
        this->Actors->SetLevel( 0, rep->GetValue( ) );
      */
    }
  SliderCallback( )
    : vtkCommand( )
    {
    }

public:
  TMPRActors* Actors;
};

// -------------------------------------------------------------------------
struct Slider
{
  vtkSmartPointer< vtkSliderRepresentation2D > Representation;
  vtkSmartPointer< vtkSliderWidget >           Widget;

  Slider(
    double min_value,
    double max_value,
    double value,
    const std::string& title,
    vtkRenderWindowInteractor* iren,
    double p1x, double p1y, double p2x, double p2y,
    SliderCallback* callback = NULL
    )
    {
      this->Representation =
        vtkSmartPointer< vtkSliderRepresentation2D >::New( );
      this->Representation->SetMinimumValue( min_value );
      this->Representation->SetMaximumValue( max_value );
      this->Representation->SetValue( value );
      this->Representation->SetTitleText( title.c_str( ) );
      this->Representation->GetPoint1Coordinate( )->
        SetCoordinateSystemToNormalizedDisplay();
      this->Representation->GetPoint1Coordinate( )->
        SetValue( p1x, p1y );
      this->Representation->GetPoint2Coordinate( )->
        SetCoordinateSystemToNormalizedDisplay();
      this->Representation->GetPoint2Coordinate( )->SetValue( p2x, p2y );

      this->Widget = vtkSmartPointer< vtkSliderWidget >::New( );
      this->Widget->SetInteractor( iren );
      this->Widget->SetRepresentation( this->Representation );
      this->Widget->SetAnimationModeToAnimate( );
      this->Widget->EnabledOn( );
      if( callback != NULL )
        this->Widget->AddObserver( vtkCommand::InteractionEvent, callback );
    }
};

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

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

  // Create interface
  TInterface plugins;
  plugins.Load( plugins_file );

  // Create reader
  TFilter::Pointer reader =
    plugins.CreateProcessObject( "cpPlugins::IO::ImageReader" );
  if( reader.IsNull( ) )
  {
    std::cerr
      << "ERROR: No suitable image reader found in plugins."
      << std::endl;
    return( 1 );

  } // fi

  // Configure reader
  TParameters* reader_params = reader->GetParameters( );
  for( int i = 2; i < argc; ++i )
    reader_params->AddToStringList( "FileNames", argv[ i ] );

  // Execute reader
  std::string msg = reader->Update( );
  if( msg != "" )
  {
    std::cerr << "ERROR: " << msg << std::endl;
    return( 1 );

  } // fi

  // Get input image's vtk representation
  vtkImageData* image =
    reader->GetOutput< TImage >( "Output" )->GetVTK< vtkImageData >( );
  if( image == NULL )
  {
    std::cerr
      << "ERROR: read image does not have a valid VTK conversion."
      << std::endl;
    return( 1 );

  } // fi

  // Visualization stuff
  vtkSmartPointer< vtkRenderWindow > window =
    vtkSmartPointer< vtkRenderWindow >::New( );
  window->SetSize( 700, 700 );

  // Renderers
  vtkSmartPointer< vtkRenderer > renderer =
    vtkSmartPointer< vtkRenderer >::New( );
  renderer->SetBackground( 0, 0, 1 );
  window->AddRenderer( renderer );

  // Interactor
  vtkSmartPointer< vtkRenderWindowInteractor > interactor =
    vtkSmartPointer< vtkRenderWindowInteractor >::New( );
  interactor->SetRenderWindow( window );

  // Actors
  vtkSmartPointer< TMPRActors > mpr_actors =
    vtkSmartPointer< TMPRActors >::New( );
  mpr_actors->AddInputData( image );
  mpr_actors->PushActorsInto( NULL, NULL, NULL, window );

  // Callbacks
  vtkSmartPointer< SliderCallback > cb =
    vtkSmartPointer< SliderCallback >::New( );
  cb->Actors = mpr_actors;

  /*
  Slider x_slider(
    mpr_actors->GetSliceNumberMinValue( 0 ),
    mpr_actors->GetSliceNumberMaxValue( 0 ),
    mpr_actors->GetSliceNumberMinValue( 0 ),
    "X", interactor,
    0.100, 0.15, 0.290, 0.15, cb
    );
  Slider y_slider(
    mpr_actors->GetSliceNumberMinValue( 1 ),
    mpr_actors->GetSliceNumberMaxValue( 1 ),
    mpr_actors->GetSliceNumberMinValue( 1 ),
    "Y", interactor,
    0.300, 0.15, 0.490, 0.15, cb
    );
  Slider z_slider(
    mpr_actors->GetSliceNumberMinValue( 2 ),
    mpr_actors->GetSliceNumberMaxValue( 2 ),
    mpr_actors->GetSliceNumberMinValue( 2 ),
    "Z", interactor,
    0.500, 0.15, 0.690, 0.15, cb
    );
  Slider w_slider(
    mpr_actors->GetMinWindow( 0 ),
    mpr_actors->GetMaxWindow( 0 ),
    mpr_actors->GetWindow( 0 ),
    "Window", interactor,
    0.100, 0.05, 0.290, 0.05, cb
    );
  Slider l_slider(
    mpr_actors->GetMinWindow( 0 ),
    mpr_actors->GetMaxWindow( 0 ),
    mpr_actors->GetWindow( 0 ),
    "Level", interactor,
    0.300, 0.05, 0.490, 0.05, cb
    );
    */

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

  return( 0 );
}

// eof - $RCSfile$