/*
 * Copyright 2013-2014, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Ingo Weinhold <ingo_weinhold@gmx.de>
 */
 
 
#include "Root.h"
 
#include <Alert.h>
#include <Directory.h>
#include <Entry.h>
#include <package/CommitTransactionResult.h>
#include <package/PackageDefs.h>
#include <Path.h>
 
#include <AutoDeleter.h>
#include <AutoLocker.h>
#include <Server.h>
 
#include <package/DaemonDefs.h>
#include <package/manager/Exceptions.h>
 
#include "Constants.h"
#include "DebugSupport.h"
#include "PackageManager.h"
 
 
using namespace BPackageKit::BPrivate;
using namespace BPackageKit::BManager::BPrivate;
 
 
// #pragma mark - AbstractVolumeJob
 
 
struct Root::AbstractVolumeJob : public Job {
	AbstractVolumeJob(Volume* volume)
		:
		fVolume(volume)
	{
	}
 
	Volume* GetVolume() const
	{
		return fVolume;
	}
 
protected:
	Volume*	fVolume;
};
 
 
// #pragma mark - VolumeJob
 
 
struct Root::VolumeJob : public AbstractVolumeJob {
	VolumeJob(Volume* volume, void (Root::*method)(Volume*))
		:
		AbstractVolumeJob(volume),
		fMethod(method)
	{
	}
 
	virtual void Do()
	{
		(fVolume->GetRoot()->*fMethod)(fVolume);
	}
 
private:
	void	(Root::*fMethod)(Volume*);
};
 
 
// #pragma mark - ProcessNodeMonitorEventsJob
 
 
struct Root::ProcessNodeMonitorEventsJob : public VolumeJob {
	ProcessNodeMonitorEventsJob(Volume* volume, void (Root::*method)(Volume*))
		:
		VolumeJob(volume, method)
	{
		fVolume->PackageJobPending();
	}
 
	~ProcessNodeMonitorEventsJob()
	{
		fVolume->PackageJobFinished();
	}
};
 
 
// #pragma mark - CommitTransactionJob
 
 
struct Root::CommitTransactionJob : public AbstractVolumeJob {
	CommitTransactionJob(Root* root, Volume* volume, BMessage* message)
		:
		AbstractVolumeJob(volume),
		fRoot(root),
		fMessage(message)
	{
		fVolume->PackageJobPending();
	}
 
	~CommitTransactionJob()
	{
		fVolume->PackageJobFinished();
	}
 
	virtual void Do()
	{
		fRoot->_CommitTransaction(fVolume, fMessage.Get());
	}
 
private:
	Root*					fRoot;
	ObjectDeleter<BMessage>	fMessage;
};
 
 
// #pragma mark - VolumeJobFilter
 
 
struct Root::VolumeJobFilter : public ::JobQueue::Filter {
	VolumeJobFilter(Volume* volume)
		:
		fVolume(volume)
	{
	}
 
