/*
 * Copyright © 2022  Behdad Esfahbod
 *
 *  This is part of HarfBuzz, a text shaping library.
 *
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the
 * above copyright notice and the following two paragraphs appear in
 * all copies of this software.
 *
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 */

#ifndef HB_FT_COLR_HH
#define HB_FT_COLR_HH

#include "hb.hh"

#include FT_COLOR_H

#ifndef HB_NO_PAINT

#ifdef TT_SUPPORT_COLRV1

static hb_paint_composite_mode_t
_hb_ft_paint_composite_mode (FT_Composite_Mode mode)
{
  switch (mode)
  {
    case FT_COLR_COMPOSITE_CLEAR:          return HB_PAINT_COMPOSITE_MODE_CLEAR;
    case FT_COLR_COMPOSITE_SRC:            return HB_PAINT_COMPOSITE_MODE_SRC;
    case FT_COLR_COMPOSITE_DEST:           return HB_PAINT_COMPOSITE_MODE_DEST;
    case FT_COLR_COMPOSITE_SRC_OVER:       return HB_PAINT_COMPOSITE_MODE_SRC_OVER;
    case FT_COLR_COMPOSITE_DEST_OVER:      return HB_PAINT_COMPOSITE_MODE_DEST_OVER;
    case FT_COLR_COMPOSITE_SRC_IN:         return HB_PAINT_COMPOSITE_MODE_SRC_IN;
    case FT_COLR_COMPOSITE_DEST_IN:        return HB_PAINT_COMPOSITE_MODE_DEST_IN;
    case FT_COLR_COMPOSITE_SRC_OUT:        return HB_PAINT_COMPOSITE_MODE_SRC_OUT;
    case FT_COLR_COMPOSITE_DEST_OUT:       return HB_PAINT_COMPOSITE_MODE_DEST_OUT;
    case FT_COLR_COMPOSITE_SRC_ATOP:       return HB_PAINT_COMPOSITE_MODE_SRC_ATOP;
    case FT_COLR_COMPOSITE_DEST_ATOP:      return HB_PAINT_COMPOSITE_MODE_DEST_ATOP;
    case FT_COLR_COMPOSITE_XOR:            return HB_PAINT_COMPOSITE_MODE_XOR;
    case FT_COLR_COMPOSITE_PLUS:           return HB_PAINT_COMPOSITE_MODE_PLUS;
    case FT_COLR_COMPOSITE_SCREEN:         return HB_PAINT_COMPOSITE_MODE_SCREEN;
    case FT_COLR_COMPOSITE_OVERLAY:        return HB_PAINT_COMPOSITE_MODE_OVERLAY;
    case FT_COLR_COMPOSITE_DARKEN:         return HB_PAINT_COMPOSITE_MODE_DARKEN;
    case FT_COLR_COMPOSITE_LIGHTEN:        return HB_PAINT_COMPOSITE_MODE_LIGHTEN;
    case FT_COLR_COMPOSITE_COLOR_DODGE:    return HB_PAINT_COMPOSITE_MODE_COLOR_DODGE;
    case FT_COLR_COMPOSITE_COLOR_BURN:     return HB_PAINT_COMPOSITE_MODE_COLOR_BURN;
    case FT_COLR_COMPOSITE_HARD_LIGHT:     return HB_PAINT_COMPOSITE_MODE_HARD_LIGHT;
    case FT_COLR_COMPOSITE_SOFT_LIGHT:     return HB_PAINT_COMPOSITE_MODE_SOFT_LIGHT;
    case FT_COLR_COMPOSITE_DIFFERENCE:     return HB_PAINT_COMPOSITE_MODE_DIFFERENCE;
    case FT_COLR_COMPOSITE_EXCLUSION:      return HB_PAINT_COMPOSITE_MODE_EXCLUSION;
    case FT_COLR_COMPOSITE_MULTIPLY:       return HB_PAINT_COMPOSITE_MODE_MULTIPLY;
    case FT_COLR_COMPOSITE_HSL_HUE:        return HB_PAINT_COMPOSITE_MODE_HSL_HUE;
    case FT_COLR_COMPOSITE_HSL_SATURATION: return HB_PAINT_COMPOSITE_MODE_HSL_SATURATION;
    case FT_COLR_COMPOSITE_HSL_COLOR:      return HB_PAINT_COMPOSITE_MODE_HSL_COLOR;
    case FT_COLR_COMPOSITE_HSL_LUMINOSITY: return HB_PAINT_COMPOSITE_MODE_HSL_LUMINOSITY;

    case FT_COLR_COMPOSITE_MAX:            HB_FALLTHROUGH;
    default:                               return HB_PAINT_COMPOSITE_MODE_CLEAR;
  }
}

