// Glew include
#include <GL/glew.h>

// TnzCore includes
#include "tgl.h"

// Qt includes
#include <QCoreApplication>
#include <QThread>
#include <QDateTime>

#include <QGLPixelBuffer>
#include <QGLFramebufferObject>
#include <QGLShaderProgram>

// STD includes
#include <map>
#include <memory>

#include "stdfx/shadingcontext.h"

//*****************************************************************
//    Local Namespace stuff
//*****************************************************************

namespace
{

typedef std::auto_ptr<QGLPixelBuffer> QGLPixelBufferP;
typedef std::auto_ptr<QGLFramebufferObject> QGLFramebufferObjectP;
typedef std::auto_ptr<QGLShaderProgram> QGLShaderProgramP;

struct CompiledShader {
	QGLShaderProgramP m_program;
	QDateTime m_lastModified;

public:
	CompiledShader() {}
	CompiledShader(const CompiledShader &)
	{
		assert(!m_program.get());
	}
};

} // namespace

//*****************************************************************
//    ShadingContext::Imp  definition
//*****************************************************************

struct ShadingContext::Imp {
	QGLPixelBufferP m_pixelBuffer; //!< OpenGL context.
	QGLFramebufferObjectP m_fbo;   //!< Output buffer.

	std::map<QString,
			 CompiledShader> m_shaderPrograms; //!< Shader Programs stored in the context.
											   //!  \warning   Values have \p auto_ptr members.
public:
	Imp();

	static QGLFormat format();

	void initMatrix(int lx, int ly);

private:
	// Not copyable
	Imp(const Imp &);
	Imp &operator=(const Imp &);
};

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

ShadingContext::Imp::Imp()
	: m_pixelBuffer(new QGLPixelBuffer(1, 1, format()))
{
}

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

QGLFormat ShadingContext::Imp::format()
{
	QGLFormat fmt;

#ifdef MACOSX
	fmt.setVersion(3, 2);
	fmt.setProfile(QGLFormat::CompatibilityProfile);
#endif

	return fmt;
}

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

void ShadingContext::Imp::initMatrix(int lx, int ly)
{
	glViewport(0, 0, lx, ly);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluOrtho2D(0, lx, 0, ly);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

//*****************************************************************
//    ShadingContext  implementation
//*****************************************************************

ShadingContext::ShadingContext()
	: m_imp(new Imp)
{
	makeCurrent();
	glewExperimental = GL_TRUE;
	glewInit();
	doneCurrent();
}

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

ShadingContext::~ShadingContext()
{
	delete m_imp;
}

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

ShadingContext::Support ShadingContext::support()
{
	return !QGLPixelBuffer::hasOpenGLPbuffers() ? NO_PIXEL_BUFFER : !QGLShaderProgram::hasOpenGLShaderPrograms() ? NO_SHADERS : OK;
}

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

bool ShadingContext::isValid() const
{
	return m_imp->m_pixelBuffer->isValid();
}

//--------------------------------------------------------
/*
QGLFormat ShadingContext::defaultFormat(int channelsSize)
{
  QGL::FormatOptions opts =
    QGL::SingleBuffer     |
    QGL::NoAccumBuffer    |
    QGL::NoDepthBuffer    |                           // I guess it could be necessary to let at least
    QGL::NoOverlay        |                           // the depth buffer enabled... Fragment shaders could
    QGL::NoSampleBuffers  |                           // use it...
    QGL::NoStencilBuffer  |
    QGL::NoStereoBuffers;

  QGLFormat fmt(opts);
  fmt.setDirectRendering(true);                       // Just to be explicit - USE HARDWARE ACCELERATION

  fmt.setRedBufferSize(channelsSize);
  fmt.setGreenBufferSize(channelsSize);
  fmt.setBlueBufferSize(channelsSize);
  fmt.setAlphaBufferSize(channelsSize);

  // TODO: 64-bit mode should be settable here

  return fmt;
}
*/
//--------------------------------------------------------

void ShadingContext::makeCurrent()
{
	m_imp->m_pixelBuffer->makeCurrent();
}

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

void ShadingContext::doneCurrent()
{
	m_imp->m_pixelBuffer->doneCurrent();
}

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

void ShadingContext::resize(int lx, int ly, const QGLFramebufferObjectFormat &fmt)
{
	if (m_imp->m_fbo.get() &&
		m_imp->m_fbo->width() == lx &&
		m_imp->m_fbo->height() == ly &&
		m_imp->m_fbo->format() == fmt)
		return;

	if (lx == 0 || ly == 0) {
		m_imp->m_fbo.reset(0);
	} else {
		m_imp->m_fbo.reset(new QGLFramebufferObject(lx, ly, fmt));
		assert(m_imp->m_fbo->isValid());

		m_imp->m_fbo->bind();
	}
}

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

QGLFramebufferObjectFormat ShadingContext::format() const
{
	QGLFramebufferObject *fbo = m_imp->m_fbo.get();
	return fbo ? m_imp->m_fbo->format() : QGLFramebufferObjectFormat();
}

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

TDimension ShadingContext::size() const
{
	QGLFramebufferObject *fbo = m_imp->m_fbo.get();
	return fbo ? TDimension(fbo->width(), fbo->height()) : TDimension();
}

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

void ShadingContext::addShaderProgram(
	const QString &shaderName, QGLShaderProgram *program)
{
	std::map<QString, CompiledShader>::iterator st =
		m_imp->m_shaderPrograms.insert(std::make_pair(shaderName, CompiledShader())).first;

	st->second.m_program.reset(program);
}

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

void ShadingContext::addShaderProgram(
	const QString &shaderName, QGLShaderProgram *program, const QDateTime &lastModified)
{
	std::map<QString, CompiledShader>::iterator st =
		m_imp->m_shaderPrograms.insert(std::make_pair(shaderName, CompiledShader())).first;

	st->second.m_program.reset(program);
	st->second.m_lastModified = lastModified;
}

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

bool ShadingContext::removeShaderProgram(const QString &shaderName)
{
	return (m_imp->m_shaderPrograms.erase(shaderName) > 0);
}

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

QGLShaderProgram *ShadingContext::shaderProgram(const QString &shaderName) const
{
	std::map<QString, CompiledShader>::iterator st =
		m_imp->m_shaderPrograms.find(shaderName);

	return (st != m_imp->m_shaderPrograms.end()) ? st->second.m_program.get() : 0;
}

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

QDateTime ShadingContext::lastModified(const QString &shaderName) const
{
	std::map<QString, CompiledShader>::iterator st =
		m_imp->m_shaderPrograms.find(shaderName);

	return (st != m_imp->m_shaderPrograms.end()) ? st->second.m_lastModified : QDateTime();
}

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

std::pair<QGLShaderProgram *, QDateTime> ShadingContext::shaderData(
	const QString &shaderName) const
{
	std::map<QString, CompiledShader>::iterator st =
		m_imp->m_shaderPrograms.find(shaderName);

	return (st != m_imp->m_shaderPrograms.end()) ? std::make_pair(st->second.m_program.get(), st->second.m_lastModified) : std::make_pair((QGLShaderProgram *)0, QDateTime());
}

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

GLuint ShadingContext::loadTexture(const TRasterP &src, GLuint texUnit)
{
	glActiveTexture(GL_TEXTURE0 + texUnit);

	GLuint texId;
	glGenTextures(1, &texId);
	glBindTexture(GL_TEXTURE_2D, texId);

	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);	   // These must be used on a bound texture,
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);	   // and are remembered in the OpenGL context.
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // They can be set here, no need for
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); // the user to do it.

	glPixelStorei(GL_UNPACK_ROW_LENGTH, src->getWrap());
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	GLenum chanType = TRaster32P(src) ? GL_UNSIGNED_BYTE : GL_UNSIGNED_SHORT;

	glTexImage2D(GL_TEXTURE_2D,
				 0,			   // one level only
				 GL_RGBA,	  // pixel channels count
				 src->getLx(), // width
				 src->getLy(), // height
				 0,			   // border size
				 TGL_FMT,	  // pixel format
				 chanType,	 // channel data type
				 (GLvoid *)src->getRawData());

	assert(glGetError() == GL_NO_ERROR);

	return texId;
}

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

