/* -*- mode: C; c-basic-offset: 4; indent-tabs-mode: nil; -*- */

/* vim:set et sts=4: */

/* IBus - The Input Bus

 * Copyright (C) 2008-2010 Peng Huang <shawn.p.huang@gmail.com>

 * Copyright (C) 2018 Takao Fujiwara <takao.fujiwara1@gmail.com>

 * Copyright (C) 2008-2018 Red Hat, Inc.

 *

 * 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 Street, Fifth Floor, Boston, MA  02110-1301

 * USA

 */

#include <errno.h>

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <glib/gstdio.h>

#include "ibuskeys.h"

#include "ibuskeysyms.h"

#include "ibuskeymap.h"

typedef guint KEYMAP[256][7];

/* functions prototype */

static void         ibus_keymap_destroy         (IBusKeymap             *keymap);

static gboolean     ibus_keymap_load            (const gchar            *name,

                                                 KEYMAP                  keymap);

static GHashTable   *keymaps = NULL;

G_DEFINE_TYPE (IBusKeymap, ibus_keymap, IBUS_TYPE_OBJECT)

static void

ibus_keymap_class_init (IBusKeymapClass *class)

{

    IBusObjectClass *object_class = IBUS_OBJECT_CLASS (class);

    object_class->destroy = (IBusObjectDestroyFunc) ibus_keymap_destroy;

}

static void

ibus_keymap_init (IBusKeymap *keymap)

{

    gint i;

    keymap->name = NULL;

    for (i = 0; i < sizeof (keymap->keymap) / sizeof (guint); i++) {

        ((guint *)keymap->keymap)[i] = IBUS_KEY_VoidSymbol;

    }

}

static void

ibus_keymap_destroy (IBusKeymap *keymap)

{

    if (keymap->name != NULL) {

        g_free (keymap->name);

        keymap->name = NULL;

    }

    IBUS_OBJECT_CLASS (ibus_keymap_parent_class)->destroy ((IBusObject *)keymap);

}

#define SKIP_SPACE(p)   \

    while (*p == ' ') p++;

static gboolean

ibus_keymap_parse_line (gchar  *str,

                        KEYMAP  keymap)

{

    gchar *p1, *p2, ch;

    gint i;

    guint keycode;

    guint keysym;

    const struct {

        const gchar *prefix;

        const gint len;

    } prefix [] = {

        { "keycode ", sizeof ("keycode ") - 1 },

        { "shift keycode ", sizeof ("shift keycode ") - 1 },

        { "capslock keycode ", sizeof ("capslock keycode ") - 1 },

        { "shift capslock keycode ", sizeof ("shift capslock keycode ") - 1 },

        { "altgr keycode ", sizeof ("altgr keycode ") - 1},

        { "shift altgr keycode ", sizeof ("shift altgr keycode ") - 1},

        { "numlock keycode ", sizeof ("numlock keycode ") - 1},

    };

    p1 = str;

    SKIP_SPACE(p1);

    if (*p1 == '#')

        return TRUE;

    if (strncmp (p1, "include ", sizeof ("include ") - 1) == 0) {

        p1 += sizeof ("include ") - 1;

        for (p2 = p1; *p2 != '\n'; p2++);

        *p2 = '\0';

        return ibus_keymap_load (p1, keymap);

    }

    for (i = 0; i < sizeof (prefix) / sizeof (prefix[0]); i++) {

        if (strncmp (p1, prefix[i].prefix, prefix[i].len) == 0) {

            p1 += prefix[i].len;

            break;

        }

    }

    if (i >= sizeof (prefix) / sizeof (prefix[0]))

        return FALSE;

    keycode = (guint) strtoul (p1, &p2, 10);

    if (keycode == 0 && p1 == p2)

        return FALSE;

    if ((int) keycode < 0 || keycode > 255)

        return FALSE;

    p1 = p2;

    if (*p1++ != ' ')

        return FALSE;

    if (*p1++ != '=')

        return FALSE;

    if (*p1++ != ' ')

        return FALSE;

    for (p2 = p1; *p2 != '\n' && *p2 != ' '; p2++);

    *p2 = '\0'; p2++;

    keysym = ibus_keyval_from_name (p1);

    if (keysym == IBUS_KEY_VoidSymbol)

        return FALSE;

    /* Do not assign *p1 to g_ascii_isalpha() directly for the syntax check */

    if (i == 0 &&

        strncmp (p2, "addupper", sizeof ("addupper") - 1) == 0 &&

        (ch = *p1) && (ch >= 0) && g_ascii_isalpha (ch)) {

        gchar buf[] = "a";

        buf[0] = g_ascii_toupper(ch);

        keymap[keycode][0] = keymap[keycode][3] = keysym;

        keymap[keycode][1] = keymap[keycode][2] = ibus_keyval_from_name (buf);

    }

    else {

        keymap[keycode][i] = keysym;

    }

    return TRUE;

}

