/*

 * Copyright © 2011,2012  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.

 *

 * Google Author(s): Behdad Esfahbod

 */

#include "hb-ot-shape-complex-indic-private.hh"

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

/*

 * Indic shaper.

 */

/*

 * Indic configurations.  Note that we do not want to keep every single script-specific

 * behavior in these tables necessarily.  This should mainly be used for per-script

 * properties that are cheaper keeping here, than in the code.  Ie. if, say, one and

 * only one script has an exception, that one script can be if'ed directly in the code,

 * instead of adding a new flag in these structs.

 */

enum base_position_t {

  BASE_POS_LAST_SINHALA,

  BASE_POS_LAST

};

enum reph_position_t {

  REPH_POS_AFTER_MAIN  = POS_AFTER_MAIN,

  REPH_POS_BEFORE_SUB  = POS_BEFORE_SUB,

  REPH_POS_AFTER_SUB   = POS_AFTER_SUB,

  REPH_POS_BEFORE_POST = POS_BEFORE_POST,

  REPH_POS_AFTER_POST  = POS_AFTER_POST

};

enum reph_mode_t {

  REPH_MODE_IMPLICIT,  /* Reph formed out of initial Ra,H sequence. */

  REPH_MODE_EXPLICIT,  /* Reph formed out of initial Ra,H,ZWJ sequence. */

  REPH_MODE_LOG_REPHA  /* Encoded Repha character, needs reordering. */

};

enum blwf_mode_t {

  BLWF_MODE_PRE_AND_POST, /* Below-forms feature applied to pre-base and post-base. */

  BLWF_MODE_POST_ONLY     /* Below-forms feature applied to post-base only. */

};

struct indic_config_t

{

  hb_script_t     script;

  bool            has_old_spec;

  hb_codepoint_t  virama;

  base_position_t base_pos;

  reph_position_t reph_pos;

  reph_mode_t     reph_mode;

  blwf_mode_t     blwf_mode;

};

static const indic_config_t indic_configs[] =

