#include "tgl.h"

#include "tvectorgl.h"

#include "tregion.h"

#include "tregionprop.h"

#include "tstrokeutil.h"

#include "tvectorrenderdata.h"

#include "tvectorimage.h"

#include "tpalette.h"

#include "tcolorfunctions.h"

#include "tsimplecolorstyles.h"

#include "tthreadmessage.h"

#include "tstrokeprop.h"

#include "tconvert.h"

#include "tcurves.h"

#include "tstrokeoutline.h"

#ifndef WIN32

#define CALLBACK

#endif

#ifndef checkErrorsByGL

#define checkErrorsByGL                      \

	{                                        \

		GLenum err = glGetError();           \

		assert(err != GL_INVALID_ENUM);      \

		assert(err != GL_INVALID_VALUE);     \

		assert(err != GL_INVALID_OPERATION); \

		assert(err != GL_STACK_OVERFLOW);    \

		assert(err != GL_STACK_UNDERFLOW);   \

		assert(err != GL_OUT_OF_MEMORY);     \

		assert(err == GL_NO_ERROR);          \

	}

#endif

#undef checkErrorsByGL

#define checkErrorsByGL

using namespace std;

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

/*

DV_EXPORT_API void mylog(std::string s)

{

  static TThread::Mutex mutex;

  QMutexLocker sl(mutex);

  std::ofstream os("C:\\gmt\\buttami\\bu.txt", std::ios::app);

  LARGE_INTEGER ticksPerSecond;

  LARGE_INTEGER tick;   

  static LARGE_INTEGER firstTick;   

  static bool firstTime = true;

  long dt = 0;

  QueryPerformanceFrequency(&ticksPerSecond);

  QueryPerformanceCounter(&tick);

  if(firstTime) {firstTick = tick;firstTime=false;}

  else

  {

    dt = (long)(1000000*(tick.QuadPart-firstTick.QuadPart)/ticksPerSecond.QuadPart);

  }

  os << dt << ":" << s << std::endl;

}

*/

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

#ifdef _DEBUG

bool checkQuadraticDistance(TStroke *stroke, bool checkThickness)

{

	UINT i, qCount = stroke->getChunkCount();

	const TThickQuadratic *q;

	TThickPoint p1, p2, p3;

	//se i punti coincidono e' una stroke puntiforme ed e' ammessa

	if (qCount == 1)

		return true;

	for (i = 0; i != qCount; i++) {

		q = stroke->getChunk(i);

		p1 = q->getThickP0();

		p2 = q->getThickP1();

		p3 = q->getThickP2();

		if (areAlmostEqual(p1.x, p2.x) && areAlmostEqual(p2.x, p3.x) &&

			areAlmostEqual(p1.y, p2.y) && areAlmostEqual(p2.y, p3.y) &&

			(!checkThickness ||

			 (areAlmostEqual(p1.thick, p2.thick) && areAlmostEqual(p2.thick, p3.thick))))

			return false;

	}

	return true;

}

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

void drawControlPoints(const TVectorRenderData &rd, TStroke *stroke, double pixelSize, bool allPoints = true)

{

	int i;

	TPointD p;

	glPushMatrix();

	tglMultMatrix(rd.m_aff);

	glPointSize(2.0);

	glBegin(GL_POINTS);

	if (allPoints) {

		int n = stroke->getControlPointCount();

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

			p = stroke->getControlPoint(i);

			glColor3d((i + 1) & 1, i & 1, 0.0);

			glVertex2d(p.x, p.y);

		}

	} else {

		int n = stroke->getChunkCount();

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

			const TThickQuadratic *chunk = stroke->getChunk(i);

			p = chunk->getP0();

			glColor3d(1.0, 0.0, 0.0);

			glVertex2d(p.x, p.y);

		}

		const TThickQuadratic *chunk = stroke->getChunk(n - 1);

		glColor3d(1.0, 0.0, 0.0);

		p = chunk->getP2();

		glVertex2d(p.x, p.y);

	}

	glEnd();

	glPopMatrix();

}

#endif

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

/*TPixel TransparencyCheckBlackBgInk = TPixel(255,255,255);

TPixel TransparencyCheckWhiteBgInk = TPixel(0,0,0);

TPixel TransparencyCheckPaint = TPixel(127,127,127);*/

static int Index = 0;

void tglDraw(const TVectorRenderData &rd, TRegion *r, bool pushAttribs)

