#include "tsystem.h"

#include "tiio_gif.h"

#include "trasterimage.h"

#include "timageinfo.h"

#include <qstringlist></qstringlist>

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

//

//  TImageWriterGif

//

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

class TImageWriterGif : public TImageWriter {

public:

  int m_frameIndex;

  TImageWriterGif(const TFilePath &path, int frameIndex, TLevelWriterGif *lwg)

      : TImageWriter(path), m_frameIndex(frameIndex), m_lwg(lwg) {

    m_lwg->addRef();

  }

  ~TImageWriterGif() { m_lwg->release(); }

  bool is64bitOutputSupported() override { return false; }

  void save(const TImageP &img) override { m_lwg->save(img, m_frameIndex); }

private:

  TLevelWriterGif *m_lwg;

};

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

//

//  TLevelWriterGif;

//

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

TLevelWriterGif::TLevelWriterGif(const TFilePath &path, TPropertyGroup *winfo)

    : TLevelWriter(path, winfo) {

  if (!m_properties) m_properties = new Tiio::GifWriterProperties();

  std::string scale = m_properties->getProperty("Scale")->getValueAsString();

  m_scale           = QString::fromStdString(scale).toInt();

  TBoolProperty *looping =

      (TBoolProperty *)m_properties->getProperty("Looping");

  m_looping = looping->getValue();

  TBoolProperty *palette =

      (TBoolProperty *)m_properties->getProperty("Generate Palette");

  m_palette    = palette->getValue();

  ffmpegWriter = new Ffmpeg();

  ffmpegWriter->setPath(m_path);

  // m_frameCount = 0;

  if (TSystem::doesExistFileOrLevel(m_path)) TSystem::deleteFile(m_path);

}

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

TLevelWriterGif::~TLevelWriterGif() {

  QStringList preIArgs;

  QStringList postIArgs;

  QStringList palettePreIArgs;

  QStringList palettePostIArgs;

  int outLx = m_lx;

  int outLy = m_ly;

  // set scaling

  outLx = m_lx * m_scale / 100;

  outLy = m_ly * m_scale / 100;

  // ffmpeg doesn't like resolutions that aren't divisible by 2.

  if (outLx % 2 != 0) outLx++;

  if (outLy % 2 != 0) outLy++;

  QString palette;

  QString filters = "scale=" + QString::number(outLx) + ":-1:flags=lanczos";

  QString paletteFilters = filters + " [x]; [x][1:v] paletteuse";

  if (m_palette) {

    palette = m_path.getQString() + "palette.png";

    palettePreIArgs << "-v";

    palettePreIArgs << "warning";

    palettePostIArgs << "-vf";

    palettePostIArgs << filters + ",palettegen";

    palettePostIArgs << palette;

    // write the palette

    ffmpegWriter->runFfmpeg(palettePreIArgs, palettePostIArgs, false, true,

                            true);

    ffmpegWriter->addToCleanUp(palette);

  }

  preIArgs << "-v";

  preIArgs << "warning";

  preIArgs << "-r";

  preIArgs << QString::number(m_frameRate);

  if (m_palette) {

    postIArgs << "-i";

    postIArgs << palette;

    postIArgs << "-lavfi";

    postIArgs << paletteFilters;

  } else {

    postIArgs << "-lavfi";

    postIArgs << filters;

  }

  if (!m_looping) {

    postIArgs << "-loop";

    postIArgs << "-1";

  }

  std::string outPath = m_path.getQString().toStdString();

  ffmpegWriter->runFfmpeg(preIArgs, postIArgs, false, false, true);

  ffmpegWriter->cleanUpFiles();

}

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

TImageWriterP TLevelWriterGif::getFrameWriter(TFrameId fid) {

  // if (IOError != 0)

  //	throw TImageException(m_path, buildGifExceptionString(IOError));

  if (fid.getLetter() != 0) return TImageWriterP(0);

  int index            = fid.getNumber();

  TImageWriterGif *iwg = new TImageWriterGif(m_path, index, this);

  return TImageWriterP(iwg);

}

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

