/*
 * Copyright 2010-2014 Haiku Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Christophe Huriaux, c.huriaux@gmail.com
 *              Hamish Morrison, hamishm53@gmail.com
 */


#include <new>
#include <stdio.h>

#include <HashMap.h>
#include <HashString.h>
#include <Message.h>
#include <NetworkCookieJar.h>

#include "NetworkCookieJarPrivate.h"

using namespace BPrivate::Network;


// #define TRACE_COOKIE
#ifdef TRACE_COOKIE
#       define TRACE(x...) printf(x)
#else
#       define TRACE(x...) ;
#endif


const char* kArchivedCookieMessageName = "be:cookie";


BNetworkCookieJar::BNetworkCookieJar()
        :
        fCookieHashMap(new(std::nothrow) PrivateHashMap())
{
}


BNetworkCookieJar::BNetworkCookieJar(const BNetworkCookieJar& other)
        :
        fCookieHashMap(new(std::nothrow) PrivateHashMap())
{
        *this = other;
}


BNetworkCookieJar::BNetworkCookieJar(const BNetworkCookieList& otherList)
        :
        fCookieHashMap(new(std::nothrow) PrivateHashMap())
{
        AddCookies(otherList);
}


BNetworkCookieJar::BNetworkCookieJar(BMessage* archive)
        :
        fCookieHashMap(new(std::nothrow) PrivateHashMap())
{
        BMessage extractedCookie;

        for (int32 i = 0; archive->FindMessage(kArchivedCookieMessageName, i,
                        &extractedCookie) == B_OK; i++) {
                BNetworkCookie* heapCookie
                        = new(std::nothrow) BNetworkCookie(&extractedCookie);

                if (heapCookie == NULL)
                        break;

                if (AddCookie(heapCookie) != B_OK) {
                        delete heapCookie;
                        continue;
                }
        }
}


BNetworkCookieJar::~BNetworkCookieJar()
{
        for (Iterator it = GetIterator(); it.Next() != NULL;)
                delete it.Remove();

        fCookieHashMap->Lock();

        PrivateHashMap::Iterator it = fCookieHashMap->GetIterator();
        while (it.HasNext()) {
                BNetworkCookieList* list = it.Next().value;
                list->LockForWriting();
                delete list;
        }

        delete fCookieHashMap;
}


// #pragma mark Add cookie to cookie jar


status_t
BNetworkCookieJar::AddCookie(const BNetworkCookie& cookie)
{
        BNetworkCookie* heapCookie = new(std::nothrow) BNetworkCookie(cookie);
        if (heapCookie == NULL)
                return B_NO_MEMORY;

        status_t result = AddCookie(heapCookie);
        if (result != B_OK)
                delete heapCookie;

        return result;
}


status_t
BNetworkCookieJar::AddCookie(const BString& cookie, const BUrl& referrer)
{
        BNetworkCookie* heapCookie = new(std::nothrow) BNetworkCookie(cookie,
                referrer);

        if (heapCookie == NULL)
                return B_NO_MEMORY;

        status_t result = AddCookie(heapCookie);

        if (result != B_OK)
                delete heapCookie;

        return result;
}