	virtual bool FilterJob(Job* job)
	{
		AbstractVolumeJob* volumeJob = dynamic_cast<AbstractVolumeJob*>(job);
		return volumeJob != NULL && volumeJob->GetVolume() == fVolume;
	}
 
private:
	Volume*	fVolume;
};
 
 
// #pragma mark - Root
 
 
Root::Root()
	:
	fLock("packagefs root"),
	fNodeRef(),
	fIsSystemRoot(false),
	fPath(),
	fSystemVolume(NULL),
	fHomeVolume(NULL),
	fJobQueue(),
	fJobRunner(-1)
{
}
 
 
Root::~Root()
{
	fJobQueue.Close();
 
	if (fJobRunner >= 0)
		wait_for_thread(fJobRunner, NULL);
}
 
 
status_t
Root::Init(const node_ref& nodeRef, bool isSystemRoot)
{
	fNodeRef = nodeRef;
	fIsSystemRoot = isSystemRoot;
 
	// init members and spawn job runner thread
	status_t error = fJobQueue.Init();
	if (error != B_OK)
		RETURN_ERROR(error);
 
	error = fLock.InitCheck();
	if (error != B_OK)
		RETURN_ERROR(error);
 
	fJobRunner = spawn_thread(&_JobRunnerEntry, "job runner", B_NORMAL_PRIORITY,
		this);
	if (fJobRunner < 0)
		RETURN_ERROR(fJobRunner);
 
	// get the path
	BDirectory directory;
	error = directory.SetTo(&fNodeRef);
	if (error != B_OK) {
		ERROR("Root::Init(): failed to open directory: %s\n", strerror(error));
		RETURN_ERROR(error);
	}
 
	BEntry entry;
	error = directory.GetEntry(&entry);
 
	BPath path;
	if (error == B_OK)
		error = entry.GetPath(&path);
 
	if (error != B_OK) {
		ERROR("Root::Init(): failed to get directory path: %s\n",
			strerror(error));
		RETURN_ERROR(error);
	}
 
	fPath = path.Path();
	if (fPath.IsEmpty())
		RETURN_ERROR(B_NO_MEMORY);
 
	resume_thread(fJobRunner);
 
	return B_OK;
}
 
 
status_t
Root::RegisterVolume(Volume* volume)
{
	AutoLocker<BLocker> locker(fLock);
 
	Volume** volumeToSet = _GetVolume(volume->MountType());
	if (volumeToSet == NULL)
		return B_BAD_VALUE;
 
	if (*volumeToSet != NULL) {
		ERROR("Root::RegisterVolume(): can't register volume at \"%s\", since "
			"there's already volume at \"%s\" with the same type.\n",
			volume->Path().String(), (*volumeToSet)->Path().String());
		return B_BAD_VALUE;
	}
 
	*volumeToSet = volume;
	volume->SetRoot(this);
 
	// queue a job for reading the volume's packages
	status_t error = _QueueJob(
		new(std::nothrow) VolumeJob(volume, &Root::_InitPackages));
	if (error != B_OK) {
		volume->SetRoot(NULL);
		*volumeToSet = NULL;
		return error;
	}
 
	return B_OK;
}
 
 
void
Root::UnregisterVolume(Volume* volume)
{
	AutoLocker<BLocker> locker(fLock);
 
	Volume** volumeToSet = _GetVolume(volume->MountType());
	if (volumeToSet == NULL || *volumeToSet != volume) {
		ERROR("Root::UnregisterVolume(): can't unregister unknown volume at "
			"\"%s.\n", volume->Path().String());
		return;
	}
 
	*volumeToSet = NULL;
 
	// Use the job queue to delete the volume to make sure there aren't any
	// pending jobs that reference the volume.
	_QueueJob(new(std::nothrow) VolumeJob(volume, &Root::_DeleteVolume));
}
 
 
Volume*
Root::FindVolume(dev_t deviceID) const
{
	AutoLocker<BLocker> locker(fLock);
 
	Volume* volumes[] = { fSystemVolume, fHomeVolume };
	for (size_t i = 0; i < sizeof(volumes) / sizeof(volumes[0]); i++) {
		Volume* volume = volumes[i];
		if (volume != NULL && volume->DeviceID() == deviceID)
			return volume;
	}
 
	return NULL;
}
 
 
Volume*
Root::GetVolume(BPackageInstallationLocation location)
{
	switch ((BPackageInstallationLocation)location) {
		case B_PACKAGE_INSTALLATION_LOCATION_SYSTEM:
			return fSystemVolume;
		case B_PACKAGE_INSTALLATION_LOCATION_HOME:
			return fHomeVolume;
		default:
			return NULL;
	}
}
 
 
void
Root::HandleRequest(BMessage* message)
{
	ObjectDeleter<BMessage> messageDeleter(message);
 
	// get the location and the volume
	int32 location;
	if (message->FindInt32("location", &location) != B_OK
		|| location < 0
		|| location >= B_PACKAGE_INSTALLATION_LOCATION_ENUM_COUNT) {
		return;
	}
 
	AutoLocker<BLocker> locker(fLock);
 
	Volume* volume = GetVolume((BPackageInstallationLocation)location);
	if (volume == NULL)
		return;
 
	switch (message->what) {
		case B_MESSAGE_GET_INSTALLATION_LOCATION_INFO:
			volume->HandleGetLocationInfoRequest(message);
			break;
 
		case B_MESSAGE_COMMIT_TRANSACTION:
		{
			// The B_MESSAGE_COMMIT_TRANSACTION request must be handled in the
			// job thread. But only queue a job, if there aren't package jobs
			// pending already.
			if (volume->IsPackageJobPending()) {
				BMessage reply(B_MESSAGE_COMMIT_TRANSACTION_REPLY);
				BCommitTransactionResult result(
					B_TRANSACTION_INSTALLATION_LOCATION_BUSY);
				if (result.AddToMessage(reply) == B_OK) {
					message->SendReply(&reply, (BHandler*)NULL,
						kCommunicationTimeout);
				}
				return;
			}
 
			CommitTransactionJob* job = new(std::nothrow) CommitTransactionJob(
				this, volume, message);
			if (job == NULL)
				return;
 
			messageDeleter.Detach();
 
			_QueueJob(job);
			break;
		}
 
		default:
			break;
	}
}
 
 
void
Root::VolumeNodeMonitorEventOccurred(Volume* volume)
{
	_QueueJob(new(std::nothrow) ProcessNodeMonitorEventsJob(volume,
		&Root::_ProcessNodeMonitorEvents));
}
 
 
void
Root::LastReferenceReleased()
{
}
 
 
Volume**
Root::_GetVolume(PackageFSMountType mountType)
{
	switch (mountType) {
		case PACKAGE_FS_MOUNT_TYPE_SYSTEM:
			return &fSystemVolume;
		case PACKAGE_FS_MOUNT_TYPE_HOME:
			return &fHomeVolume;
		case PACKAGE_FS_MOUNT_TYPE_CUSTOM:
		default:
			return NULL;
	}
}
 
 
Volume*
Root::_NextVolumeFor(Volume* volume)
{
	if (volume == NULL)
		return NULL;
 
	PackageFSMountType mountType = volume->MountType();
 
	do {
		switch (mountType) {
			case PACKAGE_FS_MOUNT_TYPE_HOME:
				mountType = PACKAGE_FS_MOUNT_TYPE_SYSTEM;
				break;
			case PACKAGE_FS_MOUNT_TYPE_SYSTEM:
			case PACKAGE_FS_MOUNT_TYPE_CUSTOM:
			default:
				return NULL;
		}
 
		volume = *_GetVolume(mountType);
	} while (volume == NULL);
 
	return volume;
}
 
 
void
Root::_InitPackages(Volume* volume)
{
	if (volume->InitPackages(this) == B_OK) {
		AutoLocker<BLocker> locker(fLock);
		Volume* nextVolume = _NextVolumeFor(volume);
		Volume* nextNextVolume = _NextVolumeFor(nextVolume);
		locker.Unlock();
 
		volume->InitialVerify(nextVolume, nextNextVolume);
	}
}
 
 
void
Root::_DeleteVolume(Volume* volume)
{
	// delete all pending jobs for that volume
	VolumeJobFilter filter(volume);
	fJobQueue.DeleteJobs(&filter);
 
	delete volume;
}
 
 
void
Root::_ProcessNodeMonitorEvents(Volume* volume)
{
	volume->ProcessPendingNodeMonitorEvents();
 
	if (!volume->HasPendingPackageActivationChanges())
		return;
 
	// If this is not the system root, just activate/deactivate the packages.
	if (!fIsSystemRoot) {
		volume->ProcessPendingPackageActivationChanges();
		return;
	}
 
	// For the system root do the full dependency analysis.
 
	PRINT("Root::_ProcessNodeMonitorEvents(): running package manager...\n");
	try {
		PackageManager packageManager(this, volume);
		packageManager.HandleUserChanges();
	} catch (BNothingToDoException&) {
		PRINT("Root::_ProcessNodeMonitorEvents(): -> nothing to do\n");
	} catch (std::bad_alloc&) {
		_ShowError(
			"Insufficient memory while trying to apply package changes.");
	} catch (BFatalErrorException& exception) {
		if (exception.Error() == B_OK) {
			_ShowError(exception.Message());
		} else {
			_ShowError(BString().SetToFormat("%s: %s",
				exception.Message().String(), strerror(exception.Error())));
		}
		// TODO: Print exception.Details()?
	} catch (BAbortedByUserException&) {
		PRINT("Root::_ProcessNodeMonitorEvents(): -> aborted by user\n");
	}
 
	volume->ClearPackageActivationChanges();
}
 
 
void
Root::_CommitTransaction(Volume* volume, BMessage* message)
{
	volume->HandleCommitTransactionRequest(message);
}
 
 
status_t
Root::_QueueJob(Job* job)
{
	if (job == NULL)
		return B_NO_MEMORY;
 
	BReference<Job> jobReference(job, true);
	if (!fJobQueue.QueueJob(job)) {
		// job queue already closed
		return B_BAD_VALUE;
	}
 
	return B_OK;
}
 
 
/*static*/ status_t
Root::_JobRunnerEntry(void* data)
{
	return ((Root*)data)->_JobRunner();
}
 
 
status_t
Root::_JobRunner()
{
	while (Job* job = fJobQueue.DequeueJob()) {
		job->Do();
		job->ReleaseReference();
	}
 
	return B_OK;
}
 
 
/*static*/ void
Root::_ShowError(const char* errorMessage)
{
	BServer* server = dynamic_cast<BServer*>(be_app);
	if (server != NULL && server->InitGUIContext() == B_OK) {
		BAlert* alert = new(std::nothrow) BAlert("Package error",
			errorMessage, "OK", NULL, NULL, B_WIDTH_AS_USUAL, B_WARNING_ALERT);
		if (alert != NULL) {
			alert->SetShortcut(0, B_ESCAPE);
			alert->Go();
			return;
		}
	}
 
	ERROR("Root::_ShowError(): %s\n", errorMessage);
}