#include <cpPlugins/Interface/Workspace.h>

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
Workspace( )
  : m_Plugins( NULL )
{
  this->m_Graph = TGraph::New( );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
~Workspace( )
{
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
TPlugins* cpPlugins::Interface::Workspace::
GetPlugins( )
{
  return( this->m_Plugins );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Workspace::
TPlugins* cpPlugins::Interface::Workspace::
GetPlugins( ) const
{
  return( this->m_Plugins );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
SetPlugins( TPlugins* i )
{
  if( this->m_Plugins != i )
    this->m_Plugins = i;
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
TGraph* cpPlugins::Interface::Workspace::
GetGraph( )
{
  return( this->m_Graph );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Workspace::
TGraph* cpPlugins::Interface::Workspace::
GetGraph( ) const
{
  return( this->m_Graph );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
Clear( )
{
  if( this->m_Graph.IsNotNull( ) )
    this->m_Graph->Clear( );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
ClearConnections( )
{
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Workspace::
TFilter* cpPlugins::Interface::Workspace::
GetFilter( const std::string& name )
{
  TFilter* f =
    dynamic_cast< TFilter* >(
      this->m_Graph->GetVertex( name ).GetPointer( )
      );
  return( f );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Workspace::
TFilter* cpPlugins::Interface::Workspace::
GetFilter( const std::string& name ) const
{
  const TFilter* f =
    dynamic_cast< const TFilter* >(
      this->m_Graph->GetVertex( name ).GetPointer( )
      );
  return( f );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
HasFilter( const std::string& name ) const
{
  if( this->m_Graph->HasVertexIndex( name ) )
    return( this->GetFilter( name ) != NULL );
  else
    return( false );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
CreateFilter( const std::string& filter, const std::string& name )
{
  if( this->m_Plugins == NULL )
    return( false );

  // Get or create new filter from name
  if( !( this->m_Graph->HasVertexIndex( name ) ) )
  {
    TFilter::Pointer f = this->m_Plugins->CreateObject( filter );
    if( f.IsNotNull( ) )
    {
      f->SetName( name );
      TObject::Pointer o = f.GetPointer( );
      this->m_Graph->SetVertex( name, o );
      return( true );
    }
    else
      return( false );
  }
  else
    return( true );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
RenameFilter( const std::string& old_name, const std::string& new_name )
{
  if( this->m_Graph->RenameVertex( old_name, new_name ) )
  {
    TFilter* f = this->GetFilter( new_name );
    f->SetName( new_name );
    return( true );
  }
  else
    return( false );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
RemoveFilter( const std::string& name )
{
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
Connect(
  const std::string& orig_filter, const std::string& dest_filter,
  const std::string& output_name, const std::string& input_name
  )
{
  // Get filters
  TFilter* orig = this->GetFilter( orig_filter );
  TFilter* dest = this->GetFilter( dest_filter );
  if( orig == NULL || dest == NULL )
    return( false );

  // Real connection
  dest->SetInput( input_name, orig->GetOutput< TData >( output_name ) );
  this->m_Graph->AddEdge(
    orig_filter, dest_filter,
    TConnection( output_name, input_name )
    );
  return( false );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
Connect( TData* input_object, const std::string& input_name )
{
  auto port = this->m_ExposedInputPorts.find( input_name );
  if( port != this->m_ExposedInputPorts.end( ) )
  {
    TFilter* filter = this->GetFilter( port->second.first );
    if( filter != NULL )
    {
      filter->SetInput( port->second.second, input_object );
      return( true );
    }
    else
      return( false );
  }
  else
    return( false );
}

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Workspace::
Reduce( const std::string& name )
{
  return( false );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
ExposeInputPort(
  const std::string& name,
  const std::string& filter, const std::string& filter_input
  )
{
  this->m_ExposedInputPorts[ name ] = TExposedPort( filter, filter_input );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
ExposeOutputPort(
  const std::string& name,
  const std::string& filter, const std::string& filter_output
  )
{
  this->m_ExposedOutputPorts[ name ] = TExposedPort( filter, filter_output );
}

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

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

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

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

// -------------------------------------------------------------------------
/* TODO
cpPlugins::Interface::Workspace::
TData* cpPlugins::Interface::Workspace::
GetOutput( const std::string& name )
{
  auto port = this->m_ExposedOutputPorts.find( name );
  if( port != this->m_ExposedOutputPorts.end( ) )
  {
    TFilter* f = this->GetFilter( port->second.first );
    if( f != NULL )
      return( f->GetOutput< TData >( port->second.second ) );
    else
      return( NULL );
  }
  else
    return( NULL );
}

// -------------------------------------------------------------------------
const cpPlugins::Interface::Workspace::
TData* cpPlugins::Interface::Workspace::
GetOutput( const std::string& name ) const
{
  auto port = this->m_ExposedOutputPorts.find( name );
  if( port != this->m_ExposedOutputPorts.end( ) )
  {
    const TFilter* f = this->GetFilter( port->second.first );
    if( f != NULL )
      return( f->GetOutput< TData >( port->second.second ) );
    else
      return( NULL );
  }
  else
    return( NULL );
}

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

// -------------------------------------------------------------------------
void cpPlugins::Interface::Workspace::
ClearOutputPorts( )
{
  this->m_ExposedOutputPorts.clear( );
}
*/

// -------------------------------------------------------------------------
std::string cpPlugins::Interface::Workspace::
Execute( QWidget* p )
{
  // Find sinks
  std::set< std::string > sinks = this->m_Graph->GetSinks( );

  // Update sinks
  std::string err = "";
  for( auto sIt = sinks.begin( ); sIt != sinks.end( ); ++sIt )
  {
    std::string lerr = this->Execute( *sIt, p );
    if( lerr != "" )
      err += lerr + std::string( "\n" );

  } // rof
  return( err );
}

// -------------------------------------------------------------------------
std::string cpPlugins::Interface::Workspace::
Execute( const std::string& name, QWidget* p )
{
  // Get filter
  TFilter* f = this->GetFilter( name );
  if( f == NULL )
    return(
      std::string( "cpPlugins::Interface::Workspace: Vertex \"" ) +
      name + std::string( "\" is not a filter." )
      );

  // Execute and return
  if( p != NULL )
  {
    auto diag_res = f->ExecConfigurationDialog( p );
    if( diag_res == TFilter::DialogResult_NoModal )
      return( f->Update( ) );
    else
      return( "" );
  }
  else
    return( f->Update( ) );
}

// eof - $RCSfile$