// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "components/exo/wayland/zcr_color_manager.h"

#include <chrome-color-management-server-protocol.h>
#include <wayland-server-core.h>

#include <algorithm>
#include <cstdint>
#include <memory>

#include "ash/shell.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/notimplemented.h"
#include "base/strings/stringprintf.h"
#include "components/exo/surface.h"
#include "components/exo/surface_observer.h"
#include "components/exo/wayland/server.h"
#include "components/exo/wayland/server_util.h"
#include "components/exo/wayland/wayland_display_observer.h"
#include "components/exo/wayland/wayland_display_output.h"
#include "components/exo/wm_helper.h"
#include "third_party/skia/include/core/SkColorSpace.h"
#include "third_party/skia/modules/skcms/skcms.h"
#include "ui/base/wayland/color_manager_util.h"
#include "ui/display/display.h"
#include "ui/display/display_features.h"
#include "ui/display/display_observer.h"
#include "ui/display/manager/display_manager.h"
#include "ui/display/screen.h"
#include "ui/display/types/display_constants.h"
#include "ui/gfx/color_space.h"
#include "ui/gfx/display_color_spaces.h"
#include "ui/gfx/geometry/triangle_f.h"

namespace exo {
namespace wayland {

namespace {

#define PARAM_TO_FLOAT(x) (x / 10000.f)
#define FLOAT_TO_PARAM(x) (x * 10000)

constexpr auto kDefaultColorSpace = gfx::ColorSpace::CreateSRGB();

// Wrapper around a |gfx::ColorSpace| that tracks additional data useful to
// the protocol. These live as wayland resource data.
class ColorManagerColorSpace {
 public:
  explicit ColorManagerColorSpace(gfx::ColorSpace color_space, uint32_t version)
      : color_space(color_space),
        eotf(ui::wayland::ToColorManagerEOTF(color_space, version)),
        matrix(ui::wayland::ToColorManagerMatrix(color_space.GetMatrixID(),
                                                 version)),
        range(ui::wayland::ToColorManagerRange(color_space.GetRangeID(),
                                               version)),
        primaries(color_space.GetPrimaries()) {}

  ColorManagerColorSpace(gfx::ColorSpace color_space,
                         zcr_color_manager_v1_eotf_names eotf,
                         zcr_color_manager_v1_matrix_names matrix,
                         zcr_color_manager_v1_range_names range,
                         SkColorSpacePrimaries primaries)
      : color_space(color_space),
        eotf(eotf),
        matrix(matrix),
        range(range),
        primaries(primaries) {}

  virtual ~ColorManagerColorSpace() = default;

  const gfx::ColorSpace color_space;
  const zcr_color_manager_v1_eotf_names eotf;
  const zcr_color_manager_v1_matrix_names matrix;
  const zcr_color_manager_v1_range_names range;
  const SkColorSpacePrimaries primaries;

  void SendColorSpaceInfo(wl_resource* color_space_resource) {
    SendCustomColorSpaceInfo(color_space_resource);
    if (wl_resource_get_version(color_space_resource) <
        ZCR_COLOR_SPACE_V1_COMPLETE_PARAMS_SINCE_VERSION) {
      zcr_color_space_v1_send_params(
          color_space_resource, eotf,
          static_cast<int>(FLOAT_TO_PARAM(primaries.fRX)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fRY)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fGX)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fGY)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fBX)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fBY)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fWX)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fWY)));
    } else {
      zcr_color_space_v1_send_complete_params(
          color_space_resource, eotf, matrix, range,
          static_cast<int>(FLOAT_TO_PARAM(primaries.fRX)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fRY)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fGX)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fGY)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fBX)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fBY)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fWX)),
          static_cast<int>(FLOAT_TO_PARAM(primaries.fWY)));
    }
    zcr_color_space_v1_send_done(color_space_resource);
  }

  virtual void SendCustomColorSpaceInfo(wl_resource* color_space_resource) {}
};

