/*

 * Copyright © 2007,2008,2009,2010  Red Hat, Inc.

 * Copyright © 2010,2012,2013  Google, Inc.

 *

 *  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.

 *

 * Red Hat Author(s): Behdad Esfahbod

 * Google Author(s): Behdad Esfahbod

 */

#ifndef HB_OT_LAYOUT_GSUB_TABLE_HH

#define HB_OT_LAYOUT_GSUB_TABLE_HH

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

namespace OT {

struct SingleSubstFormat1

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    Coverage::Iter iter;

    for (iter.init (this+coverage); iter.more (); iter.next ()) {

      hb_codepoint_t glyph_id = iter.get_glyph ();

      if (c->glyphs->has (glyph_id))

        c->glyphs->add ((glyph_id + deltaGlyphID) & 0xFFFFu);

    }

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    Coverage::Iter iter;

    for (iter.init (this+coverage); iter.more (); iter.next ()) {

      hb_codepoint_t glyph_id = iter.get_glyph ();

      c->input->add (glyph_id);

      c->output->add ((glyph_id + deltaGlyphID) & 0xFFFFu);

    }

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_codepoint_t glyph_id = c->buffer->cur().codepoint;

    unsigned int index = (this+coverage).get_coverage (glyph_id);

    if (likely (index == NOT_COVERED)) return_trace (false);

    /* According to the Adobe Annotated OpenType Suite, result is always

     * limited to 16bit. */

    glyph_id = (glyph_id + deltaGlyphID) & 0xFFFFu;

    c->replace_glyph (glyph_id);

    return_trace (true);

  }

  inline bool serialize (hb_serialize_context_t *c,

                         Supplier<GlyphID> &glyphs,

                         unsigned int num_glyphs,

                         int delta)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false);

    deltaGlyphID.set (delta); /* TODO(serilaize) overflow? */

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (coverage.sanitize (c, this) && deltaGlyphID.sanitize (c));

  }

  protected:

  USHORT        format;                 /* Format identifier--format = 1 */

  OffsetTo<Coverage>

                coverage;               /* Offset to Coverage table--from

                                         * beginning of Substitution table */

  SHORT         deltaGlyphID;           /* Add to original GlyphID to get

                                         * substitute GlyphID */

  public:

  DEFINE_SIZE_STATIC (6);

};

struct SingleSubstFormat2

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    Coverage::Iter iter;

    for (iter.init (this+coverage); iter.more (); iter.next ()) {

      if (c->glyphs->has (iter.get_glyph ()))

        c->glyphs->add (substitute[iter.get_coverage ()]);

    }

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    Coverage::Iter iter;

    for (iter.init (this+coverage); iter.more (); iter.next ()) {

      c->input->add (iter.get_glyph ());

      c->output->add (substitute[iter.get_coverage ()]);

    }

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_codepoint_t glyph_id = c->buffer->cur().codepoint;

    unsigned int index = (this+coverage).get_coverage (glyph_id);

    if (likely (index == NOT_COVERED)) return_trace (false);

    if (unlikely (index >= substitute.len)) return_trace (false);

    glyph_id = substitute[index];

    c->replace_glyph (glyph_id);

    return_trace (true);

  }

  inline bool serialize (hb_serialize_context_t *c,

                         Supplier<GlyphID> &glyphs,

                         Supplier<GlyphID> &substitutes,

                         unsigned int num_glyphs)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!substitute.serialize (c, substitutes, num_glyphs))) return_trace (false);

    if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false);

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (coverage.sanitize (c, this) && substitute.sanitize (c));

  }

  protected:

  USHORT        format;                 /* Format identifier--format = 2 */

  OffsetTo<Coverage>

                coverage;               /* Offset to Coverage table--from

                                         * beginning of Substitution table */

  ArrayOf<GlyphID>

                substitute;             /* Array of substitute

                                         * GlyphIDs--ordered by Coverage Index */

  public:

  DEFINE_SIZE_ARRAY (6, substitute);

};

struct SingleSubst

{

