message_timer->onTick.connect(boost::bind(&TwitterPlugin::pollForDirectMessages, this));

	tweet_timer->start();

	message_timer->start();

#if HAVE_SWIFTEN_3

		cryptoProvider = boost::shared_ptr<Swift::CryptoProvider>(Swift::PlatformCryptoProvider::create());

#endif

	LOG4CXX_INFO(logger, "Starting the plugin.");

}

TwitterPlugin::~TwitterPlugin() 

{

	delete storagebackend;

	std::set<std::string>::iterator it;

	for(it = onlineUsers.begin() ; it != onlineUsers.end() ; it++) delete userdb[*it].sessions;

	delete tp;

}

// Send data to NetworkPlugin server

void TwitterPlugin::sendData(const std::string &string) 

{

	m_conn->write(Swift::createSafeByteArray(string));

}

// Receive date from the NetworkPlugin server and invoke the appropirate payload handler (implement in the NetworkPlugin class)

void TwitterPlugin::_handleDataRead(boost::shared_ptr<Swift::SafeByteArray> data) 

{

	if (m_firstPing) {

		m_firstPing = false;

		// Users can join the network without registering if we allow

		// one user to connect multiple IRC networks.

		NetworkPlugin::PluginConfig cfg;

		cfg.setNeedPassword(false);

		sendConfig(cfg);

	}

	std::string d(data->begin(), data->end());

	handleDataRead(d);

}

// User trying to login into his twitter account

void TwitterPlugin::handleLoginRequest(const std::string &user, const std::string &legacyName, const std::string &password) 

{

	if(userdb.count(user) && (userdb[user].connectionState == NEW || 

										userdb[user].connectionState == CONNECTED || 

										userdb[user].connectionState == WAITING_FOR_PIN)) {

		LOG4CXX_INFO(logger, std::string("A session corresponding to ") + user + std::string(" is already active"))

		return;

	}

	LOG4CXX_INFO(logger, std::string("Received login request for ") + user)	

	initUserSession(user, legacyName, password);

	handleConnected(user);

	LOG4CXX_INFO(logger, "SPECTRUM 1 USER? - " << (userdb[user].spectrum1User? "true" : "false")) 

	LOG4CXX_INFO(logger, user << ": Adding Buddy " << adminLegacyName << " " << adminAlias)

	handleBuddyChanged(user, adminLegacyName, adminAlias, std::vector<std::string>(), pbnetwork::STATUS_ONLINE);

	userdb[user].nickName = "";

	LOG4CXX_INFO(logger, "Querying database for usersettings of " << user)

	std::string key, secret;

	getUserOAuthKeyAndSecret(user, key, secret);

	if(key == "" || secret == "") {			

		LOG4CXX_INFO(logger, "Intiating OAuth Flow for user " << user)

		setTwitterMode(user, 0);

		tp->runAsThread(new OAuthFlow(np, userdb[user].sessions, user, userdb[user].sessions->getTwitterUsername()));

	} else {

		LOG4CXX_INFO(logger, user << " is already registerd. Using the stored oauth key and secret")

		LOG4CXX_INFO(logger, key << " " << secret)	

		pinExchangeComplete(user, key, secret);

	}

}

// User logging out

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

{

	if (userdb.count(user)) {

		delete userdb[user].sessions;

		userdb[user].sessions = NULL;

		userdb[user].connectionState = DISCONNECTED;

	}

	if(onlineUsers.count(user)) {

		onlineUsers.erase(user);

	}

}

// User joining a Chatroom

void TwitterPlugin::handleJoinRoomRequest(const std::string &user, const std::string &room, const std::string &nickname, const std::string &password)

{

	if(room == adminChatRoom) {	

		setTwitterMode(user, 2);

		handleParticipantChanged(user, adminNickName, room, 0, pbnetwork::STATUS_ONLINE);

		userdb[user].nickName = nickname;

		handleMessage(user, adminChatRoom, "Connected to Twitter room! Populating your followers list", adminNickName);

		tp->runAsThread(new FetchFriends(userdb[user].sessions, user,

										 boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3, _4)));

	} else {

		setTwitterMode(user, 0);

		LOG4CXX_ERROR(logger, "Couldn't connect to chatroom - " << room <<"! Try twitter-chatroom as the chatroom to access Twitter account")

		handleMessage(user, adminLegacyName, "Couldn't connect to chatroom! Try twitter-chatroom as the chatroom to access Twitter account");

	}	

}

