/*

 * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY

 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR

 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 

 */

#include "config.h"

#include "WebKitDLL.h"

#include "WebHistory.h"

#include "CFDictionaryPropertyBag.h"

#include "IWebURLResponse.h"

#include "MarshallingHelpers.h"

#include "WebHistoryItem.h"

#include "WebKit.h"

#include "WebNotificationCenter.h"

#include "WebPreferences.h"

#include <CoreFoundation/CoreFoundation.h>

#include <WebCore/WebCoreHistory.h>

#pragma warning( push, 0 )

#include <wtf/Vector.h>

#pragma warning( pop )

CFStringRef DatesArrayKey = CFSTR("WebHistoryDates");

CFStringRef FileVersionKey = CFSTR("WebHistoryFileVersion");

const IID IID_IWebHistoryPrivate = { 0x3de04e59, 0x93f9, 0x4369, { 0x8b, 0x43, 0x97, 0x64, 0x58, 0xd7, 0xe3, 0x19 } };

#define currentFileVersion 1

class _WebCoreHistoryProvider : public WebCore::WebCoreHistoryProvider {

public:

    _WebCoreHistoryProvider(IWebHistory* history);

    ~_WebCoreHistoryProvider();

    virtual bool containsItemForURLLatin1(const char* latin1, unsigned int length);

    virtual bool containsItemForURLUnicode(const UChar* unicode, unsigned int length);

private:

    IWebHistory* m_history;

    IWebHistoryPrivate* m_historyPrivate;

};

static bool areEqualOrClose(double d1, double d2)

{

    double diff = d1-d2;

    return (diff < .000001 && diff > -.000001);

}

static CFDictionaryPropertyBag* createUserInfoFromArray(BSTR notificationStr, CFArrayRef arrayItem)

{

    RetainPtr<CFMutableDictionaryRef> dictionary(AdoptCF, 

        CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));

    RetainPtr<CFStringRef> key(AdoptCF, MarshallingHelpers::BSTRToCFStringRef(notificationStr));

    CFDictionaryAddValue(dictionary.get(), key.get(), arrayItem);

    CFDictionaryPropertyBag* result = CFDictionaryPropertyBag::createInstance();

    result->setDictionary(dictionary.get());

    return result;

}

static CFDictionaryPropertyBag* createUserInfoFromHistoryItem(BSTR notificationStr, IWebHistoryItem* item)

{

    // reference counting of item added to the array is managed by the CFArray value callbacks

    RetainPtr<CFArrayRef> itemList(AdoptCF, CFArrayCreate(0, (const void**) &item, 1, &MarshallingHelpers::kIUnknownArrayCallBacks));

    CFDictionaryPropertyBag* info = createUserInfoFromArray(notificationStr, itemList.get());

    return info;

}

static void releaseUserInfo(CFDictionaryPropertyBag* userInfo)

{

    // free the dictionary

    userInfo->setDictionary(0);

    int result = userInfo->Release();

    (void)result;

    ASSERT(result == 0);   // make sure no one else holds a reference to the userInfo.

}

// WebHistory -----------------------------------------------------------------

IWebHistory* WebHistory::m_optionalSharedHistory = 0;

WebHistory::WebHistory()

: m_refCount(0)

, m_preferences(0)

{

    gClassCount++;

    m_entriesByURL.adoptCF(CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &MarshallingHelpers::kIUnknownDictionaryValueCallBacks));

    m_datesWithEntries.adoptCF(CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks));

    m_entriesByDate.adoptCF(CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks));

    m_preferences = WebPreferences::sharedStandardPreferences();

}

WebHistory::~WebHistory()

{

    gClassCount--;

}

WebHistory* WebHistory::createInstance()

{

    WebHistory* instance = new WebHistory();

    instance->AddRef();

    return instance;

}

HRESULT WebHistory::postNotification(NotificationType notifyType, IPropertyBag* userInfo /*=0*/)

{

    IWebNotificationCenter* nc = WebNotificationCenter::defaultCenterInternal();

    HRESULT hr = nc->postNotificationName(getNotificationString(notifyType), static_cast<IWebHistory*>(this), userInfo);

    if (FAILED(hr))

        return hr;

    return S_OK;

}

BSTR WebHistory::getNotificationString(NotificationType notifyType)

{

    static BSTR keys[6] = {0};

    if (!keys[0]) {

        keys[0] = SysAllocString(WebHistoryItemsAddedNotification);

        keys[1] = SysAllocString(WebHistoryItemsRemovedNotification);

        keys[2] = SysAllocString(WebHistoryAllItemsRemovedNotification);

        keys[3] = SysAllocString(WebHistoryLoadedNotification);

        keys[4] = SysAllocString(WebHistoryItemsDiscardedWhileLoadingNotification);

        keys[5] = SysAllocString(WebHistorySavedNotification);

    }

    return keys[notifyType];

}

