// =========================================================================
// @author Leonardo Florez Valencia
// @email florez-l@javeriana.edu.co
// =========================================================================

#ifndef __fpa__Base__Algorithm__h__
#define __fpa__Base__Algorithm__h__

#include <fpa/Config.h>

#include <vector>
#include <itkObject.h>
#include <itkEventObject.h>

namespace fpa
{
  namespace Base
  {
    /**
     */
    template< class _TFilter, class _TMarksInterface, class _TSeedsInterface >
    class Algorithm
      : public _TFilter,
        public _TMarksInterface,
        public _TSeedsInterface
    {
    public:
      typedef Algorithm                       Self;
      typedef _TFilter                        Superclass;
      typedef _TMarksInterface                TMarksInterface;
      typedef _TSeedsInterface                TSeedsInterface;
      typedef itk::SmartPointer< Self >       Pointer;
      typedef itk::SmartPointer< const Self > ConstPointer;

      typedef typename _TSeedsInterface::TInputValue  TInputValue;
      typedef typename _TSeedsInterface::TOutputValue TOutputValue;
      typedef typename _TSeedsInterface::TNode        TNode;
      typedef typename _TSeedsInterface::TNodes       TNodes;
      typedef typename _TSeedsInterface::TSeeds       TSeeds;
      typedef typename _TSeedsInterface::TVertex      TVertex;

      typedef std::vector< TVertex > TNeighborhood;

      /**
       */
      class TEvent
        : public itk::EventObject
      {
      public:
        typedef TEvent           Self;
        typedef itk::EventObject Superclass;

      public:
        TEvent( );
        TEvent( const TVertex& v, unsigned long fid, bool intoq );
        virtual ~TEvent( );
        virtual const char* GetEventName( ) const override;
        virtual bool CheckEvent( const itk::EventObject* e ) const override;
        virtual itk::EventObject* MakeObject( ) const override;

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

      public:
        TVertex       Vertex;
        unsigned long FrontId;
        bool          IntoQueue;
      };

    public:
      itkTypeMacro( fpa::Base::Algorithm, _TFilter );

      itkBooleanMacro( VisualDebug );

      itkGetConstMacro( InitValue, TOutputValue );
      itkGetConstMacro( VisualDebug, bool );

      itkSetMacro( InitValue, TOutputValue );
      itkSetMacro( VisualDebug, bool );

    public:
      virtual void InvokeEvent( const itk::EventObject& e );
      virtual void InvokeEvent( const itk::EventObject& e ) const;

    protected:
      Algorithm( );
      virtual ~Algorithm( );

      virtual void GenerateData( ) override;
      virtual void _BeforeGenerateData( );
      virtual void _AfterGenerateData( );

      virtual void _QueueInit( );

      virtual void _ConfigureOutput( const TOutputValue& v ) = 0;
      virtual TNeighborhood _GetNeighbors( const TVertex& v ) const = 0;
      virtual TInputValue _GetInputValue( const TVertex& v ) const = 0;
      virtual TOutputValue _GetOutputValue( const TVertex& v ) const = 0;

      virtual TOutputValue _ComputeOutputValue( const TNode& n ) = 0;
      virtual void _UpdateOutputValue( const TNode& n ) = 0;
      virtual void _QueueClear( ) = 0;
      virtual void _QueuePush( const TNode& node ) = 0;
      virtual unsigned long _QueueSize( ) const = 0;
      virtual TNode _QueuePop( ) = 0;

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

    protected:
      bool m_VisualDebug;
      TOutputValue m_InitValue;
    };

  } // ecapseman

} // ecapseman

#ifndef ITK_MANUAL_INSTANTIATION
#  include <fpa/Base/Algorithm.hxx>
#endif // ITK_MANUAL_INSTANTIATION

#endif // __fpa__Base__Algorithm__h__

// eof - $RCSfile$