//*********************************************************************
//*                  Microsoft Windows                               **
//*            Copyright(c) Microsoft Corp., 1994                    **
//*********************************************************************

#include "pre.h"
#include "perhist.h"
#include "shlobj.h"

const VARIANT c_vaEmpty = {0};
const LARGE_INTEGER c_li0 = { 0, 0 };


CHAR szTempBuffer[TEMP_BUFFER_LENGTH];

#define ReadVerifyDW(x)     if (!ReadDW(&(x),pcCSVFile))                        \
                            {                                                   \
                                AssertMsg(0,"Invalid DWORD in CSV file");       \
                                goto ReadOneLineError;                          \
                            }
#define ReadVerifyW(x)      if (!ReadW(&(x),pcCSVFile))                         \
                            {                                                   \
                                AssertMsg(0,"Invalid WORD in CSV file");        \
                                goto ReadOneLineError;                          \
                            }
//Accepts -1 as a valid number. currently this is used for LCID, since all langs has a LDID == -1
#define ReadVerifyWEx(x)    if (!ReadWEx(&(x),pcCSVFile))                       \
                            {                                                   \
                                AssertMsg(0,"Invalid WORD in CSV file");        \
                                goto ReadOneLineError;                          \
                            }
#define ReadVerifyB(x)      if (!ReadB(&(x),pcCSVFile))                         \
                            {                                                   \
                                AssertMsg(0,"Invalid BYTE in CSV file");        \
                                goto ReadOneLineError;                          \
                            }
#define ReadVerifyBOOL(x)   if (!ReadBOOL(&(x),pcCSVFile))                      \
                            {                                                   \
                                AssertMsg(0,"Invalid BOOL in CSV file");        \
                                goto ReadOneLineError;                          \
                            }
#define ReadVerifySPECIAL(x, y, z) if (!ReadSPECIAL(&(x), &(y), &(z), pcCSVFile))   \
                            {                                                   \
                                AssertMsg(0,"Invalid SPECIAL in CSV file");     \
                                goto ReadOneLineError;                          \
                            }
#define ReadVerifySZ(x,y)   if (!ReadSZ(&x[0],y+sizeof('\0'),pcCSVFile))        \
                            {                                                   \
                                AssertMsg(0,"Invalid STRING in CSV file");      \
                                goto ReadOneLineError;                          \
                            }

CISPCSV::~CISPCSV(void)
{
    if(m_lpStgHistory)
    {
        // Release the storage
        m_lpStgHistory->Release();
        m_lpStgHistory = NULL;
    }
    
    if (hbmTierIcon)
        DeleteObject(hbmTierIcon);
    
    CleanupISPPageCache(TRUE);
}

// Do an strip of Single Quotes from a source string.  The source is formatted as:
// 'some text', and the dest string ends up being
// some text
void CISPCSV::StripQuotes
(
    LPSTR   lpszDst,
    LPSTR   lpszSrc
)
{
    //strcpy(lpszDst, lpszSrc + 1, strlen(lpszSrc) - 1);
    strcpy(lpszDst, lpszSrc + 1);
    lpszDst[strlen(lpszDst) - 1] = '\0';
}


BOOL CISPCSV::ValidateFile(TCHAR* pszFile)
{
    ASSERT(pszFile);
  
    if (!lstrlen(pszFile))
        return FALSE;

    if (GetFileAttributes(pszFile) == 0xFFFFFFFF)
        return FALSE;

    return TRUE;
}

// ############################################################################
BOOL CISPCSV::ReadDW(DWORD far *pdw, CCSVFile far *pcCSVFile)
{
    if (!pcCSVFile->ReadToken(szTempBuffer,TEMP_BUFFER_LENGTH))
            return FALSE;
    return (FSz2Dw(szTempBuffer,pdw));
}