status_t
BNetworkCookieJar::AddCookie(BNetworkCookie* cookie)
{
        if (fCookieHashMap == NULL)
                return B_NO_MEMORY;

        if (cookie == NULL || !cookie->IsValid())
                return B_BAD_VALUE;

        HashString key(cookie->Domain());

        if (!fCookieHashMap->Lock())
                return B_ERROR;

        // Get the cookies for the requested domain, or create a new list if there
        // isn't one yet.
        BNetworkCookieList* list = fCookieHashMap->Get(key);
        if (list == NULL) {
                list = new(std::nothrow) BNetworkCookieList();

                if (list == NULL) {
                        fCookieHashMap->Unlock();
                        return B_NO_MEMORY;
                }

                if (fCookieHashMap->Put(key, list) != B_OK) {
                        fCookieHashMap->Unlock();
                        delete list;
                        return B_NO_MEMORY;
                }
        }

        if (list->LockForWriting() != B_OK) {
                fCookieHashMap->Unlock();
                return B_ERROR;
        }

        fCookieHashMap->Unlock();

        // Remove any cookie with the same key as the one we're trying to add (it
        // replaces/updates them)
        for (int32 i = 0; i < list->CountItems(); i++) {
                const BNetworkCookie* c = list->ItemAt(i);

                if (c->Name() == cookie->Name() && c->Path() == cookie->Path()) {
                        list->RemoveItemAt(i);
                        break;
                }
        }

        // If the cookie has an expiration date in the past, stop here: we
        // effectively deleted a cookie.
        if (cookie->ShouldDeleteNow()) {
                TRACE("Remove cookie: %s\n", cookie->RawCookie(true).String());
                delete cookie;
        } else {
                // Make sure the cookie has cached the raw string and expiration date
                // string, so it is now actually immutable. This way we can safely
                // read the cookie data from multiple threads without any locking.
                const BString& raw = cookie->RawCookie(true);
                (void)raw;

                TRACE("Add cookie: %s\n", raw.String());

                // Keep the list sorted by path length (longest first). This makes sure
                // that cookies for most specific paths are returned first when
                // iterating the cookie jar.
                int32 i;
                for (i = 0; i < list->CountItems(); i++) {
                        const BNetworkCookie* current = list->ItemAt(i);
                        if (current->Path().Length() < cookie->Path().Length())
                                break;
                }
                list->AddItem(cookie, i);
        }

        list->Unlock();

        return B_OK;
}


status_t
BNetworkCookieJar::AddCookies(const BNetworkCookieList& cookies)
{
        for (int32 i = 0; i < cookies.CountItems(); i++) {
                const BNetworkCookie* cookiePtr = cookies.ItemAt(i);

                // Using AddCookie by reference in order to avoid multiple
                // cookie jar share the same cookie pointers
                status_t result = AddCookie(*cookiePtr);
                if (result != B_OK)
                        return result;
        }

        return B_OK;
}


// #pragma mark Purge useless cookies


uint32
BNetworkCookieJar::DeleteOutdatedCookies()
{
        int32 deleteCount = 0;
        const BNetworkCookie* cookiePtr;

        for (Iterator it = GetIterator(); (cookiePtr = it.Next()) != NULL;) {
                if (cookiePtr->ShouldDeleteNow()) {
                        delete it.Remove();
                        deleteCount++;
                }
        }

        return deleteCount;
}


uint32
BNetworkCookieJar::PurgeForExit()
{
        int32 deleteCount = 0;
        const BNetworkCookie* cookiePtr;

        for (Iterator it = GetIterator(); (cookiePtr = it.Next()) != NULL;) {
                if (cookiePtr->ShouldDeleteAtExit()) {
                        delete it.Remove();
                        deleteCount++;
                }
        }

        return deleteCount;
}


// #pragma mark BArchivable interface


status_t
BNetworkCookieJar::Archive(BMessage* into, bool deep) const
{
        status_t error = BArchivable::Archive(into, deep);

        if (error == B_OK) {
                const BNetworkCookie* cookiePtr;

                for (Iterator it = GetIterator(); (cookiePtr = it.Next()) != NULL;) {
                        BMessage subArchive;

                        error = cookiePtr->Archive(&subArchive, deep);
                        if (error != B_OK)
                                return error;

                        error = into->AddMessage(kArchivedCookieMessageName, &subArchive);
                        if (error != B_OK)
                                return error;
                }
        }

        return error;
}


BArchivable*
BNetworkCookieJar::Instantiate(BMessage* archive)
{
        if (archive->HasMessage(kArchivedCookieMessageName))
                return new(std::nothrow) BNetworkCookieJar(archive);

        return NULL;
}


// #pragma mark BFlattenable interface


bool
BNetworkCookieJar::IsFixedSize() const
{
        // Flattened size vary
        return false;
}


