#include "thumbnail.h"

#include "tstream.h"

#include "tvectorrenderdata.h"

#include "tvectorimage.h"

#include "tlevel_io.h"

#include "tpalette.h"

#include "tsystem.h"

#include "tsound_io.h"

#include "trop.h"

#include "tw/mainshell.h"

//#include "zapplication.h"

#include "tw/dragdrop.h"

#include "tw/message.h"

#include "pixmapFiletype.h"

#include "tofflinegl.h"

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

//

// Thumbnail

//

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

Thumbnail::Thumbnail(const TDimension &size)

    : m_currentFrameIndex(0)

    , m_iconLoaded(false)

    , m_playing(false)

    , m_size(size)

    , m_raster() {

  m_raster = TRaster32P(m_size);

  m_raster->fill(TPixel32(100, 100, 100));

  m_raster->extractT(m_raster->getBounds().enlarge(-20))

      ->fill(TPixel32(80, 90, 100));

}

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

Thumbnail::~Thumbnail() { clearPointerContainer(m_frames); }

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

void Thumbnail::addFrame(const TFrameId &fid) {

  m_frames.push_back(new Frame(fid));

}

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

bool Thumbnail::gotoFrame(int index) {

  assert(m_playing);

  if (m_currentFrameIndex == index) return true;

  if (index < 0 || index >= (int)m_frames.size()) return false;

  m_currentFrameIndex = index;

  m_raster            = TRaster32P();

  if (!m_frames[index]->m_raster) loadFrame(index);

  m_raster = m_frames[index]->m_raster;

  return true;

}

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

TAffine Thumbnail::getAffine(const TDimension &cameraSize) const {

  double scx = 1 * m_size.lx / (double)cameraSize.lx;

  double scy = 1 * m_size.ly / (double)cameraSize.ly;

  double sc  = tmin(scx, scy);

  double dx  = (m_size.lx - cameraSize.lx * sc) * 0.5;

  double dy  = (m_size.ly - cameraSize.ly * sc) * 0.5;

  return TScale(sc) * TTranslation(0.5 * TPointD(cameraSize.lx, cameraSize.ly) +

                                   TPointD(dx, dy));

}

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

//

// Pli Thumbnail

//

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

class PliThumbnail : public FileThumbnail {

  TLevelReaderP m_lr;

  TPaletteP m_palette;

public:

  PliThumbnail(const TDimension &size, const TFilePath &fp);

  void loadIcon();

  void loadFrame(int index);

  void setPlaying(bool on);

  Type getType() const { return LEVEL; };

private:

  // not implemented

  PliThumbnail(const PliThumbnail &);

  PliThumbnail &operator=(const PliThumbnail &);

};

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

PliThumbnail::PliThumbnail(const TDimension &size, const TFilePath &fp)

    : FileThumbnail(size, fp), m_lr() {}

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

void PliThumbnail::loadIcon() {

  clearPointerContainer(m_frames);

  m_lr          = TLevelReaderP(m_filepath);

  TLevelP level = m_lr->loadInfo();

  m_palette     = level->getPalette();

  for (TLevel::Iterator it = level->begin(); it != level->end(); ++it)

    addFrame(it->first);

  loadFrame(0);

  m_lr         = TLevelReaderP();

  m_raster     = m_frames[0]->m_raster;

  m_iconLoaded = true;

}

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

namespace {

void doRender(const TVectorImageP &vi, const TVectorRenderData &rd,

              const TRaster32P &ras) {

  TOfflineGL *glContext = TOfflineGL::getStock(ras->getSize());

  glContext->getRaster()->copy(ras);

  glContext->draw(vi, rd);

  ras->copy(glContext->getRaster());

}

}

void PliThumbnail::loadFrame(int index) {

  assert(0 <= index && index < (int)m_frames.size());

  if (!m_lr) {

    assert(m_playing);

    m_lr = TLevelReaderP(m_filepath);

    m_lr->loadInfo();

  }

  TVectorImageP vi   = m_lr->getFrameReader(m_frames[index]->m_fid)->load();

  TRaster32P &raster = m_frames[index]->m_raster;

  raster             = TRaster32P(m_size);

  if (vi) {

    raster->fill(TPixel32::White);

    TDimension cameraSize(640, 480);

    const TVectorRenderData rd(getAffine(cameraSize),

                               TRect(),  // raster->getBounds(),

                               m_palette.getPointer(), 0);

    // vi->render(rd,raster);

    doRender(vi, rd, raster);

  } else {

    raster->fill(TPixel32(255, 0, 0));

  }

}

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

