/* Copyright (C) 1995 Bjoern Beutel. */

/* Description. =============================================================*/

/* This module handles the splitting of Hangul syllables and multi-letter
 * Jamos into single Hangul letters (and back).
 * It also converts Romanised Hangul to single-letter Hangul (and back).
 * 
 * In this conversion module, we use four representations of
 * Hangul letters and syllables:
 * 1. Unicode Hangul syllables, which occupy code points 0xac00-0xd7a3.
 *    The syllables are sorted by their constituting letters. The sort criteria
 *    are (from major to minor):
 *    - the 19 different initial consonant combinations (Choseong) as defined 
 *      in the table CHOSEONGS
 *    - the 21 different vowel combinations (Jungseong) as defined in the table
 *      JUNGSEONGS
 *    - the 28 different final consonant combinations (Jonseong) as defined in
 *      the table JONSEONGS (including the empty string)
 * 2. Unicode alternative Jamo characters, which occupy the code points 
 *    0x3131-0x3163. For internal representation, only the Jamos that represent
 *    single characters are used.
 * 3. Roman code, which is a latin transcription; it adopts the Yale standard 
 *    for Hangul romanization.
 *    Here, every syllable begins with a dot ".". Transcripted Hangul is 
 *    enclosed in curly brackets in order to distinguish it from original
 *    latin characters. */

/* Includes. ================================================================*/

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <setjmp.h>
#include <glib.h>
#include "basic.h"
#include "pools.h"
#include "tries.h"
#include "hangul.h"

/* Constants. ===============================================================*/

/* Intermediate representation of single Jamo letters as strings */
#define A "\x01" /* a */
#define B "\x02" /* phieuph */
#define C "\x03" /* cieuc */
#define D "\x04" /* thieuth */
#define E "\x05" /* eo */
#define G "\x06" /* kieukh */
#define H "\x07" /* hieuh */
#define I "\x08" /* i */
#define K "\x09" /* kiyeok */
#define L "\x0a" /* rieul */
#define M "\x0b" /* mieum */
#define N "\x0c" /* nieun */
#define O "\x0d" /* o */
#define P "\x0e" /* pieup */
#define S "\x0f" /* sios */ 
#define T "\x10" /* tikeut */
#define U "\x11" /* eu */ 
#define W "\x12" /* u */
#define X "\x13" /* ieung */
#define Z "\x14" /* chieuch */
#define DOT "\x15" /* syllable start */

#define VOWELS A E I O U W

/* Intermediate representation of single Jamo letters as characters*/
#define A_C '\x01' /* a */
#define B_C '\x02' /* phieuph */
#define C_C '\x03' /* cieuc */
#define D_C '\x04' /* thieuth */
#define E_C '\x05' /* eo */
#define G_C '\x06' /* kieukh */
#define H_C '\x07' /* hieuh */
#define I_C '\x08' /* i */
#define K_C '\x09' /* kiyeok */
#define L_C '\x0a' /* rieul */
#define M_C '\x0b' /* mieum */
#define N_C '\x0c' /* nieun */
#define O_C '\x0d' /* o */
#define P_C '\x0e' /* pieup */
#define S_C '\x0f' /* sios */ 
#define T_C '\x10' /* tikeut */
#define U_C '\x11' /* eu */ 
#define W_C '\x12' /* u */
#define X_C '\x13' /* ieung */
#define Z_C '\x14' /* chieuch */
#define DOT_C '\x15' /* syllable start */

/* Unicode representation of single Jamo letters. */
static const u_short_t jamos_unicodes[22] =
{
  0, /* EOS */
  0x314f, /* a */
  0x314d, /* phieuph */
  0x3148, /* cieuc */
  0x314c, /* thieuth */
  0x3153, /* eo */
  0x314b, /* kieukh */
  0x314e, /* hieuh */
  0x3163, /* i */
  0x3131, /* kiyeok */
  0x3139, /* rieul */
  0x3141, /* mieum */
  0x3134, /* nieun */
  0x3157, /* o */
  0x3142, /* pieup */
  0x3145, /* sios */ 
  0x3137, /* tikeut */
  0x3161, /* eu */ 
  0x315c, /* u */
  0x3147, /* ieung */
  0x314a, /* chieuch */
  0x3164, /* syllable start */
};

enum {SYLLABLE_START = 0x3164};

/* Composition of Jamo characters */
enum {FIRST_JAMO = 0x3131, 
      LAST_JAMO = 0x3163, 
      JAMO_COUNT = (LAST_JAMO - FIRST_JAMO + 1) };

