//-----------------------------------------------------------------------------
//  This exe runs in the background and wakes up every so often to do it's work.
//  When it wakes up it checks to see how much time the user has left on their
//  free ISP subscription.  At certain intervals it will tell the user time
//  is running out and will give the user the chance to signup for rea.
//-----------------------------------------------------------------------------
#define  STRICT
#include <windows.h>
#include <stdlib.h>
#include <stdarg.h>
#include <crtdbg.h>
#include <winbase.h>
#include <ras.h>
#include <time.h>
#include "IcwRmind.h"
#include "resource.h"
#include "RegData.h"


//-----------------------------------------------------------------------------
//  Forward Declarations
//-----------------------------------------------------------------------------
BOOL            InitializeApp (void);
BOOL            CheckForRASConnection();
void            CheckForSignupAttempt();
int             GetISPTrialDaysLeft();
void            ShutDownForGood();
void            PerformTheSignup();
void            CenterTheWindow(HWND hWnd);
DWORD           GetTickDelta();
void            AttemptTrialOverSignup();


//-----------------------------------------------------------------------------
//  Defines
//-----------------------------------------------------------------------------
#define TIMER_DIALOG_STAYUP         319     // Wake up timer to do work.
#define TIMER_RUNONCE_SETUP         320
#define TIME_RUNONCE_INTERVAL       30000   // 30 seconds
#define MAXRASCONNS                 8
#define MAX_DIALOGTEXT              512
#define MAX_ATTEMPTCOUNTER          20
#define LONG_WAKEUP_INTERVAL        3600000 // 1 hour

//-----------------------------------------------------------------------------
//  Global Handles and other defines
//-----------------------------------------------------------------------------
HINSTANCE   g_hModule;              // Process Instance handle
HWND        g_hwndMain;             // Main window handle
bool        g_bDoNotRemindAgain;    // Used by signup dialog.
time_t      g_timeAppStartUp;
DWORD       g_dwTickAppStartUp;
int         g_nAttemptCounter;
DWORD       g_dwMasterWakeupInterval;
bool        g_bDialogExpiredMode = false;
static const TCHAR* g_szTrialStartEvent = TEXT("_319IcwTrialStart913_");
static const TCHAR* g_szRunOnceEvent = TEXT("_319IcwRunOnce913_");


