/*
 * Copyright 2002-2013 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *		Ithamar R. Adema <ithamar@unet.nl>
 *		Stephan Aßmus <superstippi@gmx.de>
 *		Axel Dörfler, axeld@pinc-software.de.
 *		Bryce Groff <bgroff@hawaii.edu>
 *		Erik Jaesler <ejakowatz@users.sourceforge.net>
 */


#include "Support.h"

#include <stdio.h>

#include <Catalog.h>
#include <Locale.h>
#include <Partition.h>
#include <String.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "Support"


static const int32 kMaxSliderLimit = 0x7fffff80;
	// this is the maximum value that BSlider seem to work with fine


void
dump_partition_info(const BPartition* partition)
{
	char size[1024];
	printf("\tOffset(): %" B_PRIdOFF "\n", partition->Offset());
	printf("\tSize(): %s\n", string_for_size(partition->Size(), size,
		sizeof(size)));
	printf("\tContentSize(): %s\n", string_for_size(partition->ContentSize(),
		size, sizeof(size)));
	printf("\tBlockSize(): %" B_PRId32 "\n", partition->BlockSize());
	printf("\tPhysicalBlockSize(): %" B_PRId32 "\n", partition->PhysicalBlockSize());
	printf("\tIndex(): %" B_PRId32 "\n", partition->Index());
	printf("\tStatus(): %" B_PRId32 "\n\n", partition->Status());
	printf("\tContainsFileSystem(): %s\n",
		partition->ContainsFileSystem() ? "true" : "false");
	printf("\tContainsPartitioningSystem(): %s\n\n",
		partition->ContainsPartitioningSystem() ? "true" : "false");
	printf("\tIsDevice(): %s\n", partition->IsDevice() ? "true" : "false");
	printf("\tIsReadOnly(): %s\n", partition->IsReadOnly() ? "true" : "false");
	printf("\tIsMounted(): %s\n", partition->IsMounted() ? "true" : "false");
	printf("\tIsBusy(): %s\n\n", partition->IsBusy() ? "true" : "false");
	printf("\tFlags(): %" B_PRIx32 "\n\n", partition->Flags());
	printf("\tName(): %s\n", partition->Name());
	printf("\tContentName(): %s\n", partition->RawContentName());
	printf("\tType(): %s\n", partition->Type());
	printf("\tContentType(): %s\n", partition->ContentType());
	printf("\tID(): %" B_PRIx32 "\n\n", partition->ID());
}


bool
is_valid_partitionable_space(size_t size)
{
	// TODO: remove this again, the DiskDeviceAPI should
	// not even show these spaces to begin with
	return size >= 8 * 1024 * 1024;
}


// #pragma mark - SpaceIDMap


SpaceIDMap::SpaceIDMap()
	:
	HashMap<HashString, partition_id>(),
	fNextSpaceID(-2)
{
}


SpaceIDMap::~SpaceIDMap()
{
}


partition_id
SpaceIDMap::SpaceIDFor(partition_id parentID, off_t spaceOffset)
{
	BString key;
	key << parentID << ':' << (uint64)spaceOffset;

	if (ContainsKey(key.String()))
		return Get(key.String());

	partition_id newID = fNextSpaceID--;
	Put(key.String(), newID);

	return newID;
}


// #pragma mark -


SizeSlider::SizeSlider(const char* name, const char* label,
		BMessage* message, off_t offset, off_t size, uint32 minGranularity)
	:
	BSlider(name, label, message, 0, kMaxSliderLimit, B_HORIZONTAL,
		B_TRIANGLE_THUMB),
	fStartOffset(offset),
	fEndOffset(offset + size),
	fMaxPartitionSize(size),
	fGranularity(minGranularity)
{
	rgb_color fillColor = ui_color(B_CONTROL_HIGHLIGHT_COLOR);
	UseFillColor(true, &fillColor);

	// Lazy loop to get a power of two granularity
	while (size / fGranularity > kMaxSliderLimit)
		fGranularity *= 2;

	SetKeyIncrementValue(int32(1024 * 1024 * 1.0 * kMaxSliderLimit
		/ ((MaxPartitionSize() - 1) / fGranularity) + 0.5));

	char buffer[64];
	char minString[64];
	char maxString[64];
	snprintf(minString, sizeof(minString), B_TRANSLATE("Offset: %s"),
		string_for_size(fStartOffset, buffer, sizeof(buffer)));
	snprintf(maxString, sizeof(maxString), B_TRANSLATE("End: %s"),
		string_for_size(fEndOffset, buffer, sizeof(buffer)));
	SetLimitLabels(minString, maxString);
}


SizeSlider::~SizeSlider()
{
}


void
SizeSlider::SetValue(int32 value)
{
	BSlider::SetValue(value);

	fSize = (off_t(1.0 * (MaxPartitionSize() - 1) * Value()
		/ kMaxSliderLimit + 0.5) / fGranularity) * fGranularity;
}


const char*
SizeSlider::UpdateText() const
{
	return string_for_size(Size(), fStatusLabel, sizeof(fStatusLabel));
}


off_t
SizeSlider::Size() const
{
	return fSize;
}


void
SizeSlider::SetSize(off_t size)
{
	if (size == fSize)
		return;

	SetValue(int32(1.0 * kMaxSliderLimit / fGranularity * size
		/ ((MaxPartitionSize() - 1) / fGranularity) + 0.5));
	fSize = size;
	UpdateTextChanged();
}


off_t
SizeSlider::Offset() const
{
	// TODO: This should be the changed offset once a double
	// headed slider is implemented.
	return fStartOffset;
}


off_t
SizeSlider::MaxPartitionSize() const
{
	return fMaxPartitionSize;
}