void PliThumbnail::setPlaying(bool on) {

  if (m_playing == on) return;

  m_playing = on;

  if (!m_playing) {

    m_lr      = TLevelReaderP();

    m_palette = TPaletteP();

  }

}

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

//

// Raster Thumbnail

//

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

class RasterThumbnail : public FileThumbnail {

  TLevelReaderP m_lr;

public:

  RasterThumbnail(const TDimension &size, const TFilePath &fp);

  void loadIcon();

  void loadFrame(int index);

  void setPlaying(bool on);

  Type getType() const { return LEVEL; };

private:

  // not implemented

  RasterThumbnail(const RasterThumbnail &);

  RasterThumbnail &operator=(const RasterThumbnail &);

};

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

RasterThumbnail::RasterThumbnail(const TDimension &size, const TFilePath &fp)

    : FileThumbnail(size, fp), m_lr() {}

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

void RasterThumbnail::loadIcon() {

  clearPointerContainer(m_frames);

  m_lr = TLevelReaderP(m_filepath);

  try {

    TLevelP level = m_lr->loadInfo();

    if (level && level->getFrameCount() != 0) {

      for (TLevel::Iterator it = level->begin(); it != level->end(); ++it)

        addFrame(it->first);

      loadFrame(0);

      m_raster = m_frames[0]->m_raster;

    } else {

      m_raster = TRaster32P(m_size);

      m_raster->fill(TPixel32::Red);

    }

  } catch (TException &e) {

    TMessage::error(toString(e.getMessage()));

    m_raster = TRaster32P(m_size);

    m_raster->fill(TPixel32::Red);

  }

  m_lr         = TLevelReaderP();

  m_iconLoaded = true;

}

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

void RasterThumbnail::loadFrame(int index) {

  assert(0 <= index && index < (int)m_frames.size());

  if (!m_lr) {

    assert(m_playing);

    m_lr = TLevelReaderP(m_filepath);

    m_lr->loadInfo();

  }

  TRasterImageP ri   = m_lr->getFrameReader(m_frames[index]->m_fid)->load();

  TRaster32P &raster = m_frames[index]->m_raster;

  raster             = TRaster32P(m_size);

  TRaster32P inputRaster;

  if (ri) inputRaster = ri->getRaster();

  if (inputRaster) {

    raster->fill(TPixel32::White);

    double sx = (double)(raster->getLx()) / (double)(inputRaster->getLx());

    double sy = (double)(raster->getLy()) / (double)(inputRaster->getLy());

    double sc = tmin(sx, sy);

    TAffine aff =

        TScale(sc).place(inputRaster->getCenterD(), raster->getCenterD());

    TRop::resample(raster, inputRaster, aff);

  } else {

    raster->fill(TPixel32(255, 0, 0));

  }

}

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

void RasterThumbnail::setPlaying(bool on) {

  if (m_playing == on) return;

  m_playing = on;

  if (!m_playing) {

    m_lr = TLevelReaderP();

  }

}

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

//

// Soundtrack Thumbnail

//

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

class SoundtrackThumbnail : public FileThumbnail {

public:

  SoundtrackThumbnail(const TDimension &size, const TFilePath &fp);

  void loadIcon();

  void loadFrame(int index);

  void setPlaying(bool on);

  Type getType() const { return LEVEL; };

private:

  // not implemented

  SoundtrackThumbnail(const SoundtrackThumbnail &);

  SoundtrackThumbnail &operator=(const SoundtrackThumbnail &);

};

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

SoundtrackThumbnail::SoundtrackThumbnail(const TDimension &size,

                                         const TFilePath &fp)

    : FileThumbnail(size, fp) {}

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

void SoundtrackThumbnail::loadIcon() { m_iconLoaded = true; }

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

void SoundtrackThumbnail::loadFrame(int index) {}

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

void SoundtrackThumbnail::setPlaying(bool on) {

  if (m_playing == on) return;

  m_playing = on;

  /*

if(!m_playing)

{

m_lr = TLevelReaderP();

}

*/

}

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

//

// Casm Thumbnail

//

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

class CasmThumbnail : public FileThumbnail {

public:

  CasmThumbnail(const TDimension &size, const TFilePath &fp);

  void loadIcon();

  void loadFrame(int index);

  void setPlaying(bool on);

  Type getType() const { return LEVEL; };

private:

  // not implemented

  CasmThumbnail(const CasmThumbnail &);

  CasmThumbnail &operator=(const CasmThumbnail &);

};

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

