#include <Widgets/SeedWidget.h>

#include <cpPlugins/DataObjects/Image.h>
#include <cpPlugins/DataObjects/Mesh.h>

#include <cpExtensions/Interaction/SeedWidget.h>
#include <cpExtensions/Interaction/ImageSlicePointPlacer.h>
#include <cpExtensions/Visualization/WindowLevelImageActor.h>

#include <vtkHandleWidget.h>
#include <vtkImageData.h>
#include <vtkPlane.h>
#include <vtkPointHandleRepresentation3D.h>
#include <vtkProperty.h>
#include <vtkRendererCollection.h>
#include <vtkRenderWindow.h>
#include <vtkSeedRepresentation.h>

// -------------------------------------------------------------------------
void cpPluginsWidgets::SeedWidget::
Clear( )
{
}

// -------------------------------------------------------------------------
void cpPluginsWidgets::SeedWidget::
SetEnabled( bool v )
{
  for( auto w = this->m_Widgets.begin( ); w != this->m_Widgets.end( ); ++w )
  {
    if( v ) w->second->RestartInteraction( );
    else    w->second->CompleteInteraction( );
    w->second->SetEnabled( v );
    w->second->Render( );

  } // rof
}

// -------------------------------------------------------------------------
bool cpPluginsWidgets::SeedWidget::
GetEnabled( ) const
{
  if( this->m_Widgets.size( ) > 0 )
  {
    auto i = this->m_Widgets.begin( );
    TWidget* w = const_cast< TWidget* >( i->second.GetPointer( ) );
    return( w->GetEnabled( ) != 0 );
  }
  else
    return( false );
}

// -------------------------------------------------------------------------
cpPluginsWidgets::SeedWidget::
SeedWidget( )
  : Superclass( )
{
  typedef cpPlugins::BaseObjects::DataObject _TData;
  typedef cpPlugins::DataObjects::Mesh       _TMesh;

  // Create ports
  this->_ConfigureInput< _TData >( "Input", false, false );
  this->_ConfigureOutput< _TMesh >( "Output" );

  // Create output data
  auto out = this->_CreateVTK< vtkPolyData >( );
  out->SetPoints( vtkSmartPointer< vtkPoints >::New( ) );
  out->SetVerts( vtkSmartPointer< vtkCellArray >::New( ) );
  out->SetLines( vtkSmartPointer< vtkCellArray >::New( ) );
  out->SetPolys( vtkSmartPointer< vtkCellArray >::New( ) );
  out->SetStrips( vtkSmartPointer< vtkCellArray >::New( ) );
  this->GetOutput( "Output" )->SetVTK( out );
}

// -------------------------------------------------------------------------
cpPluginsWidgets::SeedWidget::
~SeedWidget( )
{
  /* TODO
     for( auto w = this->m_Widgets.begin( ); w != this->m_Widgets.end( ); ++w )
     w->second->EnabledOff( );
     this->m_Widgets.clear( );
  */
}

// -------------------------------------------------------------------------
void cpPluginsWidgets::SeedWidget::
_GenerateData( )
{
  auto image = this->GetInputData< vtkImageData >( "Input" );
  if( image != NULL )
    this->_GD0_Image( image );
  else
    this->_Error( "Invalid input image." );
}

