/*

 * 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 "MemoryStream.h"

#include "WebKit.h"

#include "MarshallingHelpers.h"

#include "WebHistoryItem.h"

#include "WebKit.h"

#include "WebNotificationCenter.h"

#include "WebPreferences.h"

#include <CoreFoundation/CoreFoundation.h>

#pragma warning( push, 0 )

#include <WebCore/HistoryItem.h>

#include <WebCore/HistoryPropertyList.h>

#include <WebCore/KURL.h>

#include <WebCore/PageGroup.h>

#include <WebCore/SharedBuffer.h>

#pragma warning( pop )

#include <functional>

#include <wtf/StdLibExtras.h>

#include <wtf/Vector.h>

using namespace WebCore;

using namespace std;

CFStringRef DatesArrayKey = CFSTR("WebHistoryDates");

CFStringRef FileVersionKey = CFSTR("WebHistoryFileVersion");

#define currentFileVersion 1

class WebHistoryWriter : public HistoryPropertyListWriter {

public:

    WebHistoryWriter(const WebHistory::DateToEntriesMap&);

private:

    virtual void writeHistoryItems(BinaryPropertyListObjectStream&);

    const WebHistory::DateToEntriesMap& m_entriesByDate;

    Vector<WebHistory::DateKey> m_dateKeys;

};

WebHistoryWriter::WebHistoryWriter(const WebHistory::DateToEntriesMap& entriesByDate)

    : m_entriesByDate(entriesByDate)

{

    copyKeysToVector(m_entriesByDate, m_dateKeys);

    sort(m_dateKeys.begin(), m_dateKeys.end());

}

void WebHistoryWriter::writeHistoryItems(BinaryPropertyListObjectStream& stream)

{

    for (int dateIndex = m_dateKeys.size() - 1; dateIndex >= 0; --dateIndex) {

        // get the entries for that date

        CFArrayRef entries = m_entriesByDate.get(m_dateKeys[dateIndex]).get();

        CFIndex entriesCount = CFArrayGetCount(entries);

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

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

            COMPtr<WebHistoryItem> webItem(Query, item);

            if (!webItem)

                continue;

            writeHistoryItem(stream, webItem->historyItem());

        }

    }

}

static bool areEqualOrClose(double d1, double d2)

{

    double diff = d1-d2;

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

}

static COMPtr<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);

    COMPtr<CFDictionaryPropertyBag> result = CFDictionaryPropertyBag::createInstance();

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

    return result;

}

static COMPtr<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));

    COMPtr<CFDictionaryPropertyBag> info = createUserInfoFromArray(notificationStr, itemList.get());

    return info;

}

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

WebHistory::WebHistory()

: m_refCount(0)

, m_preferences(0)

{

    gClassCount++;

    gClassNameCount.add("WebHistory");

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

    m_preferences = WebPreferences::sharedStandardPreferences();

}

WebHistory::~WebHistory()

{

    gClassCount--;

    gClassNameCount.remove("WebHistory");

}

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 ----------------------------------------------------------------

static inline COMPtr<WebHistory>& sharedHistoryStorage()

{

    DEFINE_STATIC_LOCAL(COMPtr<WebHistory>, sharedHistory, ());

    return sharedHistory;

}

WebHistory* WebHistory::sharedHistory()

{

    return sharedHistoryStorage().get();

}

HRESULT STDMETHODCALLTYPE WebHistory::optionalSharedHistory( 

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

{

    *history = sharedHistory();

    if (*history)

        (*history)->AddRef();

    return S_OK;

}

HRESULT STDMETHODCALLTYPE WebHistory::setOptionalSharedHistory( 

    /* [in] */ IWebHistory* history)

{

    if (sharedHistoryStorage() == history)

        return S_OK;

    sharedHistoryStorage().query(history);

    PageGroup::setShouldTrackVisitedLinks(sharedHistoryStorage());

    PageGroup::removeAllVisitedLinks();

    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) {

        COMPtr<CFDictionaryPropertyBag> userInfo = createUserInfoFromArray(getNotificationString(kWebHistoryItemsDiscardedWhileLoadingNotification), discardedItems.get());

        hr = postNotification(kWebHistoryItemsDiscardedWhileLoadingNotification, userInfo.get());

        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 {

                bool added;

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

                if (added)

                    ++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<CFDataRef> data = this->data();

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

    if (!stream) 

        return E_FAIL;

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

        return E_FAIL;

    const UInt8* dataPtr = CFDataGetBytePtr(data.get());

    CFIndex length = CFDataGetLength(data.get());

    while (length) {

        CFIndex bytesWritten = CFWriteStreamWrite(stream.get(), dataPtr, length);

        if (bytesWritten <= 0) {

            hr = E_FAIL;

            break;

        }

        dataPtr += bytesWritten;

        length -= bytesWritten;

    }

    CFWriteStreamClose(stream.get());

    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], false, 0);

        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)

{

    m_entriesByDate.clear();

    m_orderedLastVisitedDays.clear();

    CFIndex itemCount = CFDictionaryGetCount(m_entriesByURL.get());

    Vector<IWebHistoryItem*> itemsVector(itemCount);

    CFDictionaryGetKeysAndValues(m_entriesByURL.get(), 0, (const void**)itemsVector.data());

    RetainPtr<CFArrayRef> allItems(AdoptCF, CFArrayCreate(kCFAllocatorDefault, (const void**)itemsVector.data(), itemCount, &MarshallingHelpers::kIUnknownArrayCallBacks));

    CFDictionaryRemoveAllValues(m_entriesByURL.get());

    PageGroup::removeAllVisitedLinks();

    COMPtr<CFDictionaryPropertyBag> userInfo = createUserInfoFromArray(getNotificationString(kWebHistoryAllItemsRemovedNotification), allItems.get());

    return postNotification(kWebHistoryAllItemsRemovedNotification, userInfo.get());

}

HRESULT STDMETHODCALLTYPE WebHistory::orderedLastVisitedDays( 

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

    /* [in] */ DATE* calendarDates)

{

    int dateCount = m_entriesByDate.size();

    if (!calendarDates) {

        *count = dateCount;

        return S_OK;

    }

    if (*count < dateCount) {

        *count = dateCount;

        return E_FAIL;

    }

    *count = dateCount;

    if (!m_orderedLastVisitedDays) {

        m_orderedLastVisitedDays.set(new DATE[dateCount]);

        DateToEntriesMap::const_iterator::Keys end = m_entriesByDate.end().keys();

        int i = 0;

        for (DateToEntriesMap::const_iterator::Keys it = m_entriesByDate.begin().keys(); it != end; ++it, ++i)

            m_orderedLastVisitedDays[i] = MarshallingHelpers::CFAbsoluteTimeToDATE(*it);

        // Use std::greater to sort the days in descending order (i.e., most-recent first).

        sort(m_orderedLastVisitedDays.get(), m_orderedLastVisitedDays.get() + dateCount, greater<DATE>());

    }

    memcpy(calendarDates, m_orderedLastVisitedDays.get(), dateCount * sizeof(DATE));

    return S_OK;

}

HRESULT STDMETHODCALLTYPE WebHistory::orderedItemsLastVisitedOnDay( 

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

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

    /* [in] */ DATE calendarDate)

{

    DateKey dateKey;

    if (!findKey(&dateKey, MarshallingHelpers::DATEToCFAbsoluteTime(calendarDate))) {

        *count = 0;

        return 0;

    }

    CFArrayRef entries = m_entriesByDate.get(dateKey).get();

    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;

    }

    *count = newCount;

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

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

        item->AddRef();

        items[i] = item;

    }

    return S_OK;

}