#include "tgl.h"
 
#include "tconvert.h"
#include "tofflinegl.h"
#include "trop.h"
#include "timage_io.h"
#include "tcurves.h"
 
#ifndef __sgi
#ifdef _WIN32
#include <cstdlib>
#include <GL/glut.h>
#elif defined(LINUX)
#include <GL/glut.h>
#else
#include <GLUT/glut.h>
#endif
#endif
 
#if defined(MACOSX) || defined(LINUX)
#include <QGLContext>
#endif
 
//#include "tthread.h"
 
#undef SCALE_BY_GLU
//#undef NEW_DRAW_TEXT
 
//-----------------------------------------------------------------------------
 
namespace
{
 
// GLUquadric*  localDisk=0;
 
/*
  Find the number of slices in function of radius size.
  \par radius of circle 
  \par size of pixel
  \ret number of division to obtain a circle
  */
int computeSlices(double radius, double pixelSize = 1.0)
{
	if (radius < 0)
		return 2;
 
	double thetaStep;
	double temp = pixelSize * 0.5 / radius;
 
	if (fabs(1.0 - temp) <= 1)
		thetaStep = acos(1.0 - temp);
	else
		thetaStep = M_PI_4;
 
	assert(thetaStep != 0.0);
 
	int numberOfSlices = (int)(M_2PI / thetaStep);
 
	return numberOfSlices != 0 ? numberOfSlices : 2;
}
} // end of unnamed namespace
 
//-----------------------------------------------------------------------------
 
double tglGetPixelSize2()
{
	double mat[16];
	glMatrixMode(GL_MODELVIEW);
	glGetDoublev(GL_MODELVIEW_MATRIX, mat);
 
	double det = fabs(mat[0] * mat[5] - mat[1] * mat[4]);
	if (det < TConsts::epsilon)
		det = TConsts::epsilon;
	return 1.0 / det;
}
 
//-----------------------------------------------------------------------------
 
double tglGetTextWidth(const std::string &s, void *font)
{
	double factor = 0.07;
	double w = 0;
	for (int i = 0; i < (int)s.length(); i++)
		w += glutStrokeWidth(font, s[i]);
	return w * factor;
}
 
//-----------------------------------------------------------------------------
 
void tglDrawText(const TPointD &p, const std::string &s, void *character)
{
#ifndef __sgi
	glPushMatrix();
	glTranslated(p.x, p.y, 0);
	double factor = 0.07;
	glScaled(factor, factor, factor);
	for (int i = 0; i < (int)s.size(); i++)
		glutStrokeCharacter(character, s[i]);
	glPopMatrix();
#else
	assert("Not Yet Implemented" && 0);
	std::cout << s << std::endl;
#endif
}
 
//-----------------------------------------------------------------------------
 
void tglDrawText(const TPointD &p, const std::wstring &s, void *character)
{
#ifndef __sgi
	glPushMatrix();
	glTranslated(p.x, p.y, 0);
	double factor = 0.07;
	glScaled(factor, factor, factor);
	for (int i = 0; i < (int)s.size(); i++)
		glutStrokeCharacter(character, s[i]);
	glPopMatrix();
#else
	assert("Not Yet Implemented" && 0);
	std::cout << s << std::endl;
#endif
}
 
//-----------------------------------------------------------------------------
 
void tglDrawSegment(const TPointD &p1, const TPointD &p2)
{
	glBegin(GL_LINES);
	tglVertex(p1);
	tglVertex(p2);
	glEnd();
}
 
//-----------------------------------------------------------------------------
 
