#include "drawingdata.h"

#include "filmstripcommand.h"

#include "timagecache.h"

#include "tpaletteutil.h"

#include "ttoonzimage.h"

#include "tvectorimage.h"

#include "trasterimage.h"

#include "trop.h"

#include "tstroke.h"

#include "toonzqt/icongenerator.h"

#include "toonzqt/dvdialog.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/toonzimageutils.h"

#include "toonz/txshleveltypes.h"

#include "toonz/stage.h"

#include "toonz/tcenterlinevectorizer.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "vectorizerpopup.h"

#include <qapplication></qapplication>

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

// DrawingData

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

namespace {

// aggiorna gli hook: sono stati inseriti shiftRange (>0) drawings a partire da

// startFrameId

// quindi tutti i riferimenti a frameId >= startFrameId devono essere aggiornati

void shiftHooks(TXshSimpleLevel *sl, const TFrameId &startFrameId,

                int shiftRange) {

  int i, startIndex = sl->guessIndex(startFrameId);

  assert(startIndex >= 0);

  if (startIndex < 0) return;

  HookSet *levelHooks = sl->getHookSet();

  for (i = sl->getFrameCount() - 1; i >= startIndex + shiftRange; i--) {

    TFrameId fid     = sl->index2fid(i);

    TFrameId precFid = sl->index2fid(i - shiftRange);

    assert(precFid >= startFrameId);

    if (precFid == TFrameId::NO_FRAME) break;

    int j, hookCount = levelHooks->getHookCount();

    for (j = 0; j < hookCount; j++) {

      Hook *hook = levelHooks->getHook(j);

      if (hook) {

        hook->setAPos(fid, hook->getAPos(precFid));

        hook->setBPos(fid, hook->getBPos(precFid));

      }

    }

  }

}

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

QString makeCacheId(UINT id, const TFrameId &fid) {

  return "DrawingData" + QString::number(id) + "-" +

         QString::number(fid.getNumber());

}

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

//

// frames[] is replaced by a sequence of imageSet.size() consecutive TFrameId's

// frames[0] is used to determine the 'pastePosition', i.e. the starting frame

// of the new sequence

void getFrameIdToInsert(std::set<tframeid> &frames, TXshSimpleLevel *sl,</tframeid>

                        const std::map<tframeid, qstring=""> &imageSet) {</tframeid,>

  assert(!frames.empty());

  int count              = (int)imageSet.size();

  TFrameId pastePosition = *frames.begin();

  // devo inserire prima di pastePosition. ci puo' essere un "buco".

  // es: frames=[1,3,5] selected=[3]  => devo inserire in 2 (creando un nuovo

  // frameid).

  std::vector<tframeid> fids;</tframeid>

  sl->getFids(fids);

  // cerca fids[j] <= pastePosition

  // fids.beginからfids.endまで、frames.begin()に比べFrameIdが同じか大きいところまでjを進める

  //要するに、ペースト場所を選択フレーム範囲の一番上の部分にする。

  std::vector<tframeid>::iterator j =</tframeid>

      std::lower_bound(fids.begin(), fids.end(), pastePosition);

  if (j != fids.begin()) {

    // pastePosition is not the first frameid of the level

    if (j != fids.end() && frames.find(*j) != frames.end()) {

      // Se il frameId e' gia' presente nel livello lo modifico.

      --j;

      pastePosition = *j + 1;

    }

  } else {

    // pastePosition e' il primo frame (o perche' fids[0]==pastePosition

    // o perche' pastePosition < fids[j], per ogni j

    if (pastePosition.getNumber() > 1)

      pastePosition = TFrameId(pastePosition.getNumber() - 1);

  }

  // pastePositionからコピーされたフレームの枚数分framesに挿入する。

  // frames <- i frames da inserire

  frames.clear();

  int i;

  for (i = 0; i < count; i++) frames.insert(pastePosition + i);

}

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

void rasterize(TToonzImageP &target, const TVectorImageP &source,

               const std::map<int, int=""> &styleTable) {</int,>

  double dpix, dpiy;

  target->getDpi(dpix, dpiy);

  assert(dpix != 0 && dpiy != 0);

  TScale sc(dpix / Stage::inch, dpiy / Stage::inch);

  TRectD bbox = sc * source->getBBox();

  bbox.x0     = tfloor(bbox.x0);

  bbox.y0     = tfloor(bbox.y0);

  bbox.x1     = tceil(bbox.x1);

  bbox.y1     = tceil(bbox.y1);

  TDimension size(bbox.getLx(), bbox.getLy());

  TToonzImageP app = ToonzImageUtils::vectorToToonzImage(

      source, sc, source->getPalette(), bbox.getP00(), size, 0, true);

  TRect rBbox = ToonzImageUtils::convertWorldToRaster(bbox, target);

  target->getCMapped()->copy(app->getCMapped(), rBbox.getP00());

  ToonzImageUtils::scrambleStyles(target, styleTable);

}

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

void vectorize(TVectorImageP &target, const TToonzImageP &source,

               const std::map<int, int=""> &styleTable,</int,>

               const VectorizerConfiguration &config) {

  VectorizerCore vc;

  TVectorImageP vi =

      vc.vectorize(source.getPointer(), config, source->getPalette());

  assert(vi);

  vi->setPalette(source->getPalette());

  double dpiX, dpiY;

  source->getDpi(dpiX, dpiY);

  TScale sc(dpiX / Stage::inch, dpiY / Stage::inch);

  TRect rBox   = source->getCMapped()->getBounds();

  TRectD wBbox = ToonzImageUtils::convertRasterToWorld(rBox, source);

  TTranslation tr(wBbox.getP00());

  int i;

  for (i = 0; i < (int)vi->getStrokeCount(); i++) {

    TStroke *stroke = vi->getStroke(i);

    stroke->transform(sc.inv() * tr, true);

  }

  target->mergeImage(vi, TAffine(), styleTable);

}

}  // namespace

