#include "gtest/gtest.h"

#include <cmath>

#include "color.h"

static std::array<uint8_t, 3> white_rgb = {255, 255, 255};
static std::array<double, 3> white_cielab = {100, 0, 0};
static std::array<double, 3> white_cieluv = {100, 0, 0};
static std::array<double, 3> white_oklab = {1, 0, 0};

static std::array<uint8_t, 3> black_rgb = {0, 0, 0};
static std::array<double, 3> black_cielab = {0, 0, 0};
static std::array<double, 3> black_cieluv = {0, 0, 0};
static std::array<double, 3> black_oklab = {0, 0, 0};

static std::array<uint8_t, 3> tiny_rgb = {4, 31, 13};
static std::array<double, 3> tiny_cielab = {9.2779, -14.8940, 8.1560};
static std::array<double, 3> tiny_cieluv = {9.2779, -7.2368, 6.6930};
static std::array<double, 3> tiny_oklab = {0.2125, -0.0429, 0.023};

static std::array<uint8_t, 3> big_rgb = {247, 252, 255};
static std::array<double, 3> big_cielab = {98.6759, -1.1049, -2.006};
static std::array<double, 3> big_cieluv = {98.6759, -2.9261, -2.9267};
static std::array<double, 3> big_oklab = {0.9882, -0.0039, -0.0054};


static std::array<uint8_t, 3> medium_rgb = {89, 69, 219};
static std::array<double, 3> medium_cielab = {40.3991, 49.4085, -73.8982};
static std::array<double, 3> medium_cieluv = {40.3991, -2.9720, -108.8107};
static std::array<double, 3> medium_oklab = {0.5074, 0.0429, -0.2129};

static double round_to_4_decimals(double val) {
  return std::round(val * 10000.) / 10000.;
}

static void assert_equal_color_arr(Color c, std::array<double, 3> a) {
  ASSERT_DOUBLE_EQ(round_to_4_decimals(c.v1), a[0]);
  ASSERT_DOUBLE_EQ(round_to_4_decimals(c.v2), a[1]);
  ASSERT_DOUBLE_EQ(round_to_4_decimals(c.v3), a[2]);
}

static void assert_equal_rgb(std::array<double, 3> a1, std::array<uint8_t, 3> a2) {
  ASSERT_EQ(static_cast<int>(round(a1[0]*255.)), a2[0]);
  ASSERT_EQ(static_cast<int>(round(a1[1]*255.)), a2[1]);
  ASSERT_EQ(static_cast<int>(round(a1[2]*255.)), a2[2]);
}

////

TEST(RgbToOklab, White) {
  auto color = Color::from_rgb(white_rgb, ColorSpace::OKLAB);
  assert_equal_color_arr(color, white_oklab);
}

TEST(RgbToOklab, Black) {
  auto color = Color::from_rgb(black_rgb, ColorSpace::OKLAB);
  assert_equal_color_arr(color, black_oklab);
}

TEST(RgbToOklab, TinyValues) {
  auto color = Color::from_rgb(tiny_rgb, ColorSpace::OKLAB);
  assert_equal_color_arr(color, tiny_oklab);
}

TEST(RgbToOklab, BigValues) {
  auto color = Color::from_rgb(big_rgb, ColorSpace::OKLAB);
  assert_equal_color_arr(color, big_oklab);
}

TEST(RgbToOklab, MediumValues) {
  auto color = Color::from_rgb(medium_rgb, ColorSpace::OKLAB);
  assert_equal_color_arr(color, medium_oklab);
}

////

TEST(OklabToRgb, White) {
  auto color = Color{white_oklab, ColorSpace::OKLAB}.to_normalized_rgb();
  assert_equal_rgb(color, white_rgb);
}

TEST(OklabToRgb, Black) {
  auto color = Color{black_oklab, ColorSpace::OKLAB}.to_normalized_rgb();
  assert_equal_rgb(color, black_rgb);
}

TEST(OklabToRgb, TinyValues) {
  auto color = Color{tiny_oklab, ColorSpace::OKLAB}.to_normalized_rgb();
  assert_equal_rgb(color, tiny_rgb);
}

TEST(OklabToRgb, BigValues) {
  auto color = Color{big_oklab, ColorSpace::OKLAB}.to_normalized_rgb();
  assert_equal_rgb(color, big_rgb);
}

TEST(OklabToRgb, MediumValues) {
  auto color = Color{medium_oklab, ColorSpace::OKLAB}.to_normalized_rgb();
  assert_equal_rgb(color, medium_rgb);
}

////

TEST(RgbToCielab, White) {
  auto color = Color::from_rgb(white_rgb, ColorSpace::CIELAB);
  assert_equal_color_arr(color, white_cielab);
}