class NameBasedColorSpace final : public ColorManagerColorSpace {
 public:
  explicit NameBasedColorSpace(
      gfx::ColorSpace color_space,
      zcr_color_manager_v1_chromaticity_names chromaticity,
      zcr_color_manager_v1_eotf_names eotf,
      zcr_color_manager_v1_matrix_names matrix,
      zcr_color_manager_v1_range_names range,
      zcr_color_manager_v1_whitepoint_names whitepoint)
      : ColorManagerColorSpace(color_space,
                               eotf,
                               matrix,
                               range,
                               color_space.GetPrimaries()),
        chromaticity(chromaticity),
        whitepoint(whitepoint) {}

  const zcr_color_manager_v1_chromaticity_names chromaticity;
  const zcr_color_manager_v1_whitepoint_names whitepoint;

  void SendCustomColorSpaceInfo(wl_resource* color_space_resource) override {
    if (wl_resource_get_version(color_space_resource) <
        ZCR_COLOR_SPACE_V1_COMPLETE_NAMES_SINCE_VERSION) {
      zcr_color_space_v1_send_names(color_space_resource, eotf, chromaticity,
                                    whitepoint);
    } else {
      zcr_color_space_v1_send_complete_names(
          color_space_resource, eotf, chromaticity, whitepoint, matrix, range);
    }
  }
};

// Wrap a surface pointer and handle relevant events.
// TODO(b/207031122): This class should also watch for display color space
// changes and update clients.
class ColorManagerSurface final : public SurfaceObserver {
 public:
  explicit ColorManagerSurface(Server* server,
                               wl_resource* color_manager_surface_resource,
                               Surface* surface)
      : server_(server),
        color_manager_surface_resource_(color_manager_surface_resource),
        scoped_surface_(std::make_unique<ScopedSurface>(surface, this)) {}
  ColorManagerSurface(ColorManagerSurface&) = delete;
  ColorManagerSurface(ColorManagerSurface&&) = delete;
  ~ColorManagerSurface() override = default;

  // Safely set the color space (doing nothing if the surface was destroyed).
  void SetColorSpace(gfx::ColorSpace color_space) {
    Surface* surface = scoped_surface_->get();
    if (!surface)
      return;

    surface->SetColorSpace(color_space);
  }

 private:
  // SurfaceObserver:
  void OnDisplayChanged(Surface* surface,
                        int64_t old_display,
                        int64_t new_display) override {
    wl_client* client = wl_resource_get_client(color_manager_surface_resource_);
    wl_resource* display_resource =
        server_->GetOutputResource(client, new_display);

    if (!display_resource)
      return;

    const auto* wm_helper = WMHelper::GetInstance();

    if (old_display != display::kInvalidDisplayId) {
      const auto& old_display_info = wm_helper->GetDisplayInfo(old_display);
      const auto& new_display_info = wm_helper->GetDisplayInfo(new_display);

      if (old_display_info.display_color_spaces() ==
          new_display_info.display_color_spaces())
        return;
    }

    zcr_color_management_surface_v1_send_preferred_color_space(
        color_manager_surface_resource_, display_resource);
  }

  void OnSurfaceDestroying(Surface* surface) override {
    scoped_surface_.reset();
  }

  raw_ptr<Server> server_;
  raw_ptr<wl_resource> color_manager_surface_resource_;
  std::unique_ptr<ScopedSurface> scoped_surface_;
};

class ColorManagerObserver : public WaylandDisplayObserver {
 public:
  ColorManagerObserver(WaylandDisplayHandler* wayland_display_handler,
                       wl_resource* color_management_output_resource,
                       wl_resource* output_resource)
      : wayland_display_handler_(wayland_display_handler),
        color_management_output_resource_(color_management_output_resource),
        output_resource_(output_resource) {
    wayland_display_handler->AddObserver(this);
  }

  ColorManagerObserver(const ColorManagerObserver&) = delete;
  ColorManagerObserver& operator=(const ColorManagerObserver&) = delete;

  ~ColorManagerObserver() override {
    if (wayland_display_handler_)
      wayland_display_handler_->RemoveObserver(this);
  }

