/*
 * Copyright 2011, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Oliver Tappe <zooey@hirschkaefer.de>
 *              Ingo Weinhold <ingo_weinhold@gmx.de>
 */


#include <package/PackageInfoSet.h>

#include <new>

#include <Referenceable.h>

#include <AutoDeleter.h>

#include <util/OpenHashTable.h>

#include <package/PackageInfo.h>


namespace BPackageKit {


// #pragma mark - PackageInfo


struct BPackageInfoSet::PackageInfo : public BPackageInfo {
        PackageInfo*    hashNext;
        PackageInfo*    listNext;

        PackageInfo(const BPackageInfo& other)
                :
                BPackageInfo(other),
                listNext(NULL)
        {
        }

        void DeleteList()
        {
                PackageInfo* info = this;
                while (info != NULL) {
                        PackageInfo* next = info->listNext;
                        delete info;
                        info = next;
                }
        }
};


// #pragma mark - PackageInfoHashDefinition


struct BPackageInfoSet::PackageInfoHashDefinition {
        typedef const char*             KeyType;
        typedef PackageInfo             ValueType;

        size_t HashKey(const char* key) const
        {
                return BString::HashValue(key);
        }

        size_t Hash(const PackageInfo* value) const
        {
                return value->Name().HashValue();
        }

        bool Compare(const char* key, const PackageInfo* value) const
        {
                return value->Name() == key;
        }

        PackageInfo*& GetLink(PackageInfo* value) const
        {
                return value->hashNext;
        }
};


// #pragma mark - PackageMap


struct BPackageInfoSet::PackageMap : public BReferenceable,
        public BOpenHashTable<PackageInfoHashDefinition> {

        PackageMap()
                :
                fCount(0)
        {
        }

        ~PackageMap()
        {
                DeleteAllPackageInfos();
        }

        static PackageMap* Create()
        {
                PackageMap* map = new(std::nothrow) PackageMap;
                if (map == NULL || map->Init() != B_OK) {
                        delete map;
                        return NULL;
                }

                return map;
        }

        PackageMap* Clone() const
        {
                PackageMap* newMap = Create();
                if (newMap == NULL)
                        return NULL;
                ObjectDeleter<PackageMap> newMapDeleter(newMap);

                for (BPackageInfoSet::Iterator it(this); it.HasNext();) {
                        const BPackageInfo* info = it.Next();
                        if (newMap->AddNewPackageInfo(*info) != B_OK)
                                return NULL;
                }

                return newMapDeleter.Detach();
        }

        void AddPackageInfo(PackageInfo* info)
        {
                if (PackageInfo* oldInfo = Lookup(info->Name())) {
                        info->listNext = oldInfo->listNext;
                        oldInfo->listNext = info;
                } else
                        Insert(info);

                fCount++;
        }

        status_t AddNewPackageInfo(const BPackageInfo& oldInfo)
        {
                PackageInfo* info = new(std::nothrow) PackageInfo(oldInfo);
                if (info == NULL)
                        return B_NO_MEMORY;
                ObjectDeleter<PackageInfo> infoDeleter(info);

                status_t error = info->InitCheck();
                if (error != B_OK)
                        return error;

                AddPackageInfo(infoDeleter.Detach());

                return B_OK;
        }

        void DeleteAllPackageInfos()
        {
                PackageInfo* info = Clear(true);
                while (info != NULL) {
                        PackageInfo* next = info->hashNext;
                        info->DeleteList();
                        info = next;
                }
        }

        uint32 CountPackageInfos() const
        {
                return fCount;
        }

private:
        uint32  fCount;
};


// #pragma mark - Iterator


BPackageInfoSet::Iterator::Iterator(const PackageMap* map)
        :
        fMap(map),
        fNextInfo(map != NULL ? map->GetIterator().Next() : NULL)
{
}


bool
BPackageInfoSet::Iterator::HasNext() const
{
        return fNextInfo != NULL;
}


const BPackageInfo*
BPackageInfoSet::Iterator::Next()
{
        BPackageInfo* result = fNextInfo;

        if (fNextInfo != NULL) {
                if (fNextInfo->listNext != NULL) {
                        // get next in list
                        fNextInfo = fNextInfo->listNext;
                } else {
                        // get next in hash table
                        PackageMap::Iterator iterator
                                = fMap->GetIterator(fNextInfo->Name());
                        iterator.Next();
                        fNextInfo = iterator.Next();
                }
        }

        return result;
}


// #pragma mark - BPackageInfoSet


BPackageInfoSet::BPackageInfoSet()
        :
        fPackageMap(NULL)
{
}


BPackageInfoSet::~BPackageInfoSet()
{
        if (fPackageMap != NULL)
                fPackageMap->ReleaseReference();
}


BPackageInfoSet::BPackageInfoSet(const BPackageInfoSet& other)
        :
        fPackageMap(other.fPackageMap)
{
        if (fPackageMap != NULL)
                fPackageMap->AcquireReference();
}


status_t
BPackageInfoSet::AddInfo(const BPackageInfo& info)
{
        if (!_CopyOnWrite())
                return B_NO_MEMORY;

        return fPackageMap->AddNewPackageInfo(info);
}


void
BPackageInfoSet::MakeEmpty()
{
        if (fPackageMap == NULL || fPackageMap->CountPackageInfos() == 0)
                return;

        // If our map is shared, just set it to NULL.
        if (fPackageMap->CountReferences() != 1) {
                fPackageMap->ReleaseReference();
                fPackageMap = NULL;
                return;
        }

        // Our map is not shared -- make it empty.
        fPackageMap->DeleteAllPackageInfos();
}


uint32
BPackageInfoSet::CountInfos() const
{
        if (fPackageMap == NULL)
                return 0;

        return fPackageMap->CountPackageInfos();
}


BPackageInfoSet::Iterator
BPackageInfoSet::GetIterator() const
{
        return Iterator(fPackageMap);
}


BPackageInfoSet&
BPackageInfoSet::operator=(const BPackageInfoSet& other)
{
        if (other.fPackageMap == fPackageMap)
                return *this;

        if (fPackageMap != NULL)
                fPackageMap->ReleaseReference();

        fPackageMap = other.fPackageMap;

        if (fPackageMap != NULL)
                fPackageMap->AcquireReference();

        return *this;
}


bool
BPackageInfoSet::_CopyOnWrite()
{
        if (fPackageMap == NULL) {
                fPackageMap = PackageMap::Create();
                return fPackageMap != NULL;
        }

        if (fPackageMap->CountReferences() == 1)
                return true;

        PackageMap* newMap = fPackageMap->Clone();
        if (newMap == NULL)
                return false;

        fPackageMap->ReleaseReference();
        fPackageMap = newMap;
        return true;
}


}       // namespace BPackageKit