/*

    SDL - Simple DirectMedia Layer

    Copyright (C) 1997-2010 Sam Lantinga

    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

    Sam Lantinga

    slouken@libsdl.org

*/

#include "SDL_config.h"

#include "SDL_win32video.h"

#include "../../events/SDL_keyboard_c.h"

#include "../../events/scancodes_win32.h"

#include <imm.h>

#include <oleauto.h>

static void IME_Init(SDL_VideoData *videodata, HWND hwnd);

static void IME_Enable(SDL_VideoData *videodata, HWND hwnd);

static void IME_Disable(SDL_VideoData *videodata, HWND hwnd);

static void IME_Quit(SDL_VideoData *videodata);

#ifndef MAPVK_VK_TO_VSC

#define MAPVK_VK_TO_VSC     0

#endif

#ifndef MAPVK_VSC_TO_VK

#define MAPVK_VSC_TO_VK     1

#endif

#ifndef MAPVK_VK_TO_CHAR

#define MAPVK_VK_TO_CHAR    2

#endif

/* Alphabetic scancodes for PC keyboards */

BYTE alpha_scancodes[26] = {

    30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38, 50, 49, 24,

    25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44

};

BYTE keypad_scancodes[10] = {

    82, 79, 80, 81, 75, 76, 77, 71, 72, 73

};

void

WIN_InitKeyboard(_THIS)

{

    SDL_VideoData *data = (SDL_VideoData *) _this->driverdata;

    int i;

    /* Make sure the alpha scancodes are correct.  T isn't usually remapped */

    if (MapVirtualKey('T', MAPVK_VK_TO_VSC) != alpha_scancodes['T' - 'A']) {

#if 0

        printf

            ("Fixing alpha scancode map, assuming US QWERTY layout!\nPlease send the following 26 lines of output to the SDL mailing list <sdl@libsdl.org>, including a description of your keyboard hardware.\n");

#endif

        for (i = 0; i < SDL_arraysize(alpha_scancodes); ++i) {

            alpha_scancodes[i] = MapVirtualKey('A' + i, MAPVK_VK_TO_VSC);

#if 0

            printf("%d = %d\n", i, alpha_scancodes[i]);

#endif

        }

    }

    if (MapVirtualKey(VK_NUMPAD0, MAPVK_VK_TO_VSC) != keypad_scancodes[0]) {

#if 0

        printf

            ("Fixing keypad scancode map!\nPlease send the following 10 lines of output to the SDL mailing list <sdl@libsdl.org>, including a description of your keyboard hardware.\n");

#endif

        for (i = 0; i < SDL_arraysize(keypad_scancodes); ++i) {

            keypad_scancodes[i] =

                MapVirtualKey(VK_NUMPAD0 + i, MAPVK_VK_TO_VSC);

#if 0

            printf("%d = %d\n", i, keypad_scancodes[i]);

#endif

        }

    }

    data->key_layout = win32_scancode_table;

    data->ime_com_initialized = SDL_FALSE;

    data->ime_threadmgr = 0;

    data->ime_initialized = SDL_FALSE;

    data->ime_enabled = SDL_FALSE;

    data->ime_available = SDL_FALSE;

    data->ime_hwnd_main = 0;

    data->ime_hwnd_current = 0;

    data->ime_himc = 0;

    data->ime_composition[0] = 0;

    data->ime_readingstring[0] = 0;

    data->ime_cursor = 0;

    data->ime_hkl = 0;

    data->ime_himm32 = 0;

    data->GetReadingString = 0;

    data->ShowReadingWindow = 0;

    data->ImmLockIMC = 0;

    data->ImmUnlockIMC = 0;

    data->ImmLockIMCC = 0;

    data->ImmUnlockIMCC = 0;

    data->ime_uiless = SDL_FALSE;

    data->ime_threadmgrex = 0;

    data->ime_uielemsinkcookie = TF_INVALID_COOKIE;

    data->ime_alpnsinkcookie = TF_INVALID_COOKIE;

    data->ime_openmodesinkcookie = TF_INVALID_COOKIE;

    data->ime_convmodesinkcookie = TF_INVALID_COOKIE;

    data->ime_uielemsink = 0;

    data->ime_ippasink = 0;

    WIN_UpdateKeymap();

    SDL_SetScancodeName(SDL_SCANCODE_APPLICATION, "Menu");

    SDL_SetScancodeName(SDL_SCANCODE_LGUI, "Left Windows");

    SDL_SetScancodeName(SDL_SCANCODE_RGUI, "Right Windows");

}

void

WIN_UpdateKeymap()