void tglDrawCircle(const TPointD &center, double radius)
{
	if (radius <= 0)
		return;
 
	double pixelSize = 1;
	int slices = 60;
 
	if (slices <= 0)
		slices = computeSlices(radius, pixelSize) >> 1;
 
	double step = M_PI / slices;
	double step2 = 2.0 * step;
 
	double
		cos_t,
		sin_t,
		cos_ts, sin_ts, t;
 
	glPushMatrix();
	glTranslated(center.x, center.y, 0.0);
	glBegin(GL_LINES);
 
	cos_t = radius /* *1.0*/;
	sin_t = 0.0;
	for (t = 0; t + step < M_PI_2; t += step2) {
		cos_ts = radius * cos(t + step);
		sin_ts = radius * sin(t + step);
 
		glVertex2f(cos_t, sin_t);
		glVertex2f(cos_ts, sin_ts);
 
		glVertex2f(-cos_t, sin_t);
		glVertex2f(-cos_ts, sin_ts);
 
		glVertex2f(-cos_t, -sin_t);
		glVertex2f(-cos_ts, -sin_ts);
 
		glVertex2f(cos_t, -sin_t);
		glVertex2f(cos_ts, -sin_ts);
 
		cos_t = cos_ts;
		sin_t = sin_ts;
	}
 
	cos_ts = 0.0;
	sin_ts = radius /* *1.0*/;
 
	glVertex2f(cos_t, sin_t);
	glVertex2f(cos_ts, sin_ts);
 
	glVertex2f(-cos_t, sin_t);
	glVertex2f(-cos_ts, sin_ts);
 
	glVertex2f(-cos_t, -sin_t);
	glVertex2f(-cos_ts, -sin_ts);
 
	glVertex2f(cos_t, -sin_t);
	glVertex2f(cos_ts, -sin_ts);
 
	glEnd();
	glPopMatrix();
}
 
//-----------------------------------------------------------------------------
 
void tglDrawDisk(const TPointD &c, double r)
{
	if (r <= 0)
		return;
 
	double pixelSize = 1;
	int slices = 60;
 
	if (slices <= 0)
		slices = computeSlices(r, pixelSize) >> 1;
 
	glPushMatrix();
	glTranslated(c.x, c.y, 0.0);
	GLUquadric *quadric = gluNewQuadric();
	gluDisk(quadric, 0, r, slices, 1);
	gluDeleteQuadric(quadric);
	glPopMatrix();
}
 
//-----------------------------------------------------------------------------
 
void tglDrawRect(const TRectD &rect)
{
	glBegin(GL_LINE_LOOP);
	tglVertex(rect.getP00());
	tglVertex(rect.getP10());
	tglVertex(rect.getP11());
	tglVertex(rect.getP01());
	glEnd();
}
 
//-----------------------------------------------------------------------------
 
void tglFillRect(const TRectD &rect)
{
	glBegin(GL_POLYGON);
	tglVertex(rect.getP00());
	tglVertex(rect.getP10());
	tglVertex(rect.getP11());
	tglVertex(rect.getP01());
	glEnd();
}
//-----------------------------------------------------------------------------
 
void tglRgbOnlyColorMask()
{
	tglMultColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_FALSE);
	tglEnableBlending(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}
 
//-----------------------------------------------------------------------------
 
void tglAlphaOnlyColorMask()
{
	tglMultColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_TRUE);
	tglEnableBlending(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}
 
//-----------------------------------------------------------------------------
 
void tglEnableBlending(GLenum src, GLenum dst)
{
	glEnable(GL_BLEND);
	glBlendFunc(src, dst);
}
 
//-----------------------------------------------------------------------------
 
void tglEnableLineSmooth(bool enable, double lineSize)
{
	if (enable) {
		glHint(GL_LINE_SMOOTH_HINT, GL_NICEST);
		glEnable(GL_LINE_SMOOTH);
		glLineWidth(lineSize);
	} else
		glDisable(GL_LINE_SMOOTH);
}
 
//-----------------------------------------------------------------------------
 
void tglEnablePointSmooth(double pointSize)
{
	glEnable(GL_BLEND);
	glPointSize(pointSize);
}
 
//-----------------------------------------------------------------------------
 
void tglGetColorMask(GLboolean &red, GLboolean &green, GLboolean &blue, GLboolean &alpha)
{
	GLboolean channels[4];
	glGetBooleanv(GL_COLOR_WRITEMASK, &channels[0]);
	red = channels[0], green = channels[1], blue = channels[2], alpha = channels[3];
}
 
//-----------------------------------------------------------------------------
 
void tglMultColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
	GLboolean channels[4];
	glGetBooleanv(GL_COLOR_WRITEMASK, &channels[0]);
	glColorMask(red && channels[0],
				green && channels[1],
				blue && channels[2],
				alpha && channels[3]);
}
 
//============================================================================
 