// -------------------------------------------------------------------------
void cpPluginsWidgets::SeedWidget::
_GD0_Image( vtkImageData* image )
{
  auto seeds = this->GetOutputData< vtkPolyData >( "Output" );
  if( this->m_Widgets.size( ) == 0 )
  {
    this->m_Command = vtkSmartPointer< TCallback >::New( );
    this->m_Command->SetSeeds( seeds );
    for(
      auto inIt = this->m_Interactors.begin( );
      inIt != this->m_Interactors.end( );
      ++inIt
      )
    {
      auto rends = ( *inIt )->GetRenderWindow( )->GetRenderers( );
      std::set< TImageActor* > all_props;
      if( rends != NULL )
      {
        rends->InitTraversal( );
        while( vtkRenderer* ren = rends->GetNextItem( ) )
        {
          auto props = ren->GetViewProps( );
          props->InitTraversal( );
          while( vtkProp* p = props->GetNextProp( ) )
          {
            auto image_actor = dynamic_cast< TImageActor* >( p );
            if( image_actor != NULL )
            {
              if( image_actor->GetImage( ) == image )
                all_props.insert( image_actor );

            } // fi

          } // elihw

        } // elihw

      } // fi
      if( all_props.size( ) == 1 )
      {
        if( this->m_Widgets.find( *inIt ) == this->m_Widgets.end( ) )
        {
          auto act = *( all_props.begin( ) );
          auto pla = vtkSmartPointer< TPlacer >::New( );
          auto hnd = vtkSmartPointer< THandleRep >::New( );
          auto rep = vtkSmartPointer< TSeedRep >::New( );
          auto wdg = vtkSmartPointer< TWidget >::New( );

          pla->SetImageSlice( act );
          hnd->GetProperty( )->SetColor( 1, 0, 0 );
          hnd->SetPointPlacer( pla );
          rep->SetHandleRepresentation( hnd );
          wdg->SetRepresentation( rep );
          wdg->SetInteractor( *inIt );
          act->AddObserver( vtkCommand::InteractionEvent, this->m_Command );
          wdg->AddObserver( vtkCommand::PlacePointEvent, this->m_Command );
          wdg->AddObserver( vtkCommand::CursorChangedEvent, this->m_Command );
          this->m_Widgets[ *inIt ] = wdg;

        } // fi

      } // fi

    } // rof

    // Associate input text
    std::string text = this->m_Parameters.GetString( "Text" );
    std::vector< std::string > tok1, tok2;
    cpExtensions::Tokenize( tok1, text, "#" );
    for( auto t1 = tok1.begin( ); t1 != tok1.end( ); ++t1 )
    {
      if( *t1 != "" )
      {
        cpExtensions::Tokenize( tok2, *t1, " " );
        double x[ 3 ];
        for( unsigned int d = 0; d < 3; ++d )
        {
          if( d < tok2.size( ) )
          {
            std::istringstream str( tok2[ d ] );
            str >> x[ d ];
          }
          else
            x[ d ] = double( 0 );

        } // rof

        seeds->GetPoints( )->InsertNextPoint( x );
        seeds->GetVerts( )->InsertNextCell( 1 );
        seeds->GetVerts( )->InsertCellPoint(
          seeds->GetPoints( )->GetNumberOfPoints( ) - 1
          );
        seeds->Modified( );

      } // fi

    } // rof
  }
  else
  {
    double x[ 3 ];
    std::stringstream text;
    for( long i = 0; i < seeds->GetNumberOfPoints( ); ++i )
    {
      seeds->GetPoint( i, x );
      text << x[ 0 ] << " " << x[ 1 ] << " " << x[ 2 ] << "#";

    } // rof
    this->m_Parameters.SetString( "Text", text.str( ) );

  } // fi
}

// -------------------------------------------------------------------------
cpPluginsWidgets::SeedWidget::TCallback*
cpPluginsWidgets::SeedWidget::TCallback::
New( )
{
  return( new TCallback );
}