CasmThumbnail::CasmThumbnail(const TDimension &size, const TFilePath &fp)

    : FileThumbnail(size, fp) {}

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

void CasmThumbnail::loadIcon() {

  m_iconLoaded    = true;

  TRaster32P icon = casm_browser_icon;

  if (!icon) return;

  double sx = (double)(m_raster->getLx()) / (double)(icon->getLx());

  double sy = (double)(m_raster->getLy()) / (double)(icon->getLy());

  double sc = tmax(sx, sy);

  TAffine aff = TScale(sc).place(icon->getCenterD(), m_raster->getCenterD());

  TRop::resample(m_raster, icon, aff);

}

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

void CasmThumbnail::loadFrame(int index) {}

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

void CasmThumbnail::setPlaying(bool on) {

  if (m_playing == on) return;

  m_playing = on;

  /*

if(!m_playing)

{

m_lr = TLevelReaderP();

}

*/

}

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

//

// Setup file Thumbnail

//

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

class SetupThumbnail : public FileThumbnail {

public:

  SetupThumbnail(const TDimension &size, const TFilePath &fp);

  void loadIcon();

  void loadFrame(int index);

  void setPlaying(bool on);

  Type getType() const { return LEVEL; };

private:

  // not implemented

  SetupThumbnail(const SetupThumbnail &);

  SetupThumbnail &operator=(const SetupThumbnail &);

};

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

SetupThumbnail::SetupThumbnail(const TDimension &size, const TFilePath &fp)

    : FileThumbnail(size, fp) {}

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

void SetupThumbnail::loadIcon() {

  m_iconLoaded    = true;

  TRaster32P icon = setup_browser_icon;

  if (!icon) return;

  double sx = (double)(m_raster->getLx()) / (double)(icon->getLx());

  double sy = (double)(m_raster->getLy()) / (double)(icon->getLy());

  double sc = tmax(sx, sy);

  TAffine aff = TScale(sc).place(icon->getCenterD(), m_raster->getCenterD());

  TRop::resample(m_raster, icon, aff);

}

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

void SetupThumbnail::loadFrame(int index) {}

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

void SetupThumbnail::setPlaying(bool on) {

  if (m_playing == on) return;

  m_playing = on;

  /*

if(!m_playing)

{

m_lr = TLevelReaderP();

}

*/

}

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

//

// Txt Thumbnail

//

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

class TxtThumbnail : public FileThumbnail {

public:

  TxtThumbnail(const TDimension &size, const TFilePath &fp);

  void loadIcon();

  void loadFrame(int index);

  void setPlaying(bool on);

  Type getType() const { return LEVEL; };

private:

  // not implemented

  TxtThumbnail(const TxtThumbnail &);

  TxtThumbnail &operator=(const TxtThumbnail &);

};

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

TxtThumbnail::TxtThumbnail(const TDimension &size, const TFilePath &fp)

    : FileThumbnail(size, fp) {}

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

void TxtThumbnail::loadIcon() { m_iconLoaded = true; }

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

void TxtThumbnail::loadFrame(int index) {}

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

void TxtThumbnail::setPlaying(bool on) {

  if (m_playing == on) return;

  m_playing = on;

  /*

if(!m_playing)

{

m_lr = TLevelReaderP();

}

*/

}

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

//

// Script Thumbnail

//

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

class ScriptThumbnail : public FileThumbnail {

public:

  ScriptThumbnail(const TDimension &size, const TFilePath &fp);

  void loadIcon();

  void loadFrame(int index);

  void setPlaying(bool on);

  Type getType() const { return LEVEL; };

private:

  // not implemented

  ScriptThumbnail(const ScriptThumbnail &);

  ScriptThumbnail &operator=(const ScriptThumbnail &);

};

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

ScriptThumbnail::ScriptThumbnail(const TDimension &size, const TFilePath &fp)

    : FileThumbnail(size, fp) {}

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

void ScriptThumbnail::loadIcon() {

  m_iconLoaded    = true;

  TRaster32P icon = script_browser_icon;

  if (!icon) return;

  double sx = (double)(m_raster->getLx()) / (double)(icon->getLx());

  double sy = (double)(m_raster->getLy()) / (double)(icon->getLy());

  double sc = tmax(sx, sy);

  TAffine aff = TScale(sc).place(icon->getCenterD(), m_raster->getCenterD());

  TRop::resample(m_raster, icon, aff);

}

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

void ScriptThumbnail::loadFrame(int index) {}

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

