if(str)
                            delete [] str;
                        return false;
                    }
                    dayOfMonth = _wtol(token);
                    if(dayOfMonth == 0) {
                        if(str)
                            delete [] str;
                        return false;
                    }
                }
            }
            else if(recType == olRecursMonthNth) {
                if(wcschr(token, TEXT('#'))) {
                    pRecPat->put_RecurrenceType(recType);
                    token++;
                    occurences = _wtol(token);
                    if(occurences == 0)
                        pRecPat->put_NoEndDate(VARIANT_TRUE);
                    else
                        pRecPat->put_Occurrences(occurences);
                    pRecPat->put_Interval(interval);
                    pRecPat->put_Instance(weekOfMonth);
                    pRecPat->put_DayOfWeekMask(calculateDayOfWeek(days));
                }
                else if(token[8] == TEXT('T')) {
                    pRecPat->put_RecurrenceType(recType);
                    systemTimeToDouble(token, &endDate, NULL);
                    pRecPat->put_PatternEndDate(endDate);
                    pRecPat->put_Interval(interval);
                    pRecPat->put_Instance(weekOfMonth);
                    pRecPat->put_DayOfWeekMask(calculateDayOfWeek(days));
                }
                else if(isDayOfWeek(token)) {
                     wcscat(days, token);
                    wcscat(days, TEXT(" "));
                }
                else {
                    if(token[1] != TEXT('+') && token[1] != TEXT('-')) {
                        if(str)
                            delete [] str;
                        return false;
                    }
                    wchar_t sWeek[] = TEXT("\0\0");
                    sWeek[0] = token[0];
                    weekOfMonth = _wtol(sWeek);
                    if(token[1] == TEXT('-'))
                        weekOfMonth = 5 - weekOfMonth;
                    if(weekOfMonth > 5 || weekOfMonth < 1) {
                        if(str)
                            delete [] str;
                        return false;
                    }
                }
            }
            else if(recType == olRecursYearly) {
                //expected sequence will be YM1 month <end tag>
                if(wcschr(token, TEXT('#'))) {
                    pRecPat->put_RecurrenceType(recType);
                    token++;
                    occurences = _wtol(token);
                    if(occurences == 0)
                        pRecPat->put_NoEndDate(VARIANT_TRUE);
                    else
                        pRecPat->put_Occurrences(occurences);
                    pRecPat->put_Interval(interval);
                    pRecPat->put_MonthOfYear(monthOfYear);
                    pRecPat->put_DayOfMonth(dayOfMonth);
                }
                else if(token[8] == TEXT('T')) {
                    pRecPat->put_RecurrenceType(recType);
                    systemTimeToDouble(token, &endDate, NULL);
                    pRecPat->put_PatternEndDate(endDate);
                    pRecPat->put_Interval(interval);
                    pRecPat->put_MonthOfYear(monthOfYear);
                    pRecPat->put_DayOfMonth(dayOfMonth);
                }
                else {
                    if(wcscmp(mOfYear, TEXT(""))) {
                        if(str)
                            delete [] str;
                        return false;
                    }
                     wcscat(mOfYear, token);
                    monthOfYear = _wtol(mOfYear);
                    SYSTEMTIME st;
                    VariantTimeToSystemTime(startDate, &st);
                    dayOfMonth = st.wDay;
                }
            }
        }
    }

    return ret;
}
wchar_t* extractRrule(IRecurrencePattern* pRecPat) {

    wchar_t* recurrence = new wchar_t[100];
    wcscpy(recurrence, TEXT(""));
    DATE patStartDate;
    DATE patEndDate;
    wchar_t* datev = new wchar_t[30];

    long recType;
    pRecPat->get_RecurrenceType(&recType);
    pRecPat->get_PatternEndDate(& patEndDate);
    pRecPat->get_PatternStartDate(& patStartDate);

    VARIANT_BOOL noEnd;
    pRecPat->get_NoEndDate(&noEnd);

    long interval;
    pRecPat->get_Interval(&interval);

    long occurences;
    pRecPat->get_Occurrences(&occurences);

    long dayofweek;
    pRecPat->get_DayOfWeekMask(&dayofweek);

    long dayofmonth;
    pRecPat->get_DayOfMonth(& dayofmonth);

    //week of month
    long instance;
    pRecPat->get_Instance(&instance);

    long duration;
    pRecPat->get_Duration(&duration);

    long monthofyear;
    pRecPat->get_MonthOfYear(&monthofyear);

    switch(recType) {
            case olRecursDaily:
                if(noEnd == VARIANT_TRUE)
                    occurences = 0;  //occurences are -1 in this case but we use 0 to indicate event that does not end
                if(interval >0)
                        wsprintf(recurrence, TEXT("D%ld #%ld"), interval, occurences);
                else if (dayofweek > 0) {
                    wchar_t* days = extractDayOfWeek(dayofweek);
                    if (days) {
                        doubleToSystemTimeHourZero(datev, patEndDate, FALSE);
                        wsprintf(recurrence, TEXT("W1 %s %s #%ld"), days, datev, occurences);
                        delete [] days;
                    }
                }
                break;
            case olRecursWeekly:
                if (dayofweek > 0) {
                    wchar_t* days = extractDayOfWeek(dayofweek);
                    if (days) {
                        if(noEnd == VARIANT_TRUE)
                            wsprintf(recurrence, TEXT("W%ld %s #0"), interval, days);
                        else {
                            doubleToSystemTimeHourZero(datev, patEndDate, FALSE);
                            wsprintf(recurrence, TEXT("W%ld %s%s #%ld"), interval, days, datev, occurences);
                            delete [] days;
                        }
                    }
                }
                break;
            case olRecursMonthly:
                if(dayofmonth > 0)
                    if(noEnd == VARIANT_TRUE)
                            wsprintf(recurrence, TEXT("MD%ld %ld #0"), interval, dayofmonth);
                        else {
                            doubleToSystemTimeHourZero(datev, patEndDate, FALSE);
                            wsprintf(recurrence, TEXT("MD%ld %ld %s #%ld"), interval, dayofmonth, datev, occurences);
                        }
                break;
            case olRecursMonthNth:
                if(instance > 0 && dayofweek >0) {
                    wchar_t* days = extractDayOfWeek(dayofweek);
                    if(days)
                        if(noEnd == VARIANT_TRUE)
                                wsprintf(recurrence, TEXT("MP%ld %ld+ %s #0"), interval, instance, days);
                            else {
                                doubleToSystemTimeHourZero(datev, patEndDate, FALSE);
                                wsprintf(recurrence, TEXT("MP%ld %ld+ %s%s #%ld"), interval, instance, days, datev, occurences);
                            }
                    if(days)
                        delete [] days;
                }
                break;
            case olRecursYearly:
                if(dayofmonth > 0 && monthofyear > 0)
                    if(noEnd == VARIANT_TRUE)
                        wsprintf(recurrence, TEXT("YM1 %ld #0"), monthofyear);
                    else
                        wsprintf(recurrence, TEXT("YM1 %ld #%ld"), monthofyear, occurences);
                break;
            case olRecursYearNth:
                if(dayofweek > 0 && instance >0) {
                    wchar_t* days = extractDayOfWeek(dayofweek);
                    if(days)
                        if(noEnd == VARIANT_TRUE)
                            wsprintf(recurrence, TEXT("MP12 %ld+ %s #0"), instance, days);
                            else {
                                doubleToSystemTimeHourZero(datev, patEndDate, FALSE);
                                wsprintf(recurrence, TEXT("MP12 %ld+ %s%s #%ld"), instance, days, datev, occurences);
                            }
                    if(days)
                        delete [] days;
                }
                break;
        }

        delete [] datev; datev = NULL;

    return recurrence;
}

