/* libhangul

 * Copyright (c) 2005,2006 Choe Hwanjin

 * All rights reserved.

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <inttypes.h>

#include <limits.h>

#include "hangul.h"

#include "hangulinternals.h"

#ifndef TRUE

#define TRUE 1

#endif

#ifndef FALSE

#define FALSE 0

#endif

#define HANGUL_KEYBOARD_TABLE_SIZE 0x80

typedef void   (*HangulOnTranslate)  (HangulInputContext*,

				      int,

				      ucschar*,

				      void*);

typedef bool   (*HangulOnTransition) (HangulInputContext*,

				      ucschar,

				      const ucschar*,

				      void*);

typedef struct _HangulCombinationItem HangulCombinationItem;

struct _HangulKeyboard {

    int type;

    ucschar* table;

};

struct _HangulCombinationItem {

    uint32_t key;

    ucschar code;

};

struct _HangulCombination {

    int size;

    HangulCombinationItem *table;

};

struct _HangulBuffer {

    ucschar choseong;

    ucschar jungseong;

    ucschar jongseong;

    ucschar stack[12];

    int     index;

};

struct _HangulInputContext {

    int type;

    const HangulKeyboard*    keyboard;

    const HangulCombination* combination;

    HangulBuffer buffer;

    int output_mode;

    ucschar preedit_string[64];

    ucschar commit_string[64];

    ucschar flushed_string[64];

    HangulOnTranslate   on_translate;

    void*               on_translate_data;

    HangulOnTransition  on_transition;

    void*               on_transition_data;

    HangulICFilter filter;

    void *filter_data;

    unsigned int use_jamo_mode_only : 1;

};

#include "hangulkeyboard.h"

static const HangulKeyboard hangul_keyboard_2 = {

    HANGUL_KEYBOARD_TYPE_JAMO,

    (ucschar*)hangul_keyboard_table_2

};

static const HangulKeyboard hangul_keyboard_32 = {

    HANGUL_KEYBOARD_TYPE_JASO,

    (ucschar*)hangul_keyboard_table_32

};

static const HangulKeyboard hangul_keyboard_390 = {

    HANGUL_KEYBOARD_TYPE_JASO,

    (ucschar*)hangul_keyboard_table_390

};

static const HangulKeyboard hangul_keyboard_3final = {

    HANGUL_KEYBOARD_TYPE_JASO,

    (ucschar*)hangul_keyboard_table_3final

};

static const HangulKeyboard hangul_keyboard_3sun = {

    HANGUL_KEYBOARD_TYPE_JASO,

    (ucschar*)hangul_keyboard_table_3sun

};

static const HangulKeyboard hangul_keyboard_3yet = {

    HANGUL_KEYBOARD_TYPE_JASO,

    (ucschar*)hangul_keyboard_table_3yet

};

static const HangulCombination hangul_combination_default = {

    N_ELEMENTS(hangul_combination_table_default),

    (HangulCombinationItem*)hangul_combination_table_default

};

static const HangulCombination hangul_combination_full = {

    N_ELEMENTS(hangul_combination_table_full),

    (HangulCombinationItem*)hangul_combination_table_full

};

static void    hangul_buffer_push(HangulBuffer *buffer, ucschar ch);

static ucschar hangul_buffer_pop (HangulBuffer *buffer);

static ucschar hangul_buffer_peek(HangulBuffer *buffer);

static void    hangul_buffer_clear(HangulBuffer *buffer);

static int     hangul_buffer_get_string(HangulBuffer *buffer, ucschar*buf, int buflen);

static int     hangul_buffer_get_jamo_string(HangulBuffer *buffer, ucschar *buf, int buflen);

static void    hangul_ic_flush_internal(HangulInputContext *hic);

HangulKeyboard*

hangul_keyboard_new()

{

    HangulKeyboard *keyboard = malloc(sizeof(HangulKeyboard));

    if (keyboard != NULL) {

	keyboard->table = malloc(sizeof(ucschar) * HANGUL_KEYBOARD_TABLE_SIZE);

	if (keyboard->table != NULL) {

	    int i;

	    for (i = 0; i < HANGUL_KEYBOARD_TABLE_SIZE; i++)

		keyboard->table[i] = 0;

	    return keyboard;

	}

	free(keyboard);

    }

    return NULL;

}

static ucschar

hangul_keyboard_get_value(const HangulKeyboard *keyboard, int key)

{

    if (keyboard != NULL) {

	if (key >= 0 && key < HANGUL_KEYBOARD_TABLE_SIZE)

	    return keyboard->table[key];

    }

    return 0;

}

void

hangul_keyboard_set_value(HangulKeyboard *keyboard, int key, ucschar value)

{

    if (keyboard != NULL) {

	if (key >= 0 && key < N_ELEMENTS(keyboard->table))

	    keyboard->table[key] = value;

    }

}

static int

hangul_keyboard_get_type(const HangulKeyboard *keyboard)

{

    int type = 0;

    if (keyboard != NULL) {

	type = keyboard->type;

    }

    return type;

}

void

hangul_keyboard_set_type(HangulKeyboard *keyboard, int type)

{

    if (keyboard != NULL) {

	keyboard->type = type;

    }

}

void

hangul_keyboard_delete(HangulKeyboard *keyboard)

{

    if (keyboard != NULL)

	free(keyboard);

}

HangulCombination*

hangul_combination_new()

{

    HangulCombination *combination = malloc(sizeof(HangulCombination));

    if (combination != NULL) {

	combination->size = 0;

	combination->table = NULL;

	return combination;

    }

    return NULL;

}

void

hangul_combination_delete(HangulCombination *combination)

{

    if (combination != NULL) {

	if (combination->table != NULL)

	    free(combination->table);

	free(combination);

    }

}

static uint32_t

hangul_combination_make_key(ucschar first, ucschar second)

{

    return first << 16 | second;

}

bool

hangul_combination_set_data(HangulCombination* combination, 

			    ucschar* first, ucschar* second, ucschar* result,

			    unsigned int n)

{

    if (combination == NULL)

	return false;

    if (n == 0 || n > ULONG_MAX / sizeof(HangulCombinationItem))

	return false;

    combination->table = malloc(sizeof(HangulCombinationItem) * n);

    if (combination->table != NULL) {

	int i;

	combination->size = n;

	for (i = 0; i < n; i++) {

	    combination->table[i].key = hangul_combination_make_key(first[i], second[i]);

	    combination->table[i].code = result[i];

	}

	return true;

    }

    return false;

}

static int 

hangul_combination_cmp(const void* p1, const void* p2)

{

    const HangulCombinationItem *item1 = p1;

    const HangulCombinationItem *item2 = p2;

    return item1->key - item2->key;

}

ucschar

hangul_combination_combine(const HangulCombination* combination,

			   ucschar first, ucschar second)

{

    HangulCombinationItem *res;

    HangulCombinationItem key;

    if (combination == NULL)

	return 0;

    key.key = hangul_combination_make_key(first, second);

    res = bsearch(&key, combination->table, combination->size,

	          sizeof(combination->table[0]), hangul_combination_cmp);

    if (res != NULL)

	return res->code;

    return 0;

}

static bool

hangul_buffer_is_empty(HangulBuffer *buffer)

{

    return buffer->choseong == 0 && buffer->jungseong == 0 &&

	   buffer->jongseong == 0;

}

static bool

hangul_buffer_has_choseong(HangulBuffer *buffer)

{

    return buffer->choseong != 0;

}

static bool

hangul_buffer_has_jungseong(HangulBuffer *buffer)

{

    return buffer->jungseong != 0;

}

static bool

hangul_buffer_has_jongseong(HangulBuffer *buffer)

{

    return buffer->jongseong != 0;

}

static void

hangul_buffer_push(HangulBuffer *buffer, ucschar ch)

{

    if (hangul_is_choseong(ch)) {

	buffer->choseong = ch;

    } else if (hangul_is_jungseong(ch)) {

	buffer->jungseong = ch;

    } else if (hangul_is_jongseong(ch)) {

	buffer->jongseong = ch;

    } else {

    }

    buffer->stack[++buffer->index] = ch;

}

static ucschar

hangul_buffer_pop(HangulBuffer *buffer)

{

    return buffer->stack[buffer->index--];

}

static ucschar

hangul_buffer_peek(HangulBuffer *buffer)

{

    if (buffer->index < 0)

	return 0;

    return buffer->stack[buffer->index];

}

static void

hangul_buffer_clear(HangulBuffer *buffer)

{

    buffer->choseong = 0;

    buffer->jungseong = 0;

    buffer->jongseong = 0;

    buffer->index = -1;

    buffer->stack[0]  = 0;

    buffer->stack[1]  = 0;

    buffer->stack[2]  = 0;

    buffer->stack[3]  = 0;

    buffer->stack[4]  = 0;

    buffer->stack[5]  = 0;

    buffer->stack[6]  = 0;

    buffer->stack[7]  = 0;

    buffer->stack[8]  = 0;

    buffer->stack[9]  = 0;

    buffer->stack[10] = 0;

    buffer->stack[11] = 0;

}

static int

hangul_buffer_get_jamo_string(HangulBuffer *buffer, ucschar *buf, int buflen)

{

    int n = 0;

    if (buffer->choseong || buffer->jungseong || buffer->jongseong) {

	if (buffer->choseong) {

	    buf[n++] = buffer->choseong;

	} else {

	    buf[n++] = HANGUL_CHOSEONG_FILLER;

	}

	if (buffer->jungseong) {

	    buf[n++] = buffer->jungseong;

	} else {

	    buf[n++] = HANGUL_JUNGSEONG_FILLER;

	}

	if (buffer->jongseong) {

	    buf[n++] = buffer->jongseong;

	}

    }

    buf[n] = 0;

    return n;

}

static int

hangul_jaso_to_string(ucschar cho, ucschar jung, ucschar jong,

		      ucschar *buf, int len)

{

    ucschar ch = 0;

    int n = 0;

    if (cho) {

	if (jung) {

	    /* have cho, jung, jong or no jong */

	    ch = hangul_jaso_to_syllable(cho, jung, jong);

	    buf[n++] = ch;

	} else {

	    if (jong) {

		/* have cho, jong */

		ch = hangul_jaso_to_jamo(cho);

		buf[n++] = ch;

		ch = hangul_jaso_to_jamo(jong);

		buf[n++] = ch;

	    } else {

		/* have cho */

		ch = hangul_jaso_to_jamo(cho);

		buf[n++] = ch;

	    }

	}

    } else {

	if (jung) {

	    if (jong) {

		/* have jung, jong */

		ch = hangul_jaso_to_jamo(jung);

		buf[n++] = ch;

		ch = hangul_jaso_to_jamo(jong);

		buf[n++] = ch;

	    } else {

		/* have jung */

		ch = hangul_jaso_to_jamo(jung);

		buf[n++] = ch;

	    }

	} else {

	    if (jong) { 

		/* have jong */

		ch = hangul_jaso_to_jamo(jong);

		buf[n++] = ch;

	    } else {

		/* have nothing */

		buf[n] = 0;

	    }

	}

    }

    buf[n] = 0;

    return n;

}

