#ifndef __SMSFUNC_H__
#define __SMSFUNC_H__
#include <windows.h>
#include "debug.h"
#include <sms.h>
class smsfunc {
public:
    smsfunc() : _h(NULL) { }
    ~smsfunc() { FreeLibrary(_h); _h=NULL; }
    bool load()
    {
        _h= LoadLibrary(_T("sms.dll"));
        if (_h==NULL) {
            error("loadlib(sms.dll)");
            return false;
        }

        *(FARPROC*)&pSmsOpen= GetProcAddress(_h, _T("SmsOpen"));
        *(FARPROC*)&pSmsSendMessage= GetProcAddress(_h, _T("SmsSendMessage"));
        *(FARPROC*)&pSmsClose= GetProcAddress(_h, _T("SmsClose"));
        if (pSmsOpen==NULL || pSmsSendMessage==NULL || pSmsClose==NULL) {
            error("error loading sms funcs\n");
            return false;
        }
        return true;
    }
    bool send(const std::string& msgtext, const std::string& number)
    {
        SMS_HANDLE smshHandle = NULL;
        SMS_ADDRESS smsaSource;
        SMS_ADDRESS smsaDestination;
        HANDLE smsevent = NULL;
        TEXT_PROVIDER_SPECIFIC_DATA tpsd;
        SMS_MESSAGE_ID smsmidMessageID;

        memset( &smsaDestination, 0, sizeof( smsaDestination ) );
        memset( &tpsd, 0, sizeof( tpsd ) );

        HRESULT hr= pSmsOpen(SMS_MSGTYPE_TEXT, SMS_MODE_SEND, &smshHandle, NULL);
        if (!SUCCEEDED(hr))
        {
            error("SmsOpen(txt,send): %08lx", hr);
            return false;
        }

        bool bUseDefaultSMSC= true; //keep this var for now plz
        // Create the source address
        if(!bUseDefaultSMSC)
        {
            smsaSource.smsatAddressType = SMSAT_INTERNATIONAL;
            //_tcsncpy(smsaSource.ptsAddress, lpszSMSC, SMS_MAX_ADDRESS_LENGTH);
        }

        int numofs=0;
        if (number[0]=='+') {
            smsaDestination.smsatAddressType = SMSAT_INTERNATIONAL;
            numofs++;
        }
        else if (number[0]=='0' && number[1]=='0') {
            smsaDestination.smsatAddressType = SMSAT_INTERNATIONAL;
            numofs+=2;
        }
        else {
            smsaDestination.smsatAddressType = SMSAT_NATIONAL;
        }

        _tcsncpy(smsaDestination.ptsAddress, ToTString(number).c_str()+numofs, SMS_MAX_ADDRESS_LENGTH);

        // Set up provider specific data
        bool bSendConfirmation= false;
        memset(&tpsd, 0, sizeof(tpsd));
        tpsd.dwMessageOptions = bSendConfirmation ? PS_MESSAGE_OPTION_STATUSREPORT : PS_MESSAGE_OPTION_NONE;
        tpsd.psMessageClass = PS_MESSAGE_CLASS1;
        tpsd.psReplaceOption = PSRO_NONE;
        tpsd.dwHeaderDataSize = 0;
        tpsd.dwProtocolID = SMS_MSGPROTOCOL_UNKNOWN;

        std::Wstring wmsg= ToWString(msgtext);
        bool bRes= true;
        hr= pSmsSendMessage(smshHandle, ((bUseDefaultSMSC) ? NULL : &smsaSource), 
                    &smsaDestination, NULL, (const BYTE*)wmsg.c_str(), wmsg.size()*sizeof(std::Wstring::value_type),
                                     (PBYTE) &tpsd, sizeof(TEXT_PROVIDER_SPECIFIC_DATA), SMSDE_GSM, 
                                     SMS_OPTION_DELIVERY_NONE, &smsmidMessageID);
        if(!SUCCEEDED(hr))
        {
            error("SmsSendMessage failed: %08lx", hr); 
            bRes= false;
        }
        // clean up
        hr= pSmsClose(smshHandle);
        if(!SUCCEEDED(hr))
        {
            error("SmsClose: %08lx", hr);
        }
        return bRes;
    }
private:
    HMODULE _h;

    HRESULT (*pSmsOpen) ( const LPCTSTR ptsMessageProtocol, const DWORD dwMessageModes, SMS_HANDLE* const psmshHandle, HANDLE* const phMessageAvailableEvent);
    HRESULT (*pSmsSendMessage) ( const SMS_HANDLE smshHandle, const SMS_ADDRESS* const psmsaSMSCAddress, const SMS_ADDRESS* const psmsaDestinationAddress, const SYSTEMTIME* const pstValidityPeriod, __in_bcount(dwDataSize) const BYTE* const pbData, const DWORD dwDataSize, __in_bcount(dwProviderSpecificDataSize) const BYTE* const pbProviderSpecificData, const DWORD dwProviderSpecificDataSize, const SMS_DATA_ENCODING smsdeDataEncoding, const DWORD dwOptions, SMS_MESSAGE_ID* psmsmidMessageID);
    HRESULT (*pSmsClose) ( const SMS_HANDLE smshHandle);
};
#endif