type_code
BNetworkCookieJar::TypeCode() const
{
        // TODO: Add a B_COOKIEJAR_TYPE
        return B_ANY_TYPE;
}


ssize_t
BNetworkCookieJar::FlattenedSize() const
{
        _DoFlatten();
        return fFlattened.Length() + 1;
}


status_t
BNetworkCookieJar::Flatten(void* buffer, ssize_t size) const
{
        if (FlattenedSize() > size)
                return B_ERROR;

        fFlattened.CopyInto(reinterpret_cast<char*>(buffer), 0,
                fFlattened.Length());
        reinterpret_cast<char*>(buffer)[fFlattened.Length()] = 0;

        return B_OK;
}


bool
BNetworkCookieJar::AllowsTypeCode(type_code) const
{
        // TODO
        return false;
}


status_t
BNetworkCookieJar::Unflatten(type_code, const void* buffer, ssize_t size)
{
        BString flattenedCookies;
        flattenedCookies.SetTo(reinterpret_cast<const char*>(buffer), size);

        while (flattenedCookies.Length() > 0) {
                BNetworkCookie tempCookie;
                BString tempCookieLine;

                int32 endOfLine = flattenedCookies.FindFirst('\n', 0);
                if (endOfLine == -1)
                        tempCookieLine = flattenedCookies;
                else {
                        flattenedCookies.MoveInto(tempCookieLine, 0, endOfLine);
                        flattenedCookies.Remove(0, 1);
                }

                if (tempCookieLine.Length() != 0 && tempCookieLine[0] != '#') {
                        for (int32 field = 0; field < 7; field++) {
                                BString tempString;

                                int32 endOfField = tempCookieLine.FindFirst('\t', 0);
                                if (endOfField == -1)
                                        tempString = tempCookieLine;
                                else {
                                        tempCookieLine.MoveInto(tempString, 0, endOfField);
                                        tempCookieLine.Remove(0, 1);
                                }

                                switch (field) {
                                        case 0:
                                                tempCookie.SetDomain(tempString);
                                                break;

                                        case 1:
                                                // TODO: Useless field ATM
                                                break;

                                        case 2:
                                                tempCookie.SetPath(tempString);
                                                break;

                                        case 3:
                                                tempCookie.SetSecure(tempString == "TRUE");
                                                break;

                                        case 4:
                                                tempCookie.SetExpirationDate(atoi(tempString));
                                                break;

                                        case 5:
                                                tempCookie.SetName(tempString);
                                                break;

                                        case 6:
                                                tempCookie.SetValue(tempString);
                                                break;
                                } // switch
                        } // for loop

                        AddCookie(tempCookie);
                }
        }

        return B_OK;
}


BNetworkCookieJar&
BNetworkCookieJar::operator=(const BNetworkCookieJar& other)
{
        if (&other == this)
                return *this;

        for (Iterator it = GetIterator(); it.Next() != NULL;)
                delete it.Remove();

        BArchivable::operator=(other);
        BFlattenable::operator=(other);

        fFlattened = other.fFlattened;

        delete fCookieHashMap;
        fCookieHashMap = new(std::nothrow) PrivateHashMap();

        for (Iterator it = other.GetIterator(); it.HasNext();) {
                const BNetworkCookie* cookie = it.Next();
                AddCookie(*cookie); // Pass by reference so the cookie is copied.
        }

        return *this;
}


// #pragma mark Iterators


BNetworkCookieJar::Iterator
BNetworkCookieJar::GetIterator() const
{
        return BNetworkCookieJar::Iterator(this);
}


BNetworkCookieJar::UrlIterator
BNetworkCookieJar::GetUrlIterator(const BUrl& url) const
{
        if (!url.HasPath()) {
                BUrl copy(url);
                copy.SetPath("/");
                return BNetworkCookieJar::UrlIterator(this, copy);
        }

        return BNetworkCookieJar::UrlIterator(this, url);
}