static gboolean

ibus_keymap_load (const gchar *name,

                  KEYMAP       keymap)

{

    const gchar *envstr;

    gchar *fname;

    FILE *pf;

    gchar buf[256];

    gint lineno;

    if ((envstr = g_getenv ("IBUS_KEYMAP_PATH")) != NULL)

        fname = g_build_filename (envstr, name, NULL);

    else

        fname = g_build_filename (IBUS_DATA_DIR, "keymaps", name, NULL);

    if (fname == NULL) {

        return FALSE;

    }

    pf = g_fopen (fname, "r");

    g_free (fname);

    if (pf == NULL) {

        return FALSE;

    }

    lineno = 0;

    while (fgets (buf, sizeof (buf), pf) != NULL) {

        lineno ++;

        if (!ibus_keymap_parse_line (buf, keymap)) {

            g_warning ("parse %s failed on %d line", name, lineno);

            lineno = -1;

            break;

        }

    }

    fclose (pf);

    if (lineno == -1) {

        return FALSE;

    }

    return TRUE;

}

void

ibus_keymap_fill (KEYMAP keymap)

{

    gint i;

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

        /* fill shift */

        if (keymap[i][1] == IBUS_KEY_VoidSymbol)

            keymap[i][1] = keymap[i][0];

        /* fill capslock */

        if (keymap[i][2] == IBUS_KEY_VoidSymbol)

            keymap[i][2] = keymap[i][0];

        /* fill shift capslock */

        if (keymap[i][3] == IBUS_KEY_VoidSymbol)

            keymap[i][3] = keymap[i][1];

        /* fill altgr */

        if (keymap[i][4] == IBUS_KEY_VoidSymbol)

            keymap[i][4] = keymap[i][0];

        /* fill shift altgr */

        if (keymap[i][5] == IBUS_KEY_VoidSymbol)

            keymap[i][5] = keymap[i][1];

    }

}

static void

_keymap_destroy_cb (IBusKeymap *keymap,

                    gpointer    user_data)

{

    g_hash_table_remove (keymaps, keymap->name);

    g_object_unref (keymap);

}

IBusKeymap *

ibus_keymap_new (const gchar *name)

{

    return ibus_keymap_get (name);

}

IBusKeymap *

ibus_keymap_get (const gchar *name)

{

    g_assert (name != NULL);

    IBusKeymap *keymap;

    if (keymaps == NULL) {

        keymaps = g_hash_table_new_full (g_str_hash,

                                         g_str_equal,

                                         (GDestroyNotify) g_free,

                                         (GDestroyNotify)  g_object_unref);

    }

    keymap = (IBusKeymap *) g_hash_table_lookup (keymaps, name);

    if (keymap == NULL) {

        keymap = g_object_new (IBUS_TYPE_KEYMAP, NULL);

        g_object_ref_sink (keymap);

        if (ibus_keymap_load (name, keymap->keymap)) {

            ibus_keymap_fill (keymap->keymap);

            keymap->name = g_strdup (name);

            g_hash_table_insert (keymaps, g_strdup (keymap->name), keymap);

            g_signal_connect (keymap, "destroy", G_CALLBACK (_keymap_destroy_cb), NULL);

        }

        else {

            g_object_unref (keymap);

            keymap = NULL;

        }

    }

    if (keymap != NULL)

        g_object_ref_sink (keymap);

    return keymap;

}

guint32

ibus_keymap_lookup_keysym (IBusKeymap *keymap,

                           guint16     keycode,

                           guint32     state)

{

    g_assert (IBUS_IS_KEYMAP (keymap));

    if (keycode < 256) {

        /* numlock */

        if ((state & IBUS_MOD2_MASK) &&

            (keymap->keymap[keycode][6] != IBUS_KEY_VoidSymbol)) {

            return keymap->keymap[keycode][6];

        }

        state &= IBUS_SHIFT_MASK | IBUS_LOCK_MASK | IBUS_MOD5_MASK;

        switch (state) {

        case 0:

            return keymap->keymap[keycode][0];

        case IBUS_SHIFT_MASK:

            return keymap->keymap[keycode][1];

        case IBUS_LOCK_MASK:

            return keymap->keymap[keycode][2];

        case IBUS_SHIFT_MASK | IBUS_LOCK_MASK:

            return keymap->keymap[keycode][3];

        case IBUS_MOD5_MASK:

        case IBUS_MOD5_MASK | IBUS_LOCK_MASK:

            return keymap->keymap[keycode][4];

        case IBUS_MOD5_MASK | IBUS_SHIFT_MASK:

        case IBUS_MOD5_MASK | IBUS_LOCK_MASK | IBUS_SHIFT_MASK:

            return keymap->keymap[keycode][5];

        default:

            break;

        }

    }

    return IBUS_KEY_VoidSymbol;

}