#include "ImageMPR.h"
#include "ui_ImageMPR.h"

#include <vtkProperty.h>
#include <vtkRenderWindow.h>

#include <QDoubleSpinBox>
#include <QFileDialog>
#include <QLabel>
#include <QMessageBox>

#ifdef _WIN32
#  define PLUGIN_PREFIX ""
#  define PLUGIN_EXT "dll"
#  define PLUGIN_REGEX "Plugins file (*.dll);;All files (*)"
#else
#  define PLUGIN_PREFIX "lib"
#  define PLUGIN_EXT "so"
#  define PLUGIN_REGEX "Plugins file (*.so);;All files (*)"
#endif // _WIN32

// -------------------------------------------------------------------------
ImageMPR::ImageMPR( QWidget* parent )
  : QMainWindow( parent ),
    m_UI( new Ui::ImageMPR ),
    m_ImageReaderClass( "" ),
    m_ImageWriterClass( "" ),
    m_InputImage( NULL ),
    m_ParametersDlg( NULL )
{
  this->m_UI->setupUi( this );

  // Create and associate renderers
  this->m_MPR = new TMPR(
    this->m_UI->m_XPlaneVTK->GetRenderWindow( ),
    this->m_UI->m_YPlaneVTK->GetRenderWindow( ),
    this->m_UI->m_ZPlaneVTK->GetRenderWindow( ),
    this->m_UI->m_3DVTK->GetRenderWindow( )
    );

  // signals <-> slots
  QObject::connect(
    this->m_UI->actionOpenPlugins, SIGNAL( triggered( ) ),
    this, SLOT( _triggered_actionOpenPlugins( ) )
    );
  QObject::connect(
    this->m_UI->actionOpenInputImage, SIGNAL( triggered( ) ),
    this, SLOT( _triggered_actionOpenInputImage( ) )
    );
  QObject::connect(
    this->m_UI->actionOpenInputPolyData, SIGNAL( triggered( ) ),
    this, SLOT( _triggered_actionOpenInputPolyData( ) )
    );

  // Start: load all disponible plugins
  this->_LoadPlugins(
    std::string( PLUGIN_PREFIX ) +
    std::string( "cpPlugins." ) +
    std::string( PLUGIN_EXT )
    );
}

// -------------------------------------------------------------------------
ImageMPR::
~ImageMPR( )
{
  // Close all connections
  this->m_Plugins.UnloadAll( );

  // Delete objects
  delete this->m_UI;
  delete this->m_MPR;
  if( this->m_ParametersDlg != NULL )
  {
    this->m_ParametersDlg->close( );
    delete this->m_ParametersDlg;

  } // fi
}

// -------------------------------------------------------------------------
bool ImageMPR::
_LoadPlugins( const std::string& filename )
{
  this->m_ImageReaderClass = "";
  this->m_ImageWriterClass = "";
  this->m_MeshReaderClass = "";
  this->m_MeshWriterClass = "";
  this->m_ImageToImageFilters.clear( );
  this->m_ImageToMeshFilters.clear( );

  this->m_Plugins.UnloadAll( );
  if( !( this->m_Plugins.Load( filename ) ) )
  {
    this->m_Plugins.UnloadAll( );
    return( false );

  } // fi

  typedef TPluginsInterface::TClasses _TClasses;
  _TClasses::const_iterator cIt = this->m_Plugins.GetClasses( ).begin( );
  for( ; cIt != this->m_Plugins.GetClasses( ).end( ); ++cIt )
  {
    TPluginFilter::Pointer o =
      this->m_Plugins.CreateProcessObject( cIt->first );
    std::string name = o->GetClassName( );
    std::string category = o->GetClassCategory( );
    if( category == "ImageReader" )
      this->m_ImageReaderClass = name;
    else if( category == "ImageWriter" )
      this->m_ImageWriterClass = name;
    else if( category == "MeshReader" )
      this->m_MeshReaderClass = name;
    else if( category == "MeshWriter" )
      this->m_MeshWriterClass = name;
    else if( category == "ImageToImageFilter" )
    {
      this->m_ImageToImageFilters.insert( name );
      QAction* action =
        this->m_UI->MenuImageToImage->addAction( QString( name.c_str( ) ) );
      QObject::connect(
        action, SIGNAL( triggered( ) ),
        this, SLOT( _triggered_actionImageToImage( ) )
        );
    }
    else if( category == "ImageToMeshFilter" )
    {
      this->m_ImageToMeshFilters.insert( name );
      QAction* action =
        this->m_UI->MenuImageToMesh->addAction( QString( name.c_str( ) ) );
      QObject::connect(
        action, SIGNAL( triggered( ) ),
        this, SLOT( _triggered_actionImageToMesh( ) )
        );

    } // fi

  } // rof
  return( true );
}

