/*
 * Copyright 2008-2013 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT license.
 *
 * Authors:
 *		Stephan Aßmus <superstippi@gmx.de>
 *		Axel Dörfler, axeld@pinc-software.de.
 *		Karsten Heimrich. <host.haiku@gmx.de>
 */


#include "AbstractParametersPanel.h"

#include <driver_settings.h>
#include <stdio.h>

#include <Button.h>
#include <Catalog.h>
#include <DiskSystemAddOn.h>
#include <DiskSystemAddOnManager.h>
#include <GroupLayout.h>
#include <MessageFilter.h>
#include <String.h>


#undef B_TRANSLATION_CONTEXT
#define B_TRANSLATION_CONTEXT "AbstractParametersPanel"


static const uint32 kMsgOk = 'okok';
static const uint32 kParameterChanged = 'pmch';


class AbstractParametersPanel::EscapeFilter : public BMessageFilter {
public:
	EscapeFilter(AbstractParametersPanel* target)
		:
		BMessageFilter(B_ANY_DELIVERY, B_ANY_SOURCE),
		fPanel(target)
	{
	}

	virtual	~EscapeFilter()
	{
	}

	virtual filter_result Filter(BMessage* message, BHandler** target)
	{
		filter_result result = B_DISPATCH_MESSAGE;
		switch (message->what) {
			case B_KEY_DOWN:
			case B_UNMAPPED_KEY_DOWN: {
				uint32 key;
				if (message->FindInt32("raw_char", (int32*)&key) >= B_OK) {
					if (key == B_ESCAPE) {
						result = B_SKIP_MESSAGE;
						fPanel->Cancel();
					}
				}
				break;
			}
			default:
				break;
		}
		return result;
	}

private:
 	AbstractParametersPanel*	fPanel;
};


// #pragma mark -


AbstractParametersPanel::AbstractParametersPanel(BWindow* window)
	:
	BWindow(BRect(300.0, 200.0, 600.0, 300.0), 0, B_MODAL_WINDOW_LOOK,
		B_MODAL_SUBSET_WINDOW_FEEL,
		B_ASYNCHRONOUS_CONTROLS | B_AUTO_UPDATE_SIZE_LIMITS),
	fOkButton(new BButton(B_TRANSLATE("OK"), new BMessage(kMsgOk))),
	fReturnStatus(B_CANCELED),
	fEditor(NULL),
	fEscapeFilter(new EscapeFilter(this)),
	fExitSemaphore(create_sem(0, "AbstractParametersPanel exit")),
	fWindow(window)
{
	AddCommonFilter(fEscapeFilter);
	AddToSubset(fWindow);
}


AbstractParametersPanel::~AbstractParametersPanel()
{
	RemoveCommonFilter(fEscapeFilter);
	delete fEscapeFilter;

	delete_sem(fExitSemaphore);

	if (fOkButton->Window() == NULL)
		delete fOkButton;
}


bool
AbstractParametersPanel::QuitRequested()
{
	release_sem(fExitSemaphore);
	return false;
}


void
AbstractParametersPanel::MessageReceived(BMessage* message)
{
	switch (message->what) {
		case B_CANCEL:
			Cancel();
			break;

		case kMsgOk:
			fReturnStatus = B_OK;
			release_sem(fExitSemaphore);
			break;

		case kParameterChanged:
			fOkButton->SetEnabled(fEditor->ValidateParameters());
			break;

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


status_t
AbstractParametersPanel::Go(BString& parameters)
{
	BMessage storage;
	return Go(parameters, storage);
}


void
AbstractParametersPanel::Cancel()
{
	fReturnStatus = B_CANCELED;
	release_sem(fExitSemaphore);
}


void
AbstractParametersPanel::Init(B_PARAMETER_EDITOR_TYPE type,
	const BString& diskSystem, BPartition* partition)
{
	// Create partition parameter editor

	status_t status = B_ERROR;
	if (diskSystem.IsEmpty()) {
		status = partition->GetParameterEditor(type, &fEditor);
	} else {
		DiskSystemAddOnManager* manager = DiskSystemAddOnManager::Default();
		BDiskSystemAddOn* addOn = manager->GetAddOn(diskSystem);
		if (addOn != NULL) {
			// put the add-on
			manager->PutAddOn(addOn);

			status = addOn->GetParameterEditor(type, &fEditor);
		}
	}
	if (status != B_OK && status != B_NOT_SUPPORTED)
		fReturnStatus = status;

	// Create controls

	BLayoutBuilder::Group<> builder = BLayoutBuilder::Group<>(this,
		B_VERTICAL);

	if (fEditor == NULL)
		AddControls(builder, NULL);
	else
		AddControls(builder, fEditor->View());

	builder.AddGroup(B_HORIZONTAL, B_USE_DEFAULT_SPACING)
			.AddGlue()
			.Add(new BButton(B_TRANSLATE("Cancel"), new BMessage(B_CANCEL)))
			.Add(fOkButton)
		.End()
		.SetInsets(B_USE_DEFAULT_SPACING);

	SetDefaultButton(fOkButton);

	if (fEditor != NULL) {
		fEditor->SetTo(partition);
		fEditor->SetModificationMessage(new BMessage(kParameterChanged));
	}
}


status_t
AbstractParametersPanel::Go(BString& parameters, BMessage& storage)
{
	// Without an editor, we cannot change anything, anyway
	if (fEditor == NULL && NeedsEditor()) {
		parameters = "";
		if (ValidWithoutEditor() && fReturnStatus == B_CANCELED)
			fReturnStatus = B_OK;

		if (!Lock())
			return B_ERROR;
	} else {
		// run the window thread, to get an initial layout of the controls
		Hide();
		Show();
		if (!Lock())
			return B_CANCELED;

		// center the panel above the parent window
		CenterIn(fWindow->Frame());

		Show();
		Unlock();

		// block this thread now, but keep the window repainting
		while (true) {
			status_t status = acquire_sem_etc(fExitSemaphore, 1,
				B_CAN_INTERRUPT | B_RELATIVE_TIMEOUT, 50000);
			if (status != B_TIMED_OUT && status != B_INTERRUPTED)
				break;
			fWindow->UpdateIfNeeded();
		}

		if (!Lock())
			return B_CANCELED;

		if (fReturnStatus == B_OK) {
			if (fEditor != NULL && fEditor->ValidateParameters()) {
				status_t status = fEditor->GetParameters(parameters);
				if (status != B_OK)
					fReturnStatus = status;
			}
			if (fReturnStatus == B_OK)
				fReturnStatus = ParametersReceived(parameters, storage);
		}
	}

	status_t status = fReturnStatus;

	Quit();
		// NOTE: this object is toast now!

	return status;
}


bool
AbstractParametersPanel::NeedsEditor() const
{
	return true;
}


bool
AbstractParametersPanel::ValidWithoutEditor() const
{
	return true;
}

status_t
AbstractParametersPanel::ParametersReceived(const BString& parameters,
	BMessage& storage)
{
	return B_OK;
}


void
AbstractParametersPanel::AddControls(BLayoutBuilder::Group<>& builder,
	BView* editorView)
{
	if (editorView != NULL)
		builder.Add(editorView);
}