//-----------------------------------------------------------------------------
// tregion.h: interface for the TRegion class.
//-----------------------------------------------------------------------------
#if !defined(TREGION_H)
#define TREGION_H

#include <memory>

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "tgeometry.h"
//#include "tsmartpointer.h"

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

//=============================================================================
//forward declarations

class TStroke;
//class  TVectorRenderData;
class TRegion;
class TRegionProp;
//class TVectorPalette;

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

class TRegionId
{
public:
	int m_strokeId;
	float m_midW;
	bool m_direction;

	TRegionId(int strokeId, float midW, bool direction)
		: m_strokeId(strokeId), m_midW(midW), m_direction(direction)
	{
	}
};

class TFilledRegionInf
{
public:
	TRegionId m_regionId;
	int m_styleId;

	TFilledRegionInf(int strokeId, float midW, bool direction, int styleId)
		: m_regionId(strokeId, midW, direction), m_styleId(styleId)
	{
	}

	TFilledRegionInf(TRegionId regionId, int styleId)
		: m_regionId(regionId), m_styleId(styleId)
	{
	}
};

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

class TGeneralEdge
{
public:
	enum Type {
		eNormal,
		eAutoclose
	};

	Type m_type;

	TGeneralEdge(Type type) : m_type(type) {}
};

class TEdge : public TGeneralEdge
{

public:
	TStroke *m_s;
	double m_w0, m_w1;
	int m_index;
	TRegion *m_r;
	int m_styleId;
	bool m_toBeDeleted;
	//bool m_forward;
public:
	TEdge()
		: TGeneralEdge(eNormal), m_s(0), m_w0(-1), m_w1(-1), m_index(-1), m_r(0), m_styleId(0), m_toBeDeleted(false)
	//, m_forward(true)
	{
	}

	TEdge(TStroke *ref, UINT index, double w0, double w1, bool toBeDeletedWithStroke, int styleId)
		: TGeneralEdge(eNormal), m_s(ref), m_w0(w0), m_w1(w1), m_index(index), m_r(0), m_styleId(styleId), m_toBeDeleted(toBeDeletedWithStroke)
	//, m_forward(forward)
	{
	}

	/* TEdge(TStroke* ref, bool toBeDeletedWithStroke)
      : m_s (ref)
      , m_w0  (-1)
      , m_w1  (-1) 
      , m_r(0)
      , m_styleId(0) 
			, m_toBeDeleted(toBeDeletedWithStroke)
      {}*/

	TEdge(const TEdge &e, bool toBeDeletedWithStroke)
		: TGeneralEdge(eNormal), m_s(e.m_s), m_w0(e.m_w0), m_w1(e.m_w1), m_index(e.m_index), m_r(e.m_r), m_styleId(e.m_styleId), m_toBeDeleted(toBeDeletedWithStroke)
	//, m_forward(e.m_forward)
	{
	}

	TEdge &operator=(const TEdge &e)
	{
		m_s = e.m_s;
		m_w0 = e.m_w0;
		m_w1 = e.m_w1;
		m_index = e.m_index;
		m_r = e.m_r;
		m_styleId = e.m_styleId;
		m_toBeDeleted = e.m_toBeDeleted;
		//m_forward = e.m_forward;
		return *this;
	}
	TEdge(const TEdge &e) : TGeneralEdge(eNormal), m_s(e.m_s), m_w0(e.m_w0), m_w1(e.m_w1), m_index(e.m_index), m_r(e.m_r), m_styleId(e.m_styleId), m_toBeDeleted(e.m_toBeDeleted) /*, m_forward(e.m_forward)*/ {}

	bool operator<(const TEdge &e) const
	{
		return (e.m_s == m_s) ? ((e.m_w0 == m_w0) ? e.m_w1 < m_w1 : e.m_w0 < m_w0) : e.m_s < m_s;
	}

	inline int getStyle() const { return m_styleId; }
	inline void setStyle(int styleId) { m_styleId = styleId; }

