/*
 * Copyright 2005, Axel Dörfler, axeld@pinc-software.de
 * All rights reserved. Distributed under the terms of the MIT License.
 *
 * Copyright 2010-2012 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *      Hamish Morrison, hamish@lavabit.com
 *      Alexander von Gluck, kallisti5@unixzen.com
 */


#include "Settings.h"

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

#include <AutoDeleter.h>
#include <AutoDeleterDrivers.h>
#include <File.h>
#include <FindDirectory.h>
#include <Path.h>
#include <VolumeRoster.h>

#include <driver_settings.h>


static const char* const kWindowSettingsFile = "virtualmemory_preferences";
static const char* const kVirtualMemorySettings = "virtual_memory";
static const off_t kMegaByte = 1024 * 1024;
static const off_t kGigaByte = kMegaByte * 1024;


Settings::Settings()
{
	fDefaultSettings.enabled = true;
	fDefaultSettings.automatic = true;

	system_info sysInfo;
	get_system_info(&sysInfo);

	fDefaultSettings.size = (off_t)sysInfo.max_pages * B_PAGE_SIZE;
	if (fDefaultSettings.size <= kGigaByte) {
		// Memory under 1GB? double the swap
		// This matches the behaviour of the kernel
		fDefaultSettings.size *= 2;
	}

	fDefaultSettings.volume = dev_for_path("/boot");
}


void
Settings::SetSwapEnabled(bool enabled, bool revertable)
{
	fCurrentSettings.enabled = enabled;
	if (!revertable)
		fInitialSettings.enabled = enabled;
}


void
Settings::SetSwapAutomatic(bool automatic, bool revertable)
{
	fCurrentSettings.automatic = automatic;
	if (!revertable)
		fInitialSettings.automatic = automatic;
}


void
Settings::SetSwapSize(off_t size, bool revertable)
{
	fCurrentSettings.size = size;
	if (!revertable)
		fInitialSettings.size = size;
}


void
Settings::SetSwapVolume(dev_t volume, bool revertable)
{
	fCurrentSettings.volume = volume;
	if (!revertable)
		fInitialSettings.volume = volume;

}


void
Settings::SetWindowPosition(BPoint position)
{
	fWindowPosition = position;
}


status_t
Settings::ReadWindowSettings()
{
	BPath path;
	if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
		return B_ERROR;

	path.Append(kWindowSettingsFile);
	BFile file;
	if (file.SetTo(path.Path(), B_READ_ONLY) != B_OK)
		return B_ERROR;

	if (file.Read(&fWindowPosition, sizeof(BPoint)) == sizeof(BPoint))
		return B_OK;

	return B_ERROR;
}


status_t
Settings::WriteWindowSettings()
{
	BPath path;
	if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) < B_OK)
		return B_ERROR;

	path.Append(kWindowSettingsFile);

	BFile file;
	if (file.SetTo(path.Path(), B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE)
		!= B_OK)
		return B_ERROR;

	file.Write(&fWindowPosition, sizeof(BPoint));
	return B_OK;
}