// ############################################################################
BOOL CISPCSV::ReadW(WORD far *pw, CCSVFile far *pcCSVFile)
{
    if (!pcCSVFile->ReadToken(szTempBuffer,TEMP_BUFFER_LENGTH))
            return FALSE;
    return (FSz2W(szTempBuffer,pw));
}

// ############################################################################
//Accepts -1 as a valid number. currently this is used for LCID, since all langs has a LDID == -1
BOOL CISPCSV::ReadWEx(WORD far *pw, CCSVFile far *pcCSVFile)
{
    if (!pcCSVFile->ReadToken(szTempBuffer,TEMP_BUFFER_LENGTH))
            return FALSE;
    return (FSz2WEx(szTempBuffer,pw));
}

// ############################################################################
BOOL CISPCSV::ReadB(BYTE far *pb, CCSVFile far *pcCSVFile)
{
    if (!pcCSVFile->ReadToken(szTempBuffer,TEMP_BUFFER_LENGTH))
            return FALSE;
    return (FSz2B(szTempBuffer,pb));
}

// ############################################################################
BOOL CISPCSV::ReadBOOL(BOOL far *pbool, CCSVFile far *pcCSVFile)
{
    if (!pcCSVFile->ReadToken(szTempBuffer,TEMP_BUFFER_LENGTH))
            return FALSE;
    return (FSz2BOOL(szTempBuffer,pbool));
}

// ############################################################################
// A special int can be either a BOOL (TRUE,FALSE) or a int, 0 or -1
// if the value is 0 or -1, then the pbIsSpecial bool is set to TRUE
BOOL CISPCSV::ReadSPECIAL(BOOL far *pbool, BOOL far *pbIsSpecial, int far *pInt, CCSVFile far *pcCSVFile)
{
    if (!pcCSVFile->ReadToken(szTempBuffer,TEMP_BUFFER_LENGTH))
            return FALSE;
    return (FSz2SPECIAL(szTempBuffer,pbool, pbIsSpecial, pInt));
}

// ############################################################################
BOOL CISPCSV::ReadSZ(LPSTR psz, DWORD dwSize, CCSVFile far *pcCSVFile)
{
    if (!pcCSVFile->ReadToken(psz,dwSize))
            return FALSE;
    return TRUE;
}

// ############################################################################
BOOL CISPCSV::ReadToEOL(CCSVFile far *pcCSVFile)
{
    return pcCSVFile->SkipTillEOL();
}

