#include "regionstyles.h"

#include "tgl.h"

#include "tcolorfunctions.h"

#include "trandom.h"

//#include "tsystem.h"

//#include "tvectorrenderdata.h"

#include "colorfxutils.h"

//#include "tgl.h"

//#include "tregionoutline.h"

//#include "tpalette.h"

//#include "tvectorimage.h"

//#include "tstroke.h"

#include "tflash.h"

#include "tregion.h"

#include "tcurves.h"

//#include "drawutil.h"

#include "tmathutil.h"

#include "tstencilcontrol.h"

//***************************************************************************

//    MovingModifier  implementation

//***************************************************************************

TOutlineStyle::RegionOutlineModifier *MovingModifier::clone() const

{

	return new MovingModifier(*this);

}

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

void MovingModifier::modify(TRegionOutline &outline) const

{

	TRegionOutline::Boundary::iterator regIt = outline.m_exterior.begin();

	TRegionOutline::Boundary::iterator regItEnd = outline.m_exterior.end();

	TRegionOutline::PointVector::iterator pIt;

	TRegionOutline::PointVector::iterator pItEnd;

	for (; regIt != regItEnd; ++regIt) {

		pIt = regIt->begin();

		pItEnd = regIt->end();

		for (; pIt != pItEnd; ++pIt) {

			pIt->x += m_move.x;

			pIt->y += m_move.y;

		}

	}

	regIt = outline.m_interior.begin();

	regItEnd = outline.m_interior.end();

	for (; regIt != regItEnd; ++regIt) {

		pIt = regIt->begin();

		pItEnd = regIt->end();

		for (; pIt != pItEnd; ++pIt) {

			pIt->x += m_move.x;

			pIt->y += m_move.y;

		}

	}

}

//***************************************************************************

//    MovingSolidColor  implementation

//***************************************************************************

MovingSolidColor::MovingSolidColor(const TPixel32 &color, const TPointD &move)

	: TSolidColorStyle(color)

{

	m_regionOutlineModifier = new MovingModifier(move);

}

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

TColorStyle *MovingSolidColor::clone() const

{

	return new MovingSolidColor(*this);

}

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

void MovingSolidColor::loadData(TInputStreamInterface &is)

{

	TSolidColorStyle::loadData(is);

	delete m_regionOutlineModifier;

	MovingModifier *mov = new MovingModifier(TPointD());

	mov->loadData(is);

	m_regionOutlineModifier = mov;

}

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

void MovingSolidColor::saveData(TOutputStreamInterface &os) const

{

	TSolidColorStyle::saveData(os);

	assert(m_regionOutlineModifier);

	((MovingModifier *)m_regionOutlineModifier)->saveData(os);

}

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

int MovingSolidColor::getParamCount() const

{

	return 2;

}

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

TColorStyle::ParamType MovingSolidColor::getParamType(int index) const

{

	assert(0 <= index && index < getParamCount());

	return TColorStyle::DOUBLE;

}

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

QString MovingSolidColor::getParamNames(int index) const

{

	assert(0 <= index && index < 2);

	return index == 0 ? QCoreApplication::translate("MovingSolidColor", "Horiz Offset") : QCoreApplication::translate("MovingSolidColor", "Vert Offset");

}

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

void MovingSolidColor::getParamRange(int index, double &min, double &max) const

{

	assert(0 <= index && index < 2);

	min = -100.0;

	max = 100.0;

}

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

double MovingSolidColor::getParamValue(TColorStyle::double_tag, int index) const

{

	assert(0 <= index && index < 2);

	if (index)

		return ((MovingModifier *)m_regionOutlineModifier)->getMovePoint().y;

	else

		return ((MovingModifier *)m_regionOutlineModifier)->getMovePoint().x;

}

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

void MovingSolidColor::setParamValue(int index, double value)

{

	assert(0 <= index && index < 2);

	TPointD oldMove = ((MovingModifier *)m_regionOutlineModifier)->getMovePoint();

	if (!index) {

		if (oldMove.x != value) {

			delete m_regionOutlineModifier;

			oldMove.x = value;

			m_regionOutlineModifier = new MovingModifier(oldMove);

			updateVersionNumber();

		}

	} else {

		if (oldMove.y != value) {

			delete m_regionOutlineModifier;

			oldMove.y = value;

			m_regionOutlineModifier = new MovingModifier(oldMove);

			updateVersionNumber();

		}

	}

}

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