  gfx::ColorSpace GetColorSpace() const {
    if (!wayland_display_handler_) {
      LOG(WARNING) << "Wayland output was destroyed and not replaced.";
      return gfx::ColorSpace::CreateSRGB();
    }

    // Lacros only checks if the colorspace is HDR or not. So send display
    // colorspace if HDR is possible, otherwise just send SRGB.
    if (base::FeatureList::IsEnabled(
            display::features::kUseHDRTransferFunction)) {
      // Snapshot ColorSpace is only valid for ScreenAsh.
      return ash::Shell::Get()
          ->display_manager()
          ->GetDisplayInfo(wayland_display_handler_->id())
          .GetSnapshotColorSpace();
    }
    return gfx::ColorSpace::CreateSRGB();
  }

  WaylandDisplayHandler* wayland_display_handler() {
    return wayland_display_handler_;
  }

  wl_resource* GetOutputResource() { return output_resource_; }

  // Overriden from WaylandDisplayObserver.
  void OnOutputDestroyed() override {
    wayland_display_handler_->RemoveObserver(this);
    wayland_display_handler_ = nullptr;
  }

  // Overridden from WaylandDisplayObserver.
  bool SendDisplayMetrics(const display::Display& display,
                          uint32_t changed_metrics) override {
    if (!(changed_metrics &
          display::DisplayObserver::DISPLAY_METRIC_COLOR_SPACE)) {
      return false;
    }

    zcr_color_management_output_v1_send_color_space_changed(
        color_management_output_resource_);
    return true;
  }
  void SendActiveDisplay() override {}

 private:
  raw_ptr<WaylandDisplayHandler> wayland_display_handler_;
  const raw_ptr<wl_resource> color_management_output_resource_;
  raw_ptr<wl_resource, DanglingUntriaged> output_resource_;
};

////////////////////////////////////////////////////////////////////////////////
// zcr_color_management_color_space_v1_interface:

void color_space_get_information(struct wl_client* client,
                                 struct wl_resource* color_space_resource) {
  GetUserDataAs<ColorManagerColorSpace>(color_space_resource)
      ->SendColorSpaceInfo(color_space_resource);
}

void color_space_destroy(struct wl_client* client,
                         struct wl_resource* color_space_resource) {
  wl_resource_destroy(color_space_resource);
}

const struct zcr_color_space_v1_interface color_space_v1_implementation = {
    color_space_get_information, color_space_destroy};

////////////////////////////////////////////////////////////////////////////////
// zcr_color_management_output_v1_interface:

void color_management_output_get_color_space(
    struct wl_client* client,
    struct wl_resource* color_management_output_resource,
    uint32_t id) {
  auto* color_management_output_observer =
      GetUserDataAs<ColorManagerObserver>(color_management_output_resource);

  // create new zcr color space for the current color space of the output
  auto color_space = std::make_unique<ColorManagerColorSpace>(
      color_management_output_observer->GetColorSpace(),
      wl_resource_get_version(color_management_output_resource));

  wl_resource* color_space_resource = wl_resource_create(
      client, &zcr_color_space_v1_interface,
      wl_resource_get_version(color_management_output_resource), id);

  SetImplementation(color_space_resource, &color_space_v1_implementation,
                    std::move(color_space));
}

void color_management_output_destroy(
    struct wl_client* client,
    struct wl_resource* color_management_output_resource) {
  wl_resource_destroy(color_management_output_resource);
}

const struct zcr_color_management_output_v1_interface
    color_management_output_v1_implementation = {
        color_management_output_get_color_space,
        color_management_output_destroy};

////////////////////////////////////////////////////////////////////////////////
// zcr_color_management_surface_v1_interface:

void color_management_surface_set_alpha_mode(
    struct wl_client* client,
    struct wl_resource* color_management_surface_resource,
    uint32_t alpha_mode) {
  NOTIMPLEMENTED();
}

void color_management_surface_set_extended_dynamic_range(
    struct wl_client* client,
    struct wl_resource* color_management_surface_resource,
    uint32_t value) {
  NOTIMPLEMENTED();
}

void color_management_surface_set_color_space(
    struct wl_client* client,
    struct wl_resource* color_management_surface_resource,
    struct wl_resource* color_space_resource,
    uint32_t render_intent) {
  auto* color_manager_color_space =
      GetUserDataAs<ColorManagerColorSpace>(color_space_resource);
  GetUserDataAs<ColorManagerSurface>(color_management_surface_resource)
      ->SetColorSpace(color_manager_color_space->color_space);
}