//-----------------------------------------------------------------------------
//  WinMain
//-----------------------------------------------------------------------------
int WINAPI WinMainT(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPTSTR lpCmdLine,
                    int nCmdShow)
{
    MSG msg;
    HANDLE hEventTrialStart = NULL;
    HANDLE hEventRunOnce = NULL;
    DWORD dwRetCode;
    bool bStartedViaWizard = false;

        // If there is a command line then see who started us.
    if (lstrlen(lpCmdLine))
    {
            // The RunOnce registry stuff will freeze up until we return.  Hence
            // the RunOnce setting in the registry must have some value for the
            // command line.  If we see any data we will spawn a second instance
            // of ourselves and exit this instance.
        if (0 == lstrcmpi(TEXT("-R"), lpCmdLine))
        {
            LPTSTR lpszFileName = new TCHAR[_MAX_PATH + 1];

            if (GetModuleFileName(GetModuleHandle(NULL), lpszFileName, _MAX_PATH + 1))
            {
                STARTUPINFO          sui;
                PROCESS_INFORMATION  pi;
                
                sui.cb               = sizeof (STARTUPINFO);
                sui.lpReserved       = 0;
                sui.lpDesktop        = NULL;
                sui.lpTitle          = NULL;
                sui.dwX              = 0;
                sui.dwY              = 0;
                sui.dwXSize          = 0;
                sui.dwYSize          = 0;
                sui.dwXCountChars    = 0;
                sui.dwYCountChars    = 0;
                sui.dwFillAttribute  = 0;
                sui.dwFlags          = 0;
                sui.wShowWindow      = 0;
                sui.cbReserved2      = 0;
                sui.lpReserved2      = 0;

                BOOL ret = CreateProcess (lpszFileName, NULL, NULL, NULL,
                        FALSE, DETACHED_PROCESS,
                        NULL, NULL, &sui, &pi );
                _ASSERT(ret);

                CloseHandle(pi.hProcess);
                CloseHandle(pi.hThread);
            }

            delete [] lpszFileName;
            return 0;
        }
            // See if this is the start of a new trial.
        else if (0 == lstrcmpi(TEXT("-T"), lpCmdLine))
        {
            bStartedViaWizard = true;
            RemoveTrialConvertedFlag();
        }
    }

        // If we got this far let's create the named event and find out if we
        // are the first instance to run or if there is another instance already
        // running.
    hEventTrialStart = CreateEvent(NULL, FALSE, FALSE, g_szTrialStartEvent);
    if (hEventTrialStart)
    {
            // See if the named event already exists.  If it does then another 
            // instance of the IcwRmind exe is already running.  Signal the event
            // and exit.
        if (ERROR_ALREADY_EXISTS == GetLastError())
        {
                // If we were started via the wizard tell the other instance
                // to reset it's trial start data.
            if (bStartedViaWizard)
            {
                SetEvent(hEventTrialStart);
            }
                // Otherwise assume that RunOnce started us again.  In this case
                // Open the existing RunOnce named event and signal it.  This
                // tells the running instance to place us back into RunOnce key.
            else
            {
                hEventRunOnce = OpenEvent(EVENT_MODIFY_STATE, false, g_szRunOnceEvent);
                if (hEventRunOnce)
                {
                    SetEvent(hEventRunOnce);
                    CloseHandle(hEventRunOnce);
                }
            }

            CloseHandle(hEventTrialStart);
            return 0;
        }
    }
    else
    {
        _ASSERT(FALSE);
        return 0;
    }

    hEventRunOnce = CreateEvent(NULL, FALSE, FALSE, g_szRunOnceEvent);
    if (!hEventRunOnce)
    {
        CloseHandle(hEventTrialStart);
        return 0;
    }

        // If this flag is true and we got this far then we are the first
        // instance to run after being started by the wizard.  Let's clear
        // registry data just in case there is old stuff in there.
    if (bStartedViaWizard)
    {
        ResetCachedData();
    }

        // Check the registry and see if the user has successfully signed up.
        // If so then shut down for good.
    if (IsSignupSuccessful())
    {
        ShutDownForGood();
        CloseHandle(hEventTrialStart);
        CloseHandle(hEventRunOnce);
        return 0;
    }

    g_hModule = hInstance;
    ClearCachedData();  // This initializes cache data to zero.
    g_nAttemptCounter = 0;

    time(&g_timeAppStartUp);
    g_dwTickAppStartUp = GetTickCount();

        // If the connectoid entry name does not exist in the registry then
        // we will shut down for good.
    const TCHAR* pcszConnectName = GetISPConnectionName();
    if (NULL == pcszConnectName || 0 == lstrlen(pcszConnectName))
    {
        ShutDownForGood();
        CloseHandle(hEventTrialStart);
        CloseHandle(hEventRunOnce);
        return 0;
    }

        // If we cannot get or create the start time then something is really
        // bad.  We will stop never to be run again.
    if (0 == GetTrialStartDate())
    {
        ShutDownForGood();
        CloseHandle(hEventTrialStart);
        CloseHandle(hEventRunOnce);
        return 0;
    }

        // Initialize and create the window class and window.
    if (!InitializeApp())
    {
        _ASSERT(FALSE);
        CloseHandle(hEventTrialStart);
        CloseHandle(hEventRunOnce);
        return 0;
    }

        // Testers can make the application visible via the registry.
    if (IsApplicationVisible())
    {
        ShowWindow(g_hwndMain, nCmdShow);
    }

        // Let's initialize the wake up interval.  If we are in the first half
        // of the trial then we don't want to wake up very often.  As we get
        // closer to the half way point we want to wake up more ofter to do
        // our polling.
    if (GetISPTrialDaysLeft() > (int)((GetISPTrialDays() / 2) + 1))
    {
            // Don't start polling more often until the day before the
            // half way point.
        g_dwMasterWakeupInterval = LONG_WAKEUP_INTERVAL;
    }
    else
    {
            // Use this method because the wake up interval may be in the
            // registry for testing.
        g_dwMasterWakeupInterval = GetWakeupInterval();
    }

        // Set a timer to re-setup the run once data in the registry.
        // If we do this too soon the intial run once startup will create
        // us multiple times.
    SetTimer(g_hwndMain, TIMER_RUNONCE_SETUP, TIME_RUNONCE_INTERVAL, NULL);

    HANDLE hEventList[2];
    hEventList[0] = hEventTrialStart;
    hEventList[1] = hEventRunOnce;

    while (TRUE)
    {
            // We will wait on window messages and also the named event.
        dwRetCode = MsgWaitForMultipleObjects(2, &hEventList[0], FALSE, g_dwMasterWakeupInterval, QS_ALLINPUT);

            // Determine why we came out of MsgWaitForMultipleObjects().  If
            // we timed out then let's do some TrialWatcher work.  Otherwise
            // process the message that woke us up.
        if (WAIT_TIMEOUT == dwRetCode)
        {
                // If we are still in the long wake up interval do a quick check
                // to see if we should switch to the shorter interval.
            if (LONG_WAKEUP_INTERVAL == g_dwMasterWakeupInterval)
            {
                if (GetISPTrialDaysLeft() <= (int)((GetISPTrialDays() / 2) + 1))
                {
                    g_dwMasterWakeupInterval = GetWakeupInterval();
                }
            }

            CheckForSignupAttempt();
        }
        else if (WAIT_OBJECT_0 == dwRetCode)
        {
                // If we get in here then the named event was signaled meaning
                // a second instance started up.  This means the user has 
                // signed up for a new trial with somebody else.  Clear
                // all persistant registry data.
            ResetCachedData();

                // Reset the trial start date.  If this fails then something
                // is really messed up in the registry.
            if (0 == GetTrialStartDate())
            {
                ShutDownForGood();
                break;
            }
        }
        else if (WAIT_OBJECT_0 + 1== dwRetCode)
        {
                // Signaled by the RunOnce event.  We must reset the timer to
                // place ourselves back into RunOnce.
            KillTimer(g_hwndMain, TIMER_RUNONCE_SETUP); // In case it is already running.
            SetTimer(g_hwndMain, TIMER_RUNONCE_SETUP, TIME_RUNONCE_INTERVAL, NULL);
        }
        else if (WAIT_OBJECT_0 + 2 == dwRetCode)
        {
                // 0 is returned if no message retrieved.
            if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
            {
                if (WM_QUIT == msg.message)
                {
                    break;
                }
                else
                {
                    TranslateMessage(&msg);
                    DispatchMessage(&msg);
                }
            }
        }
    }

    CloseHandle(hEventTrialStart);
    CloseHandle(hEventRunOnce);
    return 1;

    UNREFERENCED_PARAMETER(lpCmdLine);
    UNREFERENCED_PARAMETER(hPrevInstance);
}


