#ifndef OT_LAYOUT_GPOS_GPOS_HH

#define OT_LAYOUT_GPOS_GPOS_HH

#include "../../../hb-ot-layout-common.hh"

#include "../../../hb-ot-layout-gsubgpos.hh"

#include "Common.hh"

#include "PosLookup.hh"

namespace OT {

using Layout::GPOS_impl::PosLookup;

namespace Layout {

static void

propagate_attachment_offsets (hb_glyph_position_t *pos,

                              unsigned int len,

                              unsigned int i,

                              hb_direction_t direction,

                              unsigned nesting_level = HB_MAX_NESTING_LEVEL);

/*

 * GPOS -- Glyph Positioning

 * https://docs.microsoft.com/en-us/typography/opentype/spec/gpos

 */

struct GPOS : GSUBGPOS

{

  static constexpr hb_tag_t tableTag = HB_OT_TAG_GPOS;

  using Lookup = PosLookup;

  const PosLookup& get_lookup (unsigned int i) const

  { return static_cast<const PosLookup &> (GSUBGPOS::get_lookup (i)); }

  static inline void position_start (hb_font_t *font, hb_buffer_t *buffer);

  static inline void position_finish_advances (hb_font_t *font, hb_buffer_t *buffer);

  static inline void position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer);

  bool subset (hb_subset_context_t *c) const

  {

    hb_subset_layout_context_t l (c, tableTag);

    return GSUBGPOS::subset<PosLookup> (&l);

  }

  bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (GSUBGPOS::sanitize<PosLookup> (c));

  }

  HB_INTERNAL bool is_blocklisted (hb_blob_t *blob,

                                   hb_face_t *face) const;

  void collect_variation_indices (hb_collect_variation_indices_context_t *c) const

  {

    for (unsigned i = 0; i < GSUBGPOS::get_lookup_count (); i++)

    {

      if (!c->gpos_lookups->has (i)) continue;

      const PosLookup &l = get_lookup (i);

      l.dispatch (c);

    }

  }

  void closure_lookups (hb_face_t      *face,

                        const hb_set_t *glyphs,

                        hb_set_t       *lookup_indexes /* IN/OUT */) const

  { GSUBGPOS::closure_lookups<PosLookup> (face, glyphs, lookup_indexes); }

  typedef GSUBGPOS::accelerator_t<GPOS> accelerator_t;

};

static void

propagate_attachment_offsets (hb_glyph_position_t *pos,

                              unsigned int len,

                              unsigned int i,

                              hb_direction_t direction,

                              unsigned nesting_level)

{

  /* Adjusts offsets of attached glyphs (both cursive and mark) to accumulate

   * offset of glyph they are attached to. */

  int chain = pos[i].attach_chain();

  int type = pos[i].attach_type();

  pos[i].attach_chain() = 0;

  unsigned int j = (int) i + chain;

  if (unlikely (j >= len))

    return;

  if (unlikely (!nesting_level))

    return;

  if (pos[j].attach_chain())

    propagate_attachment_offsets (pos, len, j, direction, nesting_level - 1);

  assert (!!(type & GPOS_impl::ATTACH_TYPE_MARK) ^ !!(type & GPOS_impl::ATTACH_TYPE_CURSIVE));

  if (type & GPOS_impl::ATTACH_TYPE_CURSIVE)

  {

    if (HB_DIRECTION_IS_HORIZONTAL (direction))

      pos[i].y_offset += pos[j].y_offset;

    else

      pos[i].x_offset += pos[j].x_offset;

  }

  else /*if (type & GPOS_impl::ATTACH_TYPE_MARK)*/

  {

    pos[i].x_offset += pos[j].x_offset;

    pos[i].y_offset += pos[j].y_offset;

    // i is the position of the mark; j is the base.

    if (j < i)

    {

      /* This is the common case: mark follows base.

       * And currently the only way in OpenType. */

      if (HB_DIRECTION_IS_FORWARD (direction))

  for (unsigned int k = j; k < i; k++) {

    pos[i].x_offset -= pos[k].x_advance;

    pos[i].y_offset -= pos[k].y_advance;

  }

      else

  for (unsigned int k = j + 1; k < i + 1; k++) {

    pos[i].x_offset += pos[k].x_advance;

    pos[i].y_offset += pos[k].y_advance;

  }

    }

    else // j > i

    {

      /* This can happen with `kerx`: a mark attaching

       * to a base after it in the logical order. */

      if (HB_DIRECTION_IS_FORWARD (direction))

  for (unsigned int k = i; k < j; k++) {

    pos[i].x_offset += pos[k].x_advance;

    pos[i].y_offset += pos[k].y_advance;

  }

      else

  for (unsigned int k = i + 1; k < j + 1; k++) {

    pos[i].x_offset -= pos[k].x_advance;

    pos[i].y_offset -= pos[k].y_advance;

  }

    }

  }

}

Unexecuted instantiation: hb-ot-face.cc:OT::Layout::propagate_attachment_offsets(hb_glyph_position_t*, unsigned int, unsigned int, hb_direction_t, unsigned int)

Unexecuted instantiation: hb-aat-layout.cc:OT::Layout::propagate_attachment_offsets(hb_glyph_position_t*, unsigned int, unsigned int, hb_direction_t, unsigned int)

Unexecuted instantiation: hb-ot-layout.cc:OT::Layout::propagate_attachment_offsets(hb_glyph_position_t*, unsigned int, unsigned int, hb_direction_t, unsigned int)

Unexecuted instantiation: hb-ot-shape-fallback.cc:OT::Layout::propagate_attachment_offsets(hb_glyph_position_t*, unsigned int, unsigned int, hb_direction_t, unsigned int)

void

GPOS::position_start (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)

{

  unsigned int count = buffer->len;

  for (unsigned int i = 0; i < count; i++)

    buffer->pos[i].attach_chain() = buffer->pos[i].attach_type() = 0;

}

void

GPOS::position_finish_advances (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer HB_UNUSED)

{

  //_hb_buffer_assert_gsubgpos_vars (buffer);

}

void

GPOS::position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer)

{

  _hb_buffer_assert_gsubgpos_vars (buffer);

  unsigned int len;

  hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len);

  hb_direction_t direction = buffer->props.direction;

  /* Handle attachments */

  if (buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT)

  {

    auto *pos = buffer->pos;

    // https://github.com/harfbuzz/harfbuzz/issues/5514

    if (HB_DIRECTION_IS_FORWARD (direction))

    {

      for (unsigned i = 0; i < len; i++)

  if (pos[i].attach_chain())

    propagate_attachment_offsets (pos, len, i, direction);

    } else {

      for (unsigned i = len; i-- > 0; )

  if (pos[i].attach_chain())

    propagate_attachment_offsets (pos, len, i, direction);

    }

  }

  if (unlikely (font->slant_xy) &&

      HB_DIRECTION_IS_HORIZONTAL (direction))

  {

    /* Slanting shaping results is only supported for horizontal text,

     * as it gets weird otherwise. */

    for (unsigned i = 0; i < len; i++)

      if (unlikely (pos[i].y_offset))

        pos[i].x_offset += roundf (font->slant_xy * pos[i].y_offset);

  }

}

}

struct GPOS_accelerator_t : Layout::GPOS::accelerator_t {

  GPOS_accelerator_t (hb_face_t *face) : Layout::GPOS::accelerator_t (face) {}

};

}

#endif  /* OT_LAYOUT_GPOS_GPOS_HH */