// ServerManager.cpp

#include "ServerManager.h"

#include <errno.h>
#include <unistd.h>

#ifdef HAIKU_TARGET_PLATFORM_BEOS
#	include <socket.h>
#else
#	include <netinet/in.h>
#	include <sys/socket.h>
#endif

#include <AutoDeleter.h>
#include <AutoLocker.h>
#include <ByteOrder.h>
#include <HashMap.h>

#include "Compatibility.h"
#include "DebugSupport.h"
#include "ExtendedServerInfo.h"
#include "InsecureChannel.h"
#include "NetAddress.h"
#include "NetFSDefs.h"
#include "RequestChannel.h"
#include "Requests.h"
#include "TaskManager.h"
#include "Utils.h"

// server info states
enum {
	STATE_ADDING,
	STATE_REMOVING,
	STATE_UPDATING,
	STATE_READY,
	STATE_OBSOLETE
};


// ServerInfoMap
struct ServerManager::ServerInfoMap : HashMap<NetAddress, ExtendedServerInfo*> {
};

// ServerInfoTask
class ServerManager::ServerInfoTask : public Task {
public:
	ServerInfoTask(ServerManager* manager, ExtendedServerInfo* oldServerInfo,
		ExtendedServerInfo* serverInfo)
		: Task("server info task"),
		  fServerManager(manager),
		  fOldServerInfo(oldServerInfo),
		  fServerInfo(serverInfo),
		  fFD(-1),
		  fSuccess(false)
	{
		if (fServerInfo)
			fServerInfo->AcquireReference();
	}

	virtual ~ServerInfoTask()
	{
		Stop();
		if (!fSuccess) {
			if (fOldServerInfo)
				fServerManager->_UpdatingServerFailed(fServerInfo);
			else
				fServerManager->_AddingServerFailed(fServerInfo);
		}
		if (fServerInfo)
			fServerInfo->ReleaseReference();
	}

	status_t Init()
	{
		// create a socket
		fFD = socket(AF_INET, SOCK_STREAM, 0);
		if (fFD < 0) {
			ERROR("ServerManager::ServerInfoTask: ERROR: Failed to create "
				"socket: %s\n", strerror(errno));
			return errno;
		}
		return B_OK;
	}

	virtual status_t Execute()
	{
		// connect to the server info port
		sockaddr_in addr = fServerInfo->GetAddress().GetAddress();
		addr.sin_port = htons(kDefaultServerInfoPort);
		if (connect(fFD, (sockaddr*)&addr, sizeof(addr)) < 0) {
			ERROR("ServerManager::ServerInfoTask: ERROR: Failed to connect "
				"to server info port: %s\n", strerror(errno));
			return errno;
		}

		// create a channel
		InsecureChannel channel(fFD);

		// receive a request
		RequestChannel requestChannel(&channel);
		Request* _request;
		status_t error = requestChannel.ReceiveRequest(&_request);
		if (error != B_OK) {
			ERROR("ServerManager::ServerInfoTask: ERROR: Failed to receive "
				"server info request: %s\n", strerror(errno));
			return error;
		}
		ObjectDeleter<Request> requestDeleter(_request);
		ServerInfoRequest* request = dynamic_cast<ServerInfoRequest*>(_request);
		if (!request) {
			ERROR("ServerManager::ServerInfoTask: ERROR: Received request "
				"is not a server info request.\n");
			return B_BAD_DATA;
		}

		// get the info
		error = fServerInfo->SetTo(&request->serverInfo);
		if (error != B_OK)
			return error;

		// notify the manager
		if (fOldServerInfo)
			fServerManager->_ServerUpdated(fServerInfo);
		else
			fServerManager->_ServerAdded(fServerInfo);

		fSuccess = true;
		return B_OK;
	}

	virtual void Stop()
	{
		safe_closesocket(fFD);
	}

private:
	ServerManager*		fServerManager;
	ExtendedServerInfo*	fOldServerInfo;
	ExtendedServerInfo*	fServerInfo;
	int32				fFD;
	bool				fUpdate;
	bool				fSuccess;
};


// #pragma mark -

// constructor
ServerManager::ServerManager(Listener* listener)
	: fLock("server manager"),
	  fBroadcastListener(-1),
	  fBroadcastListenerSocket(-1),
	  fListener(listener),
	  fTerminating(false)
{
}

// destructor
ServerManager::~ServerManager()
{
	Uninit();
}

// Init
status_t
ServerManager::Init()
{
	// create the server info map
	fServerInfos = new(std::nothrow) ServerInfoMap();
	if (!fServerInfos)
		RETURN_ERROR(B_NO_MEMORY);
	status_t error = fServerInfos->InitCheck();
	if (error != B_OK)
		RETURN_ERROR(error);

	// init the broadcast listener
	error = _InitBroadcastListener();
	if (error != B_OK)
		RETURN_ERROR(error);

	return B_OK;
}