{

    int i;

    SDL_scancode scancode;

    SDLKey keymap[SDL_NUM_SCANCODES];

    SDL_GetDefaultKeymap(keymap);

    for (i = 0; i < SDL_arraysize(win32_scancode_table); i++) {

        /* Make sure this scancode is a valid character scancode */

        scancode = win32_scancode_table[i];

        if (scancode == SDL_SCANCODE_UNKNOWN || keymap[scancode] >= 127) {

            continue;

        }

        /* Alphabetic keys are handled specially, since Windows remaps them */

        if (i >= 'A' && i <= 'Z') {

            BYTE vsc = alpha_scancodes[i - 'A'];

            keymap[scancode] = MapVirtualKey(vsc, MAPVK_VSC_TO_VK) + 0x20;

        } else {

            keymap[scancode] = (MapVirtualKey(i, MAPVK_VK_TO_CHAR) & 0x7FFF);

        }

    }

    SDL_SetKeymap(0, keymap, SDL_NUM_SCANCODES);

}

void

WIN_QuitKeyboard(_THIS)

{

    IME_Quit((SDL_VideoData *)_this->driverdata);

}

void

WIN_StartTextInput(_THIS)

{

    SDL_Window *window = SDL_GetKeyboardFocus();

    if (window) {

        HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

        SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;

        IME_Init(videodata, hwnd);

        IME_Enable(videodata, hwnd);

    }

}

void

WIN_StopTextInput(_THIS)

{

    SDL_Window *window = SDL_GetKeyboardFocus();

    if (window) {

        HWND hwnd = ((SDL_WindowData *) window->driverdata)->hwnd;

        SDL_VideoData *videodata = (SDL_VideoData *)_this->driverdata;

        IME_Init(videodata, hwnd);

        IME_Disable(videodata, hwnd);

    }

}

void

WIN_SetTextInputRect(_THIS, SDL_Rect *rect)

{

}

#define LANG_CHT MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_TRADITIONAL)

#define LANG_CHS MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED)

#define MAKEIMEVERSION(major,minor) ((DWORD) (((BYTE)(major) << 24) | ((BYTE)(minor) << 16) ))

#define IMEID_VER(id) ((id) & 0xffff0000)

#define IMEID_LANG(id) ((id) & 0x0000ffff)

#define CHT_HKL_DAYI            ((HKL)0xE0060404)

#define CHT_HKL_NEW_PHONETIC    ((HKL)0xE0080404)

#define CHT_HKL_NEW_CHANG_JIE   ((HKL)0xE0090404)

#define CHT_HKL_NEW_QUICK       ((HKL)0xE00A0404)

#define CHT_HKL_HK_CANTONESE    ((HKL)0xE00B0404)

#define CHT_IMEFILENAME1        "TINTLGNT.IME"

#define CHT_IMEFILENAME2        "CINTLGNT.IME"

#define CHT_IMEFILENAME3        "MSTCIPHA.IME"

#define IMEID_CHT_VER42         (LANG_CHT | MAKEIMEVERSION(4, 2))

#define IMEID_CHT_VER43         (LANG_CHT | MAKEIMEVERSION(4, 3))

#define IMEID_CHT_VER44         (LANG_CHT | MAKEIMEVERSION(4, 4))

#define IMEID_CHT_VER50         (LANG_CHT | MAKEIMEVERSION(5, 0))

#define IMEID_CHT_VER51         (LANG_CHT | MAKEIMEVERSION(5, 1))

#define IMEID_CHT_VER52         (LANG_CHT | MAKEIMEVERSION(5, 2))

#define IMEID_CHT_VER60         (LANG_CHT | MAKEIMEVERSION(6, 0))

#define IMEID_CHT_VER_VISTA     (LANG_CHT | MAKEIMEVERSION(7, 0))

#define CHS_HKL                 ((HKL)0xE00E0804)

#define CHS_IMEFILENAME1        "PINTLGNT.IME"

#define CHS_IMEFILENAME2        "MSSCIPYA.IME"

#define IMEID_CHS_VER41         (LANG_CHS | MAKEIMEVERSION(4, 1))

#define IMEID_CHS_VER42         (LANG_CHS | MAKEIMEVERSION(4, 2))

#define IMEID_CHS_VER53         (LANG_CHS | MAKEIMEVERSION(5, 3))

#define LANG() LOWORD((videodata->ime_hkl))

#define PRIMLANG() ((WORD)PRIMARYLANGID(LANG()))

#define SUBLANG() SUBLANGID(LANG())

static void IME_UpdateInputLocale(SDL_VideoData *videodata);

static void IME_ClearComposition(SDL_VideoData *videodata);

static void IME_SetWindow(SDL_VideoData* videodata, HWND hwnd);

static void IME_SetupAPI(SDL_VideoData *videodata);

static DWORD IME_GetId(SDL_VideoData *videodata, UINT uIndex);

static void IME_SendEditingEvent(SDL_VideoData *videodata);