void color_management_surface_set_default_color_space(
    struct wl_client* client,
    struct wl_resource* color_management_surface_resource) {
  GetUserDataAs<ColorManagerSurface>(color_management_surface_resource)
      ->SetColorSpace(kDefaultColorSpace);
}

void color_management_surface_destroy(
    struct wl_client* client,
    struct wl_resource* color_management_surface_resource) {
  GetUserDataAs<ColorManagerSurface>(color_management_surface_resource)
      ->SetColorSpace(kDefaultColorSpace);

  wl_resource_destroy(color_management_surface_resource);
}

const struct zcr_color_management_surface_v1_interface
    color_management_surface_v1_implementation = {
        color_management_surface_set_alpha_mode,
        color_management_surface_set_extended_dynamic_range,
        color_management_surface_set_color_space,
        color_management_surface_set_default_color_space,
        color_management_surface_destroy};

////////////////////////////////////////////////////////////////////////////////
// zcr_color_manager_v1_interface:

void CreateColorSpace(struct wl_client* client,
                      int32_t resource_version,
                      int32_t color_space_creator_id,
                      std::unique_ptr<ColorManagerColorSpace> color_space) {
  wl_resource* color_space_resource = wl_resource_create(
      client, &zcr_color_space_v1_interface, resource_version, /*id=*/0);
  wl_resource* color_space_creator_resource =
      wl_resource_create(client, &zcr_color_space_creator_v1_interface,
                         resource_version, color_space_creator_id);
  SetImplementation(color_space_resource, &color_space_v1_implementation,
                    std::move(color_space));
  zcr_color_space_creator_v1_send_created(color_space_creator_resource,
                                          color_space_resource);
  // The resource should be immediately destroyed once it's sent its event.
  wl_resource_destroy(color_space_creator_resource);
}

void SendColorCreationError(struct wl_client* client,
                            int32_t color_space_creator_id,
                            int32_t error_flags) {
  wl_resource* color_space_creator_resource = wl_resource_create(
      client, &zcr_color_space_creator_v1_interface, 1, color_space_creator_id);

  zcr_color_space_creator_v1_send_error(color_space_creator_resource,
                                        error_flags);

  // The resource should be immediately destroyed once it's sent its event.
  wl_resource_destroy(color_space_creator_resource);
}

void color_manager_create_color_space_from_icc(
    struct wl_client* client,
    struct wl_resource* color_manager_resource,
    uint32_t id,
    int32_t icc) {
  NOTIMPLEMENTED();
}

// Not all MatrixID and RangeID combinations are supported in DRM/KMS
// so alter their values to something more acceptable in those cases.
void adjust_matrix_and_range(gfx::ColorSpace::MatrixID* matrix_id,
                             gfx::ColorSpace::RangeID* range_id) {
  // TODO(b/233667677): Passing MatrixID=BT2020_NCL and RangeID=LIMITED results
  // in improper rendering, until that is supported default to {RGB, FULL} which
  // is identical to composited video values.
  if (*matrix_id == gfx::ColorSpace::MatrixID::BT2020_NCL) {
    *matrix_id = gfx::ColorSpace::MatrixID::RGB;
    *range_id = gfx::ColorSpace::RangeID::FULL;
  }
}