void ScriptThumbnail::setPlaying(bool on) {

  if (m_playing == on) return;

  m_playing = on;

  /*

if(!m_playing)

{

m_lr = TLevelReaderP();

}

*/

}

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

//

// Scene Thumbnail

//

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

class ZSceneThumbnail : public FileThumbnail {

public:

  ZSceneThumbnail(const TDimension &size, const TFilePath &fp);

  void loadIcon();

  void loadFrame(int index);

  void setPlaying(bool on);

  void setName(string name);

  Type getType() const { return SCENE; };

private:

  // not implemented

  ZSceneThumbnail(const ZSceneThumbnail &);

  ZSceneThumbnail &operator=(const ZSceneThumbnail &);

};

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

ZSceneThumbnail::ZSceneThumbnail(const TDimension &size, const TFilePath &fp)

    : FileThumbnail(size, fp) {}

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

void ZSceneThumbnail::loadIcon() {

  m_iconLoaded = true;

  clearPointerContainer(m_frames);

  string name        = m_filepath.getName();

  TFilePath dir      = m_filepath.getParentDir();

  TFilePath iconPath = dir + TFilePath(name + "_files") + "icon.bmp";

  if (!TFileStatus(iconPath).isReadable()) return;

  TRasterP ras;

  TImageReader::load(iconPath, ras);

  TRaster32P icon = ras;

  if (!icon) return;

  double sx = (double)(m_raster->getLx()) / (double)(icon->getLx());

  double sy = (double)(m_raster->getLy()) / (double)(icon->getLy());

  double sc = tmax(sx, sy);

  TAffine aff = TScale(sc).place(icon->getCenterD(), m_raster->getCenterD());

  TRop::resample(m_raster, icon, aff);

}

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

void ZSceneThumbnail::loadFrame(int index) {}

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

void ZSceneThumbnail::setPlaying(bool on) {

  if (m_playing == on) return;

  m_playing = on;

  /*

if(on)

{

if(m_frames.empty()) loadXsheet();

}

else

{

m_xsh = TXsheetP();

m_palette = TPaletteP();

}

*/

}

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

void ZSceneThumbnail::setName(string name) {

  assert(!m_playing);

  TFilePath oldPath = m_filepath;

  TFilePath newPath = m_filepath.withName(name);

  if (oldPath == newPath) return;

  string oldName          = m_filepath.getName();

  TFilePath oldRepository = oldPath.getParentDir() + (oldName + "_files");

  TFilePath newRepository = newPath.getParentDir() + (name + "_files");

  TSystem::renameFile(newPath, oldPath);

  TSystem::renameFile(newRepository, oldRepository);

  m_filepath = newPath;

}

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

//

// File Thumbnail

//

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

FileThumbnail::FileThumbnail(const TDimension &size, const TFilePath &path)

    : Thumbnail(size), m_filepath(path) {}

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

void FileThumbnail::setName(string name) {

  assert(!m_playing);

  TFilePath fp = m_filepath.withName(name);

  if (fp != m_filepath) {

    TSystem::renameFile(fp, m_filepath);

    m_filepath = fp;

  }

}

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

FileThumbnail *FileThumbnail::create(const TDimension &size,

                                     const TFilePath &path) {

  vector<string> fileTypes;</string>

  vector<string> soundTypes;</string>

  TImageReader::getSupportedFormats(fileTypes);

  TLevelReader::getSupportedFormats(fileTypes);

  TSoundTrackReader::getSupportedFormats(soundTypes);

  string type = path.getType();

  if (type == "pli") return new PliThumbnail(size, path);

  if (type == "casm") return new CasmThumbnail(size, path);

  if (type == "setup") return new SetupThumbnail(size, path);

  if (type == "txt") return new TxtThumbnail(size, path);

  if (type == "bat" || type == "sh" || type == "csh" || type == "tcsh")

    return new ScriptThumbnail(size, path);

  /*

else if (type == ZComp::getApplication()->getSceneFileExt())

return new ZSceneThumbnail(size,path);

*/

  else if (std::find(soundTypes.begin(), soundTypes.end(), type) !=

           soundTypes.end())

    return new SoundtrackThumbnail(size, path);

  else if (std::find(fileTypes.begin(), fileTypes.end(), type) !=

           fileTypes.end())

    return new RasterThumbnail(size, path);

  else

    return 0;

}

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

bool FileThumbnail::startDragDrop() {

  TDropSource dropSource;

  std::vector<std::string> v;</std::string>

  v.push_back(toString(m_filepath.getWideString()));

  TDataObject data(v);

  dropSource.doDragDrop(data);

  return true;

}

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