else b = std::string(diff,'0') + b;

	if(a == b) return 0;

	if(a < b) return -1;

	return 1;

}

TwitterPlugin::TwitterPlugin(Config *config, Swift::SimpleEventLoop *loop, StorageBackend *storagebackend, const std::string &host, int port) : NetworkPlugin() 

{

	this->config = config;

	this->storagebackend = storagebackend;

	this->m_firstPing = true;

	if (CONFIG_HAS_KEY(config, "twitter.consumer_key") == false) {

		consumerKey = "5mFePMiJi0KpeURONkelg";

	}

	else {

		consumerKey = CONFIG_STRING(config, "twitter.consumer_key");

	}

	if (CONFIG_HAS_KEY(config, "twitter.consumer_secret") == false) {

		consumerSecret = "YFZCDJwRhbkccXEnaYr1waCQejTJcOY8F7l5Wim3FA";

	}

	else {

		consumerSecret = CONFIG_STRING(config, "twitter.consumer_secret");

	}

	if (consumerSecret.empty() || consumerKey.empty()) {

		LOG4CXX_ERROR(logger, "Consumer key and Consumer secret can't be empty.");

		exit(1);

	}

	adminLegacyName = "twitter.com"; 

	adminChatRoom = "#twitter"; 

	adminNickName = "twitter"; 

	adminAlias = "twitter";

	OAUTH_KEY = "twitter_oauth_token";

	OAUTH_SECRET = "twitter_oauth_secret";

	MODE = "mode";

	m_factories = new Swift::BoostNetworkFactories(loop);

	m_conn = m_factories->getConnectionFactory()->createConnection();

	m_conn->onDataRead.connect(boost::bind(&TwitterPlugin::_handleDataRead, this, _1));

	m_conn->connect(Swift::HostAddressPort(Swift::HostAddress(host), port));

	tp = new ThreadPool(loop_, 10);

	tweet_timer->onTick.connect(boost::bind(&TwitterPlugin::pollForTweets, this));

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

	tweet_timer->start();

	message_timer->start();

	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;

#include "boost/date_time/local_time/local_time.hpp"

#include "boost/date_time/time_facet.hpp"

DEFINE_LOGGER(logger, "TwitterResponseParser")

static std::string tolowercase(std::string inp)

{

	std::string out = inp;

	for(int i=0 ; i<out.size() ; i++) out[i] = tolower(out[i]);

	return out;

}

static std::string unescape(std::string data) {

	using boost::algorithm::replace_all;

	replace_all(data, "&",  "&");

	replace_all(data, """, "\"");

	replace_all(data, "'", "\'");

	replace_all(data, "&lt;",   "<");

	replace_all(data, ">",   ">");

	return data;

}

static std::string toIsoTime(std::string in) {

	std::locale locale(std::locale::classic(), new boost::local_time::local_time_input_facet("%a %b %d %H:%M:%S +0000 %Y"));

	boost::local_time::local_time_facet* output_facet = new boost::local_time::local_time_facet();

	boost::local_time::local_date_time ldt(boost::local_time::not_a_date_time);

	std::stringstream ss(in);

	ss.imbue(locale);

	ss.imbue(std::locale(ss.getloc(), output_facet));

	output_facet->format("%Y%m%dT%H%M%S"); // boost::local_time::local_time_facet::iso_time_format_specifier ?

	ss >> ldt;

	ss.str("");

	ss << ldt;	

	return ss.str();

}

EmbeddedStatus getEmbeddedStatus(const rapidjson::Value &element)

{

	EmbeddedStatus status;

	if(!element.IsObject()) {

		LOG4CXX_ERROR(logger, "Not a status element!")

		return status;

	}

	status.setCreationTime( toIsoTime ( std::string( element[TwitterReponseTypes::created_at.c_str()].GetString() ) ) );

	status.setID( std::to_string( element[TwitterReponseTypes::id.c_str()].GetInt64() ) ); 

	status.setTweet( unescape ( std::string( element[TwitterReponseTypes::text.c_str()].GetString() ) ) );

	status.setTruncated( element[TwitterReponseTypes::truncated.c_str()].GetBool());

	status.setReplyToStatusID( element[TwitterReponseTypes::in_reply_to_status_id.c_str()].IsNull() ?

	status.setReplyToUserID( element[TwitterReponseTypes::in_reply_to_user_id.c_str()].IsNull() ?

	status.setReplyToScreenName( element[TwitterReponseTypes::in_reply_to_screen_name.c_str()].IsNull() ?

"" : std::string(element[TwitterReponseTypes::in_reply_to_screen_name.c_str()].GetString()) );

	status.setRetweetCount( element[TwitterReponseTypes::retweet_count.c_str()].GetInt64() );

	status.setFavorited( element[TwitterReponseTypes::favorited.c_str()].GetBool() );

	status.setRetweeted( element[TwitterReponseTypes::retweeted.c_str()].GetBool());	

	return status;

}

User getUser(const rapidjson::Value &element) 

{

	User user;

	if(!element.IsObject()) {

		LOG4CXX_ERROR(logger, "Not a user element!")

		return user;

	}

	user.setUserID( std::to_string( element[TwitterReponseTypes::id.c_str()].GetInt64() ) );

	user.setScreenName( tolowercase( std::string( element[TwitterReponseTypes::screen_name.c_str()].GetString() ) ) );

	user.setUserName( std::string( element[TwitterReponseTypes::name.c_str()].GetString() ) );

	user.setProfileImgURL( std::string( element[TwitterReponseTypes::profile_image_url.c_str()].GetString() ) );

	user.setNumberOfTweets( element[TwitterReponseTypes::statuses_count.c_str()].GetInt64() );

	if(element[TwitterReponseTypes::status.c_str()].IsObject()) 

		user.setLastStatus(getEmbeddedStatus(element[TwitterReponseTypes::status.c_str()]));

	return user;

}

Status getStatus(const rapidjson::Value &element) 

{

	Status status;

	status.setCreationTime( toIsoTime ( std::string( element[TwitterReponseTypes::created_at.c_str()].GetString() ) ) );

	status.setID( std::to_string( element[TwitterReponseTypes::id.c_str()].GetInt64()  )); 

	status.setTweet( unescape ( std::string( element[TwitterReponseTypes::text.c_str()].GetString() ) ) );

	status.setTruncated( element[TwitterReponseTypes::truncated.c_str()].GetBool());

	status.setReplyToStatusID( element[TwitterReponseTypes::in_reply_to_status_id.c_str()].IsNull() ?

	status.setReplyToUserID( element[TwitterReponseTypes::in_reply_to_user_id.c_str()].IsNull() ?

	status.setReplyToScreenName( element[TwitterReponseTypes::in_reply_to_screen_name.c_str()].IsNull() ?

"" : std::string(element[TwitterReponseTypes::in_reply_to_screen_name.c_str()].GetString()) );

	status.setUserData( getUser(element[TwitterReponseTypes::user.c_str()]) );

	status.setRetweetCount( element[TwitterReponseTypes::retweet_count.c_str()].GetInt64() );

	status.setFavorited( element[TwitterReponseTypes::favorited.c_str()].GetBool() );

	status.setRetweeted( element[TwitterReponseTypes::retweeted.c_str()].GetBool());

	const rapidjson::Value &rt = element[TwitterReponseTypes::retweeted_status.c_str()];

	if (rt.IsObject()) {

		status.setTweet(unescape( std::string( rt[TwitterReponseTypes::text.c_str()].GetString()) + " (RT by @" + status.getUserData().getScreenName() + ")") );

		status.setRetweetID( std::to_string(rt[TwitterReponseTypes::id.c_str()].GetInt64()) );

		status.setCreationTime( toIsoTime ( std::string (rt[TwitterReponseTypes::created_at.c_str()].GetString() ) ) );

		status.setUserData( getUser ( rt[TwitterReponseTypes::user.c_str()]) );

	}

	return status;

}

DirectMessage getDirectMessage(const rapidjson::Value &element) 

{

	DirectMessage DM;

	DM.setCreationTime( toIsoTime ( std::string( element[TwitterReponseTypes::created_at.c_str()].GetString() ) ) );

	DM.setID( std::to_string( element[TwitterReponseTypes::id.c_str()].GetInt64() ) );

	DM.setMessage( unescape ( std::string( element[TwitterReponseTypes::text.c_str()].GetString() ) ) );

	DM.setSenderID( std::to_string( element[TwitterReponseTypes::sender_id.c_str()].GetInt64())  );

	DM.setRecipientID( std::to_string( element[TwitterReponseTypes::recipient_id.c_str()].GetInt64() ) );

	DM.setSenderScreenName( std::string( element[TwitterReponseTypes::sender_screen_name.c_str()].GetString() ) );

	DM.setRecipientScreenName( std::string( element[TwitterReponseTypes::recipient_screen_name.c_str()].GetString() ) );

	DM.setSenderData( getUser(element[TwitterReponseTypes::sender.c_str()] ));

	DM.setRecipientData( getUser(element[TwitterReponseTypes::recipient.c_str()]) );

	return DM;

}

std::vector<Status> getTimeline(std::string &json)

{

	std::vector<Status> statuses;

	rapidjson::Document rootElement;

	if(rootElement.Parse<0>(json.c_str()).HasParseError()) {

		LOG4CXX_ERROR(logger, "Error while parsing JSON")

        LOG4CXX_ERROR(logger, json)

		return statuses;

	}

	if(!rootElement.IsArray()) {

		LOG4CXX_ERROR(logger, "JSON doesn't correspond to timeline:")

        LOG4CXX_ERROR(logger, json)

		return statuses;

	}