void MovingSolidColor::drawRegion(const TColorFunction *cf, const bool antiAliasing, TRegionOutline &boundary) const

{

	TSolidColorStyle::drawRegion(cf, true, boundary);

}

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

void MovingSolidColor::drawRegion(TFlash &flash, const TRegion *r) const

{

	SFlashUtils rdf(r);

	rdf.computeRegionOutline();

	m_regionOutlineModifier->modify(rdf.m_ro);

	flash.setFillColor(getMainColor());

	rdf.drawRegionOutline(flash, false);

}

//***************************************************************************

//    ShadowStyle  implementation

//***************************************************************************

ShadowStyle::ShadowStyle(const TPixel32 &bgColor,

						 const TPixel32 &shadowColor,

						 const TPointD &shadowDirection,

						 double len,

						 double density)

	: TSolidColorStyle(bgColor), m_shadowColor(shadowColor), m_shadowDirection(normalize(shadowDirection)), m_len(len), m_density(density)

{

}

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

TColorStyle *ShadowStyle::clone() const

{

	return new ShadowStyle(*this);

}

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

void ShadowStyle::loadData(TInputStreamInterface &is)

{

	TSolidColorStyle::loadData(is);

	is >> m_shadowDirection.x >> m_shadowDirection.y;

	is >> m_density;

	is >> m_shadowColor;

	is >> m_len;

}

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

void ShadowStyle::saveData(TOutputStreamInterface &os) const

{

	TSolidColorStyle::saveData(os);

	os << m_shadowDirection.x << m_shadowDirection.y;

	os << m_density;

	os << m_shadowColor;

	os << m_len;

}

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

int ShadowStyle::getParamCount() const

{

	return 3;

}

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

TColorStyle::ParamType ShadowStyle::getParamType(int index) const

{

	assert(0 <= index && index < getParamCount());

	return TColorStyle::DOUBLE;

}

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

QString ShadowStyle::getParamNames(int index) const

{

	assert(0 <= index && index < 3);

	switch (index) {

	case 0:

		return QCoreApplication::translate("ShadowStyle", "Angle");

	case 1:

		return QCoreApplication::translate("ShadowStyle", "Density");

	case 2:

		return QCoreApplication::translate("ShadowStyle", "Length");

	default:

		return QString();

	}

	assert(0);

	return QString();

}

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

void ShadowStyle::getParamRange(int index, double &min, double &max) const

{

	assert(0 <= index && index < 3);

	switch (index) {

	case 0:

		min = 0.0;

		max = 360.0;

		break;

	case 1:

		min = 0.0;

		max = 1.0;

		break;

	case 2:

		min = 0.0;

		max = 100.0;

		break;

	}

}

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

double ShadowStyle::getParamValue(TColorStyle::double_tag, int index) const

{

	assert(0 <= index && index < 3);

	double degree;

	switch (index) {

	case 0:

		degree = asin(m_shadowDirection.y);

		if (m_shadowDirection.x < 0)

			degree = M_PI - degree;

		if (degree < 0)

			degree += M_2PI;

		return degree * M_180_PI;

	case 1:

		return m_density;

	case 2:

		return m_len;

	}

	assert(0);

	return 0.0;

}

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

void ShadowStyle::setParamValue(int index, double value)

{

	assert(0 <= index && index < 3);

	double degree;

	switch (index) {

	case 0:

		degree = value * M_PI_180;

		m_shadowDirection.x = cos(degree);

		m_shadowDirection.y = sin(degree);

		break;

	case 1:

		m_density = value;

		break;

	case 2:

		m_len = value;

		break;

	}

}

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

void ShadowStyle::drawPolyline(const TColorFunction *cf, std::vector<t3dpointd> &polyline, TPointD shadowDirection) const</t3dpointd>

