#include "ttoonzimage.h"
#include "tpalette.h"
//#include "ttile.h"
//#include "transparencyCheck.h"

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

TToonzImage::TToonzImage()
    : m_ras()
    , m_dpix(0)
    , m_dpiy(0)
    , m_subsampling(1)
    , m_name("")
    , m_savebox()
    //, m_hPos(0.0)
    , m_offset(0, 0)
    , m_size() {}

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

TToonzImage::TToonzImage(const TRasterCM32P &ras, const TRect &saveBox)
    : m_ras(ras)
    , m_size(ras->getSize())
    , m_dpix(0)
    , m_dpiy(0)
    , m_subsampling(1)
    , m_name("")
    , m_savebox(saveBox)
    //, m_hPos(0.0)
    , m_offset(0, 0) {
  assert(ras->getBounds().contains(saveBox));
}

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

TToonzImage::TToonzImage(const TToonzImage &src)
    : m_ras(TRasterCM32P())
    , m_dpix(src.m_dpix)
    , m_dpiy(src.m_dpiy)
    , m_subsampling(src.m_subsampling)
    , m_name(src.m_name)
    , m_savebox(src.m_savebox)
    //, m_hPos(src.m_hPos)
    , m_offset(src.m_offset)
    , m_size(src.m_size) {
  if (src.m_ras)  // src non e' compressa
  {
    m_ras = src.m_ras->clone();
  } else {
    assert(false);
    assert(!src.m_ras);
  }

  TPalette *palette = src.getPalette();
  if (palette) {
    m_palette = palette->clone();
    m_palette->addRef();
  } else
    m_palette = 0;
}

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

TToonzImageP TToonzImage::clone() const { return TToonzImageP(cloneImage()); }

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

TToonzImage::~TToonzImage() {}

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

TImage *TToonzImage::cloneImage() const { return new TToonzImage(*this); }

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

void TToonzImage::setSubsampling(int s) { m_subsampling = s; }

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

void TToonzImage::setSavebox(const TRect &rect) {
  QMutexLocker sl(&m_mutex);

  // assert(m_lockCount>0);
  assert(m_ras);
  m_savebox = TRect(m_size) * rect;
  assert(TRect(m_size).contains(m_savebox));
}

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

namespace {

//---------------------------------------------------------
// il clipRect fa riferimento alle coordinate di rasIn
// se clipRect.isEmpty() allora aggiorna tutto

/*
void doUpdateRas32(const TRaster32P   &rasOut,
                   const TRasterCM32P &rasIn,
                   TPaletteP palette,
                   const TRect &theClipRect,
                                                                         bool
transparencyCheck,
                                                                         bool
applyFx)
{
  assert(palette);
  assert(rasIn && rasOut);

  applyFx = true;

  TRect clipRect(theClipRect);
  if(clipRect.isEmpty())
    clipRect = rasIn->getBounds();
  else
    {
     if(!clipRect.overlaps(rasIn->getBounds())) return;
     clipRect = clipRect * rasIn->getBounds();
    }
  if (clipRect.isEmpty())
    return;

        TRect clipRectIn, clipRectOut;

        if (applyFx && palette->getFxRects(clipRect, clipRectIn, clipRectOut))
          {
                TRect rAux = clipRectIn;
                TRasterP rAuxIn = rasIn->extract(clipRectIn);
                if (rAux!=clipRectIn && rAux!=rasIn->getBounds())
                  {
                        TRasterCM32P rNew(rAux.getSize());
                        TRect tmpRect = clipRectIn - rAux.getP00();
      rNew->extract(tmpRect)->copy(rAuxIn);
      rAuxIn = rNew;
                        clipRectIn = rAux;
                        }
    TTile tileIn(rAuxIn, convert(clipRectIn.getP00()));

                rAux = clipRectOut;
    TRasterP rAuxOut = rasOut->extract(clipRectOut);
    TTile tileOut(rAuxOut, convert(clipRectOut.getP00()));
    TRop::convert(tileOut, tileIn, palette, transparencyCheck, true);
    }
        else
          {
                TRect clipRectIn = clipRect;
                TRect clipRectOut = clipRect;
                TRasterP _rasOut = rasOut->extract(clipRectOut);
                TRasterP _rasIn;

                _rasIn = rasIn->extract(clipRectIn);

    TRop::convert(TTile(_rasOut, convert(clipRectOut.getP00())),
                              TTile(_rasIn,  convert(clipRectIn.getP00())),
                                                                        palette,
transparencyCheck, false);
                }
}

*/

}  // anonymous namespace

//---------------------------------------------------------
/*
TRaster32P TToonzImage::getRGBM(bool readOnly, bool computeFx)
{

  if (readOnly)
  {
    QMutexLocker sl(m_mutex);

    if (m_ras32)
      return m_ras32->clone();

    TRasterCM32P rasCM32;
    if (m_ras)
      rasCM32 = m_ras;
    else
      rasCM32 = getCMapped(true);

    assert(rasCM32);

    TPalette *palette = getPalette();
    assert(palette);

    TRaster32P ras32(rasCM32->getSize());
    const TPixel32 bgColor(255,255,255,0);
    ras32->fillOutside(m_savebox, bgColor);

    doUpdateRas32(ras32, rasCM32, palette, m_savebox, false, computeFx);
    return ras32;
  }
  else
  {
    QMutexLocker sl(m_mutex);
    return m_ras32;
  }
}
*/
//---------------------------------------------------------

TRasterCM32P TToonzImage::getCMapped(/*bool readOnly*/) const {
  /*
if (readOnly)
{
{
QMutexLocker sl(m_mutex);
if (m_ras)
  return m_ras->clone();
}

return decompress();
}
else
*/
  {
    // QMutexLocker sl(&m_mutex);
    return m_ras;
  }
}

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

void TToonzImage::setCMapped(const TRasterCM32P &ras) {
  QMutexLocker sl(&m_mutex);
  m_ras     = ras;
  m_size    = ras->getSize();
  m_savebox = ras->getBounds();
  // delete [] m_compressedBuffer;
  // m_compressedBuffer = 0;
  // m_compressedBufferSize = 0;
}

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

void TToonzImage::getCMapped(const TRasterCM32P &ras) {
  assert(ras && ras->getSize() == m_size);

  QMutexLocker sl(&m_mutex);
  if (m_ras) ras->copy(m_ras);
  /*
else
decompress(ras);
*/
}