HRESULT CISPCSV::ReadOneLine
(
    CCSVFile    far *pcCSVFile
)
{
    HRESULT     hr = ERROR_SUCCESS;
    CHAR    szTemp                [MAX_ISP_NAME];
    CHAR    szISPLogoPath         [MAX_PATH] = "\0";
    CHAR    szISPTierLogoPath     [MAX_PATH];
    CHAR    szISPTeaserPath       [MAX_PATH];
    CHAR    szISPMarketingHTMPath [MAX_PATH];
    CHAR    szISPFilePath         [MAX_PATH];
    CHAR    szISPName             [MAX_ISP_NAME];
    //CHAR    szCNSIconPath         [MAX_PATH];
    CHAR    szBillingFormPath     [MAX_PATH];
    CHAR    szPayCSVPath          [MAX_PATH];
    CHAR    szOfferGUID           [MAX_GUID];
    CHAR    szMir                 [MAX_ISP_NAME];

    if (!ReadSZ(szTemp, sizeof(szTemp), pcCSVFile))
    {
        hr = ERROR_NO_MORE_ITEMS; // no more enteries
        goto ReadOneLineExit;
    }
    // Strip the single quotes from the isp Name
    StripQuotes(szISPName, szTemp);
    
    ReadVerifyW(wOfferID);   
    ReadVerifySZ(szISPLogoPath, sizeof(szISPLogoPath));
    ReadVerifySZ(szISPMarketingHTMPath, sizeof(szISPMarketingHTMPath));
    ReadVerifySZ(szISPTierLogoPath, sizeof(szISPTierLogoPath));
    ReadVerifySZ(szISPTeaserPath, sizeof(szISPTeaserPath));
    ReadVerifySZ(szISPFilePath, sizeof(szISPFilePath)); 
    ReadVerifyDW(dwCfgFlag);
    ReadVerifyDW(dwRequiredUserInputFlags);
    ReadVerifySZ(szBillingFormPath, sizeof(szBillingFormPath));
    ReadVerifySZ(szPayCSVPath, sizeof(szPayCSVPath));
    ReadVerifySZ(szOfferGUID, sizeof(szOfferGUID));
    ReadVerifySZ(szMir, sizeof(szMir));   
    ReadVerifyWEx(wLCID);   //Accepts -1 as a valid number. currently this is used for LCID, since all langs has a LDID == -1
    ReadToEOL(pcCSVFile);

#ifdef UNICODE
    MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szISPName,              MAX_ISP_NAME,   m_szISPName,            MAX_ISP_NAME);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szISPLogoPath,          MAX_PATH,       m_szISPLogoPath,        MAX_PATH);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szISPMarketingHTMPath,  MAX_PATH,       m_szISPMarketingHTMPath,MAX_PATH);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szISPTierLogoPath,      MAX_PATH,       m_szISPTierLogoPath,    MAX_PATH);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szISPTeaserPath,        MAX_PATH,       m_szISPTeaserPath,      MAX_PATH);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szISPFilePath,          MAX_PATH,       m_szISPFilePath,        MAX_PATH);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szBillingFormPath,      MAX_PATH,       m_szBillingFormPath,    MAX_PATH);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szPayCSVPath,           MAX_PATH,       m_szPayCSVPath,         MAX_PATH);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szOfferGUID,            MAX_GUID,       m_szOfferGUID,          MAX_GUID);
	MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, szMir,                  MAX_ISP_NAME,   m_szMir,                MAX_ISP_NAME);
#else

    lstrcpy(m_szISPName, szISPName);
    lstrcpy(m_szISPLogoPath, szISPLogoPath);
    lstrcpy(m_szISPMarketingHTMPath, szISPMarketingHTMPath);
    lstrcpy(m_szISPTierLogoPath, szISPTierLogoPath);
    lstrcpy(m_szISPTeaserPath, szISPTeaserPath);
    lstrcpy(m_szISPFilePath, szISPFilePath);
    lstrcpy(m_szBillingFormPath, szBillingFormPath);
    lstrcpy(m_szPayCSVPath, szPayCSVPath);
    lstrcpy(m_szOfferGUID, szOfferGUID);
    lstrcpy(m_szMir, szMir);
#endif


    bCNS = (ICW_CFGFLAG_CNS & dwCfgFlag) ? TRUE : FALSE;
    bSecureConnection = (ICW_CFGFLAG_SECURE & dwCfgFlag) ? TRUE : FALSE;

    //If this is nooffer we won't try to validate
    if (!(dwCfgFlag & ICW_CFGFLAG_OFFERS))
    {
        if (!ValidateFile(m_szISPMarketingHTMPath))
            hr = ERROR_FILE_NOT_FOUND;
        return hr;
    }

    if (!(dwCfgFlag & ICW_CFGFLAG_AUTOCONFIG))
    {
        if (!ValidateFile(m_szISPMarketingHTMPath))
            return ERROR_FILE_NOT_FOUND;
    }

    if (dwCfgFlag & ICW_CFGFLAG_OEM_SPECIAL)
    {
        if (!ValidateFile(m_szISPTierLogoPath) || !ValidateFile(m_szISPTeaserPath))
            dwCfgFlag &= ~ICW_CFGFLAG_OEM_SPECIAL ;
    }

    //Try and validate the integrity of various offers
    //based on type.

    //OLS, CNS, NO-CNS   
    if (!ValidateFile(m_szISPLogoPath))
        return ERROR_FILE_NOT_FOUND;
    if (!ValidateFile(m_szISPFilePath))
        return ERROR_FILE_NOT_FOUND;

    // Validate the billing path only when billing option is set
    if (dwCfgFlag & ICW_CFGFLAG_BILL)
    {
        if(!ValidateFile(m_szBillingFormPath))
            return ERROR_FILE_NOT_FOUND;
    }

    // Validate the payment path only when payment option is set
    if (dwCfgFlag & ICW_CFGFLAG_PAYMENT)
    {
        if(!ValidateFile(m_szPayCSVPath))
            return ERROR_FILE_NOT_FOUND;
    }        
