/*
 * Copyright 2008-2011, Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Michael Pfeiffer <laplace@users.sourceforge.net>
 */


#include "DefaultPartitionPage.h"


#include <Catalog.h>
#include <ControlLook.h>
#include <Locale.h>
#include <Message.h>
#include <MenuItem.h>
#include <MenuField.h>
#include <PopUpMenu.h>
#include <RadioButton.h>
#include <Slider.h>
#include <string.h>
#include <String.h>
#include <TextView.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "DefaultPartitionPage"


enum {
	kMsgPartition = 'part',
	kMsgTimeout = 'time'
};


// The timeout code to wait indefinitely
// Note: The timeout is encoded in seconds, -1 indicates to wait indefinitely
const int32 kTimeoutIndefinitely = -1;
const int32 kDefaultTimeout = kTimeoutIndefinitely;

struct TimeoutOption {
	int32 timeout;
	const char* label;
};

static const TimeoutOption gTimeoutOptions[] = {
	{ 0, B_TRANSLATE_MARK("Immediately")},
	{ 1, B_TRANSLATE_MARK("After one second")},
	{ 2, B_TRANSLATE_MARK("After two seconds")},
	{ 3, B_TRANSLATE_MARK("After three seconds")},
	{ 4, B_TRANSLATE_MARK("After four seconds")},
	{ 5, B_TRANSLATE_MARK("After five seconds")},
	{ 60, B_TRANSLATE_MARK("After one minute")},
	{ kTimeoutIndefinitely, B_TRANSLATE_MARK("Never")}
};


#define kNumberOfTimeoutOptions \
	(int32)(sizeof(gTimeoutOptions) / sizeof(TimeoutOption))


static int32
get_index_for_timeout(int32 timeout)
{
	int32 defaultIndex = 0;
	for (int32 i = 0; i < kNumberOfTimeoutOptions; i ++) {
		if (gTimeoutOptions[i].timeout == timeout)
			return i;

		if (gTimeoutOptions[i].timeout == kDefaultTimeout)
			defaultIndex = i;
	}
	return defaultIndex;
}


static int32
get_timeout_for_index(int32 index)
{
	if (index < 0)
		return gTimeoutOptions[0].timeout;
	if (index >= kNumberOfTimeoutOptions)
		return gTimeoutOptions[kNumberOfTimeoutOptions-1].timeout;
	return gTimeoutOptions[index].timeout;
}


const char*
get_label_for_timeout(int32 timeout)
{
	int32 index = get_index_for_timeout(timeout);
	return gTimeoutOptions[index].label;
}


// #pragma mark -


DefaultPartitionPage::DefaultPartitionPage(BMessage* settings, BRect frame,
	const char* name)
	:
	WizardPageView(settings, frame, name, B_FOLLOW_ALL,
		B_WILL_DRAW | B_FRAME_EVENTS | B_FULL_UPDATE_ON_RESIZE)
{
	_BuildUI();
}


DefaultPartitionPage::~DefaultPartitionPage()
{
}


void
DefaultPartitionPage::FrameResized(float width, float height)
{
	WizardPageView::FrameResized(width, height);
	_Layout();
}


void
DefaultPartitionPage::AttachedToWindow()
{
	fDefaultPartition->Menu()->SetTargetForItems(this);
	fTimeoutSlider->SetTarget(this);
}


void
DefaultPartitionPage::MessageReceived(BMessage* msg)
{
	switch (msg->what) {
		case kMsgPartition:
		{
			int32 index;
			msg->FindInt32("index", &index);
			fSettings->ReplaceInt32("defaultPartition", index);
			break;
		}
		case kMsgTimeout:
		{
			int32 sliderValue = fTimeoutSlider->Value();
			int32 timeout = get_timeout_for_index(sliderValue);
			fSettings->ReplaceInt32("timeout", timeout);

			BString label;
			_GetTimeoutLabel(timeout, label);
			fTimeoutSlider->SetLabel(label.String());
			break;
		}

		default:
			WizardPageView::MessageReceived(msg);
	}
}


