// Toonz includes

#include "tvectorimage.h"

#include "trasterimage.h"

#include "tlevel_io.h"

#include "tofflinegl.h"

#include "tropcm.h"

#include "tvectorrenderdata.h"

#include "tsystem.h"

#include "tvectorgl.h"

#include "tcolorstyles.h"

// TnzCore includes

#include "tfiletype.h"

#include "tvectorbrushstyle.h"

// TnzLib includes

#include "toonz/imagestyles.h"

#include "toonz/toonzfolders.h"

// Qt includes

#include <qdir></qdir>

#include <qimage></qimage>

#include <qoffscreensurface></qoffscreensurface>

#include <qthread></qthread>

#include <qguiapplication></qguiapplication>

#include <qopenglcontext></qopenglcontext>

#include <qopenglframebufferobject></qopenglframebufferobject>

#include "toonz/stylemanager.h"

#include <qvector></qvector>

//********************************************************************************

//    Local namespace stuff

//********************************************************************************

namespace {

void convertRaster32ToImage(TRaster32P ras, QImage *image) {

  int lx = ras->getLx();

  int ly = ras->getLy();

  int i, j;

  ras->lock();

  for (i = 0; i < lx; i++)

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

      TPixel32 pix = ras->pixels(ly - 1 - j)[i];

      QRgb value;

      value = qRgba(pix.r, pix.g, pix.b, pix.m);

      image->setPixel(i, j, value);

    }

  ras->unlock();

}

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

QImage rasterToQImage(const TRasterP &ras, bool premultiplied = true,

                      bool mirrored = true) {

  if (TRaster32P ras32 = ras) {

    QImage image(ras->getRawData(), ras->getLx(), ras->getLy(),

                 premultiplied ? QImage::Format_ARGB32_Premultiplied

                               : QImage::Format_ARGB32);

    if (mirrored) return image.mirrored();

    return image;

  } else if (TRasterGR8P ras8 = ras) {

    QImage image(ras->getRawData(), ras->getLx(), ras->getLy(), ras->getWrap(),

                 QImage::Format_Indexed8);

    static QVector<qrgb> colorTable;</qrgb>

    if (colorTable.size() == 0) {

      int i;

      for (i = 0; i < 256; i++) colorTable.append(QColor(i, i, i).rgb());

    }

    image.setColorTable(colorTable);

    if (mirrored) return image.mirrored();

    return image;

  }

  return QImage();

}

}  // namespace

//********************************************************************************

//    FavoritesManager implementation

//********************************************************************************

FavoritesManager::FavoritesManager() {

  m_fpPinsToTop = ToonzFolder::getMyModuleDir() + "pintotopbrushes.txt";

  m_xxPinsToTop = false;

  loadPinsToTop();

}

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

FavoritesManager *FavoritesManager::instance() {

  static FavoritesManager _instance;

  return &_instance;

}

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

bool FavoritesManager::loadPinsToTop() {

  if (!TFileStatus(m_fpPinsToTop).doesExist()) return false;

  TIStream is(m_fpPinsToTop);

  if (!is) throw TException("Can't read XML");

  std::string tagName;

  if (!is.matchTag(tagName) || tagName != "PinsToTop") return false;

  m_pinsToTop.clear();

  while (!is.matchEndTag()) {

    if (!is.matchTag(tagName)) throw TException("Expected tag");

    if (tagName == "BrushIdName") {

      std::string brushname;

      is >> brushname;

      m_pinsToTop.push_back(brushname);

      if (!is.matchEndTag()) throw TException("Expected end tag");

    }

  }

  m_xxPinsToTop = false;

  return true;

}

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

void FavoritesManager::savePinsToTop() {

  if (!m_xxPinsToTop) return;

  TOStream os(m_fpPinsToTop);

  if (!os) throw TException("Can't write XML");

  os.openChild("PinsToTop");

  for (auto &idname : m_pinsToTop) {

    os.openChild("BrushIdName", {});

    os << idname;

    os.closeChild();

  }

  os.closeChild();

}

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

bool FavoritesManager::getPinToTop(std::string idname) const {

  return m_pinsToTop.contains(idname);

}

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