void TLevelWriterGif::setFrameRate(double fps) {

  // m_fps = fps;

  m_frameRate = fps;

  ffmpegWriter->setFrameRate(fps);

}

void TLevelWriterGif::saveSoundTrack(TSoundTrack *st) { return; }

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

void TLevelWriterGif::save(const TImageP &img, int frameIndex) {

  TRasterImageP image(img);

  m_lx = image->getRaster()->getLx();

  m_ly = image->getRaster()->getLy();

  ffmpegWriter->createIntermediateImage(img, frameIndex);

}

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

//

//  TImageReaderGif

//

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

class TImageReaderGif final : public TImageReader {

public:

  int m_frameIndex;

  TImageReaderGif(const TFilePath &path, int index, TLevelReaderGif *lra)

      : TImageReader(path), m_lra(lra), m_frameIndex(index) {

    m_lra->addRef();

  }

  ~TImageReaderGif() { m_lra->release(); }

  TImageP load() override { return m_lra->load(m_frameIndex); }

  TDimension getSize() const { return m_lra->getSize(); }

  TRect getBBox() const { return TRect(); }

private:

  TLevelReaderGif *m_lra;

  // not implemented

  TImageReaderGif(const TImageReaderGif &);

  TImageReaderGif &operator=(const TImageReaderGif &src);

};

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

//

//  TLevelReaderGif

//

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

TLevelReaderGif::TLevelReaderGif(const TFilePath &path)

    : TLevelReader(path)

{

  ffmpegReader = new Ffmpeg();

  ffmpegReader->setPath(m_path);

  ffmpegReader->disablePrecompute();

  ffmpegFileInfo tempInfo = ffmpegReader->getInfo();

  double fps              = tempInfo.m_frameRate;

  m_frameCount            = tempInfo.m_frameCount;

  m_size                  = TDimension(tempInfo.m_lx, tempInfo.m_ly);

  m_lx                    = m_size.lx;

  m_ly                    = m_size.ly;

  ffmpegReader->getFramesFromMovie();

  m_frameCount = ffmpegReader->getGifFrameCount();

  // set values

  m_info                   = new TImageInfo();

  m_info->m_frameRate      = fps;

  m_info->m_lx             = m_lx;

  m_info->m_ly             = m_ly;

  m_info->m_bitsPerSample  = 8;

  m_info->m_samplePerPixel = 4;

}

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

TLevelReaderGif::~TLevelReaderGif() {

  // ffmpegReader->cleanUpFiles();

}

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

TLevelP TLevelReaderGif::loadInfo() {

  if (m_frameCount == -1) return TLevelP();

  TLevelP level;

  for (int i = 1; i <= m_frameCount; i++) level->setFrame(i, TImageP());

  return level;

}

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

TImageReaderP TLevelReaderGif::getFrameReader(TFrameId fid) {

  // if (IOError != 0)

  //	throw TImageException(m_path, buildAVIExceptionString(IOError));

  if (fid.getLetter() != 0) return TImageReaderP(0);

  int index = fid.getNumber();

  TImageReaderGif *irm = new TImageReaderGif(m_path, index, this);

  return TImageReaderP(irm);

}

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

TDimension TLevelReaderGif::getSize() { return m_size; }

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

TImageP TLevelReaderGif::load(int frameIndex) {

  return ffmpegReader->getImage(frameIndex);

}

Tiio::GifWriterProperties::GifWriterProperties()

    : m_scale("Scale", 1, 100, 100)

    , m_looping("Looping", true)

    , m_palette("Generate Palette", true) {

  bind(m_scale);

  bind(m_looping);

  bind(m_palette);

}

// Tiio::Reader* Tiio::makeGifReader(){ return nullptr; }

// Tiio::Writer* Tiio::makeGifWriter(){ return nullptr; }