//-----------------------------------------------------------------------------
//  InitializeApp
//-----------------------------------------------------------------------------
BOOL InitializeApp(void)
{
    WNDCLASS wc;

    wc.style            = 0;
    wc.lpfnWndProc      = MainWndProc;
    wc.cbClsExtra       = 0;
    wc.cbWndExtra       = 0;
    wc.hInstance        = g_hModule;
    wc.hIcon            = NULL;
    wc.hCursor          = LoadCursor(g_hModule, IDC_ARROW);
    wc.hbrBackground    = (HBRUSH)(COLOR_APPWORKSPACE);
    wc.lpszMenuName     = NULL;
    wc.lpszClassName    = TEXT("IcwRmindClass");

    if (!RegisterClass(&wc))
    {
        return(FALSE);
    }

        // Create the main window.  This window will stay hidden during the
        // life of the application.
    g_hwndMain = CreateWindow(TEXT("IcwRmindClass"),
                            TEXT("IcwRmind"),
                            WS_OVERLAPPEDWINDOW,
                            CW_USEDEFAULT,
                            CW_USEDEFAULT,
                            100,
                            100,
                            HWND_DESKTOP,
                            NULL,
                            g_hModule,
                            NULL);

    if (g_hwndMain == NULL)
    {
        _ASSERT(FALSE);
        return(FALSE);
    }

    return(TRUE);
}


