#include "tpixelutils.h"

#include "tvectorimage.h"

#include "trop.h"

#include <qapplication></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());

}