wchar_t* extractDayOfWeek(long l) {
    /*
        enum OlDaysOfWeek {
          olSunday    = 1,
          olMonday    = 2,
          olTuesday   = 4,
          olWednesday = 8,
          olThursday  = 16,
          olFriday    = 32,
          olSaturday  = 64,
        };

        */
    if (l<0 || l>128)
        return NULL;

    //SU MO TU WE TH FR SA

    wchar_t* ret = new wchar_t[21];
    wcscpy(ret, TEXT(""));

    if(l & olSunday)
        wcscat(ret, TEXT("SU "));
    if(l & olMonday)
        wcscat(ret, TEXT("MO "));
    if(l & olTuesday)
        wcscat(ret, TEXT("TU "));
    if(l & olWednesday)
        wcscat(ret, TEXT("WE "));
    if(l & olThursday)
        wcscat(ret, TEXT("TH "));
    if(l & olFriday)
        wcscat(ret, TEXT("FR "));
    if(l & olSaturday)
        wcscat(ret, TEXT("SA "));

    return ret;

}
long calculateDayOfWeek(wchar_t* in) {

    long ret = 0;

    wchar_t* index;
    index = NULL;
    index = wcsstr(in, TEXT("SU"));
    if(index)
        ret += olSunday;

    index = NULL;
    index = wcsstr(in, TEXT("MO"));
    if(index)
        ret += olMonday;

    index = NULL;
    index = wcsstr(in, TEXT("TU"));
    if(index)
        ret += olTuesday;

    index = NULL;
    index = wcsstr(in, TEXT("WE"));
    if(index)
        ret += olWednesday;

    index = NULL;
    index = wcsstr(in, TEXT("TH"));
    if(index)
        ret += olThursday;

    index = NULL;
    index = wcsstr(in, TEXT("FR"));
    if(index)
        ret += olFriday;

    index = NULL;
    index = wcsstr(in, TEXT("SA"));
    if(index)
        ret += olSaturday;

    return ret;
}

