#include "tregionprop.h"

#include "tstroke.h"

#include "tregion.h"

//#include "tcurves.h"

//#include "tgl.h"

//#include "tcolorfunctions.h"

#include "tmathutil.h"

#include "drawutil.h"

#include "tvectorrenderdata.h"

//#include "tcolorstyles.h"

#include "tsimplecolorstyles.h"

//#include "tcurveutil.h"

//#include "tdebugmessage.h"

//#include "tflash.h"

#ifndef _WIN32

#define CALLBACK

#endif

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

TRegionProp::TRegionProp(const TRegion *region)

    : m_region(region), m_regionChanged(true) {}

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

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

namespace {

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

bool computeOutline(const TRegion *region,

                    TRegionOutline::PointVector &polyline,

                    const double pixelSize) {

  bool doAntialiasing = false;

  polyline.clear();

  std::vector<tpointd> polyline2d;</tpointd>

  std::vector<int> indices;</int>

  int i, edgeSize = region->getEdgeCount(), oldSize = 0;

  for (i = 0; i < edgeSize; i++) {

    TEdge &edge = *region->getEdge(i);

    if (edge.m_index >= 0 && edge.m_s) {

      bool outline = (edge.m_s->getAverageThickness() == 0.0);

      if (outline && !doAntialiasing) {

        // The region must be antialiased if it has at least one invisible

        // (0-thin) edge

        doAntialiasing = true;

        // Plus, edges will have to be reproduced independently from the edge

        // side

        indices.reserve(edgeSize);

      }

      if (outline && (edge.m_w0 > edge.m_w1)) {

        int newSize = polyline2d.size();

        if (oldSize < newSize) {

          // There is a sequence of forward vertices

          indices.push_back(newSize - oldSize);

          oldSize = newSize;

        }

        stroke2polyline(polyline2d, *edge.m_s, pixelSize, edge.m_w1, edge.m_w0,

                        true);

        // Insert the sequence of backward vertices

        newSize = polyline2d.size();

        indices.push_back(oldSize - newSize);

        oldSize = newSize;

      } else

        stroke2polyline(polyline2d, *edge.m_s, pixelSize, edge.m_w0, edge.m_w1);

    }

  }

  // Copy points to the output

  int pointNumber = polyline2d.size();

  polyline.reserve(pointNumber);

  int j, k, l, indicesCount = indices.size();

  for (i = 0, k = 0; k < indicesCount; ++k) {

    l = indices[k];

    if (l == 0) continue;

    if (l > 0) {

      l = i + l;

      for (j = i; j < l; ++j) polyline.push_back(T3DPointD(polyline2d[j], 0.0));

      i      = l;

    } else {

      l = i - l;

      j = l - 1;

      // Inverted sequences are symmetric by construction.

      // If necessary, chop the last element.

      if (polyline2d[i] == polyline2d[j]) ++i;

      for (; j >= i; --j) polyline.push_back(T3DPointD(polyline2d[j], 0.0));

      i = l;

    }

  }

  // Finally, copy the remaining (forward) ones

  for (; i < pointNumber; ++i)

    polyline.push_back(T3DPointD(polyline2d[i], 0.0));

  return doAntialiasing;

}

/*!

 This function accept a polygon which can have autointersections,

 and creates a number of not-autointersecting polygons. the second function is

 for recursive calls.

 It is used for The GlTessellator

*/

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

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

}  // end namaspace

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

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

void OutlineRegionProp::computeRegionOutline() {

  int subRegionNumber = getRegion()->getSubregionCount();

  TRegionOutline::PointVector app;

  m_outline.m_exterior.clear();

  computeOutline(getRegion(), app, m_pixelSize);

  m_outline.m_doAntialiasing = true;

  m_outline.m_exterior.push_back(app);

  m_outline.m_interior.clear();

  m_outline.m_interior.reserve(subRegionNumber);

  for (int i = 0; i < subRegionNumber; i++) {

    app.clear();

    computeOutline(getRegion()->getSubregion(i), app, m_pixelSize);

    m_outline.m_doAntialiasing = true;

    m_outline.m_interior.push_back(app);

  }

  m_outline.m_bbox = getRegion()->getBBox();

}

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

OutlineRegionProp::OutlineRegionProp(const TRegion *region,

                                     const TOutlineStyleP colorStyle)

    : TRegionProp(region), m_pixelSize(0), m_colorStyle(colorStyle) {

  m_styleVersionNumber = m_colorStyle->getVersionNumber();

}

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

void OutlineRegionProp::draw(const TVectorRenderData &rd) {

  if (rd.m_clippingRect != TRect() && !rd.m_is3dView &&

      !(rd.m_aff * getRegion()->getBBox()).overlaps(convert(rd.m_clippingRect)))

    return;

  glPushMatrix();

  tglMultMatrix(rd.m_aff);

  double pixelSize = sqrt(tglGetPixelSize2());

  if (!isAlmostZero(pixelSize - m_pixelSize, 1e-5) || m_regionChanged ||

      m_styleVersionNumber != m_colorStyle->getVersionNumber()) {

    m_pixelSize     = pixelSize;

    m_regionChanged = false;

    computeRegionOutline();

    TOutlineStyle::RegionOutlineModifier *modifier =

        m_colorStyle->getRegionOutlineModifier();

    if (modifier) modifier->modify(m_outline);

    m_styleVersionNumber = m_colorStyle->getVersionNumber();

  }

  assert(!m_outline.m_exterior.empty());

  m_colorStyle->drawRegion(rd.m_cf, rd.m_antiAliasing && rd.m_regionAntialias,

                           m_outline);

  glPopMatrix();

}

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

TRegionProp *OutlineRegionProp::clone(const TRegion *region) const {

  OutlineRegionProp *prop = new OutlineRegionProp(region, m_colorStyle);

  prop->m_regionChanged   = m_regionChanged;

  prop->m_pixelSize       = m_pixelSize;

  prop->m_outline         = m_outline;

  return prop;

}

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

const TColorStyle *OutlineRegionProp::getColorStyle() const {

  return m_colorStyle.getPointer();

}

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

void OutlineRegionProp::draw(TFlash &flash) {

  m_colorStyle->drawRegion(flash, getRegion());

  /*

//flash.setColor(m_colorStyle->getMainColor());

m_colorStyle->setFill(flash);

//rd.setTexture(m_colorStyle->getMainColor());

for (i=0; i<(int)r->getEdgeCount(); i++)

  computeQuadChain(*r->getEdge(i), quadArray, toBeDeleted);

flash.drawPolygon(quadArray);

clearPointerContainer(toBeDeleted);

*/

}