/*
 * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "UserlandFSServer.h"

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

#include <Application.h>
#include <Clipboard.h>
#include <Entry.h>
#include <FindDirectory.h>
#include <fs_interface.h>
#include <Locker.h>
#include <Path.h>
#include <PathFinder.h>
#include <StringList.h>

#include <image_private.h>

#include "AutoDeleter.h"
#include "AutoLocker.h"
#include "Compatibility.h"
#include "Debug.h"
#include "FileSystem.h"
#include "RequestThread.h"
#include "ServerDefs.h"
#include "UserlandFSDefs.h"


static const int32 kRequestThreadCount = 10;


// constructor
UserlandFSServer::UserlandFSServer(const char* signature)
	: BApplication(signature),
	  fAddOnImage(-1),
	  fFileSystem(NULL),
	  fNotificationRequestPort(NULL),
	  fRequestThreads(NULL)
{
}


// destructor
UserlandFSServer::~UserlandFSServer()
{
	if (fRequestThreads) {
		for (int32 i = 0; i < kRequestThreadCount; i++)
			fRequestThreads[i].PrepareTermination();
		for (int32 i = 0; i < kRequestThreadCount; i++)
			fRequestThreads[i].Terminate();
		delete[] fRequestThreads;
	}
	delete fNotificationRequestPort;
	delete fFileSystem;
	if (fAddOnImage >= 0)
		unload_add_on(fAddOnImage);
}


// Init
status_t
UserlandFSServer::Init(const char* fileSystem, port_id port)
{
	// get the add-on path
	BPathFinder pathFinder;
	BStringList paths;
	status_t error = pathFinder.FindPaths(B_FIND_PATH_ADD_ONS_DIRECTORY,
		"userlandfs", B_FIND_PATH_EXISTING_ONLY, paths);
	if (error != B_OK)
		RETURN_ERROR(error);

	BPath addOnPath;
	for (int index = 0; index < paths.CountStrings(); index++) {
		error = addOnPath.SetTo(paths.StringAt(index));
		if (error != B_OK)
			RETURN_ERROR(error);

		error = addOnPath.Append(fileSystem);
		if (error != B_OK)
			RETURN_ERROR(error);

		BEntry entry(addOnPath.Path());
		if (entry.Exists())
			break;
		else
			addOnPath.Unset();
	}

	if (addOnPath.InitCheck() != B_OK)
		RETURN_ERROR(B_BAD_VALUE);

	// load the add-on
	fAddOnImage = load_add_on(addOnPath.Path());
	if (fAddOnImage < 0)
		RETURN_ERROR(fAddOnImage);

	// Get the FS creation function -- the add-on links against one of our
	// libraries exporting that function, so we search recursively.
	union {
		void* address;
		status_t (*function)(const char*, image_id, FileSystem**);
	} createFSFunction;
	error = get_image_symbol_etc(fAddOnImage, "userlandfs_create_file_system",
		B_SYMBOL_TYPE_TEXT, true, NULL, &createFSFunction.address);
	if (error != B_OK)
		RETURN_ERROR(error);

	// create the FileSystem interface
	error = createFSFunction.function(fileSystem, fAddOnImage, &fFileSystem);
	if (error != B_OK)
		RETURN_ERROR(error);

	// create the notification request port
	fNotificationRequestPort = new(std::nothrow) RequestPort(kRequestPortSize);
	if (!fNotificationRequestPort)
		RETURN_ERROR(B_NO_MEMORY);
	error = fNotificationRequestPort->InitCheck();
	if (error != B_OK)
		RETURN_ERROR(error);

	// now create the request threads
	fRequestThreads = new(std::nothrow) RequestThread[kRequestThreadCount];
	if (!fRequestThreads)
		RETURN_ERROR(B_NO_MEMORY);
	for (int32 i = 0; i < kRequestThreadCount; i++) {
		error = fRequestThreads[i].Init(fFileSystem);
		if (error != B_OK)
			RETURN_ERROR(error);
	}

	// run the threads
	for (int32 i = 0; i < kRequestThreadCount; i++)
		fRequestThreads[i].Run();

	// enter the debugger here, if desired
	if (gServerSettings.ShallEnterDebugger())
		debugger("File system ready to use.");

	// finally announce our existence
	error = _Announce(fileSystem, port);
	RETURN_ERROR(error);
}


// GetNotificationRequestPort
RequestPort*
UserlandFSServer::GetNotificationRequestPort()
{
	if (UserlandFSServer* server = dynamic_cast<UserlandFSServer*>(be_app))
		return server->fNotificationRequestPort;
	return NULL;
}


// GetFileSystem
FileSystem*
UserlandFSServer::GetFileSystem()
{
	if (UserlandFSServer* server = dynamic_cast<UserlandFSServer*>(be_app))
		return server->fFileSystem;
	return NULL;
}


// _Announce
status_t
UserlandFSServer::_Announce(const char* fsName, port_id port)
{
	// if not given, create a port
	if (port < 0) {
		char portName[B_OS_NAME_LENGTH];
		snprintf(portName, sizeof(portName), "_userlandfs_%s", fsName);

		port = create_port(1, portName);
		if (port < 0)
			RETURN_ERROR(port);
	}

	// allocate stack space for the FS initialization info
	const size_t bufferSize = sizeof(fs_init_info)
		+ sizeof(Port::Info) * (kRequestThreadCount + 1);
	char buffer[bufferSize];
	fs_init_info* info = (fs_init_info*)buffer;

	// get the port infos
	info->portInfoCount = kRequestThreadCount + 1;
	info->portInfos[0] = *fNotificationRequestPort->GetPortInfo();
	for (int32 i = 0; i < kRequestThreadCount; i++)
		info->portInfos[i + 1] = *fRequestThreads[i].GetPortInfo();

	// FS capabilities
	fFileSystem->GetCapabilities(info->capabilities);
	info->clientFSType = fFileSystem->GetClientFSType();

	// send the info to our port
	RETURN_ERROR(write_port(port, 0, buffer, bufferSize));
}