/*

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

/* buffer var allocations */

#define indic_category() complex_var_u8_0() /* indic_category_t */

#define indic_position() complex_var_u8_1() /* indic_position_t */

/*

 * Indic shaper.

 */

#define IN_HALF_BLOCK(u, Base) (((u) & ~0x7Fu) == (Base))

#define IS_DEVA(u) (IN_HALF_BLOCK (u, 0x0900u))

#define IS_BENG(u) (IN_HALF_BLOCK (u, 0x0980u))

#define IS_GURU(u) (IN_HALF_BLOCK (u, 0x0A00u))

#define IS_GUJR(u) (IN_HALF_BLOCK (u, 0x0A80u))

#define IS_ORYA(u) (IN_HALF_BLOCK (u, 0x0B00u))

#define IS_TAML(u) (IN_HALF_BLOCK (u, 0x0B80u))

#define IS_TELU(u) (IN_HALF_BLOCK (u, 0x0C00u))

#define IS_KNDA(u) (IN_HALF_BLOCK (u, 0x0C80u))

#define IS_MLYM(u) (IN_HALF_BLOCK (u, 0x0D00u))

#define IS_SINH(u) (IN_HALF_BLOCK (u, 0x0D80u))

#define IS_KHMR(u) (IN_HALF_BLOCK (u, 0x1780u))

#define MATRA_POS_LEFT(u)       POS_PRE_M

#define MATRA_POS_RIGHT(u)      ( \

                                  IS_DEVA(u) ? POS_AFTER_SUB  : \

                                  IS_BENG(u) ? POS_AFTER_POST : \

                                  IS_GURU(u) ? POS_AFTER_POST : \

                                  IS_GUJR(u) ? POS_AFTER_POST : \

                                  IS_ORYA(u) ? POS_AFTER_POST : \

                                  IS_TAML(u) ? POS_AFTER_POST : \

                                  IS_TELU(u) ? (u <= 0x0C42u ? POS_BEFORE_SUB : POS_AFTER_SUB) : \

                                  IS_KNDA(u) ? (u < 0x0CC3u || u > 0xCD6u ? POS_BEFORE_SUB : POS_AFTER_SUB) : \

                                  IS_MLYM(u) ? POS_AFTER_POST : \

                                  IS_SINH(u) ? POS_AFTER_SUB  : \

                                  IS_KHMR(u) ? POS_AFTER_POST : \

                                  /*default*/  POS_AFTER_SUB    \

                                )

#define MATRA_POS_TOP(u)        ( /* BENG and MLYM don't have top matras. */ \

                                  IS_DEVA(u) ? POS_AFTER_SUB  : \

                                  IS_GURU(u) ? POS_AFTER_POST : /* Deviate from spec */ \

                                  IS_GUJR(u) ? POS_AFTER_SUB  : \

                                  IS_ORYA(u) ? POS_AFTER_MAIN : \

                                  IS_TAML(u) ? POS_AFTER_SUB  : \

                                  IS_TELU(u) ? POS_BEFORE_SUB : \

                                  IS_KNDA(u) ? POS_BEFORE_SUB : \

                                  IS_SINH(u) ? POS_AFTER_SUB  : \

                                  IS_KHMR(u) ? POS_AFTER_POST : \

                                  /*default*/  POS_AFTER_SUB    \

                                )

#define MATRA_POS_BOTTOM(u)     ( \

                                  IS_DEVA(u) ? POS_AFTER_SUB  : \

                                  IS_BENG(u) ? POS_AFTER_SUB  : \

                                  IS_GURU(u) ? POS_AFTER_POST : \

                                  IS_GUJR(u) ? POS_AFTER_POST : \

                                  IS_ORYA(u) ? POS_AFTER_SUB  : \

                                  IS_TAML(u) ? POS_AFTER_POST : \

                                  IS_TELU(u) ? POS_BEFORE_SUB : \

                                  IS_KNDA(u) ? POS_BEFORE_SUB : \

                                  IS_MLYM(u) ? POS_AFTER_POST : \

                                  IS_SINH(u) ? POS_AFTER_SUB  : \

                                  IS_KHMR(u) ? POS_AFTER_POST : \

                                  /*default*/  POS_AFTER_SUB    \

                                )

static inline indic_position_t

matra_position (hb_codepoint_t u, indic_position_t side)