static string_t jamos[JAMO_COUNT] =
{
  (K), (K K), (K S), (N), (N C), (N H), (T), (T T), (L), (L K), (L M), (L P),
  (L S), (L D), (L B), (L H), (M), (P), (P P), (P S), (S), (S S), (X), (C),
  (C C), (Z), (G), (D), (B), (H), (A), (A I), (I A), (I A I), (E), (E I), 
  (I E), (I E I), (O), (O A), (O I E), (O I), (I O), (W), (W E), (W E I), 
  (W I), (I W), (U), (U I), (I) 
};

enum {FIRST_SYLLABLE = 0xac00,
      LAST_SYLLABLE = 0xd7a3,
      SYLLABLE_COUNT = (LAST_SYLLABLE - FIRST_SYLLABLE + 1)};

/* The initial consonants in a syllable. */
enum {CHOSEONG_COUNT = 19};
static string_t choseongs[CHOSEONG_COUNT] = 
{ 
  (K), (K K), (N), (T), (T T), (L), (M), (P), (P P), (S), (S S), (X), (C), 
  (C C), (Z), (G), (D), (B), (H),
};

/* The vowels in a syllable. */
enum {JUNGSEONG_COUNT = 21};
static string_t jungseongs[JUNGSEONG_COUNT] = 
{ 
  (A), (A I), (I A), (I A I), (E), (E I), (I E), (I E I), (O), (O A), (O I E),
  (O I), (I O), (W), (W E), (W E I), (W I), (I W), (U), (U I), (I)
};

/* The final consonants in a syllable. */
enum {JONSEONG_COUNT = 28};
static string_t jonseongs[JONSEONG_COUNT] = 
{
  "", (K), (K K), (K S), (N), (N C), (N H), (T), (L), (L K), (L M), (L P), 
  (L S), (L D), (L B), (L H), (M), (P), (P S), (S), (S S), (X), (C), (Z), (G), 
  (D), (B), (H),
};

enum {SPLIT_TABLE_SIZE = (SYLLABLE_COUNT + JAMO_COUNT)};

/* Global variables. ========================================================*/

bool_t roman_hangul;
/* Indicates whether Hangul output is transcribed in latin script. */

/* Variables. ===============================================================*/

static byte_t jamo_enc[JAMO_COUNT + 1]; 
/* Intermediate encoding of Jamo single letters and syllable start. */

static string_t split_strings[SPLIT_TABLE_SIZE];
static pool_t string_pool; /* String pool with split Syllables and Jamos. */
static int_t *split_trie; /* Trie used to segmentise Hangul syllables. */
static int_t split_trie_root; /* Root node index of SPLIT_TRIE. */

/* Functions. ===============================================================*/

static int
compare_trie_entries( const void *entry1, const void *entry2 )
/* Compare two trie entries. */
{ 
  return strcmp_no_case( ((trie_entry_t *) entry1)->key,
                         ((trie_entry_t *) entry2)->key );
}

/*---------------------------------------------------------------------------*/

static void
add_jamos_to_text( text_t *text, const char *jamos )
{
  for (; *jamos != EOS; jamos++ )
    add_unichar_to_text( text, jamos_unicodes[ (int_t) *jamos ]);
}

/*---------------------------------------------------------------------------*/

void 
init_hangul( void )
/* Initialise the hangul module. */
{ 
  trie_entry_t trie_entries[ SPLIT_TABLE_SIZE ]; /* Syllable/Jamos. */
  int_t c, i, choseong, jungseong, jonseong;
  pool_t trie_pool;
  text_t *text;

  if (! split_hangul_syllables) 
    return;

  /* Fill table to convert from Jamo letter to intermediate encoding. */
  for (i = A_C; i <= DOT_C; i++)
    jamo_enc[ jamos_unicodes[i] - FIRST_JAMO ] = i;

  text = new_text();
  string_pool = new_pool( sizeof( char_t ) );

  for (i = 0; i < SYLLABLE_COUNT; i++) 
  { 
    /* Build Jamos string for syllable i. */
    c = i / JONSEONG_COUNT;
    jonseong = i % JONSEONG_COUNT;
    jungseong = c % JUNGSEONG_COUNT;
    choseong = c / JUNGSEONG_COUNT;
    clear_text( text );
    add_unichar_to_text( text, SYLLABLE_START );
    add_jamos_to_text( text, choseongs[ choseong ] );
    add_jamos_to_text( text, jungseongs[ jungseong ] );
    add_jamos_to_text( text, jonseongs[ jonseong ] );
    split_strings[i] = copy_string_to_pool( string_pool, text->buffer, NULL );
    
    /* Copy to trie entry table. */
    trie_entries[i].key = split_strings[i];
    trie_entries[i].content = i + FIRST_SYLLABLE;
  }

  for (i = SYLLABLE_COUNT; i < SPLIT_TABLE_SIZE; i++)
  {
    clear_text( text );
    add_jamos_to_text( text, jamos[ i  - SYLLABLE_COUNT ] );
    split_strings[i] = copy_string_to_pool( string_pool, text->buffer, NULL );
    trie_entries[i].key = split_strings[i];
    trie_entries[i].content = i - SYLLABLE_COUNT + FIRST_JAMO;
  }

  free_text( &text );

  /* Sort the Jamos strings and build the trie. */ 
  qsort( trie_entries, SPLIT_TABLE_SIZE, sizeof( trie_entry_t ), 
         compare_trie_entries);
  new_trie( SPLIT_TABLE_SIZE, trie_entries, &trie_pool, &split_trie_root );
  split_trie = pool_to_vector( trie_pool );
  free_pool( &trie_pool );

  roman_hangul = FALSE;
}