// Uninit
void
ServerManager::Uninit()
{
	// stop the broadcast listener
	fTerminating = true;
	_TerminateBroadcastListener();

	// remove all server infos
	AutoLocker<Locker> _(fLock);
	for (ServerInfoMap::Iterator it = fServerInfos->GetIterator();
		 it.HasNext();) {
		ExtendedServerInfo* serverInfo = it.Next().value;
		serverInfo->ReleaseReference();
	}
	fServerInfos->Clear();
}

// Run
void
ServerManager::Run()
{
	// start the broadcast listener
	resume_thread(fBroadcastListener);
}

// GetServerInfo
ExtendedServerInfo*
ServerManager::GetServerInfo(const NetAddress& address)
{
	AutoLocker<Locker> _(fLock);
	ExtendedServerInfo* serverInfo = fServerInfos->Get(address);
	if (!serverInfo
		|| (serverInfo->GetState() != STATE_READY
			&& serverInfo->GetState() != STATE_UPDATING)) {
		return NULL;
	}
	serverInfo->AcquireReference();
	return serverInfo;
}

// AddServer
status_t
ServerManager::AddServer(const NetAddress& address)
{
	// check, if the server is already known
	AutoLocker<Locker> locker(fLock);
	ExtendedServerInfo* oldInfo = fServerInfos->Get(address);
	if (oldInfo)
		return B_OK;

	// create a new server info and add it
	ExtendedServerInfo* serverInfo
		= new(std::nothrow) ExtendedServerInfo(address);
	if (!serverInfo)
		return B_NO_MEMORY;
	serverInfo->SetState(STATE_ADDING);
	BReference<ExtendedServerInfo> serverInfoReference(serverInfo, true);
	status_t error = fServerInfos->Put(address, serverInfo);
	if (error != B_OK)
		return error;
	serverInfo->AcquireReference();

	// create and execute the task -- it will do what is necessary
	ServerInfoTask task(this, NULL, serverInfo);
	error = task.Init();
	if (error != B_OK)
		return error;

	locker.Unlock();
	return task.Execute();
}

// RemoveServer
void
ServerManager::RemoveServer(const NetAddress& address)
{
	// check, if the server is known at all
	AutoLocker<Locker> locker(fLock);
	ExtendedServerInfo* serverInfo = fServerInfos->Get(address);
	if (!serverInfo)
		return;

	// If its current state is not STATE_READY, then an info thread is currently
	// trying to add/update it. We mark the info STATE_REMOVING, which will
	// remove the info as soon as possible.
	if (serverInfo->GetState() == STATE_READY) {
		BReference<ExtendedServerInfo> _(serverInfo);
		_RemoveServer(serverInfo);
		locker.Unlock();
		fListener->ServerRemoved(serverInfo);
	} else
		serverInfo->SetState(STATE_REMOVING);
}

// _BroadcastListenerEntry
int32
ServerManager::_BroadcastListenerEntry(void* data)
{
	return ((ServerManager*)data)->_BroadcastListener();
}