ReadOneLineExit:
    return hr;
    
ReadOneLineError:
    hr = ERROR_INVALID_DATA;
    goto ReadOneLineExit;
}

HRESULT CISPCSV::ReadFirstLine
(
    CCSVFile    far *pcCSVFile
)
{
    CHAR   szTemp[TEMP_BUFFER_LENGTH];

    for (int i = 0; i < NUM_ISPCSV_FIELDS; i++)
    {
        if (!ReadSZ(szTemp, sizeof(szTemp), pcCSVFile))
        {
            return(ERROR_INVALID_DATA);
        }            
    }          
    ReadToEOL(pcCSVFile);
    return (ERROR_SUCCESS);
}

void CISPCSV::MakeCompleteURL(LPTSTR   lpszURL, LPTSTR  lpszSRC)    
{
    TCHAR   szCurrentDir[MAX_PATH] = TEXT("\0");

    // Form the URL
    GetCurrentDirectory(ARRAYSIZE(szCurrentDir), szCurrentDir);
    wsprintf (lpszURL, TEXT("FILE://%s\\%s"), szCurrentDir, lpszSRC);        

}

// Display this object's HTML page
HRESULT CISPCSV::DisplayHTML(LPTSTR szFile)
{    
    TCHAR           szURL[INTERNET_MAX_URL_LENGTH];
    HRESULT         hr;
            
    // Make the URL
    MakeCompleteURL(szURL, szFile);
    hr = gpWizardState->pICWWebView->DisplayHTML(szURL);

    return (hr);
}

//Takes RES ID
HRESULT CISPCSV::DisplayTextWithISPName
(
    HWND    hDlgCtrl, 
    int     iMsgString,
    TCHAR*  pszExtra    //sticks something on the very end of the string if needed.
)
{
    TCHAR   szFinal [MAX_MESSAGE_LEN*3] = TEXT("\0");
    TCHAR   szFmt   [MAX_MESSAGE_LEN];
    TCHAR   *args   [1];
    LPVOID  pszIntro = NULL;

    args[0] = (LPTSTR) m_szISPName;
    
    // BUGBUG should probably check for error return from LoadString
    LoadString(ghInstanceResDll, iMsgString, szFmt, ARRAYSIZE(szFmt));
                
    if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_STRING | FORMAT_MESSAGE_ARGUMENT_ARRAY, 
                      szFmt, 
                      0, 
                      0, 
                      (LPTSTR)&pszIntro, 
                      0,
                      (va_list*)args))
    {
                  
        lstrcpy(szFinal, (LPTSTR)pszIntro);
        if (pszExtra)
            lstrcat(szFinal, pszExtra);
        
        SetWindowText(hDlgCtrl, szFinal);
    }

    if (pszIntro)
    {
        LocalFree(pszIntro);
    }

    return(S_OK);
}

#if 0
// Delete a Persisted History stream
HRESULT CISPCSV::DeleteHistory
(
    BSTR    bstrStreamName
)
{
    // No persistence if we don't have a storage object
    ASSERT(m_lpStgHistory);
    if (!m_lpStgHistory)
        return E_FAIL;

    // Delete the stream
    return (m_lpStgHistory->DestroyElement(bstrStreamName));
}
#endif