  inline bool serialize (hb_serialize_context_t *c,

                         Supplier<GlyphID> &glyphs,

                         Supplier<GlyphID> &substitutes,

                         unsigned int num_glyphs)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (u.format))) return_trace (false);

    unsigned int format = 2;

    int delta = 0;

    if (num_glyphs) {

      format = 1;

      /* TODO(serialize) check for wrap-around */

      delta = substitutes[0] - glyphs[0];

      for (unsigned int i = 1; i < num_glyphs; i++)

        if (delta != substitutes[i] - glyphs[i]) {

          format = 2;

          break;

        }

    }

    u.format.set (format);

    switch (u.format) {

    case 1: return_trace (u.format1.serialize (c, glyphs, num_glyphs, delta));

    case 2: return_trace (u.format2.serialize (c, glyphs, substitutes, num_glyphs));

    default:return_trace (false);

    }

  }

  template <typename context_t>

  inline typename context_t::return_t dispatch (context_t *c) const

  {

    TRACE_DISPATCH (this, u.format);

    if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());

    switch (u.format) {

    case 1: return_trace (c->dispatch (u.format1));

    case 2: return_trace (c->dispatch (u.format2));

    default:return_trace (c->default_return_value ());

    }

  }

  protected:

  union {

  USHORT                format;         /* Format identifier */

  SingleSubstFormat1    format1;

  SingleSubstFormat2    format2;

  } u;

};

struct Sequence

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    unsigned int count = substitute.len;

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

      c->glyphs->add (substitute[i]);

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    unsigned int count = substitute.len;

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

      c->output->add (substitute[i]);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    unsigned int count = substitute.len;

    /* TODO:

     * Testing shows that Uniscribe actually allows zero-len susbstitute,

     * which essentially deletes a glyph.  We don't allow for now.  It

     * can be confusing to the client since the cluster from the deleted

     * glyph won't be merged with any output cluster...  Also, currently

     * buffer->move_to() makes assumptions about this too.  Perhaps fix

     * in the future after figuring out what to do with the clusters.

     */

    if (unlikely (!count)) return_trace (false);

    /* Special-case to make it in-place and not consider this

     * as a "multiplied" substitution. */

    if (unlikely (count == 1))

    {

      c->replace_glyph (substitute.array[0]);

      return_trace (true);

    }

    unsigned int klass = _hb_glyph_info_is_ligature (&c->buffer->cur()) ?

                         HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH : 0;

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

      _hb_glyph_info_set_lig_props_for_component (&c->buffer->cur(), i);

      c->output_glyph_for_component (substitute.array[i], klass);

    }

    c->buffer->skip_glyph ();

    return_trace (true);

  }

  inline bool serialize (hb_serialize_context_t *c,

                         Supplier<GlyphID> &glyphs,

                         unsigned int num_glyphs)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!substitute.serialize (c, glyphs, num_glyphs))) return_trace (false);

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (substitute.sanitize (c));

  }

  protected:

  ArrayOf<GlyphID>

                substitute;             /* String of GlyphIDs to substitute */

  public:

  DEFINE_SIZE_ARRAY (2, substitute);

};

struct MultipleSubstFormat1

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    Coverage::Iter iter;

    for (iter.init (this+coverage); iter.more (); iter.next ()) {

      if (c->glyphs->has (iter.get_glyph ()))

        (this+sequence[iter.get_coverage ()]).closure (c);

    }

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    (this+coverage).add_coverage (c->input);

    unsigned int count = sequence.len;

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

        (this+sequence[i]).collect_glyphs (c);

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);

    if (likely (index == NOT_COVERED)) return_trace (false);

    return_trace ((this+sequence[index]).apply (c));

  }

  inline bool serialize (hb_serialize_context_t *c,

                         Supplier<GlyphID> &glyphs,

                         Supplier<unsigned int> &substitute_len_list,

                         unsigned int num_glyphs,

                         Supplier<GlyphID> &substitute_glyphs_list)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!sequence.serialize (c, num_glyphs))) return_trace (false);

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

      if (unlikely (!sequence[i].serialize (c, this).serialize (c,

                                                                substitute_glyphs_list,

                                                                substitute_len_list[i]))) return_trace (false);

    substitute_len_list.advance (num_glyphs);

    if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false);

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (coverage.sanitize (c, this) && sequence.sanitize (c, this));

  }

  protected:

  USHORT        format;                 /* Format identifier--format = 1 */

  OffsetTo<Coverage>

                coverage;               /* Offset to Coverage table--from

                                         * beginning of Substitution table */

  OffsetArrayOf<Sequence>

                sequence;               /* Array of Sequence tables

                                         * ordered by Coverage Index */

  public:

  DEFINE_SIZE_ARRAY (6, sequence);

};