{

  /* Default.  Should be first. */

  {HB_SCRIPT_INVALID,   false,      0,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},

  {HB_SCRIPT_DEVANAGARI,true, 0x094Du,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},

  {HB_SCRIPT_BENGALI,   true, 0x09CDu,BASE_POS_LAST, REPH_POS_AFTER_SUB,  REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},

  {HB_SCRIPT_GURMUKHI,  true, 0x0A4Du,BASE_POS_LAST, REPH_POS_BEFORE_SUB, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},

  {HB_SCRIPT_GUJARATI,  true, 0x0ACDu,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},

  {HB_SCRIPT_ORIYA,     true, 0x0B4Du,BASE_POS_LAST, REPH_POS_AFTER_MAIN, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},

  {HB_SCRIPT_TAMIL,     true, 0x0BCDu,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},

  {HB_SCRIPT_TELUGU,    true, 0x0C4Du,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_EXPLICIT, BLWF_MODE_POST_ONLY},

  {HB_SCRIPT_KANNADA,   true, 0x0CCDu,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_IMPLICIT, BLWF_MODE_POST_ONLY},

  {HB_SCRIPT_MALAYALAM, true, 0x0D4Du,BASE_POS_LAST, REPH_POS_AFTER_MAIN, REPH_MODE_LOG_REPHA,BLWF_MODE_PRE_AND_POST},

  {HB_SCRIPT_SINHALA,   false,0x0DCAu,BASE_POS_LAST_SINHALA,

};

/*

 * Indic shaper.

 */

struct feature_list_t {

  hb_tag_t tag;

  hb_ot_map_feature_flags_t flags;

};

static const feature_list_t

indic_features[] =

{

  /*

   * Basic features.

   * These features are applied in order, one at a time, after initial_reordering.

   */

  {HB_TAG('n','u','k','t'), F_GLOBAL},

  {HB_TAG('a','k','h','n'), F_GLOBAL},

  {HB_TAG('r','p','h','f'), F_NONE},

  {HB_TAG('r','k','r','f'), F_GLOBAL},

  {HB_TAG('p','r','e','f'), F_NONE},

  {HB_TAG('b','l','w','f'), F_NONE},

  {HB_TAG('a','b','v','f'), F_NONE},

  {HB_TAG('h','a','l','f'), F_NONE},

  {HB_TAG('p','s','t','f'), F_NONE},

  {HB_TAG('v','a','t','u'), F_GLOBAL},

  {HB_TAG('c','j','c','t'), F_GLOBAL},

  /*

   * Other features.

   * These features are applied all at once, after final_reordering.

   * Default Bengali font in Windows for example has intermixed

   * lookups for init,pres,abvs,blws features.

   */

  {HB_TAG('i','n','i','t'), F_NONE},

  {HB_TAG('p','r','e','s'), F_GLOBAL},

  {HB_TAG('a','b','v','s'), F_GLOBAL},

  {HB_TAG('b','l','w','s'), F_GLOBAL},

  {HB_TAG('p','s','t','s'), F_GLOBAL},

  {HB_TAG('h','a','l','n'), F_GLOBAL},

  /* Positioning features, though we don't care about the types. */

  {HB_TAG('d','i','s','t'), F_GLOBAL},

  {HB_TAG('a','b','v','m'), F_GLOBAL},

  {HB_TAG('b','l','w','m'), F_GLOBAL},

};

/*

 * Must be in the same order as the indic_features array.

 */

enum {

  _NUKT,

  _AKHN,

  RPHF,

  _RKRF,

  PREF,

  BLWF,

  ABVF,

  HALF,

  PSTF,

  _VATU,

  _CJCT,

  INIT,

  _PRES,

  _ABVS,

  _BLWS,

  _PSTS,

  _HALN,

  _DIST,

  _ABVM,

  _BLWM,

  INDIC_NUM_FEATURES,

  INDIC_BASIC_FEATURES = INIT /* Don't forget to update this! */

};

static void

setup_syllables (const hb_ot_shape_plan_t *plan,

                 hb_font_t *font,

                 hb_buffer_t *buffer);

static void

initial_reordering (const hb_ot_shape_plan_t *plan,

                    hb_font_t *font,

                    hb_buffer_t *buffer);

static void

final_reordering (const hb_ot_shape_plan_t *plan,

                  hb_font_t *font,

                  hb_buffer_t *buffer);

static void

clear_syllables (const hb_ot_shape_plan_t *plan,

                 hb_font_t *font,

                 hb_buffer_t *buffer);

static void

collect_features_indic (hb_ot_shape_planner_t *plan)

{

  hb_ot_map_builder_t *map = &plan->map;

  /* Do this before any lookups have been applied. */

  map->add_gsub_pause (setup_syllables);

  map->add_global_bool_feature (HB_TAG('l','o','c','l'));

  /* The Indic specs do not require ccmp, but we apply it here since if

   * there is a use of it, it's typically at the beginning. */

  map->add_global_bool_feature (HB_TAG('c','c','m','p'));

  unsigned int i = 0;

  map->add_gsub_pause (initial_reordering);

  for (; i < INDIC_BASIC_FEATURES; i++) {

    map->add_feature (indic_features[i].tag, 1, indic_features[i].flags | F_MANUAL_ZWJ | F_MANUAL_ZWNJ);

    map->add_gsub_pause (nullptr);

  }

  map->add_gsub_pause (final_reordering);

  for (; i < INDIC_NUM_FEATURES; i++) {

    map->add_feature (indic_features[i].tag, 1, indic_features[i].flags | F_MANUAL_ZWJ | F_MANUAL_ZWNJ);

  }

  map->add_global_bool_feature (HB_TAG('c','a','l','t'));

  map->add_global_bool_feature (HB_TAG('c','l','i','g'));

  map->add_gsub_pause (clear_syllables);

}

static void

override_features_indic (hb_ot_shape_planner_t *plan)

{

  plan->map.add_feature (HB_TAG('l','i','g','a'), 0, F_GLOBAL);

}

struct would_substitute_feature_t

{

  inline void init (const hb_ot_map_t *map, hb_tag_t feature_tag, bool zero_context_)

  {

    zero_context = zero_context_;

    map->get_stage_lookups (0/*GSUB*/,

                            map->get_feature_stage (0/*GSUB*/, feature_tag),

                            &lookups, &count);

  }

  inline bool would_substitute (const hb_codepoint_t *glyphs,

                                unsigned int          glyphs_count,

                                hb_face_t            *face) const

  {

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

      if (hb_ot_layout_lookup_would_substitute_fast (face, lookups[i].index, glyphs, glyphs_count, zero_context))

        return true;

    return false;

  }

  private:

  const hb_ot_map_t::lookup_map_t *lookups;

  unsigned int count;

  bool zero_context;

};

struct indic_shape_plan_t

{

  ASSERT_POD ();

  inline bool get_virama_glyph (hb_font_t *font, hb_codepoint_t *pglyph) const

  {

    hb_codepoint_t glyph = virama_glyph;

    if (unlikely (virama_glyph == (hb_codepoint_t) -1))

    {

      if (!config->virama || !font->get_nominal_glyph (config->virama, &glyph))

        glyph = 0;

      /* Technically speaking, the spec says we should apply 'locl' to virama too.

       * Maybe one day... */

      /* Our get_nominal_glyph() function needs a font, so we can't get the virama glyph

       * during shape planning...  Instead, overwrite it here.  It's safe.  Don't worry! */

      virama_glyph = glyph;

    }

    *pglyph = glyph;

    return glyph != 0;

  }

  const indic_config_t *config;

  bool is_old_spec;

  mutable hb_codepoint_t virama_glyph;

  would_substitute_feature_t rphf;

  would_substitute_feature_t pref;

  would_substitute_feature_t blwf;

  would_substitute_feature_t pstf;

  hb_mask_t mask_array[INDIC_NUM_FEATURES];

};

static void *

data_create_indic (const hb_ot_shape_plan_t *plan)

{

  indic_shape_plan_t *indic_plan = (indic_shape_plan_t *) calloc (1, sizeof (indic_shape_plan_t));

  if (unlikely (!indic_plan))

    return nullptr;

  indic_plan->config = &indic_configs[0];

  for (unsigned int i = 1; i < ARRAY_LENGTH (indic_configs); i++)

    if (plan->props.script == indic_configs[i].script) {

      indic_plan->config = &indic_configs[i];

      break;

    }

  indic_plan->is_old_spec = indic_plan->config->has_old_spec && ((plan->map.chosen_script[0] & 0x000000FFu) != '2');

  indic_plan->virama_glyph = (hb_codepoint_t) -1;

  /* Use zero-context would_substitute() matching for new-spec of the main

   * Indic scripts, and scripts with one spec only, but not for old-specs.

   * The new-spec for all dual-spec scripts says zero-context matching happens.

   *

   * However, testing with Malayalam shows that old and new spec both allow

   * context.  Testing with Bengali new-spec however shows that it doesn't.

   * So, the heuristic here is the way it is.  It should *only* be changed,

   * as we discover more cases of what Windows does.  DON'T TOUCH OTHERWISE.

   */

  bool zero_context = !indic_plan->is_old_spec && plan->props.script != HB_SCRIPT_MALAYALAM;

  indic_plan->rphf.init (&plan->map, HB_TAG('r','p','h','f'), zero_context);

  indic_plan->pref.init (&plan->map, HB_TAG('p','r','e','f'), zero_context);

  indic_plan->blwf.init (&plan->map, HB_TAG('b','l','w','f'), zero_context);

  indic_plan->pstf.init (&plan->map, HB_TAG('p','s','t','f'), zero_context);

  for (unsigned int i = 0; i < ARRAY_LENGTH (indic_plan->mask_array); i++)

    indic_plan->mask_array[i] = (indic_features[i].flags & F_GLOBAL) ?

                                 0 : plan->map.get_1_mask (indic_features[i].tag);

  return indic_plan;

}

static void

data_destroy_indic (void *data)

{

  free (data);

}

static indic_position_t

consonant_position_from_face (const indic_shape_plan_t *indic_plan,

                              const hb_codepoint_t consonant,

                              const hb_codepoint_t virama,

                              hb_face_t *face)

{

  /* For old-spec, the order of glyphs is Consonant,Virama,

   * whereas for new-spec, it's Virama,Consonant.  However,

   * some broken fonts (like Free Sans) simply copied lookups

   * from old-spec to new-spec without modification.

   * And oddly enough, Uniscribe seems to respect those lookups.

   * Eg. in the sequence U+0924,U+094D,U+0930, Uniscribe finds

   * base at 0.  The font however, only has lookups matching

   * 930,94D in 'blwf', not the expected 94D,930 (with new-spec

   * table).  As such, we simply match both sequences.  Seems

   * to work. */

  hb_codepoint_t glyphs[3] = {virama, consonant, virama};

  if (indic_plan->blwf.would_substitute (glyphs  , 2, face) ||

      indic_plan->blwf.would_substitute (glyphs+1, 2, face))

    return POS_BELOW_C;

  if (indic_plan->pstf.would_substitute (glyphs  , 2, face) ||

      indic_plan->pstf.would_substitute (glyphs+1, 2, face))

    return POS_POST_C;

  if (indic_plan->pref.would_substitute (glyphs  , 2, face) ||

      indic_plan->pref.would_substitute (glyphs+1, 2, face))

    return POS_POST_C;

  return POS_BASE_C;

}

enum syllable_type_t {

  consonant_syllable,

  vowel_syllable,

  standalone_cluster,

  symbol_cluster,

  broken_cluster,

  non_indic_cluster,

};

#include "hb-ot-shape-complex-indic-machine.hh"

static void

setup_masks_indic (const hb_ot_shape_plan_t *plan HB_UNUSED,

                   hb_buffer_t              *buffer,

                   hb_font_t                *font HB_UNUSED)

{

  HB_BUFFER_ALLOCATE_VAR (buffer, indic_category);

  HB_BUFFER_ALLOCATE_VAR (buffer, indic_position);

  /* We cannot setup masks here.  We save information about characters

   * and setup masks later on in a pause-callback. */

  unsigned int count = buffer->len;

  hb_glyph_info_t *info = buffer->info;

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

    set_indic_properties (info[i]);

}

static void

setup_syllables (const hb_ot_shape_plan_t *plan HB_UNUSED,

                 hb_font_t *font HB_UNUSED,

                 hb_buffer_t *buffer)

{

  find_syllables (buffer);

  foreach_syllable (buffer, start, end)

    buffer->unsafe_to_break (start, end);

}

static int

compare_indic_order (const hb_glyph_info_t *pa, const hb_glyph_info_t *pb)

{

  int a = pa->indic_position();

  int b = pb->indic_position();

  return a < b ? -1 : a == b ? 0 : +1;

}

static void

update_consonant_positions (const hb_ot_shape_plan_t *plan,

                            hb_font_t         *font,

                            hb_buffer_t       *buffer)

{

  const indic_shape_plan_t *indic_plan = (const indic_shape_plan_t *) plan->data;

  if (indic_plan->config->base_pos != BASE_POS_LAST)

    return;

  hb_codepoint_t virama;

  if (indic_plan->get_virama_glyph (font, &virama))

  {

    hb_face_t *face = font->face;

    unsigned int count = buffer->len;

    hb_glyph_info_t *info = buffer->info;

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

      if (info[i].indic_position() == POS_BASE_C)

      {

        hb_codepoint_t consonant = info[i].codepoint;

        info[i].indic_position() = consonant_position_from_face (indic_plan, consonant, virama, face);

      }

  }

}

/* Rules from:

static void

initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,

                                       hb_face_t *face,

                                       hb_buffer_t *buffer,

                                       unsigned int start, unsigned int end)

{

  const indic_shape_plan_t *indic_plan = (const indic_shape_plan_t *) plan->data;

  hb_glyph_info_t *info = buffer->info;

  /* https://github.com/harfbuzz/harfbuzz/issues/435#issuecomment-335560167

   * // For compatibility with legacy usage in Kannada,

   * // Ra+h+ZWJ must behave like Ra+ZWJ+h...

   */

  if (buffer->props.script == HB_SCRIPT_KANNADA &&

      start + 3 <= end &&

      is_one_of (info[start  ], FLAG (OT_Ra)) &&

      is_one_of (info[start+1], FLAG (OT_H)) &&

      is_one_of (info[start+2], FLAG (OT_ZWJ)))

  {

    buffer->merge_clusters (start+1, start+3);

    hb_glyph_info_t tmp = info[start+1];

    info[start+1] = info[start+2];

    info[start+2] = tmp;

  }

  /* 1. Find base consonant:

   *

   * The shaping engine finds the base consonant of the syllable, using the

   * following algorithm: starting from the end of the syllable, move backwards

   * until a consonant is found that does not have a below-base or post-base

   * form (post-base forms have to follow below-base forms), or that is not a

   * pre-base-reordering Ra, or arrive at the first consonant. The consonant

   * stopped at will be the base.

   *

   *   o If the syllable starts with Ra + Halant (in a script that has Reph)

   *     and has more than one consonant, Ra is excluded from candidates for

   *     base consonants.

   */

  unsigned int base = end;

  bool has_reph = false;

  {

    /* -> If the syllable starts with Ra + Halant (in a script that has Reph)

     *    and has more than one consonant, Ra is excluded from candidates for

     *    base consonants. */

    unsigned int limit = start;

    if (indic_plan->mask_array[RPHF] &&

        start + 3 <= end &&

        (

         (indic_plan->config->reph_mode == REPH_MODE_IMPLICIT && !is_joiner (info[start + 2])) ||

         (indic_plan->config->reph_mode == REPH_MODE_EXPLICIT && info[start + 2].indic_category() == OT_ZWJ)

        ))

    {

      /* See if it matches the 'rphf' feature. */

      hb_codepoint_t glyphs[3] = {info[start].codepoint,

                                  info[start + 1].codepoint,

                                  indic_plan->config->reph_mode == REPH_MODE_EXPLICIT ?

                                    info[start + 2].codepoint : 0};

      if (indic_plan->rphf.would_substitute (glyphs, 2, face) ||

          (indic_plan->config->reph_mode == REPH_MODE_EXPLICIT &&

           indic_plan->rphf.would_substitute (glyphs, 3, face)))

      {

        limit += 2;

        while (limit < end && is_joiner (info[limit]))

          limit++;

        base = start;

        has_reph = true;

      }

    } else if (indic_plan->config->reph_mode == REPH_MODE_LOG_REPHA && info[start].indic_category() == OT_Repha)

    {

        limit += 1;

        while (limit < end && is_joiner (info[limit]))

          limit++;

        base = start;

        has_reph = true;

    }

    switch (indic_plan->config->base_pos)

    {

      case BASE_POS_LAST:

      {

        /* -> starting from the end of the syllable, move backwards */

        unsigned int i = end;