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


#include "PackageLinkSymlink.h"

#include <algorithm>

#include <NodeMonitor.h>

#include "AutoPackageAttributeDirectoryCookie.h"
#include "DebugSupport.h"
#include "NodeListener.h"
#include "PackageLinksListener.h"
#include "Utils.h"
#include "Volume.h"


static const char* const kUnknownLinkTarget = "?";

static const char* const kLinkPaths[PackageLinkSymlink::TYPE_ENUM_COUNT]
		[PACKAGE_FS_MOUNT_TYPE_ENUM_COUNT] = {
	{
		"../..",
		"../../../home/config",
		kUnknownLinkTarget
	},
	{
		"../../../system/settings",
		"../../../home/config/settings",
		kUnknownLinkTarget
	}
};


static const char*
link_path_for_mount_type(MountType mountType, PackageLinkSymlink::Type linkType)
{
	if (mountType < 0 || mountType >= PACKAGE_FS_MOUNT_TYPE_ENUM_COUNT
		|| linkType < 0 || linkType >= PackageLinkSymlink::TYPE_ENUM_COUNT) {
		return kUnknownLinkTarget;
	}

	return kLinkPaths[linkType][mountType];
}


// #pragma mark - OldAttributes


struct PackageLinkSymlink::OldAttributes : OldNodeAttributes {
	OldAttributes(const timespec& modifiedTime, off_t fileSize)
		:
		fModifiedTime(modifiedTime),
		fFileSize(fileSize)
	{
	}

	virtual timespec ModifiedTime() const
	{
		return fModifiedTime;
	}

	virtual off_t FileSize() const
	{
		return fFileSize;
	}

private:
	timespec	fModifiedTime;
	off_t		fFileSize;
};


// #pragma mark - PackageLinkSymlink


PackageLinkSymlink::PackageLinkSymlink(Package* package, Type type)
	:
	Node(0),
	fPackage(),
	fLinkPath(kUnknownLinkTarget),
	fType(type)
{
	Update(package, NULL);
}


PackageLinkSymlink::~PackageLinkSymlink()
{
}


void
PackageLinkSymlink::Update(Package* package, PackageLinksListener* listener)
{
	OldAttributes oldAttributes(fModifiedTime, FileSize());

	fPackage = package;

	if (package != NULL) {
		fLinkPath = package->InstallPath();
		if (fLinkPath[0] != '\0') {
			if (fType == TYPE_SETTINGS)
				fLinkPath = ".self/settings";
		} else {
			fLinkPath = link_path_for_mount_type(
				package->Volume()->MountType(), fType);
		}
	} else
		fLinkPath = kUnknownLinkTarget;

	get_real_time(fModifiedTime);

	if (listener != NULL) {
		listener->PackageLinkNodeChanged(this,
			B_STAT_SIZE | B_STAT_MODIFICATION_TIME, oldAttributes);
	}
}


mode_t
PackageLinkSymlink::Mode() const
{
	return S_IFLNK | S_IRUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH;
}


timespec
PackageLinkSymlink::ModifiedTime() const
{
	return fModifiedTime;
}


off_t
PackageLinkSymlink::FileSize() const
{
	return strlen(fLinkPath);
}


status_t
PackageLinkSymlink::Read(off_t offset, void* buffer, size_t* bufferSize)
{
	return B_BAD_VALUE;
}


status_t
PackageLinkSymlink::Read(io_request* request)
{
	return B_BAD_VALUE;
}


status_t
PackageLinkSymlink::ReadSymlink(void* buffer, size_t* bufferSize)
{
	size_t linkLength = strnlen(fLinkPath, B_PATH_NAME_LENGTH);

	size_t bytesToCopy = std::min(linkLength, *bufferSize);

	*bufferSize = linkLength;

	memcpy(buffer, fLinkPath, bytesToCopy);
	return B_OK;
}


status_t
PackageLinkSymlink::OpenAttributeDirectory(AttributeDirectoryCookie*& _cookie)
{
	AutoPackageAttributeDirectoryCookie* cookie = new(std::nothrow)
		AutoPackageAttributeDirectoryCookie();
	if (cookie == NULL)
		return B_NO_MEMORY;

	_cookie = cookie;
	return B_OK;
}


status_t
PackageLinkSymlink::OpenAttribute(const StringKey& name, int openMode,
	AttributeCookie*& _cookie)
{
	if (!fPackage.IsSet())
		return B_ENTRY_NOT_FOUND;

	return AutoPackageAttributes::OpenCookie(fPackage, name, openMode, _cookie);
}