/*
 * Copyright 2009-2013, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "PackageNode.h"

#include <stdlib.h>
#include <string.h>

#include <time_private.h>

#include "DebugSupport.h"
#include "Package.h"
#include "Utils.h"


DEFINE_INLINE_REFERENCEABLE_METHODS(PackageNode, fReferenceable);


PackageNode::PackageNode(Package* package, mode_t mode)
        :
        fPackage(package),
        fParent(NULL),
        fName(),
        fMode(mode)
{
}


PackageNode::~PackageNode()
{
        while (PackageNodeAttribute* attribute = fAttributes.RemoveHead())
                delete attribute;
}


BReference<Package>
PackageNode::GetPackage() const
{
        return fPackage.GetReference();
}


status_t
PackageNode::Init(PackageDirectory* parent, const String& name)
{
        fParent = parent;
        fName = name;
        return B_OK;
}


status_t
PackageNode::VFSInit(dev_t deviceID, ino_t nodeID)
{
        BReference<Package> package(GetPackage());

        // open the package
        int fd = package->Open();
        if (fd < 0)
                RETURN_ERROR(fd);

        package->AcquireReference();
        return B_OK;
}


void
PackageNode::VFSUninit()
{
        BReference<Package> package(GetPackage());
        package->Close();
        package->ReleaseReference();
}


void
PackageNode::SetModifiedTime(const timespec& time)
{
        if (!timespec_to_bigtime(time, fModifiedTime))
                fModifiedTime = 0;
}


timespec
PackageNode::ModifiedTime() const
{
        timespec modifiedTime;
        bigtime_to_timespec(fModifiedTime, modifiedTime);
        return modifiedTime;
}


off_t
PackageNode::FileSize() const
{
        return 0;
}


void
PackageNode::AddAttribute(PackageNodeAttribute* attribute)
{
        fAttributes.Add(attribute);
}


PackageNodeAttribute*
PackageNode::FindAttribute(const StringKey& name) const
{
        for (PackageNodeAttributeList::ConstIterator it = fAttributes.GetIterator();
                        PackageNodeAttribute* attribute = it.Next();) {
                if (name == attribute->Name())
                        return attribute;
        }

        return NULL;
}


void
PackageNode::UnsetIndexCookie(void* attributeCookie)
{
        ((PackageNodeAttribute*)attributeCookie)->SetIndexCookie(NULL);
}


bool
PackageNode::HasPrecedenceOver(const PackageNode* other) const
{
        uint32 packageFlags = 0, otherPackageFlags = 0;
        BReference<Package> package(GetPackage()), otherPackage(other->GetPackage());
        if (package)
                packageFlags = package->Flags();
        if (otherPackage)
                otherPackageFlags = otherPackage->Flags();

        const bool isSystemPkg = (packageFlags
                        & BPackageKit::B_PACKAGE_FLAG_SYSTEM_PACKAGE) != 0,
                otherIsSystemPkg = (otherPackageFlags
                        & BPackageKit::B_PACKAGE_FLAG_SYSTEM_PACKAGE) != 0;
        if (isSystemPkg && !otherIsSystemPkg)
                return true;
        if (!isSystemPkg && otherIsSystemPkg)
                return false;
        return ModifiedTime() > other->ModifiedTime();
}