#include "drawutil.h"
#include "tstroke.h"
#include "tmathutil.h"
//#include "tregion.h"
#include "tcurveutil.h"
#include "tcurves.h"

namespace
{
void drawQuadraticCenterline(const TQuadratic &inQuad,
							 double pixelSize,
							 double from,
							 double to)
{
	assert(0.0 <= from &&
		   from <= to &&
		   to <= 1.0);

	to = (std::max)(0.0, (std::min)(to, 1.0));
	from = (std::max)(0.0, (std::min)(from, to));

	TQuadratic
		tmp(inQuad),
		s1,
		s2;

	TQuadratic
		*quad = &tmp;

	double
		newFrom = from;
	if (to != 1.0) {
		tmp.split(to, s1, s2);
		quad = &s1;
		newFrom = from / to;
	}

	if (from != 0.0) {
		tmp = *quad;
		tmp.split(newFrom, s1, s2);
		quad = &s2;
	}

	//glColor( TPixel32::Black );
	double step = computeStep(*quad, pixelSize);

	// It draws the curve as a linear piecewise approximation

	double invSqrtScale = 1.0;

	// First of all, it computes the control circles of the curve in screen coordinates
	TPointD scP0 = quad->getP0();
	TPointD scP1 = quad->getP1();
	TPointD scP2 = quad->getP2();

	TPointD A = scP0 - 2 * scP1 + scP2;
	TPointD B = scP0 - scP1;

	double h;
	h = invSqrtScale * step;
	double h2 = h * h;

	TPointD P = scP0, D2 = 2 * h2 * A, D1 = A * h2 - 2 * B * h;

	if (h < 0 || isAlmostZero(h))
		return;

	//    if ( h < from )
	//      h = from;

	// It draws the whole curve, using forward differencing
	glBegin(GL_LINE_STRIP); // The curve starts from scP0

	//scP0 = quad.getPoint(from);
	glVertex2d(scP0.x, scP0.y);

	for (double t = from + h; t < to; t = t + h) {
		P = P + D1;
		D1 = D1 + D2;
		glVertex2d(P.x, P.y);
	}

	//scP2 = quad.getPoint(to);
	glVertex2d(scP2.x, scP2.y); // The curve ends in scP2
	glEnd();
}
}

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

void stroke2polyline(std::vector<TPointD> &pnts, const TStroke &stroke,
					 double pixelSize, double w0, double w1, bool lastRepeatable)
{
	TPointD p;
	double step;
	int i, index0, index1;
	double t0, t1;

	if (isAlmostZero(w0))
		w0 = 0.0;
	if (isAlmostZero(w1))
		w1 = 0.0;
	if (isAlmostZero(1 - w0))
		w0 = 1.0;
	if (isAlmostZero(1 - w1))
		w1 = 1.0;

	assert(w0 >= 0.0);
	assert(w0 <= 1.0);
	assert(w1 >= 0.0);
	assert(w1 <= 1.0);

	stroke.getChunkAndT(w0, index0, t0);
	stroke.getChunkAndT(w1, index1, t1);

	double t;
	double endT;

	if (index1 < index0 || (index1 == index0 && t1 < t0)) {

		for (i = index0; i >= index1; i--) {
			step = computeStep(*(stroke.getChunk(i)), pixelSize);

			if (step < TConsts::epsilon)
				step = TConsts::epsilon;

			p = stroke.getChunk(i)->getPoint(t0);

			if (pnts.empty() || pnts.back() != p)
				pnts.push_back(p);

			endT = (i == index1) ? t1 : 0;

			pnts.reserve((UINT)((t0 - endT) / step) + 1 + pnts.size());

			for (t = t0 - step; t >= endT; t -= step)
				pnts.push_back(stroke.getChunk(i)->getPoint(t));

			t0 = 1;
		}

	} else {

		for (i = index0; i <= index1; i++) {
			step = computeStep(*(stroke.getChunk(i)), pixelSize);

			assert(step);
			if (!step)
				step = TConsts::epsilon; //non dovrebbe accadere mai!!!

			p = stroke.getChunk(i)->getPoint(t0);

			if (pnts.empty() || pnts.back() != p)
				pnts.push_back(p);

			endT = (i == index1) ? t1 : 1;

			pnts.reserve((UINT)((endT - t0) / step) + 1 + pnts.size());

			for (t = t0 + step; t <= endT; t += step)
				pnts.push_back(stroke.getChunk(i)->getPoint(t));

			t0 = 0;
		}
	}

	p = stroke.getPoint(w1);

	if (pnts.empty() || (p != pnts.back() && (p != pnts.front() || lastRepeatable)))
		pnts.push_back(p);
}

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