static int

hangul_buffer_get_string(HangulBuffer *buffer, ucschar *buf, int buflen)

{

    return hangul_jaso_to_string(buffer->choseong,

				 buffer->jungseong,

				 buffer->jongseong,

				 buf, buflen);

}

static bool

hangul_buffer_backspace(HangulBuffer *buffer)

{

    if (buffer->index >= 0) {

	ucschar ch = hangul_buffer_pop(buffer);

	if (ch == 0)

	    return false;

	if (hangul_is_choseong(ch)) {

	    ch = hangul_buffer_peek(buffer);

	    buffer->choseong = hangul_is_choseong(ch) ? ch : 0;

	    return true;

	} else if (hangul_is_jungseong(ch)) {

	    ch = hangul_buffer_peek(buffer);

	    buffer->jungseong = hangul_is_jungseong(ch) ? ch : 0;

	    return true;

	} else if (hangul_is_jongseong(ch)) {

	    ch = hangul_buffer_peek(buffer);

	    buffer->jongseong = hangul_is_jongseong(ch) ? ch : 0;

	    return true;

	}

    }

    return false;

}

static 

#ifndef __SYMBIAN32__

inline 

#endif

bool

hangul_ic_push(HangulInputContext *hic, ucschar c)

{

    ucschar buf[64] = { 0, };

    if (hic->on_transition != NULL) {

	ucschar cho, jung, jong;

	if (hangul_is_choseong(c)) {

	    cho  = c;

	    jung = hic->buffer.jungseong;

	    jong = hic->buffer.jongseong;

	} else if (hangul_is_jungseong(c)) {

	    cho  = hic->buffer.choseong;

	    jung = c;

	    jong = hic->buffer.jongseong;

	} else if (hangul_is_jongseong(c)) {

	    cho  = hic->buffer.choseong;

	    jung = hic->buffer.jungseong;

	    jong = c;

	} else {

	    hangul_ic_flush_internal(hic);

	    return false;

	}

	hangul_jaso_to_string(cho, jung, jong, buf, N_ELEMENTS(buf));

	if (!hic->on_transition(hic, c, buf, hic->on_transition_data)) {

	    hangul_ic_flush_internal(hic);

	    return false;

	}

    } else {

	if (!hangul_is_jaso(c)) {

	    hangul_ic_flush_internal(hic);

	    return false;

	}

    }