#ifndef __RILFUNC_H__
#define __RILFUNC_H__
#include <windows.h>
#include "debug.h"
#include <ril.h>
#include "util/boostthread.h"
class rilfunc {
public:
    rilfunc() : _h(NULL), _ril(NULL) { }
    ~rilfunc() { close(); unload(); }


    bool load()
    {
        _h= LoadLibrary(_T("ril.dll"));
        if (_h==NULL) {
            error("loadlib(ril)");
            return false;
        }
        *(FARPROC*)&pRIL_Initialize= GetProcAddress(_h, _T("RIL_Initialize"));
        *(FARPROC*)&pRIL_Deinitialize= GetProcAddress(_h, _T("RIL_Deinitialize"));
        *(FARPROC*)&pRIL_SendMsg= GetProcAddress(_h, _T("RIL_SendMsg"));
        *(FARPROC*)&pRIL_Dial= GetProcAddress(_h, _T("RIL_Dial"));
        if (pRIL_Initialize==NULL) {
            error("load procs(ril)");
            return false;
        }
        return true;
    }
    void unload()
    {
        FreeLibrary(_h);
        _h= NULL;
    }
    bool open()
    {
        HRESULT hr= pRIL_Initialize(1, &rilfunc::rilresultcallback, &rilfunc::rilnotifycallback, 0, reinterpret_cast<DWORD>(this), &_ril);
        if (hr) {
            error(hr, "rilinit: %08lx");
            SetLastError(hr);
            return false;
        }
    }
    void close()
    {
        pRIL_Deinitialize(_ril);
        _ril= NULL;
    }
    void rilresult(DWORD dwCode, HRESULT hrCmdID, const void* lpData, DWORD cbData)
    {
        boost::mutex::scoped_lock lock(_mtx);
        if (hrCmdID==_hrdial) {
            debug("rilresult dial : %08lx\n", dwCode);
            _dialcode= dwCode;
            _hrdial= 0;
            lock.unlock();
            _cond.notify_one();
        }
        else if (hrCmdID==_hrsend) {
            debug("rilresult send : %08lx\n", dwCode);
            _sendcode= dwCode;
            _hrsend= 0;
            lock.unlock();
            _cond.notify_one();
        }

    }
    void rilnotify(DWORD dwCode, const void* lpData, DWORD cbData)
    {
    }