void FavoritesManager::setPinToTop(std::string idname, bool state) {

  int index = m_pinsToTop.indexOf(idname);

  if (state && index == -1) {

    m_xxPinsToTop = true;

    m_pinsToTop.append(idname);

  } else if (!state && index != -1) {

    m_xxPinsToTop = true;

    m_pinsToTop.removeAll(idname);

  }

}

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

void FavoritesManager::togglePinToTop(std::string idname) {

  int index = m_pinsToTop.indexOf(idname);

  if (index != -1)

    m_pinsToTop.removeAt(index);

  else

    m_pinsToTop.append(idname);

  m_xxPinsToTop = true;

}

//********************************************************************************

//    BaseStyleManager implementation

//********************************************************************************

TFilePath BaseStyleManager::s_rootPath;

BaseStyleManager::ChipData BaseStyleManager::s_emptyChipData;

BaseStyleManager::BaseStyleManager(const TFilePath &stylesFolder,

                                   QString filters, QSize chipSize)

    : m_stylesFolder(stylesFolder)

    , m_filters(filters)

    , m_chipSize(chipSize)

    , m_loaded(false)

    , m_isIndexed(false) {}

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

const BaseStyleManager::ChipData &BaseStyleManager::getData(int index) const {

  if (m_isIndexed) {

    return (index < 0 || index >= m_indexes.count())

               ? s_emptyChipData

               : m_chips[m_indexes[index]];

  } else {

    return (index < 0 || index >= m_chips.count()) ? s_emptyChipData

                                                   : m_chips[index];

  }

}

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

void BaseStyleManager::applyFilter() {

  FavoritesManager *favMan = FavoritesManager::instance();

  QList<int> indexes;</int>

  m_indexes.clear();

  int len = m_chips.count();

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

    auto &chip = m_chips[i];

    if (chip.desc.indexOf(m_searchText, 0, Qt::CaseInsensitive) >= 0) {

      if (favMan->getPinToTop(chip.idname)) {

        chip.markPinToTop = true;

        m_indexes.append(i);

      } else {

        chip.markPinToTop = false;

        indexes.append(i);

      }

    }

  }

  bool hasPinsToTop = m_indexes.count() > 0;

  m_indexes.append(indexes);

  m_isIndexed = (m_indexes.count() != len) || hasPinsToTop;

}

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

TFilePath BaseStyleManager::getRootPath() { return s_rootPath; }

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

void BaseStyleManager::setRootPath(const TFilePath &rootPath) {

  s_rootPath = rootPath;

}

//********************************************************************************

//    StyleLoaderTask definition

//********************************************************************************

class CustomStyleManager::StyleLoaderTask final : public TThread::Runnable {

  CustomStyleManager *m_manager;

  TFilePath m_fp;

  ChipData m_data;

  std::shared_ptr<qoffscreensurface> m_offScreenSurface;</qoffscreensurface>

public:

  StyleLoaderTask(CustomStyleManager *manager, const TFilePath &fp);

  void run() override;

  void onFinished(TThread::RunnableP sender) override;

};

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

CustomStyleManager::StyleLoaderTask::StyleLoaderTask(

    CustomStyleManager *manager, const TFilePath &fp)

    : m_manager(manager), m_fp(fp) {

  connect(this, SIGNAL(finished(TThread::RunnableP)), this,

          SLOT(onFinished(TThread::RunnableP)));

  if (QThread::currentThread() == qGuiApp->thread()) {

    m_offScreenSurface.reset(new QOffscreenSurface());

    m_offScreenSurface->setFormat(QSurfaceFormat::defaultFormat());

    m_offScreenSurface->create();

  }

}

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

void CustomStyleManager::StyleLoaderTask::run() {

  m_data = m_manager->createPattern(m_fp, m_offScreenSurface);

}

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

void CustomStyleManager::StyleLoaderTask::onFinished(

    TThread::RunnableP sender) {

  // On the main thread...

  if (!m_data.image.isNull())  // Everything went ok

  {

    m_manager->m_chips.append(m_data);

    emit m_manager->patternAdded();

  }

}

//********************************************************************************

//    CustomStyleManager implementation

//********************************************************************************