// -------------------------------------------------------------------------
bool ImageMPR::
_ParametersDialog( TPluginFilter* filter )
{
  if( this->m_ParametersDlg != NULL ) 
    this->m_ParametersDlg->close( );
  this->m_ParametersDlg = new QWidget( NULL );
  this->m_ParametersDlg->setWindowFlags( Qt::FramelessWindowHint ); 
  this->m_ParametersDlg->setWindowFlags( Qt::WindowTitleHint );

  QGridLayout* gridLayout = new QGridLayout( this->m_ParametersDlg );
  QVBoxLayout* verticalLayout = new QVBoxLayout( );

  // Put a title
  QLabel* title = new QLabel( this->m_ParametersDlg );
  title->setText( filter->GetClassName( ).c_str( ) );
  verticalLayout->addWidget( title );

  // Put values
  TParameters parameters = filter->GetDefaultParameters( );
  std::vector< std::string > names = parameters.GetParameters( );
  std::vector< std::string >::const_iterator nIt = names.begin( );
  for( ; nIt != names.end( ); ++nIt )
  {
    std::string par_name = *nIt;
    TParameters::Type par_type = parameters.GetParameterType( par_name );

    /*
      enum Type
      {
      String = 0,
      Bool,
      Int,
      Uint,
      Real,
      Index,
      Point,
      StringList,
      BoolList,
      IntList,
      UintList,
      RealList,
      IndexList,
      PointList,
      NoType
      };
    */

    QHBoxLayout* horizontalLayout = new QHBoxLayout( );
    QLabel* label = new QLabel( this->m_ParametersDlg );
    label->setText( QString( par_name.c_str( ) ) );
    horizontalLayout->addWidget( label );

    if( par_type == TParameters::Uint )
    {
      QSpinBox* v_uint =
        new QSpinBox( this->m_ParametersDlg );
      v_uint->setMinimum( 0 );
      v_uint->setMaximum( std::numeric_limits< unsigned long >::max( ) );
      v_uint->setValue( parameters.GetValueAsUint( par_name ) );
      v_uint->setObjectName( QString( par_name.c_str( ) ) );
      horizontalLayout->addWidget( v_uint );
      verticalLayout->addLayout( horizontalLayout );
    }
    else if( par_type == TParameters::Int )
    {
      QSpinBox* v_int =
        new QSpinBox( this->m_ParametersDlg );
      v_int->setMinimum( -std::numeric_limits< long >::max( ) );
      v_int->setMaximum( std::numeric_limits< long >::max( ) );
      v_int->setValue( parameters.GetValueAsInt( par_name ) );
      v_int->setObjectName( QString( par_name.c_str( ) ) );
      horizontalLayout->addWidget( v_int );
      verticalLayout->addLayout( horizontalLayout );
    }
    else if( par_type == TParameters::Real )
    {
      QDoubleSpinBox* v_double =
        new QDoubleSpinBox( this->m_ParametersDlg );
      v_double->setDecimals( 3 );
      v_double->setMinimum( -( std::numeric_limits< double >::max( ) ) );
      v_double->setMaximum( std::numeric_limits< double >::max( ) );
      v_double->setValue( parameters.GetValueAsReal( par_name ) );
      v_double->setObjectName( QString( par_name.c_str( ) ) );
      horizontalLayout->addWidget( v_double );
      verticalLayout->addLayout( horizontalLayout );

    } // fi

  } // rof
  gridLayout->addLayout( verticalLayout, 0, 0, 1, 1 );

  // Infere plugin type
  /* TODO
     TParameters::const_iterator seedIt = parameters.find( "Seed" );
     TParameters::const_iterator radiusIt = parameters.find( "Radius" );
     TParameters::const_iterator endIt = parameters.end( );
     if( seedIt == endIt && radiusIt == endIt )
     this->m_ActivePluginType = Self::GlobalPluginType;
     else if( seedIt != endIt && radiusIt == endIt )
     this->m_ActivePluginType = Self::DoubleClickPluginType;
     else if( seedIt != endIt && radiusIt != endIt )
     this->m_ActivePluginType = Self::SpherePluginType;
     else
     this->m_ActivePluginType = Self::NonePluginType;
  */

  QMetaObject::connectSlotsByName( this->m_ParametersDlg );
  this->m_ParametersDlg->show( );

  return( false );
}

// -------------------------------------------------------------------------
void ImageMPR::
_triggered_actionOpenPlugins( )
{
  // Show dialog and check if it was accepted
  QFileDialog dialog( this );
  dialog.setFileMode( QFileDialog::ExistingFile );
  dialog.setDirectory( "." );
  dialog.setNameFilter( tr( PLUGIN_REGEX ) );
  dialog.setDefaultSuffix( tr( PLUGIN_EXT ) );
  if( !( dialog.exec( ) ) )
    return;
  
  std::string fname = dialog.selectedFiles( ).at( 0 ).toStdString( );
  if( !( _LoadPlugins( fname ) ) )
    QMessageBox::critical(
      this,
      tr( "Ignoring plugin" ),
      tr( fname.c_str( ) )
      );
}