// TODO(b/206971557): This doesn't handle the user-set white point yet.
void color_manager_create_color_space_from_complete_names(
    struct wl_client* client,
    struct wl_resource* color_manager_resource,
    uint32_t id,
    uint32_t eotf,
    uint32_t chromaticity,
    uint32_t whitepoint,
    uint32_t matrix,
    uint32_t range) {
  uint32_t error_flags = 0;

  auto chromaticity_id = gfx::ColorSpace::PrimaryID::INVALID;
  const auto maybe_primary = ui::wayland::kChromaticityMap.find(chromaticity);
  if (maybe_primary != std::end(ui::wayland::kChromaticityMap)) {
    chromaticity_id = maybe_primary->second.primary;
  } else {
    DLOG(ERROR) << "Unable to find named chromaticity for id=" << chromaticity;
    error_flags |= ZCR_COLOR_SPACE_CREATOR_V1_CREATION_ERROR_BAD_PRIMARIES;
  }

  auto matrix_id = gfx::ColorSpace::MatrixID::INVALID;
  const auto maybe_matrix = ui::wayland::kMatrixMap.find(matrix);
  if (maybe_matrix != std::end(ui::wayland::kMatrixMap)) {
    matrix_id = maybe_matrix->second.matrix;
  } else {
    DLOG(ERROR) << "Unable to find named matrix for id=" << matrix;
    wl_resource_post_error(color_manager_resource,
                           ZCR_COLOR_MANAGER_V1_ERROR_BAD_ENUM,
                           "Unable to find a matrix matching %d", matrix);
  }

  auto range_id = gfx::ColorSpace::RangeID::INVALID;
  const auto maybe_range = ui::wayland::kRangeMap.find(range);
  if (maybe_range != std::end(ui::wayland::kRangeMap)) {
    range_id = maybe_range->second.range;
  } else {
    DLOG(ERROR) << "Unable to find named range for id=" << range;
    wl_resource_post_error(color_manager_resource,
                           ZCR_COLOR_MANAGER_V1_ERROR_BAD_ENUM,
                           "Unable to find a range matching %d", range);
  }
  adjust_matrix_and_range(&matrix_id, &range_id);

  auto eotf_id = gfx::ColorSpace::TransferID::INVALID;
  const auto maybe_eotf = ui::wayland::kEotfMap.find(eotf);
  if (maybe_eotf != std::end(ui::wayland::kEotfMap)) {
    eotf_id = maybe_eotf->second.transfer;
  } else if (ui::wayland::kHDRTransferMap.contains(eotf)) {
    auto transfer_fn = ui::wayland::kHDRTransferMap.at(eotf).transfer_fn;
    CreateColorSpace(
        client, wl_resource_get_version(color_manager_resource), id,
        std::make_unique<NameBasedColorSpace>(
            gfx::ColorSpace(chromaticity_id,
                            gfx::ColorSpace::TransferID::CUSTOM_HDR, matrix_id,
                            range_id, nullptr, &transfer_fn),
            static_cast<zcr_color_manager_v1_chromaticity_names>(chromaticity),
            static_cast<zcr_color_manager_v1_eotf_names>(eotf),
            static_cast<zcr_color_manager_v1_matrix_names>(matrix),
            static_cast<zcr_color_manager_v1_range_names>(range),
            static_cast<zcr_color_manager_v1_whitepoint_names>(whitepoint)));
    return;
  } else {
    DLOG(ERROR) << "Unable to find named eotf for id=" << eotf;
    wl_resource_post_error(color_manager_resource,
                           ZCR_COLOR_MANAGER_V1_ERROR_BAD_ENUM,
                           "Unable to find an EOTF matching %d", eotf);
  }

  if (error_flags)
    SendColorCreationError(client, id, error_flags);

  CreateColorSpace(
      client, wl_resource_get_version(color_manager_resource), id,
      std::make_unique<NameBasedColorSpace>(
          gfx::ColorSpace(chromaticity_id, eotf_id, matrix_id, range_id),
          static_cast<zcr_color_manager_v1_chromaticity_names>(chromaticity),
          static_cast<zcr_color_manager_v1_eotf_names>(eotf),
          static_cast<zcr_color_manager_v1_matrix_names>(matrix),
          static_cast<zcr_color_manager_v1_range_names>(range),
          static_cast<zcr_color_manager_v1_whitepoint_names>(whitepoint)));
}

void color_manager_create_color_space_from_names_DEPRECATED(
    struct wl_client* client,
    struct wl_resource* color_manager_resource,
    uint32_t id,
    uint32_t eotf,
    uint32_t chromaticity,
    uint32_t whitepoint) {
  LOG(WARNING) << "Deprecated request:  create_color_space_from_names";
  color_manager_create_color_space_from_complete_names(
      client, color_manager_resource, id, eotf,
      ZCR_COLOR_MANAGER_V1_MATRIX_NAMES_RGB,
      ZCR_COLOR_MANAGER_V1_RANGE_NAMES_FULL, chromaticity, whitepoint);
}