//-----------------------------------------------------------------------------
//  MainWndProc
//-----------------------------------------------------------------------------
LRESULT WINAPI MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    switch (message)
    {
        case WM_CREATE:
        {
            return 0;
        }
        
        case WM_TIMER:
        {
            KillTimer(g_hwndMain, TIMER_RUNONCE_SETUP);
            SetupRunOnce();

                // Wait for trial days left to drop below -1.  The trail to
                // do the trial over sign up.
            if (GetISPTrialDaysLeft() < -1)
            {
                AttemptTrialOverSignup();
            }

            return 1;
        }

        case WM_TIMECHANGE:
        {
                // Calculate the relative current time.  We do not want to 
                // grab the system time because that is the new time after
                // the time change.  Tick count is in milleseconds so we
                // convert that to seconds by dividing by 1000.
            DWORD dwTickDelta = GetTickDelta();
            
                // If tick count rolls around GetTickDelta() will modify app 
                // start date, so get the tick delta before actually using it.
            time_t timeRelativeCurrent = g_timeAppStartUp + (dwTickDelta / 1000);

                // Determine the delta in seconds between the relative
                // system time and the new time set by the user.
            time_t timeCurrent;
            time(&timeCurrent);

                // Delta seconds will be negative if the user has turned
                // the clock back.
            time_t timeDeltaSeconds = timeCurrent - timeRelativeCurrent;
            time_t timeNewTrialStartDate = GetTrialStartDate() + timeDeltaSeconds;

#ifdef _DEBUG
            TCHAR buf[255];
            OutputDebugString(TEXT("-------------------\n"));
            time_t timeOldStart = GetTrialStartDate();
            wsprintf(buf, TEXT("Old Start:  %s\n"), ctime(&timeOldStart));
            OutputDebugString(buf);
            wsprintf(buf, TEXT("New Start:  %s\n"), ctime(&timeNewTrialStartDate));
            OutputDebugString(buf);
            OutputDebugString(TEXT("-------------------\n"));
#endif

                // Now reset the trial start date and the application start
                // date.  Also reset the app start date and app start tick
                // count.  This will be our new frame of reference for 
                // calculating relative dates.
            ResetTrialStartDate(timeNewTrialStartDate);
            g_timeAppStartUp = timeCurrent;
            g_dwTickAppStartUp = GetTickCount();

            return 1;
        }

        case WM_DESTROY:
        {
            PostQuitMessage(0);
            return 1;
        }

        default:
        {
            return DefWindowProc(hwnd, message, wParam, lParam);
        }
    }
}