/*
void  region2polyline(vector<T3DPointD>& pnts,
                      const TRegion* reg, 
                      double pixelSize )
{
assert( reg );
if(!reg) return;

const TStroke* stroke;
double w0;
double w1;
TPointD lastPnt;
for(UINT i=0; i<reg->getEdgeCount(); i++)
  {
  TRegion::edge* edge = reg->getEdge(i);
  stroke = edge->m_stroke;
  assert(stroke);

  if (edge->m_w0==-1)
    {
    int index;
    double t, dummy;
    stroke->getNearestChunk(edge->m_p0, t, index, dummy);
    edge->m_w0 = getWfromChunkAndT(stroke, index, t);
     
    stroke->getNearestChunk(edge->m_p1, t, index, dummy);
    edge->m_w1 = getWfromChunkAndT(stroke, index, t);
    }

  w0 = edge->m_w0;
  w1 = edge->m_w1;
    
  assert( 0 <= w0 && w0 <= 1.0 );
  assert( 0 <= w1 && w1 <= 1.0 );
   
  double step = computeStep( *stroke, pixelSize );
    
    // assert( step != 2 && step != 0.0 );
    
  if( isAlmostZero( step ) ) 
    step = 1.0;
   
  step/= stroke->getChunkCount(); 
    
  double direction = 1;
    
  if( w0 > w1 ) 
    direction *=-1;
    
  T3DPointD pnt;
    
  double incr = direction*step;
    
  pnt = T3DPointD( stroke->getPoint( w0 ), 0 );
    
  if ( pnts.empty() || pnt != pnts.back() )
    pnts.push_back( pnt );
    
  for( double w = w0 + incr; direction*w < direction*w1; w+= incr)
    {
    pnt = T3DPointD( stroke->getPoint( w ), 0 );    
      if ( pnt != pnts.back() )
        pnts.push_back( pnt );
    }	           
  }
}
*/

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

#if defined(MACOSX)
void lefttRotateBits(UCHAR *buf, int bufferSize)
{
	UINT *buffer = (UINT *)buf;
	UINT app;
	for (int i = 0; i < bufferSize; i++, buffer++) {
		app = *buffer;
		*buffer = app << 8 | app >> 24;
	}
}
#endif

double computeStep(const TStroke &s, double pixelSize)
{
	double minVal = (std::numeric_limits<double>::max)();
	double tempVal;
	for (int i = 0; i < s.getChunkCount(); ++i)
		if ((tempVal = computeStep(*s.getChunk(i), pixelSize)) < minVal)
			minVal = tempVal;

	return minVal;
}

/*
*/
TRasterP prepareTexture(const TRasterP &ras, TextureInfoForGL &texinfo)
{
	TDimension size = ras->getSize();

	texinfo.width = size.lx;
	texinfo.height = size.ly;
	texinfo.internalformat = ras->getPixelSize();
	texinfo.format = GL_UNSIGNED_BYTE;
	texinfo.pixels = ras->getRawData();

	switch (texinfo.internalformat) {
	case 1:
		texinfo.type = GL_LUMINANCE;
		break;
	case 2:
		texinfo.type = GL_LUMINANCE_ALPHA;
		break;
	}

	if (texinfo.internalformat > 2) {
		switch (texinfo.internalformat) {
		case 3:
			texinfo.type = GL_RGB;
			break;
		case 4:
			texinfo.type = GL_RGBA;
			break; // GL_RGBA;  break;
		}

#ifdef TNZ_MACHINE_CHANNEL_ORDER_BGRM // under win32 pixel are in reverse order

#ifdef GL_EXT_bgra // if extension exists...

		// and it's  present at run time all okay
		// if(TGLArea::isBGRASupported())
		{
			switch (texinfo.internalformat) {
			case 3:
				texinfo.type = GL_BGR_EXT;
				break;
			case 4:
				texinfo.type = GL_BGRA_EXT;
				break;
			}
			return ras;
		}
#else

		TDimension size = ras->getSize();
		TRasterP outRas = ras->clone();
		outRas->lock();
		int pixelSize = ras->getPixelSize();
		texinfo.pixels = outRas->getRawData();

		UCHAR *p1, *p2;

		for (int i = 0; i < size.lx; ++i)
			for (int j = 0; j < size.ly; ++j) {
				p1 = outRas->getRawData(i, j);
				p2 = p1 + 2;
				std::swap(*p1, *p2);
			}
		outRas->unlock();
		return outRas;
#endif

#elif defined(TNZ_MACHINE_CHANNEL_ORDER_MRGB)
//mrgb

#warning "ottimizzare in qualche modo"

		TDimension size = ras->getSize();
		TRasterP outRas = ras->clone();

		texinfo.pixels = outRas->getRawData();

		lefttRotateBits((UCHAR *)texinfo.pixels, size.lx * size.ly);

		return outRas;

#endif
	}

	texinfo.pixels = ras->getRawData();
	return ras;
}