    bool dial(const std::string& number)
    {
        boost::mutex::scoped_lock lock(_mtx);
        HRESULT hr= pRIL_Dial(_ril, number.c_str(), RIL_CALLTYPE_VOICE, RIL_DIALOPT_NONE);
        if (hr<0) {
            error(hr, "ril dial");
            SetLastError(hr);
            return false;
        }
        _hrdial= hr;
        debug("ril dial: waiting for %08lx\n", hr);
        _dialcode= 0;
        while (_hrdial)
            _cond.wait(lock);

        debug("ril dial: result=%08lx\n", _dialcode);
        if (_dialcode) {
            SetLastError(_dialcode);
            return false;
        }
        return true;
    }
    bool send(const std::string& msgtext, const std::string& number)
    {
        boost::mutex::scoped_lock lock(_mtx);
        RILMESSAGE msg;
        msg.cbSize= sizeof(RILMESSAGE);
        msg.dwParams= RIL_PARAM_M_ALL_OUT_SUBMIT;
        msg.raSvcCtrAddress.cbSize= 0;  // use default.
        msg.dwType= RIL_MSGTYPE_OUT_SUBMIT;
        msg.dwFlags= RIL_MSGFLAG_NONE;

        msg.msgOutSubmit.raDestAddress.cbSize= sizeof(RILADDRESS);
        msg.msgOutSubmit.raDestAddress.dwParams= RIL_PARAM_A_ALL;
        msg.msgOutSubmit.raDestAddress.dwNumPlan= RIL_NUMPLAN_TELEPHONE;

        int numofs= 0;
        if (number[0]=='+') {
            msg.msgOutSubmit.raDestAddress.dwType = RIL_ADDRTYPE_INTERNATIONAL;
            numofs++;
        }
        else if (number[0]=='0' && number[1]=='0') {
            msg.msgOutSubmit.raDestAddress.dwType = RIL_ADDRTYPE_INTERNATIONAL;
            numofs+=2;
        }
        else {
            msg.msgOutSubmit.raDestAddress.dwType = RIL_ADDRTYPE_NATIONAL;
        }
        wcsncpy(msg.msgOutSubmit.raDestAddress.wszAddress, ToWString(number).c_str()+numofs, MAXLENGTH_ADDRESS);

        msg.msgOutSubmit.dwProtocolID = RIL_MSGPROTOCOL_SM_TYPE0;
        msg.msgOutSubmit.rmdDataCoding.cbSize= sizeof(RILMSGDCS);
        msg.msgOutSubmit.rmdDataCoding.dwParams= RIL_PARAM_MDCS_ALL;
        msg.msgOutSubmit.rmdDataCoding.dwType= RIL_DCSTYPE_GENERAL;
        msg.msgOutSubmit.rmdDataCoding.dwFlags= RIL_DCSFLAG_NONE;
        msg.msgOutSubmit.rmdDataCoding.dwMsgClass= RIL_DCSMSGCLASS_0;
        msg.msgOutSubmit.rmdDataCoding.dwAlphabet= RIL_DCSALPHABET_8BIT;
        msg.msgOutSubmit.rmdDataCoding.dwIndication= RIL_DCSINDICATION_OTHER;
        msg.msgOutSubmit.rmdDataCoding.dwLanguage= RIL_DCSLANG_UNKNOWN;
        msg.msgOutSubmit.dwVPFormat= RIL_MSGVP_NONE;
        memset(&msg.msgOutSubmit.stVP, 0, sizeof(SYSTEMTIME));
        msg.msgOutSubmit.cbHdrLength= 0;
        msg.msgOutSubmit.cchMsgLength= msgtext.size();
        memset(msg.msgOutSubmit.rgbHdr, 0, MAXLENGTH_HDR);
        memset(msg.msgOutSubmit.rgbMsg, 0, MAXLENGTH_MSG);
        memcpy(msg.msgOutSubmit.rgbMsg, msgtext.c_str(), msg.msgOutSubmit.cchMsgLength);

        HRESULT hr= pRIL_SendMsg(_ril, &msg, RIL_SENDOPT_NONE);
        if (hr<0) {
            error(hr, "ril send");
            SetLastError(hr);
            return false;
        }
        _hrsend= hr;
        debug("ril send: waiting for %08lx\n", hr);
        _sendcode= 0;
        while (_hrsend)
            _cond.wait(lock);

        debug("ril send: result=%08lx\n", _sendcode);
        if (_sendcode) {
            SetLastError(_sendcode);
            return false;
        }
        return true;
    }
private:
    HMODULE _h;
    HRESULT (*pRIL_Initialize)( DWORD dwIndex, RILRESULTCALLBACK pfnResult, RILNOTIFYCALLBACK pfnNotify, DWORD dwNotificationClasses, DWORD dwParam, HRIL* lphRil);
    HRESULT (*pRIL_Deinitialize)( HRIL hRil);
    HRESULT (*pRIL_Dial)( HRIL hRil, LPCSTR lpszAddress, DWORD dwType, DWORD dwOptions);
    HRESULT (*pRIL_SendMsg)( HRIL hRil, const RILMESSAGE* lpMessage, DWORD dwOptions);

    HRIL _ril;
    boost::condition _cond;
    boost::mutex _mtx;
    DWORD _dialcode;
    HRESULT _hrdial;
    DWORD _sendcode;
    HRESULT _hrsend;

    static void CALLBACK rilresultcallback(DWORD dwCode, HRESULT hrCmdID, const void* lpData, DWORD cbData, DWORD dwParam)
    {
        reinterpret_cast<rilfunc*>(dwParam)->rilresult(dwCode, hrCmdID, lpData, cbData);
    }
    static void CALLBACK rilnotifycallback(DWORD dwCode, const void* lpData, DWORD cbData, DWORD dwParam)
    {
        reinterpret_cast<rilfunc*>(dwParam)->rilnotify(dwCode, lpData, cbData);
    }
};
#endif