#include "toonz/glrasterpainter.h"

#include "tgl.h"

#include "texturemanager.h"

#include "tpalette.h"

#include "tropcm.h"

#include "tvectorimage.h"

#include "tvectorrenderdata.h"

#include "tvectorgl.h"

namespace

{

void doDrawRaster(const TAffine &aff,

				  UCHAR *buffer, int wrap, int bpp, const TDimension &rasDim,

				  const TRect &bbox,

				  bool showBBox,

				  GLenum magFilter,

				  GLenum minFilter,

				  bool premultiplied)

{

	if (!buffer)

		return;

	bool isRGBM = (bpp == 4);

	if (!isRGBM) {

		if (bpp != 1)

			return;

	}

	TDimension maxSize = TextureManager::instance()->getMaxSize(isRGBM);

	if (bbox.getLx() > maxSize.lx) {

		TRect leftBox(bbox.getP00(), TDimension(maxSize.lx, bbox.getLy()));

		TRect rightBox(TPoint(bbox.getP00().x + maxSize.lx, bbox.getP00().y), bbox.getP11());

		assert(leftBox.getLx() == maxSize.lx);

		assert(rightBox.getLx() == bbox.getLx() - maxSize.lx);

		assert(leftBox.getLy() == bbox.getLy());

		assert(rightBox.getLy() == bbox.getLy());

		doDrawRaster(aff, buffer, wrap, bpp, rasDim, leftBox, showBBox, magFilter, minFilter, premultiplied);

		doDrawRaster(aff, buffer, wrap, bpp, rasDim, rightBox, showBBox, magFilter, minFilter, premultiplied);

		return;

	}

	if (bbox.getLy() > maxSize.ly) {

		TRect bottomBox(bbox.getP00(), TDimension(bbox.getLx(), maxSize.ly));

		TRect topBox(TPointI(bbox.getP00().x, bbox.getP00().y + maxSize.ly), bbox.getP11());

		assert(bottomBox.getLy() == maxSize.ly);

		assert(topBox.getLy() == bbox.getLy() - maxSize.ly);

		assert(bottomBox.getLx() == bbox.getLx());

		assert(topBox.getLx() == bbox.getLx());

		doDrawRaster(aff, buffer, wrap, bpp, rasDim, bottomBox, showBBox, magFilter, minFilter, premultiplied);

		doDrawRaster(aff, buffer, wrap, bpp, rasDim, topBox, showBBox, magFilter, minFilter, premultiplied);

		return;

	}

	glPushMatrix();

	TTranslation T((bbox.getP00().x - (rasDim.lx - bbox.getLx()) / 2.),

				   (bbox.getP00().y - (rasDim.ly - bbox.getLy()) / 2.));

	tglMultMatrix(aff * T);

	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);

	glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);

	glTexEnvf(GL_TEXTURE_ENV,

			  GL_TEXTURE_ENV_MODE,

			  GL_REPLACE);

	glEnable(GL_TEXTURE_2D);

	glEnable(GL_BLEND);

	if (premultiplied)

		glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);

	else

		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	TDimension ts = TextureManager::instance()->selectTexture(bbox.getSize(), isRGBM);

	GLenum fmt, type;

	TextureManager::instance()->getFmtAndType(isRGBM, fmt, type);

	int width = bbox.getLx();

	int height = bbox.getLy();

	int y = bbox.getP00().y;

	int x = bbox.getP00().x;

	buffer += (x + y * wrap) * bpp;

	glPixelStorei(GL_UNPACK_ROW_LENGTH, wrap);

	glTexSubImage2D(

		GL_TEXTURE_2D, // target (is a 2D texture)

		0,			   // is one level only

		0,

		0,

		width,

		height,

		fmt,

		type,

		buffer);

	CHECK_ERRORS_BY_GL

	double halfWidth = 0.5 * bbox.getLx();

	double halfHeight = 0.5 * bbox.getLy();

	TPointD v0((-halfWidth), (-halfHeight));

	TPointD v1((halfWidth), (-halfHeight));

	TPointD v2((-halfWidth), (halfHeight));

	TPointD v3((halfWidth), (halfHeight));

	double s = (bbox.getLx()) / (double)ts.lx;

	double t = (bbox.getLy()) / (double)ts.ly;

	glColor3d(0, 0, 0);

	glBegin(GL_QUAD_STRIP);

	glTexCoord2d(0, 0);

	glVertex2d(v0.x, v0.y);

	glTexCoord2d(s, 0);

	glVertex2d(v1.x, v1.y);

	glTexCoord2d(0, t);

	glVertex2d(v2.x, v2.y);

	glTexCoord2d(s, t);

	glVertex2d(v3.x, v3.y);

	glEnd();

	glDisable(GL_BLEND);

	glDisable(GL_TEXTURE_2D);

	if (showBBox) {

		glBegin(GL_LINE_LOOP);

		glVertex2d(v0.x, v0.y);

		glVertex2d(v1.x, v1.y);

		glVertex2d(v3.x, v3.y);

		glVertex2d(v2.x, v2.y);

		glEnd();

	}

	glPopMatrix();

}

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

void doDrawRaster(const TAffine &aff,

				  const TRasterImageP &ri,

				  const TRectI &bbox,

				  bool showBBox,

				  GLenum magFilter,

				  GLenum minFilter,

				  bool premultiplied)

{

	TRasterP r = ri->getRaster();

	r->lock();

	doDrawRaster(aff,

				 r->getRawData(), r->getWrap(), r->getPixelSize(),

				 r->getSize(),

				 bbox,

				 showBBox,

				 magFilter,

				 minFilter,

				 premultiplied);

	r->unlock();

}

} //namespace

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

void GLRasterPainter::drawRaster(const TAffine &aff, UCHAR *buffer, int wrap, int bpp, const TDimension &rasSize, bool premultiplied)

{

	if (!buffer)

		return;

	doDrawRaster(

		aff, buffer, wrap, bpp, rasSize, rasSize,

		false, GL_NEAREST, GL_LINEAR, premultiplied);

}

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

void GLRasterPainter::drawRaster(const TAffine &aff, const TRasterImageP &ri, bool premultiplied)

{

	if (!ri || !ri->getRaster())

		return;

	doDrawRaster(

		aff, ri, ri->getRaster()->getBounds(),

		false, GL_NEAREST, GL_LINEAR, premultiplied);

}

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

void GLRasterPainter::drawRaster(const TAffine &aff, const TToonzImageP &ti, bool showSavebox)

{

	TRect saveBox = ti->getSavebox();

	if (saveBox.isEmpty())

		return;

	TRasterCM32P ras = ti->getRaster();

	TPaletteP palette = ti->getPalette();

	TRaster32P ras32(ras->getSize());

	TRop::convert(ras32, ras, palette, saveBox);

	TRasterImageP rasImg(ras32);

	double dpix, dpiy;

	ti->getDpi(dpix, dpiy);

	rasImg->setDpi(dpix, dpiy);

	bool premultiplied = true;

	doDrawRaster(aff, rasImg, saveBox, showSavebox, GL_NEAREST, GL_LINEAR, premultiplied);

}