CustomStyleManager::CustomStyleManager(std::string rasterIdName,

                                       std::string vectorIdName,

                                       const TFilePath &stylesFolder,

                                       QString filters, QSize chipSize)

    : BaseStyleManager(stylesFolder, filters, chipSize)

    , m_started(false)

    , m_rasterIdName(rasterIdName)

    , m_vectorIdName(vectorIdName) {

  m_executor.setMaxActiveTasks(1);

}

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

void CustomStyleManager::loadItems() {

  // Build the folder to be read

  const TFilePath &rootFP(getRootPath());

  assert(rootFP != TFilePath());

  if (rootFP == TFilePath()) return;

  QDir patternDir(

      QString::fromStdWString((rootFP + m_stylesFolder).getWideString()));

  patternDir.setNameFilters(m_filters.split(' '));

  // Read the said folder

  TFilePathSet fps;

  try {

    TSystem::readDirectory(fps, patternDir);

  } catch (...) {

    return;

  }

  // Delete patterns no longer in the folder

  TFilePathSet newFps;

  TFilePathSet::iterator it;

  int i;

  for (i = 0; i < m_chips.size(); i++) {

    ChipData data = m_chips.at(i);

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

      int isVector = (it->getType() == "pli") ? 1 : 0;

      QString name = QString::fromStdWString(it->getWideName());

      if (data.name == name && data.isVector == isVector) break;

    }

    if (it == fps.end()) {

      m_chips.removeAt(i);

      i--;

    } else

      fps.erase(it);  // The style is not new, so don't generate tasks for it

  }

  // For each (now new) file entry, generate a fetching task

  for (TFilePathSet::iterator it = fps.begin(); it != fps.end(); it++)

    m_executor.addTask(new StyleLoaderTask(this, *it));

}

QImage CustomStyleManager::makeIcon(

    const TFilePath &path, const QSize &qChipSize,

    std::shared_ptr<qoffscreensurface> offsurf) {</qoffscreensurface>

  try {

    // Fetch the level

    TLevelReaderP lr(path);

    TLevelP level = lr->loadInfo();

    if (!level || level->getFrameCount() == 0) return QImage();

    // Fetch the image of the first frame in the level

    TLevel::Iterator frameIt = level->begin();

    if (frameIt == level->end()) return QImage();

    TImageP img = lr->getFrameReader(frameIt->first)->load();

    // Process the image

    TDimension chipSize(qChipSize.width(), qChipSize.height());

    TVectorImageP vimg = img;

    TRasterImageP rimg = img;

    TRaster32P ras;

    QImage image;

    if (vimg) {

      assert(level->getPalette());

      TPalette *vPalette = level->getPalette();

      assert(vPalette);

      vimg->setPalette(vPalette);

#ifdef LINUX

      TOfflineGL *glContext = 0;

      glContext             = TOfflineGL::getStock(chipSize);

      glContext->clear(TPixel32::White);

#else

      QOpenGLContext *glContext = new QOpenGLContext();

      if (QOpenGLContext::currentContext())

        glContext->setShareContext(QOpenGLContext::currentContext());

      glContext->setFormat(QSurfaceFormat::defaultFormat());

      glContext->create();

      glContext->makeCurrent(offsurf.get());

      // attaching stencil buffer here as some styles use it

      QOpenGLFramebufferObject fb(

          chipSize.lx, chipSize.ly,

          QOpenGLFramebufferObject::CombinedDepthStencil);

      fb.bind();

      // Draw

      glViewport(0, 0, chipSize.lx, chipSize.ly);

      glClearColor(1.0, 1.0, 1.0, 1.0);  // clear with white color

      glClear(GL_COLOR_BUFFER_BIT);

      glMatrixMode(GL_PROJECTION);

      glLoadIdentity();

      gluOrtho2D(0, chipSize.lx, 0, chipSize.ly);

      glMatrixMode(GL_MODELVIEW);

      glLoadIdentity();

#endif

      TRectD bbox = img->getBBox();

      double scx  = 0.8 * chipSize.lx / bbox.getLx();

      double scy  = 0.8 * chipSize.ly / bbox.getLy();

      double sc   = std::min(scx, scy);

      double dx   = 0.5 * chipSize.lx;

      double dy   = 0.5 * chipSize.ly;

      TAffine aff =

          TTranslation(dx, dy) * TScale(sc) *

          TTranslation(-0.5 * (bbox.x0 + bbox.x1), -0.5 * (bbox.y0 + bbox.y1));

      TVectorRenderData rd(aff, chipSize, vPalette, 0, true);

#ifdef LINUX

      glContext->draw(img, rd);

      // No need to clone! The received raster already is a copy of the

      // context's buffer

      ras = glContext->getRaster();  //->clone();

#else

      tglDraw(rd, vimg.getPointer());

      image = QImage(fb.toImage().scaled(QSize(chipSize.lx, chipSize.ly),

                                         Qt::IgnoreAspectRatio,

                                         Qt::SmoothTransformation));

      fb.release();

      glContext->deleteLater();

#endif

    } else if (rimg) {

      TDimension size = rimg->getRaster()->getSize();

      if (size == chipSize)

        ras = rimg->getRaster()->clone();  // Yep, this may be necessary

      else {

        TRaster32P rout(chipSize);

        TRop::resample(rout, rimg->getRaster(),

                       TScale((double)chipSize.lx / size.lx,

                              (double)chipSize.ly / size.ly));

        TRop::addBackground(rout, TPixel::White);

        ras = rout;

      }

#ifndef LINUX

      // image = QImage(chipSize.lx, chipSize.ly, QImage::Format_RGB32);

      // convertRaster32ToImage(ras, &image);

      image = rasterToQImage(ras);

#endif

    } else

      assert(!"unsupported type for custom styles!");

#ifdef LINUX

    // image = QImage(chipSize.lx, chipSize.ly, QImage::Format_RGB32);

    // convertRaster32ToImage(ras, &image);

    image = rasterToQImage(ras);

#endif

    return image;

  } catch (...) {

  }

  return QImage();

}