{

	checkErrorsByGL;

	assert(r);

	checkErrorsByGL;

	if (!r)

		return;

	bool alphaChannel = rd.m_alphaChannel;

	checkErrorsByGL;

	int j = 0;

	bool visible = false;

	int colorCount = 0;

	TColorStyleP style;

	if (rd.m_paintCheckEnabled && r->getStyle() == rd.m_colorCheckIndex) {

		static TSolidColorStyle *redColor = new TSolidColorStyle();

		redColor->addRef();

		redColor->setMainColor(TPixel::Red);

		style = redColor;

	} else if (rd.m_tcheckEnabled) {

		static TSolidColorStyle *color = new TSolidColorStyle();

		color->addRef();

		color->setMainColor(rd.m_tCheckPaint);

		style = color;

	} else

		style = rd.m_palette->getStyle(r->getStyle());

	colorCount = style->getColorParamCount();

	if (colorCount == 0) { //for example texture

		visible = true;

	} else {

		visible = false;

		for (j = 0; j < colorCount && !visible; j++) {

			TPixel32 color = style->getColorParamValue(j);

			if (rd.m_cf)

				color = (*(rd.m_cf))(color);

			if (color.m != 0)

				visible = true;

		}

	}

	if (visible) {

		TRegionProp *prop = r->getProp(/*rd.m_palette*/);

		///questo codice satva dentro tregion::getprop/////

		int styleId = r->getStyle();

		if (styleId) {

			// TColorStyle * style = rd.m_palette->getStyle(styleId);

			if (!style->isRegionStyle() || style->isEnabled() == false) {

				prop = 0;

			} else {

				//Warning: The same remark of stroke props holds here.

				if (!prop || style.getPointer() != prop->getColorStyle()) {

					r->setProp(style->makeRegionProp(r));

					prop = r->getProp();

				}

			}

		}

		////// draw

		if (prop) {

			if (pushAttribs)

				glPushAttrib(GL_ALL_ATTRIB_BITS);

			tglEnableLineSmooth(true);

//#define DRAW_EDGE_NUMBERS

#ifdef DRAW_EDGE_NUMBERS

			glPushMatrix();

			tglMultMatrix(rd.m_aff);

			switch (Index % 7) {

			case 0:

				tglColor(TPixel::Red);

				break;

			case 1:

				tglColor(TPixel::Green);

				break;

			case 2:

				tglColor(TPixel::Blue);

				break;

			case 3:

				tglColor(TPixel::Cyan);

				break;

			case 4:

				tglColor(TPixel::Magenta);

				break;

			case 5:

				tglColor(TPixel::Yellow);

				break;

			case 6:

				tglColor(TPixel::Black);

				break;

			default:

				tglColor(TPixel::Red);

				break;

			}

			Index++;

			if (rIndex == 2) {

				double y = r->getEdge(0)->m_s->getThickPoint((r->getEdge(0)->m_w0 + r->getEdge(0)->m_w1) / 2.0).y;

				tglDrawSegment(TPointD(-1000, y), TPointD(1000, y));

			}

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

				TEdge *e = r->getEdge(i);

				TPointD p = e->m_s->getPoint(0.8 * e->m_w0 + 0.2 * e->m_w1);

				if (i == 0)

					tglDrawText(p, (QString::number(rIndex) + QString("-0")).toStdString());

				else

					tglDrawText(p, QString::number(i).toStdString());

				if (e->m_index == 3) {

					tglColor(TPixel::Black);

					TStroke *s = e->m_s;

					drawPoint(s->getChunk(0)->getP0(), .3);

					tglColor(TPixel::Red);

					tglDrawText(s->getChunk(0)->getP0(), QString::number(0).toStdString());

					for (int ii = 0; ii < s->getChunkCount(); ii++) {

						drawPoint(s->getChunk(ii)->getP2(), .3);

						if (ii < s->getChunkCount() - 1) {

							tglColor(TPixel::Red);

							tglDrawText(s->getChunk(ii)->getP2(), QString::number(ii + 1).toStdString());

						}

					}

				}

			}

			glPopMatrix();

#endif

			if (alphaChannel) {

				GLboolean red, green, blue, alpha;

				tglGetColorMask(red, green, blue, alpha);

				//Draw RGB channels

				tglEnableBlending(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

				glColorMask(red, green, blue, GL_FALSE);

				prop->draw(rd);

				//Draw Matte channel

				tglEnableBlending(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

				glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, alpha);

				prop->draw(rd);

				glColorMask(red, green, blue, alpha);

			} else {

				//pezza: in render, le aree fillate dei custom styles sparivano.

				if (!rd.m_isOfflineRender || !rd.m_isImagePattern)

					tglRgbOnlyColorMask(); //RGB components only

				prop->draw(rd);

			}

			if (pushAttribs)

				glPopAttrib();

		}

	}

	for (UINT i = 0; i < r->getSubregionCount(); i++)

		tglDraw(rd, r->getSubregion(i), pushAttribs);

	checkErrorsByGL;

}

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

void tglDrawMask(const TVectorRenderData &rd1, const TVectorImage *vim)

