#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);
}