/*
 * Copyright (c) 2010, Haiku, Inc.
 * Distributed under the terms of the MIT license.
 *
 * Author:
 *		Łukasz 'Sil2100' Zemczak <sil2100@vexillium.org>
 */
 
 
#include "PackageInstall.h"
 
#include "InstalledPackageInfo.h"
#include "PackageItem.h"
#include "PackageView.h"
 
#include <Alert.h>
#include <Catalog.h>
#include <Locale.h>
#include <stdio.h>
 
 
#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "PackageInstall"
 
 
static int32
install_function(void* data)
{
	// TODO: Inform if already one thread is running
	if (data == NULL)
		return -1;
 
	PackageInstall* install = static_cast<PackageInstall*>(data);
	install->Install();
	return 0;
}
 
 
PackageInstall::PackageInstall(PackageView* parent)
	:
	fParent(parent),
	fThreadId(-1),
	fCurrentScript(NULL)
{
}
 
 
PackageInstall::~PackageInstall()
{
}
 
 
status_t
PackageInstall::Start()
{
	status_t ret = B_OK;
 
	fIdLocker.Lock();
	if (fThreadId > -1) {
		ret = B_BUSY;
	} else {
		fThreadId = spawn_thread(install_function, "install_package",
			B_NORMAL_PRIORITY, this);
		resume_thread(fThreadId);
	}
	fIdLocker.Unlock();
 
	return ret;
}
 
 
void
PackageInstall::Stop()
{
	// TODO: Argh! No killing of threads!! That leaks resources which they
	// allocated. Rather inform them they need to quit, which they do at the
	// next convenient time, then use wait_for_thread() here.
	fIdLocker.Lock();
	if (fThreadId > -1) {
		kill_thread(fThreadId);
		fThreadId = -1;
	}
	fIdLocker.Unlock();
 
	fCurrentScriptLocker.Lock();
	if (fCurrentScript != NULL) {
		thread_id id = fCurrentScript->GetThreadId();
		if (id > -1) {
			fCurrentScript->SetThreadId(-1);
			kill_thread(id);
		}
		fCurrentScript = NULL;
	}
	fCurrentScriptLocker.Unlock();
}
 
 
void
PackageInstall::Install()
{
	// A message sending wrapper around _Install()
	uint32 code = _Install();
 
	BMessenger messenger(fParent);
	if (messenger.IsValid()) {
		BMessage message(code);
		messenger.SendMessage(&message);
	}
}
 
 
static inline BString
get_item_progress_string(uint32 index, uint32 total) 
{
	BString label(B_TRANSLATE("%index% of %total%"));
	BString indexString;
	indexString << (index + 1);
	BString totalString;
	totalString << total;
	label.ReplaceAll("%index%", indexString);
	label.ReplaceAll("%total%", totalString);
	return label;
}
 
 
uint32
PackageInstall::_Install()
{
	PackageInfo* info = fParent->GetPackageInfo();
	pkg_profile* type = static_cast<pkg_profile*>(info->GetProfile(
		fParent->CurrentType()));
	uint32 n = type->items.CountItems();
	uint32 m = info->GetScriptCount();
 
	PackageStatus* progress = fParent->StatusWindow();
	progress->Reset(n + m + 5);
 
	progress->StageStep(1, B_TRANSLATE("Preparing package"));
 
	InstalledPackageInfo packageInfo(info->GetName(), info->GetVersion());
 
	status_t err = packageInfo.InitCheck();
	if (err == B_OK) {
		// The package is already installed, inform the user
		BAlert* reinstall = new BAlert("reinstall",
			B_TRANSLATE("The given package seems to be already installed on "
				"your system. Would you like to uninstall the existing one "
				"and continue the installation?"),
			B_TRANSLATE("Continue"),
			B_TRANSLATE("Abort"));
		reinstall->SetShortcut(1, B_ESCAPE);
 
		if (reinstall->Go() == 0) {
			// Uninstall the package
			err = packageInfo.Uninstall();
			if (err != B_OK) {
				fprintf(stderr, "Error uninstalling previously installed "
					"package: %s\n", strerror(err));
				// Ignore error
			}
 
			err = packageInfo.SetTo(info->GetName(), info->GetVersion(), true);
			if (err != B_OK) {
				fprintf(stderr, "Error marking installation of package: "
					"%s\n", strerror(err));
				return P_MSG_I_ERROR;
			}
		} else {
			// Abort the installation
			return P_MSG_I_ABORT;
		}
	} else if (err == B_ENTRY_NOT_FOUND) {
		err = packageInfo.SetTo(info->GetName(), info->GetVersion(), true);
		if (err != B_OK) {
				fprintf(stderr, "Error marking installation of package: "
					"%s\n", strerror(err));
			return P_MSG_I_ERROR;
		}
	} else if (progress->Stopped()) {
		return P_MSG_I_ABORT;
	} else {
		fprintf(stderr, "returning on error\n");
		return P_MSG_I_ERROR;
	}
 
	progress->StageStep(1, B_TRANSLATE("Installing files and folders"));
 
	// Install files and directories
 
	packageInfo.SetName(info->GetName());
	// TODO: Here's a small problem, since right now it's not quite sure
	//		which description is really used as such. The one displayed on
	//		the installer is mostly package installation description, but
	//		most people use it for describing the application in more detail
	//		then in the short description.
	//		For now, we'll use the short description if possible.
	BString description = info->GetShortDescription();
	if (description.Length() <= 0)
		description = info->GetDescription();
	packageInfo.SetDescription(description.String());
	packageInfo.SetSpaceNeeded(type->space_needed);
 
	fItemExistsPolicy = P_EXISTS_NONE;
 
	const char* installPath = fParent->CurrentPath()->Path();
	for (uint32 i = 0; i < n; i++) {
		ItemState state(fItemExistsPolicy);
		PackageItem* item = static_cast<PackageItem*>(type->items.ItemAt(i));
 
		err = item->DoInstall(installPath, &state);
		if (err == B_FILE_EXISTS) {
			// Writing to path failed because path already exists - ask the user
			// what to do and retry the writing process
			int32 choice = fParent->ItemExists(*item, state.destination,
				fItemExistsPolicy);
			if (choice != P_EXISTS_ABORT) {
				state.policy = choice;
				err = item->DoInstall(installPath, &state);
			}
		}
 
		if (err != B_OK) {
			fprintf(stderr, "Error '%s' while writing path\n", strerror(err));
			return P_MSG_I_ERROR;
		}
 
		if (progress->Stopped())
			return P_MSG_I_ABORT;
 
		// Update progress
		progress->StageStep(1, NULL, get_item_progress_string(i, n).String());
 
		// Mark installed item in packageInfo
		packageInfo.AddItem(state.destination.Path());
	}
 
	progress->StageStep(1, B_TRANSLATE("Running post-installation scripts"),
		 "");
 
	// Run all scripts
	// TODO: Change current working directory to installation location!
	for (uint32 i = 0; i < m; i++) {
		PackageScript* script = info->GetScript(i);
 
		fCurrentScriptLocker.Lock();
		fCurrentScript = script;
 
		status_t status = script->DoInstall(installPath);
		if (status != B_OK) {
			fprintf(stderr, "Error while running script: %s\n",
				strerror(status));
			fCurrentScriptLocker.Unlock();
			return P_MSG_I_ERROR;
		}
		fCurrentScriptLocker.Unlock();
 
		wait_for_thread(script->GetThreadId(), &status);
 
		fCurrentScriptLocker.Lock();
		script->SetThreadId(-1);
		fCurrentScript = NULL;
		fCurrentScriptLocker.Unlock();
 
		if (progress->Stopped())
			return P_MSG_I_ABORT;
 
		progress->StageStep(1, NULL, get_item_progress_string(i, m).String());
	}
 
	progress->StageStep(1, B_TRANSLATE("Finishing installation"), "");
 
	err = packageInfo.Save();
	if (err != B_OK)
		return P_MSG_I_ERROR;
 
	progress->StageStep(1, B_TRANSLATE("Done"));
 
	// Inform our parent that we finished
	return P_MSG_I_FINISHED;
}