// IUnknown -------------------------------------------------------------------

HRESULT STDMETHODCALLTYPE WebHistory::QueryInterface(REFIID riid, void** ppvObject)

{

    *ppvObject = 0;

    if (IsEqualGUID(riid, CLSID_WebHistory))

        *ppvObject = this;

    else if (IsEqualGUID(riid, IID_IUnknown))

        *ppvObject = static_cast<IWebHistory*>(this);

    else if (IsEqualGUID(riid, IID_IWebHistory))

        *ppvObject = static_cast<IWebHistory*>(this);

    else if (IsEqualGUID(riid, IID_IWebHistoryPrivate))

        *ppvObject = static_cast<IWebHistoryPrivate*>(this);

    else

        return E_NOINTERFACE;

    AddRef();

    return S_OK;

}

ULONG STDMETHODCALLTYPE WebHistory::AddRef(void)

{

    return ++m_refCount;

}

ULONG STDMETHODCALLTYPE WebHistory::Release(void)

{

    ULONG newRef = --m_refCount;

    if (!newRef)

        delete(this);

    return newRef;

}

// IWebHistory ----------------------------------------------------------------

HRESULT STDMETHODCALLTYPE WebHistory::optionalSharedHistory( 

    /* [retval][out] */ IWebHistory** history)

{

    *history = m_optionalSharedHistory;

    if (m_optionalSharedHistory)

        m_optionalSharedHistory->AddRef();

    return S_OK;

}

HRESULT STDMETHODCALLTYPE WebHistory::setOptionalSharedHistory( 

    /* [in] */ IWebHistory* history)

{

    if (m_optionalSharedHistory) {

        m_optionalSharedHistory->Release();

        m_optionalSharedHistory = 0;        

    }

    _WebCoreHistoryProvider* coreHistory = 0;

    m_optionalSharedHistory = history;

    if (history) {

        history->AddRef();

        coreHistory = new _WebCoreHistoryProvider(history);

    }

    WebCore::WebCoreHistory::setHistoryProvider(coreHistory);

    return S_OK;

}

HRESULT STDMETHODCALLTYPE WebHistory::loadFromURL( 

    /* [in] */ BSTR url,

    /* [out] */ IWebError** error,

    /* [retval][out] */ BOOL* succeeded)

{

    HRESULT hr = S_OK;

    RetainPtr<CFMutableArrayRef> discardedItems(AdoptCF, 

        CFArrayCreateMutable(0, 0, &MarshallingHelpers::kIUnknownArrayCallBacks));

    RetainPtr<CFURLRef> urlRef(AdoptCF, MarshallingHelpers::BSTRToCFURLRef(url));

    hr = loadHistoryGutsFromURL(urlRef.get(), discardedItems.get(), error);

    if (FAILED(hr))

        goto exit;

    hr = postNotification(kWebHistoryLoadedNotification);

    if (FAILED(hr))

        goto exit;

    if (CFArrayGetCount(discardedItems.get()) > 0) {

        CFDictionaryPropertyBag* userInfo = createUserInfoFromArray(getNotificationString(kWebHistoryItemsDiscardedWhileLoadingNotification), discardedItems.get());

        hr = postNotification(kWebHistoryItemsDiscardedWhileLoadingNotification, userInfo);

        releaseUserInfo(userInfo);

        if (FAILED(hr))

            goto exit;

    }

exit:

    if (succeeded)

        *succeeded = SUCCEEDED(hr);

    return hr;

}

static CFDictionaryRef createHistoryListFromStream(CFReadStreamRef stream, CFPropertyListFormat format)

{

    return (CFDictionaryRef)CFPropertyListCreateFromStream(0, stream, 0, kCFPropertyListImmutable, &format, 0);

}

HRESULT WebHistory::loadHistoryGutsFromURL(CFURLRef url, CFMutableArrayRef discardedItems, IWebError** /*error*/) //FIXME

