#include "_pattern_cache.h"

#include "_mplcairo.h"

#include "_macros.h"

namespace mplcairo {

dash_t convert_dash(cairo_t* cr)
{
  auto const& dash_count = cairo_get_dash_count(cr);
  auto const& dashes = std::unique_ptr<double[]>{new double[dash_count]};
  double offset;
  cairo_get_dash(cr, dashes.get(), &offset);
  return {
    offset,
    std::string{
      reinterpret_cast<char*>(dashes.get()),
      dash_count * sizeof(dashes[0])}};
}

void set_dashes(cairo_t* cr, dash_t dash)
{
  auto& [offset, buf] = dash;
  cairo_set_dash(
    cr,
    reinterpret_cast<double*>(buf.data()),
    buf.size() / sizeof(double),
    offset);
}

void PatternCache::CacheKey::draw(
  cairo_t* cr, double x, double y, rgba_t color)
{
  auto const& m = cairo_matrix_t{
    matrix.xx, matrix.yx,
    matrix.xy, matrix.yy,
    matrix.x0 + x, matrix.y0 + y};
  switch (draw_func) {
    case draw_func_t::Fill:
      fill_and_stroke_exact(cr, path, &m, color, {});
      break;
    case draw_func_t::Stroke:
      cairo_save(cr);
      cairo_set_line_width(cr, linewidth);
      cairo_set_miter_limit(
        cr, detail::MITER_LIMIT >= 0 ? detail::MITER_LIMIT : linewidth);
      set_dashes(cr, dash);
      cairo_set_line_cap(cr, capstyle);
      cairo_set_line_join(cr, joinstyle);
      fill_and_stroke_exact(cr, path, &m, {}, color);
      cairo_restore(cr);
      break;
  }
}

size_t PatternCache::Hash::operator()(py::handle const& path) const
{
  return std::hash<void*>{}(path.ptr());
}

size_t PatternCache::Hash::operator()(CacheKey const& key) const
{
  // std::tuple is not hashable by default.  Reuse boost::hash_combine.
  size_t hashes[] = {
    std::hash<void*>{}(key.path.ptr()),
    std::hash<double>{}(key.matrix.xx), std::hash<double>{}(key.matrix.xy),
    std::hash<double>{}(key.matrix.yx), std::hash<double>{}(key.matrix.yy),
    std::hash<double>{}(key.matrix.x0), std::hash<double>{}(key.matrix.y0),
    std::hash<draw_func_t>{}(key.draw_func),
    std::hash<double>{}(key.linewidth),
    std::hash<double>{}(std::get<0>(key.dash)),
    std::hash<std::string>{}(std::get<1>(key.dash)),
    std::hash<cairo_line_cap_t>{}(key.capstyle),
    std::hash<cairo_line_join_t>{}(key.joinstyle)};
  auto seed = size_t{0};
  for (size_t i = 0; i < sizeof(hashes) / sizeof(hashes[0]); ++i) {
    seed ^= hashes[i] + 0x9e3779b9 + (seed << 6) + (seed >> 2);
  }
  return seed;
}

bool PatternCache::EqualTo::operator()(
  CacheKey const& lhs, CacheKey const& rhs) const
{
  return
    lhs.path.is(rhs.path)
    && lhs.matrix.xx == rhs.matrix.xx && lhs.matrix.xy == rhs.matrix.xy
    && lhs.matrix.yx == rhs.matrix.yx && lhs.matrix.yy == rhs.matrix.yy
    && lhs.matrix.x0 == rhs.matrix.x0 && lhs.matrix.y0 == rhs.matrix.y0
    && lhs.draw_func == rhs.draw_func
    && lhs.linewidth == rhs.linewidth && lhs.dash == rhs.dash
    && lhs.capstyle == rhs.capstyle && lhs.joinstyle == rhs.joinstyle;
}

PatternCache::PatternCache(double threshold) : threshold_{threshold}
{
  if (threshold >= 1. / 16) {  // NOTE: Arbitrary limit.
    n_subpix_ = std::ceil(1 / threshold);
  } else {
    n_subpix_ = 0;
  }
}

PatternCache::~PatternCache()
{
  for (auto const& [key, entry]: patterns_) {
    (void)key;
    for (size_t i = 0; i < n_subpix_ * n_subpix_; ++i) {
      cairo_pattern_destroy(entry.patterns[i]);
    }
  }
}

void PatternCache::mask(
  cairo_t* cr, double cr_width, double cr_height,
  py::handle path,
  cairo_matrix_t matrix,
  draw_func_t draw_func,
  double linewidth,
  dash_t dash,
  double x, double y)
{
  // The matrix gets cached, so we may as well take it by value instead of by
  // pointer.
  auto key =
    draw_func == draw_func_t::Fill
    ? CacheKey{
      path, matrix, draw_func, 0, {},
      static_cast<cairo_line_cap_t>(-1), static_cast<cairo_line_join_t>(-1)}
    : CacheKey{
      path, matrix, draw_func, linewidth, dash,
      cairo_get_line_cap(cr), cairo_get_line_join(cr)};
  auto const& draw_direct = [&] {
    double r, g, b, a;
    CAIRO_CHECK(cairo_pattern_get_rgba, cairo_get_source(cr), &r, &g, &b, &a);
    key.draw(cr, x, y, {r, g, b, a});
  };
  if (!n_subpix_) {
    draw_direct();
    return;
  }
  // Get the untransformed path bbox with cairo_path_extents(), so that we
  // know how to quantize the transformation matrix.  Note that this ignores
  // the additional size from linewidths, including miters (they will only
  // contribute a constant offset).
  // Importantly, cairo_*_extents() ignores surface dimensions and clipping.
  auto it_bboxes = bboxes_.find(key.path);
  if (it_bboxes == bboxes_.end()) {
    auto const& id = cairo_matrix_t{1, 0, 0, 1, 0, 0};
    load_path_exact(cr, key.path, &id);
    double x0, y0, x1, y1;
    cairo_path_extents(cr, &x0, &y0, &x1, &y1);
    bool ok;
    std::tie(it_bboxes, ok) =
      bboxes_.emplace(key.path, cairo_rectangle_t{x0, y0, x1 - x0, y1 - y0});
    if (!ok) {
      throw std::runtime_error{"unexpected insertion failure into cache"};
    }
  }
  // Approximate ("quantize") the transform matrix, so that the transformed
  // path is within 3x(threshold/3) of the path transformed by the original
  // matrix.  1x threshold will be added by the patterns_ cache.
  // If the entire object is within the threshold of the origin in either
  // direction, then draw it directly, as doing otherwise would be highly
  // inaccurate (see e.g. :mpltest:`test_mplot3d.test_quiver3d`).
  auto const& bbox = it_bboxes->second;
  // Binding by reference results in dangling reference.
  auto const x_max = std::max(std::abs(bbox.x), std::abs(bbox.x + bbox.width)),
             y_max = std::max(std::abs(bbox.y), std::abs(bbox.y + bbox.height));
  if (x_max < threshold_ || y_max < threshold_) {
    double r, g, b, a;
    CAIRO_CHECK(cairo_pattern_get_rgba, cairo_get_source(cr), &r, &g, &b, &a);
    key.draw(cr, x, y, {r, g, b, a});
    return;
  }
  auto const& eps = threshold_ / 3,
            & x_q = eps / x_max, y_q = eps / y_max,
            & xx_q = std::round(key.matrix.xx / x_q) * x_q,
            & yx_q = std::round(key.matrix.yx / x_q) * x_q,
            & xy_q = std::round(key.matrix.xy / y_q) * y_q,
            & yy_q = std::round(key.matrix.yy / y_q) * y_q,
            & x0_q = std::round(key.matrix.x0 / eps) * eps,
            & y0_q = std::round(key.matrix.y0 / eps) * eps;
  key.matrix = {xx_q, yx_q, xy_q, yy_q, x0_q, y0_q};
  // Get the patterns.
  auto it_patterns = patterns_.find(key);
  if (it_patterns == patterns_.end()) {
    // Get the pattern extents.
    load_path_exact(cr, key.path, &key.matrix);
    double x0, y0, x1, y1;
    switch (key.draw_func) {
      case draw_func_t::Fill:
        cairo_fill_extents(cr, &x0, &y0, &x1, &y1);
        break;
      case draw_func_t::Stroke:
        cairo_save(cr);
        cairo_set_line_width(cr, key.linewidth);
        cairo_set_miter_limit(
          cr, detail::MITER_LIMIT >= 0 ? detail::MITER_LIMIT : linewidth);
        set_dashes(cr, key.dash);
        cairo_stroke_extents(cr, &x0, &y0, &x1, &y1);
        cairo_restore(cr);
        break;
    }
    // If the pattern is huge, caching it can blow up the memory.
    if (x1 - x0 > cr_width || y1 - y0 > cr_height) {
      draw_direct();
      return;
    }
    auto patterns = std::unique_ptr<cairo_pattern_t*[]>{
      new cairo_pattern_t*[n_subpix_ * n_subpix_]()};  // () for nullptr-init!
    bool ok;
    std::tie(it_patterns, ok) =
      patterns_.emplace(
        key, PatternEntry{x0, y0, x1 - x0, y1 - y0, std::move(patterns)});
    if (!ok) {
      throw std::runtime_error{"unexpected insertion failure into cache"};
    }
  }
  auto const& entry = it_patterns->second;
  auto const& target_x = x + entry.x,
            & target_y = y + entry.y;
  auto const& i_target_x = std::floor(target_x),
            & i_target_y = std::floor(target_y);
  auto const& f_target_x = target_x - i_target_x,
            & f_target_y = target_y - i_target_y;
  auto const& i = int(n_subpix_ * f_target_x),
            & j = int(n_subpix_ * f_target_y);
  auto const& idx = i * n_subpix_ + j;
  auto& pattern = entry.patterns[idx];
  if (!pattern) {
    auto const& width = std::ceil(entry.width + 1),
              & height = std::ceil(entry.height + 1);
    auto const& raster_surface =
      cairo_image_surface_create(CAIRO_FORMAT_A8, width, height);
    auto const& raster_gcr =
      GraphicsContextRenderer::make_pattern_gcr(raster_surface);
    key.draw(
      raster_gcr.cr_,
      -entry.x + double(i) / n_subpix_, -entry.y + double(j) / n_subpix_);
    pattern = cairo_pattern_create_for_surface(raster_surface);
    cairo_pattern_set_filter(pattern, CAIRO_FILTER_NEAREST);
  }
  // Draw using the pattern.
  auto const& pattern_matrix =
    cairo_matrix_t{1, 0, 0, 1, -i_target_x, -i_target_y};
  cairo_pattern_set_matrix(pattern, &pattern_matrix);
  cairo_mask(cr, pattern);
}

}