{

	UINT i;

	assert(vim);

	if (!vim)

		return;

	TVectorRenderData rd(rd1);

	glPushAttrib(GL_ALL_ATTRIB_BITS);

	if (!rd.m_palette) {

		TPalette *vPalette = vim->getPalette();

		assert(vPalette);

		rd.m_palette = vPalette;

	}

	for (i = 0; i < vim->getRegionCount(); i++)

		tglDraw(rd, vim->getRegion(i), false);

	glPopAttrib();

}

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

namespace

{

bool isOThick(const TStroke *s)

{

	int i;

	for (i = 0; i < s->getControlPointCount(); i++)

		if (s->getControlPoint(i).thick != 0)

			return false;

	return true;

}

}

void tglDraw(const TVectorRenderData &rd, const TStroke *s, bool pushAttribs)

{

	assert(s);

	if (!s)

		return;

	TStrokeProp *prop = 0;

	bool pushedAttribs = false;

	try {

		TColorStyleP style;

		TStroke *stroke = const_cast<tstroke *="">(s);</tstroke>

		if (rd.m_inkCheckEnabled && s->getStyle() == rd.m_colorCheckIndex) {

			static TSolidColorStyle *redColor = new TSolidColorStyle();

			redColor->addRef();

			redColor->setMainColor(TPixel::Red);

			style = redColor;

		} else if (rd.m_tcheckEnabled) {

			static TSolidColorStyle *color = new TSolidColorStyle();

			color->addRef();

			color->setMainColor(rd.m_tCheckInk);

			style = color;

		} else

			style = rd.m_palette->getStyle(stroke->getStyle());

		if (!rd.m_show0ThickStrokes && isOThick(s) && dynamic_cast<tsolidcolorstyle *="">(style.getPointer()) // This is probably to exclude TCenterlineStrokeStyle-like styles</tsolidcolorstyle>

			&& !rd.m_tcheckEnabled)																		   // I wonder why this?

			return;

		// const TStroke& stroke = *s;  //serve???

		assert(rd.m_palette);

		prop = s->getProp(/*rd.m_palette*/);

		/////questo codice stava dentro tstroke::getprop/////////

		if (prop)

			prop->getMutex()->lock();

		if (!style->isStrokeStyle() || style->isEnabled() == false) {

			if (prop)

				prop->getMutex()->unlock();

			prop = 0;

		} else {

			//Warning: the following pointers check is conceptually wrong - we

			//keep it because the props maintain SMART POINTER-like reference to

			//the associated style. This prevents the style from being destroyed

			//while still referenced by the prop.

			if (!prop || style.getPointer() != prop->getColorStyle()) {

				if (prop)

					prop->getMutex()->unlock();

				stroke->setProp(style->makeStrokeProp(stroke));

				prop = stroke->getProp();

				if (prop)

					prop->getMutex()->lock();

			}

		}

		//--------- draw ------------

		if (!prop)

			return;

		if (pushAttribs)

			glPushAttrib(GL_ALL_ATTRIB_BITS), pushedAttribs = true;

		bool alphaChannel = rd.m_alphaChannel, antialias = rd.m_antiAliasing;

		TVectorImagePatternStrokeProp *aux = dynamic_cast<tvectorimagepatternstrokeprop *="">(prop);</tvectorimagepatternstrokeprop>

		if (aux) //gli image pattern vettoriali tornano in questa funzione....non facendo il corpo dell'else'si evita di disegnarli due volte!

			prop->draw(rd);

		else {

			if (antialias)

				tglEnableLineSmooth(true);

			else

				tglEnableLineSmooth(false);

			if (alphaChannel) {

				GLboolean red, green, blue, alpha;

				tglGetColorMask(red, green, blue, alpha);

				//Draw RGB channels

				tglEnableBlending(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

				glColorMask(red, green, blue, GL_FALSE);

				prop->draw(rd);

				//Draw Matte channel

				tglEnableBlending(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

				glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, alpha);

				prop->draw(rd);

				glColorMask(red, green, blue, alpha);

			} else {

				tglEnableBlending(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

				prop->draw(rd);

			}

		}

		if (pushAttribs)

			glPopAttrib(), pushedAttribs = false;

		prop->getMutex()->unlock();

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

	} catch (...) {

		if (prop)

			prop->getMutex()->unlock();

		if (pushedAttribs)

			glPopAttrib();

	}

}

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

void tglDoDraw(const TVectorRenderData &rd, TRegion *r)

{

	bool visible = false;

	int colorCount = 0;

	if (!r)

		return;

	TColorStyleP style = rd.m_palette->getStyle(r->getStyle());

	colorCount = style->getColorParamCount();

	if (colorCount == 0) //for example texture

		visible = true;

	else {

		visible = false;

		for (int j = 0; j < colorCount && !visible; j++) {

			TPixel32 color = style->getColorParamValue(j);

			if (rd.m_cf)

				color = (*(rd.m_cf))(color);

			if (color.m != 0)

				visible = true;

		}

	}

	if (visible)

		tglDraw(rd, r, false);

	else

		for (UINT j = 0; j < r->getSubregionCount(); j++)

			tglDraw(rd, r->getSubregion(j), false);

}

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

void tglDoDraw(const TVectorRenderData &rd, const TStroke *s)

{

	bool visible = false;

	int colorCount = 0;

	const TPalette *palette = rd.m_palette;

	int styleId = s->getStyle();

	//assert(0<=styleId && styleId

	TColorStyleP style = palette->getStyle(styleId);

	assert(style);

	colorCount = style->getColorParamCount();

	if (colorCount == 0)

		visible = true;

	else {

		visible = false;

		for (int j = 0; j < style->getColorParamCount() && !visible; j++) {

			TPixel32 color = style->getColorParamValue(j);

			if (rd.m_cf)

				color = (*(rd.m_cf))(color);

			if (color.m != 0)

				visible = true;

		}

	}

#if DISEGNO_OUTLINE == 0

	if (visible)

#endif

		tglDraw(rd, s, false);

#ifdef _DEBUG

//drawControlPoints(rd, vim->getStroke(i), sqrt(tglGetPixelSize2()), true);

//assert(checkQuadraticDistance(vim->getStroke(i),true));

#endif

}

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

namespace

{

void doDraw(const TVectorImage *vim, const TVectorRenderData &_rd, bool drawEnteredGroup)

{

	static TOnionFader *fade = new TOnionFader(TPixel::White, 0.5);

	TVectorRenderData rd(_rd);

	if (!rd.m_palette) {

		TPalette *vPalette = vim->getPalette();

		rd.m_palette = vPalette;

		if (!vPalette)

			return;

	}

	if (!drawEnteredGroup && !rd.m_isIcon && vim->isInsideGroup() > 0)

		rd.m_cf = fade;

	TVectorRenderData rdRegions = rd;

	/*if (rd.m_drawRegions && rd.m_isImagePattern)//gli image pattern hanno bisogno dell'antialiasig per le linee, ma sulle aree ci sarebbero un sacco di assert

  rdRegions.m_alphaChannel = rdRegions.m_antiAliasing = false;*/

	UINT strokeIndex = 0;

	Index = 0;

	while (strokeIndex < vim->getStrokeCount()) // ogni ciclo di while disegna un gruppo

	{

		int currStrokeIndex = strokeIndex;

		if (!rd.m_isIcon && vim->isInsideGroup() > 0 &&

			((drawEnteredGroup && !vim->isEnteredGroupStroke(strokeIndex)) ||

			 !drawEnteredGroup && vim->isEnteredGroupStroke(strokeIndex))) {

			while (strokeIndex < vim->getStrokeCount() && vim->sameGroup(strokeIndex, currStrokeIndex))

				strokeIndex++;

			continue;

		}

		if (rd.m_drawRegions)

			for (UINT regionIndex = 0; regionIndex < vim->getRegionCount(); regionIndex++)

				if (vim->sameGroupStrokeAndRegion(currStrokeIndex, regionIndex))

					tglDoDraw(rdRegions, vim->getRegion(regionIndex));

		while (strokeIndex < vim->getStrokeCount() && vim->sameGroup(strokeIndex, currStrokeIndex)) {

#if DISEGNO_OUTLINE == 1

			CurrStrokeIndex = strokeIndex;

			CurrVimg = vim;

#endif

			tglDoDraw(rd, vim->getStroke(strokeIndex));

			strokeIndex++;

		}

	}

}

}

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

void tglDraw(const TVectorRenderData &rd, const TVectorImage *vim)

{

	assert(vim);

	if (!vim)

		return;

	QMutexLocker sl(vim->getMutex());

	checkErrorsByGL;

	checkErrorsByGL;

	glPushAttrib(GL_ALL_ATTRIB_BITS);

	//if(!rd.m_palette) rd.m_palette = vim->getPalette();

	//mylog("tglDraw start; mutex=" + toString((unsigned long)&vim->getMutex()));

	glEnable(GL_ALPHA_TEST);

	glAlphaFunc(GL_GREATER, 0);

	doDraw(vim, rd, false);

	if (!rd.m_isIcon && vim->isInsideGroup() > 0)

		doDraw(vim, rd, true);

	glDisable(GL_ALPHA_TEST);

	glPopAttrib();

#ifdef _DEBUG

	vim->drawAutocloses(rd);

#endif

	checkErrorsByGL;

	//mylog("tglDraw stop");

}

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

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