/*
 * Copyright 2009, Axel Dörfler, axeld@pinc-software.de.
 * Distributed under the terms of the MIT License.
 */


#include "SettingsWindow.h"

#include <stdio.h>
#include <stdlib.h>

#include <Catalog.h>
#include <LayoutBuilder.h>
#include <GroupLayoutBuilder.h>
#include <Slider.h>
#include <String.h>

#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "SettingsWindow"


static const uint32 kMsgUpdateTimeInterval = 'upti';

static const bigtime_t kUpdateIntervals[] = {
	25, 50, 75, 100, 250, 500, 1000, 2000
};
static const size_t kNumUpdateIntervals
	= sizeof(kUpdateIntervals) / sizeof(kUpdateIntervals[0]);


class IntervalSlider : public BSlider {
public:
	IntervalSlider(const char* label, BMessage* message, uint32 levels)
		: BSlider("intervalSlider", label, message, 0, levels - 1, B_HORIZONTAL)
	{
		BString min(_TextFor(0));
		BString max(_TextFor(levels - 1));
		SetLimitLabels(min.String(), max.String());
		SetHashMarks(B_HASH_MARKS_BOTTOM);
		SetHashMarkCount(levels);
		SetViewUIColor(B_PANEL_BACKGROUND_COLOR);

		if (message != NULL)
			SetModificationMessage(new BMessage(*message));
	}

	void SetInterval(bigtime_t interval)
	{
		interval /= 1000;

		// Find closest index
		int32 bestDiff = INT32_MAX;
		uint32 bestIndex = 0;
		for (uint32 i = 0; i < kNumUpdateIntervals; i++) {
			int32 diff = abs(kUpdateIntervals[i] - interval);
			if (diff < bestDiff) {
				bestDiff = diff;
				bestIndex = i;
			}
		}

		SetValue(bestIndex);
	}

	virtual const char* UpdateText() const
	{
		return _TextFor(Value());
	}

private:
	const char* _TextFor(uint32 level) const
	{
		if (level >= kNumUpdateIntervals)
			return NULL;

		bigtime_t interval = kUpdateIntervals[level];
		if ((interval % 1000) == 0) {
			snprintf(fText, sizeof(fText), B_TRANSLATE("%lld sec."),
				(long long int)interval / 1000);
		} else
			snprintf(fText, sizeof(fText), B_TRANSLATE("%lld ms"), (long long int)interval);

		return fText;
	}

	mutable char	fText[64];
};


//	#pragma mark -


SettingsWindow::SettingsWindow(ActivityWindow* target)
	: BWindow(_RelativeTo(target),
		B_TRANSLATE_CONTEXT("Settings", "ActivityWindow"), B_FLOATING_WINDOW,
	   	B_ASYNCHRONOUS_CONTROLS | B_NOT_ZOOMABLE | B_AUTO_UPDATE_SIZE_LIMITS),
	fTarget(target)
{
	fIntervalSlider = new IntervalSlider(B_TRANSLATE("Update time interval:"),
		new BMessage(kMsgUpdateTimeInterval), kNumUpdateIntervals);
	fIntervalSlider->SetInterval(target->RefreshInterval());

	// controls pane
	BLayoutBuilder::Group<>(this, B_VERTICAL)
		.Add(fIntervalSlider)
		.SetInsets(B_USE_WINDOW_SPACING);

	if (target->IsAlwaysOnTop())
		SetFeel(B_MODAL_ALL_WINDOW_FEEL);

	MoveOnScreen(B_MOVE_IF_PARTIALLY_OFFSCREEN);
}


SettingsWindow::~SettingsWindow()
{
}


void
SettingsWindow::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case kMsgUpdateTimeInterval:
		{
			int32 level = 0;
			if (message->FindInt32("be:value", &level) != B_OK)
				break;

			BMessage update(kMsgTimeIntervalUpdated);
			update.AddInt64("interval", kUpdateIntervals[level] * 1000LL);

			fTarget.SendMessage(&update);
			break;
		}

		default:
			BWindow::MessageReceived(message);
			break;
	}
}


bool
SettingsWindow::QuitRequested()
{
	return true;
}


BRect
SettingsWindow::_RelativeTo(BWindow* window)
{
	BRect frame = window->Frame();
	return BRect(frame.right - 150, frame.top + frame.Height() / 4,
		frame.right + 200, frame.top + frame.Height() / 4 + 50);
}