{

	int i;

	int stepNumber;

	double distance;

	TPointD v1, v2, diff, midPoint, ratio;

	double len;

	TPixel32 color;

	if (cf)

		color = (*(cf))(m_shadowColor);

	else

		color = m_shadowColor;

	tglColor(color);

	//glEnable(GL_BLEND);

	//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	//// <-- tglEnableBlending();

	TRegionOutline::PointVector::iterator it;

	TRegionOutline::PointVector::iterator it_b = polyline.begin();

	TRegionOutline::PointVector::iterator it_e = polyline.end();

	v1.x = polyline.back().x;

	v1.y = polyline.back().y;

	for (it = it_b; it != it_e; ++it) {

		v2.x = it->x;

		v2.y = it->y;

		if (v1 == v2)

			continue;

		diff = normalize(rotate90(v2 - v1));

		len = diff * shadowDirection;

		if (len > 0) {

			distance = tdistance(v1, v2) * m_density;

			ratio = (v2 - v1) * (1.0 / distance);

			midPoint = v1;

			stepNumber = (int)distance;

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

				glBegin(GL_LINE_STRIP);

				tglColor(TPixel32(color.r, color.g, color.b, 0));

				tglVertex(midPoint);

				tglColor(color);

				tglVertex(midPoint + (shadowDirection * len * m_len * 0.5));

				tglColor(TPixel32(color.r, color.g, color.b, 0));

				tglVertex(midPoint + (shadowDirection * len * m_len));

				midPoint += ratio;

				glEnd();

			}

		}

		v1 = v2;

	}

	//tglColor(TPixel32::White);

}

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

void ShadowStyle::drawRegion(const TColorFunction *cf, const bool antiAliasing,

							 TRegionOutline ®ionOutline) const

{

	TStencilControl *stenc = TStencilControl::instance();

	TPixel32 backgroundColor = TSolidColorStyle::getMainColor();

	if (cf)

		backgroundColor = (*(cf))(backgroundColor);

	////stenc->beginMask();

	/*

  glBegin(GL_QUADS);      

  glVertex2d (regionOutline.m_bbox.getP00().x, regionOutline.m_bbox.getP00().y);

  glVertex2d (regionOutline.m_bbox.getP01().x, regionOutline.m_bbox.getP01().y);

  glVertex2d (regionOutline.m_bbox.getP11().x, regionOutline.m_bbox.getP11().y);

  glVertex2d (regionOutline.m_bbox.getP10().x, regionOutline.m_bbox.getP10().y);

  glEnd();

  */

	////stenc->endMask();

	////stenc->enableMask(TStencilControl::SHOW_INSIDE);

	if (backgroundColor.m == 0) { //only to create stencil mask

		TSolidColorStyle appStyle(TPixel32::White);

		stenc->beginMask();

		appStyle.drawRegion(0, false, regionOutline);

	} else {

		stenc->beginMask(TStencilControl::DRAW_ALSO_ON_SCREEN);

		TSolidColorStyle::drawRegion(cf, antiAliasing, regionOutline);

	}

	stenc->endMask();

	stenc->enableMask(TStencilControl::SHOW_INSIDE);

	TRegionOutline::Boundary::iterator regions_it;

	TRegionOutline::Boundary::iterator regions_it_b = regionOutline.m_exterior.begin();

	TRegionOutline::Boundary::iterator regions_it_e = regionOutline.m_exterior.end();

	for (regions_it = regions_it_b; regions_it != regions_it_e; ++regions_it)

		drawPolyline(cf, *regions_it, m_shadowDirection);

	stenc->enableMask(TStencilControl::SHOW_OUTSIDE);

	regions_it_b = regionOutline.m_interior.begin();

	regions_it_e = regionOutline.m_interior.end();

	for (regions_it = regions_it_b; regions_it != regions_it_e; ++regions_it)

		drawPolyline(cf, *regions_it, -m_shadowDirection);

	//tglColor(TPixel32::White);

	stenc->disableMask();

}

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

