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

#include <QFileInfo>
#include <QMessageBox>

// -------------------------------------------------------------------------
#define ImageMPR_ConnectAction( ACTION )                \
  QObject::connect(                                     \
    this->m_UI->a##ACTION, SIGNAL( triggered( ) ),      \
    this, SLOT( _a##ACTION( ) )                         \
    )

// -------------------------------------------------------------------------
ImageMPR::
ImageMPR( QWidget* parent )
  : QMainWindow( parent ),
    m_UI( new Ui::ImageMPR )
{
  this->m_UI->setupUi( this );
  this->m_Plugins.SetWidget( this );
  this->m_Plugins.SetApplication( this );

  // Connect actions
  ImageMPR_ConnectAction( OpenImage );
  ImageMPR_ConnectAction( OpenDICOMSeries );
  ImageMPR_ConnectAction( OpenSegmentation );
  ImageMPR_ConnectAction( OpenPolyData );
  ImageMPR_ConnectAction( SaveImage );
  ImageMPR_ConnectAction( SavePolyData );
  ImageMPR_ConnectAction( Undo );
  ImageMPR_ConnectAction( Redo );
  ImageMPR_ConnectAction( LoadPlugins );
  ImageMPR_ConnectAction( ShowPlugins );

  // Associate model with view
  for( unsigned int i = 0; i < 4; ++i )
    this->m_Plugins.AddInteractor( this->m_UI->MPR->GetInteractor( i ) );

  // Try to load default plugins
  QStringList args = QApplication::arguments( );
  QFileInfo info( args.at( 0 ) );
  this->m_Plugins.LoadPluginsPath(
    info.absolutePath( ).toStdString( ), true
    );

  // Put loaded plugins into menu
  this->_AssociatePluginsToMenu( );
}

// -------------------------------------------------------------------------
ImageMPR::
~ImageMPR( )
{
  delete this->m_UI;
}

// -------------------------------------------------------------------------
void ImageMPR::
UpdateActualFilter( )
{
  if( !( this->m_Plugins.HasActiveFilter( ) ) )
    return;

  // Update filter
  TPlugins::TStringContainer outputs;
  if(
    !(
      this->m_Plugins.UpdateActiveFilter(
        outputs, this->m_ActiveFilterMainInput
        )
      )
    )
    return;

  // Show outputs
  for( auto oIt = outputs.begin( ); oIt != outputs.end( ); ++oIt )
  {
    std::string parent = this->m_Plugins.GetParent( *oIt );
    TDataObject* dobj = this->m_Plugins.GetData< TDataObject >( *oIt );
    if( this->m_UI->MPR->AddData( dobj, *oIt, parent ) )
      this->m_UI->MPR->ShowData( *oIt );

  } // rof
}

// -------------------------------------------------------------------------
void ImageMPR::
_AssociatePluginsToMenu( )
{
  this->m_UI->MenuFilters->clear( );

  TPlugins::TStringContainer categories;
  this->m_Plugins.GetLoadedCategories( categories );
  for( auto cIt = categories.begin( ); cIt != categories.end( ); ++cIt )
  {
    QMenu* category = this->m_UI->MenuFilters->addMenu( cIt->c_str( ) );
    const TPlugins::TStringContainer& filters =
      this->m_Plugins.GetLoadedFilters( *cIt );
    for( auto fIt = filters.begin( ); fIt != filters.end( ); ++fIt )
    {
      QAction* filter = category->addAction( fIt->c_str( ) );
      this->connect(
        filter, SIGNAL( triggered( ) ),
        this, SLOT( _execPlugin( ) )
        );

    } // rof

  } // rof
}

// -------------------------------------------------------------------------
#define ImageMPR_ReadImage( F )                                         \
  this->m_UI->MPR->DeleteAllData( );                                    \
  this->m_Plugins.ClearDataObjects( );                                  \
  try                                                                   \
  {                                                                     \
    std::string name = this->m_Plugins.Read##F( "" );                   \
    if( name == "" )                                                    \
      return;                                                           \
    TImage* image = this->m_Plugins.GetData< TImage >( name );          \
    this->m_UI->MPR->AddData( image, name, "" );                        \
    this->m_UI->MPR->SetMainImage( name );                              \
    this->m_UI->MPR->ShowData( name );                                  \
  }                                                                     \
  catch( std::exception& err )                                          \
  {                                                                     \
    QMessageBox::critical(                                              \
      this,                                                             \
      QMessageBox::tr( "Error reading image." ),                        \
      QMessageBox::tr( err.what( ) )                                    \
      );                                                                \
  }

void ImageMPR::_aOpenImage( )       { ImageMPR_ReadImage( Image ) }
void ImageMPR::_aOpenDICOMSeries( ) { ImageMPR_ReadImage( DicomSeries ) }

// -------------------------------------------------------------------------
void ImageMPR::
_aOpenSegmentation( )
{
  try
  {
    std::string parent = this->m_UI->MPR->GetMainImage( );
    std::string name = this->m_Plugins.ReadImage( parent );
    if( name == "" )
      return;
    TImage* image = this->m_Plugins.GetData< TImage >( name );
    this->m_UI->MPR->AddData( image, name, parent );
    this->m_UI->MPR->ShowData( name );
  }
  catch( std::exception& err )
  {
    QMessageBox::critical(
      this,
      QMessageBox::tr( "Error reading image." ),
      QMessageBox::tr( err.what( ) )
      );

  } // yrt
}

// -------------------------------------------------------------------------
void ImageMPR::
_aOpenPolyData( )
{
}

// -------------------------------------------------------------------------
void ImageMPR::
_aSaveImage( )
{
  this->m_Plugins.WriteDataObject( this->m_UI->MPR->GetSelectedData( ) );
}

// -------------------------------------------------------------------------
void ImageMPR::
_aSavePolyData( )
{
}

// -------------------------------------------------------------------------
void ImageMPR::
_aUndo( )
{
}

// -------------------------------------------------------------------------
void ImageMPR::
_aRedo( )
{
}

// -------------------------------------------------------------------------
void ImageMPR::
_aLoadPlugins( )
{
  this->m_Plugins.DialogLoadPlugins( );
  this->_AssociatePluginsToMenu( );
}

// -------------------------------------------------------------------------
void ImageMPR::
_aShowPlugins( )
{
}

// -------------------------------------------------------------------------
void ImageMPR::
_execPlugin( )
{
  // Get filter's name
  QAction* action = dynamic_cast< QAction* >( this->sender( ) );
  if( action == NULL )
    return;
  std::string filter_name = action->text( ).toStdString( );

  // Activate filter
  if( !( this->m_Plugins.ActivateFilter( filter_name ) ) )
    return;

  // Get IO names
  TPlugins::TStringContainer inputs;
  this->m_Plugins.GetActiveFilterInputsNames( inputs );

  // Configure inputs
  if( inputs.size( ) > 1 )
  {
    // TODO
  }
  else if( inputs.size( ) == 1 )
  {
    this->m_ActiveFilterMainInput = this->m_UI->MPR->GetSelectedData( );
    this->m_Plugins.ConnectInputInActiveFilter(
      this->m_ActiveFilterMainInput, *( inputs.begin( ) )
      );

  } // fi

  // Configure paramereters
  auto dlg_res = this->m_Plugins.ConfigureActiveFilter( );
  if( !dlg_res )
  {
    // Just deactivate filter, since it was canceled
    this->m_Plugins.DeactivateFilter( );
    return;
  }
  else
  {
    // Execute automatic filter and associate outputs
    this->UpdateActualFilter( );
    this->m_Plugins.DeactivateFilter( );

  } // fi
}

// eof - $RCSfile$