//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// cache.cpp

//   XML document cache.

//   History:

//       4/15/97  edwardp   Created.




// Includes


#include "stdinc.h"
#include "persist.h"
#include "cache.h"
#include "cdfidl.h"
#include "xmlutil.h"
#include "dll.h"


// Cache functions.


//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// *** Cache_Initialize ***

//   Prepare the XML document cache for use.


void
Cache_Initialize(
    void
)
{
    ASSERT(NULL == g_pCache);

    InitializeCriticalSection(&g_csCache);

    return;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// *** Cache_Initialize ***

//   Deactivate the cache.


void
Cache_Deinitialize(
    void
)
{
    // BUGBUG: MSXML has gone away at this point
    // Cache_FreeAll();

    DeleteCriticalSection(&g_csCache);

    return;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// *** Cache_EnterWriteLock ***

//    Obtain exclusive use of the XML document cache.


void
Cache_EnterWriteLock(
    void
)
{
    EnterCriticalSection(&g_csCache);

    return;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// *** Cache_EnterWriteLock ***

//    Release exclusive use of the XML document cache.


void
Cache_LeaveWriteLock(
    void
)
{
    LeaveCriticalSection(&g_csCache);

    return;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// *** Cache_EnterReadLock ***

//    Exclude writes to the the items list.  Currently this also excludes other
//    reads.  If need be this can be modified to allow multiple reads while
//    still excluding writes.


void
Cache_EnterReadLock(
    void
)
{
    EnterCriticalSection(&g_csCache);

    return;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// *** Cache_LeaveReadLock ***

//    Release a read hold on the use of the XML document cache.


void
Cache_LeaveReadLock(
    void
)
{
    LeaveCriticalSection(&g_csCache);

    return;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// *** Cache_AddItem ***


// Description:
//     Add an xml document to the cache.

// Parameters:
//     [In]  szURL         - The URL of the cdf file.
//     [In]  pIXMLDocument - The already parsed xml document.

// Return:
//     S_OK if the document was added to the cache.
//     E_OUTOFMEMORY if the document couldn't be aded to the cache.

// Comments:
//     The xml document is AddRefed when inserted into the cache and
//     Released on removal from the cache.


HRESULT
Cache_AddItem(
    LPTSTR szURL,
    IXMLDocument* pIXMLDocument,
    DWORD dwParseFlags,
    FILETIME ftLastMod,
    DWORD dwCacheCount
)
{
    ASSERT(szURL);
    ASSERT(pIXMLDocument);

    Cache_EnterWriteLock();

    HRESULT hr;

    PCACHEITEM pNewItem = new CACHEITEM;

    if (pNewItem)
    {
        LPTSTR szURLCopy = (LPTSTR)new TCHAR[(StrLen(szURL) + 1)];

        if (szURLCopy)
        {

            // Limit the cache to one item by freeing all current items.


            Cache_FreeAll();


            // Remove an old cache entry for this url if it exists.


            // Check no longer needed since we just cleared the cache.
            /*IXMLDocument* pIXMLDocumentOld;

            if (SUCCEEDED(Cache_QueryItem(szURL, &pIXMLDocumentOld,
                                          PARSE_LOCAL)))
            {
                ASSERT(pIXMLDocumentOld);

                Cache_RemoveItem(szURL);
                pIXMLDocumentOld->Release();
            }*/

            StrCpy(szURLCopy, szURL);

            pIXMLDocument->AddRef();

            pNewItem->szURL         = szURLCopy;
            pNewItem->dwParseFlags  = dwParseFlags;
            pNewItem->ftLastMod     = ftLastMod;
            pNewItem->dwCacheCount  = dwCacheCount;
            pNewItem->pIXMLDocument = pIXMLDocument;


            // REVIEW:  Check for duplicate cache items?


            pNewItem->pNext = g_pCache;
            g_pCache = pNewItem;


            hr = S_OK;
        }
        else
        {
            delete pNewItem;

            hr = E_OUTOFMEMORY;
        }
    }
    else
    {
        hr = E_OUTOFMEMORY;
    }

    Cache_LeaveWriteLock();

    return hr;
}





BOOL
IsEmptyTime(
    FILETIME ft
)
{
    return (0 == ft.dwLowDateTime && 0 == ft.dwHighDateTime);
}

BOOL
IsEqualTime(
    FILETIME ft1,
    FILETIME ft2
)
{
    return ((ft1.dwLowDateTime == ft2.dwLowDateTime) &&
            (ft1.dwHighDateTime == ft2.dwHighDateTime));
}

void
Cache_RefreshItem(
    CACHEITEM* pItem,
    LPTSTR pszLocalFile,
    FILETIME ftLastMod
)
{
    ASSERT(pItem);


    // Try and parse the cdf from the wininet cache.


    IXMLDocument* pIXMLDocument;

    HRESULT hr;

    DLL_ForcePreloadDlls(PRELOAD_MSXML);

    hr = CoCreateInstance(CLSID_XMLDocument, NULL, CLSCTX_INPROC_SERVER, IID_IXMLDocument, (void**)&pIXMLDocument);
    BOOL bCoInit = FALSE;
    if ((CO_E_NOTINITIALIZED == hr || REGDB_E_IIDNOTREG == hr) && SUCCEEDED(CoInitialize(NULL)))
    {
        bCoInit = TRUE;
        hr = CoCreateInstance(CLSID_XMLDocument, NULL, CLSCTX_INPROC_SERVER, IID_IXMLDocument, (void**)&pIXMLDocument);
    }

    if (SUCCEEDED(hr))
    {
        ASSERT(pIXMLDocument);

        hr = XML_SynchronousParse(pIXMLDocument, pszLocalFile);

        if (FAILED(hr))
            pIXMLDocument->Release();
    }

    if (bCoInit)
        CoUninitialize();


    // If the new cdf was parsed, replace the old one.


    if (SUCCEEDED(hr))
    {
        pItem->pIXMLDocument->Release();
        pItem->pIXMLDocument = pIXMLDocument;
        pItem->ftLastMod = ftLastMod;
    }

    return;
}

BOOL
Cache_IsItemFresh(
    CACHEITEM* pItem,
    DWORD dwParseFlags
)
{
    ASSERT(pItem);

    BOOL  fRet;
    DWORD dwCurrentCacheCount = g_dwCacheCount;


    // If the caller asked for "Net" quality data and we only have "Local" data
    // then throw the "Local" data away.  The resultant cache miss will cause
    // the caller to pick up fresher data.


    if ((dwParseFlags & PARSE_NET) && (pItem->dwParseFlags & PARSE_LOCAL))
    {
        fRet = FALSE;
    }
    else
    {
        fRet = TRUE;


        // If the global cache counter is greater than the counter for this
        // item, then a cdf has been added to the cache.


        if (dwCurrentCacheCount > pItem->dwCacheCount)
        {

            // Get the last mod time from the the cdf in the wininet cache.


            FILETIME ftLastMod;
            TCHAR    szLocalFile[MAX_PATH];

            if (SUCCEEDED(URLGetLocalFileName(pItem->szURL, szLocalFile,
                                ARRAYSIZE(szLocalFile), &ftLastMod)))
            {

                //  If the last mod times are different then the cdf in the
                //  wininet cache is newer, pick it up.
                //  If there are no last modified times then do the conservative
                //  thing and pick up the cdf from the wininet cache.


                if ((IsEmptyTime(ftLastMod) && IsEmptyTime(pItem->ftLastMod)) ||
                    !IsEqualTime(ftLastMod, pItem->ftLastMod))
                {
                    Cache_RefreshItem(pItem, szLocalFile, ftLastMod);
                }
            }

            pItem->dwCacheCount = dwCurrentCacheCount;
        }
    }

    return fRet;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// *** Cache_QueryItem ***


// Description:
//     Returns a xml document from the cache if it is found.

// Parameters:
//     [In]  szURL          - The URL associated with the xml document.
//     [Out] ppIXMLDocument - A pointer that receives the xml document.

// Return:
//     S_OK if the document associtaed with the given URL is found in the cache.
//     E_FAIL if the document isn't in the cache.

// Comments:
//     The returned pointer is AddRefed.  The caller isresposible for releasing
//     this pointer.


HRESULT
Cache_QueryItem(
    LPTSTR szURL,
    IXMLDocument** ppIXMLDocument,
    DWORD dwParseFlags
)
{
    ASSERT(szURL);
    ASSERT(ppIXMLDocument);

    HRESULT hr = E_FAIL;

    Cache_EnterReadLock();

    PCACHEITEM pItem = g_pCache;


    // REVIEW: Use CompareUrl from shlwapip?


    while (pItem && !StrEql(szURL, pItem->szURL))
        pItem = pItem->pNext;

    if (pItem)
    {
        if (Cache_IsItemFresh(pItem, dwParseFlags))
        {
            ASSERT(pItem->pIXMLDocument);

            pItem->pIXMLDocument->AddRef();

            *ppIXMLDocument = pItem->pIXMLDocument;

            hr = S_OK;
        }
        else
        {
            Cache_RemoveItem(szURL);
        }

    }

    Cache_LeaveReadLock();

    ASSERT(SUCCEEDED(hr) && ppIXMLDocument || FAILED(hr));

    return hr;
}

//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// *** Cache_FreeAll ***


// Description:
//     Frees all items from the xml document cache.

// Parameters:
//     None.

// Return:
//     None.

// Comments:
//     Frees all memory held in the xml document cache.


void
Cache_FreeAll(
    void
)
{
    Cache_EnterWriteLock();

    PCACHEITEM pItem = g_pCache;
    g_pCache = NULL;

    Cache_LeaveWriteLock();

    while (pItem)
    {
        PCACHEITEM pNext = pItem->pNext;

        ASSERT(pItem->szURL);
        ASSERT(pItem->pIXMLDocument);

        pItem->pIXMLDocument->Release();

        delete [] pItem->szURL;
        delete pItem;

        pItem = pNext;
    }

    return;
}
//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\

// *** Cache_FreeItem ***


// Description:
//     Frees item associated with given URL from the xml document cache.

// Parameters:
//     LPTSTR szURL

// Return:
//     HRESULT S_OK if item in cache and deleted, E_FAIL if item not in cache


HRESULT
Cache_RemoveItem(
    LPCTSTR szURL
)
{
    ASSERT(szURL);

    HRESULT hr;

    Cache_EnterWriteLock();

    PCACHEITEM pItem = g_pCache;
    PCACHEITEM pItemPrev = NULL;


    // REVIEW: Use CompareUrl from slwapip?.


    while (pItem && !StrEql(szURL, pItem->szURL))
    {
        pItemPrev = pItem;
        pItem = pItem->pNext;
    }

    if (pItem)
    {
        ASSERT(pItem->pIXMLDocument);

        if (pItemPrev)
        {
            pItemPrev->pNext = pItem->pNext;
        }
        else
        {
            g_pCache = pItem->pNext; // handle remove first item case
        }

        pItem->pIXMLDocument->Release();
        delete [] pItem->szURL;
        delete pItem;

        hr = S_OK;
    }
    else
    {
        hr = E_FAIL;
    }

    Cache_LeaveWriteLock();

    return hr;
}