DrawingData *DrawingData::clone() const { return new DrawingData(this); }

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

void DrawingData::setLevelFrames(TXshSimpleLevel *sl,

                                 std::set<tframeid> &frames) {</tframeid>

  if (!sl || frames.empty()) return;

  m_level = sl;

  m_imageSet.clear();

  std::set<tframeid>::iterator it;</tframeid>

  HookSet *levelHooks = m_level->getHookSet();

  int i, hookCount = levelHooks->getHookCount();

  for (it = frames.begin(); it != frames.end(); ++it) {

    TFrameId frameId = *it;

    // Retrieve the image to be stored in this instance

    TImageP img =

        sl->getFullsampledFrame(  // Subsampling is explicitly removed, here.

            frameId, ImageManager::dontPutInCache);  // Furthermore, will not

                                                     // force the IM to cache

                                                     // it.

    if (!img) continue;

    // Clone the image and store it in the image cache

    QString id = makeCacheId(

        (uintptr_t) this,

        it->getNumber());  // Cloning is necessary since the user may

    TImageCache::instance()->add(

        id, img->cloneImage());  // modify and save the original AFTER the copy

    m_imageSet[frameId] = id;    // has been done.

    for (i = 0; i < hookCount; i++) {

      Hook *levelHook = levelHooks->getHook(i);

      if (!levelHook || levelHook->isEmpty()) continue;

      Hook *copiedHook            = m_levelHooks.getHook(i);

      if (!copiedHook) copiedHook = m_levelHooks.addHook();

      copiedHook->setAPos(frameId, levelHook->getAPos(frameId));

      copiedHook->setBPos(frameId, levelHook->getBPos(frameId));

    }

  }

}

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

//

// sl <= frames

//

// setType = INSERT | OVER_FRAMEID | OVER_SELECTION

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

// paste DrawingData to sl.

// frames: selected frames

// setType : INSERT->InsertPaste,  OVER_FRAMEID->Merge,

// OVER_SELECTION->PasteInto

