#include "tcolorvalue.h"

//===================================================================

void TColorValue::getHsv(int &ih, int &is, int &iv) const {
  double max, min;
  double delta;
  double r, g, b;
  double v, s, h;
  r = m_r;
  g = m_g;
  b = m_b;
  assert(0 <= r && r <= 1);
  assert(0 <= g && g <= 1);
  assert(0 <= b && b <= 1);

  max = std::max({r, g, b});
  min = std::min({r, g, b});

  v = max;

  if (max != 0)
    s = (max - min) / max;
  else
    s = 0;

  if (s == 0)
    h = 0;
  else {
    delta = max - min;

    if (r == max)
      h = (g - b) / delta;
    else if (g == max)
      h = 2 + (b - r) / delta;
    else if (b == max)
      h = 4 + (r - g) / delta;
    h   = h * 60;
    if (h < 0) h += 360;
  }
  assert(0 <= h && h <= 360);
  assert(0 <= s && s <= 1);
  assert(0 <= v && v <= 1);
  ih = (int)h;
  is = (int)(s * 100);
  iv = (int)(v * 100);
}

//===================================================================

void TColorValue::getHls(double &h, double &l, double &s) const {
  double max, min;
  double delta;

  max = std::max({m_r, m_g, m_b});
  min = std::min({m_r, m_g, m_b});

  l = (max + min) / 2;

  if (max == min) {
    s = 0;
    h = 0;
  } else {
    if (l <= 0.5)
      s = (max - min) / (max + min);
    else
      s = (max - min) / (2 - max - min);

    delta = max - min;
    if (m_r == max)
      h = (m_g - m_b) / delta;
    else if (m_g == max)
      h = 2 + (m_b - m_r) / delta;
    else if (m_b == max)
      h = 4 + (m_r - m_g) / delta;

    h = h * 60;
    if (h < 0) h += 360;
  }
}

//===================================================================

void TColorValue::setHsv(int h, int s, int v) {
  int i;
  double p, q, t, f;
  double hue, sat, value;

  hue   = h;
  sat   = 0.01 * s;
  value = 0.01 * v;

  assert(0 <= hue && hue <= 360);
  assert(0 <= sat && sat <= 1);
  assert(0 <= value && value <= 1);

  if (sat == 0) {
    m_r = m_g = m_b = value;
  } else {
    if (hue == 360) hue = 0;

    hue = hue / 60;
    i   = (int)hue;
    f   = hue - i;
    p   = tcrop(value * (1 - sat), 0., 1.);
    q   = tcrop(value * (1 - (sat * f)), 0., 1.);
    t   = tcrop(value * (1 - (sat * (1 - f))), 0., 1.);

    switch (i) {
    case 0:
      m_r = value;
      m_g = t;
      m_b = p;
      break;
    case 1:
      m_r = q;
      m_g = value;
      m_b = p;
      break;
    case 2:
      m_r = p;
      m_g = value;
      m_b = t;
      break;
    case 3:
      m_r = p;
      m_g = q;
      m_b = value;
      break;
    case 4:
      m_r = t;
      m_g = p;
      m_b = value;
      break;
    case 5:
      m_r = value;
      m_g = p;
      m_b = q;
      break;
    }
  }
}

//===================================================================

void TColorValue::getRgb(int &r, int &g, int &b) const {
  r = (int)(m_r * 255 + 0.5);
  g = (int)(m_g * 255 + 0.5);
  b = (int)(m_b * 255 + 0.5);
}

//===================================================================

TPixel32 TColorValue::getPixel() const {
  int r, g, b;
  getRgb(r, g, b);
  return TPixel32(r, g, b, (int)(m_m * 255.0 + 0.5));
}

//===================================================================

void TColorValue::setRgb(int r, int g, int b) {
  m_r = r / 255.0;
  m_g = g / 255.0;
  m_b = b / 255.0;
}

//===================================================================

void TColorValue::setPixel(const TPixel32 &src) {
  setRgb(src.r, src.g, src.b);
  m_m = src.m / 255.0;
}