/* Copyright (c) Dovecot authors, see top-level COPYING file */

#include "lib.h"

#include "unicode-data.h"

#include "unicode-break.h"

/* This file implements the Unicode Text Segmemtation algorithms as specified in

   Unicode Standard Annex #29.

 */

/*

 * Grapheme Cluster Boundaries (Unicode Standard Annex #29, Section 3)

 */

void unicode_gc_break_init(struct unicode_gc_break *gcbrk)

{

  i_zero(gcbrk);

}

bool unicode_gc_break_cp(struct unicode_gc_break *gcbrk, uint32_t cp,

       const struct unicode_code_point_data **_cp_data)

{

  if (*_cp_data == NULL)

    *_cp_data = unicode_code_point_get_data(cp);

  const struct unicode_code_point_data *cp_data = *_cp_data;

  int bstatus = -1;

  /* GB1: Break at the start and end of text.

     sot + Any

     Any + eot

   */

  if (!gcbrk->gb1) {

    gcbrk->gb1 = TRUE;

    bstatus = 1;

  }

  /* GB3: Do not break between a CR and LF.

     CR x LF

   */

  if (gcbrk->gb3) {

    if (cp_data->pb_b_lf) {

      if (bstatus < 0)

        bstatus = 0;

    }

    if (!cp_data->pb_b_cr)

      gcbrk->gb3 = FALSE;

  } else if (cp_data->pb_b_cr) {

    gcbrk->gb3 = TRUE;

  }

  /* GB4, GB5: Break before and after controls.

     (Control | CR | LF) +

     + (Control | CR | LF)

   */

  if (gcbrk->gb4) {

    /* GB4: (Control | CR | LF) / */

    if (bstatus < 0)

      bstatus = 1;

    if (!cp_data->pb_b_cr && !cp_data->pb_b_lf &&

        !cp_data->pb_gcb_control)

      gcbrk->gb4 = FALSE;

  } else if (cp_data->pb_b_cr || cp_data->pb_b_lf ||

       cp_data->pb_gcb_control) {

    gcbrk->gb4 = TRUE;

    /* GB5: / (Control | CR | LF) */

    if (bstatus < 0)

      bstatus = 1;

  }

  /* GB6: Do not break Hangul syllable or other conjoining sequences.

     L x (L | V | LV | LVT)

   */

  if (gcbrk->gb6) {

    if (cp_data->pb_gcb_v || cp_data->pb_gcb_lv ||

        cp_data->pb_gcb_lvt) {

      if (bstatus < 0)

        bstatus = 0;

      gcbrk->gb6 = FALSE;

    } else if (cp_data->pb_gcb_l) {

      if (bstatus < 0)

        bstatus = 0;

    } else {

      gcbrk->gb6 = FALSE;

    }

  } else if (cp_data->pb_gcb_l) {

    gcbrk->gb6 = TRUE;

  }

  /* GB7: Do not break Hangul syllable or other conjoining sequences.

     (LV | V) x (V | T)

   */

  if (gcbrk->gb7) {

    if (cp_data->pb_gcb_t) {

      if (bstatus < 0)

        bstatus = 0;

      gcbrk->gb7 = FALSE;

    } else if (cp_data->pb_gcb_v) {

      if (bstatus < 0)

        bstatus = 0;

    } else {

      gcbrk->gb7 = FALSE;

    }

  } else if (cp_data->pb_gcb_lv || cp_data->pb_gcb_v) {

    gcbrk->gb7 = TRUE;

  }

  /* GB8: Do not break Hangul syllable or other conjoining sequences.

     (LVT | T) x T

   */

  if (gcbrk->gb8) {

    if (!cp_data->pb_gcb_t)

      gcbrk->gb8 = FALSE;

    else {

      if (bstatus < 0)

        bstatus = 0;

    }

  } else if (cp_data->pb_gcb_lvt || cp_data->pb_gcb_t) {

    gcbrk->gb8 = TRUE;

  }

  /* GB9: Do not break before extending characters or ZWJ.

     x (Extend | ZWJ)

   */

  if (cp_data->pb_gcb_extend || cp_data->pb_b_zwj) {

    if (bstatus < 0)

      bstatus = 0;

  }

  /* GB9a: Do not break before SpacingMarks.

     x SpacingMark

   */

  if (cp_data->pb_gcb_spacingmark) {

    if (bstatus < 0)

      bstatus = 0;

  }

  /* GB9b: Do not break after Prepend characters.

     Prepend x

   */

  if (gcbrk->gb9b) {

    if (bstatus < 0)

      bstatus = 0;

    if (!cp_data->pb_gcb_prepend)

      gcbrk->gb9b = FALSE;

  } else if (cp_data->pb_gcb_prepend) {

    gcbrk->gb9b = TRUE;

  }

  /* GB9c: Do not break within Indic conjuncts.

     \p{InCB=Linker} \p{InCB=Extend}* x \p{InCB=Consonant}

   */

  enum {

    GB9C_STATE_NONE = 0,

    GB9C_STATE_LINKER,

  };

  switch (cp_data->indic_conjunct_break) {

  case UNICODE_INDIC_CONJUNCT_BREAK_LINKER:

    gcbrk->gb9c = GB9C_STATE_LINKER;

    break;

  case UNICODE_INDIC_CONJUNCT_BREAK_EXTEND:

    break;

  case UNICODE_INDIC_CONJUNCT_BREAK_CONSONANT:

    if (gcbrk->gb9c == GB9C_STATE_LINKER && bstatus < 0)

      bstatus = 0;

    gcbrk->gb9c = GB9C_STATE_NONE;

    break;

  default:

    gcbrk->gb9c = GB9C_STATE_NONE;

    break;

  }

  /* GB11: Do not break within emoji ZWJ sequences.

     \p{Extended_Pictographic} Extend* ZWJ x \p{Extended_Pictographic}

   */

  enum {

    GB11_STATE_NONE = 0,

    GB11_STATE_EP,

    GB11_STATE_ZWJ,

  };

  switch (gcbrk->gb11) {

  case GB11_STATE_NONE:

    if (cp_data->pb_e_extended_pictographic)

      gcbrk->gb11 = GB11_STATE_EP;

    break;

  case GB11_STATE_EP:

    if (cp_data->pb_e_extended_pictographic)

      break;

    if (cp_data->pb_gcb_extend)

      break;

    if (cp_data->pb_b_zwj) {

      gcbrk->gb11 = GB11_STATE_ZWJ;

      break;

    }

    gcbrk->gb11 = GB11_STATE_NONE;

    break;

  case GB11_STATE_ZWJ:

    if (cp_data->pb_e_extended_pictographic) {

      if (bstatus < 0)

        bstatus = 0;

      gcbrk->gb11 = GB11_STATE_EP;

      break;

    }

    gcbrk->gb11 = GB11_STATE_NONE;

    break;

  default:

    i_unreached();

  }

  /* GB12, GB13: Do not break within emoji flag sequences. That is, do not

           break between regional indicator (RI) symbols if there is

           an odd number of RI characters before the break point.

     sot   (RI RI)* RI x RI

     [^RI] (RI RI)* RI x RI

   */

  if (gcbrk->gb12) {

    if (cp_data->pb_b_regional_indicator) {

      if (bstatus < 0)

        bstatus = 0;

    }

    gcbrk->gb12 = FALSE;

  } else if (cp_data->pb_b_regional_indicator) {

    gcbrk->gb12 = TRUE;

  }

  /* GB999: Otherwise, break everywhere.

     (Any + Any)

   */

  if (bstatus == 0)

    return FALSE;

  return TRUE;

}