	inline bool operator==(const TEdge &b) const
	{
		return m_s == b.m_s && ((m_w0 == b.m_w0 && m_w1 == b.m_w1) || (m_w0 == b.m_w1 && m_w1 == b.m_w0));
	}

private:
	TEdge(TStroke *ref);
};

/*
#ifdef _WIN32
template class DVAPI TSmartPointerT<TEdge>; 
#endif

typedef TSmartPointerT<TEdge> TEdgeP;
*/
//-----------------------------------------------------------------------------

//void addRegion(vector<TRegion*>& regionArray, TRegion *region);

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

class DVAPI TRegion
{
	class Imp;
	std::unique_ptr<Imp> m_imp;

public:
	TRegion();
	~TRegion();

	TRectD getBBox() const;

	bool contains(const TPointD &p) const;
	bool contains(const TRegion &r) const;
	bool contains(const TStroke &s, bool mayIntersect = false) const;
	bool contains(const TEdge &e) const;

	//! returns the region equivalent to r, 0 if does not exists.
	TRegion *findRegion(const TRegion &r) const;
	TRegion *getSubregion(UINT index) const;
	UINT getSubregionCount() const;
	void deleteSubregion(UINT index);
	void addSubregion(TRegion *region);
	TEdge *getEdge(UINT index) const;
	TEdge *getLastEdge() const;
	UINT getEdgeCount() const;
	void addEdge(TEdge *e, bool minimizeEdges);
	TEdge *popFrontEdge();
	TEdge *popBackEdge();

	void moveSubregionsTo(TRegion *r);
	//it returns the  style of the region before filling or -1 if not filled.
	int fill(const TPointD &p, int styleId);

	bool selectFill(const TRectD &selectArea, int styleId);

	//! returns the smallest subregions (including this) containing p
	TRegion *getRegion(const TPointD &p);

	int getStyle() const;

	void setStyle(int styleId);

	void autoFill(int styleId, bool oddLevel);

	bool isSubRegionOf(const TRegion &r) const;
	bool getInternalPoint(TPointD &p);

	TRegionProp *getProp();
	void setProp(TRegionProp *prop);

	TRegionId getId();

	void invalidateProp();

	void invalidateBBox();

	void print();

	//friend void addRegion(vector<TRegion*>& regionArray, TRegion *region);
	void computeScanlineIntersections(double y, std::vector<double> &intersections) const;

	int scanlineIntersectionsBefore(double x, double y, bool horiz) const;
	int leftScanlineIntersections(double x, double y) const
	{
		return scanlineIntersectionsBefore(x, y, true);
	}

#ifdef _DEBUG
	void checkRegion();
#endif
};

//-----------------------------------------------------------------------------
/*Spostata in tregion.cpp
inline int TRegion::getStyle() const
{
int ret = 0;
  UINT i=0, j, n=getEdgeCount();
  for (; i<n; i++)
  {
	  int styleId = getEdge(i)->getStyle();
      if(styleId != 0 && ret==0) 
			  {
				//assert(styleId<100);
				ret =  styleId;
				if (i>0) for (j=0;j<i;j++) getEdge(i)->setStyle(ret);
				}
			else if (styleId!=ret)
			  getEdge(i)->setStyle(ret);
  }
  return ret;
}
*/

class DVAPI TRegionFeatureFormula
{
public:
	virtual void update(const TPointD &p1, const TPointD &p2) = 0;
};

//permette di calcolare varie grandesse sul poligono della regione,
//come l'area, il baricentro, il perimetro...
//per usarla si deve sottoclassare la classe virtuale TRegionFeatureFormula
//specificando la formual della grandezza da calcolare.

void DVAPI computeRegionFeature(const TRegion &r, TRegionFeatureFormula &formula);

#endif // !defined(TREGION_H)
//-----------------------------------------------------------------------------
//  End Of File
//-----------------------------------------------------------------------------