#include "tpixelutils.h"
#include "tvectorimage.h"
#include "trop.h"
 
#include <QApplication>
 
#include "toonz/cleanupcolorstyles.h"
 
//-------------------------------------------------------------------
 
TCleanupStyle::TCleanupStyle(const TPixel32 &color)
	: TSolidColorStyle(color), m_outColor(color), m_brightness(0), m_contrast(50), m_canUpdate(true)
{
}
 
//-------------------------------------------------------------------
 
TCleanupStyle::TCleanupStyle(const TCleanupStyle &src)
	: TSolidColorStyle(src), m_outColor(src.m_outColor), m_brightness(src.m_brightness), m_contrast(src.m_contrast), m_contrastEnable(true), m_canUpdate(src.m_canUpdate)
{
	setName(src.getName());
}
 
//-------------------------------------------------------------------
 
TCleanupStyle::~TCleanupStyle()
{
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::setCanUpdate(bool state)
{
	m_canUpdate = state;
}
 
//--------------------------------------------
 
void TCleanupStyle::loadData(TInputStreamInterface &is)
{
	TSolidColorStyle::loadData(is);
 
	VersionNumber version(is.versionNumber());
	if (version.first == 1 && version.second == 18) {
		//Toonz 6.3 ML had removed the output color option
		TPixel32 dummy;
		is >> dummy >> m_brightness >> m_contrast;
		m_outColor = getMainColor();
	} else
		is >> m_outColor >> m_brightness >> m_contrast;
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::saveData(TOutputStreamInterface &os) const
{
	TSolidColorStyle::saveData(os);
	os << m_outColor << m_brightness << m_contrast;
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::setMainColor(const TPixel32 &color)
{
	if (getMainColor() == m_outColor)
		m_outColor = color;
	TSolidColorStyle::setMainColor(color);
}
 
//-------------------------------------------------------------------
 
int TCleanupStyle::getColorParamCount() const
{
	return 2;
}
 
//-------------------------------------------------------------------
 
TPixel32 TCleanupStyle::getColorParamValue(int index) const
{
	return (index == 0) ? getMainColor() : m_outColor;
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::setColorParamValue(int index, const TPixel32 &color)
{
	if (index == 0)
		setMainColor(color);
	else
		m_outColor = color;
}
 
//-------------------------------------------------------------------
 
QString TCleanupStyle::getParamNames(int index) const
{
	switch (index) {
	case 0:
		return "Brightness";
	case 1:
		return "Contrast";
	default:
		return QString("");
	}
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::getParamRange(int index, double &min, double &max) const
{
	if (index == 0) {
		min = -100;
		max = 100;
	} else {
		min = 0;
		max = 100;
	}
}
 
//-------------------------------------------------------------------
 
double TCleanupStyle::getParamValue(TColorStyle::double_tag, int index) const
{
	switch (index) {
	case 0:
		return getBrightness();
	case 1:
		return getContrast();
	default:
		return 0.0;
	}
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::setParamValue(int index, double value)
{
	switch (index) {
	case 0:
		setBrightness(value);
		break;
	case 1:
		setContrast(value);
		break;
	}
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::setBrightness(double b)
{
	m_brightness = b;
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::setContrast(double c)
{
	m_contrast = c;
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::enableContrast(bool value)
{
	m_contrastEnable = value;
}
 
//-------------------------------------------------------------------
 
bool TCleanupStyle::isContrastEnabled() const
{
	return m_contrastEnable;
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::makeIcon(const TDimension &size)
{
	//Build an icon with mainColor on the top half, and
	//getColorParamValue(1) on the bottom.
	if (!m_icon || m_icon->getSize() != size) {
		TRaster32P ras(size);
		m_icon = ras;
	}
 
	TPixel32 topCol(getMainColor()), botCol(getColorParamValue(1));
 
	int ly_2 = size.ly / 2;
	TRaster32P botRas(m_icon->extract(0, 0, size.lx, ly_2));
	TRaster32P topRas(m_icon->extract(0, ly_2 + 1, size.lx, size.ly));
 
	makeIcon(botRas, botCol);
	makeIcon(topRas, topCol);
}
 
//-------------------------------------------------------------------
 
void TCleanupStyle::makeIcon(TRaster32P &ras, const TPixel32 &col)
{
	if (col.m == 255)
		ras->fill(col);
	else {
		TRaster32P fg(ras->getSize());
		fg->fill(premultiply(col));
		TRop::checkBoard(ras, TPixel32::Black, TPixel32::White, TDimensionD(6, 6), TPointD());
		TRop::over(ras, fg);
	}
}
 
//===================================================================
 
TColorCleanupStyle::TColorCleanupStyle(const TPixel32 &color)
	: TCleanupStyle(color), m_hRange(60.0), m_lineWidth(90.0)
{
}
 
//-------------------------------------------------------------------
 
void TColorCleanupStyle::loadData(TInputStreamInterface &is)
{
	TCleanupStyle::loadData(is);
	is >> m_hRange;
 
	if (is.versionNumber() >= VersionNumber(1, 18))
		is >> m_lineWidth;
}
 
//-------------------------------------------------------------------
 
void TColorCleanupStyle::saveData(TOutputStreamInterface &os) const
{
	TCleanupStyle::saveData(os);
	os << m_hRange;
	os << m_lineWidth;
}
 
//-------------------------------------------------------------------
 
TColorStyle *TColorCleanupStyle::clone() const
{
	return new TColorCleanupStyle(*this);
}
 
//-------------------------------------------------------------------
 
QString TColorCleanupStyle::getDescription() const
{
	return "CleanupColor";
}
 
//-------------------------------------------------------------------
 
int TColorCleanupStyle::getTagId() const
{
	return 2001;
}
 
//-------------------------------------------------------------------
 
QString TColorCleanupStyle::getParamNames(int index) const
{
	if (index == 2)
		"HRange";
	if (index == 3)
		"Line Width";
	return TCleanupStyle::getParamNames(index);
}
 
//-------------------------------------------------------------------
 
void TColorCleanupStyle::getParamRange(int index, double &min, double &max) const
{
	if (index >= 2) {
		min = 0;
		max = 100;
	} else
		TCleanupStyle::getParamRange(index, min, max);
}
 
//-------------------------------------------------------------------
 
double TColorCleanupStyle::getParamValue(TColorStyle::double_tag tag, int index) const
{
	if (index == 2)
		return getHRange();
	if (index == 3)
		return getLineWidth();
	return TCleanupStyle::getParamValue(tag, index);
}
 
//-------------------------------------------------------------------
 
void TColorCleanupStyle::setParamValue(int index, double value)
{
	if (index == 2)
		setHRange(value);
	else if (index == 3)
		setLineWidth(value);
	else
		TCleanupStyle::setParamValue(index, value);
}
 
//-------------------------------------------------------------------
 
void TColorCleanupStyle::setHRange(double hRange)
{
	m_hRange = hRange;
}
 
//-------------------------------------------------------------------
 
void TColorCleanupStyle::setLineWidth(double lineWidth)
{
	m_lineWidth = lineWidth;
}
 
//===================================================================
 
TBlackCleanupStyle::TBlackCleanupStyle(const TPixel32 &color)
	: TCleanupStyle(color), m_colorThreshold(70), m_whiteThreshold(10)
{
}
 
//-------------------------------------------------------------------
 
TColorStyle *TBlackCleanupStyle::clone() const
{
	return new TBlackCleanupStyle(*this);
}
 
//-------------------------------------------------------------------
 
void TBlackCleanupStyle::loadData(TInputStreamInterface &is)
{
	TCleanupStyle::loadData(is);
	is >> m_colorThreshold >> m_whiteThreshold;
}
 
//-------------------------------------------------------------------
 
void TBlackCleanupStyle::saveData(TOutputStreamInterface &os) const
{
	TCleanupStyle::saveData(os);
	os << m_colorThreshold << m_whiteThreshold;
}
 
//-------------------------------------------------------------------
 
QString TBlackCleanupStyle::getDescription() const
{
	return "CleanupBlack";
}
 
//-------------------------------------------------------------------
 
int TBlackCleanupStyle::getTagId() const
{
	return 2002;
}
 
//-------------------------------------------------------------------
 
QString TBlackCleanupStyle::getParamNames(int index) const
{
	switch (index) {
	case 2:
		return "ColorThres";
	case 3:
		return "WhiteThres";
	default:
		return TCleanupStyle::getParamNames(index);
	}
}
 
//-------------------------------------------------------------------
 
void TBlackCleanupStyle::getParamRange(int index, double &min, double &max) const
{
	switch (index) {
	case 2:
	case 3:
		min = 0;
		max = 100;
		break;
	default:
		TCleanupStyle::getParamRange(index, min, max);
	}
}
 
//-------------------------------------------------------------------
 
double TBlackCleanupStyle::getParamValue(TColorStyle::double_tag tag, int index) const
{
	switch (index) {
	case 2:
		return getColorThreshold();
	case 3:
		return getWhiteThreshold();
	default:
		return TCleanupStyle::getParamValue(tag, index);
	}
}
 
//-------------------------------------------------------------------
 
void TBlackCleanupStyle::setParamValue(int index, double value)
{
	switch (index) {
	case 2:
		setColorThreshold(value);
		break;
	case 3:
		setWhiteThreshold(value);
		break;
	default:
		TCleanupStyle::setParamValue(index, value);
	}
}
 
//-------------------------------------------------------------------
 
void TBlackCleanupStyle::setColorThreshold(double threshold)
{
	m_colorThreshold = threshold;
}
 
//-------------------------------------------------------------------
 
void TBlackCleanupStyle::setWhiteThreshold(double threshold)
{
	m_whiteThreshold = threshold;
}
 
namespace
{
TColorStyle::Declaration s0(new TBlackCleanupStyle());
TColorStyle::Declaration s1(new TColorCleanupStyle());
}