bool isDayOfWeek(wchar_t* string) {

    bool ret = false;
    wchar_t* weekDay[] = {TEXT("SU"), TEXT("MO"), TEXT("TU"), TEXT("WE"), TEXT("TH"), TEXT("FR"), TEXT("SA")};

    for(int i = 0; i < 7 ; i++)
        if(!wcscmp(string, weekDay[i]))
            return true;

    return ret;
}

long getWeekDay(DATE  dt) {
    long ret = 0;

    SYSTEMTIME st;
    VariantTimeToSystemTime(dt, &st);

    ret = (long)pow(2, st.wDayOfWeek);

    return ret;
}


BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
{
    DWORD pid = NULL;
    DWORD threadId = GetWindowThreadProcessId(hwnd, &pid);
    if (pid == (DWORD)lParam)
    {
        SendMessage(hwnd,WM_CLOSE, 0, 0);
    }

    return TRUE;
}


DWORD getProcessPid(const wchar_t *processName)
{
    PROCESSENTRY32 lppe;
    BOOL next = TRUE;
    HANDLE hProcess = 0;
    DWORD pid = 0;

    HANDLE hSnapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);

    if (hSnapshot == INVALID_HANDLE_VALUE) {
        // try to see in the registry the pid if there is any
        wchar_t value[128];
        getClientConfigurationInternal(NULL, PROPERTY_SPDM_PID, value, FALSE);
        if (wcscmp(value, TEXT("")) != 0 && wcscmp(value, TEXT("0")) != 0) {
            pid = atol(_wcc(value));
            DWORD code = 0;
            GetExitCodeProcess((HANDLE)pid, &code);
            if (code != STILL_ACTIVE) {
                pid = 0;
            }
        }
        return pid;
    }


    lppe.dwSize = sizeof( PROCESSENTRY32 );

    if (!Process32First(hSnapshot, &lppe))
        return 1;

    if (wcsstr(lppe.szExeFile, processName) != NULL) {
        pid = lppe.th32ProcessID;
    }

    do {
        next = Process32Next(hSnapshot, &lppe);

        if (!next)
            break;

        if (wcsstr(lppe.szExeFile, processName) != NULL ) {
            pid = lppe.th32ProcessID;
            break;
        }

    } while(next);

    if (hSnapshot)
        CloseToolhelp32Snapshot(hSnapshot);
    CloseHandle(hProcess);
    return pid;
}


DWORD stopProcess(DWORD pid)
{
    DWORD out = EnumWindows(&EnumWindowsProc, pid);

    return out;
}

DWORD stopProcessByName(const wchar_t *name)
{
    DWORD out = 0;
    DWORD pid = getProcessPid(name);
    out = stopProcess(pid);
    return out;
}

DWORD getMemoryAvailable() {
    MEMORYSTATUS mem;
    GlobalMemoryStatus(&mem);
    return mem.dwAvailPhys;

}

BOOL isMemoryAvailable(DWORD min) {

    if (min == 0)
        min = 2500000; // 2.5 Mb

    return getMemoryAvailable() > min ? TRUE : FALSE;

}

// Windows Mobile 5 has OS version = 5
// The previous is < 5 (2003 is 4)
//
BOOL isWindowsMobile5() {

    if (windowsMobileVersion == 0) {
        OSVERSIONINFO OSVersionInfo;
        OSVersionInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
        GetVersionEx(&OSVersionInfo);

        windowsMobileVersion = OSVersionInfo.dwMajorVersion;
        TCHAR szPlatform[512];
        SystemParametersInfo(SPI_GETPLATFORMTYPE, sizeof(szPlatform),szPlatform,0);
        if (wcsicmp(szPlatform, L"SmartPhone") == 0) {
            pocketPCDevice = 0;
        } else {
            pocketPCDevice = 1;
        }

    }

    if (windowsMobileVersion < 5)
        return false;
    else
        return true;
}

BOOL isPocketPC() {
    return pocketPCDevice == 1 ? TRUE : FALSE;
}


// converts newline characters from "\n" to "\r\n"
void convertNewlines(std::wstring &s)
{
    unsigned long pos = 0;
    while(pos != wstring::npos){
        pos = s.find(_T("\n"),pos);
        if(pos == wstring::npos)
            continue;
        if(pos == 0)
        {
            s.insert(0, _T("\r"));
            pos+=2;
        }
        else
        {
            if(s[pos-1] != '\r')
            {
                s.