#include <cpPlugins/Interface/Parameters.h>
#include <cpPlugins/Interface/ProcessObject.h>

#include <sstream>

// -------------------------------------------------------------------------
const cpPlugins::Interface::
ProcessObject* cpPlugins::Interface::Parameters::
GetProcessObject( ) const
{
  return( this->m_Process );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
SetProcessObject( ProcessObject* v )
{
  this->m_Process = v;
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
Modified( ) const
{
  this->Superclass::Modified( );
  if( this->m_Process != NULL )
    this->m_Process->Modified( );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
Clear( )
{
  this->m_Parameters.clear( );
  this->Modified( );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
ConfigureAsString( const TString& name, const TString& v )
{
  this->m_Parameters[ name ] = TParameter( Self::String, TValues( v, v ) );
  this->Modified( );
}

// -------------------------------------------------------------------------
#define cpPlugins_Parameters_Configure( Y )             \
  void cpPlugins::Interface::Parameters::               \
  ConfigureAs##Y( const TString& name, const T##Y& v )  \
  {                                                     \
    std::stringstream str;                              \
    str << v;                                           \
    std::string s = str.str( );                         \
    this->m_Parameters[ name ] =                        \
      TParameter( Self::Y, TValues( s, s ) );           \
    this->Modified( );                                  \
  }

cpPlugins_Parameters_Configure( Bool );
cpPlugins_Parameters_Configure( Int );
cpPlugins_Parameters_Configure( Uint );
cpPlugins_Parameters_Configure( Real );

// -------------------------------------------------------------------------
#define cpPlugins_Parameters_List_Configure( Y )        \
  void cpPlugins::Interface::Parameters::               \
  ConfigureAs##Y##List( const TString& name )           \
  {                                                     \
    this->m_Parameters[ name ] =                        \
      TParameter( Self::Y##List, TValues( "", "" ) );   \
    this->Modified( );                                  \
  }

cpPlugins_Parameters_List_Configure( String );
cpPlugins_Parameters_List_Configure( Bool );
cpPlugins_Parameters_List_Configure( Int );
cpPlugins_Parameters_List_Configure( Uint );
cpPlugins_Parameters_List_Configure( Real );
cpPlugins_Parameters_List_Configure( Index );
cpPlugins_Parameters_List_Configure( Point );

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
ConfigureAsChoices(
  const TString& name, const std::vector< TString >& choices
  )
{
  // It is invalid not to give choices when configuring
  if( choices.size( ) == 0 )
    return;

  std::stringstream str_choices;
  str_choices << choices[ 0 ];
  for( unsigned int i = 1; i < choices.size( ); ++i )
    str_choices << "#" << choices[ i ];
  this->m_Parameters[ name ] =
    TParameter( Self::Choices, TValues( str_choices.str( ), "" ) );
  this->Modified( );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
GetNames( std::vector< TString >& container ) const
{
  container.clear( );
  TParameters::const_iterator i = this->m_Parameters.begin( );
  for( ; i != this->m_Parameters.end( ); ++i )
    container.push_back( i->first );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Parameters::
Type cpPlugins::Interface::Parameters::
GetType( const TString& name ) const
{
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i != this->m_Parameters.end( ) )
    return( i->second.first );
  else
    return( Self::NoType );
}

// -------------------------------------------------------------------------
#define cpPlugins_Parameters_Has( Y )                                   \
  bool cpPlugins::Interface::Parameters::                               \
  Has##Y( const TString& name ) const                                   \
  {                                                                     \
    TParameters::const_iterator i = this->m_Parameters.find( name );    \
    if( i != this->m_Parameters.end( ) )                                \
      return( i->second.first == Self::Y );                             \
    else                                                                \
      return( false );                                                  \
  }

cpPlugins_Parameters_Has( String );
cpPlugins_Parameters_Has( Bool );
cpPlugins_Parameters_Has( Int );
cpPlugins_Parameters_Has( Uint );
cpPlugins_Parameters_Has( Real );
cpPlugins_Parameters_Has( Index );
cpPlugins_Parameters_Has( Point );
cpPlugins_Parameters_Has( StringList );
cpPlugins_Parameters_Has( BoolList );
cpPlugins_Parameters_Has( IntList );
cpPlugins_Parameters_Has( UintList );
cpPlugins_Parameters_Has( RealList );
cpPlugins_Parameters_Has( IndexList );
cpPlugins_Parameters_Has( PointList );
cpPlugins_Parameters_Has( Choices );

// -------------------------------------------------------------------------
cpPlugins::Interface::Parameters::
TString cpPlugins::Interface::Parameters::
GetString( const TString& name ) const
{
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i != this->m_Parameters.end( ) )
  {
    if( i->second.first == Self::String )
      return( i->second.second.second );

  } // fi
  return( "" );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Parameters::
TBool cpPlugins::Interface::Parameters::
GetBool( const TString& name ) const
{
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i != this->m_Parameters.end( ) )
  {
    if( i->second.first == Self::Bool )
      return( std::atoi( i->second.second.second.c_str( ) ) == 1 );

  } // fi
  return( false );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Parameters::
TInt cpPlugins::Interface::Parameters::
GetInt( const TString& name ) const
{
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i != this->m_Parameters.end( ) )
  {
    if( i->second.first == Self::Int )
      return( TInt( std::atoi( i->second.second.second.c_str( ) ) ) );

  } // fi
  return( TInt( 0 ) );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Parameters::
TUint cpPlugins::Interface::Parameters::
GetUint( const TString& name ) const
{
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i != this->m_Parameters.end( ) )
  {
    if( i->second.first == Self::Uint )
      return( TUint( std::atoi( i->second.second.second.c_str( ) ) ) );

  } // fi
  return( TUint( 0 ) );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Parameters::
TReal cpPlugins::Interface::Parameters::
GetReal( const TString& name ) const
{
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i != this->m_Parameters.end( ) )
  {
    if( i->second.first == Self::Real )
      return( TReal( std::atof( i->second.second.second.c_str( ) ) ) );

  } // fi
  return( TReal( 0 ) );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
GetStringList( std::vector< TString >& lst, const TString& name ) const
{
  lst.clear( );
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i == this->m_Parameters.end( ) )
    return;
  if( i->second.first != Self::StringList )
    return;

  std::istringstream str( i->second.second.second );
  std::string token;
  while( std::getline( str, token, '#' ) )
    lst.push_back( token );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
GetBoolList( std::vector< TBool >& lst, const TString& name ) const
{
  lst.clear( );
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i == this->m_Parameters.end( ) )
    return;
  if( i->second.first != Self::BoolList )
    return;

  std::istringstream str( i->second.second.second );
  std::string token;
  while( std::getline( str, token, '#' ) )
    lst.push_back( std::atoi( token.c_str( ) ) == 1 );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
GetIntList( std::vector< TInt >& lst, const TString& name ) const
{
  lst.clear( );
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i == this->m_Parameters.end( ) )
    return;
  if( i->second.first != Self::IntList )
    return;

  std::istringstream str( i->second.second.second );
  std::string token;
  while( std::getline( str, token, '#' ) )
    lst.push_back( TInt( std::atoi( token.c_str( ) ) ) );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
GetUintList( std::vector< TUint >& lst, const TString& name ) const
{
  lst.clear( );
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i == this->m_Parameters.end( ) )
    return;
  if( i->second.first != Self::UintList )
    return;

  std::istringstream str( i->second.second.second );
  std::string token;
  while( std::getline( str, token, '#' ) )
    lst.push_back( TUint( std::atoi( token.c_str( ) ) ) );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
GetRealList( std::vector< TReal >& lst, const TString& name ) const
{
  lst.clear( );
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i == this->m_Parameters.end( ) )
    return;
  if( i->second.first != Self::RealList )
    return;

  std::istringstream str( i->second.second.second );
  std::string token;
  while( std::getline( str, token, '#' ) )
    lst.push_back( TReal( std::atof( token.c_str( ) ) ) );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
GetChoices( std::vector< TString >& choices, const TString& name ) const
{
  choices.clear( );
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i == this->m_Parameters.end( ) )
    return;
  if( i->second.first != Self::Choices )
    return;

  std::istringstream str( i->second.second.first );
  std::string token;
  while( std::getline( str, token, '#' ) )
    choices.push_back( token );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Parameters::
TString cpPlugins::Interface::Parameters::
GetSelectedChoice( const TString& name ) const
{
  TParameters::const_iterator i = this->m_Parameters.find( name );
  if( i == this->m_Parameters.end( ) )
    return( "" );
  if( i->second.first != Self::Choices )
    return( "" );
  return( i->second.second.second );
}

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
SetString( const TString& name, const TString& v )
{
  TParameters::iterator i = this->m_Parameters.find( name );
  if( i == this->m_Parameters.end( ) )
    return;
  if( i->second.first != Self::String )
    return;
  i->second.second.second = v;
  this->Modified( );
}

// -------------------------------------------------------------------------
#define cpPlugins_Parameters_Set( Y )                           \
  void cpPlugins::Interface::Parameters::                       \
  Set##Y( const TString& name, const T##Y& v )                  \
  {                                                             \
    TParameters::iterator i = this->m_Parameters.find( name );  \
    if( i == this->m_Parameters.end( ) )                        \
      return;                                                   \
    if( i->second.first != Self::Y )                            \
      return;                                                   \
    std::stringstream str;                                      \
    str << v;                                                   \
    i->second.second.second = str.str( );                       \
    this->Modified( );                                          \
  }

cpPlugins_Parameters_Set( Bool );
cpPlugins_Parameters_Set( Int );
cpPlugins_Parameters_Set( Uint );
cpPlugins_Parameters_Set( Real );

// -------------------------------------------------------------------------
#define cpPlugins_Parameters_Add( Y )                           \
  void cpPlugins::Interface::Parameters::                       \
  AddTo##Y##List( const TString& name, const T##Y& v )          \
  {                                                             \
    TParameters::iterator i = this->m_Parameters.find( name );  \
    if( i == this->m_Parameters.end( ) )                        \
      return;                                                   \
    if( i->second.first != Self::Y##List )                      \
      return;                                                   \
    std::stringstream str;                                      \
    if( i->second.second.second == "" )                         \
      str << v;                                                 \
    else                                                        \
      str << "#" << v;                                          \
    i->second.second.second += str.str( );                      \
    this->Modified( );                                          \
  }

cpPlugins_Parameters_Add( String );
cpPlugins_Parameters_Add( Bool );
cpPlugins_Parameters_Add( Int );
cpPlugins_Parameters_Add( Uint );
cpPlugins_Parameters_Add( Real );

// -------------------------------------------------------------------------
#define cpPlugins_Parameters_Clear( Y )                         \
  void cpPlugins::Interface::Parameters::                       \
  Clear##Y##List( const TString& name )                         \
  {                                                             \
    TParameters::iterator i = this->m_Parameters.find( name );  \
    if( i == this->m_Parameters.end( ) )                        \
      return;                                                   \
    if( i->second.first != Self::Y##List )                      \
      return;                                                   \
    i->second.second.second = "";                               \
    this->Modified( );                                          \
  }

cpPlugins_Parameters_Clear( String );
cpPlugins_Parameters_Clear( Bool );
cpPlugins_Parameters_Clear( Int );
cpPlugins_Parameters_Clear( Uint );
cpPlugins_Parameters_Clear( Real );
cpPlugins_Parameters_Clear( Index );
cpPlugins_Parameters_Clear( Point );

// -------------------------------------------------------------------------
bool cpPlugins::Interface::Parameters::
SetSelectedChoice( const TString& name, const TString& choice )
{
  TParameters::iterator i = this->m_Parameters.find( name );
  if( i == this->m_Parameters.end( ) )
    return( false );
  if( i->second.first != Self::Choices )
    return( false );
  if( i->second.second.first.find( choice ) != std::string::npos )
  {
    i->second.second.second = choice;
    this->Modified( );
    return( true );
  }
  else
    return( false );
}

// -------------------------------------------------------------------------
cpPlugins::Interface::Parameters::
Parameters( )
  : Superclass( ),
    m_Process( NULL )
{
  this->Clear( );
}

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

// -------------------------------------------------------------------------
void cpPlugins::Interface::Parameters::
PrintSelf( std::ostream& os, itk::Indent indent ) const
{
  TParameters::const_iterator i = this->m_Parameters.begin( );
  for( ; i != this->m_Parameters.end( ); ++i )
    os << indent
       << i->first << ": ("
       << i->second.first << " | "
       << i->second.second.first << " | "
       << i->second.second.second << ")"
       << std::endl;
}

// eof - $RCSfile$