// User leaving a Chatroom

void TwitterPlugin::handleLeaveRoomRequest(const std::string &user, const std::string &room)

{

	if(room == adminChatRoom && onlineUsers.count(user)) {

		LOG4CXX_INFO(logger, "Leaving chatroom! Switching back to default mode 0")

		setTwitterMode(user, 0);

		handleBuddyChanged(user, adminLegacyName, adminAlias, std::vector<std::string>(), pbnetwork::STATUS_ONLINE);

	}

}

// Messages to be sent to Twitter 

void TwitterPlugin::handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml, const std::string &/*id*/) 

{

	LOG4CXX_INFO(logger, "Received " << user << " --> " << legacyName << " - " << message)

	if(legacyName == adminLegacyName || legacyName == adminChatRoom)  {

		std::string cmd = "", data = "";

		/** Parsing the message - Assuming message format to be <cmd>[ ]*<data>**/	

		int i;

		for(i=0 ; i<message.size() && message[i] != ' '; i++) cmd += message[i];

		while(i<message.size() && message[i] == ' ') i++;

		data = message.substr(i);

		/***********************************************************************/

		if(cmd == "#pin") 

			tp->runAsThread(new PINExchangeProcess(np, userdb[user].sessions, user, data));

		else if(cmd == "#help") 

			tp->runAsThread(new HelpMessageRequest(user, CONFIG_STRING(config, "service.jid"), boost::bind(&TwitterPlugin::helpMessageResponse, this, _1, _2)));

		else if(cmd[0] == '@') {

			std::string username = cmd.substr(1); 

			tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, username, data,

												     boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));

		}

		else if(cmd == "#status") 

			tp->runAsThread(new StatusUpdateRequest(userdb[user].sessions, user, data,

														boost::bind(&TwitterPlugin::statusUpdateResponse, this, _1, _2)));

		else if(cmd == "#timeline") 

			tp->runAsThread(new TimelineRequest(userdb[user].sessions, user, data, "",

														boost::bind(&TwitterPlugin::displayTweets, this, _1, _2, _3, _4)));

		else if(cmd == "#friends") 

			tp->runAsThread(new FetchFriends(userdb[user].sessions, user,

													   boost::bind(&TwitterPlugin::displayFriendlist, this, _1, _2, _3, _4)));

		else if(cmd == "#follow") 

			tp->runAsThread(new CreateFriendRequest(userdb[user].sessions, user, data.substr(0,data.find('@')),

													   boost::bind(&TwitterPlugin::createFriendResponse, this, _1, _2, _3, _4)));

		else if(cmd == "#unfollow") 

			tp->runAsThread(new DestroyFriendRequest(userdb[user].sessions, user, data.substr(0,data.find('@')),

													   boost::bind(&TwitterPlugin::deleteFriendResponse, this, _1, _2, _3)));

		else if(cmd == "#retweet") 

			tp->runAsThread(new RetweetRequest(userdb[user].sessions, user, data,

													   boost::bind(&TwitterPlugin::RetweetResponse, this, _1, _2)));

		else if(cmd == "#mode") {

			int m = 0;

			m = atoi(data.c_str());

			mode prevm = userdb[user].twitterMode;

			if((mode)m == userdb[user].twitterMode) return; //If same as current mode return

			if(m < 0 || m > 1) { // Invalid modes

				handleMessage(user, adminLegacyName, std::string("Error! Unknown mode ") + data + ". Allowed values 0 or 1." );

				return;

			}

			setTwitterMode(user, m);

			if((userdb[user].twitterMode == SINGLECONTACT || userdb[user].twitterMode == CHATROOM) && prevm == MULTIPLECONTACT) clearRoster(user);

			else if(userdb[user].twitterMode == MULTIPLECONTACT) 

				tp->runAsThread(new FetchFriends(userdb[user].sessions, user, boost::bind(&TwitterPlugin::populateRoster, this, _1, _2, _3, _4)));

			handleMessage(user, userdb[user].twitterMode == CHATROOM ? adminChatRoom : adminLegacyName,

								std::string("Changed mode to ") + data, userdb[user].twitterMode == CHATROOM ? adminNickName : "");

			LOG4CXX_INFO(logger, user << ": Changed mode to " << data  << " <" << (userdb[user].twitterMode == CHATROOM ? adminNickName : "") << ">" )

		}

		else if(userdb[user].twitterMode == CHATROOM) {

			std::string buddy = message.substr(0, message.find(":"));

			if(userdb[user].buddies.count(buddy) == 0) {

				tp->runAsThread(new StatusUpdateRequest(userdb[user].sessions, user, message,

														boost::bind(&TwitterPlugin::statusUpdateResponse, this, _1, _2)));

			} else {

				data = message.substr(message.find(":")+1); //Can parse better??:P

				tp->runAsThread(new DirectMessageRequest(userdb[user].sessions, user, buddy, data,

												 		 boost::bind(&TwitterPlugin::directMessageResponse, this, _1, _2, _3, _4)));

	User *user = m_userManager->getUser(stanza->getTo().toBare());

	if (!user)

		return;

	Swift::JID originalJID = stanza->getFrom();

	NetworkConversation *conv = (NetworkConversation *) user->getConversationManager()->getConversation(originalJID.toBare());

	LocalBuddy *buddy = (LocalBuddy *) user->getRosterManager()->getBuddy(stanza->getFrom().toBare());

	if (buddy) {

		const Swift::JID &jid = buddy->getJID();

		if (stanza->getFrom().getResource().empty()) {

			stanza->setFrom(Swift::JID(jid.getNode(), jid.getDomain()));

		}

		else {

			stanza->setFrom(Swift::JID(jid.getNode(), jid.getDomain(), stanza->getFrom().getResource()));

		}

	}

	else {

		std::string name = stanza->getFrom().toBare();

		if (conv && conv->isMUC()) {

			if (name.find_last_of("@") != std::string::npos) {

				name.replace(name.find_last_of("@"), 1, "%");

			}

		}

		else {

			if (CONFIG_BOOL_DEFAULTED(m_config, "service.jid_escaping", true)) {

				name = Swift::JID::getEscapedNode(name);

			}

			else {

				if (name.find_last_of("@") != std::string::npos) {

					name.replace(name.find_last_of("@"), 1, "%");

				}

			}

		}

		if (stanza->getFrom().getResource().empty()) {

			stanza->setFrom(Swift::JID(name, m_component->getJID().toString()));

		}

		else {

			stanza->setFrom(Swift::JID(name, m_component->getJID().toString(), stanza->getFrom().getResource()));

		}

	}

	boost::shared_ptr<Swift::Message> message = boost::dynamic_pointer_cast<Swift::Message>(stanza);

	if (message) {

		if (conv) {

			conv->handleRawMessage(message);

			return;

		}

		m_component->getFrontend()->sendMessage(message);

		return;

	}

	boost::shared_ptr<Swift::Presence> presence = boost::dynamic_pointer_cast<Swift::Presence>(stanza);

	if (presence) {

		if (buddy) {

			if (!buddy->isAvailable() && presence->getType() != Swift::Presence::Unavailable) {

				buddy->m_status.setType(Swift::StatusShow::Online);

			}

			buddy->handleRawPresence(presence);

		}

		else if (conv) {

			conv->handleRawPresence(presence);

		}

		else {

			m_component->getFrontend()->sendPresence(presence);

		}

		return;

	}

	// TODO: FIX TO MAKE RAW XML BACKENDS WORKING AGAIN.

// 	boost::shared_ptr<Swift::IQ> iq = boost::dynamic_pointer_cast<Swift::IQ>(stanza);

// 	if (iq) {

// 		if (m_id2resource.find(stanza->getTo().toBare().toString() + stanza->getID()) != m_id2resource.end()) {

// 			iq->setTo(Swift::JID(iq->getTo().getNode(), iq->getTo().getDomain(), m_id2resource[stanza->getTo().toBare().toString() + stanza->getID()]));

// 			m_id2resource.erase(stanza->getTo().toBare().toString() + stanza->getID());

// 		}

// 		else {

// 			Swift::Presence::ref highest = m_component->getPresenceOracle()->getHighestPriorityPresence(user->getJID());

// 			if (highest) {

// 			    iq->setTo(highest->getFrom());

// 			} else {

// 			    iq->setTo(user->getJID());

// 			}

// 		}

// 		m_component->getFrontend()->sendIQ(iq);

// 		return;

// 	}

}

void NetworkPluginServer::handleRawXML(const std::string &xml) {

	m_xmppParser->parse(xml);

}

void NetworkPluginServer::handleRawPresenceReceived(boost::shared_ptr<Swift::Presence> presence) {

	User *user = m_userManager->getUser(presence->getFrom().toBare());

	if (!user)

		return;

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	Swift::JID legacyname = Swift::JID(Buddy::JIDToLegacyName(presence->getTo()));

	if (!presence->getTo().getResource().empty()) {

		presence->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain(), presence->getTo().getResource()));

	}

	else {

		presence->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain()));

	}

	std::string xml = safeByteArrayToString(m_serializer->serializeElement(presence));

	WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);

	send(c->connection, xml);

}