namespace
{
//============================================================================
 
class GlFontManager
{
	GlFontManager();
 
public:
	~GlFontManager();
	static GlFontManager *instance();
	bool setFont(void *font = GLUT_BITMAP_TIMES_ROMAN_10);
	void drawText(/*const TRectD bBox,*/
				  std::wstring wtext /*,
                TDimensionD scale = TDimensionD(1.0, 1.0)*/);
 
private:
	static GlFontManager *m_instance;
 
	//       font    font_height
	//         |       |
	std::map<void *, double> m_fonts;
	std::vector<TRectD> m_charsBBox;
	void *m_currentFont;
	TRaster32P m_fontTexture;
	GLuint m_base;
};
 
//----------------------------------------------------------------------------
 
GlFontManager *GlFontManager::m_instance = 0L;
 
//----------------------------------------------------------------------------
 
GlFontManager::GlFontManager()
	: m_currentFont(0L), m_base(0)
{
	m_fonts.insert(std::make_pair(GLUT_BITMAP_8_BY_13, 13.0));
	m_fonts.insert(std::make_pair(GLUT_BITMAP_9_BY_15, 15.0));
	m_fonts.insert(std::make_pair(GLUT_BITMAP_TIMES_ROMAN_10, 10.0));
	m_fonts.insert(std::make_pair(GLUT_BITMAP_TIMES_ROMAN_24, 24.0));
	m_fonts.insert(std::make_pair(GLUT_BITMAP_HELVETICA_10, 10.0));
	m_fonts.insert(std::make_pair(GLUT_BITMAP_HELVETICA_12, 12.0));
	m_fonts.insert(std::make_pair(GLUT_BITMAP_HELVETICA_18, 18.0));
	bool ok = setFont();
	assert(ok);
}
 
//----------------------------------------------------------------------------
 
GlFontManager::~GlFontManager()
{
	m_instance = 0L;
}
 
//----------------------------------------------------------------------------
 
GlFontManager *GlFontManager::instance()
{
	if (!m_instance)
		m_instance = new GlFontManager();
 
	return m_instance;
}
 
//----------------------------------------------------------------------------
 
bool GlFontManager::setFont(void *font)
{
	// cerca il font scelto nella mappa dei fonts conosciuti
	std::map<void *, double>::iterator it =
		m_fonts.find(font);
 
	// se e' stato trovato
	if (it != m_fonts.end()) {
		m_currentFont = font;
 
		glPushAttrib(GL_ALL_ATTRIB_BITS);
		glPushMatrix();
		m_base = glGenLists(256);
		glListBase(m_base);
		int i = 0;
		for (; i < 256; ++i) {
			glNewList(m_base + i, GL_COMPILE);
			glutStrokeCharacter(GLUT_STROKE_ROMAN, i);
			//glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, i);
			glEndList();
		}
		glPopAttrib();
		glPopMatrix();
		return true;
	}
	return false;
}
 
//----------------------------------------------------------------------------
 
void GlFontManager::drawText(/*const TRectD bBox,*/
							 std::wstring wtext /*,
                             TDimensionD scale*/)
{
	if (!m_currentFont)
		return;
 
	std::string text = ::to_string(wtext);
	const char *textString = text.c_str();
	glListBase(m_base);
	/*
  glPushMatrix();
  glTranslated(bBox.x0, bBox.y0, 0.0);
  glScaled(scale.lx*0.07, scale.ly*0.07, 1.0);
  */
	glCallLists((GLuint)strlen(textString), GL_BYTE, textString);
	/*glPopMatrix();*/
}
 
//============================================================================
 
} // anonymous namespace
 
//============================================================================
 
void tglDraw(const TCubic &cubic, int precision, GLenum pointOrLine)
{
	CHECK_ERRORS_BY_GL;
	assert(pointOrLine == GL_POINT || pointOrLine == GL_LINE);
	float ctrlPts[4][3];
 
	ctrlPts[0][0] = cubic.getP0().x;
	ctrlPts[0][1] = cubic.getP0().y;
	ctrlPts[0][2] = 0.0;
 
	ctrlPts[1][0] = cubic.getP1().x;
	ctrlPts[1][1] = cubic.getP1().y;
	ctrlPts[1][2] = 0.0;
 
	ctrlPts[2][0] = cubic.getP2().x;
	ctrlPts[2][1] = cubic.getP2().y;
	ctrlPts[2][2] = 0.0;
 
	ctrlPts[3][0] = cubic.getP3().x;
	ctrlPts[3][1] = cubic.getP3().y;
	ctrlPts[3][2] = 0.0;
 
	CHECK_ERRORS_BY_GL;
	glMap1f(GL_MAP1_VERTEX_3, 0.0, 1.0, 3, 4, &ctrlPts[0][0]);
	CHECK_ERRORS_BY_GL;
	glEnable(GL_MAP1_VERTEX_3);
	CHECK_ERRORS_BY_GL;
	glMapGrid1f(precision, 0.0, 1.0);
	CHECK_ERRORS_BY_GL;
	glEvalMesh1(pointOrLine, 0, precision);
	CHECK_ERRORS_BY_GL;
}
 