//-----------------------------------------------------------------------------
//  SignUpDialogProc
//-----------------------------------------------------------------------------
INT_PTR CALLBACK SignUpDialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    HICON hIcon = NULL;

    switch (message)
    {
        case WM_INITDIALOG:
        {
            TCHAR bufOut[MAX_DIALOGTEXT];
            TCHAR bufFormat[MAX_DIALOGTEXT];
            TCHAR *bufAll = new TCHAR[MAX_DIALOGTEXT * 2 + MAX_ISPMSGSTRING];

            g_bDoNotRemindAgain = false;

                // This dialog has two modes.  Set the text the correct way.
            if (g_bDialogExpiredMode)
            {
                if (LoadString(g_hModule, IDS_EXPIRED_DLG_TITLE, bufFormat, MAX_DIALOGTEXT))
                {
                    SendMessage(hDlg, WM_SETTEXT, 0, (LPARAM) bufFormat);
                }

                if (bufAll)
                {
                    if (LoadString(g_hModule, IDS_EXPIRED_TEXT1, bufFormat, MAX_DIALOGTEXT))
                    {
                        wsprintf(bufOut, bufFormat, GetISPName());
                        lstrcpy(bufAll, bufOut);
                        lstrcat(bufAll, TEXT("\n\n"));
                    }

                    if(*GetISPMessage() != '\0')
                    {
                        lstrcat(bufAll, GetISPMessage());
                        lstrcat(bufAll, TEXT("\n\n"));
                    }

                    if (LoadString(g_hModule, IDS_EXPIRED_TEXT2, bufFormat, MAX_DIALOGTEXT))
                    {
                        wsprintf(bufOut, bufFormat, GetISPName(), GetISPName(), GetISPPhone());
                        lstrcat(bufAll, bufOut);
                    }

                    SetDlgItemText(hDlg, IDC_TEXT1, bufAll);

                    ShowWindow(GetDlgItem(hDlg, IDC_DONTREMIND), SW_HIDE);

                    if (LoadString(g_hModule, IDS_DONOTSIGNUP, bufOut, MAX_DIALOGTEXT))
                    {
                        SetDlgItemText(hDlg, IDCANCEL, bufOut);
                    }
                }
                
            }
            else
            {
                    // Set up the text in the dialog box.
                if (LoadString(g_hModule, IDS_DLG_TITLE, bufFormat, MAX_DIALOGTEXT))
                {
                    wsprintf(bufOut, bufFormat, GetISPTrialDaysLeft());
                    SendMessage(hDlg, WM_SETTEXT, 0, (LPARAM) bufOut);
                }

                if (bufAll)
                {
                    if (LoadString(g_hModule, IDS_TEXT1, bufFormat, MAX_DIALOGTEXT))
                    {
                        wsprintf(bufOut, bufFormat, GetISPName(), GetISPTrialDaysLeft());
                        lstrcpy(bufAll, bufOut);
                        lstrcat(bufAll, TEXT("\n\n"));
                    }

                    if(*GetISPMessage() != '\0')
                    {
                        lstrcat(bufAll, GetISPMessage());
                        lstrcat(bufAll, TEXT("\n\n"));
                    }

                    if (LoadString(g_hModule, IDS_TEXT2, bufFormat, MAX_DIALOGTEXT))
                    {
                        wsprintf(bufOut, bufFormat, GetISPName(), GetISPName(), GetISPPhone());
                        lstrcat(bufAll, bufOut);
                    }
                    SetDlgItemText(hDlg, IDC_TEXT1, bufAll);
                }

                    // If there are 0 days left then don't give user a change
                    // to say remind me later.
                if (0 == GetISPTrialDaysLeft())
                {
                    ShowWindow(GetDlgItem(hDlg, IDC_DONTREMIND), SW_HIDE);

                    if (LoadString(g_hModule, IDS_DONOTSIGNUP, bufOut, MAX_DIALOGTEXT))
                    {
                        SetDlgItemText(hDlg, IDCANCEL, bufOut);
                    }
                }
            }

                // Set the timer for how long the dialog will stay up before
                // removing itself.
            SetTimer(hDlg, TIMER_DIALOG_STAYUP, GetDialogTimeout(), NULL);
            CenterTheWindow(hDlg);
            if (bufAll)
            {
                delete [] bufAll;
            }


            return TRUE;
        }

        case WM_COMMAND:
        {
            switch (LOWORD(wParam))
            {
                    // IDOK is the Sign up now button.
                case IDOK:
                {
                    KillTimer(hDlg, TIMER_DIALOG_STAYUP);
                    EndDialog(hDlg, wParam);
                    break;
                }

                    // If the checkbox is clicked then toggle the button text for the
                    // signup later button.
                case IDC_DONTREMIND:
                {
                    if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_DONTREMIND))
                    {
                        TCHAR bufOut[MAX_DIALOGTEXT];
                        if (LoadString(g_hModule, IDS_DONOTREMIND, bufOut, MAX_DIALOGTEXT))
                        {
                            SetDlgItemText(hDlg, IDCANCEL, bufOut);
                        }
                    }
                    else
                    {
                        TCHAR bufOut[MAX_DIALOGTEXT];
                        if (LoadString(g_hModule, IDS_SIGNUPLATER, bufOut, MAX_DIALOGTEXT))
                        {
                            SetDlgItemText(hDlg, IDCANCEL, bufOut);
                        }
                    }

                    break;
                }

                    // Otherwise assume they hit the close button or the sign up later
                    // button.
                default:
                {
                        // See if the user never wants reminded again.
                    if (BST_CHECKED == IsDlgButtonChecked(hDlg, IDC_DONTREMIND))
                    {
                        g_bDoNotRemindAgain = true;
                    }

                    KillTimer(hDlg, TIMER_DIALOG_STAYUP);
                    EndDialog(hDlg, wParam);
                    break;
                }
            }

            break;
        }

            // No user interaction has occurred.  remove the dialog but do not count
            // this as an attempt to sign up.
        case WM_TIMER:
        {
            KillTimer(hDlg, TIMER_DIALOG_STAYUP);
            EndDialog(hDlg, IDABORT);
            break;
        }

        case WM_PAINT:
        {
            HDC             hDC;
            PAINTSTRUCT     ps;
            HICON           hIcon;
            HWND            hWndRect;
            RECT            rect;
            POINT           ptUpperLeft;

            hDC = BeginPaint(hDlg, &ps);

            hIcon = LoadIcon(NULL, MAKEINTRESOURCE(IDI_QUESTION));

            if (hIcon)
            {
                hWndRect = GetDlgItem(hDlg, IDC_ICON1);
                GetWindowRect(hWndRect, &rect);

                ptUpperLeft.x = rect.left;
                ptUpperLeft.y = rect.top;
                ScreenToClient(hDlg, &ptUpperLeft);

                DrawIcon(hDC, ptUpperLeft.x, ptUpperLeft.y, hIcon);
            }

            EndPaint(hDlg, &ps);
            break;
        }
    }

    return FALSE;

    UNREFERENCED_PARAMETER(lParam);
    UNREFERENCED_PARAMETER(hDlg);
}