#define SDL_IsEqualIID(riid1, riid2) SDL_IsEqualGUID(riid1, riid2)

#define SDL_IsEqualGUID(rguid1, rguid2) (!SDL_memcmp(rguid1, rguid2, sizeof(GUID)))

static SDL_bool UILess_SetupSinks(SDL_VideoData *videodata);

static void UILess_ReleaseSinks(SDL_VideoData *videodata);

static void UILess_EnableUIUpdates(SDL_VideoData *videodata);

static void UILess_DisableUIUpdates(SDL_VideoData *videodata);

static void

IME_Init(SDL_VideoData *videodata, HWND hwnd)

{

    if (videodata->ime_initialized)

        return;

    videodata->ime_hwnd_main = hwnd;

    if (SUCCEEDED(CoInitializeEx(NULL, COINIT_APARTMENTTHREADED))) {

        videodata->ime_com_initialized = SDL_TRUE;

    }

    videodata->ime_initialized = SDL_TRUE;

    videodata->ime_himm32 = LoadLibraryA("imm32.dll");

    if (!videodata->ime_himm32) {

        videodata->ime_available = SDL_FALSE;

        return;

    }

    videodata->ImmLockIMC = (LPINPUTCONTEXT2 (WINAPI *)(HIMC))GetProcAddress(videodata->ime_himm32, "ImmLockIMC");

    videodata->ImmUnlockIMC = (BOOL (WINAPI *)(HIMC))GetProcAddress(videodata->ime_himm32, "ImmUnlockIMC");

    videodata->ImmLockIMCC = (LPVOID (WINAPI *)(HIMCC))GetProcAddress(videodata->ime_himm32, "ImmLockIMCC");

    videodata->ImmUnlockIMCC = (BOOL (WINAPI *)(HIMCC))GetProcAddress(videodata->ime_himm32, "ImmUnlockIMCC");

    IME_SetWindow(videodata, hwnd);

    videodata->ime_himc = ImmGetContext(hwnd);

    ImmReleaseContext(hwnd, videodata->ime_himc);

    if (!videodata->ime_himc) {

        videodata->ime_available = SDL_FALSE;

        IME_Disable(videodata, hwnd);

        return;

    }

    videodata->ime_available = SDL_TRUE;

    IME_UpdateInputLocale(videodata);

    IME_SetupAPI(videodata);

    videodata->ime_uiless = UILess_SetupSinks(videodata);

    IME_UpdateInputLocale(videodata);

    IME_Disable(videodata, hwnd);

}

static void

IME_Enable(SDL_VideoData *videodata, HWND hwnd)

{

    if (!videodata->ime_initialized || !videodata->ime_hwnd_current)

        return;

    if (!videodata->ime_available) {

        IME_Disable(videodata, hwnd);

        return;

    }

    if (videodata->ime_hwnd_current == videodata->ime_hwnd_main)

        ImmAssociateContext(videodata->ime_hwnd_current, videodata->ime_himc);

    videodata->ime_enabled = SDL_TRUE;

    IME_UpdateInputLocale(videodata);

    UILess_EnableUIUpdates(videodata);

}

static void

IME_Disable(SDL_VideoData *videodata, HWND hwnd)

{

    if (!videodata->ime_initialized || !videodata->ime_hwnd_current)

        return;

    IME_ClearComposition(videodata);

    if (videodata->ime_hwnd_current == videodata->ime_hwnd_main)

    videodata->ime_enabled = SDL_FALSE;

    UILess_DisableUIUpdates(videodata);

}

static void

IME_Quit(SDL_VideoData *videodata)

{

    if (!videodata->ime_initialized)

        return;

    UILess_ReleaseSinks(videodata);

    if (videodata->ime_hwnd_main)

        ImmAssociateContext(videodata->ime_hwnd_main, videodata->ime_himc);

    videodata->ime_hwnd_main = 0;

    videodata->ime_himc = 0;

    if (videodata->ime_himm32) {

        FreeLibrary(videodata->ime_himm32);

        videodata->ime_himm32 = 0;

    }

    if (videodata->ime_threadmgr) {

        videodata->ime_threadmgr->lpVtbl->Release(videodata->ime_threadmgr);

        videodata->ime_threadmgr = 0;

    }

    if (videodata->ime_com_initialized) {

        CoUninitialize();

        videodata->ime_com_initialized = SDL_FALSE;

    }

    videodata->ime_initialized = SDL_FALSE;

}

static void

IME_GetReadingString(SDL_VideoData *videodata, HWND hwnd)