CustomStyleManager::ChipData CustomStyleManager::createPattern(

    const TFilePath &path, std::shared_ptr<qoffscreensurface> offsurf) {</qoffscreensurface>

  ChipData data;

  bool isVector = (path.getType() == "pli" || path.getType() == "svg");

  // Generate preview

  try {

    data.image = makeIcon(path, getChipSize(), offsurf);

  } catch (...) {

  }

  if (!data.image.isNull()) {

    data.name     = QString::fromStdWString(path.getWideName());

    data.desc     = data.name;

    data.isVector = isVector;

    if (isVector)

      data.idname = m_vectorIdName + data.name.toStdString();

    else

      data.idname = m_rasterIdName + data.name.toStdString();

    data.hash = TColorStyle::generateHash(data.idname);

  }

  return data;

}

//********************************************************************************

//    TextureStyleManager implementation

//********************************************************************************

TextureStyleManager::TextureStyleManager(const TFilePath &stylesFolder,

                                         QSize chipSize)

    : BaseStyleManager(stylesFolder, QString(), chipSize) {}

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

void TextureStyleManager::loadTexture(const TFilePath &fp) {

  if (fp == TFilePath()) {

    TRaster32P ras(25, 25);

    TTextureStyle::fillCustomTextureIcon(ras);

    // ras->fill(TPixel::Blue);

    ChipData customText(

        QString(""), QObject::tr("Custom Texture", "TextureStyleChooserPage"),

        rasterToQImage(ras), 4, false, ras,

        TTextureStyle::staticBrushIdName(L""));

    customText.hash = TTextureStyle::generateHash(customText.idname);

    m_chips.append(customText);

    return;

  }

  TRasterP ras;

  TImageReader::load(fp, ras);

  if (!ras || ras->getLx() < 2 || ras->getLy() < 2) return;

  TRaster32P ras32 = ras;

  if (!ras32) return;

  TDimension d(2, 2);

  while (d.lx < 256 && d.lx * 2 <= ras32->getLx()) d.lx *= 2;

  while (d.ly < 256 && d.ly * 2 <= ras32->getLy()) d.ly *= 2;

  TRaster32P texture;

  if (d == ras32->getSize())

    texture = ras32;

  else {

    texture = TRaster32P(d);

    TScale sc((double)texture->getLx() / ras32->getLx(),

              (double)texture->getLy() / ras32->getLy());

    TRop::resample(texture, ras32, sc);

  }

  QString name = QString::fromStdWString(fp.getLevelNameW());

  ChipData text(name, name, rasterToQImage(ras), 4, false, texture,

                TTextureStyle::staticBrushIdName(fp.getLevelNameW()));

  text.hash = TTextureStyle::generateHash(text.idname);

  m_chips.append(text);

}

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