void ShadingContext::unloadTexture(GLuint texId)
{
	glDeleteTextures(1, &texId);
}

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

void ShadingContext::draw(const TRasterP &dst)
{
	assert("ShadingContext::resize() must be invoked at least once before this" && m_imp->m_fbo.get());

	int lx = dst->getLx(), ly = dst->getLy(); // NOTE: We're not using m_imp->m_fbo's size, since
											  // it could be possibly greater than the required
											  // destination surface.

	m_imp->initMatrix(lx, ly); // This call sets the OpenGL viewport to this
							   // size - and matches (1, 1) to dst's (lx, ly)

	{
		glBegin(GL_QUADS);

		glVertex2f(0.0, 0.0);
		glVertex2f(lx, 0.0);
		glVertex2f(lx, ly);
		glVertex2f(0.0, ly);

		glEnd();
	}

	glPixelStorei(GL_PACK_ROW_LENGTH, dst->getWrap());

	// Read the fbo to dst
	if (TRaster32P ras32 = dst)
		glReadPixels(0, 0, lx, ly, GL_BGRA_EXT, GL_UNSIGNED_BYTE, dst->getRawData());
	else {
		assert(TRaster64P(dst));
		glReadPixels(0, 0, lx, ly, GL_BGRA_EXT, GL_UNSIGNED_SHORT, dst->getRawData());
	}

	assert(glGetError() == GL_NO_ERROR);
}

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

void ShadingContext::transformFeedback(
	int varyingsCount, const GLsizeiptr *varyingSizes, GLvoid **bufs)
{
	// Generate buffer objects
	std::vector<GLuint> bufferObjectNames(varyingsCount, 0);

	glGenBuffers(varyingsCount, &bufferObjectNames[0]);

	for (int v = 0; v != varyingsCount; ++v) {
		glBindBuffer(GL_ARRAY_BUFFER, bufferObjectNames[v]);
		glBufferData(GL_ARRAY_BUFFER, varyingSizes[v], bufs[v], GL_STATIC_READ);
		glBindBuffer(GL_ARRAY_BUFFER, 0);

		glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, v, bufferObjectNames[v]);
	}

	// Draw
	GLuint Query = 0;

	glGenQueries(1, &Query);
	{
		// Disable rasterization, vertices processing only!
		glEnable(GL_RASTERIZER_DISCARD);
		glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, Query);

		glBeginTransformFeedback(GL_POINTS);
		glBegin(GL_POINTS);
		glVertex2f(0.0f, 0.0f);
		glEnd();
		glEndTransformFeedback();

		glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);
		glDisable(GL_RASTERIZER_DISCARD);
	}

	GLint count = 0;
	glGetQueryObjectiv(Query, GL_QUERY_RESULT, &count);

	glDeleteQueries(1, &Query);

	// Retrieve transformed data
	for (int v = 0; v != varyingsCount; ++v) {
		glBindBuffer(GL_ARRAY_BUFFER, bufferObjectNames[v]);
		glGetBufferSubData(GL_ARRAY_BUFFER, 0, varyingSizes[v], bufs[v]);
	}

	glBindBuffer(GL_ARRAY_BUFFER, 0);

	// Delete buffer objects
	glDeleteBuffers(varyingsCount, &bufferObjectNames[0]);
}