typedef struct
{
  FT_Face face;
  FT_Color *palette;
  hb_color_t foreground;
} _hb_ft_get_color_stops_data_t;

static unsigned
_hb_ft_color_line_get_color_stops (hb_color_line_t *color_line,
				   void *color_line_data,
				   unsigned int start,
				   unsigned int *count,
				   hb_color_stop_t *color_stops,
				   void *user_data)
{
  FT_ColorLine *c = (FT_ColorLine *) color_line_data;
  _hb_ft_get_color_stops_data_t *data = (_hb_ft_get_color_stops_data_t *) user_data;

  if (count)
  {
    FT_ColorStop stop;
    unsigned wrote = 0;
    FT_ColorStopIterator iter = c->color_stop_iterator;

    if (start >= c->color_stop_iterator.num_color_stops)
    {
      *count = 0;
      return c->color_stop_iterator.num_color_stops;
    }

    while (c->color_stop_iterator.current_color_stop < start)
      FT_Get_Colorline_Stops(data->face,
			     &stop,
			     &c->color_stop_iterator);

    while (count && *count &&
	   FT_Get_Colorline_Stops(data->face,
				  &stop,
				  &c->color_stop_iterator))
    {
      color_stops->offset = stop.stop_offset / 16384.f;
      color_stops->is_foreground = stop.color.palette_index == 0xFFFF;
      if (color_stops->is_foreground)
	color_stops->color = HB_COLOR (hb_color_get_blue (data->foreground),
				       hb_color_get_green (data->foreground),
				       hb_color_get_red (data->foreground),
				       (hb_color_get_alpha (data->foreground) * stop.color.alpha) >> 14);
      else
      {
	FT_Color ft_color = data->palette[stop.color.palette_index];
	color_stops->color = HB_COLOR (ft_color.blue,
				       ft_color.green,
				       ft_color.red,
				       (ft_color.alpha * stop.color.alpha) >> 14);
      }

      color_stops++;
      wrote++;
    }

    *count = wrote;

    // reset the iterator for next time
    c->color_stop_iterator = iter;
  }

  return c->color_stop_iterator.num_color_stops;
}

static hb_paint_extend_t
_hb_ft_color_line_get_extend (hb_color_line_t *color_line,
			      void *color_line_data,
			      void *user_data)
{
  FT_ColorLine *c = (FT_ColorLine *) color_line_data;
  switch (c->extend)
  {
    default:
    case FT_COLR_PAINT_EXTEND_PAD:     return HB_PAINT_EXTEND_PAD;
    case FT_COLR_PAINT_EXTEND_REPEAT:  return HB_PAINT_EXTEND_REPEAT;
    case FT_COLR_PAINT_EXTEND_REFLECT: return HB_PAINT_EXTEND_REFLECT;
  }
}

typedef struct hb_ft_paint_context_t hb_ft_paint_context_t;

static void
_hb_ft_paint (hb_ft_paint_context_t *c,
	      FT_OpaquePaint opaque_paint);

struct hb_ft_paint_context_t
{
  hb_ft_paint_context_t (const hb_ft_font_t *ft_font,
			 hb_font_t *font,
			 hb_paint_funcs_t *paint_funcs, void *paint_data,
			 FT_Color *palette,
			 hb_color_t foreground) :
    ft_font (ft_font), font(font),
    funcs (paint_funcs), data (paint_data),
    palette (palette), foreground (foreground) {}

  void recurse (FT_OpaquePaint paint) { _hb_ft_paint (this, paint);
  }

  const hb_ft_font_t *ft_font;
  hb_font_t *font;
  hb_paint_funcs_t *funcs;
  void *data;
  FT_Color *palette;
  hb_color_t foreground;
};

