#include "TwitterPlugin.h"

#include "Requests/StatusUpdateRequest.h"

#include "Requests/DirectMessageRequest.h"

#include "Requests/TimelineRequest.h"

#include "Requests/FetchFriends.h"

#include "Requests/HelpMessageRequest.h"

#include "Requests/PINExchangeProcess.h"

#include "Requests/OAuthFlow.h"

#include "Requests/CreateFriendRequest.h"

#include "Requests/DestroyFriendRequest.h"

#include "Requests/RetweetRequest.h"

#include "Requests/ProfileImageRequest.h"

#include "Swiften/StringCodecs/Hexify.h"

DEFINE_LOGGER(logger, "Twitter Backend");

TwitterPlugin *np = NULL;

Swift::SimpleEventLoop *loop_; // Event Loop

const std::string OLD_APP_KEY = "PCWAdQpyyR12ezp2fVwEhw";

const std::string OLD_APP_SECRET = "EveLmCXJIg2R7BTCpm6OWV8YyX49nI0pxnYXh7JMvDg";

#define abs(x) ((x)<0?-(x):(x))

#define SHA(x) (Swift::Hexify::hexify(Swift::SHA1::getHash(Swift::createByteArray((x)))))

//Compares two +ve intergers 'a' and 'b' represented as strings 

static int cmp(std::string a, std::string b)

{

	int diff = abs((int)a.size() - (int)b.size());

	if(a.size() < b.size()) a = std::string(diff,'0') + a;

	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;

	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 = m_factories->getTimerFactory()->createTimer(60000);

	message_timer = m_factories->getTimerFactory()->createTimer(60000);

	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) 

{

	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(onlineUsers.count(user)) {

		delete userdb[user].sessions;

		userdb[user].sessions = NULL;

		userdb[user].connectionState = DISCONNECTED;

		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) {	

		LOG4CXX_INFO(logger, "Received Join Twitter room request for " << user)

		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) 

{

	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, 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 > 2) { // Invalid modes

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

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

			}

		}

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

				                 "Unknown command! Type #help for a list of available commands.", userdb[user].twitterMode == CHATROOM ? adminNickName : "");

	} 

	else {	

		std::string buddy;

		if(userdb[user].twitterMode == CHATROOM) buddy = legacyName.substr(legacyName.find("/") + 1);

		if(legacyName != "twitter") {

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

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

		}

	}

}

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

{

	if(userdb[user].connectionState != CONNECTED) {

		LOG4CXX_ERROR(logger, user << " is not connected to twitter!")

		return;

	}

	LOG4CXX_INFO(logger, user << " - Adding Twitter contact " << buddyName)

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

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

}

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

{

	if(userdb[user].connectionState != CONNECTED) {

		LOG4CXX_ERROR(logger, user << " is not connected to twitter!")

		return;

	}

	LOG4CXX_INFO(logger, user << " - Removing Twitter contact " << buddyName)

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

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

}

#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 "transport/threadpool.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*/);

		void pollForTweets();

		void pollForDirectMessages();

		bool getUserOAuthKeyAndSecret(const std::string user, std::string &key, std::string &secret);

		bool checkSpectrum1User(const std::string user);

		bool storeUserOAuthKeyAndSecret(const std::string user, const std::string OAuthKey, const std::string OAuthSecret);

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

		void OAuthFlowComplete(const std::string user, twitCurl *obj);

		void pinExchangeComplete(const std::string user, const std::string OAuthAccessTokenKey, const std::string OAuthAccessTokenSecret);

		void updateLastTweetID(const std::string user, const std::string ID);

		std::string getMostRecentTweetID(const std::string user);

		void updateLastDMID(const std::string user, const std::string ID);

		std::string getMostRecentDMID(const std::string user);

		void clearRoster(const std::string user);

		int getTwitterMode(const std::string user);

		bool setTwitterMode(const std::string user, int m);

		/****************** Twitter response handlers **************************************/

		void statusUpdateResponse(std::string &user, Error &errMsg);

		void helpMessageResponse(std::string &user, std::string &msg);

		void populateRoster(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, Error &errMsg);

		void displayFriendlist(std::string &user, std::vector<User> &friends, std::vector<std::string> &friendAvatars, Error &errMsg);

		void displayTweets(std::string &user, std::string &userRequested, std::vector<Status> &tweets , Error &errMsg);

		void directMessageResponse(std::string &user, std::string &username, std::vector<DirectMessage> &messages, Error &errMsg);

		void createFriendResponse(std::string &user, User &frnd, std::string &img, Error &errMsg);

		void deleteFriendResponse(std::string &user, User &frnd, Error &errMsg);

		void RetweetResponse(std::string &user, Error &errMsg);

		void profileImageResponse(std::string &user, std::string &buddy, std::string &img, unsigned int reqID, Error &errMsg);

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

	private:

		std::string getMostRecentTweetIDUnsafe(const std::string user);

		enum status {NEW, WAITING_FOR_PIN, CONNECTED, DISCONNECTED};

		enum mode {SINGLECONTACT, MULTIPLECONTACT, CHATROOM};

		Config *config;

		std::string adminLegacyName;

		std::string adminChatRoom;

		std::string adminNickName;

		std::string adminAlias;

		std::string consumerKey;

		std::string consumerSecret;

		std::string OAUTH_KEY;

		std::string OAUTH_SECRET;

		std::string MODE;

		boost::mutex dblock, userlock;

		ThreadPool *tp;

		std::set<std::string> onlineUsers;

		struct UserData

		{

			std::string legacyName;

			bool spectrum1User; //Legacy support

			User userTwitterObj;

			std::string userImg;

			twitCurl* sessions;		

			status connectionState;

			std::string mostRecentTweetID;

			std::string mostRecentDirectMessageID;

			std::string nickName;

			std::set<std::string> buddies;

			std::map<std::string, User> buddiesInfo;

			std::map<std::string, std::string> buddiesImgs;

			mode twitterMode;

			UserData() { sessions = NULL; }

		};

		std::map<std::string, UserData> userdb;

};

#endif