void NetworkPluginServer::handleRawIQReceived(boost::shared_ptr<Swift::IQ> iq) {

	User *user = m_userManager->getUser(iq->getFrom().toBare());

	if (!user)

		return;

	Backend *c = (Backend *) user->getData();

	if (!c) {

		return;

	}

	if (iq->getType() == Swift::IQ::Get) {

		m_id2resource[iq->getFrom().toBare().toString() + iq->getID()] = iq->getFrom().getResource();

	}

	Swift::JID legacyname = Swift::JID(Buddy::JIDToLegacyName(iq->getTo()));

	if (!iq->getTo().getResource().empty()) {

		iq->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain(), iq->getTo().getResource()));

	}

	else {

		iq->setTo(Swift::JID(legacyname.getNode(), legacyname.getDomain()));

	}

	std::string xml = safeByteArrayToString(m_serializer->serializeElement(iq));

	WRAP(xml, pbnetwork::WrapperMessage_Type_TYPE_RAW_XML);

	send(c->connection, xml);

}

void NetworkPluginServer::handleDataRead(Backend *c, boost::shared_ptr<Swift::SafeByteArray> data) {

	// Append data to buffer

	c->data.insert(c->data.end(), data->begin(), data->end());

	// Parse data while there are some

	while (c->data.size() != 0) {

		// expected_size of wrapper message

		unsigned int expected_size;

		// if data is >= 4, we have whole header and we can

		// read expected_size.

		if (c->data.size() >= 4) {

			expected_size = *((unsigned int*) &c->data[0]);

			expected_size = ntohl(expected_size);

			// If we don't have whole wrapper message, wait for next

			// handleDataRead call.

			if (c->data.size() - 4 < expected_size)

				return;

		}

		else {

			return;

		}

		// Parse wrapper message and erase it from buffer.

		pbnetwork::WrapperMessage wrapper;

		if (wrapper.ParseFromArray(&c->data[4], expected_size) == false) {

			std::cout << "PARSING ERROR " << expected_size << "\n";

			c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);

			continue;

		}

		c->data.erase(c->data.begin(), c->data.begin() + 4 + expected_size);

		// If backend is slow and it is sending us lot of message, there is possibility

		// that we don't receive PONG response before timeout. However, if we received

		// at least some data, it means backend is not dead and we can treat it as

		// PONG received event.

		if (c->pongReceived == false) {

			c->pongReceived = true;

		}

		// Handle payload in wrapper message

		switch(wrapper.type()) {

			case pbnetwork::WrapperMessage_Type_TYPE_CONNECTED:

				handleConnectedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_DISCONNECTED:

				handleDisconnectedPayload(wrapper.payload());

import optparse

import sys

import time

import subprocess

import os

import sleekxmpp

from sleekxmpp.xmlstream.matcher import StanzaPath, MatchXPath

from sleekxmpp.xmlstream.handler import Callback

class Responder(sleekxmpp.ClientXMPP):

	def __init__(self, jid, password, room, room_password, nick):

		sleekxmpp.ClientXMPP.__init__(self, jid, password)

		self.room = room

		self.room_password = room_password

		self.nick = nick

		self.finished = False

		self.tests = {}

class Client(sleekxmpp.ClientXMPP):

	def __init__(self, jid, password, room, nick):

		sleekxmpp.ClientXMPP.__init__(self, jid, password)

		self.room = room

		self.nick = nick

		self.add_event_handler("session_start", self.start)

		self.add_event_handler("message", self.message)

		self.add_event_handler('roster_update', self.roster_update)

		self.finished = False

		self.tests = {}

		self.tests["timeline_poll"] = ["Timeline received automatically", False]

		self.tests["help"] = ["#help command", False]

		self.tests["status1"] = ["#status command response", False]

		self.tests["status2"] = ["#status command pushes status", False]

		self.tests["follow"] = ["#follow command", False]

		self.tests["friends"] = ["#friends command", False]

		self.tests["unfollow"] = ["#unfollow command", False]

		self.tests["friends2"] = ["#friends after unfollow command", False]

		self.tests["mode1"] = ["#mode 1 response", False]

		self.tests["mode1buddy"] = ["#mode 1 buddy added", False]

		self.status = "timeline"

		self.timestamp = int(time.time())

	def message(self, msg):

		if self.status == "timeline" and msg['body'].find("spectrum2tests") != -1 and msg['body'].find("MsgId") != -1:

			self.tests["timeline_poll"][1] = True

			self.send_message(mto=msg['from'], mbody="#help")

			self.status = "help"

		elif self.status == "help" and msg['body'].find("You will receive tweets of people you follow") != -1:

			self.tests["help"][1] = True

			self.send_message(mto=msg['from'], mbody="#status My testing status " + str(self.timestamp))

			self.status = "status"

		elif self.status == "status" and msg['body'].find("Status Update successful") != -1:

			self.tests["status1"][1] = True

		elif self.status == "status" and msg['body'].find("spectrum2tests") != -1 and msg['body'].find("MsgId") != -1:

			self.tests["status2"][1] = True

			self.status = "follow"

			self.send_message(mto=msg['from'], mbody="#follow colinpwheeler")

		elif self.status == "follow" and msg['body'] == "You are now following colinpwheeler":

			self.status = "friends"

			self.tests["follow"][1] = True

			self.send_message(mto=msg['from'], mbody="#friends")

		elif self.status == "friends" and msg['body'].find("USER LIST") != -1 and msg['body'].find("colinpwheeler") != -1:

			self.status = "mode1"

			self.tests["friends"][1] = True

			self.send_message(mto=msg['from'], mbody="#mode 1")

		elif self.status == "mode1" and msg['body'] == "Changed mode to 1":

			self.tests["mode1"][1] = True

		elif self.status == "unfollow" and msg['body'] == "You are not following colinpwheeler anymore":

			self.status = "friends2"

			self.tests["unfollow"][1] = True

			self.send_message(mto=msg['from'], mbody="#friends")

		elif self.status == "friends2" and msg['body'].find("USER LIST") != -1 and msg['body'].find("colinpwheeler") == -1:

			self.status = "mode1"

			self.tests["friends2"][1] = True

			self.finished = True

	def roster_update(self, iq):

		roster = iq['roster']['items']

		if self.status == "mode1" and roster.has_key("colinpwheeler@localhost"):

			self.status = "unfollow"

			self.tests["mode1buddy"][1] = True

			self.send_message(mto="twitter.com@localhost", mbody="#unfollow colinpwheeler")

	def start(self, event):

		self.getRoster()

		self.sendPresence()