void
BNetworkCookieJar::_DoFlatten() const
{
        fFlattened.Truncate(0);

        const BNetworkCookie* cookiePtr;
        for (Iterator it = GetIterator(); (cookiePtr = it.Next()) != NULL;) {
                fFlattened      << cookiePtr->Domain() << '\t' << "TRUE" << '\t'
                        << cookiePtr->Path() << '\t'
                        << (cookiePtr->Secure()?"TRUE":"FALSE") << '\t'
                        << (int32)cookiePtr->ExpirationDate() << '\t'
                        << cookiePtr->Name() << '\t' << cookiePtr->Value() << '\n';
        }
}


// #pragma mark Iterator


BNetworkCookieJar::Iterator::Iterator(const Iterator& other)
        :
        fCookieJar(other.fCookieJar),
        fIterator(NULL),
        fLastList(NULL),
        fList(NULL),
        fElement(NULL),
        fLastElement(NULL),
        fIndex(0)
{
        fIterator = new(std::nothrow) PrivateIterator(
                fCookieJar->fCookieHashMap->GetIterator());

        _FindNext();
}


BNetworkCookieJar::Iterator::Iterator(const BNetworkCookieJar* cookieJar)
        :
        fCookieJar(const_cast<BNetworkCookieJar*>(cookieJar)),
        fIterator(NULL),
        fLastList(NULL),
        fList(NULL),
        fElement(NULL),
        fLastElement(NULL),
        fIndex(0)
{
        fIterator = new(std::nothrow) PrivateIterator(
                fCookieJar->fCookieHashMap->GetIterator());

        // Locate first cookie
        _FindNext();
}


BNetworkCookieJar::Iterator::~Iterator()
{
        if (fList != NULL)
                fList->Unlock();
        if (fLastList != NULL)
                fLastList->Unlock();

        delete fIterator;
}


BNetworkCookieJar::Iterator&
BNetworkCookieJar::Iterator::operator=(const Iterator& other)
{
        if (this == &other)
                return *this;

        delete fIterator;
        if (fList != NULL)
                fList->Unlock();

        fCookieJar = other.fCookieJar;
        fIterator = NULL;
        fLastList = NULL;
        fList = NULL;
        fElement = NULL;
        fLastElement = NULL;
        fIndex = 0;

        fIterator = new(std::nothrow) PrivateIterator(
                fCookieJar->fCookieHashMap->GetIterator());

        _FindNext();

        return *this;
}


bool
BNetworkCookieJar::Iterator::HasNext() const
{
        return fElement;
}


const BNetworkCookie*
BNetworkCookieJar::Iterator::Next()
{
        if (!fElement)
                return NULL;

        const BNetworkCookie* result = fElement;
        _FindNext();
        return result;
}


const BNetworkCookie*
BNetworkCookieJar::Iterator::NextDomain()
{
        if (!fElement)
                return NULL;

        const BNetworkCookie* result = fElement;

        if (!fIterator->fCookieMapIterator.HasNext()) {
                fElement = NULL;
                return result;
        }

        if (fList != NULL)
                fList->Unlock();

        if (fCookieJar->fCookieHashMap->Lock()) {
                fList = fIterator->fCookieMapIterator.Next().value;
                fList->LockForReading();

                while (fList->CountItems() == 0
                        && fIterator->fCookieMapIterator.HasNext()) {
                        // Empty list. Skip it
                        fList->Unlock();
                        fList = fIterator->fCookieMapIterator.Next().value;
                        fList->LockForReading();
                }

                fCookieJar->fCookieHashMap->Unlock();
        }

        fIndex = 0;
        fElement = fList->ItemAt(fIndex);
        return result;
}