void color_manager_create_color_space_from_complete_params(
    struct wl_client* client,
    struct wl_resource* color_manager_resource,
    uint32_t id,
    uint32_t eotf,
    uint32_t matrix,
    uint32_t range,
    uint32_t primary_r_x,
    uint32_t primary_r_y,
    uint32_t primary_g_x,
    uint32_t primary_g_y,
    uint32_t primary_b_x,
    uint32_t primary_b_y,
    uint32_t white_point_x,
    uint32_t white_point_y) {
  SkColorSpacePrimaries primaries = {
      PARAM_TO_FLOAT(primary_r_x),   PARAM_TO_FLOAT(primary_r_y),
      PARAM_TO_FLOAT(primary_g_x),   PARAM_TO_FLOAT(primary_g_y),
      PARAM_TO_FLOAT(primary_b_x),   PARAM_TO_FLOAT(primary_b_y),
      PARAM_TO_FLOAT(white_point_x), PARAM_TO_FLOAT(white_point_y)};

  gfx::PointF r(primaries.fRX, primaries.fRY);
  gfx::PointF g(primaries.fGX, primaries.fGY);
  gfx::PointF b(primaries.fBX, primaries.fBY);
  gfx::PointF w(primaries.fWX, primaries.fWY);
  if (!gfx::PointIsInTriangle(w, r, g, b)) {
    auto error_message = base::StringPrintf(
        "White point %s must be inside of the triangle r=%s g=%s b=%s",
        w.ToString().c_str(), r.ToString().c_str(), g.ToString().c_str(),
        b.ToString().c_str());
    DLOG(ERROR) << error_message;
    wl_resource_post_error(color_manager_resource,
                           ZCR_COLOR_MANAGER_V1_ERROR_BAD_PARAM, "%s",
                           error_message.c_str());
    return;
  }

  auto matrix_id = gfx::ColorSpace::MatrixID::INVALID;
  const auto maybe_matrix = ui::wayland::kMatrixMap.find(matrix);
  if (maybe_matrix != std::end(ui::wayland::kMatrixMap)) {
    matrix_id = maybe_matrix->second.matrix;
  } else {
    DLOG(ERROR) << "Unable to find named matrix for id=" << matrix;
    wl_resource_post_error(color_manager_resource,
                           ZCR_COLOR_MANAGER_V1_ERROR_BAD_ENUM,
                           "Unable to find a matrix matching %d", matrix);
  }

  auto range_id = gfx::ColorSpace::RangeID::INVALID;
  const auto maybe_range = ui::wayland::kRangeMap.find(range);
  if (maybe_range != std::end(ui::wayland::kRangeMap)) {
    range_id = maybe_range->second.range;
  } else {
    DLOG(ERROR) << "Unable to find named range for id=" << range;
    wl_resource_post_error(color_manager_resource,
                           ZCR_COLOR_MANAGER_V1_ERROR_BAD_ENUM,
                           "Unable to find a range matching %d", range);
  }
  adjust_matrix_and_range(&matrix_id, &range_id);

  auto eotf_id = gfx::ColorSpace::TransferID::INVALID;
  const auto maybe_eotf = ui::wayland::kEotfMap.find(eotf);
  if (maybe_eotf != std::end(ui::wayland::kEotfMap)) {
    eotf_id = maybe_eotf->second.transfer;
  } else {
    DLOG(ERROR) << "Unable to find named transfer function for id=" << eotf;
    wl_resource_post_error(color_manager_resource,
                           ZCR_COLOR_MANAGER_V1_ERROR_BAD_ENUM,
                           "Unable to find an EOTF matching %d", eotf);
    return;
  }

  skcms_Matrix3x3 xyzd50 = {};
  if (!primaries.toXYZD50(&xyzd50)) {
    DLOG(ERROR) << base::StringPrintf(
        "Unable to translate color space primaries to XYZD50: "
        "{%f, %f, %f, %f, %f, %f, %f, %f}",
        primaries.fRX, primaries.fRY, primaries.fGX, primaries.fGY,
        primaries.fBX, primaries.fBY, primaries.fWX, primaries.fWY);

    SendColorCreationError(
        client, id, ZCR_COLOR_SPACE_CREATOR_V1_CREATION_ERROR_BAD_PRIMARIES);
    return;
  }

  auto primary_id = gfx::ColorSpace::PrimaryID::CUSTOM;
  CreateColorSpace(client, wl_resource_get_version(color_manager_resource), id,
                   std::make_unique<ColorManagerColorSpace>(
                       gfx::ColorSpace(primary_id, eotf_id, matrix_id, range_id,
                                       &xyzd50, nullptr),
                       kZcrColorManagerVersion));
}