void TextureStyleManager::loadItems() {

  m_chips.clear();

  if (getRootPath() == TFilePath()) return;

  TFilePath texturePath = getRootPath() + "textures";

  TFilePathSet fps;

  try {

    fps = TSystem::readDirectory(texturePath);

  } catch (...) {

    return;

  }

  if (fps.empty()) return;

  int count = 0;

  for (TFilePathSet::iterator it = fps.begin(); it != fps.end(); it++)

    if (TFileType::getInfo(*it) == TFileType::RASTER_IMAGE) {

      try {

        loadTexture(*it);

        ++count;

      } catch (...) {

      }

    }

  loadTexture(TFilePath());  // custom texture

  m_loaded = true;

}

//********************************************************************************

//    MyPaintBrushStyleManager  implementation

//********************************************************************************

MyPaintBrushStyleManager::MyPaintBrushStyleManager(QSize chipSize)

    : BaseStyleManager(TFilePath(), QString(), chipSize) {}

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

void MyPaintBrushStyleManager::loadItems() {

  m_brushes.clear();

  m_chips.clear();

  std::set<tfilepath> brushFiles;</tfilepath>

  TFilePathSet dirs = TMyPaintBrushStyle::getBrushesDirs();

  for (TFilePathSet::iterator i = dirs.begin(); i != dirs.end(); ++i) {

    TFileStatus fs(*i);

    if (fs.doesExist() && fs.isDirectory()) {

      TFilePathSet files = TSystem::readDirectoryTree(*i, false, true);

      for (TFilePathSet::iterator j = files.begin(); j != files.end(); ++j)

        if (j->getType() == TMyPaintBrushStyle::getBrushType())

          brushFiles.insert(*j - *i);

    }

  }

  // reserve memory to avoid reallocation

  m_brushes.reserve(brushFiles.size());

  for (std::set<tfilepath>::iterator i = brushFiles.begin();</tfilepath>

       i != brushFiles.end(); ++i) {

    TMyPaintBrushStyle style = TMyPaintBrushStyle(*i);

    m_brushes.push_back(style);

    // Generate a QImage preview to draw the chip faster at cost of few memory

    QImage previewQImage = rasterToQImage(style.getPreview());

    QString stylePath    = style.getPath().getQString();

    m_chips.append(ChipData(stylePath, stylePath, previewQImage, 4001, false,

                            TRasterP(), style.getBrushIdName(),

                            style.getBrushIdHash()));

  }

  m_loaded = true;

}

//********************************************************************************

//    SpecialStyleManager  implementation

//********************************************************************************

SpecialStyleManager::SpecialStyleManager(QSize chipSize)

    : BaseStyleManager(TFilePath(), QString(), chipSize) {}

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

void SpecialStyleManager::loadItems() {

  m_chips.clear();

  std::vector<int> tags;</int>

  TColorStyle::getAllTags(tags);

  int chipCount = 0;

  for (int j = 0; j < (int)tags.size(); j++) {

    int tagId = tags[j];

    if (tagId == 3 ||     // solid color

        tagId == 4 ||     // texture

        tagId == 100 ||   // obsolete imagepattern id

        tagId == 2000 ||  // imagepattern

        tagId == 2800 ||  // imagepattern

        tagId == 2001 ||  // cleanup

        tagId == 2002 ||  // black cleanup

        tagId == 3000 ||  // vector brush

        tagId == 4001     // mypaint brush

    )

      continue;

    TColorStyle *style = TColorStyle::create(tagId);

    if (style->isRasterStyle()) {

      delete style;

      continue;

    }

    TDimension chipSize(getChipSize().width(), getChipSize().height());

    // QImage *image = new QImage(chipSize.lx, chipSize.ly,

    // QImage::Format_RGB32); convertRaster32ToImage(style->getIcon(chipSize),

    // image);

    TRaster32P raster = style->getIcon(chipSize);

    ChipData chip(style->getDescription(), style->getDescription(),

                  rasterToQImage(raster), tagId, true, raster,

                  style->getBrushIdName(), style->getBrushIdHash());

    m_chips.append(chip);

    delete style;

  }

  m_loaded = true;

}