#include "toonz/scriptbinding_outline_vectorizer.h"

#include "toonz/scriptbinding_level.h"

#include "toonz/tcenterlinevectorizer.h"

#include "toonz/stage.h"

#include "ttoonzimage.h"

#include "tpalette.h"

namespace TScriptBinding

{

OutlineVectorizer::OutlineVectorizer()

{

	m_parameters = new NewOutlineConfiguration();

}

OutlineVectorizer::~OutlineVectorizer()

{

	delete m_parameters;

}

QScriptValue OutlineVectorizer::toString()

{

	return "Outline Vectorizer";

}

QScriptValue OutlineVectorizer::ctor(QScriptContext *context, QScriptEngine *engine)

{

	return create(engine, new OutlineVectorizer());

}

QScriptValue vectorizeImage(QScriptContext *context, QScriptEngine *engine, const TImageP &src, TPalette *palette, NewOutlineConfiguration *parameters)

{

	VectorizerCore vc;

	TAffine dpiAff;

	double factor = Stage::inch;

	double dpix = factor / 72, dpiy = factor / 72;

	TPointD center;

	if (TRasterImageP ri = src) {

		ri->getDpi(dpix, dpiy);

		center = ri->getRaster()->getCenterD();

	} else if (TToonzImageP ti = src) {

		ti->getDpi(dpix, dpiy);

		center = ti->getRaster()->getCenterD();

	} else {

		return context->throwError(QObject::tr("Vectorization failed"));

	}

	if (dpix != 0.0 && dpiy != 0.0)

		dpiAff = TScale(factor / dpix, factor / dpiy);

	factor = norm(dpiAff * TPointD(1, 0));

	parameters->m_affine = dpiAff * TTranslation(-center);

	parameters->m_thickScale = factor;

	TVectorImageP vi = vc.vectorize(src, *parameters, palette);

	vi->setPalette(palette);

	return engine->newQObject(new Image(vi), QScriptEngine::AutoOwnership);

}

QScriptValue OutlineVectorizer::vectorize(QScriptValue arg)

{

	Level *level = qscriptvalue_cast<level *="">(arg);</level>

	Image *img = qscriptvalue_cast(arg);

	QString type;

	TPalette *palette = 0;

	if (level) {

		type = level->getType();

		if (type != "Raster" && type != "ToonzRaster")

			return context()->throwError(tr("Can't vectorize a %1 level").arg(type));

		if (level->getFrameCount() <= 0)

			return context()->throwError(tr("Can't vectorize a level with no frames"));

		palette = level->getSimpleLevel()->getPalette();

	} else if (img) {

		type = img->getType();

		if (type != "Raster" && type != "ToonzRaster")

			return context()->throwError(tr("Can't vectorize a %1 image").arg(type));

		if (TToonzImageP ti = img->getImg()) {

			palette = ti->getPalette();

		}

	} else {

		return context()->throwError(tr("Bad argument (%1): should be an Image or a Level").arg(arg.toString()));

	}

	if (palette == 0)

		palette = new TPalette();

	if (img) {

		return vectorizeImage(context(), engine(), img->getImg(), palette, m_parameters);

	} else if (level) {

		QScriptValue newLevel = create(engine(), new Level());

		QList<tframeid> fids;</tframeid>

		level->getFrameIds(fids);

		foreach (TFrameId fid, fids) {

			TImageP srcImg = level->getImg(fid);

			if (srcImg && (srcImg->getType() == TImage::RASTER || srcImg->getType() == TImage::TOONZ_RASTER)) {

				QScriptValue newFrame = vectorizeImage(context(), engine(), srcImg, palette, m_parameters);

				if (newFrame.isError()) {

					return newFrame;

				}

				QScriptValueList args;

				args << QString::fromStdString(fid.expand()) << newFrame;

				newLevel.property("setFrame").call(newLevel, args);

			}

		}

		return newLevel;

	} else {

		// should never happen

		return QScriptValue();

	}

}

int OutlineVectorizer::getAccuracy() const

{

	return (5.0 - m_parameters->m_mergeTol) * 2.0;

}

void OutlineVectorizer::setAccuracy(int v)

{

	m_parameters->m_mergeTol = 5.0 - v * 0.5;

}

int OutlineVectorizer::getDespeckling() const

{

	return m_parameters->m_despeckling;

}

void OutlineVectorizer::setDespeckling(int v)

{

	m_parameters->m_despeckling = v;

}

bool OutlineVectorizer::getPreservePaintedAreas() const

{

	return !m_parameters->m_leaveUnpainted;

}

void OutlineVectorizer::setPreservePaintedAreas(bool v)

{

	m_parameters->m_leaveUnpainted = !v;

}

double OutlineVectorizer::getCornerAdherence() const

{

	return m_parameters->m_adherenceTol * 100.0;

}

void OutlineVectorizer::setCornerAdherence(double v)

{

	m_parameters->m_adherenceTol = 0.01 * v;

}

double OutlineVectorizer::getCornerAngle() const

{

	return m_parameters->m_angleTol * 180.0;

}

void OutlineVectorizer::setCornerAngle(double v)

{

	m_parameters->m_angleTol = v / 180.0;

}

double OutlineVectorizer::getCornerCurveRadius() const

{

	return m_parameters->m_relativeTol * 100;

}

void OutlineVectorizer::setCornerCurveRadius(double v)

{

	m_parameters->m_relativeTol = 0.01 * v;

}

int OutlineVectorizer::getMaxColors() const

{

	return m_parameters->m_maxColors;

}

void OutlineVectorizer::setMaxColors(int v)

{

	m_parameters->m_maxColors = v;

}

QString OutlineVectorizer::getTransparentColor() const

{

	TPixel32 c = m_parameters->m_transparentColor;

	QColor color(c.r, c.g, c.b, c.m);

	return color.name();

}

void OutlineVectorizer::setTransparentColor(const QString &colorName)

{

	QColor color;

	color.setNamedColor(colorName);

	if (color.isValid()) {

		m_parameters->m_transparentColor = TPixel32(color.red(), color.green(), color.blue(), color.alpha());

	} else {

		context()->throwError(tr("Invalid color : ").arg(colorName));

	}

}

int OutlineVectorizer::getToneThreshold() const

{

	return m_parameters->m_toneTol;

}

void OutlineVectorizer::setToneThreshold(int v)

{

	m_parameters->m_toneTol = v;

}

} // namespace TScriptBinding