//-----------------------------------------------------------------------------
//  CheckForRASConnection
//-----------------------------------------------------------------------------
BOOL CheckForRASConnection()
{
    RASCONNSTATUS rascs;
    RASCONN rasConn[MAXRASCONNS];
    DWORD dwEntries = MAXRASCONNS;
    DWORD dwSize = sizeof(rasConn);
    DWORD dwRet;
    BOOL bRetCode = FALSE;
    
        // This is the connection name of the ISP the user has signed up
        // with.  We will look for a connectiod with this same name.
    const TCHAR* pszConnectionName = GetISPConnectionName();
    if (NULL == pszConnectionName || 0 == lstrlen(pszConnectionName))
    {
        return FALSE;
    }

    for (int i = 0; i < MAXRASCONNS; ++i)
    {
        rasConn[i].dwSize = sizeof(RASCONN);
    }

    dwRet = RasEnumConnections(rasConn, &dwSize, &dwEntries);

    if (dwRet == 0)
    {
        for (dwRet = 0; dwRet < dwEntries; dwRet++)
        {
                // If this is the connection we are looking for let's make
                // sure the connection is all set to go.
            if (0 == lstrcmpi(pszConnectionName, rasConn[dwRet].szEntryName))
            {
                rascs.dwSize = sizeof(RASCONNSTATUS);
                dwRet = RasGetConnectStatus(rasConn[dwRet].hrasconn, 
                                            &rascs);
                if (dwRet == 0 && rascs.rasconnstate == RASCS_Connected)
                {
                    bRetCode = TRUE;
                }
            }
        }
    }

    return bRetCode;
}


//-----------------------------------------------------------------------------
//  CheckForSignupAttempt
//
//  This method contains the logic that check to see if we should make an attempt
//  to pop up the sign up dialog.  If we should make an attempt will will then
//  enum the RAS connections to see if the user is connected before popping
//  up the dialog.
//-----------------------------------------------------------------------------
void CheckForSignupAttempt()
{
    int nDaysLeft = GetISPTrialDaysLeft();
    int nRetValue = 0;
            
        // Every some many signup attempts lets read the registry and see if
        // a successful signup happened.
    ++g_nAttemptCounter;

    if (MAX_ATTEMPTCOUNTER == g_nAttemptCounter)
    {
        g_nAttemptCounter = 0;

        if (IsSignupSuccessful())
        {
            ShutDownForGood();
            return;
        }

            // If the trial is expired then set the IE run once key.
        if (nDaysLeft < -1)
        {
            SetIERunOnce();
        }
    }

        // If we are in negative days left then do not do anything.  This means
        // the trail is over and the user has not signed up.  We will give
        // them one more signup attempt on application start up.
    if (nDaysLeft < 0)
    {
        return;
    }

    bool bAttemptSignup = false;

        // Based on the total signup notificaiton attempts we will determine
        // if the days left requires another attempt.
    switch (GetTotalNotifications())
    {
            // If we have not made any attempts yet then if we are at the half
            // way point in the trial or past the half way point we will make
            // a signup attempt.
        case 0:
        {
            if (nDaysLeft <= (int)(GetISPTrialDays() / 2))
            {
                bAttemptSignup = true;
            }
            break;
        }

            // If we have already perfomed 1 attempt then the second attempt
            // will come on the next to last day or the last day.
        case 1:
        {
            if (nDaysLeft <= 1)
            {
                bAttemptSignup = true;
            }
            break;
        }

            // The 3rd attempt will not come until the last day.
        case 2:
        {
            if (nDaysLeft == 0)
            {
                bAttemptSignup = true;
            }
            break;
        }

        default:
        {
            break;
        }
    }

    if (bAttemptSignup)
    {
        if (CheckForRASConnection())
        {
                // Before actually showing the dialog do a quick check to see
                // if a previous signup was successful.  If so we will shut 
                // down for good.
            if (IsSignupSuccessful())
            {
                ShutDownForGood();
                return;
            }

            g_bDialogExpiredMode = false;
            //if we have an isp message we need the right dlg template
            if(*GetISPMessage() != '\0')
                nRetValue = (int)DialogBox(g_hModule, MAKEINTRESOURCE(IDD_SIGNUP_ISPMSG), g_hwndMain, SignUpDialogProc);
            else 
                nRetValue = (int)DialogBox(g_hModule, MAKEINTRESOURCE(IDD_SIGNUP), g_hwndMain, SignUpDialogProc);

            switch (nRetValue)
            {
                    // The user wants to try and signup.
                case IDOK:
                {
                    PerformTheSignup();
                    break;
                }

                    // The user said signup later.  Check to see if the don't remind
                    // me button was pressed.  If so then shut down for good.
                case IDCANCEL:
                {
                        // If this is the last day of the trial then the remind
                        // me later button is not the Don't signup button.  In
                        // this case shut down for good.
                    if (0 == nDaysLeft)
                    {
                        ShutDownForGood();
                    }
                    else
                    {
                        IncrementTotalNotifications();
                        
                        if (g_bDoNotRemindAgain)
                        {
                            ShutDownForGood();
                        }
                    }

                    break;
                }

                    // The dialog timed out.  Don't do anything.  The does not
                    // count as an attempt.
                case IDABORT:
                {
                    break;
                }

                    // No work in here, in fact we should not get here.
                default:
                {
                    _ASSERT(false);
                    break;
                }
            }

                // If there is 1 day left let's make sure that total notifications
                // is 2.  If not the dialog may pop up multiple times.  Oh yea,
                // if dialog timed out then don't do this.
            if (IDABORT != nRetValue && 1 == nDaysLeft && 1 == GetTotalNotifications())
            {
                IncrementTotalNotifications();
            }
        }
    }
}


