#ifndef T_RASTER_INCLUDED
#define T_RASTER_INCLUDED

#include "tutil.h"
#include "tgeometry.h"
#include "tpixel.h"
#include "tpixelgr.h"
#include "tsmartpointer.h"
#include "tbigmemorymanager.h"

#undef DVAPI
#undef DVVAR
#ifdef TRASTER_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif

//=========================================================

class DVAPI TRasterType
{
	int m_id;

	/*
public:
	enum Type {
		None,
		BW,
		WB,
		RGBM32,  // LPIXEL, matte channel considered
		RGBM64,  // SPIXEL, matte channel considered 
		CM8,     // color-mapped,  8 bits 
		GR8,     // grey tones, 8 bits 
		CM16,    // color-mapped, 16 bits 
		GR16,    // grey tones, 16 bits 
		RGB555,
		RGB565,
		CM24,    // cmapped, 8+8+8 bits (ink, paint, ramp), +8 bits spare (MSB)
		CM16S12,
		CM16S8   // cmapped, 16 bits, standard SGI 256-color colormap
		// ....
	};
*/

public:
	TRasterType(int id) : m_id(id){};
	int getId() const { return m_id; };
	bool operator==(TRasterType a) { return m_id == a.m_id; };
	bool operator!=(TRasterType a) { return m_id != a.m_id; };
};

//=========================================================

// forward declaration
template <class T>
class TRasterPT;
class TRaster;
typedef TSmartPointerT<TRaster> TRasterP;

//=========================================================
/*!This class stores bitmap images. */
class DVAPI TRaster : public TSmartObject
{

	DECLARE_CLASS_CODE

protected:
	int m_pixelSize;
	int m_lx, m_ly;
	int m_wrap;
	int m_lockCount;
	TRaster *m_parent; // nel caso di sotto-raster
	UCHAR *m_buffer;
	bool m_bufferOwner;
	// i costruttori sono qui per centralizzare la gestione della memoria
	// e' comunque impossibile fare new TRaster perche' e' una classe astratta (clone, extract)

	// crea il buffer associato (NON fa addRef())
	TRaster(int lx, int ly, int pixelSize);

	// si attacca ad un buffer pre-esistente (NON fa addRef() - neanche a parent)
	TRaster(int lx, int ly, int pixelSize,
			int wrap, UCHAR *buffer, TRaster *parent, bool bufferOwner = false);

private:
	static TAtomicVar m_totalMemory;
	TThread::Mutex m_mutex;
	// not implemented
	TRaster(const TRaster &);
	TRaster &operator=(const TRaster &);

public:
#ifdef _DEBUG
	bool m_cashed;
	static unsigned long getTotalMemoryInKB();
#endif

	virtual ~TRaster();

	// accessors
	// TRasterType getType() const {return m_type;};
	int getLx() const { return m_lx; };
	int getLy() const { return m_ly; };
	TDimension getSize() const { return TDimension(m_lx, m_ly); };

	//!Returns the length of a row in pixel.
	int getWrap() const { return m_wrap; }; // lunghezza di una riga in pixel

	TPointD getCenterD() const { return TPointD(0.5 * m_lx, 0.5 * m_ly); };
	TPoint getCenter() const { return TPoint(m_lx / 2, m_ly / 2); };
	TRect getBounds() const { return TRect(0, 0, m_lx - 1, m_ly - 1); };
	int getPixelSize() const { return m_pixelSize; };

	int getRowSize() const { return m_pixelSize * m_lx; };
	// in bytes

	//when the bigMemoryManager is active, remapping can change buffers...need to to lock/unlock them o use them.

	void lock()
	{
		if (!TBigMemoryManager::instance()->isActive())
			return;
		TThread::MutexLocker sl(&m_mutex);
		if (m_parent)
			m_parent->lock();
		else
			++m_lockCount;
	}
	void unlock()
	{
		if (!TBigMemoryManager::instance()->isActive())
			return;
		TThread::MutexLocker sl(&m_mutex);
		if (m_parent)
			m_parent->unlock();
		else {
			assert(m_lockCount > 0);
			--m_lockCount;
		}
	}
	void beginRemapping();
	void endRemapping();
	//!Returns a pointer to the image buffer.
	//WARNING!!!!! before getting the buffer with getRawData(),
	//you have to lock the raster with'lock method, and unlock
	//it when you've done with the buffer
	const UCHAR *getRawData() const { return m_buffer; };

	UCHAR *getRawData() { return m_buffer; };
	//!Returns a pointer to the image buffer positioned in the (x,y) coords.
	const UCHAR *getRawData(int x, int y) const
	{
		assert(0 <= x && x < m_lx && 0 <= y && y < m_ly);
		return m_buffer + (y * m_wrap + x) * m_pixelSize;
	};
	UCHAR *getRawData(int x, int y)
	{
		assert(0 <= x && x < m_lx && 0 <= y && y < m_ly);
		return m_buffer + (y * m_wrap + x) * m_pixelSize;
	};
	bool isEmpty() const { return getSize() == TDimension(); };

