#include "utils.h"

#include "glib.h"

// win32/libc_interface.h defines its own socket(), read() and so on.

// We don't want to use it here.

#define _LIBC_INTERFACE_H_ 1

#include "purple.h"

#include <algorithm>

#include <iostream>

#include "transport/networkplugin.h"

#include "transport/logging.h"

#include "transport/config.h"

#include "transport/logging.h"

#include "geventloop.h"

// #include "valgrind/memcheck.h"

#include "malloc.h"

#endif

#include <algorithm>

#include "errno.h"

#include <boost/make_shared.hpp>

#ifdef WITH_LIBEVENT

#include <event.h>

#endif

#ifdef WIN32

#include "win32/win32dep.h"

#define close closesocket

#define ssize_t SSIZE_T

#include <process.h>

#define getpid _getpid

#endif

#include "purple_defs.h"

DEFINE_LOGGER(logger_libpurple, "libpurple");

DEFINE_LOGGER(logger, "backend");

int main_socket;

			// Set the status

			const PurpleStatusType *status_type = purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_AVAILABLE);

			if (status_type != NULL) {

				purple_account_set_status_wrapped(account, purple_status_type_get_id_wrapped(status_type), TRUE, NULL);

			}

		}

		void handleLogoutRequest(const std::string &user, const std::string &legacyName) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				if (purple_account_get_int_wrapped(account, "version", 0) != 0) {

					std::string data = stringOf(purple_account_get_int_wrapped(account, "version", 0));

					g_file_set_contents ("gfire.cfg", data.c_str(), data.size(), NULL);

				}

// 				VALGRIND_DO_LEAK_CHECK;

				m_sessions.erase(user);

				purple_account_disconnect_wrapped(account);

				purple_account_set_enabled_wrapped(account, "spectrum", FALSE);

				m_accounts.erase(account);

				purple_accounts_delete_wrapped(account);

#ifndef WIN32

				malloc_trim(0);

#endif

#endif

// 				VALGRIND_DO_LEAK_CHECK;

			}

		}

		void handleStatusChangeRequest(const std::string &user, int status, const std::string &statusMessage) {

			PurpleAccount *account = m_sessions[user];

			if (account) {

				int st;

				switch(status) {

					case pbnetwork::STATUS_AWAY: {

						st = PURPLE_STATUS_AWAY;

						if (!purple_account_get_status_type_with_primitive_wrapped(account, PURPLE_STATUS_AWAY))

							st = PURPLE_STATUS_EXTENDED_AWAY;

						else

							st = PURPLE_STATUS_AWAY;

						break;

					}

					case pbnetwork::STATUS_DND: {

						st = PURPLE_STATUS_UNAVAILABLE;

						break;

					}

 *

 * 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 "transport/logging.h"

#include "storageresponder.h"

#include "Swiften/Swiften.h"

#include "Swiften/Server/ServerStanzaChannel.h"

#include "Swiften/Elements/StreamError.h"

#include "malloc.h"

#endif

// #include "valgrind/memcheck.h"

namespace Transport {

DEFINE_LOGGER(logger, "UserManager");

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

	m_cachedUser = NULL;

	m_onlineBuddies = 0;

	m_sentToXMPP = 0;

	m_sentToBackend = 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));

}

void UserManager::removeUser(User *user, bool onUserBehalf) {

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

	if (m_cachedUser == user)

		m_cachedUser = NULL;

	if (m_component->inServerMode()) {

		disconnectUser(user->getJID());

	}

	else {

		// User could be disconnected by User::handleDisconnect() method, but

		// Transport::PresenceOracle could still contain his last presence.

		// We have to clear all received presences for this user in PresenceOracle.

		m_component->getPresenceOracle()->clearPresences(user->getJID().toBare());

	}

	if (m_storageBackend && onUserBehalf) {

		m_storageBackend->setUserOnline(user->getUserInfo().id, false);

	}

	onUserDestroyed(user);

	delete user;

#ifndef WIN32

	malloc_trim(0);

#endif

#endif

// 	VALGRIND_DO_LEAK_CHECK;

}

void UserManager::removeAllUsers(bool onUserBehalf) {

	while(m_users.begin() != m_users.end()) {

		removeUser((*m_users.begin()).second, onUserBehalf);

	}

}

int UserManager::getUserCount() {

	return m_users.size();

}

void UserManager::handleDiscoInfo(const Swift::JID& jid, boost::shared_ptr<Swift::DiscoInfo> info) {

	User *user = getUser(jid.toBare().toString());

	if (!user) {

		return;

	}

	user->handleDiscoInfo(jid, info);

}