//-----------------------------------------------------------------------------
//  GetISPTrialDaysLeft
//-----------------------------------------------------------------------------
int GetISPTrialDaysLeft()
{
        // Calculate the relative current time.  The current system time cannot
        // be trusted if the System date/time dialog is up.  That dialog will
        // change the actual system time when every the user pokes around even
        // before hitting OK or Apply!!!
    time_t timeRelativeCurrent = g_timeAppStartUp + (GetTickDelta() / 1000);

        // The relative time and the trial start date are both time_t type
        // variables which are in seconds.
    int nSecondsSinceStart = (int)(timeRelativeCurrent - GetTrialStartDate());

        // Now convert seconds into days.  There are 86400 seconds in a day.
        // Note that we will always round up one more day if there is any 
        // remainder.
    div_t divResult = div(nSecondsSinceStart, 86400);
    int nDaysSinceStart = divResult.quot;
    if (divResult.rem)
    {
        ++nDaysSinceStart;
    }

#ifdef _DEBUG
    TCHAR buf[255];
    wsprintf(buf, TEXT("Days Since = %i\n"), nDaysSinceStart);
    OutputDebugString(buf);
    wsprintf(buf, TEXT("Check:  %s\n"), ctime(&timeRelativeCurrent));
    OutputDebugString(buf);
    time_t tt = GetTrialStartDate();
    wsprintf(buf, TEXT("Start:  %s\n"), ctime(&tt));
    OutputDebugString(buf);
#endif

    int nDaysLeft = GetISPTrialDays() - nDaysSinceStart;

#ifdef _DEBUG
    wsprintf(buf, TEXT("Days Left = %i\r\n"), nDaysLeft);
    OutputDebugString(buf);
#endif

    return nDaysLeft;
}


//-----------------------------------------------------------------------------
//  ShutDownForGood
//-----------------------------------------------------------------------------
void ShutDownForGood()
{
    RemoveRunOnce();
    RemoveIERunOnce();
    DeleteAllRegistryData();
    PostMessage(g_hwndMain, WM_CLOSE, 0, 0);
}


//-----------------------------------------------------------------------------
//  PerformTheSignup
//-----------------------------------------------------------------------------
void PerformTheSignup()
{
        // Note that we do not shut down for good.  The sign up may fail so 
        // simply increment the notification count.
    const TCHAR* pcszSignupUrl = GetISPSignupUrl();
    ShellExecute(g_hwndMain, TEXT("open"), pcszSignupUrl, TEXT(""), TEXT(""), SW_SHOW);
    IncrementTotalNotifications();
}