{

    CFPropertyListFormat format = kCFPropertyListBinaryFormat_v1_0 | kCFPropertyListXMLFormat_v1_0;

    HRESULT hr = S_OK;

    int numberOfItemsLoaded = 0;

    RetainPtr<CFReadStreamRef> stream(AdoptCF, CFReadStreamCreateWithFile(0, url));

    if (!stream) 

        return E_FAIL;

    if (!CFReadStreamOpen(stream.get())) 

        return E_FAIL;

    RetainPtr<CFDictionaryRef> historyList(AdoptCF, createHistoryListFromStream(stream.get(), format));

    CFReadStreamClose(stream.get());

    if (!historyList) 

        return E_FAIL;

    CFNumberRef fileVersionObject = (CFNumberRef)CFDictionaryGetValue(historyList.get(), FileVersionKey);

    int fileVersion;

    if (!CFNumberGetValue(fileVersionObject, kCFNumberIntType, &fileVersion)) 

        return E_FAIL;

    if (fileVersion > currentFileVersion) 

        return E_FAIL;

    CFArrayRef datesArray = (CFArrayRef)CFDictionaryGetValue(historyList.get(), DatesArrayKey);

    int itemCountLimit;

    hr = historyItemLimit(&itemCountLimit);

    if (FAILED(hr))

        return hr;

    CFAbsoluteTime limitDate;

    hr = ageLimitDate(&limitDate);

    if (FAILED(hr))

        return hr;

    bool ageLimitPassed = false;

    bool itemLimitPassed = false;

    CFIndex itemCount = CFArrayGetCount(datesArray);

    for (CFIndex i = 0; i < itemCount; ++i) {

        CFDictionaryRef itemAsDictionary = (CFDictionaryRef)CFArrayGetValueAtIndex(datesArray, i);

        COMPtr<WebHistoryItem> item(AdoptCOM, WebHistoryItem::createInstance());

        hr = item->initFromDictionaryRepresentation((void*)itemAsDictionary);

        if (FAILED(hr))

            return hr;

        // item without URL is useless; data on disk must have been bad; ignore

        BOOL hasURL;

        hr = item->hasURLString(&hasURL);

        if (FAILED(hr))

            return hr;

        if (hasURL) {

            // Test against date limit. Since the items are ordered newest to oldest, we can stop comparing

            // once we've found the first item that's too old.

            if (!ageLimitPassed) {

                DATE lastVisitedTime;

                hr = item->lastVisitedTimeInterval(&lastVisitedTime);

                if (FAILED(hr))

                    return hr;

                if (timeToDate(MarshallingHelpers::DATEToCFAbsoluteTime(lastVisitedTime)) <= limitDate)

                    ageLimitPassed = true;

            }

            if (ageLimitPassed || itemLimitPassed)

                CFArrayAppendValue(discardedItems, item.get());

            else {

                addItem(item.get()); // ref is added inside addItem

                ++numberOfItemsLoaded;

                if (numberOfItemsLoaded == itemCountLimit)

                    itemLimitPassed = true;

            }

        }

    }

    return hr;

}

HRESULT STDMETHODCALLTYPE WebHistory::saveToURL( 

    /* [in] */ BSTR url,

    /* [out] */ IWebError** error,

    /* [retval][out] */ BOOL* succeeded)

{

    HRESULT hr = S_OK;

    RetainPtr<CFURLRef> urlRef(AdoptCF, MarshallingHelpers::BSTRToCFURLRef(url));

    hr = saveHistoryGuts(urlRef.get(), error);

    if (succeeded)

        *succeeded = SUCCEEDED(hr);

    if (SUCCEEDED(hr))

        hr = postNotification(kWebHistorySavedNotification);

    return hr;

}

HRESULT WebHistory::saveHistoryGuts(CFURLRef url, IWebError** error)

{

    HRESULT hr = S_OK;

    // FIXME:  Correctly report error when new API is ready.

    if (error)

        *error = 0;

    RetainPtr<CFWriteStreamRef> stream(AdoptCF, CFWriteStreamCreateWithFile(kCFAllocatorDefault, url));

    if (!stream) 

        return E_FAIL;

    CFMutableArrayRef rawEntries;

    hr = datesArray(&rawEntries);

    if (FAILED(hr))

        return hr;

    RetainPtr<CFMutableArrayRef> entries(AdoptCF, rawEntries);

    // create the outer dictionary

    CFTypeRef keys[2];

    CFTypeRef values[2];

    keys[0]   = DatesArrayKey;

    values[0] = entries.get();

    keys[1]   = FileVersionKey;

    int version = currentFileVersion;

    RetainPtr<CFNumberRef> versionCF(AdoptCF, CFNumberCreate(0, kCFNumberIntType, &version));

    values[1] = versionCF.get();

    RetainPtr<CFDictionaryRef> dictionary(AdoptCF, 

        CFDictionaryCreate(0, keys, values, 2, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));

    if (!CFWriteStreamOpen(stream.get())) 

        return E_FAIL;

    if (!CFPropertyListWriteToStream(dictionary.get(), stream.get(), kCFPropertyListXMLFormat_v1_0, 0))

        hr = E_FAIL;

    CFWriteStreamClose(stream.get());

    return hr;

}

HRESULT WebHistory::datesArray(CFMutableArrayRef* datesArray)