{

  switch ((int) side)

  {

    case POS_PRE_C:     return MATRA_POS_LEFT (u);

    case POS_POST_C:    return MATRA_POS_RIGHT (u);

    case POS_ABOVE_C:   return MATRA_POS_TOP (u);

    case POS_BELOW_C:   return MATRA_POS_BOTTOM (u);

  };

  return side;

}

/* XXX

 * This is a hack for now.  We should move this data into the main Indic table.

 * Or completely remove it and just check in the tables.

 */

static const hb_codepoint_t ra_chars[] = {

  0x0930u, /* Devanagari */

  0x09B0u, /* Bengali */

  0x09F0u, /* Bengali */

  0x0A30u, /* Gurmukhi */       /* No Reph */

  0x0AB0u, /* Gujarati */

  0x0B30u, /* Oriya */

  0x0BB0u, /* Tamil */          /* No Reph */

  0x0C30u, /* Telugu */         /* Reph formed only with ZWJ */

  0x0CB0u, /* Kannada */

  0x0D30u, /* Malayalam */      /* No Reph, Logical Repha */

  0x0DBBu, /* Sinhala */                /* Reph formed only with ZWJ */

  0x179Au, /* Khmer */          /* No Reph, Visual Repha */

};

static inline bool

is_ra (hb_codepoint_t u)

{

  for (unsigned int i = 0; i < ARRAY_LENGTH (ra_chars); i++)

    if (u == ra_chars[i])

      return true;

  return false;

}

static inline bool

is_one_of (const hb_glyph_info_t &info, unsigned int flags)

{

  /* If it ligated, all bets are off. */

  if (_hb_glyph_info_ligated (&info)) return false;

  return !!(FLAG_SAFE (info.indic_category()) & flags);

}

static inline bool

is_joiner (const hb_glyph_info_t &info)

{

  return is_one_of (info, JOINER_FLAGS);

}

static inline bool

is_consonant (const hb_glyph_info_t &info)

{

  return is_one_of (info, CONSONANT_FLAGS);

}

static inline bool

is_halant_or_coeng (const hb_glyph_info_t &info)

{

  return is_one_of (info, HALANT_OR_COENG_FLAGS);

}

static inline void

set_indic_properties (hb_glyph_info_t &info)

{

  hb_codepoint_t u = info.codepoint;

  unsigned int type = hb_indic_get_categories (u);

  indic_category_t cat = (indic_category_t) (type & 0x7Fu);

  indic_position_t pos = (indic_position_t) (type >> 8);

  /*

   * Re-assign category

   */

  /* The spec says U+0952 is OT_A.  However, testing shows that Uniscribe

   * treats a whole bunch of characters similarly.

   * TESTS: For example, for U+0951:

   * U+092E,U+0947,U+0952

   * U+092E,U+0952,U+0947

   * U+092E,U+0947,U+0951

   * U+092E,U+0951,U+0947

   * U+092E,U+0951,U+0952

   * U+092E,U+0952,U+0951

   */

  if (unlikely (hb_in_ranges (u, 0x0951u, 0x0952u,

                                 0x1CD0u, 0x1CD2u,

                                 0x1CD4u, 0x1CE1u) ||

                            u == 0x1CF4u))

    cat = OT_A;

  /* The following act more like the Bindus. */

  else if (unlikely (hb_in_range (u, 0x0953u, 0x0954u)))

    cat = OT_SM;

  /* The following act like consonants. */

  else if (unlikely (hb_in_ranges (u, 0x0A72u, 0x0A73u,

                                      0x1CF5u, 0x1CF6u)))

    cat = OT_C;

  /* TODO: The following should only be allowed after a Visarga.

   * For now, just treat them like regular tone marks. */

  else if (unlikely (hb_in_range (u, 0x1CE2u, 0x1CE8u)))

    cat = OT_A;

  /* TODO: The following should only be allowed after some of

   * the nasalization marks, maybe only for U+1CE9..U+1CF1.

   * For now, just treat them like tone marks. */

  else if (unlikely (u == 0x1CEDu))

    cat = OT_A;

  /* The following take marks in standalone clusters, similar to Avagraha. */

  else if (unlikely (hb_in_ranges (u, 0xA8F2u, 0xA8F7u,

                                      0x1CE9u, 0x1CECu,

                                      0x1CEEu, 0x1CF1u)))

  {

    cat = OT_Symbol;

    ASSERT_STATIC ((int) INDIC_SYLLABIC_CATEGORY_AVAGRAHA == OT_Symbol);

  }

  else if (unlikely (hb_in_range (u, 0x17CDu, 0x17D1u) ||

                     u == 0x17CBu || u == 0x17D3u || u == 0x17DDu)) /* Khmer Various signs */

  {

    /* These are like Top Matras. */

    cat = OT_M;

    pos = POS_ABOVE_C;

  }

  else if (unlikely (u == 0x17C6u)) cat = OT_N; /* Khmer Bindu doesn't like to be repositioned. */

  else if (unlikely (u == 0x17D2u)) cat = OT_Coeng; /* Khmer coeng */

  else if (unlikely (hb_in_range (u, 0x2010u, 0x2011u)))

                                    cat = OT_PLACEHOLDER;

  else if (unlikely (u == 0x25CCu)) cat = OT_DOTTEDCIRCLE;

  else if (unlikely (u == 0xA982u)) cat = OT_SM; /* Javanese repha. */

  else if (unlikely (u == 0xA9BEu)) cat = OT_CM2; /* Javanese medial ya. */

  else if (unlikely (u == 0xA9BDu)) { cat = OT_M; pos = POS_POST_C; } /* Javanese vocalic r. */

  /*

   * Re-assign position.

   */

  if ((FLAG_SAFE (cat) & CONSONANT_FLAGS))

  {

    pos = POS_BASE_C;

    if (is_ra (u))

      cat = OT_Ra;

  }

  else if (cat == OT_M)

  {

    pos = matra_position (u, pos);

  }

  else if ((FLAG_SAFE (cat) & (FLAG (OT_SM) | FLAG (OT_VD) | FLAG (OT_A) | FLAG (OT_Symbol))))

  {

    pos = POS_SMVD;

  }

  if (unlikely (u == 0x0B01u)) pos = POS_BEFORE_SUB; /* Oriya Bindu is BeforeSub in the spec. */

  info.indic_category() = cat;

  info.indic_position() = pos;

}