// Save the history of current lpBrowser using the provided name
HRESULT CISPCSV::SaveHistory
(
    BSTR bstrStreamName
)
{
    IStream         *lpStream;
    IPersistHistory *pHist;
    IWebBrowser2    *lpWebBrowser;
    HRESULT         hr = S_OK;
    
    // No persistence if we don't have a storage object
    ASSERT(m_lpStgHistory);
    if (!m_lpStgHistory)
        return E_FAIL;
            
    // Create a new Stream
    if (SUCCEEDED(hr = m_lpStgHistory->CreateStream(bstrStreamName, 
                                                    STGM_DIRECT | 
                                                    STGM_READWRITE | 
                                                    STGM_SHARE_EXCLUSIVE | 
                                                    STGM_CREATE,
                                                    0, 
                                                    0, 
                                                    &lpStream)))
    {
        // Get an IPersistHistory interface pointer on the current WebBrowser object
        gpWizardState->pICWWebView->get_BrowserObject(&lpWebBrowser);
        if ( SUCCEEDED(lpWebBrowser->QueryInterface(IID_IPersistHistory, (LPVOID*) &pHist)))
        {
            // Save the history
            pHist->SaveHistory(lpStream);
            pHist->Release();
            
            // Reset the stream pointer to the beginning
            lpStream->Seek(c_li0, STREAM_SEEK_SET, NULL);
        }
        lpStream->Release();
    }
    
    return (hr);
}

HRESULT CISPCSV::LoadHistory
(
    BSTR   bstrStreamName
)
{
    IStream         *lpStream;
    IPersistHistory *pHist;
    IWebBrowser2    *lpWebBrowser;
    HRESULT         hr = S_OK;
    
    // No persistence if we don't have a storage object
    ASSERT(m_lpStgHistory);
    if (!m_lpStgHistory)
        return E_FAIL;
        
    // Open the Stream
    if (SUCCEEDED(hr = m_lpStgHistory->OpenStream(bstrStreamName, 
                                                  NULL, 
                                                  STGM_DIRECT | 
                                                  STGM_READWRITE | 
                                                  STGM_SHARE_EXCLUSIVE,
                                                  0, 
                                                  &lpStream)))
    {
        // Get an IPersistHistory interface pointer on the current WebBrowser object
        gpWizardState->pICWWebView->get_BrowserObject(&lpWebBrowser);
        if ( SUCCEEDED(lpWebBrowser->QueryInterface(IID_IPersistHistory, (LPVOID*) &pHist)))
        {
            // Save the history
            pHist->LoadHistory(lpStream, NULL);
            pHist->Release();
            
            // Reset the stream pointer to the beginning
            lpStream->Seek(c_li0, STREAM_SEEK_SET, NULL);
        }
        lpStream->Release();
    }
    return (hr);
}


// This funtion will get the name of a ISP page cache filen from the page's ID
HRESULT CISPCSV::GetCacheFileNameFromPageID
(
    BSTR    bstrPageID,
    LPTSTR  lpszCacheFile,
    ULONG   cbszCacheFile
)
{
    HRESULT     hr = S_OK;
    IStream     *lpStream;
    ULONG       cbRead;
    
    if (!m_lpStgIspPages)
        return E_FAIL;
        
    // Open the stream
    if (SUCCEEDED(hr = m_lpStgIspPages->OpenStream(bstrPageID, 
                                                   NULL, 
                                                   STGM_DIRECT | 
                                                   STGM_READWRITE | 
                                                   STGM_SHARE_EXCLUSIVE,
                                                   0, 
                                                   &lpStream)))
    {
        // Read the file name
        lpStream->Read(lpszCacheFile, cbszCacheFile, &cbRead);
        
        // release the stream
        lpStream->Release();
    }   
    
    return hr;
}