bool DrawingData::getLevelFrames(TXshSimpleLevel *sl,

                                 std::set<tframeid> &frames,</tframeid>

                                 ImageSetType setType, bool cloneImages,

                                 bool &keepOriginalPalette, bool isRedo) const {

  int slType = m_level->getType();

  if (m_imageSet.empty() || !sl ||

      (frames.empty() &&

       setType != DrawingData::OVER_FRAMEID) ||  // If setType == OVER_FRAMEID

                                                 // ignore frames

      (sl->getType() != slType &&  // Level types must be compatible...

       (sl->getType() != TZP_XSHLEVEL ||

        slType != PLI_XSHLEVEL) &&  // ...unless they are of type PLI and TLV

       (sl->getType() != PLI_XSHLEVEL || slType != TZP_XSHLEVEL)))  //

    return false;

  if (m_level.getPointer() == sl || isRedo) {

  }

  // when pasting the frame to different level

  else {

    QString question;

    question = "Replace palette ?";

    int ret  = DVGui::MsgBox(

        question, QObject::tr("Replace with copied palette"),

        QObject::tr("Keep original palette"), QObject::tr("Cancel"), 0);

    if (ret == 0 || ret == 3)

      return false;

    else if (ret == 1)

      keepOriginalPalette = false;

    else

      keepOriginalPalette = true;

  }

  QApplication::setOverrideCursor(Qt::WaitCursor);

  // oldFids = old frame ids

  // renumberTable = old -> new

  // framesToInsert = new frames

  std::vector<tframeid> oldFids;</tframeid>

  sl->getFids(oldFids);

  std::set<tframeid> framesToInsert;</tframeid>

  if (setType == INSERT) {

    framesToInsert = frames;

    getFrameIdToInsert(framesToInsert, sl, m_imageSet);

    // faccio posto (se serve)

    makeSpaceForFids(sl, framesToInsert);

    assert(sl->getFrameCount() == (int)oldFids.size());

  } else if (setType == OVER_SELECTION)

    framesToInsert = frames;

  frames.clear();

  std::map<tframeid, qstring=""> usedImageSet;</tframeid,>

  TPaletteP imgPlt;

  // selected frames

  std::set<tframeid>::iterator it = framesToInsert.begin();</tframeid>

  // Preprocessing to keep used styles

  for (auto const &image : m_imageSet) {

    QString imageId = image.second;

    // paste destination

    TFrameId frameId;

    // merge

    if (setType == OVER_FRAMEID)  // If setType == OVER_FRAMEID ignore frames

      frameId = image.first;

    else {

      // if type == OVER_SELECTION, pasting ends at the end of selected range

      if (it == framesToInsert.end())

        continue;  // If setType == INSERT this is not possible.

      frameId = *it;

    }

    frames.insert(frameId);

    usedImageSet[frameId] = imageId;

    if (!imgPlt.getPointer()) {

      TImageP img     = TImageCache::instance()->get(imageId, false);

      if (img) imgPlt = img->getPalette();

    }

    if (setType != OVER_FRAMEID) ++it;

  }

  // Merge Palette :

  TPalette *slPlt = sl->getPalette();

  bool styleAdded = mergePalette_Overlap(slPlt, imgPlt, keepOriginalPalette);

  std::map<int, int=""> styleTable;</int,>

  if (slPlt) {

    for (int s = 0; s < slPlt->getStyleCount(); s++) styleTable[s] = s;

  }

  // Merge Image

  for (auto const &image : usedImageSet) {

    QString imageId = image.second;

    TImageP img     = getImage(imageId, sl, styleTable, m_keepVectorFills);

    if (!cloneImages) TImageCache::instance()->remove(imageId);

    sl->setFrame(image.first, cloneImages ? img->cloneImage() : img);

  }

  // merge Hooks

  HookSet *levelHooks = sl->getHookSet();

  int hookCount = m_levelHooks.getHookCount();

  // shiftHooks(sl,usedImageSet.begin()->first,framesToInsert.size());

  auto frameIt = m_imageSet.begin();

  for (auto const &image : usedImageSet) {

    for (int i = 0; i < hookCount; i++) {

      Hook *levelHook           = levelHooks->getHook(i);

      if (!levelHook) levelHook = levelHooks->addHook();

      Hook *copiedHook          = m_levelHooks.getHook(i);

      assert(copiedHook);

      levelHook->setAPos(image.first, copiedHook->getAPos((*frameIt).first));

      levelHook->setBPos(image.first, copiedHook->getBPos((*frameIt).first));

    }

    ++frameIt;

  }

  sl->setDirtyFlag(true);

  // notify if there are any modifications to the palette

  if (styleAdded && !isRedo) {

    QString message;

    if (keepOriginalPalette)

      message = "NOTICE: Some styles were added from copied palette.";

    else

      message = "NOTICE: Some styles were added from original palette.";

    DVGui::info(message);

  }

  QApplication::restoreOverrideCursor();

  return true;

}

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

