/* Copyright (C) 2007-2008 The Android Open Source Project
**
** This software is licensed under the terms of the GNU General Public
** License version 2, as published by the Free Software Foundation, and
** may be copied, distributed, and modified under those terms.
**
** This program 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 General Public License for more details.
*/
#include "android/skin/keyboard.h"

#include "android/skin/charmap.h"
#include "android/skin/keycode.h"
#include "android/skin/keycode-buffer.h"
#include "android/utils/debug.h"
#include "android/utils/bufprint.h"
#include "android/utils/system.h"
#include "android/utils/utf8_utils.h"

#include <stdio.h>

#define  DEBUG  1

#if DEBUG
#  define  D(...)  VERBOSE_PRINT(keys,__VA_ARGS__)
#else
#  define  D(...)  ((void)0)
#endif

struct SkinKeyboard {
    const SkinCharmap*  charmap;
    SkinKeyset*         kset;
    char                enabled;
    char                raw_keys;

    SkinRotation        rotation;

    SkinKeyCommandFunc  command_func;
    void*               command_opaque;
    SkinKeyEventFunc    press_func;
    void*               press_opaque;

    SkinKeycodeBuffer   keycodes[1];
};

#define DEFAULT_ANDROID_CHARMAP  "qwerty2"

static bool skin_key_code_is_arrow(int code) {
    return code == kKeyCodeDpadLeft ||
           code == kKeyCodeDpadRight ||
           code == kKeyCodeDpadUp ||
           code == kKeyCodeDpadDown;
}

static void
skin_keyboard_cmd( SkinKeyboard*   keyboard,
                   SkinKeyCommand  command,
                   int             param )
{
    if (keyboard->command_func) {
        keyboard->command_func( keyboard->command_opaque, command, param );
    }
}

static SkinKeyCode
skin_keyboard_key_to_code(SkinKeyboard*  keyboard,
                          int            code,
                          int            mod,
                          int            down)
{
    SkinKeyCommand  command;

    D("key code=%d mod=%d str=%s",
      code,
      mod,
      skin_key_pair_to_string(code, mod));

    /* first, handle the arrow keys directly */
    if (skin_key_code_is_arrow(code)) {
        code = skin_keycode_rotate(code, -keyboard->rotation);
        D("handling arrow (code=%d mod=%d)", code, mod);
        if (!keyboard->raw_keys) {
            int  doCapL, doCapR, doAltL, doAltR;

            doCapL = mod & kKeyModLShift;
            doCapR = mod & kKeyModRShift;
            doAltL = mod & kKeyModLAlt;
            doAltR = mod & kKeyModRAlt;

            if (down) {
                if (doAltL) skin_keyboard_add_key_event(keyboard, kKeyCodeAltLeft, 1);
                if (doAltR) skin_keyboard_add_key_event(keyboard, kKeyCodeAltRight, 1);
                if (doCapL) skin_keyboard_add_key_event(keyboard, kKeyCodeCapLeft, 1);
                if (doCapR) skin_keyboard_add_key_event(keyboard, kKeyCodeCapRight, 1);
            }
            skin_keyboard_add_key_event(keyboard, code, down);

            if (!down) {
                if (doCapR) skin_keyboard_add_key_event(keyboard, kKeyCodeCapRight, 0);
                if (doCapL) skin_keyboard_add_key_event(keyboard, kKeyCodeCapLeft, 0);
                if (doAltR) skin_keyboard_add_key_event(keyboard, kKeyCodeAltRight, 0);
                if (doAltL) skin_keyboard_add_key_event(keyboard, kKeyCodeAltLeft, 0);
            }
            code = 0;
        }
        return code;
    }

    /* special case for keypad keys, ignore them here if numlock is on */
    if ((mod & kKeyModNumLock) != 0) {
        switch ((int)code) {
            case KEY_KP0:
            case KEY_KP1:
            case KEY_KP2:
            case KEY_KP3:
            case KEY_KP4:
            case KEY_KP5:
            case KEY_KP6:
            case KEY_KP7:
            case KEY_KP8:
            case KEY_KP9:
            case KEY_KPPLUS:
            case KEY_KPMINUS:
            case KEY_KPASTERISK:
            case KEY_KPSLASH:
            case KEY_KPEQUAL:
            case KEY_KPDOT:
            case KEY_KPENTER:
                return 0;
            default:
                ;
        }
    }

    /* now try all keyset combos */
    command = skin_keyset_get_command(keyboard->kset, code, mod);
    if (command != SKIN_KEY_COMMAND_NONE) {
        D("handling command %s from (sym=%d, mod=%d, str=%s)",
          skin_key_command_to_str(command),
          code,
          mod,
          skin_key_pair_to_string(code, mod));
        skin_keyboard_cmd(keyboard, command, down);
        return 0;
    }
    D("could not handle (code=%d, mod=%d, str=%s)", code, mod,
      skin_key_pair_to_string(code,mod));
    return -1;
}

/* this gets called only if the reverse unicode mapping didn't work
 * or wasn't used (when in raw keys mode)
 */

void
skin_keyboard_enable( SkinKeyboard*  keyboard,
                      int            enabled )
{
    keyboard->enabled = enabled;
    if (enabled) {
        skin_event_enable_unicode(!keyboard->raw_keys);
    }
}

static void
skin_keyboard_do_key_event( SkinKeyboard*   kb,
                            SkinKeyCode  code,
                            int             down )
{
    if (kb->press_func) {
        kb->press_func( kb->press_opaque, code, down );
    }
    skin_keyboard_add_key_event(kb, code, down);
}

