#ifndef CREATE_FRIEND

#define CREATE_FRIEND

#include "../TwitterResponseParser.h"

#include "../libtwitcurl/twitcurl.h"

#include "transport/logging.h"

#include <string>

#include <boost/function.hpp>

#include <iostream>

#include <vector>

using namespace Transport;

class CreateFriendRequest : public Thread

{

	twitCurl *twitObj;

	std::string user;

	std::string frnd;

	std::string replyMsg;

	boost::function< void (std::string&, User&, std::string &, std::string&) > callBack;

	User friendInfo;

	std::string profileImg;	

	bool success;

	public:

	CreateFriendRequest(twitCurl *obj, const std::string &_user, const std::string & _frnd,

			     		 boost::function< void (std::string&, User&, std::string &, std::string&) >  cb) {

		twitObj = obj->clone();

		user = _user;

		frnd = _frnd;

		callBack = cb;

	}

	~CreateFriendRequest() {

		delete twitObj;

	}

	void run();

	void finalize();

};

#endif

#ifndef DESTROY_FRIEND

#define DESTROY_FRIEND

#include "../TwitterResponseParser.h"

#include "../libtwitcurl/twitcurl.h"

#include "transport/logging.h"

#include <string>

#include <boost/function.hpp>

#include <iostream>

#include <vector>

using namespace Transport;

class DestroyFriendRequest : public Thread

{

	twitCurl *twitObj;

	std::string user;

	std::string frnd;

	std::string replyMsg;

	boost::function< void (std::string&, User&, std::string&) > callBack;

	User friendInfo;	

	bool success;

	public:

	DestroyFriendRequest(twitCurl *obj, const std::string &_user, const std::string & _frnd,

			     		 boost::function< void (std::string&, User&, std::string&) >  cb) {

		twitObj = obj->clone();

		user = _user;

		frnd = _frnd;

		callBack = cb;

	}

	~DestroyFriendRequest() {

		delete twitObj;

	}

	void run();

	void finalize();

};

#endif

#ifndef DIRECT_MESSAGE

#define DIRECT_MESSAGE

#include "../TwitterResponseParser.h"

#include "../libtwitcurl/twitcurl.h"

#include "transport/logging.h"

#include <string>

#include <boost/function.hpp>

#include <iostream>

using namespace Transport;

class DirectMessageRequest : public Thread

{

	twitCurl *twitObj;

	std::string data;

	std::string user;

	std::string username;

	std::string replyMsg;

	boost::function< void (std::string&, std::string &, std::vector<DirectMessage>&, std::string&) > callBack;

	std::vector<DirectMessage> messages;

	bool success;

	public:

	DirectMessageRequest(twitCurl *obj, const std::string &_user, const std::string & _username, const std::string &_data,

			     		boost::function< void (std::string&, std::string &, std::vector<DirectMessage>&, std::string&) >  cb) {

		twitObj = obj->clone();

		data = _data;

		user = _user;

		username = _username;

		callBack = cb;

	}

	~DirectMessageRequest() {

		delete twitObj;

	}

	void run();

	void finalize();

};

#endif

#ifndef FRIENDS_H

#define FRIENDS_H

#include "../libtwitcurl/twitcurl.h"

#include "../TwitterResponseParser.h"

#include "transport/logging.h"

#include <string>

#include <boost/signals.hpp>

#include <boost/function.hpp>

#include <boost/bind.hpp>

#include <iostream>

using namespace Transport;

class FetchFriends : public Thread

{

	twitCurl *twitObj;

	std::string user;

	std::string replyMsg;

	std::vector<User> friends;

	std::vector<std::string> friendAvatars;

	bool success;

	boost::function< void (std::string, std::vector<User> &, std::vector<std::string> &, std::string) > callBack;

	public:

	FetchFriends(twitCurl *obj, const std::string &_user, 

			     boost::function< void (std::string, std::vector<User> &, std::vector<std::string> &, std::string) >  cb) {

		twitObj = obj->clone();

		user = _user;

		callBack = cb;

	}

	~FetchFriends() {

		delete twitObj;

	}

	void run();

	void finalize();

};

#endif

#ifndef HELPMESSAGE_H

#define HELPMESSAGE_H

#include "../libtwitcurl/twitcurl.h"

#include "transport/networkplugin.h"

#include "transport/logging.h"

#include <string>

#include <boost/function.hpp>

#include <iostream>

using namespace Transport;

class HelpMessageRequest : public Thread

{

	std::string user;

	std::string helpMsg;

	boost::function<void (std::string &, std::string &)> callBack;

	public:

	HelpMessageRequest(const std::string &_user, boost::function<void (std::string &, std::string &)> cb) {

		user = _user;

		callBack = cb;

	}

	void run();

	void finalize();

};

#endif

#ifndef OAUTH_FLOW

#define OAUTH_FLOW

#include "../libtwitcurl/twitcurl.h"

#include "../TwitterPlugin.h"