const BNetworkCookie*
BNetworkCookieJar::Iterator::Remove()
{
        if (!fLastElement)
                return NULL;

        const BNetworkCookie* result = fLastElement;

        if (fIndex == 0) {
                if (fLastList && fCookieJar->fCookieHashMap->Lock()) {
                        // We are on the first item of fList, so we need to remove the
                        // last of fLastList
                        fLastList->Unlock();
                        if (fLastList->LockForWriting() == B_OK) {
                                fLastList->RemoveItemAt(fLastList->CountItems() - 1);
                                // TODO if the list became empty, we could remove it from the
                                // map, but this can be a problem if other iterators are still
                                // referencing it. Is there a safe place and locking pattern
                                // where we can do that?
                                fLastList->Unlock();
                                fLastList->LockForReading();
                        }
                        fCookieJar->fCookieHashMap->Unlock();
                }
        } else {
                fIndex--;

                if (fCookieJar->fCookieHashMap->Lock()) {
                        // Switch to a write lock
                        fList->Unlock();
                        if (fList->LockForWriting() == B_OK) {
                                fList->RemoveItemAt(fIndex);
                                fList->Unlock();
                        }
                        fList->LockForReading();
                        fCookieJar->fCookieHashMap->Unlock();
                }
        }

        fLastElement = NULL;
        return result;
}


void
BNetworkCookieJar::Iterator::_FindNext()
{
        fLastElement = fElement;

        fIndex++;
        if (fList && fIndex < fList->CountItems()) {
                // Get an element from the current list
                fElement = fList->ItemAt(fIndex);
                return;
        }

        if (fIterator == NULL || !fIterator->fCookieMapIterator.HasNext()) {
                // We are done iterating
                fElement = NULL;
                return;
        }

        // Get an element from the next list
        if (fLastList != NULL) {
                fLastList->Unlock();
        }
        fLastList = fList;

        if (fCookieJar->fCookieHashMap->Lock()) {
                fList = (fIterator->fCookieMapIterator.Next().value);
                fList->LockForReading();

                while (fList->CountItems() == 0
                        && fIterator->fCookieMapIterator.HasNext()) {
                        // Empty list. Skip it
                        fList->Unlock();
                        fList = fIterator->fCookieMapIterator.Next().value;
                        fList->LockForReading();
                }

                fCookieJar->fCookieHashMap->Unlock();
        }

        fIndex = 0;
        fElement = fList->ItemAt(fIndex);
}


// #pragma mark URL Iterator


BNetworkCookieJar::UrlIterator::UrlIterator(const UrlIterator& other)
        :
        fCookieJar(other.fCookieJar),
        fIterator(NULL),
        fList(NULL),
        fLastList(NULL),
        fElement(NULL),
        fLastElement(NULL),
        fIndex(0),
        fLastIndex(0),
        fUrl(other.fUrl)
{
        _Initialize();
}


BNetworkCookieJar::UrlIterator::UrlIterator(const BNetworkCookieJar* cookieJar,
        const BUrl& url)
        :
        fCookieJar(const_cast<BNetworkCookieJar*>(cookieJar)),
        fIterator(NULL),
        fList(NULL),
        fLastList(NULL),
        fElement(NULL),
        fLastElement(NULL),
        fIndex(0),
        fLastIndex(0),
        fUrl(url)
{
        _Initialize();
}


BNetworkCookieJar::UrlIterator::~UrlIterator()
{
        if (fList != NULL)
                fList->Unlock();
        if (fLastList != NULL)
                fLastList->Unlock();

        delete fIterator;
}


bool
BNetworkCookieJar::UrlIterator::HasNext() const
{
        return fElement;
}


const BNetworkCookie*
BNetworkCookieJar::UrlIterator::Next()
{
        if (!fElement)
                return NULL;

        const BNetworkCookie* result = fElement;
        _FindNext();
        return result;
}


const BNetworkCookie*
BNetworkCookieJar::UrlIterator::Remove()
{
        if (!fLastElement)
                return NULL;

        const BNetworkCookie* result = fLastElement;

        if (fCookieJar->fCookieHashMap->Lock()) {
                fLastList->Unlock();
                if (fLastList->LockForWriting() == B_OK) {
                        fLastList->RemoveItemAt(fLastIndex);

                        if (fLastList->CountItems() == 0) {
                                fCookieJar->fCookieHashMap->Remove(fIterator->fCookieMapIterator);
                                delete fLastList;
                                fLastList = NULL;
                        } else {
                                fLastList->Unlock();
                                fLastList->LockForReading();
                        }
                }
                fCookieJar->fCookieHashMap->Unlock();
        }

        fLastElement = NULL;
        return result;
}


