#include <cpPlugins/Interface/Plugins.h>
#include <cpPlugins/Interface/Config.h>

#include <fstream>
#include <sstream>

#ifdef cpPlugins_Interface_QT4

#include <QApplication>
#include <QFileDialog>
#include <QMenu>
#include <QMessageBox>
#include <QWidget>

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

#endif // cpPlugins_Interface_QT4

// -------------------------------------------------------------------------
cpPlugins::Interface::Plugins::
Plugins( QWidget* widget )
  : m_Widget( widget ),
    m_LastLoadedPlugin( "." )
{
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Plugins::
~Plugins( )
{
  // TODO: this causes a segfault? this->m_Interface.UnloadAll( );
}

// -------------------------------------------------------------------------
QWidget* cpPlugins::Interface::Plugins::
GetWidget( )
{
  return( this->m_Widget );
}

// -------------------------------------------------------------------------
const QWidget* cpPlugins::Interface::Plugins::
GetWidget( ) const
{
  return( this->m_Widget );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
SetWidget( QWidget* widget )
{
  this->m_Widget = widget;
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
BlockWidget( )
{
#ifdef cpPlugins_Interface_QT4
  if( this->m_Widget != NULL )
  {
    QApplication::setOverrideCursor( Qt::WaitCursor );
    this->m_Widget->setEnabled( false );

  } // fi
#endif // cpPlugins_Interface_QT4
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
UnblockWidget( )
{
#ifdef cpPlugins_Interface_QT4
  if( this->m_Widget != NULL )
  {
    QApplication::restoreOverrideCursor( );
    this->m_Widget->setEnabled( true );

  } // fi
#endif // cpPlugins_Interface_QT4
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
DialogLoadPlugins( )
{
#ifdef cpPlugins_Interface_QT4
  if( this->m_Widget != NULL )
  {
    QFileDialog dialog( this->m_Widget );
    dialog.setFileMode( QFileDialog::ExistingFile );
    dialog.setDirectory( this->m_LastLoadedPlugin.c_str( ) );
    dialog.setNameFilter( QFileDialog::tr( PLUGIN_REGEX ) );
    dialog.setDefaultSuffix( QFileDialog::tr( PLUGIN_EXT ) );
    if( !( dialog.exec( ) ) )
      return;

    std::string fname = dialog.selectedFiles( ).at( 0 ).toStdString( );
    if( !( this->LoadPlugins( fname ) ) )
      QMessageBox::critical(
        this->m_Widget,
        QMessageBox::tr( "Ignoring plugin" ),
        QMessageBox::tr( fname.c_str( ) )
        );

  } // fi
#endif // cpPlugins_Interface_QT4
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
AssociatePluginsToMenu( QMenu* menu, QObject* obj, const char* slot )
{
#ifdef cpPlugins_Interface_QT4
  std::map< std::string, std::set< std::string > >::const_iterator i;
  std::set< std::string >::const_iterator j;

  menu->clear( );
  for( i = this->m_Filters.begin( ); i != this->m_Filters.end( ); i++ )
  {
    QMenu* newMenu = menu->addMenu( i->first.c_str( ) );
    for( j = i->second.begin( ); j != i->second.end( ); ++j )
    {
      QAction* a = newMenu->addAction( j->c_str( ) );
      QObject::connect( a, SIGNAL( triggered( ) ), obj, slot );

    } // rof

  } // rof
#endif // cpPlugins_Interface_QT4
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Plugins::
LoadPlugins( const std::string& fname )
{
  this->BlockWidget( );

  // Is it already loaded?
  bool ret = true;
  if( this->m_LoadedPlugins.find( fname ) == this->m_LoadedPlugins.end( ) )
  {
    // Was it succesfully loaded?
    ret = this->m_Interface.Load( fname );

    // Update a simple track
    if( ret )
    {
      this->m_LoadedPlugins.insert( fname );
      this->m_LastLoadedPlugin = fname;
      this->_Update( );

    } // fi

  } // fi

  this->UnblockWidget( );
  return( ret );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Plugins::
LoadPluginsConfigurationFile( const std::string& fname )
{
  // Load file into a char buffer
  std::ifstream in(
    fname.c_str( ), std::ios::in | std::ios::binary | std::ios::ate
    );
  if( !in.is_open( ) )
    return( false );

  std::streampos size = in.tellg( );
  char* buffer = new char[ size ];
  in.seekg( 0, std::ios::beg );
  in.read( buffer, size );
  in.close( );

  // Read stream
  std::stringstream in_stream( buffer );
  char line[ 4096 ];
  while( in_stream )
  {
    in_stream.getline( line, 4096 );
    this->LoadPlugins( line );

  } // elihw
  delete buffer;

  return( true );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Plugins::
TParameters* cpPlugins::Interface::Plugins::
GetImageReaderParameters( )
{
  return( this->m_ImageReader->GetParameters( ) );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Plugins::
TParameters* cpPlugins::Interface::Plugins::
GetMeshReaderParameters( )
{
  return( this->m_MeshReader->GetParameters( ) );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Plugins::
TParameters* cpPlugins::Interface::Plugins::
GetImageWriterParameters( )
{
  return( this->m_ImageWriter->GetParameters( ) );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Plugins::
TParameters* cpPlugins::Interface::Plugins::
GetMeshWriterParameters( )
{
  return( this->m_MeshWriter->GetParameters( ) );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Plugins::
TParameters* cpPlugins::Interface::Plugins::
GetImageReaderParameters( ) const
{
  return( this->m_ImageReader->GetParameters( ) );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Plugins::
TParameters* cpPlugins::Interface::Plugins::
GetMeshReaderParameters( ) const
{
  return( this->m_MeshReader->GetParameters( ) );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Plugins::
TParameters* cpPlugins::Interface::Plugins::
GetImageWriterParameters( ) const
{
  return( this->m_ImageWriter->GetParameters( ) );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Plugins::
TParameters* cpPlugins::Interface::Plugins::
GetMeshWriterParameters( ) const
{
  return( this->m_MeshWriter->GetParameters( ) );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Plugins::
ReadImage( TImage::Pointer& image, bool exec_qt )
{
  std::string ret = "";
  if( this->m_ImageReader.IsNull( ) )
    ret = "Plugins: No valid image reader. Please load a valid plugin.";

  if( ret == "" )
  {
    TProcessObject::DialogResult dret = TProcessObject::DialogResult_NoModal;
    if( exec_qt )
      dret = this->m_ImageReader->ExecConfigurationDialog( this->m_Widget );
    if( dret != TProcessObject::DialogResult_Cancel )
    {
      this->BlockWidget( );
      ret = this->m_ImageReader->Update( );
      this->UnblockWidget( );
      if( ret == "" )
      {
        image = this->m_ImageReader->GetOutput< TImage >( "Output" );
        this->m_ImageReader->DisconnectOutputs( );
        this->m_ImageReader->GetParameters( )->ClearStringList( "FileNames" );
      }
      else
        image = NULL;

    } // fi

  } // fi

  // Show an error message and return
  if( ret != "" )
  {
#ifdef cpPlugins_Interface_QT4
    if( this->m_Widget != NULL )
      QMessageBox::critical(
        this->m_Widget,
        QMessageBox::tr( "Error reading image." ),
        QMessageBox::tr( ret.c_str( ) )
        );
#endif // cpPlugins_Interface_QT4
    return( false );
  }
  else
    return( true );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Plugins::
ReadDicomSeries( TImage::Pointer& image )
{
  std::string ret = "";
  if( this->m_DicomSeriesReader.IsNull( ) )
    ret = "Plugins: No valid dicom series reader. Please load a valid plugin.";

  if( ret == "" )
  {
    TProcessObject::DialogResult dret =
      this->m_DicomSeriesReader->ExecConfigurationDialog( this->m_Widget );
    if( dret != TProcessObject::DialogResult_Cancel )
    {
      this->BlockWidget( );
      ret = this->m_DicomSeriesReader->Update( );
      this->UnblockWidget( );
      if( ret == "" )
      {
        image = this->m_DicomSeriesReader->GetOutput< TImage >( "Output" );
        this->m_DicomSeriesReader->DisconnectOutputs( );
        this->m_DicomSeriesReader->GetParameters( )->
          ClearStringList( "FileNames" );
      }
      else
        image = NULL;

    } // fi

  } // fi

  // Show an error message and return
  if( ret != "" )
  {
#ifdef cpPlugins_Interface_QT4
    if( this->m_Widget != NULL )
      QMessageBox::critical(
        this->m_Widget,
        QMessageBox::tr( "Error reading dicom series." ),
        QMessageBox::tr( ret.c_str( ) )
        );
#endif // cpPlugins_Interface_QT4
    return( false );
  }
  else
    return( true );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Plugins::
ReadMesh( TMesh::Pointer& mesh, bool exec_qt )
{
  std::string ret = "";
  if( this->m_MeshReader.IsNull( ) )
    ret = "Plugins: No valid mesh reader. Please load a valid plugin.";

  if( ret == "" )
  {
    TProcessObject::DialogResult dret = TProcessObject::DialogResult_NoModal;
    if( exec_qt )
      dret = this->m_MeshReader->ExecConfigurationDialog( this->m_Widget );
    if( dret != TProcessObject::DialogResult_Cancel )
    {
      this->BlockWidget( );
      ret = this->m_MeshReader->Update( );
      this->UnblockWidget( );
      if( ret == "" )
      {
        mesh = this->m_MeshReader->GetOutput< TMesh >( "Output" );
        this->m_MeshReader->DisconnectOutputs( );
      }
      else
        mesh = NULL;

    } // fi

  } // fi

  // Show an error message and return
  if( ret != "" )
  {
#ifdef cpPlugins_Interface_QT4
    if( this->m_Widget != NULL )
      QMessageBox::critical(
        this->m_Widget,
        QMessageBox::tr( "Error reading image." ),
        QMessageBox::tr( ret.c_str( ) )
        );
#endif // cpPlugins_Interface_QT4
    return( false );
  }
  else
    return( true );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Plugins::
WriteImage( TImage* image, bool exec_qt )
{
  std::string ret = "";
  if( this->m_ImageWriter.IsNull( ) )
    ret = "Plugins: No valid image writer. Please load a valid plugin.";

  if( ret == "" )
  {
    TProcessObject::DialogResult dret = TProcessObject::DialogResult_NoModal;
    if( exec_qt )
      dret = this->m_ImageWriter->ExecConfigurationDialog( this->m_Widget );
    if( dret != TProcessObject::DialogResult_Cancel )
    {
      this->m_ImageWriter->SetInput( "Input", image );
      this->BlockWidget( );
      ret = this->m_ImageWriter->Update( );
      this->UnblockWidget( );

    } // fi

  } // fi

  // Show an error message and return
  if( ret != "" )
  {
#ifdef cpPlugins_Interface_QT4
    if( this->m_Widget != NULL )
      QMessageBox::critical(
        this->m_Widget,
        QMessageBox::tr( "Error reading image." ),
        QMessageBox::tr( ret.c_str( ) )
        );
#endif // cpPlugins_Interface_QT4
    return( false );
  }
  else
    return( true );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Plugins::
WriteMesh( TMesh* mesh, bool exec_qt )
{
  std::string ret = "";
  if( this->m_MeshWriter.IsNull( ) )
    ret = "Plugins: No valid mesh writer. Please load a valid plugin.";

  if( ret == "" )
  {
    TProcessObject::DialogResult dret = TProcessObject::DialogResult_NoModal;
    if( exec_qt )
      dret = this->m_MeshWriter->ExecConfigurationDialog( this->m_Widget );
    if( dret != TProcessObject::DialogResult_Cancel )
    {
      this->m_MeshWriter->SetInput( "Input", mesh );
      this->BlockWidget( );
      ret = this->m_MeshWriter->Update( );
      this->UnblockWidget( );

    } // fi

  } // fi

  // Show an error message and return
  if( ret != "" )
  {
#ifdef cpPlugins_Interface_QT4
    if( this->m_Widget != NULL )
      QMessageBox::critical(
        this->m_Widget,
        QMessageBox::tr( "Error reading image." ),
        QMessageBox::tr( ret.c_str( ) )
        );
#endif // cpPlugins_Interface_QT4
    return( false );
  }
  else
    return( true );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Plugins::
CreateFilter( TProcessObject::Pointer& filter, const std::string& name )
{
  filter = this->m_Interface.CreateProcessObject( name );
  return( filter.IsNotNull( ) );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Plugins::
_Update( )
{
  typedef TInterface::TClasses _C;

  this->m_Filters.clear( );
  _C& classes = this->m_Interface.GetClasses( );
  for( _C::const_iterator i = classes.begin( ); i != classes.end( ); ++i )
  {
    TProcessObject::Pointer o =
      this->m_Interface.CreateProcessObject( i->first );
    std::string name = o->GetClassName( );
    std::string category = o->GetClassCategory( );
    if( category == "ImageReader" )
      this->m_ImageReader = o;
    else if( category == "ImageWriter" )
      this->m_ImageWriter = o;
    else if( category == "MeshReader" )
      this->m_MeshReader = o;
    else if( category == "MeshWriter" )
      this->m_MeshWriter = o;
    else if( category == "DicomSeriesReader" )
      this->m_DicomSeriesReader = o;
    else
      this->m_Filters[ category ].insert( name );

  } // rof
}

// eof - $RCSfile$