// -------------------------------------------------------------------------
void cpPluginsWidgets::SeedWidget::TCallback::
Execute( vtkObject* caller, unsigned long id, void* data )
{
  static const double EPS = 1e-5;
  auto src_act = dynamic_cast< TImageActor* >( caller );
  auto src_wdg = dynamic_cast< TWidget* >( caller );

  if( id == vtkCommand::InteractionEvent && src_act != NULL )
  {
    TWidget* widget = NULL;
    TSeedRep* seed_rep = NULL;

    auto w = this->m_Widgets.begin( );
    while( w != this->m_Widgets.end( ) && widget == NULL )
    {
      auto rep =
        dynamic_cast< vtkSeedRepresentation* >(
          ( *w )->GetRepresentation( )
          );
      if( rep != NULL )
      {
        auto hnd = rep->GetHandleRepresentation( );
        if( hnd != NULL )
        {
          auto pla =
            dynamic_cast< SeedWidget::TPlacer* >(
              hnd->GetPointPlacer( )
              );
          if( pla != NULL )
          {
            auto act = pla->GetImageSlice( );
            if( act == src_act )
            {
              widget = *w;
              seed_rep = rep;

            } // fi

          } // fi

        } // fi

      } // fi
      w++;

    } // elihw

    if( widget != NULL )
    {
      // Cut through given seeds
      auto plane = src_act->GetSlicePlane( );
      double x[ 3 ];
      std::vector< long > ids;
      for( long i = 0; i < this->m_Seeds->GetNumberOfPoints( ); ++i )
      {
        this->m_Seeds->GetPoint( i, x );
        double d = plane->DistanceToPlane( x );
        if( d <= EPS )
          ids.push_back( i );

      } // rof

      // Erase seeds
      widget->CompleteInteraction( );
      widget->EnabledOff( );
      int nSeeds = seed_rep->GetNumberOfSeeds ();
      for( int i = 0; i < nSeeds; ++i )
      {
        seed_rep->RemoveLastHandle( );
        widget->DeleteSeed( seed_rep->GetNumberOfSeeds( ) );

      } // rof

      if( ids.size( ) > 0 )
      {
        auto ren = widget->GetInteractor( )->FindPokedRenderer(
          widget->GetInteractor( )->GetEventPosition( )[ 0 ],
          widget->GetInteractor( )->GetEventPosition( )[ 1 ]
          );

        // Add seeds
        seed_rep->BuildRepresentation( );
        for( auto id = ids.begin( ); id != ids.end( ); ++id )
        {
          this->m_Seeds->GetPoint( *id, x );
          widget->ComputeWorldToDisplay(
            ren, x[ 0 ], x[ 1 ], x[ 2 ], x
            );
          x[ 2 ] = double( 0 );
          int s = seed_rep->CreateHandle( x );
          vtkHandleWidget* curr_hnd = widget->CreateNewHandle( );
          seed_rep->SetSeedDisplayPosition( s, x );
          curr_hnd->SetEnabled( 1 );

        } // rof

      } // fi

      // Reactivate widget
      widget->RestartInteraction( );
      widget->EnabledOn( );
      widget->Render( );

    } // fi
  }
  else if( id == vtkCommand::PlacePointEvent && src_wdg != NULL )
  {
    this->m_Widgets.insert( src_wdg );
    auto rep =
      dynamic_cast< vtkSeedRepresentation* >(
        src_wdg->GetRepresentation( )
        );
    if( rep != NULL )
    {
      unsigned long nSeeds = rep->GetNumberOfSeeds( );
      if( nSeeds > 0 )
      {
        double pos[ 3 ];
        rep->GetSeedWorldPosition( nSeeds - 1, pos );

        this->m_Seeds->GetPoints( )->InsertNextPoint( pos );
        this->m_Seeds->GetVerts( )->InsertNextCell( 1 );
        this->m_Seeds->GetVerts( )->InsertCellPoint(
          this->m_Seeds->GetPoints( )->GetNumberOfPoints( ) - 1
          );
        this->m_Seeds->Modified( );

      } // fi

    } // fi

  } // fi
}

// -------------------------------------------------------------------------
void cpPluginsWidgets::SeedWidget::TCallback::
SetSeeds( vtkPolyData* seeds )
{
  this->m_Seeds = seeds;
}

// -------------------------------------------------------------------------
cpPluginsWidgets::SeedWidget::TCallback::
TCallback( )
  : vtkCommand( ),
    m_Seeds( NULL )
{
}

// -------------------------------------------------------------------------
cpPluginsWidgets::SeedWidget::TCallback::
~TCallback( )
{
}

// eof - $RCSfile$