struct MultipleSubst

{

  inline bool serialize (hb_serialize_context_t *c,

                         Supplier<GlyphID> &glyphs,

                         Supplier<unsigned int> &substitute_len_list,

                         unsigned int num_glyphs,

                         Supplier<GlyphID> &substitute_glyphs_list)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (u.format))) return_trace (false);

    unsigned int format = 1;

    u.format.set (format);

    switch (u.format) {

    case 1: return_trace (u.format1.serialize (c, glyphs, substitute_len_list, num_glyphs, substitute_glyphs_list));

    default:return_trace (false);

    }

  }

  template <typename context_t>

  inline typename context_t::return_t dispatch (context_t *c) const

  {

    TRACE_DISPATCH (this, u.format);

    if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());

    switch (u.format) {

    case 1: return_trace (c->dispatch (u.format1));

    default:return_trace (c->default_return_value ());

    }

  }

  protected:

  union {

  USHORT                format;         /* Format identifier */

  MultipleSubstFormat1  format1;

  } u;

};

typedef ArrayOf<GlyphID> AlternateSet;  /* Array of alternate GlyphIDs--in

                                         * arbitrary order */

struct AlternateSubstFormat1

{

  inline void closure (hb_closure_context_t *c) const

  {

    TRACE_CLOSURE (this);

    Coverage::Iter iter;

    for (iter.init (this+coverage); iter.more (); iter.next ()) {

      if (c->glyphs->has (iter.get_glyph ())) {

        const AlternateSet &alt_set = this+alternateSet[iter.get_coverage ()];

        unsigned int count = alt_set.len;

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

          c->glyphs->add (alt_set[i]);

      }

    }

  }

  inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  {

    TRACE_COLLECT_GLYPHS (this);

    Coverage::Iter iter;

    for (iter.init (this+coverage); iter.more (); iter.next ()) {

      c->input->add (iter.get_glyph ());

      const AlternateSet &alt_set = this+alternateSet[iter.get_coverage ()];

      unsigned int count = alt_set.len;

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

        c->output->add (alt_set[i]);

    }

  }

  inline const Coverage &get_coverage (void) const

  {

    return this+coverage;

  }

  inline bool would_apply (hb_would_apply_context_t *c) const

  {

    TRACE_WOULD_APPLY (this);

    return_trace (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);

  }

  inline bool apply (hb_apply_context_t *c) const

  {

    TRACE_APPLY (this);

    hb_codepoint_t glyph_id = c->buffer->cur().codepoint;

    unsigned int index = (this+coverage).get_coverage (glyph_id);

    if (likely (index == NOT_COVERED)) return_trace (false);

    const AlternateSet &alt_set = this+alternateSet[index];

    if (unlikely (!alt_set.len)) return_trace (false);

    hb_mask_t glyph_mask = c->buffer->cur().mask;

    hb_mask_t lookup_mask = c->lookup_mask;

    /* Note: This breaks badly if two features enabled this lookup together. */

    unsigned int shift = _hb_ctz (lookup_mask);

    unsigned int alt_index = ((lookup_mask & glyph_mask) >> shift);

    if (unlikely (alt_index > alt_set.len || alt_index == 0)) return_trace (false);

    glyph_id = alt_set[alt_index - 1];

    c->replace_glyph (glyph_id);

    return_trace (true);

  }

  inline bool serialize (hb_serialize_context_t *c,

                         Supplier<GlyphID> &glyphs,

                         Supplier<unsigned int> &alternate_len_list,

                         unsigned int num_glyphs,

                         Supplier<GlyphID> &alternate_glyphs_list)

  {

    TRACE_SERIALIZE (this);

    if (unlikely (!c->extend_min (*this))) return_trace (false);

    if (unlikely (!alternateSet.serialize (c, num_glyphs))) return_trace (false);

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

      if (unlikely (!alternateSet[i].serialize (c, this).serialize (c,

                                                                    alternate_glyphs_list,

                                                                    alternate_len_list[i]))) return_trace (false);

    alternate_len_list.advance (num_glyphs);

    if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return_trace (false);

    return_trace (true);

  }

  inline bool sanitize (hb_sanitize_context_t *c) const

  {

    TRACE_SANITIZE (this);

    return_trace (coverage.sanitize (c, this) && alternateSet.sanitize (c, this));

  }