#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;
	vector<string> soundTypes;
	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;
	v.push_back(toString(m_filepath.getWideString()));
	TDataObject data(v);
	dropSource.doDragDrop(data);
	return true;
}

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