// StatisticsManager.cpp

#include "StatisticsManager.h"

#include <AutoLocker.h>
#include <HashMap.h>
#include <Message.h>

#include "DebugSupport.h"
#include "SecurityContext.h"

typedef HashMap<HashString, int32>	UserCountMap;

// ShareStatistics
class StatisticsManager::ShareStatistics {
public:
	ShareStatistics(const char* share)
		: fShare(share),
		  fUsers()
	{
	}

	~ShareStatistics()
	{
	}

	status_t Init()
	{
		return fUsers.InitCheck();
	}

	const char* GetShare() const
	{
		return fShare.GetString();
	}

	void AddUser(const char* user)
	{
		int32 count = 0;
		if (fUsers.ContainsKey(user))
			count = fUsers.Get(user);
		count++;
		fUsers.Put(user, count);
	}

	void RemoveUser(const char* user)
	{
		if (!fUsers.ContainsKey(user))
			return;

		int32 count = fUsers.Get(user);
		count--;
		if (count > 0)
			fUsers.Put(user, count);
		else
			fUsers.Remove(user);
	}

	status_t GetStatistics(BMessage* statistics)
	{
		// add "mounted by"
		for (UserCountMap::Iterator it = fUsers.GetIterator(); it.HasNext();) {
			HashString user(it.Next().key);
			status_t error = statistics->AddString("mounted by",
				user.GetString());
			if (error != B_OK)
				return error;
		}
		return B_OK;
	}

private:
	HashString		fShare;
	UserCountMap	fUsers;
};

// ShareStatisticsMap
struct StatisticsManager::ShareStatisticsMap
	: HashMap<HashString, StatisticsManager::ShareStatistics*> {
};


// constructor
StatisticsManager::StatisticsManager()
	: fLock("statistics manager"),
	  fShareStatistics(NULL)
{
}

// destructor
StatisticsManager::~StatisticsManager()
{
	// delete the share statistics
	for (ShareStatisticsMap::Iterator it = fShareStatistics->GetIterator();
		 it.HasNext();) {
		ShareStatistics* statistics = it.Next().value;
		delete statistics;
	}

	delete fShareStatistics;
}

// Init
status_t
StatisticsManager::Init()
{
	// check lock
	if (fLock.Sem() < 0)
		return fLock.Sem();

	// create share info map
	fShareStatistics = new(std::nothrow) ShareStatisticsMap;
	if (!fShareStatistics)
		return B_NO_MEMORY;
	status_t error = fShareStatistics->InitCheck();
	if (error != B_OK)
		return error;

	return B_OK;
}

// CreateDefault
status_t
StatisticsManager::CreateDefault()
{
	if (fManager)
		return B_OK;

	fManager = new(std::nothrow) StatisticsManager;
	if (!fManager)
		return B_NO_MEMORY;
	status_t error = fManager->Init();
	if (error != B_OK) {
		DeleteDefault();
		return error;
	}

	return B_OK;
}

// DeleteDefault
void
StatisticsManager::DeleteDefault()
{
	if (fManager) {
		delete fManager;
		fManager = NULL;
	}
}

// GetDefault
StatisticsManager*
StatisticsManager::GetDefault()
{
	return fManager;
}

// UserRemoved
void
StatisticsManager::UserRemoved(User* user)
{
	// the shares the user mounted should already have been unmounted
}

// ShareRemoved
void
StatisticsManager::ShareRemoved(Share* share)
{
	if (!share)
		return;

	AutoLocker<Locker> locker(fLock);

	ShareStatistics* statistics = fShareStatistics->Remove(share->GetName());
	delete statistics;
}

// ShareMounted
void
StatisticsManager::ShareMounted(Share* share, User* user)
{
	if (!share || !user)
		return;

	AutoLocker<Locker> locker(fLock);

	// get the statistics
	ShareStatistics* statistics = fShareStatistics->Get(share->GetName());
	if (!statistics) {
		// no statistics for this share yet: create
		statistics = new(std::nothrow) ShareStatistics(share->GetName());
		if (!statistics)
			return;

		// add to the map
		if (fShareStatistics->Put(share->GetName(), statistics) != B_OK) {
			delete statistics;
			return;
		}
	}

	// add the user
	statistics->AddUser(user->GetName());
}

// ShareUnmounted
void
StatisticsManager::ShareUnmounted(Share* share, User* user)
{
	if (!share || !user)
		return;

	AutoLocker<Locker> locker(fLock);

	// get the statistics
	ShareStatistics* statistics = fShareStatistics->Get(share->GetName());
	if (!statistics)
		return;

	// remove the user
	statistics->RemoveUser(user->GetName());
}

// GetUserStatistics
status_t
StatisticsManager::GetUserStatistics(User* user, BMessage* statistics)
{
	if (!user)
		return B_BAD_VALUE;

	return GetUserStatistics(user->GetName(), statistics);
}

// GetUserStatistics
status_t
StatisticsManager::GetUserStatistics(const char* user, BMessage* _statistics)
{
	if (!user || !_statistics)
		return B_BAD_VALUE;

	// nothing for now

	return B_OK;
}

// GetShareStatistics
status_t
StatisticsManager::GetShareStatistics(Share* share, BMessage* statistics)
{
	if (!share)
		return B_BAD_VALUE;

	return GetShareStatistics(share->GetName(), statistics);
}

// GetShareStatistics
status_t
StatisticsManager::GetShareStatistics(const char* share, BMessage* _statistics)
{
	if (!share || !_statistics)
		return B_BAD_VALUE;

	AutoLocker<Locker> locker(fLock);

	// get the statistics
	ShareStatistics* statistics = fShareStatistics->Get(share);
	if (!statistics)
		return B_OK;

	// get the users
	return statistics->GetStatistics(_statistics);
}


// fManager
StatisticsManager*	StatisticsManager::fManager = NULL;