#pragma once

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

// tregion.h: interface for the TRegion class.

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

#if !defined(TREGION_H)

#define TREGION_H

#include <memory></memory>

#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 final : 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>;</tedge>

#endif

typedef TSmartPointerT<tedge> TEdgeP;</tedge>

*/

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

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

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

class DVAPI TRegion {

  class Imp;

  std::unique_ptr<imp> m_imp;</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);</tregion*>

  void computeScanlineIntersections(double y,

                                    std::vector<double> &intersections) const;</double>

  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

  {

          int styleId = getEdge(i)->getStyle();

      if(styleId != 0 && ret==0)

                          {

                                //assert(styleId<100);

                                ret =  styleId;

                                if (i>0) for (j=0;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

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