void
_hb_ft_paint (hb_ft_paint_context_t *c,
	      FT_OpaquePaint opaque_paint)
{
  FT_Face ft_face = c->ft_font->ft_face;
  FT_COLR_Paint paint;
  if (!FT_Get_Paint (ft_face, opaque_paint, &paint))
    return;

  switch (paint.format)
  {
    case FT_COLR_PAINTFORMAT_COLR_LAYERS:
    {
      FT_OpaquePaint other_paint = {0};
      while (FT_Get_Paint_Layers (ft_face,
				  &paint.u.colr_layers.layer_iterator,
				  &other_paint))
      {
	c->funcs->push_group (c->data);
	c->recurse (other_paint);
	c->funcs->pop_group (c->data, HB_PAINT_COMPOSITE_MODE_SRC_OVER);
      }
    }
    break;
    case FT_COLR_PAINTFORMAT_SOLID:
    {
      bool is_foreground = paint.u.solid.color.palette_index ==  0xFFFF;
      hb_color_t color;
      if (is_foreground)
	color = HB_COLOR (hb_color_get_blue (c->foreground),
			  hb_color_get_green (c->foreground),
			  hb_color_get_red (c->foreground),
			  (hb_color_get_alpha (c->foreground) * paint.u.solid.color.alpha) >> 14);
      else
      {
	FT_Color ft_color = c->palette[paint.u.solid.color.palette_index];
	color = HB_COLOR (ft_color.blue,
			  ft_color.green,
			  ft_color.red,
			  (ft_color.alpha * paint.u.solid.color.alpha) >> 14);
      }
      c->funcs->color (c->data, is_foreground, color);
    }
    break;
    case FT_COLR_PAINTFORMAT_LINEAR_GRADIENT:
    {
      _hb_ft_get_color_stops_data_t data = {ft_face, c->palette, c->foreground};
      hb_color_line_t cl = {
	&paint.u.linear_gradient.colorline,
	_hb_ft_color_line_get_color_stops, &data,
	_hb_ft_color_line_get_extend, nullptr
      };

      c->funcs->linear_gradient (c->data, &cl,
				    paint.u.linear_gradient.p0.x / 65536.f,
				    paint.u.linear_gradient.p0.y / 65536.f,
				    paint.u.linear_gradient.p1.x / 65536.f,
				    paint.u.linear_gradient.p1.y / 65536.f,
				    paint.u.linear_gradient.p2.x / 65536.f,
				    paint.u.linear_gradient.p2.y / 65536.f);
    }
    break;
    case FT_COLR_PAINTFORMAT_RADIAL_GRADIENT:
    {
      _hb_ft_get_color_stops_data_t data = {ft_face, c->palette, c->foreground};
      hb_color_line_t cl = {
	&paint.u.linear_gradient.colorline,
	_hb_ft_color_line_get_color_stops, &data,
	_hb_ft_color_line_get_extend, nullptr
      };

      c->funcs->radial_gradient (c->data, &cl,
				    paint.u.radial_gradient.c0.x / 65536.f,
				    paint.u.radial_gradient.c0.y / 65536.f,
				    (paint.u.radial_gradient.r0 / 65536.f),
				    paint.u.radial_gradient.c1.x / 65536.f,
				    paint.u.radial_gradient.c1.y / 65536.f,
				    (paint.u.radial_gradient.r1 / 65536.f));
    }
    break;
    case FT_COLR_PAINTFORMAT_SWEEP_GRADIENT:
    {
      _hb_ft_get_color_stops_data_t data = {ft_face, c->palette, c->foreground};
      hb_color_line_t cl = {
	&paint.u.linear_gradient.colorline,
	_hb_ft_color_line_get_color_stops, &data,
	_hb_ft_color_line_get_extend, nullptr
      };

      c->funcs->sweep_gradient (c->data, &cl,
				   paint.u.sweep_gradient.center.x / 65536.f,
				   paint.u.sweep_gradient.center.y / 65536.f,
				   (paint.u.sweep_gradient.start_angle / 65536.f + 1) * (float) M_PI,
				   (paint.u.sweep_gradient.end_angle / 65536.f + 1) * (float) M_PI);
    }
    break;
    case FT_COLR_PAINTFORMAT_GLYPH:
    {
      c->funcs->push_inverse_root_transform (c->data, c->font);
      c->ft_font->lock.unlock ();
      c->funcs->push_clip_glyph (c->data, paint.u.glyph.glyphID, c->font);
      c->ft_font->lock.lock ();
      c->funcs->push_root_transform (c->data, c->font);
      c->recurse (paint.u.glyph.paint);
      c->funcs->pop_root_transform (c->data);
      c->funcs->pop_clip (c->data);
      c->funcs->pop_inverse_root_transform (c->data);
    }
    break;
    case FT_COLR_PAINTFORMAT_COLR_GLYPH:
    {
      /* TODO Depth counter. */
      FT_OpaquePaint other_paint = {0};
      if (FT_Get_Color_Glyph_Paint (ft_face, paint.u.colr_glyph.glyphID,
				    FT_COLOR_NO_ROOT_TRANSFORM,
				    &other_paint))
      {
        bool has_clip_box;
        FT_ClipBox clip_box;
        has_clip_box = FT_Get_Color_Glyph_ClipBox (ft_face, paint.u.colr_glyph.glyphID, &clip_box);
        has_clip_box = 0;

        if (has_clip_box)
          c->funcs->push_clip_rectangle (c->data,
					    clip_box.bottom_left.x / 64.f,
					    clip_box.bottom_left.y / 64.f,
					    clip_box.top_right.x / 64.f,
					    clip_box.top_right.y / 64.f);
	c->recurse (other_paint);
        if (has_clip_box)
          c->funcs->pop_clip (c->data);
      }
    }
    break;
    case FT_COLR_PAINTFORMAT_TRANSFORM:
    {
      c->funcs->push_transform (c->data,
				   paint.u.transform.affine.xx / 65536.f,
				   paint.u.transform.affine.yx / 65536.f,
				   paint.u.transform.affine.xy / 65536.f,
				   paint.u.transform.affine.yy / 65536.f,
				   paint.u.transform.affine.dx / 65536.f,
				   paint.u.transform.affine.dy / 65536.f);
      c->recurse (paint.u.transform.paint);
      c->funcs->pop_transform (c->data);
    }
    break;
    case FT_COLR_PAINTFORMAT_TRANSLATE:
    {
      c->funcs->push_transform (c->data,
				   0.f, 0.f, 0.f, 0.f,
				   paint.u.translate.dx / 65536.f,
				   paint.u.translate.dy / 65536.f);
      c->recurse (paint.u.translate.paint);
      c->funcs->pop_transform (c->data);
    }
    break;
    case FT_COLR_PAINTFORMAT_SCALE:
    {
      bool has_translate = paint.u.scale.center_x != 0 || paint.u.scale.center_y != 0;
      if (has_translate)
        c->funcs->push_transform (c->data,
				     1.f, 0.f, 0.f, 1.f,
				     +paint.u.scale.center_x / 65536.f,
				     +paint.u.scale.center_y / 65536.f);
      c->funcs->push_transform (c->data,
				   paint.u.scale.scale_x / 65536.f,
				   0.f, 0.f,
				   paint.u.scale.scale_y / 65536.f,
				   0.f, 0.f);
      if (has_translate)
        c->funcs->push_transform (c->data,
				     1.f, 0.f, 0.f, 1.f,
				     -paint.u.scale.center_x / 65536.f,
				     -paint.u.scale.center_y / 65536.f);
      c->recurse (paint.u.scale.paint);
      c->funcs->pop_transform (c->data);
      if (has_translate)
      {
        c->funcs->pop_transform (c->data);
        c->funcs->pop_transform (c->data);
      }
    }
    break;
    case FT_COLR_PAINTFORMAT_ROTATE:
    {
      float a = paint.u.rotate.angle / 65536.f;
      float cc = cosf (a * (float) M_PI);
      float ss = sinf (a * (float) M_PI);
      c->funcs->push_transform (c->data,
				   1.f, 0.f, 0.f, 1.f,
				   +paint.u.rotate.center_x / 65536.f,
				   +paint.u.rotate.center_y / 65536.f);
      c->funcs->push_transform (c->data, cc, ss, -ss, cc, 0., 0.);
      c->funcs->push_transform (c->data,
				   1.f, 0.f, 0.f, 1.f,
				   -paint.u.rotate.center_x / 65536.f,
				   -paint.u.rotate.center_y / 65536.f);
      c->recurse (paint.u.rotate.paint);
      c->funcs->pop_transform (c->data);
      c->funcs->pop_transform (c->data);
      c->funcs->pop_transform (c->data);
    }
    break;
    case FT_COLR_PAINTFORMAT_SKEW:
    {
      float x = +tanf (paint.u.skew.x_skew_angle / 65536.f * (float) M_PI);
      float y = -tanf (paint.u.skew.y_skew_angle / 65536.f * (float) M_PI);
      c->funcs->push_transform (c->data,
				   1.f, 0.f, 0.f, 1.f,
				   +paint.u.skew.center_x / 65536.f,
				   +paint.u.skew.center_y / 65536.f);
      c->funcs->push_transform (c->data, 1., y, x, 1., 0., 0.);
      c->funcs->push_transform (c->data,
				   1.f, 0.f, 0.f, 1.f,
				   -paint.u.skew.center_x / 65536.f,
				   -paint.u.skew.center_y / 65536.f);
      c->recurse (paint.u.skew.paint);
      c->funcs->pop_transform (c->data);
      c->funcs->pop_transform (c->data);
      c->funcs->pop_transform (c->data);
    }
    break;
    case FT_COLR_PAINTFORMAT_COMPOSITE:
    {
      c->funcs->push_group (c->data);
      c->recurse (paint.u.composite.backdrop_paint);
      c->funcs->push_group (c->data);
      c->recurse (paint.u.composite.source_paint);
      c->funcs->pop_group (c->data, _hb_ft_paint_composite_mode (paint.u.composite.composite_mode));
      c->funcs->pop_group (c->data, HB_PAINT_COMPOSITE_MODE_SRC_OVER);
    }
    break;

    case FT_COLR_PAINT_FORMAT_MAX: break;
    default: HB_FALLTHROUGH;
    case FT_COLR_PAINTFORMAT_UNSUPPORTED: break;
  }
}