{

    HRESULT hr = S_OK;

    RetainPtr<CFMutableArrayRef> result(AdoptCF, CFArrayCreateMutable(0, 0, &kCFTypeArrayCallBacks));

    // for each date with entries

    int dateCount = CFArrayGetCount(m_entriesByDate.get());

    for (int i = 0; i < dateCount; ++i) {

        // get the entries for that date

        CFArrayRef entries = (CFArrayRef)CFArrayGetValueAtIndex(m_entriesByDate.get(), i);

        int entriesCount = CFArrayGetCount(entries);

        for (int j = entriesCount - 1; j >= 0; --j) {

            IWebHistoryItem* item = (IWebHistoryItem*) CFArrayGetValueAtIndex(entries, j);

            IWebHistoryItemPrivate* webHistoryItem;

            hr = item->QueryInterface(IID_IWebHistoryItemPrivate, (void**)&webHistoryItem);

            if (FAILED(hr))

                return E_FAIL;

            CFDictionaryRef itemDict;

            hr = webHistoryItem->dictionaryRepresentation((void**)&itemDict);

            webHistoryItem->Release();

            if (FAILED(hr))

                return E_FAIL;

            CFArrayAppendValue(result.get(), itemDict);

            CFRelease(itemDict);

        }

    }

    if (SUCCEEDED(hr))

        *datesArray = result.releaseRef();

    return hr;

}

HRESULT STDMETHODCALLTYPE WebHistory::addItems( 

    /* [in] */ int itemCount,

    /* [in] */ IWebHistoryItem** items)

{

    // There is no guarantee that the incoming entries are in any particular

    // order, but if this is called with a set of entries that were created by

    // iterating through the results of orderedLastVisitedDays and orderedItemsLastVisitedOnDay

    // then they will be ordered chronologically from newest to oldest. We can make adding them

    // faster (fewer compares) by inserting them from oldest to newest.

    HRESULT hr;

    for (int i = itemCount - 1; i >= 0; --i) {

        hr = addItem(items[i]);

        if (FAILED(hr))

            return hr;

    }

    return S_OK;

}

HRESULT STDMETHODCALLTYPE WebHistory::removeItems( 

    /* [in] */ int itemCount,

    /* [in] */ IWebHistoryItem** items)

{

    HRESULT hr;

    for (int i = 0; i < itemCount; ++i) {

        hr = removeItem(items[i]);

        if (FAILED(hr))

            return hr;

    }

    return S_OK;

}

HRESULT STDMETHODCALLTYPE WebHistory::removeAllItems( void)

{

    CFArrayRemoveAllValues(m_entriesByDate.get());

    CFArrayRemoveAllValues(m_datesWithEntries.get());

    CFDictionaryRemoveAllValues(m_entriesByURL.get());

    return postNotification(kWebHistoryAllItemsRemovedNotification);

}

HRESULT STDMETHODCALLTYPE WebHistory::orderedLastVisitedDays( 

    /* [out][in] */ int* count,

    /* [in] */ DATE* calendarDates)

{

    int dateCount = CFArrayGetCount(m_datesWithEntries.get());

    if (!calendarDates) {

        *count = dateCount;

        return S_OK;

    }

    if (*count < dateCount) {

        *count = dateCount;

        return E_FAIL;

    }

    *count = dateCount;

    for (int i = 0; i < dateCount; i++) {

        CFNumberRef absoluteTimeNumberRef = (CFNumberRef)CFArrayGetValueAtIndex(m_datesWithEntries.get(), i);

        CFAbsoluteTime absoluteTime;

        if (!CFNumberGetValue(absoluteTimeNumberRef, kCFNumberDoubleType, &absoluteTime))

            return E_FAIL;

        calendarDates[i] = MarshallingHelpers::CFAbsoluteTimeToDATE(absoluteTime);

    }

    return S_OK;

}

HRESULT STDMETHODCALLTYPE WebHistory::orderedItemsLastVisitedOnDay( 

    /* [out][in] */ int* count,

    /* [in] */ IWebHistoryItem** items,

    /* [in] */ DATE calendarDate)

{

    int index;

    if (!findIndex(&index, MarshallingHelpers::DATEToCFAbsoluteTime(calendarDate))) {

        *count = 0;

        return 0;

    }

    CFArrayRef entries = (CFArrayRef)CFArrayGetValueAtIndex(m_entriesByDate.get(), index);

    if (!entries) {

        *count = 0;

        return 0;

    }

    int newCount = CFArrayGetCount(entries);

    if (!items) {

        *count = newCount;

        return S_OK;

    }

    if (*count < newCount) {

        *count = newCount;

        return E_FAIL;

    }