#include <cpPlugins/Interface/Workspace.h>
#include <cpPlugins/BaseObjects/Widget.h>

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
Pointer cpPlugins::Interface::Workspace::
New( )
{
  Pointer smartPtr = new Self;
  smartPtr->UnRegister( );
  return( smartPtr );
}

// -------------------------------------------------------------------------
itk::LightObject::Pointer cpPlugins::Interface::Workspace::
CreateAnother( ) const
{
  itk::LightObject::Pointer smartPtr;
  smartPtr = Self::New( ).GetPointer( );
  return( smartPtr );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
Pointer cpPlugins::Interface::Workspace::
Clone( ) const
{
  Pointer rval =
    dynamic_cast< Self* >( this->InternalClone( ).GetPointer( ) );
  return( rval );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
Clear( )
{
  this->m_Filters.clear( );
}

// -------------------------------------------------------------------------
std::vector< std::string > cpPlugins::Interface::Workspace::
GetFiltersNames( ) const
{
  std::vector< std::string > n;
  for( auto i : this->m_Filters )
    n.push_back( i.first );
  return( n );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
TFilter* cpPlugins::Interface::Workspace::
GetFilter( const std::string& name )
{
  auto i = this->m_Filters.find( name );
  if( i != this->m_Filters.end( ) )
    return( i->second.GetPointer( ) );
  else
    return( NULL );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Workspace::
TFilter* cpPlugins::Interface::Workspace::
GetFilter( const std::string& name ) const
{
  auto i = this->m_Filters.find( name );
  if( i != this->m_Filters.end( ) )
    return( i->second.GetPointer( ) );
  else
    return( NULL );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
TWidget* cpPlugins::Interface::Workspace::
GetWidget( const std::string& name )
{
  TFilter* process = this->GetFilter( name );
  return( dynamic_cast< TWidget* >( process ) );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Workspace::
TWidget* cpPlugins::Interface::Workspace::
GetWidget( const std::string& name ) const
{
  const TFilter* process = this->GetFilter( name );
  return( dynamic_cast< const TWidget* >( process ) );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
HasFilter( const std::string& name ) const
{
  return( this->m_Filters.find( name ) != this->m_Filters.end( ) );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
HasWidget( const std::string& name ) const
{
  const TWidget* wdg = this->GetWidget( name );
  return( wdg != NULL );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
TFilter* cpPlugins::Interface::Workspace::
CreateFilter( const std::string& category, const std::string& filter )
{
  typedef cpPlugins::BaseObjects::Widget _TWidget;

  TFilter::Pointer o = this->m_Plugins->CreateFilter( category, filter );
  if( o.IsNotNull( ) )
  {
    // Choose a name
    std::string name = filter;
    while( this->GetFilter( name ) != NULL )
      name += std::string( "_" );
    o->SetPrintExecution( this->m_PrintExecution );
    o->SetName( name );

    // Interactors
    for(
      auto i = this->m_Interactors.begin( );
      i != this->m_Interactors.end( );
      ++i
      )
      o->AddInteractor( *i );

    // Finish association
    this->m_Filters[ name ] = o;

  } // fi
  return( o.GetPointer( ) );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
RenameFilter( const std::string& old_name, const std::string& new_name )
{
  auto o = this->m_Filters.find( old_name );
  auto n = this->m_Filters.find( new_name );
  if( o != this->m_Filters.end( ) && n == this->m_Filters.end( ) )
  {
    // Rename filter
    o->second->SetName( new_name );
    this->m_Filters[ new_name ] = o->second;
    this->m_Filters.erase( o );

    // Rename exposed ports
    /* TODO
       auto e = this->m_ExposedInputs.begin( );
       for( ; e != this->m_ExposedInputs.end( ); ++e )
       if( e->second.first == old_name )
       e->second.first = new_name;
       e = this->m_ExposedOutputs.begin( );
       for( ; e != this->m_ExposedOutputs.end( ); ++e )
       if( e->second.first == old_name )
       e->second.first = new_name;
    */

    return( true );
  }
  else
    return( false );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
RemoveFilter( const std::string& name )
{
  auto i = this->m_Filters.find( name );
  if( i != this->m_Filters.end( ) )
  {
    i->second->Disconnect( );
    this->m_Filters.erase( i );
    return( true );
  }
  else
    return( false );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
SetPrintExecution( bool b )
{
  this->m_PrintExecution = b;
  for( auto i = this->m_Filters.begin( ); i != this->m_Filters.end( ); ++i )
    i->second->SetPrintExecution( b );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
PrintExecutionOn( )
{
  this->SetPrintExecution( true );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
PrintExecutionOff( )
{
  this->SetPrintExecution( true );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
AddInteractor( vtkRenderWindowInteractor* iren )
{
  if( iren != NULL )
  {
    this->m_Interactors.insert( iren );
    for( auto f : this->m_Filters )
      f.second->AddInteractor( iren );

  } // fi
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
Connect(
  const std::string& origin_filter,
  const std::string& origin_output,
  const std::string& destination_filter,
  const std::string& destination_input
  )
{
  // Get filters and check pertinence
  TFilter* origin = this->GetFilter( origin_filter );
  TFilter* destination = this->GetFilter( destination_filter );
  if( origin == NULL || destination == NULL )
    return( false );
  if( !( destination->HasInput( destination_input ) ) )
    return( false );
  if( !( origin->HasOutput( origin_output ) ) )
    return( false );

  // Check if there is room for a new connection
  bool ok = true;
  if( destination->IsInputMultiple( destination_input ) )
  {
    for(
      unsigned int i = 0;
      i < destination->GetInputSize( destination_input );
      ++i
      )
      if(
        destination->GetInput( destination_input, i )->GetSource( ) == origin
        )
        ok = false;
  }
  else
    ok = ( destination->GetInput( destination_input ) == NULL );
  if( ok )
    destination->AddInput(
      destination_input,
      origin->GetOutput( origin_output )
      );
  return( ok );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
Connect(
  TDataObject* input,
  const std::string& destination_filter,
  const std::string& destination_input
  )
{
  // Get filters and check pertinence
  if( input == NULL )
    return( false );
  TFilter* destination = this->GetFilter( destination_filter );
  if( destination == NULL )
    return( false );
  if( !( destination->HasInput( destination_input ) ) )
    return( false );

  // Check if there is room for a new connection
  bool ok = true;
  if( destination->IsInputMultiple( destination_input ) )
  {
    for(
      unsigned int i = 0;
      i < destination->GetInputSize( destination_input );
      ++i
      )
      if(
        destination->GetInput( destination_input, i )->GetSource( ) ==
        input->GetSource( )
        )
        ok = false;
  }
  else
    ok = ( destination->GetInput( destination_input ) == NULL );
  if( ok )
    destination->AddInput(
      destination_input,
      input
      );
  return( ok );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
Disconnect(
  const std::string& origin_filter,
  const std::string& origin_output,
  const std::string& destination_filter,
  const std::string& destination_input
  )
{
  // Get filters and check pertinence
  TFilter* origin = this->GetFilter( origin_filter );
  TFilter* destination = this->GetFilter( destination_filter );
  if( origin == NULL || destination == NULL )
    return( false );
  if( !( destination->HasInput( destination_input ) ) )
    return( false );
  if( !( origin->HasOutput( origin_output ) ) )
    return( false );

  // Check if there is room for a new connection
  bool ok = false;
  unsigned int del_id = 0;
  for(
    unsigned int i = 0;
    i < destination->GetInputSize( destination_input );
    ++i
    )
    if(
      destination->GetInput( destination_input, i )->GetSource( ) == origin
      )
    {
      ok = true;
      del_id = i;

    } // fi
  if( ok )
    destination->DisconnectInput( destination_input, del_id );
  return( ok );
}

// -------------------------------------------------------------------------
/*
const cpPlugins::Interface::Workspace::
TExposedPorts& cpPlugins::Interface::Workspace::
GetExposedInputs( ) const
{
  return( this->m_ExposedInputs );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Workspace::
TExposedPorts& cpPlugins::Interface::Workspace::
GetExposedOutputs( ) const
{
  return( this->m_ExposedOutputs );
}

// -------------------------------------------------------------------------
cpPlugins::BaseObjects::DataObject* cpPlugins::Interface::Workspace::
GetExposedOutput( const std::string& name )
{
  auto i = this->m_ExposedOutputs.find( name );
  if( i != this->m_ExposedOutputs.end( ) )
  {
    auto f = this->GetFilter( i->second.first );
    if( f != NULL )
      return( f->GetOutput( i->second.second ) );
    else
      return( NULL );
  }
  else
    return( NULL );
}

// -------------------------------------------------------------------------
const cpPlugins::BaseObjects::DataObject* cpPlugins::Interface::Workspace::
GetExposedOutput( const std::string& name ) const
{
  auto i = this->m_ExposedOutputs.find( name );
  if( i != this->m_ExposedOutputs.end( ) )
  {
    auto f = this->GetFilter( i->second.first );
    if( f != NULL )
      return( f->GetOutput( i->second.second ) );
    else
      return( NULL );
  }
  else
    return( NULL );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
ExposeInput(
  const std::string& name,
  const std::string& filter, const std::string& filter_input
  )
{
  auto i = this->m_ExposedInputs.find( name );
  if( i == this->m_ExposedInputs.end( ) )
  {
    this->m_ExposedInputs[ name ] =
      std::pair< std::string, std::string >( filter, filter_input );
    return( true );
  }
  else
    return( false );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
ExposeOutput(
  const std::string& name,
  const std::string& filter, const std::string& filter_output
  )
{
  auto i = this->m_ExposedOutputs.find( name );
  if( i == this->m_ExposedOutputs.end( ) )
  {
    this->m_ExposedOutputs[ name ] =
      std::pair< std::string, std::string >( filter, filter_output );
    return( true );
  }
  else
    return( false );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
HideInput( const std::string& name )
{
  auto i = this->m_ExposedInputs.find( name );
  if( i != this->m_ExposedInputs.end( ) )
    this->m_ExposedInputs.erase( i );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
HideOutput( const std::string& name )
{
  auto i = this->m_ExposedOutputs.find( name );
  if( i != this->m_ExposedOutputs.end( ) )
    this->m_ExposedOutputs.erase( i );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
RenameExposedInput(
  const std::string& old_name, const std::string& new_name
  )
{
  auto o = this->m_ExposedInputs.find( old_name );
  auto n = this->m_ExposedInputs.find( new_name );
  if( o != this->m_ExposedInputs.end( ) && n == this->m_ExposedInputs.end( ) )
  {
    this->m_ExposedInputs[ new_name ] = o->second;
    this->m_ExposedInputs.erase( o );
    return( true );
  }
  else
    return( false );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
RenameExposedOutput(
  const std::string& old_name, const std::string& new_name
  )
{
  auto o = this->m_ExposedOutputs.find( old_name );
  auto n = this->m_ExposedOutputs.find( new_name );
  if(
    o != this->m_ExposedOutputs.end( ) && n == this->m_ExposedOutputs.end( )
    )
  {
    this->m_ExposedOutputs[ new_name ] = o->second;
    this->m_ExposedOutputs.erase( o );
    return( true );
  }
  else
    return( false );
}

// -------------------------------------------------------------------------
std::vector< std::pair< std::string, std::string > >
cpPlugins::Interface::Workspace::
GetConnections(
  const std::string& origin, const std::string& destination
  ) const
{
  std::vector< std::pair< std::string, std::string > > conns;
  auto orig = this->GetFilter( origin );
  auto dest = this->GetFilter( destination );
  if( orig != NULL && dest != NULL )
  {
    auto outs = orig->GetOutputsNames( );
    auto ins = dest->GetInputsNames( );
    for( auto o = outs.begin( ); o != outs.end( ); ++o )
    {
      for( auto i = ins.begin( ); i != ins.end( ); ++i )
      {
        unsigned int nInputs = dest->GetInputSize( *i );
        for( unsigned j = 0; j < nInputs; ++j )
        {
          auto od = orig->GetOutput( *o );
          auto id = dest->GetInput( *i, j );
          if( od != NULL && od == id )
            conns.push_back(
              std::pair< std::string, std::string >( *o, *i )
              );

        } // rof

      } // rof

    } // rof

  } // fi
  return( conns );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
Connect(
  const std::string& orig_filter, const std::string& dest_filter,
  const std::string& output_name, const std::string& input_name
  )
{
  auto o = this->GetFilter( orig_filter );
  auto d = this->GetFilter( dest_filter );
  if( o != NULL && d != NULL )
  {
    try
    {
      d->AddInput( input_name, o->GetOutput( output_name ) );
    }
    catch( std::exception& err )
    {
      throw std::logic_error(
        std::string( "Error connecting \"" ) +
        output_name + std::string( "@" ) + orig_filter +
        std::string( "\" with \"" ) +
        input_name + std::string( "@" ) + dest_filter +
        std::string( "\": " ) +
        err.what( )
        );

    } // yrt

  } // fi
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
Connect(
  cpPlugins::BaseObjects::DataObject* output,
  const std::string& dest_filter, const std::string& input_name
  )
{
  auto d = this->GetFilter( dest_filter );
  if( d != NULL )
    d->AddInput( input_name, output );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
Connect(
  cpPlugins::BaseObjects::DataObject* output,
  const std::string& exposed_input_name
  )
{
  auto i = this->m_ExposedInputs.find( exposed_input_name );
  if( i != this->m_ExposedInputs.end( ) )
    this->Connect( output, i->second.first, i->second.second );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
Disconnect(
  const std::string& orig_filter, const std::string& dest_filter,
  const std::string& output_name, const std::string& input_name
  )
{
  auto orig = this->GetFilter( orig_filter );
  auto dest = this->GetFilter( dest_filter );
  if( orig != NULL && dest != NULL )
  {
    auto out = orig->GetOutput( output_name );
    auto in = dest->GetInput( input_name );
    if( out != NULL && out == in )
      dest->SetInput(
        input_name, ( cpPlugins::BaseObjects::DataObject* )( NULL )
        );

  } // fi
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
Disconnect(
  const std::string& dest_filter, const std::string& input_name
  )
{
  throw std::logic_error( "Disconnect 1" );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
Disconnect( const std::string& dest_filter )
{
  throw std::logic_error( "Disconnect 2" );
}
*/

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
Update( )
{
  for( auto f = this->m_Filters.begin( ); f != this->m_Filters.end( ); ++f )
    f->second->Update( );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
Update( const std::string& name )
{
  auto filter = this->GetFilter( name );
  if( filter != NULL )
    filter->Update( );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
Workspace( )
  : Superclass( ),
    m_PrintExecution( false )
{
  this->m_Plugins = TPlugins::New( );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
~Workspace( )
{
  /* TODO
     this->m_ExposedOutputs.clear( );
     this->m_ExposedInputs.clear( );
  */
  this->m_Filters.clear( );
}

// eof - $RCSfile$