TEST(RgbToCielab, Black) {
  auto color = Color::from_rgb(black_rgb, ColorSpace::CIELAB);
  assert_equal_color_arr(color, black_cielab);
}

TEST(RgbToCielab, TinyValues) {
  auto color = Color::from_rgb(tiny_rgb, ColorSpace::CIELAB);
  assert_equal_color_arr(color, tiny_cielab);
}

TEST(RgbToCielab, BigValues) {
  auto color = Color::from_rgb(big_rgb, ColorSpace::CIELAB);
  assert_equal_color_arr(color, big_cielab);
}

TEST(RgbToCielab, MediumValues) {
  auto color = Color::from_rgb(medium_rgb, ColorSpace::CIELAB);
  assert_equal_color_arr(color, medium_cielab);
}

////

TEST(CielabToRgb, White) {
  auto color = Color{white_cielab, ColorSpace::CIELAB}.to_normalized_rgb();
  assert_equal_rgb(color, white_rgb);
}

TEST(CielabToRgb, Black) {
  auto color = Color{black_cielab, ColorSpace::CIELAB}.to_normalized_rgb();
  assert_equal_rgb(color, black_rgb);
}

TEST(CielabToRgb, TinyValues) {
  auto color = Color{tiny_cielab, ColorSpace::CIELAB}.to_normalized_rgb();
  assert_equal_rgb(color, tiny_rgb);
}

TEST(CielabToRgb, BigValues) {
  auto color = Color{big_cielab, ColorSpace::CIELAB}.to_normalized_rgb();
  assert_equal_rgb(color, big_rgb);
}

TEST(CielabToRgb, MediumValues) {
  auto color = Color{medium_cielab, ColorSpace::CIELAB}.to_normalized_rgb();
  assert_equal_rgb(color, medium_rgb);
}

/////

TEST(RgbToCieluv, White) {
  auto color = Color::from_rgb(white_rgb, ColorSpace::CIELUV);
  assert_equal_color_arr(color, white_cieluv);
}

TEST(RgbToCieluv, Black) {
  auto color = Color::from_rgb(black_rgb, ColorSpace::CIELUV);
  assert_equal_color_arr(color, black_cieluv);
}

TEST(RgbToCieluv, TinyValues) {
  auto color = Color::from_rgb(tiny_rgb, ColorSpace::CIELUV);
  assert_equal_color_arr(color, tiny_cieluv);
}

TEST(RgbToCieluv, BigValues) {
  auto color = Color::from_rgb(big_rgb, ColorSpace::CIELUV);
  assert_equal_color_arr(color, big_cieluv);
}

TEST(RgbToCieluv, MediumValues) {
  auto color = Color::from_rgb(medium_rgb, ColorSpace::CIELUV);
  assert_equal_color_arr(color, medium_cieluv);
}

////

TEST(CieluvToRgb, White) {
  auto color = Color{white_cieluv, ColorSpace::CIELUV}.to_normalized_rgb();
  assert_equal_rgb(color, white_rgb);
}

TEST(CieluvToRgb, Black) {
  auto color = Color{black_cieluv, ColorSpace::CIELUV}.to_normalized_rgb();
  assert_equal_rgb(color, black_rgb);
}

TEST(CieluvToRgb, TinyValues) {
  auto color = Color{tiny_cieluv, ColorSpace::CIELUV}.to_normalized_rgb();
  assert_equal_rgb(color, tiny_rgb);
}

TEST(CieluvToRgb, BigValues) {
  auto color = Color{big_cieluv, ColorSpace::CIELUV}.to_normalized_rgb();
  assert_equal_rgb(color, big_rgb);
}

TEST(CieluvToRgb, MediumValues) {
  auto color = Color{medium_cieluv, ColorSpace::CIELUV}.to_normalized_rgb();
  assert_equal_rgb(color, medium_rgb);
}

////

TEST(RgbNormalisation, FromRgb) {
  auto color1 = Color::from_rgb(medium_rgb);
  auto color2 = Color::from_normalized_rgb({
      static_cast<double>(medium_rgb[0])/255.,
      static_cast<double>(medium_rgb[1])/255.,
      static_cast<double>(medium_rgb[2])/255.,
  });
  ASSERT_DOUBLE_EQ(color1.v1, color2.v1);
  ASSERT_DOUBLE_EQ(color1.v2, color2.v2);
  ASSERT_DOUBLE_EQ(color1.v3, color2.v3);
}

TEST(RgbNormalisation, ToRgb) {
  auto color1 = Color{medium_cielab}.to_rgb();
  auto color2 = Color{medium_cielab}.to_normalized_rgb();
  assert_equal_rgb(color2, color1);
}