//-----------------------------------------------------------------------------
//  CenterTheWindow
//-----------------------------------------------------------------------------
void CenterTheWindow(HWND hWnd)
{
    HDC hDC = GetDC(hWnd);

    if (hDC)
    {
        int nScreenWidth = GetDeviceCaps(hDC, HORZRES);
        int nScreenHeight = GetDeviceCaps(hDC, VERTRES);
    
        RECT rect;
        GetWindowRect(hWnd, &rect);
        
            // Also make the window "always on top".
        SetWindowPos(hWnd, HWND_TOPMOST, 
                    (nScreenWidth / 2) - ((rect.right - rect.left) / 2), 
                    (nScreenHeight / 2) - ((rect.bottom - rect.top) / 2), 
                    rect.right - rect.left, 
                    rect.bottom - rect.top, 
                    SWP_SHOWWINDOW);

        ReleaseDC(hWnd, hDC);
    }
}


//-----------------------------------------------------------------------------
//  GetTickDelta
//-----------------------------------------------------------------------------
DWORD GetTickDelta()
{
        // This function returns the delta between the startup tick count and
        // the current tick count.  Note that we must watch for a rollover in 
        // the tick count.
    DWORD dwTickDelta;
    DWORD dwTickCurrent = GetTickCount();

        // If tick count rolls over we need to reset the app start up date
        // and the app tick count in case we roll over a second time.
    if (dwTickCurrent < g_dwTickAppStartUp)
    {
            // Calculate the delta by finding out how many ticks to the MAX 
            // tick count a DWORD can handle and then add the wrap around amount.
        DWORD dwDeltaToMax =  0xFFFFFFFF - g_dwTickAppStartUp;
        dwTickDelta = dwDeltaToMax + dwTickCurrent;

            // Modify the application startup by the delta in seconds that have
            // passed since it was last set.  Also reset startup tick count
            // to current tick for our new frame of reference.
        g_timeAppStartUp += (dwTickDelta / 1000);   // Convert to seconds.
        g_dwTickAppStartUp = dwTickCurrent;

            // Since we have modified the application start up date relative
            // to the current tick count and changed the app start up tick
            // count to the current tick count, the delta is zero.
        dwTickDelta = 0;
    }
    else
    {
        dwTickDelta = dwTickCurrent - g_dwTickAppStartUp;
    }

    return dwTickDelta;
}


//-----------------------------------------------------------------------------
//  AttemptTrialOverSignup
//-----------------------------------------------------------------------------
void AttemptTrialOverSignup()
{ 
    int nRetValue = 0;

    // Setup the run once data for IE.
    g_bDialogExpiredMode = true;

    if(*GetISPMessage() != '\0')
        nRetValue = (int)DialogBox(g_hModule, MAKEINTRESOURCE(IDD_SIGNUP_ISPMSG), g_hwndMain, SignUpDialogProc);
    else 
        nRetValue = (int)DialogBox(g_hModule, MAKEINTRESOURCE(IDD_SIGNUP), g_hwndMain, SignUpDialogProc);

    
    RemoveIERunOnce();

    switch (nRetValue)
    {
            // The user wants to try and signup.
        case IDOK:
        {
            const TCHAR* pcszSignupUrl = GetISPSignupUrlTrialOver();
            ShellExecute(g_hwndMain, TEXT("open"), pcszSignupUrl, TEXT(""), TEXT(""), SW_SHOW);
            ShutDownForGood();
            break;
        }

        case IDCANCEL:
        {
            ShutDownForGood();
            break;
        }

            // If we get IDABORT the dialog timed out so don't do anything.
        case IDABORT:
        {
            break;
        }

            // No work in here, in fact we should not get here.
        default:
        {
            _ASSERT(false);
            ShutDownForGood();
            break;
        }
    }
}

extern "C" void _stdcall ModuleEntry (void)
{
    LPTSTR      pszCmdLine = GetCommandLine();
    
    if ( *pszCmdLine == TEXT('\"') ) 
    {
        /*
         * Scan, and skip over, subsequent characters until
         * another double-quote or a null is encountered.
         */
        while ( *++pszCmdLine && (*pszCmdLine != TEXT('\"')) )
            ;
        /*
         * If we stopped on a double-quote (usual case), skip
         * over it.
         */
        if ( *pszCmdLine == TEXT('\"') )
            pszCmdLine++;
    }
    else 
    {
        while (*pszCmdLine > TEXT(' '))
        pszCmdLine++;
    }

    /*
     * Skip past any white space preceeding the second token.
     */
    while (*pszCmdLine && (*pszCmdLine <= TEXT(' '))) 
    {
        pszCmdLine++;
    }

    int i = WinMainT(GetModuleHandle(NULL), NULL, pszCmdLine, SW_SHOWDEFAULT);
    
    ExitProcess(i); // Were outa here....  
}   /*  ModuleEntry() */