#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 QObject::tr("Brightness");

  case 1:

    return QObject::tr("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) QObject::tr("HRange");

  if (index == 3) QObject::tr("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 QObject::tr("ColorThres");

  case 3:

    return QObject::tr("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());

}