BNetworkCookieJar::UrlIterator&
BNetworkCookieJar::UrlIterator::operator=(
        const BNetworkCookieJar::UrlIterator& other)
{
        if (this == &other)
                return *this;

        // Teardown
        if (fList)
                fList->Unlock();

        delete fIterator;

        // Init
        fCookieJar = other.fCookieJar;
        fIterator = NULL;
        fList = NULL;
        fLastList = NULL;
        fElement = NULL;
        fLastElement = NULL;
        fIndex = 0;
        fLastIndex = 0;
        fUrl = other.fUrl;

        _Initialize();

        return *this;
}


void
BNetworkCookieJar::UrlIterator::_Initialize()
{
        BString domain = fUrl.Host();

        if (!domain.Length()) {
                if (fUrl.Protocol() == "file")
                        domain = "localhost";
                else
                        return;
        }

        fIterator = new(std::nothrow) PrivateIterator(
                fCookieJar->fCookieHashMap->GetIterator());

        if (fIterator != NULL) {
                // Prepending a dot since _FindNext is going to call _SupDomain()
                domain.Prepend(".");
                fIterator->fKey.SetTo(domain, domain.Length());
                _FindNext();
        }
}


bool
BNetworkCookieJar::UrlIterator::_SuperDomain()
{
        BString domain(fIterator->fKey.GetString());
                // Makes a copy of the characters from the key. This is important,
                // because HashString doesn't like SetTo to be called with a substring
                // of its original string (use-after-free + memcpy overwrite).
        int32 firstDot = domain.FindFirst('.');
        if (firstDot < 0)
                return false;

        const char* nextDot = domain.String() + firstDot;

        fIterator->fKey.SetTo(nextDot + 1);
        return true;
}


void
BNetworkCookieJar::UrlIterator::_FindNext()
{
        fLastIndex = fIndex;
        fLastElement = fElement;
        if (fLastList != NULL)
                fLastList->Unlock();

        fLastList = fList;
        if (fCookieJar->fCookieHashMap->Lock()) {
                if (fLastList)
                        fLastList->LockForReading();

                while (!_FindPath()) {
                        if (!_SuperDomain()) {
                                fElement = NULL;
                                fCookieJar->fCookieHashMap->Unlock();
                                return;
                        }

                        _FindDomain();
                }
                fCookieJar->fCookieHashMap->Unlock();
        }
}


void
BNetworkCookieJar::UrlIterator::_FindDomain()
{
        if (fList != NULL)
                fList->Unlock();

        if (fCookieJar->fCookieHashMap->Lock()) {
                fList = fCookieJar->fCookieHashMap->Get(fIterator->fKey);

                if (fList == NULL)
                        fElement = NULL;
                else {
                        fList->LockForReading();
                }
                fCookieJar->fCookieHashMap->Unlock();
        }

        fIndex = -1;
}


bool
BNetworkCookieJar::UrlIterator::_FindPath()
{
        fIndex++;
        while (fList && fIndex < fList->CountItems()) {
                fElement = fList->ItemAt(fIndex);

                if (fElement->IsValidForPath(fUrl.Path()))
                        return true;

                fIndex++;
        }

        return false;
}


// #pragma mark - BNetworkCookieList


BNetworkCookieList::BNetworkCookieList()
{
        pthread_rwlock_init(&fLock, NULL);
}


BNetworkCookieList::~BNetworkCookieList()
{
        // Note: this is expected to be called with the write lock held.
        pthread_rwlock_destroy(&fLock);
}


status_t
BNetworkCookieList::LockForReading()
{
        return pthread_rwlock_rdlock(&fLock);
}


status_t
BNetworkCookieList::LockForWriting()
{
        return pthread_rwlock_wrlock(&fLock);
}


status_t
BNetworkCookieList::Unlock()
{
        return pthread_rwlock_unlock(&fLock);
}