// This function will cleanup the ISP Page cache.  This means deleting all temp files created
// and cleaning up the structured storage object used to store the file names
void CISPCSV::CleanupISPPageCache(BOOL bReleaseStorage)
{
    IEnumSTATSTG    *pEnum;
    STATSTG         StreamInfo;
    IMalloc         *pMalloc = NULL;
    
    // If we have a storage object already created, then enumerate the streams
    // in it, and free the underlying cache files.
    if (m_lpStgIspPages)
    {
        if (SUCCEEDED (SHGetMalloc (&pMalloc)))
        {
            if (SUCCEEDED(m_lpStgIspPages->EnumElements(0, NULL, 0, &pEnum)))
            {
                while(S_OK == pEnum->Next(1, &StreamInfo, NULL))
                {
                    if (StreamInfo.pwcsName)
                    {
                        TCHAR       szPath[MAX_PATH];
                        
                        if (SUCCEEDED(GetCacheFileNameFromPageID(StreamInfo.pwcsName,
                                                                 szPath,
                                                                 sizeof(szPath))))
                        {    
                            // delete the file
                            DeleteFile(szPath);

                            m_lpStgIspPages->DestroyElement(StreamInfo.pwcsName);
                            if(m_lpStgHistory)
                                m_lpStgHistory->DestroyElement(StreamInfo.pwcsName);
                            
                            // Free the memory allocated by the enumerator
                            pMalloc->Free (StreamInfo.pwcsName);
                        }   
                    }                        
                }
                // Release the enumerator
                pEnum->Release();
            }   
            // release the Shell Memory allocator
            pMalloc->Release ();
        }            
        
        if (bReleaseStorage)
        {
            // Release the storage
            m_lpStgIspPages->Release();
            m_lpStgIspPages= NULL;
        }            
    }
}

// This function will create a new page cache entry if necessary using the PageID as an
// index.  If an entry does not exists, and temp file will be create, then name stored,
// and the data in lpszTempFile will be copied into the new file.
// If the page already exists, this function will just return.
HRESULT CISPCSV::CopyFiletoISPPageCache
(
    BSTR    bstrPageID,
    LPTSTR  lpszTempFile
)
{
    HRESULT hr = S_OK;
    TCHAR   szTempPath[MAX_PATH];
    TCHAR   szISPCacheFile[MAX_PATH];
    IStream *lpStream;
    ULONG   cbWritten;
        
    if (!m_lpStgIspPages)
        return E_FAIL;
    
    if (SUCCEEDED(GetCacheFileNameFromPageID(bstrPageID,
                                             szISPCacheFile,
                                             sizeof(szISPCacheFile))))
    {
        // The pageID already has a file in the cache, so we can just return success
        return S_OK;
    }      

    if (!GetTempPath(ARRAYSIZE(szTempPath), szTempPath))
        return E_FAIL;
    
    // No file yet, so we have to create one
    if (!GetTempFileName(szTempPath, TEXT("ICW"), 0, szISPCacheFile))
        return E_FAIL;
        
    // Create a stream using the passed in page ID
    if (SUCCEEDED(hr = m_lpStgIspPages->CreateStream(bstrPageID, 
                                                     STGM_DIRECT | 
                                                     STGM_READWRITE | 
                                                     STGM_SHARE_EXCLUSIVE | 
                                                     STGM_CREATE,
                                                     0, 
                                                     0, 
                                                     &lpStream)))
    {
        // Write the file name to the stream, including the NULL terminator
#ifdef UNICODE
        DWORD dwSize = (lstrlen(szISPCacheFile)+1) * sizeof(TCHAR);
        if (SUCCEEDED(hr = lpStream->Write(szISPCacheFile, dwSize, &cbWritten)))
#else

        if (SUCCEEDED(hr = lpStream->Write(szISPCacheFile, lstrlen(szISPCacheFile)+1, &cbWritten)))
#endif
        {
            // Copy the passed in temp file
            if (!CopyFile(lpszTempFile, szISPCacheFile, FALSE))
                hr = E_FAIL;
        }
        // Release the stream
        lpStream->Release();
    }            
    
    return hr;
}