#ifndef __cpPlugins__BaseObjects__ProcessObject__h__
#define __cpPlugins__BaseObjects__ProcessObject__h__

#include <cpPlugins/BaseObjects/Object.h>
#include <cpPlugins/BaseObjects/Parameters.h>
#include <cpPlugins/BaseObjects/Port.h>
#include <set>

// -------------------------------------------------------------------------
class QDialog;
class vtkRenderWindowInteractor;

// -------------------------------------------------------------------------
namespace cpPlugins
{
  namespace BaseObjects
  {
    /**
     */
    class cpPlugins_EXPORT ProcessObject
      : public Object
    {
    public:
      typedef ProcessObject                   Self;
      typedef Object                          Superclass;
      typedef itk::SmartPointer< Self >       Pointer;
      typedef itk::SmartPointer< const Self > ConstPointer;

    public:
      itkTypeMacro( ProcessObject, Object );
      cpPlugins_Id_Macro( ProcessObject, Object );

      itkBooleanMacro( ExplicitExecution );
      itkBooleanMacro( PrintExecution );

      itkGetStringMacro( Name );
      itkGetStringMacro( PluginName );
      itkGetConstMacro( ExplicitExecution, bool );
      itkGetConstMacro( LastExecutionSpan, long );
      itkGetConstMacro( PrintExecution, bool );

      itkSetStringMacro( Name );
      itkSetStringMacro( PluginName );
      itkSetMacro( ExplicitExecution, bool );
      itkSetMacro( PrintExecution, bool );
      itkSetObjectMacro( PrintExecutionStream, std::ofstream );

    public:
      Parameters* GetParameters( );
      const Parameters* GetParameters( ) const;

      virtual void SetITK( itk::LightObject* o ) final;
      virtual void SetVTK( vtkObjectBase* o ) final;

      // "Getters"
      std::set< std::string > GetInputsNames( ) const;
      std::set< std::string > GetOutputsNames( ) const;

      unsigned int GetNumberOfInputs( ) const;
      unsigned int GetNumberOfOutputs( ) const;
      unsigned int GetInputSize( const std::string& n ) const;

      template< class _TType = DataObject >
        _TType* GetInput( const std::string& n, unsigned int i = 0 );

      template< class _TType = DataObject >
        const _TType* GetInput(
          const std::string& n, unsigned int i = 0
          ) const;

      template< class _TType = itk::LightObject >
        _TType* GetInputData( const std::string& n, unsigned int i = 0 );

      template< class _TType = itk::LightObject >
        const _TType* GetInputData(
          const std::string& n, unsigned int i = 0
          ) const;

      template< class _TType = DataObject >
        _TType* GetOutput( const std::string& n );

      template< class _TType = DataObject >
        const _TType* GetOutput( const std::string& n ) const;

      template< class _TType = itk::LightObject >
        _TType* GetOutputData( const std::string& n );

      template< class _TType = itk::LightObject >
        const _TType* GetOutputData( const std::string& n ) const;

      // "Setters"
      virtual void AddInput( const std::string& n, DataObject* o );
      virtual void SetInput( const std::string& n, DataObject* o );

      // Other interesting methods
      void DisconnectInputs( );
      void DisconnectOutputs( );
      void Disconnect( );

      // Pipeline execution
      virtual void Modified( ) const cpPlugins_OVERRIDE;
      virtual itk::ModifiedTimeType GetMTime( ) const cpPlugins_OVERRIDE;
      virtual void Update( );

      // Qt dialog creation
      virtual QDialog* CreateQDialog( );
      virtual void AddInteractor( vtkRenderWindowInteractor* i );
      virtual bool IsInteractive( );

    protected:
      ProcessObject( );
      virtual ~ProcessObject( );

      // Error handling method
      void _Error( const std::string& error );

      // For configuration purposes
      template< class _TType = DataObject >
        void _ConfigureInput(
          const std::string& name, bool required, bool multiple
          );

      template< class _TType = DataObject >
        void _ConfigureOutput( const std::string& name );

      template< class _TFilter >
        _TFilter* _CreateITK( );

      template< class _TFilter >
        _TFilter* _CreateVTK( );

      virtual void _GenerateData( ) = 0;

    private:
      // Purposely not implemented
      ProcessObject( const Self& );
      Self& operator=( const Self& );

    protected:
      Parameters m_Parameters;
      std::string m_Name;
      std::string m_PluginName;
      bool m_ExplicitExecution;

      std::map< std::string, Port* > m_Inputs;
      std::map< std::string, Port* > m_Outputs;

      itk::ModifiedTimeType m_LastExecutionTime;
      mutable long m_LastExecutionSpan;

      bool m_PrintExecution;
      std::ostream* m_PrintExecutionStream;

      typedef vtkSmartPointer< vtkRenderWindowInteractor > _TInteractor;
      struct _TInteractorCmp
      {
        bool operator()(
          const _TInteractor& a, const _TInteractor& b
          ) const
          { return( a.GetPointer( ) < b.GetPointer( ) ); }
      };
      std::set< _TInteractor, _TInteractorCmp > m_Interactors;
    };

  } // ecapseman

} // ecapseman

#include <cpPlugins/BaseObjects/ProcessObject.hxx>

#endif // __cpPlugins__BaseObjects__ProcessObject__h__

// eof - $RCSfile$