/*---------------------------------------------------------------------------*/

void 
terminate_hangul( void )
/* Terminate the hangul module. */
{ 
  if (! split_hangul_syllables) 
    return;
  free_mem( &split_trie );
  free_pool( &string_pool );
}  

/* Conversion of Jamos to romanised Hangul. =================================*/

static char_t *
jamos_to_roman( string_t jamos_string )
/* Convert Jamos string JAMOS_STRING to romanised Hangul. */
{ 
  /* Modified Yale roman representation for each of the Jamos letters. */
  static string_t romans[24] = 
  { NULL, "a", "ph", "c", "th", "e", "kh", "h", "i", "k", "l", "m", "n", "o", 
    "p", "s", "t", "u", "wu", "ng", "ch", "."
  };

  string_t roman_segment;
  text_t *roman_text;
  int_t c;
  char_t enc, prev, next;

  roman_text = new_text();
  while (*jamos_string != EOS) 
  { 
    c = g_utf8_get_char( jamos_string );
    if (c >= FIRST_JAMO && c <= SYLLABLE_START)
    { 
      /* Convert Jamos. */
      add_char_to_text( roman_text, '{' );
      enc = jamo_enc[ c - FIRST_JAMO ];
      prev = EOS;
      do
      { 
	jamos_string = g_utf8_next_char( jamos_string );
 	c = g_utf8_get_char( jamos_string );
	if (c >= FIRST_JAMO && c <= SYLLABLE_START)
	  next = jamo_enc[ c - FIRST_JAMO ];
	else
	  next = EOS;
	
        /* Convert ENC to roman. */
	roman_segment = romans[ (int_t) enc ];
        switch (enc) 
	{
	case X_C:
	  if (prev == DOT_C)
	    roman_segment = "";
	  break;
        case I_C:
          if ((prev != EOS && strchr( VOWELS, prev ) != NULL)
	      || (next != EOS && strchr( VOWELS, next ) != NULL)) 
	  { 
	    roman_segment = "y"; 
	  }
          break;
        case O_C:
          if (next == A_C) 
	    roman_segment = "w";
          break;
        case W_C:
          if (prev == I_C)
	    roman_segment = "u"; 
	  else if (next != EOS && strchr( VOWELS, next ) != NULL) 
	  { 
	    roman_segment = "w"; 
	  }
          break;
        default:
          break;
        } 
        add_to_text( roman_text, roman_segment );
        prev = enc;
	enc = next;
      } while (enc != 0);
      add_char_to_text( roman_text, '}' );
    } 
    else 
    {
      add_unichar_to_text( roman_text, c );
      jamos_string = g_utf8_next_char( jamos_string );
    }
  }
  
  return text_to_string( &roman_text );
}

/* Conversion of romanised Hangul to Jamos. =================================*/