/*

int ShadowStyle::drawPolyline(TFlash& flash, std::vector<t3dpointd> &polyline,</t3dpointd>

							   TPointD shadowDirection, const bool isDraw) const

{

  int i;

  int stepNumber;

  double distance;

  TPointD v1,v2,diff,midPoint,ratio;

  double len;

  TRegionOutline::PointVector::iterator it;

  TRegionOutline::PointVector::iterator it_b = polyline.begin();

  TRegionOutline::PointVector::iterator it_e = polyline.end();            

  std::vector<tsegment> segmentArray;</tsegment>

  v1.x = polyline.back().x;

  v1.y = polyline.back().y;

  for(it = it_b; it!= it_e; ++it)

  {

    v2.x = it->x;

    v2.y = it->y;

    if (v1==v2)

      continue;

    diff = normalize(rotate90(v2-v1));

    len=diff*shadowDirection;

    if(len>0)

    {

      distance = tdistance(v1,v2)*m_density;

      ratio= (v2-v1)*(1.0/distance);

      midPoint=v1;

      stepNumber= (int)distance;

      for(i=0; i

      {	  

		  std::vector<tsegment> sa;</tsegment>

		  TPointD p0=midPoint;

		  TPointD p1=midPoint+(shadowDirection*len*m_len*0.5);

		  TPointD p2=midPoint+(shadowDirection*len*m_len);

		  segmentArray.push_back(TSegment(p1,p0));

		  segmentArray.push_back(TSegment(p1,p2));

          midPoint += ratio;

      }

    }

    v1=v2;

  }

  if ( isDraw && segmentArray.size()>0 ) {

	flash.setLineColor(m_shadowColor);

	flash.drawSegments(segmentArray, true);

  }

  if ( segmentArray.size()>0 )

	 return 1;

  return 0;

}

void ShadowStyle::drawRegion( TFlash& flash, const TRegion* r) const

{

  SFlashUtils rdf(r);

  rdf.computeRegionOutline();

  TRegionOutline::Boundary::iterator regions_it;

  TRegionOutline::Boundary::iterator regions_it_b = rdf.m_ro.m_exterior->begin();

  TRegionOutline::Boundary::iterator regions_it_e = rdf.m_ro.m_exterior->end();            

// In the GL version the shadow lines are not croped into the filled region.

// This is the reason why I don't calculate the number of shadow lines. 

//  int nbDraw=0;

//  for( regions_it = regions_it_b ; regions_it!= regions_it_e; ++regions_it)

//	  nbDraw+=drawPolyline(flash,*regions_it, m_shadowDirection,false);

//  regions_it_b = rdf.m_ro.m_interior->begin();

//  regions_it_e = rdf.m_ro.m_interior->end();            

//  for( regions_it = regions_it_b ; regions_it!= regions_it_e; ++regions_it)

//     nbDraw+=drawPolyline(flash,*regions_it,-m_shadowDirection,false);

// Only the bbox rectangle is croped.

  flash.drawRegion(*r,1);  

  flash.setFillColor(getMainColor());

  flash.drawRectangle(rdf.m_ro.m_bbox);

  regions_it_b = rdf.m_ro.m_exterior->begin();

  regions_it_e = rdf.m_ro.m_exterior->end();            

  for( regions_it = regions_it_b ; regions_it!= regions_it_e; ++regions_it)

	  drawPolyline(flash,*regions_it, m_shadowDirection);

  regions_it_b = rdf.m_ro.m_interior->begin();

  regions_it_e = rdf.m_ro.m_interior->end();            

  for( regions_it = regions_it_b ; regions_it!= regions_it_e; ++regions_it)

     drawPolyline(flash,*regions_it,-m_shadowDirection);

}

*/

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

TPixel32 ShadowStyle::getColorParamValue(int index) const

{

	return index == 0 ? m_shadowColor : TSolidColorStyle::getMainColor();

}

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

void ShadowStyle::setColorParamValue(int index, const TPixel32 &color)

{

	if (index == 0)

		m_shadowColor = color;

	else {

		TSolidColorStyle::setMainColor(color);

	}

}

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

void ShadowStyle::makeIcon(const TDimension &d)

{

	double oldVal = getParamValue(TColorStyle::double_tag(), 1);

	setParamValue(1, oldVal * 0.25);

	TColorStyle::makeIcon(d);

	setParamValue(1, oldVal);

}

//***************************************************************************

//    ShadowStyle2  implementation

//***************************************************************************

