#include "PipelineEditor.h"
#include "ui_PipelineEditor.h"

#include <cpPipelineEditor/Editor.h>

#include <QFileDialog>
#include <QMessageBox>

#include <vtkImageData.h>
#include <vtkPolyData.h>

#include <cpPlugins/DataObject.h>

// -------------------------------------------------------------------------
#define PipelineEditor_ConnectAction( ACTION )          \
  this->connect(                                        \
    this->m_UI->Action##ACTION, SIGNAL( triggered( ) ), \
    this, SLOT( _Action##ACTION( ) )                    \
    )

// -------------------------------------------------------------------------
#define PipelineEditor_ConnectButton( BUTTON )          \
  this->connect(                                        \
    this->m_UI->Button##BUTTON, SIGNAL( clicked( ) ),   \
    this, SLOT( _Button##BUTTON( ) )                    \
    )

// -------------------------------------------------------------------------
bool PipelineEditor_Blocker::
eventFilter( QObject* obj, QEvent* event )
{
  return( true ); // -> Block all events
  /* NOTE: correct implementation:
     switch( event->type( ) )
     {
     //list event you want to prevent here ...
     case QEvent::KeyPress:
     case QEvent::KeyRelease:
     case QEvent::MouseButtonRelease:
     case QEvent::MouseButtonPress:
     case QEvent::MouseButtonDblClick:
     //...
     return( true );
     } // hctiws
     return( this->QObject::eventFilter( obj, event ) );
  */
}

// -------------------------------------------------------------------------
PipelineEditor::
PipelineEditor( int argc, char* argv[], QApplication* app, QWidget* parent )
  : QMainWindow( parent ),
    m_UI( new Ui::PipelineEditor ),
    m_Application( app ),
    m_Workspace( NULL ),
    m_PluginsPath( "." )
{
  this->m_UI->setupUi( this );

  // Prepare plugins interface
  QFileInfo info( argv[ 0 ] );
  if( info.exists( ) )
  {
    this->m_PluginsPath = info.canonicalPath( ).toStdString( );
    this->_LoadPluginsFromPath( this->m_PluginsPath );

  } // fi

  /* TODO
     this->m_Interface = new cpPlugins::Interface( );
     this->m_PluginsPath = info.canonicalPath( ).toStdString( );
     if( !( this->m_Interface->LoadDefaultConfiguration( this->m_PluginsPath ) ) )
     if( this->m_Interface->LoadFromFolder( this->m_PluginsPath, false ) != "" )
     if( !( this->m_Interface->SaveDefaultConfiguration( this->m_PluginsPath ) ) )
     QMessageBox::critical(
     this,
     "Error creating default plugins configuration",
     "Could not save default plugins configuration"
     );
     this->_UpdateLoadedPlugins( );

     } // fi
  */

  // Create an empty workspace
  this->m_Workspace = new cpPlugins::Workspace( );
  this->m_Workspace->SetInterface( &( this->m_Interface ) );
  this->m_UI->Canvas->editor( )->setWorkspace( this->m_Workspace );
  this->m_Workspace->SetMPRViewer( this->m_UI->Viewer );

  // Connect actions to slots
  PipelineEditor_ConnectButton( LoadPluginsFile );
  PipelineEditor_ConnectButton( LoadPluginsPath );
  PipelineEditor_ConnectAction( OpenWorkspace );
  PipelineEditor_ConnectAction( SaveWorkspace );
  this->connect(
    this->m_UI->Canvas->editor( ),
    SIGNAL( execFilter( const std::string& ) ),
    this,
    SLOT( _ExecFilter( const std::string& ) )
    );
  this->connect(
    this->m_UI->Canvas->editor( ),
    SIGNAL( showFilterOutput( const std::string&, const std::string& ) ),
    this,
    SLOT( _ShowFilterOutput( const std::string&, const std::string& ) )
    );
}

// -------------------------------------------------------------------------
PipelineEditor::
~PipelineEditor( )
{
  if( this->m_Workspace != NULL )
    delete this->m_Workspace;
  // TODO: this causes a segfault (?)
  // delete this->m_UI;
}

// -------------------------------------------------------------------------
void PipelineEditor::
_LoadPluginsFromPath( const std::string& path )
{
  QDir dir( path.c_str( ) );
  std::stringstream filters_str;
  filters_str << "*." << cpPlugins_PLUGIN_EXT;
  QStringList filters;
  filters << filters_str.str( ).c_str( );
  auto files = dir.entryList( filters );
  for( auto fIt = files.begin( ); fIt != files.end( ); ++fIt )
  {
    try
    {
      this->m_Interface.LoadPluginFile( fIt->toStdString( ) );
    }
    catch( ... )
    {
      // Just ignore un-loadable libraries
    }

  } // yrt
  this->_UpdateLoadedPlugins( );
}

// -------------------------------------------------------------------------
void PipelineEditor::
_UpdateLoadedPlugins( )
{
  this->_Block( );
  auto filters = this->m_Interface.GetFilters( );
  if( filters.size( ) == 0 )
  {
    QMessageBox::critical(
      this,
      "Error loading default plugins",
      "No plugins loaded: remember to load some!!!"
      );
    return;

  } // fi

  for( auto cIt = filters.begin( ); cIt != filters.end( ); ++cIt )
  {
    // Create or get category
    QList< QTreeWidgetItem* > cat_items =
      this->m_UI->LoadedPlugins->findItems(
        cIt->first.c_str( ), Qt::MatchExactly | Qt::MatchRecursive
        );
    QTreeWidgetItem* cat = NULL;
    if( cat_items.size( ) == 0 )
    {
      cat = new QTreeWidgetItem(
        ( QTreeWidgetItem* )( NULL ), QStringList( cIt->first.c_str( ) )
        );
      this->m_UI->LoadedPlugins->addTopLevelItem( cat );
    }
    else
      cat = cat_items[ 0 ];

    // Create filters
    auto fIt = cIt->second.begin( );
    for( ; fIt != cIt->second.end( ); ++fIt )
    {
      QList< QTreeWidgetItem* > filter_items =
        this->m_UI->LoadedPlugins->findItems(
          fIt->c_str( ), Qt::MatchExactly | Qt::MatchRecursive
          );
      auto fiIt = filter_items.begin( );
      auto found_fiIt = filter_items.end( );
      for( ; fiIt != filter_items.end( ); ++fiIt )
        if( ( *fiIt )->parent( ) == cat )
          found_fiIt = fiIt;

      // Add filter
      if( found_fiIt == filter_items.end( ) )
        QTreeWidgetItem* filter = new QTreeWidgetItem(
          cat, QStringList( fIt->c_str( ) )
          );

    } // rof

  } // rof
  this->_UnBlock( );
}

// -------------------------------------------------------------------------
void PipelineEditor::
_Block( )
{
  this->m_Application->setOverrideCursor( Qt::WaitCursor );
  this->m_Application->installEventFilter( &( this->m_Blocker ) );
}

// -------------------------------------------------------------------------
void PipelineEditor::
_UnBlock( )
{
  while( this->m_Application->overrideCursor( ) )
    this->m_Application->restoreOverrideCursor( );
  this->m_Application->removeEventFilter( &( this->m_Blocker ) );
}

// -------------------------------------------------------------------------
void PipelineEditor::
_ButtonLoadPluginsFile( )
{
  /*
  QFileDialog dlg( this );
  dlg.setFileMode( QFileDialog::ExistingFiles );
  dlg.setDirectory( "." );

  std::stringstream name_filter;
  std::string suffix = std::string( cpPlugins_PLUGIN_EXT ).substr( 1 );

  name_filter << "Plugins file (*" << cpPlugins_PLUGIN_EXT << ");;All files (*)";
  dlg.setNameFilter( name_filter.str( ).c_str( ) );
  dlg.setDefaultSuffix( suffix.c_str( ) );

  if( !( dlg.exec( ) ) )
    return;

  // Read
  QStringList names = dlg.selectedFiles( );
  std::stringstream err_str;
  for( auto qIt = names.begin( ); qIt != names.end( ); ++qIt )
    err_str << this->m_Interface->Load( qIt->toStdString( ) );

  // Show an error message
  std::string err = err_str.str( );
  if( err.size( ) > 0 )
    QMessageBox::critical(
      this,
      "Error loading plugins",
      err.c_str( )
      );

  // Update view
  this->m_Interface->SaveDefaultConfiguration( this->m_PluginsPath );
  this->_UpdateLoadedPlugins( );
  */
}

// -------------------------------------------------------------------------
void PipelineEditor::
_ButtonLoadPluginsPath( )
{
  /*
  QFileDialog dlg( this );
  dlg.setFileMode( QFileDialog::DirectoryOnly );
  dlg.setDirectory( "." );
  if( !( dlg.exec( ) ) )
    return;

  // Read
  std::string dir = dlg.selectedFiles( ).begin( )->toStdString( );
  std::string err = this->m_Interface->LoadFromFolder( dir, false );
  if( err != "" )
    QMessageBox::critical(
      this,
      "Error loading plugins directory",
      err.c_str( )
      );

  // Update view
  this->m_Interface->SaveDefaultConfiguration( this->m_PluginsPath );
  this->_UpdateLoadedPlugins( );
  */
}

// -------------------------------------------------------------------------
void PipelineEditor::
_ActionOpenWorkspace( )
{
  QFileDialog dlg( this );
  dlg.setFileMode( QFileDialog::ExistingFile );
  dlg.setDirectory( "." );
  dlg.setNameFilter(
    QFileDialog::tr( "Workspace file (*.wxml);;All files (*)" )
    );
  dlg.setDefaultSuffix( QFileDialog::tr( "wxml" ) );
  if( !( dlg.exec( ) ) )
    return;

  std::string fname = dlg.selectedFiles( ).at( 0 ).toStdString( );
  if( this->m_Workspace != NULL )
    delete this->m_Workspace;
  this->m_Workspace = new cpPlugins::Workspace( );
  this->m_Workspace->SetInterface( &( this->m_Interface ) );
  this->m_Workspace->SetMPRViewer( this->m_UI->Viewer );
  std::string err = this->m_Workspace->LoadWorkspace( fname );
  if( err != "" )
  {
    delete this->m_Workspace;
    this->m_Workspace = NULL;
    QMessageBox::critical(
      this,
      QMessageBox::tr( "Error loading workspace" ),
      QMessageBox::tr( err.c_str( ) )
      );
  }
  else
    this->m_UI->Canvas->editor( )->setWorkspace( this->m_Workspace );
}

// -------------------------------------------------------------------------
void PipelineEditor::
_ActionSaveWorkspace( )
{
  if( this->m_Workspace == NULL )
    return;

  QFileDialog dlg( this );
  dlg.setFileMode( QFileDialog::AnyFile );
  dlg.setDirectory( "." );
  dlg.setAcceptMode( QFileDialog::AcceptSave );
  dlg.setNameFilter(
    QFileDialog::tr( "Workspace file (*.wxml);;All files (*)" )
    );
  dlg.setDefaultSuffix( QFileDialog::tr( "wxml" ) );
  if( !( dlg.exec( ) ) )
    return;
  std::string fname = dlg.selectedFiles( ).at( 0 ).toStdString( );

  std::string err = this->m_Workspace->SaveWorkspace( fname );
  if( err != "" )
    QMessageBox::critical(
      this,
      QMessageBox::tr( "Error saving workspace" ),
      QMessageBox::tr( err.c_str( ) )
      );
}


// -------------------------------------------------------------------------
void PipelineEditor::
_ExecFilter( const std::string& filter_name )
{
  if( this->m_Workspace != NULL )
  {
    // Update filter, if needed
    this->_Block( );
    std::string err = this->m_Workspace->Execute( filter_name );
    this->_UnBlock( );
    if( err != "" )
      QMessageBox::critical(
        this,
        QMessageBox::tr( "Error executing filter" ),
        QMessageBox::tr( err.c_str( ) )
        );

  } // fi
}

// -------------------------------------------------------------------------
void PipelineEditor::
_ShowFilterOutput(
  const std::string& filter_name, const std::string& output_name
  )
{
  typedef cpPlugins::DataObject _TDataObject;

  // Update filter, if needed
  this->_ExecFilter( filter_name );

  // Get output
  auto filter = this->m_Workspace->GetFilter( filter_name );
  if( filter != NULL )
  {
    auto output = filter->GetOutputData( output_name );
    if( output != NULL )
    {
      std::string data_name = output_name + "@" + filter_name;
      auto idata = output->GetVTK< vtkImageData >( );
      auto mdata = output->GetVTK< vtkPolyData >( );
      if( idata != NULL )
      {
        if( this->m_UI->Viewer->AddData( idata, data_name, "" ) )
        {
          if( this->m_UI->Viewer->GetNumberOfData( ) > 1 )
            this->m_UI->Viewer->SetDataColor( data_name, 1, 0, 0 );
          else
            this->m_UI->Viewer->SetMainImage( data_name );
          this->_Block( );
          this->m_UI->Viewer->ShowData( data_name );
          this->_UnBlock( );

        } // fi
      }
      else if( mdata != NULL )
      {
      }
      else
        QMessageBox::critical(
          this,
          QMessageBox::tr( "Error showing data" ),
          QMessageBox::tr( "No known VTK conversion!" )
          );

      /* TODO
         if( this->m_UI->Viewer->AddData( output, data_name, "" ) )
         {
         if( this->m_UI->Viewer->GetNumberOfData( ) > 1 )
         this->m_UI->Viewer->SetDataColor( data_name, 1, 0, 0 );
         else
         this->m_UI->Viewer->SetMainImage( data_name );
         this->m_UI->Viewer->ShowData( data_name );
         }
         else
      */

    } // fi

  } // fi
}

// eof - $RCSfile$