TImageP DrawingData::getImage(QString imageId, TXshSimpleLevel *sl,

                              const std::map<int, int=""> &styleTable,</int,>

                              bool keepVectorFills) const {

  TImageP img = TImageCache::instance()->get(imageId, false);

  int slType  = m_level->getType();

  if (TToonzImageP ti = img) {

    assert(slType == PLI_XSHLEVEL || slType == TZP_XSHLEVEL);

    TImageP slImg = sl->createEmptyFrame();

    slImg->setPalette(sl->getPalette());

    // raster -> raster

    if (sl->getType() == TZP_XSHLEVEL) {

      TToonzImageP slTi = slImg;

      // Immagine di appoggio per effettuare lo scramble

      TToonzImageP newImg = ti->clone();

      ToonzImageUtils::scrambleStyles(newImg, styleTable);

      TRasterCM32P slRaster  = slTi->getRaster();

      TRasterCM32P imgRaster = newImg->getRaster();

      TRop::over(slRaster, imgRaster, TTranslation(slRaster->getCenterD() -

                                                   imgRaster->getCenterD()));

      TRect savebox;

      TRop::computeBBox(slTi->getRaster(), savebox);

      slTi->setSavebox(savebox);

      img = slTi;

    }

    // raster -> vector

    else if (sl->getType() == PLI_XSHLEVEL) {

      TVectorImageP slVi = slImg;

      ToonzScene *scene = sl->getScene();

      assert(scene);

      std::unique_ptr<vectorizerconfiguration> config(</vectorizerconfiguration>

          scene->getProperties()

              ->getVectorizerParameters()

              ->getCurrentConfiguration(0.0));

      bool leaveUnpainted                           = config->m_leaveUnpainted;

      if (keepVectorFills) config->m_leaveUnpainted = false;

      vectorize(slVi, ti, styleTable, *config);

      config->m_leaveUnpainted = leaveUnpainted;

      img                      = slVi;

    }

  } else if (TVectorImageP vi = img) {

    assert(slType == PLI_XSHLEVEL || slType == TZP_XSHLEVEL);

    TImageP slImg = sl->createEmptyFrame();

    slImg->setPalette(sl->getPalette());

    // vector -> vector

    if (sl->getType() == PLI_XSHLEVEL) {

      TVectorImageP slVi = slImg;

      slVi->mergeImage(vi, TAffine(), styleTable);

      img = slVi;

    }

    // vector -> raster

    else if (sl->getType() == TZP_XSHLEVEL) {

      TToonzImageP slTi = slImg;

      rasterize(slTi, vi, styleTable);

      TRect savebox;

      TRop::computeBBox(slTi->getRaster(), savebox);

      slTi->setSavebox(savebox);

      img = slTi;

    }

  }

  return img;

}

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

void DrawingData::setFrames(const std::map<tframeid, qstring=""> &imageSet,</tframeid,>

                            TXshSimpleLevel *level, const HookSet &levelHooks) {

  m_levelHooks = levelHooks;

  m_imageSet.clear();

  assert(!imageSet.empty());

  m_imageSet = imageSet;

  m_level    = level;

}

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

void DrawingData::getFrames(std::set<tframeid> &frames) const {</tframeid>

  for (auto const &image : m_imageSet) frames.insert(image.first);

}

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

DrawingData::~DrawingData() {

  // cannot do that here! if you have cloned this class, the images in the cache

  // are still used...

  // int i;

  // for(i=0; i

  //  TImageCache::instance()->remove(m_imageSet[i]);

}

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

void DrawingData::releaseData() {

  // do it when you're sure you no t need images anymore... (for example in an

  // undo destructor)

  // int i;

  // for(i=0; i

  //  TImageCache::instance()->remove(m_imageSet[i]);

}