* (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#include "transport/usermanager.h"

#include "transport/user.h"

#include "transport/transport.h"

#include "transport/storagebackend.h"

#include "transport/conversationmanager.h"

#include "transport/rostermanager.h"

#include "transport/userregistry.h"

#include "storageresponder.h"

#include "log4cxx/logger.h"

#include "Swiften/Swiften.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

using namespace log4cxx;

namespace Transport {

static LoggerPtr logger = Logger::getLogger("UserManager");

UserManager::UserManager(Component *component, UserRegistry *userRegistry, StorageBackend *storageBackend) {

	m_cachedUser = NULL;

	m_onlineBuddies = 0;

	m_component = component;

	m_storageBackend = storageBackend;

	m_storageResponder = NULL;

	m_userRegistry = userRegistry;

	if (m_storageBackend) {

		m_storageResponder = new StorageResponder(component->getIQRouter(), m_storageBackend, this);

		m_storageResponder->start();

	}

	component->onUserPresenceReceived.connect(bind(&UserManager::handlePresence, this, _1));

	m_component->getStanzaChannel()->onMessageReceived.connect(bind(&UserManager::handleMessageReceived, this, _1));

	m_component->getStanzaChannel()->onPresenceReceived.connect(bind(&UserManager::handleGeneralPresenceReceived, this, _1));

void UserManager::addUser(User *user) {

	m_users[user->getJID().toBare().toString()] = user;

	onUserCreated(user);

}

User *UserManager::getUser(const std::string &barejid){

	if (m_cachedUser && barejid == m_cachedUser->getJID().toBare().toString()) {

		return m_cachedUser;

	}

	if (m_users.find(barejid) != m_users.end()) {

		User *user = m_users[barejid];

		m_cachedUser = user;

		return user;

	}

	return NULL;

}

void UserManager::removeUser(User *user) {

	m_users.erase(user->getJID().toBare().toString());

	if (m_cachedUser == user)

		m_cachedUser = NULL;

	onUserDestroyed(user);

	delete user;

}

int UserManager::getUserCount() {

	return m_users.size();

}

void UserManager::handlePresence(Swift::Presence::ref presence) {

	std::string barejid = presence->getTo().toBare().toString();

	std::string userkey = presence->getFrom().toBare().toString();

	User *user = getUser(userkey);

	// Create user class if it's not there

	if (!user) {

		// Admin user is not legacy network user, so do not create User class instance for him

		if (CONFIG_STRING(m_component->getConfig(), "service.admin_username") == presence->getFrom().getNode()) {

			return;

		}

		// No user and unavailable presence -> answer with unavailable

		if (presence->getType() == Swift::Presence::Unavailable) {

			Swift::Presence::ref response = Swift::Presence::create();

			response->setTo(presence->getFrom());

			response->setFrom(presence->getTo());

			response->setType(Swift::Presence::Unavailable);