{

    DWORD id = 0;

    HIMC himc = 0;

    WCHAR buffer[16];

    WCHAR *s = buffer;

    DWORD len = 0;

    BOOL vertical = FALSE;

    UINT maxuilen = 0;

    static OSVERSIONINFOA osversion = {0};

    if (videodata->ime_uiless)

        return;

    videodata->ime_readingstring[0] = 0;

    if (!osversion.dwOSVersionInfoSize) {

        osversion.dwOSVersionInfoSize = sizeof(osversion);

        GetVersionExA(&osversion);

    }

    id = IME_GetId(videodata, 0);

    if (!id)

        return;

    himc = ImmGetContext(hwnd);

    if (!himc)

        return;

    if (videodata->GetReadingString) {

        len = videodata->GetReadingString(himc, 0, 0, &err, &vertical, &maxuilen);

        if (len) {

            if (len > SDL_arraysize(buffer))

                len = SDL_arraysize(buffer);

            len = videodata->GetReadingString(himc, len, s, &err, &vertical, &maxuilen);

        }

        SDL_wcslcpy(videodata->ime_readingstring, s, len);

    }

    else {

        LPINPUTCONTEXT2 lpimc = videodata->ImmLockIMC(himc);

        LPBYTE p = 0;

        s = 0;

        switch (id)

        {

        case IMEID_CHT_VER42:

        case IMEID_CHT_VER43:

        case IMEID_CHT_VER44:

            p = *(LPBYTE *)((LPBYTE)videodata->ImmLockIMCC(lpimc->hPrivate) + 24);

            if (!p)

                break;

            len = *(DWORD *)(p + 7*4 + 32*4);

            s = (WCHAR *)(p + 56);

            break;

        case IMEID_CHT_VER51:

        case IMEID_CHT_VER52:

        case IMEID_CHS_VER53:

            p = *(LPBYTE *)((LPBYTE)videodata->ImmLockIMCC(lpimc->hPrivate) + 4);

            if (!p)

                break;

            p = *(LPBYTE *)((LPBYTE)p + 1*4 + 5*4);

            if (!p)

                break;

            len = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16*2);

            s = (WCHAR *)(p + 1*4 + (16*2+2*4) + 5*4);

            break;

        case IMEID_CHS_VER41:

            {

                int offset = (IME_GetId(videodata, 1) >= 0x00000002) ? 8 : 7;

                p = *(LPBYTE *)((LPBYTE)videodata->ImmLockIMCC(lpimc->hPrivate) + offset * 4);

                if (!p)

                    break;

                len = *(DWORD *)(p + 7*4 + 16*2*4);

                s = (WCHAR *)(p + 6*4 + 16*2*1);

            }

            break;

        case IMEID_CHS_VER42:

            if (osversion.dwPlatformId != VER_PLATFORM_WIN32_NT)

                break;

            p = *(LPBYTE *)((LPBYTE)videodata->ImmLockIMCC(lpimc->hPrivate) + 1*4 + 1*4 + 6*4);

            if (!p)

                break;

            len = *(DWORD *)(p + 1*4 + (16*2+2*4) + 5*4 + 16*2);

            s = (WCHAR *)(p + 1*4 + (16*2+2*4) + 5*4);

            break;

        }

        if (s)

            SDL_wcslcpy(videodata->ime_readingstring, s, len + 1);

        videodata->ImmUnlockIMCC(lpimc->hPrivate);

        videodata->ImmUnlockIMC(himc);

    }

    ImmReleaseContext(hwnd, himc);

    IME_SendEditingEvent(videodata);

}

static void

IME_InputLangChanged(SDL_VideoData *videodata)

{

    UINT lang = PRIMLANG();

    HWND hwndime = 0;

    IME_UpdateInputLocale(videodata);

    IME_SetupAPI(videodata);

    if (lang != PRIMLANG()) {

        IME_ClearComposition(videodata);

    }

    hwndime = ImmGetDefaultIMEWnd(videodata->ime_hwnd_current);

    if (hwndime) {

        SendMessageA(hwndime, WM_IME_CONTROL, IMC_OPENSTATUSWINDOW, 0);

        SendMessageA(hwndime, WM_IME_CONTROL, IMC_CLOSESTATUSWINDOW, 0);

    }

}

static DWORD

IME_GetId(SDL_VideoData *videodata, UINT uIndex)

{

    static HKL hklprev = 0;

    static DWORD dwRet[2] = {0};

    DWORD dwVerSize = 0;

    DWORD dwVerHandle = 0;

    LPVOID lpVerBuffer = 0;

    LPVOID lpVerData = 0;

    UINT cbVerData = 0;

    char szTemp[256];

    HKL hkl = 0;

    DWORD dwLang = 0;

    if (uIndex >= sizeof(dwRet) / sizeof(dwRet[0]))

        return 0;

    hkl = videodata->ime_hkl;

    if (hklprev == hkl)

        return dwRet[uIndex];

    hklprev = hkl;

    dwLang = ((DWORD)hkl & 0xffff);