#endif

static bool
hb_ft_paint_glyph_colr (hb_font_t *font,
			void *font_data,
			hb_codepoint_t gid,
			hb_paint_funcs_t *paint_funcs, void *paint_data,
			unsigned int palette_index,
			hb_color_t foreground,
			void *user_data)
{
  const hb_ft_font_t *ft_font = (const hb_ft_font_t *) font_data;
  FT_Face ft_face = ft_font->ft_face;

  /* Face is locked. */

  FT_Error error;
  FT_Color*         palette;
  FT_LayerIterator  iterator;

  FT_Bool  have_layers;
  FT_UInt  layer_glyph_index;
  FT_UInt  layer_color_index;

  error = FT_Palette_Select(ft_face, palette_index, &palette);
  if (error)
    palette = NULL;

#ifdef TT_SUPPORT_COLRV1
  /* COLRv1 */
  FT_OpaquePaint paint = {0};
  if (FT_Get_Color_Glyph_Paint (ft_face, gid,
			        FT_COLOR_NO_ROOT_TRANSFORM,
			        &paint))
  {
    FT_ClipBox clip_box;
    bool has_clip;

    has_clip = FT_Get_Color_Glyph_ClipBox (ft_face, gid, &clip_box);
    if (has_clip)
      paint_funcs->push_clip_rectangle (paint_data,
                                        clip_box.bottom_left.x - font->slant_xy * clip_box.bottom_left.y,
                                        clip_box.bottom_left.y,
                                        clip_box.top_right.x - font->slant_xy * clip_box.top_right.y,
                                        clip_box.top_right.y);

    paint_funcs->push_root_transform (paint_data, font);

    hb_ft_paint_context_t c (ft_font, font,
			     paint_funcs, paint_data,
			     palette, foreground);
    _hb_ft_paint (&c, paint);

    paint_funcs->pop_root_transform (paint_data);
    if (has_clip)
      paint_funcs->pop_clip (paint_data);

    return true;
  }
#endif

  /* COLRv0 */
  iterator.p  = NULL;
  have_layers = FT_Get_Color_Glyph_Layer(ft_face,
					 gid,
					 &layer_glyph_index,
					 &layer_color_index,
					 &iterator);

  if (palette && have_layers)
  {
    do
    {
      hb_bool_t is_foreground = true;
      hb_color_t color = foreground;

      if ( layer_color_index != 0xFFFF )
      {
	FT_Color layer_color = palette[layer_color_index];
	color = HB_COLOR (layer_color.blue,
			  layer_color.green,
			  layer_color.red,
			  layer_color.alpha);
	is_foreground = false;
      }

      ft_font->lock.unlock ();
      paint_funcs->push_clip_glyph (paint_data, layer_glyph_index, font);
      ft_font->lock.lock ();
      paint_funcs->color (paint_data, is_foreground, color);
      paint_funcs->pop_clip (paint_data);

    } while (FT_Get_Color_Glyph_Layer(ft_face,
				      gid,
				      &layer_glyph_index,
				      &layer_color_index,
				      &iterator));
    return true;
  }

  return false;
}

#endif


#endif /* HB_FT_COLR_HH */