status_t
Settings::ReadSwapSettings()
{
	DriverSettingsUnloader settings(
		load_driver_settings(kVirtualMemorySettings));
	if (!settings.IsSet())
		return kErrorSettingsNotFound;

	const char* enabled = get_driver_parameter(settings.Get(),
		"vm", NULL, NULL);
	const char* automatic = get_driver_parameter(settings.Get(),
		"swap_auto", NULL, NULL);
	const char* size = get_driver_parameter(settings.Get(),
		"swap_size", NULL, NULL);
	const char* volume = get_driver_parameter(settings.Get(),
		"swap_volume_name", NULL, NULL);
	const char* device = get_driver_parameter(settings.Get(),
		"swap_volume_device", NULL, NULL);
	const char* filesystem = get_driver_parameter(settings.Get(),
		"swap_volume_filesystem", NULL, NULL);
	const char* capacity = get_driver_parameter(settings.Get(),
		"swap_volume_capacity", NULL, NULL);

	if (enabled == NULL	|| automatic == NULL || size == NULL || device == NULL
		|| volume == NULL || capacity == NULL || filesystem == NULL)
		return kErrorSettingsInvalid;

	off_t volCapacity = atoll(capacity);

	SetSwapEnabled(get_driver_boolean_parameter(settings.Get(),
		"vm", true, false));
	SetSwapAutomatic(get_driver_boolean_parameter(settings.Get(),
		"swap_auto", true, false));
	SetSwapSize(atoll(size));

	int32 bestScore = -1;
	dev_t bestVol = -1;

	BVolume vol;
	fs_info volStat;
	BVolumeRoster roster;
	while (roster.GetNextVolume(&vol) == B_OK) {
		if (!vol.IsPersistent() || vol.IsReadOnly() || vol.IsRemovable()
			|| vol.IsShared())
			continue;
		if (fs_stat_dev(vol.Device(), &volStat) == 0) {
			int32 score = 0;
			if (strcmp(volume, volStat.volume_name) == 0)
				score += 4;
			if (strcmp(device, volStat.device_name) == 0)
				score += 3;
			if (volCapacity == volStat.total_blocks * volStat.block_size)
				score += 2;
			if (strcmp(filesystem, volStat.fsh_name) == 0)
				score += 1;
			if (score >= 4 && score > bestScore) {
				bestVol = vol.Device();
				bestScore = score;
			}
		}
	}

	SetSwapVolume(bestVol);
	fInitialSettings = fCurrentSettings;

	if (bestVol < 0)
		return kErrorVolumeNotFound;

	return B_OK;
}


status_t
Settings::WriteSwapSettings()
{
	BPath path;
	if (find_directory(B_USER_SETTINGS_DIRECTORY, &path) != B_OK)
		return B_ERROR;

	path.Append("kernel/drivers");
	path.Append(kVirtualMemorySettings);

	BFile file;
	if (file.SetTo(path.Path(), B_WRITE_ONLY | B_CREATE_FILE | B_ERASE_FILE)
		!= B_OK)
		return B_ERROR;

	fs_info info;
	if (fs_stat_dev(SwapVolume(), &info) != 0)
		return B_ERROR;

	char buffer[1024];
	snprintf(buffer, sizeof(buffer), "vm %s\nswap_auto %s\nswap_size %"
		B_PRIdOFF "\nswap_volume_name %s\nswap_volume_device %s\n"
		"swap_volume_filesystem %s\nswap_volume_capacity %" B_PRIdOFF "\n",
		SwapEnabled() ? "on" : "off", SwapAutomatic() ? "yes" : "no",
		SwapSize(), info.volume_name, info.device_name, info.fsh_name,
		info.total_blocks * info.block_size);

	file.Write(buffer, strlen(buffer));
	return B_OK;
}


bool
Settings::IsRevertable()
{
	return SwapEnabled() != fInitialSettings.enabled
		|| SwapAutomatic() != fInitialSettings.automatic
		|| SwapSize() != fInitialSettings.size
		|| SwapVolume() != fInitialSettings.volume;
}


void
Settings::RevertSwapSettings()
{
	SetSwapEnabled(fInitialSettings.enabled);
	SetSwapAutomatic(fInitialSettings.automatic);
	SetSwapSize(fInitialSettings.size);
	SetSwapVolume(fInitialSettings.volume);
}


bool
Settings::IsDefaultable()
{
	return SwapEnabled() != fDefaultSettings.enabled
		|| SwapAutomatic() != fDefaultSettings.automatic
		|| SwapSize() != fDefaultSettings.size
		|| SwapVolume() != fDefaultSettings.volume;
}


void
Settings::DefaultSwapSettings(bool revertable)
{
	SetSwapEnabled(fDefaultSettings.enabled);
	SetSwapAutomatic(fDefaultSettings.automatic);
	SetSwapSize(fDefaultSettings.size);
	SetSwapVolume(fDefaultSettings.volume);
	if (!revertable)
		fInitialSettings = fDefaultSettings;
}