#include "transport/logging.h"

#include <string>

#include <iostream>

//class TwitterPlugin;

using namespace Transport;

class OAuthFlow : public Thread

{

	twitCurl *twitObj;

	std::string username;

	std::string user;

	std::string authUrl;

	TwitterPlugin *np;

	bool success;

	public:

	OAuthFlow(TwitterPlugin *_np, twitCurl *obj, const std::string &_user, const std::string &_username) {

		twitObj = obj->clone();

		username = _username;

		user = _user;

		np = _np;

	}

	~OAuthFlow() {

		delete twitObj;

	}	

	void run();

	void finalize();

};

#endif

#ifndef PIN_EXCHANGE

#define PIN_EXCHANGE

#include "../libtwitcurl/twitcurl.h"

#include "../TwitterPlugin.h"

#include "transport/networkplugin.h"

#include "transport/logging.h"

#include <string>

#include <iostream>

//class TwitterPlugin;

using namespace Transport;

class PINExchangeProcess : public Thread

{

	twitCurl *twitObj;

	std::string data;

	std::string user;

	TwitterPlugin *np;

	bool success;

	public:

	PINExchangeProcess(TwitterPlugin *_np, twitCurl *obj, const std::string &_user, const std::string &_data) {

		twitObj = obj->clone();

		data = _data;

		user = _user;

		np = _np;

	}

	~PINExchangeProcess() {

		delete twitObj;

	}	

	void run();

	void finalize();

};

#endif

#ifndef PROFILEIMAGE_H

#define PROFILEIMAGE_H

#include "../TwitterResponseParser.h"

#include "transport/logging.h"

#include "transport/config.h"

#include <string>

#include <boost/signals.hpp>

#include <boost/function.hpp>

#include <boost/bind.hpp>

#include <iostream>

#include <sstream>

using namespace Transport;

using namespace boost::program_options;

class ProfileImageRequest : public Thread

{

	std::string user;

	std::string buddy;

	std::string url;

	std::string img;

	unsigned int reqID;

	boost::function< void (std::string&, std::string&, std::string&, int, std::string&) > callBack;

	std::string ip, port, puser, ppasswd;

	bool success;

	std::string error;

	std::string callbackdata;

	public:

	ProfileImageRequest(Config *config, const std::string &_user, const std::string &_buddy, const std::string &_url, unsigned int _reqID,

			     boost::function< void (std::string&, std::string&, std::string&, int, std::string&) >  cb) {

		if(CONFIG_HAS_KEY(config,"proxy.server")) {

			ip = CONFIG_STRING(config,"proxy.server");

			std::ostringstream out; 

			out << CONFIG_INT(config,"proxy.port");

			port = out.str();

			puser = CONFIG_STRING(config,"proxy.user");

			ppasswd = CONFIG_STRING(config,"proxy.password");

		}

		user = _user;

		buddy = _buddy;

		url = _url;

		reqID = _reqID;

#ifndef RETWEET_H

#define RETWEET_H

#include "../TwitterResponseParser.h"

#include "../libtwitcurl/twitcurl.h"

#include "transport/networkplugin.h"

#include "transport/logging.h"

#include <boost/function.hpp>

#include <string>

#include <iostream>

using namespace Transport;

class RetweetRequest : public Thread

{

	twitCurl *twitObj;

	std::string data;

	std::string user;

	std::string replyMsg;

	bool success;

	boost::function < void (std::string&, std::string &) > callBack;

	public:

	RetweetRequest(twitCurl *obj, const std::string &_user, const std::string &_data,

			       boost::function < void (std::string &, std::string &) > _cb) {

		twitObj = obj->clone();

		data = _data;

		user = _user;

		callBack = _cb;

	}

	~RetweetRequest() {

		delete twitObj;

	}

	void run();

	void finalize();

};

#endif

#ifndef STATUS_UPDATE

#define STATUS_UPDATE

#include "../libtwitcurl/twitcurl.h"

#include "transport/networkplugin.h"

#include "transport/logging.h"

#include <boost/function.hpp>

#include <string>

#include <iostream>

using namespace Transport;

class StatusUpdateRequest : public Thread

{

	twitCurl *twitObj;

	std::string data;

	std::string user;

	std::string replyMsg;

	boost::function<void (std::string& user, std::string& errMsg)> callBack;

	bool success;

	public:

	StatusUpdateRequest(twitCurl *obj, const std::string &_user, const std::string &_data,

						boost::function<void (std::string& user, std::string& errMsg)> cb) {

		twitObj = obj->clone();

		data = _data;

		user = _user;

		callBack = cb;

	}

	~StatusUpdateRequest() {

		delete twitObj;

	}

	void run();

	void finalize();

};

#endif

#ifndef TIMELINE_H

#define TIMELINE_H

#include "../libtwitcurl/twitcurl.h"

#include "../TwitterResponseParser.h"

#include "transport/logging.h"

#include <string>

#include <iostream>

#include <boost/function.hpp>

using namespace Transport;

class TimelineRequest : public Thread

{

	twitCurl *twitObj;

	std::string user;

	std::string userRequested;

	std::string replyMsg;

	std::string since_id;

	bool success;

	boost::function< void (std::string&, std::string&, std::vector<Status> &, std::string&) > callBack;

	std::vector<Status> tweets;

	public:

	TimelineRequest(twitCurl *obj, const std::string &_user, const std::string &_user2, const std::string &_since_id,

					boost::function< void (std::string&, std::string&, std::vector<Status> &, std::string&) > cb) {

		twitObj = obj->clone();

		user = _user;

		userRequested = _user2;

		since_id = _since_id;

		callBack = cb;

	}

	~TimelineRequest() {

		//std::cerr << "*****Timeline request: DESTROYING twitObj****" << std::endl;

		delete twitObj;

	}

	void run();

	void finalize();

};

#endif

#ifndef TWITTER_PLUGIN

#define TWITTER_PLUGIN

#include "transport/config.h"

#include "transport/networkplugin.h"

#include "transport/logging.h"

#include "transport/sqlite3backend.h"

#include "transport/mysqlbackend.h"

#include "transport/pqxxbackend.h"

#include "transport/storagebackend.h"

#include "Swiften/Swiften.h"

#include "unistd.h"

#include "signal.h"

#include "sys/wait.h"

#include "sys/signal.h"

#include <boost/algorithm/string.hpp>

#include <boost/signal.hpp>

#include <boost/thread.hpp>

#include <boost/thread/mutex.hpp>

#include "twitcurl.h"

#include "TwitterResponseParser.h"

#include <iostream>

#include <sstream>

#include <map>

#include <vector>

#include <queue>

#include <set>

#include <cstdio>

#include "Swiften/StringCodecs/SHA1.h"

using namespace boost::filesystem;

using namespace boost::program_options;

using namespace Transport;

#define STR(x) (std::string("(") + x.from + ", " + x.to + ", " + x.message + ")")

class TwitterPlugin;

extern TwitterPlugin *np;

extern Swift::SimpleEventLoop *loop_; // Event Loop

class TwitterPlugin : public NetworkPlugin {

	public:

		Swift::BoostNetworkFactories *m_factories;

		Swift::BoostIOServiceThread m_boostIOServiceThread;

		boost::shared_ptr<Swift::Connection> m_conn;

		Swift::Timer::ref tweet_timer;

		Swift::Timer::ref message_timer;

		StorageBackend *storagebackend;

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

		~TwitterPlugin();

		// Send data to NetworkPlugin server

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

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

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

		// User trying to login into his twitter account

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

		// User logging out

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

		void handleJoinRoomRequest(const std::string &/*user*/, const std::string &/*room*/, const std::string &/*nickname*/, const std::string &/*pasword*/);

		void handleLeaveRoomRequest(const std::string &/*user*/, const std::string &/*room*/);

		void handleMessageSendRequest(const std::string &user, const std::string &legacyName, const std::string &message, const std::string &xhtml = "");

		void handleBuddyUpdatedRequest(const std::string &user, const std::string &buddyName, const std::string &alias, const std::vector<std::string> &groups);

		void handleBuddyRemovedRequest(const std::string &user, const std::string &buddyName, const std::vector<std::string> &groups);

		void handleVCardRequest(const std::string &/*user*/, const std::string &/*legacyName*/, unsigned int /*id*/);

DEFINE_LOGGER(logger, "ThreadPool")

boost::signals2::signal< void (Thread*, int) > onWorkCompleted;

static void Worker(Thread *t, int wid, Swift::EventLoop *loop)

{

	LOG4CXX_INFO(logger, "Starting thread " << wid)

	t->run();

	loop->postEvent(boost::bind(boost::ref(onWorkCompleted), t, wid), boost::shared_ptr<Swift::EventOwner>());

}

ThreadPool::ThreadPool(Swift::EventLoop *loop, int maxthreads) : MAX_THREADS(maxthreads)

{

	this->loop = loop;

	activeThreads = 0;

	worker = new boost::thread*[MAX_THREADS];

	for(int i=0 ; i<MAX_THREADS ; i++) {

		worker[i] = NULL;

		freeThreads.push(i);

	}

	onWorkCompleted.connect(boost::bind(&ThreadPool::cleandUp, this, _1, _2));

	onWorkerAvailable.connect(boost::bind(&ThreadPool::scheduleFromQueue, this));

}

ThreadPool::~ThreadPool()

{

	for(int i=0; i<MAX_THREADS ; i++) {

		if(worker[i]) {

			delete worker[i];

		}

	}

	delete worker;

	while(!requestQueue.empty()) {

		Thread *t = requestQueue.front(); requestQueue.pop();

		delete t;

	}

}

int ThreadPool::getActiveThreadCount()

{	

	int res;

	count_lock.lock(); 

	res = activeThreads;

	count_lock.unlock();

	return res;

}