#ifndef __fpa__Base__Algorithm__h__
#define __fpa__Base__Algorithm__h__

#include <vector>
#include <itkFunctionBase.h>
#include <fpa/Config.h>
#include <fpa/Base/Events.h>

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

      typedef _TVertex      TVertex;
      typedef _TOutput      TOutput;
      typedef unsigned long TFrontId;

      // Different functions
      typedef std::vector< TVertex >                      TNeighborhood;
      typedef itk::FunctionBase< TVertex, TNeighborhood > TNeighborhoodFunction;

      // Minigraph to represent collisions
      typedef std::pair< _TVertex, bool >   TCollision;
      typedef std::vector< TCollision >     TCollisionsRow;
      typedef std::vector< TCollisionsRow > TCollisions;

    protected:
      struct _TQueueNode
      {
        TVertex  Vertex;
        TVertex  Parent;
        TOutput  Result;
        TFrontId FrontId;
        _TQueueNode( );
        _TQueueNode( const TVertex& v );
        _TQueueNode( const TVertex& v, const _TQueueNode& n );
      };

    public:
      itkTypeMacro( Self, _TFilter );

      fpa_Base_NewEvent( TStartEvent );
      fpa_Base_NewEvent( TEndEvent );
      fpa_Base_NewEvent( TStartLoopEvent );
      fpa_Base_NewEvent( TEndLoopEvent );
      fpa_Base_NewEventWithVertex( TPushEvent, TVertex );
      fpa_Base_NewEventWithVertex( TPopEvent, TVertex );
      fpa_Base_NewEventWithVertex( TMarkEvent, TVertex );

      itkGetConstMacro( InitResult, _TOutput );
      itkSetMacro( InitResult, _TOutput );

      itkBooleanMacro( StopAtOneFront );
      itkGetConstMacro( StopAtOneFront, bool );
      itkSetMacro( StopAtOneFront, bool );

      itkGetObjectMacro( NeighborhoodFunction, TNeighborhoodFunction );
      itkSetObjectMacro( NeighborhoodFunction, TNeighborhoodFunction );

    public:
      void AddSeed( const TVertex& seed, const TOutput& value );

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

      virtual void GenerateData( ) fpa_OVERRIDE;

      // Particular methods
      virtual void _Loop( );

      virtual void _BeforeGenerateData( );
      virtual void _AfterGenerateData( );
      virtual void _BeforeLoop( );
      virtual void _AfterLoop( );

      virtual bool _ValidLoop( ) const;
      virtual void _UpdateCollisions( const TVertex& a, const TVertex& b );

      virtual void _InitMarks( ) = 0;
      virtual void _InitResults( const TOutput& init_value ) = 0;
      virtual bool _IsMarked( const _TVertex& v ) const = 0;
      virtual void _Mark( const _TQueueNode& n ) = 0;
      virtual TFrontId _GetMark( const _TVertex& v ) const = 0;
      virtual void _UpdateResult( const _TQueueNode& n ) = 0;

      virtual bool _UpdateValue( _TQueueNode& v, const _TQueueNode& p ) = 0;
      virtual unsigned long _QueueSize( ) const = 0;
      virtual void _QueueClear( ) = 0;
      virtual void _QueuePush( const _TQueueNode& node ) = 0;
      virtual _TQueueNode _QueuePop( ) = 0;

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

    protected:
      _TOutput m_InitResult;
      bool m_StopAtOneFront;
      typename TNeighborhoodFunction::Pointer m_NeighborhoodFunction;
      std::vector< _TQueueNode > m_Seeds;
      TCollisions m_Collisions;
      unsigned int m_NumberOfFronts;
    };

  } // ecaseman

} // ecaseman

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

#endif // __fpa__Base__Algorithm__h__

// eof - $RCSfile$