void color_manager_create_color_space_from_params_DEPRECATED(
    struct wl_client* client,
    struct wl_resource* color_manager_resource,
    uint32_t id,
    uint32_t eotf,
    uint32_t primary_r_x,
    uint32_t primary_r_y,
    uint32_t primary_g_x,
    uint32_t primary_g_y,
    uint32_t primary_b_x,
    uint32_t primary_b_y,
    uint32_t white_point_x,
    uint32_t white_point_y) {
  LOG(WARNING) << "Deprecated request:  create_color_space_from_params";
  color_manager_create_color_space_from_complete_params(
      client, color_manager_resource, id, eotf,
      ZCR_COLOR_MANAGER_V1_MATRIX_NAMES_RGB,
      ZCR_COLOR_MANAGER_V1_RANGE_NAMES_FULL, primary_r_x, primary_r_y,
      primary_g_x, primary_g_y, primary_b_x, primary_b_y, white_point_x,
      white_point_y);
}

void color_manager_get_color_management_output(
    struct wl_client* client,
    struct wl_resource* color_manager_resource,
    uint32_t id,
    struct wl_resource* output) {
  wl_resource* color_management_output_resource =
      wl_resource_create(client, &zcr_color_management_output_v1_interface,
                         wl_resource_get_version(color_manager_resource), id);
  auto* display_handler = GetUserDataAs<WaylandDisplayHandler>(output);
  auto color_management_output_observer =
      std::make_unique<ColorManagerObserver>(
          display_handler, color_management_output_resource, output);
  SetImplementation(color_management_output_resource,
                    &color_management_output_v1_implementation,
                    std::move(color_management_output_observer));
}

void color_manager_get_color_management_surface(
    struct wl_client* client,
    struct wl_resource* color_manager_resource,
    uint32_t id,
    struct wl_resource* surface_resource) {
  wl_resource* color_management_surface_resource =
      wl_resource_create(client, &zcr_color_management_surface_v1_interface,
                         wl_resource_get_version(color_manager_resource), id);

  SetImplementation(color_management_surface_resource,
                    &color_management_surface_v1_implementation,
                    std::make_unique<ColorManagerSurface>(
                        GetUserDataAs<Server>(color_manager_resource),
                        color_management_surface_resource,
                        GetUserDataAs<Surface>(surface_resource)));
}

void color_manager_destroy(struct wl_client* client,
                           struct wl_resource* color_manager_resource) {
  wl_resource_destroy(color_manager_resource);
}

const struct zcr_color_manager_v1_interface color_manager_v1_implementation = {
    color_manager_create_color_space_from_icc,
    color_manager_create_color_space_from_names_DEPRECATED,
    color_manager_create_color_space_from_params_DEPRECATED,
    color_manager_get_color_management_output,
    color_manager_get_color_management_surface,
    color_manager_destroy,
    color_manager_create_color_space_from_complete_names,
    color_manager_create_color_space_from_complete_params};

}  // namespace

void bind_zcr_color_manager(wl_client* client,
                            void* data,
                            uint32_t version,
                            uint32_t id) {
  wl_resource* color_manager_resource =
      wl_resource_create(client, &zcr_color_manager_v1_interface,
                         std::min(version, kZcrColorManagerVersion), id);

  wl_resource_set_implementation(color_manager_resource,
                                 &color_manager_v1_implementation, data,
                                 /*destroy=*/nullptr);
}

}  // namespace wayland
}  // namespace exo