void drawStrokeCenterline(const TStroke &stroke,
						  double pixelSize,
						  double from,
						  double to)
{
	int
		c1 = 0,
		c2 = 0;
	double
		t1 = 1.0,
		t2 = 0.0;

	if (stroke.getChunkCount() == 0)
		return;

	stroke.getChunkAndT(from, c1, t1);
	stroke.getChunkAndT(to, c2, t2);

	if (c1 == c2) {
		if (from == to)
			return;

		drawQuadraticCenterline(*stroke.getChunk(c1),
								pixelSize,
								t1,
								t2);
	} else {
		// partial first chunk
		drawQuadraticCenterline(*stroke.getChunk(c1),
								pixelSize,
								t1,
								1.0);
		// next chunk
		++c1;
		if (c1 < c2) {
			for (int i = c1;
				 i < c2;
				 ++i)
				drawQuadraticCenterline(*stroke.getChunk(i),
										pixelSize,
										0.0,
										1.0);
		}

		// partial last chunk
		drawQuadraticCenterline(*stroke.getChunk(c2),
								pixelSize,
								0.0,
								t2);
	}
}

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

DVAPI TStroke *makeEllipticStroke(double thick, TPointD center, double radiusX, double radiusY)
{

	std::vector<TThickPoint> points(17);

	double xmin = center.x - radiusX; // x coordinate of the upper left corner of the bounding rectangle
	double ymin = center.y - radiusY; // y coordinate of the upper left corner of the bounding rectangle
	double xmax = center.x + radiusX; // x coordinate of the bottom right corner of the bounding rectangle
	double ymax = center.y + radiusY; // y coordinate of the bottom right corner of the bounding rectangle
	const double C1 = 0.1465;		  // magic number for coefficient1
	const double C2 = 0.2070;		  // magic number for coefficient2
	double dx = xmax - xmin;		  // dx is width diameter
	double dy = ymax - ymin;		  // dy is height diameter
	const double begin = 0.8535;	  // starting position to draw (bounding square is 1x1)

	double c1dx = (double)(C1 * dx);
	double c1dy = (double)(C1 * dy);
	double c2dx = (double)(C2 * dx);
	double c2dy = (double)(C2 * dy);

	points[0] = TThickPoint(xmin + begin * dx, ymin + begin * dy, thick);

	points[1] = points[0] + TThickPoint(-c1dx, c1dy, 0);  //
	points[2] = points[1] + TThickPoint(-c2dx, 0, 0);	 //
	points[3] = points[2] + TThickPoint(-c2dx, 0, 0);	 //
	points[4] = points[3] + TThickPoint(-c1dx, -c1dy, 0); //
	points[5] = points[4] + TThickPoint(-c1dx, -c1dy, 0); //
	points[6] = points[5] + TThickPoint(0, -c2dy, 0);	 //
	points[7] = points[6] + TThickPoint(0, -c2dy, 0);	 //
	points[8] = points[7] + TThickPoint(c1dx, -c1dy, 0);  //
	points[9] = points[8] + TThickPoint(c1dx, -c1dy, 0);  //
	points[10] = points[9] + TThickPoint(c2dx, 0, 0);	 //
	points[11] = points[10] + TThickPoint(c2dx, 0, 0);	//
	points[12] = points[11] + TThickPoint(c1dx, c1dy, 0); //
	points[13] = points[12] + TThickPoint(c1dx, c1dy, 0); //
	points[14] = points[13] + TThickPoint(0, c2dy, 0);	//
	points[15] = points[14] + TThickPoint(0, c2dy, 0);	//
	points[16] = points[0];								  // need to be closed!!!
														  //points[15]+TThickPoint(-c1dx,  c1dy,0);//

	TStroke *stroke = new TStroke(points);
	stroke->setSelfLoop();
	return stroke;
}