// _BroadcastListener
int32
ServerManager::_BroadcastListener()
{
	TaskManager taskManager;
	while (!fTerminating) {
		taskManager.RemoveDoneTasks();

		// receive
		sockaddr_in addr;
		addr.sin_family = AF_INET;
		addr.sin_port = htons(kDefaultBroadcastPort);
		addr.sin_addr.s_addr = INADDR_ANY;
		socklen_t addrSize = sizeof(addr);
		BroadcastMessage message;
//PRINT(("ServerManager::_BroadcastListener(): recvfrom()...\n"));
		ssize_t bytesRead = recvfrom(fBroadcastListenerSocket, &message,
			sizeof(message), 0, (sockaddr*)&addr, &addrSize);
		if (bytesRead < 0) {
			PRINT("ServerManager::_BroadcastListener(): recvfrom() "
				"failed: %s\n", strerror(errno));
			continue;
		}

		// check message size, magic, and protocol version
		if (bytesRead != sizeof(BroadcastMessage)) {
			PRINT("ServerManager::_BroadcastListener(): received "
				"%ld bytes, but it should be %lu\n", bytesRead,
				sizeof(BroadcastMessage));
			continue;
		}
		if (message.magic != B_HOST_TO_BENDIAN_INT32(BROADCAST_MESSAGE_MAGIC)) {
			PRINT("ServerManager::_BroadcastListener(): message has"
				" bad magic.\n");
			continue;
		}
		if (message.protocolVersion
			!= (int32)B_HOST_TO_BENDIAN_INT32(NETFS_PROTOCOL_VERSION)) {
			PRINT("ServerManager::_BroadcastListener(): protocol "
				"version does not match: %" B_PRId32 " vs. %d.\n",
				(int32)B_BENDIAN_TO_HOST_INT32(
					message.protocolVersion),
				NETFS_PROTOCOL_VERSION);
			continue;
		}

		// check, if the server is local
		NetAddress netAddress(addr);
		#ifndef ADD_SERVER_LOCALHOST
			if (netAddress.IsLocal())
				continue;
		#endif	// ADD_SERVER_LOCALHOST

		AutoLocker<Locker> locker(fLock);
		ExtendedServerInfo* oldServerInfo = fServerInfos->Get(netAddress);

		// examine the message
		switch (B_BENDIAN_TO_HOST_INT32(message.message)) {
			case BROADCAST_MESSAGE_SERVER_TICK:
//				PRINT(("ServerManager::_BroadcastListener(): "
//					"BROADCAST_MESSAGE_SERVER_TICK.\n"));
				if (oldServerInfo)
					continue;
				break;
			case BROADCAST_MESSAGE_SERVER_UPDATE:
//				PRINT(("ServerManager::_BroadcastListener(): "
//					"BROADCAST_MESSAGE_SERVER_UPDATE.\n"));
				break;
			case BROADCAST_MESSAGE_CLIENT_HELLO:
//				PRINT(("ServerManager::_BroadcastListener(): "
//					"BROADCAST_MESSAGE_CLIENT_HELLO. Ignoring.\n"));
				continue;
				break;
		}

		if (oldServerInfo && oldServerInfo->GetState() != STATE_READY)
			continue;

		// create a new server info and add it
		ExtendedServerInfo* serverInfo
			= new(std::nothrow) ExtendedServerInfo(netAddress);
		if (!serverInfo)
			return B_NO_MEMORY;
		serverInfo->SetState(STATE_ADDING);
		BReference<ExtendedServerInfo> serverInfoReference(serverInfo, true);
		if (oldServerInfo) {
			oldServerInfo->SetState(STATE_UPDATING);
		} else {
			status_t error = fServerInfos->Put(netAddress, serverInfo);
			if (error != B_OK)
				continue;
			serverInfo->AcquireReference();
		}

		// create a task to add/update the server info
		ServerInfoTask* task = new(std::nothrow) ServerInfoTask(this, oldServerInfo,
			serverInfo);
		if (!task) {
			if (oldServerInfo) {
				oldServerInfo->SetState(STATE_READY);
			} else {
				fServerInfos->Remove(serverInfo->GetAddress());
				serverInfo->ReleaseReference();
			}
			continue;
		}
		// now the task has all info and will call the respective cleanup
		// method when being deleted
		if (task->Init() != B_OK) {
			delete task;
			continue;
		}
		status_t error = taskManager.RunTask(task);
		if (error != B_OK) {
			ERROR("ServerManager::_BroadcastListener(): Failed to start server "
				"info task: %s\n", strerror(error));
			continue;
		}
	}
	return B_OK;
}

// _InitBroadcastListener
status_t
ServerManager::_InitBroadcastListener()
{
	// create a socket
	fBroadcastListenerSocket = socket(AF_INET, SOCK_DGRAM, 0);
	if (fBroadcastListenerSocket < 0)
		return errno;
	// bind it to the port
	sockaddr_in addr;
	addr.sin_family = AF_INET;
	addr.sin_port = htons(kDefaultBroadcastPort);
	addr.sin_addr.s_addr = INADDR_ANY;
	if (bind(fBroadcastListenerSocket, (sockaddr*)&addr, sizeof(addr)) < 0) {
		ERROR("ServerManager::_InitBroadcastListener(): ERROR: bind()ing the "
			"broadcasting socket failed: %s\n", strerror(errno));
		safe_closesocket(fBroadcastListenerSocket);
		return errno;
	}
	// spawn the thread
	#if USER
		fBroadcastListener = spawn_thread(&_BroadcastListenerEntry,
			"broadcast listener", B_NORMAL_PRIORITY, this);
	#else
		fBroadcastListener = spawn_kernel_thread(&_BroadcastListenerEntry,
			"broadcast listener", B_NORMAL_PRIORITY, this);
	#endif
	if (fBroadcastListener < 0)
		return fBroadcastListener;
	return B_OK;
}

// _TerminateBroadcastListener
void
ServerManager::_TerminateBroadcastListener()
{
	safe_closesocket(fBroadcastListenerSocket);
	if (fBroadcastListener >= 0) {
		int32 result;
		wait_for_thread(fBroadcastListener, &result);
	}
}