static char_t * 
roman_to_jamos( string_t roman_string )
/* Convert transcribed Hangul string ROMAN_STRING to Jamos. */
{ 
  /* All letter sequences that can be converted to hancode. */
  static struct {string_t roman; string_t jamos;} romans[] = 
  { 
    /* Two-letter strings must come first. */
    {"ch", Z}, {"kh", G}, {"th", D}, {"ph", B}, 
    {"wu", W}, {"ng", X}, {"wa", O A}, {"yu", I W},
    
    {"a", A}, {"c", C}, {"e", E}, {"h", H}, {"i", I}, {"k", K}, {"l", L}, 
    {"m", M}, {"n", N}, {"o", O}, {"p", P}, {"r", L}, {"s", S}, {"t", T}, 
    {"u", U}, {"w", W}, {"x", X}, {"y", I}, {".", DOT},
    {NULL, NULL}
  };
  int_t i;
  text_t *jamos_text;

  jamos_text = new_text();
  while (*roman_string != EOS) 
  { 
    if (*roman_string == '{') 
    { 
      roman_string++;
      while (*roman_string != '}') 
      { 
	if (*roman_string == EOS) 
	  complain( "Missing \"}\" in romanised Hangul." );

        /* Insert an "x" at beginning of syllable if vowel is following. */
        if (roman_string[-1] == '.' 
	    && strrchr( "aeiouwy", roman_string[0] ) != NULL) 
	{ 
	  add_jamos_to_text( jamos_text, X ); 
	}

        for (i = 0; romans[i].roman != NULL; i++) 
	{ 
	  if (strncmp( roman_string, romans[i].roman, 
		       strlen( romans[i].roman ) ) == 0) 
	  { 
	    add_jamos_to_text( jamos_text, romans[i].jamos );
            roman_string += strlen( romans[i].roman );
            break;
          }
        }
        
        if (romans[i].roman == NULL)
	{ 
	  complain( "\"%c\" is not a romanised Hangul letter.", 
		    *roman_string );
	}
      }
      /* Jump over closing "}" */
      roman_string++;
    } 
    else 
      add_char_to_text( jamos_text, *roman_string++ );
  }
  
  return text_to_string( &jamos_text );
}

/* Conversion of Jamos to Hangul syllables. =================================*/

static char_t *
jamos_to_syllables( string_t jamos_string )
/* Convert Jamos JAMOS_STRING to Unicode Hangul syllables. */
{ 
  text_t *syl_text;
  int_t trie_code, code, unicode;
  int_t trie_node;
  string_t string_p;

  syl_text = new_text();
  while (*jamos_string != EOS) 
  { 
    /* Try to combine a syllable or a multi-consonant Jamo. */
    code = g_utf8_get_char( jamos_string );
    if (code >= FIRST_JAMO && code <= SYLLABLE_START)
    {
      /* Search the trie until we have found the longest segment. */
      trie_node = split_trie_root;
      string_p = jamos_string;
      unicode = 0;
      while (lookup_trie( split_trie, &trie_node, &string_p, &trie_code )) 
      { 
	jamos_string = string_p; 
        unicode = trie_code;
      }
      if (unicode != 0) 
	add_unichar_to_text( syl_text, unicode );
      else if (code == SYLLABLE_START)
      { 
	add_to_text( syl_text, "{.}" );
        jamos_string = g_utf8_next_char( jamos_string );
      } 
      else 
	complain( "Internal error." );
    } 
    else 
    {
      add_unichar_to_text( syl_text, code );
      jamos_string = g_utf8_next_char( jamos_string );
    }
  }     
  return text_to_string( &syl_text );
}

/* Conversion of Hangul syllables to Jamos. =================================*/

static char_t * 
syllables_to_jamos( string_t syl_string )
/* Convert Hangul syllables in SYL_STRING to Jamos.
 * The returned string remains valid until this function is called again. */
{ 
  text_t *jamos_text;
  int_t c;

  jamos_text = new_text();
  while (*syl_string != EOS) 
  { 
    c = g_utf8_get_char( syl_string );
    syl_string = g_utf8_next_char( syl_string );
    if (c >= FIRST_SYLLABLE && c <= LAST_SYLLABLE)
      add_to_text( jamos_text, split_strings[ c - FIRST_SYLLABLE ] );
    else if (c >= FIRST_JAMO && c <= LAST_JAMO)
    {
      add_to_text( jamos_text,
		   split_strings[ c - FIRST_JAMO  + SYLLABLE_COUNT] );
    }
    else
      add_unichar_to_text( jamos_text, c );
  }
  return text_to_string( &jamos_text );
}

/* Global conversion routines. ==============================================*/

void 
decode_hangul( char_t **string_p )
/* Decode *STRING_P to external format.
 * *STRING_P must be a string on the heap.
 * It will be replaced by the new string which is also on the heap. */
{ 
  char_t *string;

  if (! split_hangul_syllables)
    return;
  if (roman_hangul) 
    string = jamos_to_roman( *string_p );
  else 
    string = jamos_to_syllables( *string_p );
  free_mem( string_p );
  *string_p = string;
}

/*---------------------------------------------------------------------------*/

void 
encode_hangul( char_t **string_p )
/* Encode *STRING_P to internal format.
 * *STRING_P must be a string on the heap.
 * It will be replaced by the new string which is also on the heap. */
{ 
  char_t *string;

  if (! split_hangul_syllables) 
    return;
  string = syllables_to_jamos( *string_p );
  free_mem( string_p );
  *string_p = roman_to_jamos( string );
  free_mem( &string );
}

/* End of file. =============================================================*/