void
DefaultPartitionPage::_BuildUI()
{
	const float kTextDistance = be_control_look->DefaultItemSpacing();
	BRect rect(Bounds());

	BString text;
	text << B_TRANSLATE_COMMENT("Default Partition", "Title") << "\n"
		<< B_TRANSLATE("Please specify a default partition and a timeout.\n"
			"The boot menu will load the default partition after "
			"the timeout unless you select another partition. You "
			"can also have the boot menu wait indefinitely for you "
			"to select a partition.\n"
			"Keep the 'ALT' key pressed to disable the timeout at boot time.");

	fDescription = CreateDescription(rect, "description", text);
	MakeHeading(fDescription);
	AddChild(fDescription);
	LayoutDescriptionVertically(fDescription);
	rect.top = fDescription->Frame().bottom + kTextDistance;

	BPopUpMenu* popUpMenu = _CreatePopUpMenu();
	fDefaultPartition = new BMenuField(rect, "partitions",
		B_TRANSLATE_COMMENT("Default Partition:", "Menu field label"),
		popUpMenu);
	float divider = be_plain_font->StringWidth(fDefaultPartition->Label()) + 3;
	fDefaultPartition->SetDivider(divider);
	AddChild(fDefaultPartition);
	fDefaultPartition->ResizeToPreferred();

	// timeout slider
	rect.top = fDefaultPartition->Frame().bottom + kTextDistance;
	int32 timeout;
	fSettings->FindInt32("timeout", &timeout);
	BString timeoutLabel;
	_GetTimeoutLabel(timeout, timeoutLabel);

	int32 sliderValue = get_index_for_timeout(timeout);

	fTimeoutSlider = new BSlider(rect, "timeout", timeoutLabel.String(),
		new BMessage(kMsgTimeout), 0, kNumberOfTimeoutOptions-1,
		B_BLOCK_THUMB,
		B_FOLLOW_LEFT_RIGHT | B_FOLLOW_TOP);
	fTimeoutSlider->SetModificationMessage(new BMessage(kMsgTimeout));
	fTimeoutSlider->SetValue(sliderValue);
	fTimeoutSlider->SetLimitLabels(B_TRANSLATE("Immediately"),
		B_TRANSLATE("Never"));
	fTimeoutSlider->SetHashMarks(B_HASH_MARKS_BOTTOM);
	fTimeoutSlider->SetHashMarkCount(kNumberOfTimeoutOptions);
	fTimeoutSlider->ResizeToPreferred();
	AddChild(fTimeoutSlider);

	_Layout();
}


BPopUpMenu*
DefaultPartitionPage::_CreatePopUpMenu()
{
	int32 defaultPartitionIndex;
	fSettings->FindInt32("defaultPartition", &defaultPartitionIndex);

	BMenuItem* selectedItem = NULL;
	int32 selectedItemIndex = 0;

	BPopUpMenu* menu = new BPopUpMenu(B_TRANSLATE_COMMENT("Partitions",
		"Pop up menu title"));
	BMessage message;
	for (int32 i = 0; fSettings->FindMessage("partition", i, &message) == B_OK;
			i++) {
		bool show;
		if (message.FindBool("show", &show) != B_OK || !show)
			continue;

		BString name;
		message.FindString("name", &name);

		BMessage* msg = new BMessage(kMsgPartition);
		msg->AddInt32("index", i);
		BMenuItem* item = new BMenuItem(name.String(), msg);
		menu->AddItem(item);
		if (defaultPartitionIndex == i || selectedItem == NULL) {
			selectedItem = item;
			selectedItemIndex = i;
		}
	}
	fSettings->ReplaceInt32("defaultPartition", selectedItemIndex);
	selectedItem->SetMarked(true);
	return menu;
}


void
DefaultPartitionPage::_GetTimeoutLabel(int32 timeout, BString& label)
{
	const char* text = B_TRANSLATE_NOCOLLECT(get_label_for_timeout(timeout));
	label = B_TRANSLATE("Timeout: %s");
	label.ReplaceFirst("%s", text);
}


void
DefaultPartitionPage::_Layout()
{
	LayoutDescriptionVertically(fDescription);

	const float kTextDistance = be_control_look->DefaultItemSpacing();
	float left = fDefaultPartition->Frame().left;
	float top = fDescription->Frame().bottom + kTextDistance;

	fDefaultPartition->MoveTo(left, top);
	top = fDefaultPartition->Frame().bottom + kTextDistance;

	fTimeoutSlider->MoveTo(left, top);
}