//-----------------------------------------------------------------------------
 
void tglDraw(const TRectD &rect,
			 const std::vector<TRaster32P> &textures,
			 bool blending)
{
	double pixelSize2 = tglGetPixelSize2();
	// level e' la minore potenza di 2 maggiore di sqrt(pixelSize2)
	unsigned int level = 1;
	while (pixelSize2 * level * level <= 1.0)
		level <<= 1;
 
	unsigned int texturesCount = (int)textures.size();
	if (level > texturesCount)
		level = texturesCount;
 
	level = texturesCount - level;
 
	tglDraw(rect, textures[level], blending);
}
 
//-------------------------------------------------------------------
 
void tglDraw(const TRectD &rect, const TRaster32P &tex, bool blending)
{
	CHECK_ERRORS_BY_GL;
	glPushAttrib(GL_ALL_ATTRIB_BITS);
	if (blending) {
		glEnable(GL_BLEND);
		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	}
 
	unsigned int texWidth = 1;
	unsigned int texHeight = 1;
 
	while (texWidth < (unsigned int)tex->getLx())
		texWidth = texWidth << 1;
 
	while (texHeight < (unsigned int)tex->getLy())
		texHeight = texHeight << 1;
 
	double lwTex = 1.0;
	double lhTex = 1.0;
 
	TRaster32P texture;
	unsigned int texLx = (unsigned int)tex->getLx();
	unsigned int texLy = (unsigned int)tex->getLy();
 
	if (texWidth != texLx ||
		texHeight != texLy) {
		texture = TRaster32P(texWidth, texHeight);
		texture->fill(TPixel32(0, 0, 0, 0));
		texture->copy(tex);
		lwTex = (texLx) / (double)(texWidth);
		lhTex = (texLy) / (double)(texHeight);
		if (lwTex > 1.0)
			lwTex = 1.0;
		if (lhTex > 1.0)
			lhTex = 1.0;
	} else
		texture = tex;
	GLenum fmt =
#ifdef TNZ_MACHINE_CHANNEL_ORDER_BGRM
		GL_BGRA_EXT;
#elif TNZ_MACHINE_CHANNEL_ORDER_MBGR
		GL_ABGR_EXT;
#elif TNZ_MACHINE_CHANNEL_ORDER_RGBM
		GL_RGBA;
#elif TNZ_MACHINE_CHANNEL_ORDER_MRGB
		GL_BGRA;
#else
//   Error  PLATFORM NOT SUPPORTED
#error "unknown channel order!"
#endif
 
	// Generate a texture id and bind it.
	GLuint texId;
	glGenTextures(1, &texId);
 
	glBindTexture(GL_TEXTURE_2D, texId);
 
	glPixelStorei(GL_UNPACK_ROW_LENGTH, texture->getWrap());
 
	texture->lock();
	glTexImage2D(GL_TEXTURE_2D,
				 0,
				 4,
				 texWidth,
				 texHeight,
				 0,
				 fmt,
#ifdef TNZ_MACHINE_CHANNEL_ORDER_MRGB
				 GL_UNSIGNED_INT_8_8_8_8_REV,
#else
				 GL_UNSIGNED_BYTE,
#endif
				 texture->getRawData());
 
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 
	glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
	glEnable(GL_TEXTURE_2D);
 
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
 
	double rectLx = rect.getLx();
	double rectLy = rect.getLy();
 
	tglColor(TPixel32(0, 0, 0, 0));
 
	glPushMatrix();
 
	glTranslated(rect.x0, rect.y0, 0.0);
	glBegin(GL_POLYGON);
 
	glTexCoord2d(0, 0);
	tglVertex(TPointD(0.0, 0.0));
 
	glTexCoord2d(lwTex, 0);
	tglVertex(TPointD(rectLx, 0.0));
 
	glTexCoord2d(lwTex, lhTex);
	tglVertex(TPointD(rectLx, rectLy));
 
	glTexCoord2d(0, lhTex);
	tglVertex(TPointD(0.0, rectLy));
 
	glEnd();
	glDisable(GL_TEXTURE_2D);
 
	glPopMatrix();
	glPopAttrib();
 
	// Delete texture
	glDeleteTextures(1, &texId);
 
	texture->unlock();
}
 
