#include <functional>
#include <cassert>
#include <boost/shared_ptr.hpp>
#include <boost/shared_array.hpp>

namespace yoffy { namespace dynamic_image {
	using boost::shared_ptr;
	using boost::shared_array;

	class image_t
	{
	  public:
		typedef image_t      self;
		typedef uint_gen32_t size_type;
		
		struct reference
		{
			image_t &       m_image;
			const size_type m_pos;
			
			reference( image_t & img, size_type n ) : m_image( img ), m_pos( n ) {}
			operator =( float_t value ) { m_image.at( m_pos, value ); }
			operator float_t() { return m_image.at( m_pos ); }
		};
		
	  protected:
		size_type m_size;
		
	  public:
		image_t( size_type size ) : m_size( size ) {}
		virtual ~image_t() {};
		virtual image_t * create( size_type size, bool isclear = true ) const = 0;
		virtual float_t at( size_type n ) const = 0;
		virtual float_t at( size_type n, float_t value ) = 0;
		
		size_type size() const { return m_size; }
		float_t operator[]( size_type n ) const
		{ return at( n ); }
		reference operator[]( size_type n )
		{ return reference( *this, n ); }
		self & operator =( const image_t & src )
		{
			for ( size_type i = 0; i < m_size; i++ )
				at( i, src[ i ] );
			return *this;
		}
	};

	template<typename T = float>
	class image : public image_t
	{
	  public:
		typedef image_t                   super;
		typedef image<T>                  self;
		typedef typename super::size_type size_type;
		typedef T                         value_type;
		typedef shared_array<value_type>  gc_type;
		
	  protected:
		gc_type      m_collector;
		value_type * m_image;
		
	  public:
		image( size_type size, bool isclear = true )
			: super( size )
			, m_collector( new value_type[m_size] )
			, m_image( m_collector.get() )
		{ if ( isclear ) memset( m_image, 0, sizeof(value_type) * m_size ); }

		image( gc_type & ptr, size_type size )
			: super( size )
			, m_collector( ptr )
			, m_image( m_collector.get() )
		{}
		
		image( value_type * ptr, size_type size )
			: super( size )
			, m_collector( NULL )
			, m_image( ptr )
		{}

		~image() { super::~image_t(); }
		
		image_t * create( size_type size, bool isclear = true ) const
		{ return new self( size, isclear ); }
		
		gc_type get_gc() { return m_collector; }
		
		value_type * begin() { return m_image; }
		const value_type * begin() const { return m_image; }
		value_type * end() { return m_image + m_size; }
		const value_type * end() const { return m_image + m_size; }
		
		float_t at( size_type n ) const
		{ assert( n < m_size ); return float_t(m_image[n]); }
		
		float_t at( size_type n, float_t value )
		{ assert( n < m_size ); m_image[n] = value_type(value); return value; }

		self & operator =( const image_t & src )
		{ super::operator=( src ); return *this; }
	};

	template<class T1, class T2, class OP>
	struct operator_t : public image_t
	{
		typedef image_t                   super;
		typedef operator_t<T1, T2, OP>    self;
		typedef typename super::size_type size_type;
		
		const T1 & m_src1;
		const T2 & m_src2;
		const OP & m_op;

		operator_t() {}
		operator_t( const T1 & src1, const T2 & src2, const OP & op )
		: super( src1.size() ), m_src1( src1 ), m_src2( src2 ), m_op( op ) {}
		~operator_t() { super::~image_t(); }
		image_t * create( size_type size, bool isclear = true ) const
		{ assert( false ); throw; }
		float_t at( size_type n ) const { return m_op( m_src1[n], m_src2[n] ); }
		float_t at( size_type n, float_t value ) { assert( false ); throw; }
	};

	operator_t< image_t, image_t, std::plus<float_t> >
	operator+( const image_t & src1, const image_t & src2 )
	{ return operator_t< image_t, image_t, std::plus<float_t> >( src1, src2, std::plus<float_t>() ); }

	operator_t< image_t, image_t, std::minus<float_t> >
	operator-( const image_t & src1, const image_t & src2 )
	{ return operator_t< image_t, image_t, std::minus<float_t> >( src1, src2, std::minus<float_t>() ); }

	operator_t< image_t, image_t, std::multiplies<float_t> >
	operator*( const image_t & src1, const image_t & src2 )
	{ return operator_t< image_t, image_t, std::multiplies<float_t> >( src1, src2, std::multiplies<float_t>() ); }

	operator_t< image_t, image_t, std::divides<float_t> >
	operator/( const image_t & src1, const image_t & src2 )
	{ return operator_t< image_t, image_t, std::divides<float_t> >( src1, src2, std::divides<float_t>() ); }
} /* namespace dynamic_image */ } /* namespace yoffy */