// -------------------------------------------------------------------------
void ImageMPR::
_triggered_actionOpenInputImage( )
{
  // Show dialog and check if it was accepted
  QFileDialog dialog( this );
  dialog.setFileMode( QFileDialog::ExistingFiles );
  dialog.setDirectory( tr( "." ) );
  dialog.setNameFilter(
    tr( "Medical image files (*.mhd *.bin *.dcm *.nrri);;All files (*)" )
    );
  dialog.setDefaultSuffix( tr( "mhd" ) );
  if( !( dialog.exec( ) ) )
    return;
  
  this->m_InputImage = NULL;

  // Get a reader from plugins
  TPluginFilter::Pointer reader =
    this->m_Plugins.CreateProcessObject( this->m_ImageReaderClass );

  // Configure reader
  TParameters reader_params = reader->GetDefaultParameters( );
  QStringList q_fnames = dialog.selectedFiles( );
  QStringList::const_iterator qIt = q_fnames.begin( );
  for( ; qIt != q_fnames.end( ); ++qIt )
    reader_params.AddValueToStringList( "FileNames", qIt->toStdString( ) );
  reader->SetParameters( reader_params );

  // Execute and get error message, if any
  std::string err = reader->Update( );

  // Assign fresh image, if any
  if( err == "" )
  {
    this->m_InputImage =
      dynamic_cast< TPluginImage* >( reader->GetOutput( 0 ) );
    reader->DisconnectOutputs( );
    if( this->m_InputImage.IsNotNull( ) )
      this->m_MPR->SetImage( this->m_InputImage->GetVTKImageData( ) );
  }
  else
    QMessageBox::critical(
      this,
      tr( "Error reading single image" ),
      tr( err.c_str( ) )
      );
}

// -------------------------------------------------------------------------
void ImageMPR::
_triggered_actionOpenInputPolyData( )
{
  /*
  // Show dialog and check if it was accepted
  QFileDialog dialog( this );
  dialog.setFileMode( QFileDialog::ExistingFile );
  dialog.setDirectory( "." );
  dialog.setNameFilter( tr( "VTK file (*.vtk);;All files (*)" ) );
  dialog.setDefaultSuffix( tr( "vtk" ) );
  if( !( dialog.exec( ) ) )
    return;
  
  std::string fname = dialog.selectedFiles( ).at( 0 ).toStdString( );

  this->m_InputMesh = NULL;

  // Get a reader from plugins
  TPluginFilter::Pointer reader =
    this->m_Plugins.CreateProcessObject(
      this->m_BaseClasses[ "MeshReader" ]
      );

  // Configure plugin
  TParameters reader_params = reader->GetDefaultParameters( );
  reader_params.SetValueAsString( "FileName", fname );
  reader->SetParameters( reader_params );

  // Execute and get error message, if any
  std::string err = reader->Update( );

  // Assign fresh image, if any
  if( err == "" )
  {
    this->m_InputMesh =
      dynamic_cast< TPluginMesh* >( reader->GetOutput( 0 ) );
    reader->DisconnectOutputs( );
    if( this->m_InputMesh.IsNotNull( ) )
    {
      this->m_InputMeshMapper = vtkSmartPointer< vtkPolyDataMapper >::New( );
      this->m_InputMeshMapper->SetInputData( this->m_InputMesh->GetVTKPolyData( ) );
      this->m_InputMeshActor = vtkSmartPointer< vtkActor >::New( );
      this->m_InputMeshActor->SetMapper( this->m_InputMeshMapper );
      this->m_MPR->Add3DActor( this->m_InputMeshActor );

    } // fi
  }
  else
    QMessageBox::critical(
      this,
      tr( "Error reading polydata" ),
      tr( err.c_str( ) )
      );
  */
}

// -------------------------------------------------------------------------
void ImageMPR::
_triggered_actionImageToImage( )
{
  if( this->m_InputImage.IsNull( ) )
    return;

  // Get filter name
  QAction* action = dynamic_cast< QAction* >( this->sender( ) );
  if( action == NULL )
    return;
  std::string name = action->text( ).toStdString( );

  // Configure filter
  TPluginFilter::Pointer filter =
    this->m_Plugins.CreateProcessObject( name );
  this->_ParametersDialog( filter );
}

// -------------------------------------------------------------------------
void ImageMPR::
_triggered_actionImageToMesh( )
{
  if( this->m_InputImage.IsNull( ) )
    return;

  // Get filter name
  QAction* action = dynamic_cast< QAction* >( this->sender( ) );
  if( action == NULL )
    return;
  std::string name = action->text( ).toStdString( );
}

// eof - $RCSfile$