#include <windows.h>
#include "stringutils.h"
#include "debug.h"
#include "util/process.h"
#include <string>
#include <vector>

extern "C" {
DWORD GetEventData(HANDLE hEvent);
BOOL SetEventData(HANDLE hEvent, DWORD dwData);
}
class HTCKeypadNotifications : public process {
    HANDLE _hDev;
    boost::mutex _mtx;
    struct keymon {
        HANDLE evfrom;
        HANDLE evto;
        int id;
        int code;
    };
    typedef std::map<int,keymon> keymon_map;
    keymon_map _keys;
    HANDLE _evchange;
public:
    HTCKeypadNotifications() : _hDev(0)
    {
        _evchange= CreateEvent(0,0,0,0);

        opendev();
        start();
    }
    virtual ~HTCKeypadNotifications()
    {
        stop();
    }
    virtual void processstop()
    {
    }

    void opendev()
    {
        _hDev= CreateFile(_T("KBD1:"), GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, 
                        NULL, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
        if (_hDev==NULL || _hDev==INVALID_HANDLE_VALUE) {
            error("CreateFile-KBD1");
        }
    }

    bool kbd_ioctl(DWORD code, void *req, int reqlen, void *reply, int replen)
    {
        DWORD nReturned=0;
        if (!DeviceIoControl(_hDev, code, req, reqlen, reply, replen, &nReturned, NULL)) {
            error("kbd_ioctl 0x%x: err=%08lx", code, GetLastError());
            return false;
        }
        return true;
    }



// use this to find who is registered:
// pmemdump -n device.exe 0x1E3B658 0x60 -4 -x
bool kbd_register_notify(int id, int code, bool enable)
{
    struct kbd_register {
        DWORD dwNotifyID;
        DWORD byKeyCode;
        DWORD bIsEnable;
        DWORD dwUnknown;
    } request= { id, code, enable?1:0, 0 };
    
    if (enable)
        addevent(id, code);
//  else
//      delevent(id);
//
//  note: size must be either 4 or 0x20
    if (!kbd_ioctl(0xb2028, &request, 0x20, 0, 0))
        return false;

    return true;
}



virtual const char*name() { return "HTCKeypadNotifications"; }
virtual void service()
{
    boost::mutex::scoped_lock lock(_mtx);

    std::vector<HANDLE> events;
    std::vector<int>  ids;
    events.push_back(_evchange);
    for (keymon_map::iterator i= _keys.begin() ; i!=_keys.end() ; i++)
    {
        events.push_back((*i).second.evfrom);
        ids.push_back((*i).second.id);
    }
    // wait for getfrom event
    debugt("waiting for key\n");
    lock.unlock();
    DWORD rc= WaitForMultipleObjects(events.size(), &events.front(), FALSE, INFINITE);
    lock.lock();
    debugt(" -> wait : 0x%x, #ids=%d, #ev=%d\n", rc, ids.size(), events.size());
    if (rc==WAIT_OBJECT_0)
        return;
    if (rc>WAIT_OBJECT_0 && rc<WAIT_OBJECT_0+events.size()) {
        int id= ids[rc-WAIT_OBJECT_0-1];
        DWORD data= GetEventData(events[rc-WAIT_OBJECT_0]);
        ResetEvent(events[rc-WAIT_OBJECT_0]);
        debugt("got event for key %d %02x : %08lx\n", id, _keys[id].code, data);

        // set  sendback event
        SetEventData(_keys[id].evto, 0);
        SetEvent(_keys[id].evto);
    }
}

void addevent(int id, int code)
{
    keymon km;
    km.evfrom= CreateEvent(0, 0, 0, ToTString(stringformat("GetFromKeyEvent_%d", id)).c_str());
    km.evto= CreateEvent(0, 0, 0, ToTString(stringformat("SendBackToKeyEvent_%d", id)).c_str());
    km.id= id;
    km.code= code;

    boost::mutex::scoped_lock lock(_mtx);

    _keys.insert(keymon_map::value_type(id, km));

    SetEvent(_evchange);
}
void delevent(int id)
{
    boost::mutex::scoped_lock lock(_mtx);

    _keys.erase(id);

    SetEvent(_evchange);
}
};

class PhotonKeypadNotifications : public process {
    HANDLE _hDev;
    HANDLE _evfrom;
    HANDLE _evto;

    int _clientid;
    boost::mutex _mtx;
public:
    PhotonKeypadNotifications() : _hDev(0), _evfrom(0), _evto(0), _clientid(3141)
    {
        init();
        start();
    }
    virtual ~PhotonKeypadNotifications()
    {
        stop();
        CloseHandle(_evfrom);
        CloseHandle(_evto);
        CloseHandle(_hDev);
    }
    virtual void processstop()
    {
        kbd_register_notify(0x72, false);
        kbd_register_notify(0x73, false);

        SetEvent(_evfrom);
    }

    void opendev()
    {
        _hDev= CreateFile(_T("KBD1:"), GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, 
                        NULL, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM, NULL);
        if (_hDev==NULL || _hDev==INVALID_HANDLE_VALUE) {
            error("CreateFile-KBD1");
        }
    }

    bool kbd_ioctl(DWORD code, void *req, int reqlen, void *reply, int replen)
    {
        DWORD nReturned=0;
        if (!DeviceIoControl(_hDev, code, req, reqlen, reply, replen, &nReturned, NULL)) {
            error("kbd_ioctl 0x%x: err=%08lx", code, GetLastError());
            return false;
        }
        return true;
    }

void init()
{
    opendev();
    _evfrom= CreateEvent(0, 0, 0, ToTString(stringformat("GetFromKeyEvent_%d", _clientid)).c_str());
    _evto= CreateEvent(0, 0, 0, ToTString(stringformat("SendBackToKeyEvent_%d", _clientid)).c_str());

    kbd_register_notify(0x72, true);
    kbd_register_notify(0x73, true);
    kbd_register_notify(0x5b, true);
    kbd_register_notify(0xc3, true);
    kbd_register_notify(0x5c, true);
    kbd_register_notify(0xdf, true);


}
bool kbd_register_notify(int code, bool enable)
{
    struct kbd_register {
        DWORD dwNotifyID;
        DWORD byKeyCode;
        DWORD bIsEnable;
        DWORD dwUnknown;
    } request= { _clientid, code, enable?1:0, 0 };
    
//  note: size must be either 4 or 0x20
    if (!kbd_ioctl(0xb2028, &request, 0x20, 0, 0))
        return false;

    return true;
}


virtual const char*name() { return "PhotonKeypadNotifications"; }
virtual void service()
{
    DWORD rc= WaitForSingleObject(_evfrom, INFINITE);
    if (isterminating())
        return;
    if (rc!=WAIT_OBJECT_0) {
        logmsg("photon: wfso->0x%x\n", rc);
        return;
    }
    ResetEvent(_evfrom);
    DWORD data= GetEventData(_evfrom);
    SetEventData(_evto, 0);
    SetEvent(_evto);

    debugt("keypress flag=%x, code=%02x\n", data&15, data>>4);
}

};
int WINAPI WinMain( HINSTANCE hInstance,
                   HINSTANCE hPrevInstance,
                   LPTSTR    lpCmdLine,
                   int       nCmdShow)
{
    DebugSetLogfile("testphoton.log");
    debugt("photon: registering key events\n");
    PhotonKeypadNotifications  kn;
    debugt("monitoring\n");


    Sleep(20000);
    return 0;
}