ShadowStyle2::ShadowStyle2(const TPixel32 &bgColor,

						   const TPixel32 &shadowColor,

						   const TPointD &shadowDirection,

						   double shadowLength)

	: TSolidColorStyle(bgColor), m_shadowColor(shadowColor), m_shadowLength(shadowLength), m_shadowDirection(normalize(shadowDirection))

{

}

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

TColorStyle *ShadowStyle2::clone() const

{

	return new ShadowStyle2(*this);

}

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

void ShadowStyle2::loadData(TInputStreamInterface &is)

{

	TSolidColorStyle::loadData(is);

	is >> m_shadowDirection.x >> m_shadowDirection.y;

	is >> m_shadowLength;

	is >> m_shadowColor;

}

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

void ShadowStyle2::saveData(TOutputStreamInterface &os) const

{

	TSolidColorStyle::saveData(os);

	os << m_shadowDirection.x << m_shadowDirection.y;

	os << m_shadowLength;

	os << m_shadowColor;

}

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

int ShadowStyle2::getParamCount() const

{

	return 2;

}

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

TColorStyle::ParamType ShadowStyle2::getParamType(int index) const

{

	assert(0 <= index && index < getParamCount());

	return TColorStyle::DOUBLE;

}

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

QString ShadowStyle2::getParamNames(int index) const

{

	assert(0 <= index && index < 2);

	return index == 0 ? QCoreApplication::translate("ShadowStyle2", "Angle") : QCoreApplication::translate("ShadowStyle2", "Size");

}

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

void ShadowStyle2::getParamRange(int index, double &min, double &max) const

{

	assert(0 <= index && index < 2);

	if (index == 0) {

		min = 0.0;

		max = 360.0;

	} else {

		min = 0.0;

		max = 500.0;

	}

}

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

double ShadowStyle2::getParamValue(TColorStyle::double_tag, int index) const

{

	assert(0 <= index && index < 2);

	if (index == 1)

		return m_shadowLength;

	double degree = asin(m_shadowDirection.y);

	if (m_shadowDirection.x < 0)

		degree = M_PI - degree;

	if (degree < 0)

		degree += M_2PI;

	return degree * M_180_PI;

}

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

int nbDiffVerts(const std::vector<tpointd> &pv)</tpointd>

{

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

	bool isMissing[4] = {true, true, true, true};

	if (pv.size() == 0)

		return 0;

	lpv.push_back(pv[0]);

	isMissing[0] = false;

	for (int i = 1; i < (int)pv.size(); i++) {

		bool isDiff = true;

		for (int j = 0; j < (int)lpv.size() && isDiff; j++)

			isDiff = lpv[j] == pv[i] ? false : isDiff;

		if (isDiff) {

			lpv.push_back(pv[i]);

			isMissing[i] = false;

		}

	}

	return lpv.size();

}

void ShadowStyle2::setParamValue(int index, double value)

{

	assert(0 <= index && index < 2);

	if (index == 1) {

		m_shadowLength = value;

	} else {

		double degree = value * M_PI_180;

		m_shadowDirection.x = cos(degree);

		m_shadowDirection.y = sin(degree);

	}

}

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

namespace

{

void drawShadowLine(TPixel32 shadowColor, TPixel32 color, TPointD v1, TPointD v2, TPointD diff1, TPointD diff2)

{

	v1 = v1 + diff1;

	v2 = v2 + diff2;

	diff1 = -diff1;

	diff2 = -diff2;

	double r1, r2;

	double t = 0.0;

	glBegin(GL_QUAD_STRIP);

	for (; t <= 1; t += 0.1) {

		r1 = t * t * t;

		r2 = 1 - r1;

		TPixel32 c((int)(color.r * r2 + shadowColor.r * r1),

				   (int)(color.g * r2 + shadowColor.g * r1),

				   (int)(color.b * r2 + shadowColor.b * r1),

				   (int)(color.m * r2 + shadowColor.m * r1));

		tglColor(c);

		tglVertex(v1 + t * diff1);

		tglVertex(v2 + t * diff2);

	}

	glEnd();

}

int drawShadowLine(TFlash &flash, TPixel32 shadowColor, TPixel32 color,

				   TPointD v1, TPointD v2, TPointD diff1, TPointD diff2,

				   const bool isDraw = true)