//-----------------------------------------------------------------------------
 
void tglBuildMipmaps(std::vector<TRaster32P> &rasters,
					 const TFilePath &filepath)
{
	assert(rasters.size() > 0);
	TRop::ResampleFilterType resampleFilter = TRop::ClosestPixel;
	TRasterP ras;
	TImageReader::load(filepath, ras);
	int rasLx = ras->getLx();
	int rasLy = ras->getLy();
 
	int lx = 1;
	while (lx < rasLx)
		lx <<= 1;
 
	int ly = 1;
	while (ly < rasLy)
		ly <<= 1;
 
	TRaster32P ras2(lx, ly);
	double sx = (double)lx / (double)ras->getLx();
	double sy = (double)ly / (double)ras->getLy();
#ifndef SCALE_BY_GLU
	TRop::resample(ras2, ras, TScale(sx, sy), resampleFilter);
#else
	ras->lock();
	gluScaleImage(GL_RGBA, ras->getLx(), ras->getLy(), GL_UNSIGNED_BYTE, ras->getRawData(),
				  lx, ly, GL_UNSIGNED_BYTE, ras2->getRawData());
	ras->unlock();
#endif
 
	rasters[0] = ras2;
	int ras2Lx = ras2->getLx();
	int ras2Ly = ras2->getLy();
	for (int i = 1; i < (int)rasters.size(); ++i) {
		lx >>= 1;
		ly >>= 1;
		if (lx < 1)
			lx = 1;
		if (ly < 1)
			ly = 1;
		rasters[i] = TRaster32P(lx, ly);
		sx = (double)lx / (double)ras2Lx;
		sy = (double)ly / (double)ras2Ly;
		rasters[i] = TRaster32P(lx, ly);
#ifndef SCALE_BY_GLU
		TRop::resample(rasters[i], ras2, TScale(sx, sy), resampleFilter);
#else
		ras2->lock();
		gluScaleImage(GL_RGBA, ras->getLx(), ras->getLy(), GL_UNSIGNED_BYTE, ras2->getRawData(),
					  lx, ly, GL_UNSIGNED_BYTE, rasters[i]->getRawData());
		ras2->unlock();
#endif
	}
}
 
//-----------------------------------------------------------------------------
//Forse si potrebbe togliere l'ifdef ed usare QT
#if defined(_WIN32)
 
TGlContext tglGetCurrentContext()
{
	return std::make_pair(wglGetCurrentDC(), wglGetCurrentContext());
}
 
void tglMakeCurrent(TGlContext context)
{
	wglMakeCurrent(context.first, context.second);
}
 
void tglDoneCurrent(TGlContext)
{
	wglMakeCurrent(NULL, NULL);
}
 
#elif defined(LINUX) || defined(__sgi) || defined(MACOSX)
 
TGlContext tglGetCurrentContext()
{
	return reinterpret_cast<TGlContext>(
		const_cast<QGLContext *>(QGLContext::currentContext()));
 
	// (Daniele) I'm not sure why QGLContext::currentContext() returns
	// const. I think it shouldn't, and guess (hope) this is safe...
}
 
void tglMakeCurrent(TGlContext context)
{
	if (context)
		reinterpret_cast<QGLContext *>(context)->makeCurrent();
	else
		tglDoneCurrent(tglGetCurrentContext());
}
 
void tglDoneCurrent(TGlContext context)
{
	if (context)
		reinterpret_cast<QGLContext *>(context)->doneCurrent();
}
 
#else
#error "unknown platform!"
#endif
 
//-----------------------------------------------------------------------------
//  End Of File
//-----------------------------------------------------------------------------