	TRasterP getParent() { return m_parent; }
	// creazione di TRaster derivati

	// devono essere virtuali puri perche' il nuovo raster creato deve essere del tipo giusto
	virtual TRasterP clone() const = 0;
	virtual TRasterP extract(TRect &rect) = 0;
	virtual TRasterP create() const = 0;
	virtual TRasterP create(int lx, int ly) const = 0;

	// definita in termini di extract(rect); non lo posso fare subito perche' manca il
	// costruttore di copia di TRasterP
	inline virtual TRasterP extract(int x0, int y0, int x1, int y1);

	// operazioni sui pixel

	// Copia il contenuto di src (spostato di offset) nel raster corrente.
	// Il tipo deve essere lo stesso
	// In caso di dimensione diversa l'area copiata e' l'intersezione dei due getBounds()
	// e i due raster sono allineati in basso a sinistra (src[0,0] -> dst[offset])
	/*!Copies the content of the source raster in the current raster.
     */
	void copy(const TRasterP &src, const TPoint &offset = TPoint());

	void xMirror();
	void yMirror();
	void rotate180();
	void rotate90();

	void clear();
	void clearOutside(const TRect &rect);

	friend class TBigMemoryManager;

protected:
	void fillRawData(const UCHAR *pixel);
	void fillRawDataOutside(const TRect &rect, const UCHAR *pixel);

private:
	void remap(UCHAR *newLocation);
};

//------------------------------------------------------------

//
// Smart Pointer a TRaster
//

#ifdef WIN32
template class DVAPI TSmartPointerT<TRaster>;
#endif

//------------------------------------------------------------

inline void detach(TRasterP &r)
{
	if (!r || r->getRefCount() == 1)
		return;
	TRasterP tmp(r->clone());
	r = tmp;
}

//=========================================================

// forward declaration
template <class T>
class TRasterT;

//
// TRasterPT<Pixel>:
//
// Smart Pointer to TRasterT<Pixel>
//

//!\include raster_ex1.cpp
//! \include rasterpt_ex1.cpp
// class TRasterPT<T>
template <class T>
class TRasterPT : public TSmartPointerT<TRasterT<T>>
{

public:
	typedef T Pixel;
	typedef TRasterT<T> Raster;

	TRasterPT(){};

	TRasterPT(int lx, int ly) { create(lx, ly); };
	TRasterPT(const TDimension &d) { create(d.lx, d.ly); };

	inline TRasterPT(const TRasterP &src);
	inline TRasterPT(int lx, int ly, int wrap, T *buffer, bool bufferOwner = false);

	~TRasterPT(){};

	void create(int lx, int ly);
	void create(const TDimension &d) { create(d.lx, d.ly); };

	inline void detach();

	operator TRasterP() const;
};

//=========================================================

//
// TRasterT<Pixel>
//
// e' la classe concreta che discende da TRaster

template <class T>
class TRasterT : public TRaster
{
protected:
	// Constructors are protected to prevent direct allocation of TRasterT instances.
	// Users must adopt the TRasterPT smart pointer syntax instead.

	// Buffer Allocation
	TRasterT(int lx, int ly) : TRaster(lx, ly, sizeof(T)) {}

	// Buffer Attachment
	TRasterT(int lx, int ly, int wrap, T *buffer, TRasterT<T> *parent, bool bufferOwner = false)
		: TRaster(lx, ly, sizeof(T), wrap, reinterpret_cast<UCHAR *>(buffer), parent, bufferOwner) {}

public:
	typedef T Pixel;

	~TRasterT(){};

	// accessors
	//WARNING!!!!! before getting the buffer with pixels(int y),
	//you have to lock the raster with'lock method, and unlock
	//it when you've done with the buffer

	const T *pixels(int y = 0) const
	{
		assert(0 <= y && y < getLy());
		return reinterpret_cast<T *>(m_buffer) + getWrap() * y;
	};
	T *pixels(int y = 0)
	{
		assert(0 <= y && y < getLy());
		return reinterpret_cast<T *>(m_buffer) + getWrap() * y;
	};

	// Derived rasters creation

	TRasterP clone() const
	{
		TRasterP dst = TRasterPT<T>(m_lx, m_ly);
		TRasterP src(const_cast<TRaster *>((const TRaster *)this));
		dst->copy(src);
		return dst;
	}

	TRasterP create() const
	{
		return TRasterPT<T>(m_lx, m_ly);
	}

	virtual TRasterP create(int lx, int ly) const
	{
		return TRasterPT<T>(lx, ly);
	}

	//!\include raster_ex2.cpp
	TRasterP extract(int x0, int y0, int x1, int y1)
	{
		TRect rect(x0, y0, x1, y1);
		return extract(rect);
	};