void
skin_keyboard_process_event(SkinKeyboard*  kb, SkinEvent* ev, int  down)
{
    /* ignore key events if we're not enabled */
    if (!kb->enabled) {
        //printf( "ignoring key event\n");
        return;
    }

    if (ev->type == kEventTextInput) {
        if (!kb->raw_keys) {
            // TODO(digit): For each Unicode value in the input text.
            const uint8_t* text = ev->u.text.text;
            const uint8_t* end = text + sizeof(ev->u.text.text);
            while (text < end && *text) {
                uint32_t codepoint = 0;
                int len = android_utf8_decode(text, end - text, &codepoint);
                if (len < 0) {
                    break;
                }
                skin_keyboard_process_unicode_event(kb, codepoint, 1);
                skin_keyboard_process_unicode_event(kb, codepoint, 0);
                text += len;
            }
            skin_keyboard_flush(kb);
        }
    } else if (ev->type == kEventKeyDown || ev->type == kEventKeyUp) {
        int keycode = ev->u.key.keycode;
        int mod = ev->u.key.mod;

        /* first, try the keyboard-mode-independent keys */
        int code = skin_keyboard_key_to_code(kb, keycode, mod, down);
        if (code == 0) {
            return;
        }
        if ((int)code > 0) {
            skin_keyboard_do_key_event(kb, code, down);
            skin_keyboard_flush(kb);
            return;
        }

        /* Ctrl-K is used to switch between 'unicode' and 'raw' modes */
        if (keycode == kKeyCodeK) {
            if (mod == kKeyModLCtrl || mod == kKeyModRCtrl) {
                if (down) {
                    kb->raw_keys = !kb->raw_keys;
                    skin_event_enable_unicode(!kb->raw_keys);
                    D( "switching keyboard to %s mode", kb->raw_keys ? "raw" : "unicode" );
                }
                return;
            }
        }

        code = keycode;

        if ( !kb->raw_keys &&
            (code == kKeyCodeAltLeft  || code == kKeyCodeAltRight ||
             code == kKeyCodeCapLeft  || code == kKeyCodeCapRight ||
             code == kKeyCodeSym) ) {
            return;
        }

        if (code == KEY_BACKSPACE || code == KEY_ENTER) {
            skin_keyboard_do_key_event(kb, code, down);
            skin_keyboard_flush(kb);
            return;
        }
        D("ignoring keycode %d", keycode);
    }
}

void
skin_keyboard_set_keyset( SkinKeyboard*  keyboard, SkinKeyset*  kset )
{
    if (kset == NULL)
        return;
    if (keyboard->kset && keyboard->kset != skin_keyset_get_default()) {
        skin_keyset_free(keyboard->kset);
    }
    keyboard->kset = kset;
}


void
skin_keyboard_set_rotation( SkinKeyboard*     keyboard,
                            SkinRotation      rotation )
{
    keyboard->rotation = (rotation & 3);
}

void
skin_keyboard_on_command( SkinKeyboard*  keyboard, SkinKeyCommandFunc  cmd_func, void*  cmd_opaque )
{
    keyboard->command_func   = cmd_func;
    keyboard->command_opaque = cmd_opaque;
}

void
skin_keyboard_on_key_press( SkinKeyboard*  keyboard, SkinKeyEventFunc  press_func, void*  press_opaque )
{
    keyboard->press_func   = press_func;
    keyboard->press_opaque = press_opaque;
}

void
skin_keyboard_add_key_event( SkinKeyboard*  kb,
                             unsigned       code,
                             unsigned       down )
{
    skin_keycode_buffer_add(kb->keycodes, code, down);
}


void
skin_keyboard_flush( SkinKeyboard*  kb )
{
    skin_keycode_buffer_flush(kb->keycodes);
}


int
skin_keyboard_process_unicode_event( SkinKeyboard*  kb,  unsigned int  unicode, int  down )
{
    return skin_charmap_reverse_map_unicode(kb->charmap, unicode, down,
                                            kb->keycodes);
}


static SkinKeyboard*
skin_keyboard_create_from_charmap_name(const char* charmap_name,
                                       int  use_raw_keys,
                                       SkinKeyCodeFlushFunc keycode_flush)
{
    SkinKeyboard*  kb;

    ANEW0(kb);

    kb->charmap = skin_charmap_get_by_name(charmap_name);
    if (!kb->charmap) {
        // Charmap name was not found. Default to "qwerty2" */
        kb->charmap = skin_charmap_get_by_name(DEFAULT_ANDROID_CHARMAP);
        fprintf(stderr, "### warning, skin requires unknown '%s' charmap, reverting to '%s'\n",
                charmap_name, kb->charmap->name );
    }
    kb->raw_keys = use_raw_keys;
    kb->enabled  = 0;

    /* add default keyset */
    if (skin_keyset_get_default()) {
        kb->kset = skin_keyset_get_default();
    } else {
        kb->kset = skin_keyset_new_from_text(
                skin_keyset_get_default_text());
    }
    skin_keycode_buffer_init(kb->keycodes, keycode_flush);
    return kb;
}

SkinKeyboard*
skin_keyboard_create(const char* kcm_file_path,
                     int use_raw_keys,
                     SkinKeyCodeFlushFunc keycode_flush)
{
    const char* charmap_name = DEFAULT_ANDROID_CHARMAP;
    char        cmap_buff[SKIN_CHARMAP_NAME_SIZE];

    if (kcm_file_path != NULL) {
        kcm_extract_charmap_name(kcm_file_path, cmap_buff, sizeof cmap_buff);
        charmap_name = cmap_buff;
    }
    return skin_keyboard_create_from_charmap_name(
            charmap_name, use_raw_keys, keycode_flush);
}

void
skin_keyboard_free( SkinKeyboard*  keyboard )
{
    if (keyboard) {
        AFREE(keyboard);
    }
}