/*

 * Things above this line should ideally be moved to the Indic table itself.

 */

/*

 * 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_FIRST,

  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,

  REPH_POS_DONT_CARE   = POS_RA_TO_BECOME_REPH

};

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_VIS_REPHA, /* Encoded Repha character, no reordering needed. */

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

};

enum pref_len_t {

  PREF_LEN_1 = 1,

  PREF_LEN_2 = 2,

  PREF_LEN_DONT_CARE = PREF_LEN_2

};

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;

  pref_len_t      pref_len;

};

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, PREF_LEN_1},

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

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

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

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

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

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

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

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

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

  {HB_SCRIPT_SINHALA,   false,0x0DCAu,BASE_POS_LAST_SINHALA,

                                                     REPH_POS_AFTER_MAIN, REPH_MODE_EXPLICIT, BLWF_MODE_PRE_AND_POST, PREF_LEN_DONT_CARE},

  {HB_SCRIPT_KHMER,     false,0x17D2u,BASE_POS_FIRST,REPH_POS_DONT_CARE,  REPH_MODE_VIS_REPHA,BLWF_MODE_PRE_AND_POST, PREF_LEN_2},

  {HB_SCRIPT_JAVANESE,  false,0xA9C0u,BASE_POS_FIRST,REPH_POS_DONT_CARE,  REPH_MODE_VIS_REPHA,BLWF_MODE_PRE_AND_POST, PREF_LEN_1},

};

/*

 * 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},

  {HB_TAG('c','f','a','r'), F_NONE},

  /*

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

  CFAR,

  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);

    map->add_gsub_pause (NULL);

  }

  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);

  }

  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)

{

  /* Uniscribe does not apply 'kern' in Khmer. */

  if (hb_options ().uniscribe_bug_compatible)

  {

    switch ((hb_tag_t) plan->props.script)

    {

      case HB_SCRIPT_KHMER:

        plan->map.add_feature (HB_TAG('k','e','r','n'), 0, F_GLOBAL);

        break;

    }

  }

  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_glyph (config->virama, 0, &glyph))

        glyph = 0;

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

       * Maybe one day... */

      /* Our get_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! */

      (const_cast<indic_shape_plan_t *> (this))->virama_glyph = glyph;

    }

    *pglyph = glyph;

    return glyph != 0;

  }

  const indic_config_t *config;