	TRasterP extract(TRect &rect)
	{
		if (isEmpty() || getBounds().overlaps(rect) == false)
			return TRasterP();
		rect = getBounds() * rect;
		//addRef();
		return TRasterP(
			new TRasterT<T>(rect.getLx(), rect.getLy(), m_wrap,
							pixels(rect.y0) + rect.x0, this));
	};

	TRasterPT<T> extractT(TRect &rect);

	TRasterPT<T> extractT(int x0, int y0, int x1, int y1)
	{
		TRect rect(x0, y0, x1, y1);
		return extractT(rect);
	};

	friend class TRasterPT<T>;

	// Pixel Operations
	void fill(const T &a)
	{
		fillRawData(reinterpret_cast<const UCHAR *>(&a));
	}

	void fillOutside(const TRect &rect, const T &a)
	{
		fillRawDataOutside(rect, reinterpret_cast<const UCHAR *>(&a));
	}
};

//---------------------------------------------------------

inline TRasterP TRaster::extract(int x0, int y0, int x1, int y1)
{
	TRect rect(x0, y0, x1, y1);
	return extract(rect);
}

//---------------------------------------------------------

template <class T>
TRasterPT<T> TRasterT<T>::extractT(TRect &rect)
{
	if (isEmpty() || getBounds().overlaps(rect) == false) {
		return TRasterPT<T>();
	}
	rect = getBounds() * rect;
	//addRef();
	return TRasterPT<T>(
		new TRasterT<T>(rect.getLx(), rect.getLy(), m_wrap,
						pixels(rect.y0) + rect.x0, this));
}

//=========================================================
//
// metodi inline di TRasterPT
// (n.b. se non si fanno esplicitament "inline" NT si confonde con dll exort/import)
//

template <class T>
inline TRasterPT<T>::TRasterPT(const TRasterP &src)
{
	TSmartPointerT<TRasterT<T>>::m_pointer = dynamic_cast<TRasterT<T> *>(src.getPointer());
	if (TSmartPointerT<TRasterT<T>>::m_pointer)
		TSmartPointerT<TRasterT<T>>::m_pointer->addRef();
}

template <class T>
inline void TRasterPT<T>::create(int lx, int ly)
{
	TRasterT<T> *raster = new TRasterT<T>(lx, ly);
	*this = TRasterPT<T>(raster);
}

template <class T>
inline void TRasterPT<T>::detach()
{
	if (!TSmartPointerT<TRasterT<T>>::m_pointer || TSmartPointerT<TRasterT<T>>::m_pointer->getRefCount() == 1)
		return;
	*this = TRasterPT(TSmartPointerT<TRasterT<T>>::m_pointer->clone());
	// uso l'operator di assign per aggiornare correttamente
	// i reference counts del vecchio e del nuovo raster
}

template <class T>
inline TRasterPT<T>::operator TRasterP() const
{
	return TRasterP(TSmartPointerT<TRasterT<T>>::m_pointer);
}

//---------------------------------------------------------

template <class T>
inline TRasterPT<T>::TRasterPT(int lx, int ly, int wrap, T *buffer, bool bufferOwner)
{
	TSmartPointerT<TRasterT<T>>::m_pointer = new TRasterT<T>(lx, ly, wrap, buffer, 0, bufferOwner);
	TSmartPointerT<TRasterT<T>>::m_pointer->addRef();
}

//---------------------------------------------------------

#ifdef WIN32
// su NT e' necessario per evitare un warning nelle classi
// esportate che si riferiscono a TRaster32P/TRaster64P
// su IRIX non compila perche' non riesce ad instanziare le
// funzioni online (!!!)

template class DVAPI TSmartPointerT<TRasterT<TPixel32>>;
template class DVAPI TRasterPT<TPixel32>;

template class DVAPI TSmartPointerT<TRasterT<TPixel64>>;
template class DVAPI TRasterPT<TPixel64>;

template class DVAPI TSmartPointerT<TRasterT<TPixelGR8>>;
template class DVAPI TRasterPT<TPixelGR8>;

template class DVAPI TSmartPointerT<TRasterT<TPixelGR16>>;
template class DVAPI TRasterPT<TPixelGR16>;

template class DVAPI TSmartPointerT<TRasterT<TPixelGRD>>;
template class DVAPI TRasterPT<TPixelGRD>;

template class DVAPI TSmartPointerT<TRasterT<TPixelCY>>;
template class DVAPI TRasterPT<TPixelCY>;

#endif

typedef TRasterPT<TPixel32> TRaster32P;
typedef TRasterPT<TPixel64> TRaster64P;
typedef TRasterPT<TPixelGR8> TRasterGR8P;
typedef TRasterPT<TPixelGR16> TRasterGR16P;
typedef TRasterPT<TPixelGRD> TRasterGRDP;
typedef TRasterPT<TPixelCY> TRasterYUV422P;

//=========================================================

//=========================================================

#endif //__T_RASTER_INCLUDED