// _ServerAdded
void
ServerManager::_ServerAdded(ExtendedServerInfo* serverInfo)
{
	AutoLocker<Locker> locker(fLock);
	if (fServerInfos->Get(serverInfo->GetAddress()) == serverInfo) {
		// check whether someone told us to remove the server in the meantime
		if (serverInfo->GetState() == STATE_REMOVING) {
			_RemoveServer(serverInfo);
			if (fListener) {
				locker.Unlock();
				fListener->ServerRemoved(serverInfo);
			}
			return;
		}

		// no, everything is fine: go on...
		serverInfo->SetState(STATE_READY);
		if (fListener) {
			locker.Unlock();
			fListener->ServerAdded(serverInfo);
		}
	} else {
		WARN("ServerManager::_ServerAdded(%p): WARNING: Unexpected server "
			"info.\n", serverInfo);
	}
}

// _ServerUpdated
void
ServerManager::_ServerUpdated(ExtendedServerInfo* serverInfo)
{
	AutoLocker<Locker> locker(fLock);
	ExtendedServerInfo* oldInfo = fServerInfos->Get(serverInfo->GetAddress());
	if (serverInfo != oldInfo) {
		// check whether someone told us to remove the server in the meantime
		if (oldInfo->GetState() == STATE_REMOVING) {
			oldInfo->AcquireReference();
			_RemoveServer(oldInfo);
			if (fListener) {
				locker.Unlock();
				fListener->ServerRemoved(oldInfo);
			}
			oldInfo->ReleaseReference();
			return;
		}

		// no, everything is fine: go on...
		fServerInfos->Put(serverInfo->GetAddress(), serverInfo);
		serverInfo->AcquireReference();
		serverInfo->SetState(STATE_READY);
		oldInfo->SetState(STATE_OBSOLETE);
		if (fListener) {
			locker.Unlock();
			fListener->ServerUpdated(oldInfo, serverInfo);
		}
		oldInfo->ReleaseReference();
	} else {
		WARN("ServerManager::_ServerUpdated(%p): WARNING: Unexpected server "
			"info.\n", serverInfo);
	}
}

// _AddingServerFailed
void
ServerManager::_AddingServerFailed(ExtendedServerInfo* serverInfo)
{
	AutoLocker<Locker> locker(fLock);
	if (fServerInfos->Get(serverInfo->GetAddress()) == serverInfo) {
		bool removing = (serverInfo->GetState() == STATE_REMOVING);
		fServerInfos->Remove(serverInfo->GetAddress());
		serverInfo->ReleaseReference();
		serverInfo->SetState(STATE_OBSOLETE);

		// notify the listener, if someone told us in the meantime to remove
		// the server
		if (removing) {
			locker.Unlock();
			fListener->ServerRemoved(serverInfo);
		}
	} else {
		WARN("ServerManager::_AddingServerFailed(%p): WARNING: Unexpected "
			"server info.\n", serverInfo);
	}
}

// _UpdatingServerFailed
void
ServerManager::_UpdatingServerFailed(ExtendedServerInfo* serverInfo)
{
	AutoLocker<Locker> locker(fLock);
	ExtendedServerInfo* oldInfo = fServerInfos->Get(serverInfo->GetAddress());
	if (serverInfo != oldInfo) {
		// check whether someone told us to remove the server in the meantime
		if (oldInfo->GetState() == STATE_REMOVING) {
			oldInfo->AcquireReference();
			_RemoveServer(oldInfo);
			if (fListener) {
				locker.Unlock();
				fListener->ServerRemoved(oldInfo);
			}
			oldInfo->ReleaseReference();
			serverInfo->SetState(STATE_OBSOLETE);
			return;
		}

		// no, everything is fine: go on...
		serverInfo->SetState(STATE_OBSOLETE);
		oldInfo->SetState(STATE_READY);
	} else {
		WARN("ServerManager::_UpdatingServerFailed(%p): WARNING: Unexpected "
			"server info.\n", serverInfo);
	}
}

// _RemoveServer
//
// fLock must be held.
void
ServerManager::_RemoveServer(ExtendedServerInfo* serverInfo)
{
	if (!serverInfo)
		return;

	ExtendedServerInfo* oldInfo = fServerInfos->Get(serverInfo->GetAddress());
	if (oldInfo) {
		fServerInfos->Remove(oldInfo->GetAddress());
		oldInfo->SetState(STATE_OBSOLETE);
		oldInfo->ReleaseReference();
	}
}


// #pragma mark -

// destructor
ServerManager::Listener::~Listener()
{
}