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