/*

 * Copyright (C) 2008-2009 J-P Nurmi jpnurmi@gmail.com

 *

 * This example is free, and not covered by LGPL license. There is no

 * restriction applied to their modification, redistribution, using and so on.

 * You can study them, modify them, use them in your own program - either

 * completely or partially. By using it you may give me some credits in your

 * program, but you don't have to.

 */

#include "session.h"

#include <QtCore>

#include <iostream>

#include <IrcCommand>

#include <IrcMessage>

#include "ircnetworkplugin.h"

#define FROM_UTF8(WHAT) QString::fromUtf8((WHAT).c_str(), (WHAT).size())

#define TO_UTF8(WHAT) std::string((WHAT).toUtf8().data(), (WHAT).toUtf8().size())

#include "transport/logging.h"

DEFINE_LOGGER(logger, "IRCSession");

static bool sentList;

MyIrcSession::MyIrcSession(const std::string &user, IRCNetworkPlugin *np, const std::string &suffix, QObject* parent) : IrcSession(parent)

{

	this->np = np;

	this->user = user;

	this->suffix = suffix;

	m_connected = false;

	rooms = 0;

	connect(this, SIGNAL(disconnected()), SLOT(on_disconnected()));

	connect(this, SIGNAL(socketError(QAbstractSocket::SocketError)), SLOT(on_socketError(QAbstractSocket::SocketError)));

	connect(this, SIGNAL(connected()), SLOT(on_connected()));

	connect(this, SIGNAL(messageReceived(IrcMessage*)), this, SLOT(onMessageReceived(IrcMessage*)));

}

void MyIrcSession::on_connected() {

	m_connected = true;

	if (suffix.empty()) {

		np->handleConnected(user);

// 		if (!sentList) {

// 			sendCommand(IrcCommand::createList("", ""));

// 			sentList = true;

// 		}

	}

	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {

		sendCommand(IrcCommand::createJoin(FROM_UTF8(it->second->getChannel()), FROM_UTF8(it->second->getPassword())));

	}

	if (getIdentify().find(" ") != std::string::npos) {

		std::string to = getIdentify().substr(0, getIdentify().find(" "));

		std::string what = getIdentify().substr(getIdentify().find(" ") + 1);

		sendCommand(IrcCommand::createMessage(FROM_UTF8(to), FROM_UTF8(what)));

	}

}

void MyIrcSession::on_socketError(QAbstractSocket::SocketError error) {

	on_disconnected();

}

void MyIrcSession::on_disconnected() {

	if (suffix.empty()) {

		np->handleDisconnected(user, 0, "");

		np->tryNextServer();

	}

	m_connected = false;

}

bool MyIrcSession::correctNickname(std::string &nickname) {

	bool flags = 0;

	switch(nickname.at(0)) {

		case '@': nickname = nickname.substr(1); flags = 1; break;

		case '+': nickname = nickname.substr(1); break;

		default: break;

	}

	return flags;

}

void MyIrcSession::on_joined(IrcMessage *message) {

	IrcJoinMessage *m = (IrcJoinMessage *) message;

	bool flags = 0;

	std::string nickname = TO_UTF8(m->sender().name());

	flags = correctNickname(nickname);

	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()) + suffix, (int) flags, pbnetwork::STATUS_ONLINE);

	LOG4CXX_INFO(logger, user << ": " << nickname << " joined " << TO_UTF8(m->channel()) + suffix);

}

void MyIrcSession::on_parted(IrcMessage *message) {

	IrcPartMessage *m = (IrcPartMessage *) message;

	bool flags = 0;

	std::string nickname = TO_UTF8(m->sender().name());

	flags = correctNickname(nickname);

	LOG4CXX_INFO(logger, user << ": " << nickname << " parted " << TO_UTF8(m->channel()) + suffix);

	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel()) + suffix,(int) flags, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));

}

void MyIrcSession::on_quit(IrcMessage *message) {

	IrcQuitMessage *m = (IrcQuitMessage *) message;

	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {

		bool flags = 0;

		std::string nickname = TO_UTF8(m->sender().name());

		flags = correctNickname(nickname);

		LOG4CXX_INFO(logger, user << ": " << nickname << " quit " << it->second->getChannel() + suffix);

		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));

	}

}

void MyIrcSession::on_nickChanged(IrcMessage *message) {

	IrcNickMessage *m = (IrcNickMessage *) message;

	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {

		std::string nickname = TO_UTF8(m->sender().name());

		bool flags = m_modes[it->second->getChannel() + nickname];

		LOG4CXX_INFO(logger, user << ": " << nickname << " changed nickname to " << TO_UTF8(m->nick()));

		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "", TO_UTF8(m->nick()));

	}

}

void MyIrcSession::on_modeChanged(IrcMessage *message) {

	IrcModeMessage *m = (IrcModeMessage *) message;

	// mode changed: "#testik" "HanzZ" "+o" "hanzz_k"

	std::string nickname = TO_UTF8(m->argument());

	std::string mode = TO_UTF8(m->mode());

	if (nickname.empty())

		return;

	LOG4CXX_INFO(logger, user << ": " << nickname << " changed mode to " << mode);

	for(AutoJoinMap::iterator it = m_autoJoin.begin(); it != m_autoJoin.end(); it++) {

		if (mode == "+o") {

			m_modes[it->second->getChannel() + nickname] = 1;

		}

		else {

			m_modes[it->second->getChannel() + nickname] = 0;

		}

		bool flags = m_modes[it->second->getChannel() + nickname];

		np->handleParticipantChanged(user, nickname, it->second->getChannel() + suffix,(int) flags, pbnetwork::STATUS_ONLINE, "");

	}

}

void MyIrcSession::on_topicChanged(IrcMessage *message) {

	IrcTopicMessage *m = (IrcTopicMessage *) message;

	bool flags = 0;

	std::string nickname = TO_UTF8(m->sender().name());

	flags = correctNickname(nickname);

	LOG4CXX_INFO(logger, user << ": " << nickname << " topic changed to " << TO_UTF8(m->topic()));

	np->handleSubject(user, TO_UTF8(m->channel()) + suffix, TO_UTF8(m->topic()), nickname);

}

void MyIrcSession::on_messageReceived(IrcMessage *message) {

	IrcPrivateMessage *m = (IrcPrivateMessage *) message;

	if (m->isRequest()) {

		QString request = m->message().split(" ", QString::SkipEmptyParts).value(0).toUpper();

		if (request == "PING" || request == "TIME" || request == "VERSION") {

			LOG4CXX_INFO(logger, user << ": " << TO_UTF8(request) << " received and has been answered");

			return;

		}

	}

	QString msg = m->message();

	if (m->isAction()) {

		msg = QString("/me ") + msg;

	}

	std::string target = TO_UTF8(m->target());

	LOG4CXX_INFO(logger, user << ": Message from " << target);

	if (target.find("#") == 0) {

		bool flags = 0;

		std::string nickname = TO_UTF8(m->sender().name());

		flags = correctNickname(nickname);

		np->handleMessage(user, target + suffix, TO_UTF8(msg), nickname);

	}

	else {

		bool flags = 0;

		std::string nickname = TO_UTF8(m->sender().name());

		flags = correctNickname(nickname);

		LOG4CXX_INFO(logger, nickname + suffix);

		np->handleMessage(user, nickname + suffix, TO_UTF8(msg));

	}

}

void MyIrcSession::on_numericMessageReceived(IrcMessage *message) {

	QString channel;

	QStringList members;

	std::string nick;

	IrcNumericMessage *m = (IrcNumericMessage *) message;

	switch (m->code()) {

		case 301:

			break;

		case 332:

			m_topicData = TO_UTF8(m->parameters().value(2));

			break;

		case 333:

			nick = TO_UTF8(m->parameters().value(2));

			if (nick.find("!") != std::string::npos) {

				nick = nick.substr(0, nick.find("!"));

			}

			if (nick.find("/") != std::string::npos) {

				nick = nick.substr(0, nick.find("/"));

			}

			np->handleSubject(user, TO_UTF8(m->parameters().value(1)) + suffix, m_topicData, nick);

			break;

		case 352:

				channel = m->parameters().value(1);

				nick = TO_UTF8(m->parameters().value(5));

				np->handleParticipantChanged(user, nick, TO_UTF8(channel) + suffix, m_modes[TO_UTF8(channel) + nick], pbnetwork::STATUS_AWAY);

			}

			break;

		case 353:

			channel = m->parameters().value(2);

			members = m->parameters().value(3).split(" ");

			LOG4CXX_INFO(logger, user << ": Received members for " << TO_UTF8(channel) << suffix);

			for (int i = 0; i < members.size(); i++) {

				bool flags = 0;

				std::string nickname = TO_UTF8(members.at(i));

				flags = correctNickname(nickname);

				m_modes[TO_UTF8(channel) + nickname] = flags;

				np->handleParticipantChanged(user, nickname, TO_UTF8(channel) + suffix,(int) flags, pbnetwork::STATUS_ONLINE);

			}

			// ask /who to get away states

			sendCommand(IrcCommand::createWho(channel));

			break;

		case 432:

			np->handleDisconnected(user, pbnetwork::CONNECTION_ERROR_INVALID_USERNAME, "Erroneous Nickname");

			break;

		case 321:

			m_rooms.clear();

			m_names.clear();

			break;

		case 322:

			m_rooms.push_back(TO_UTF8(m->parameters().value(1)));

			m_names.push_back(TO_UTF8(m->parameters().value(1)));

			break;

		case 323:

			np->handleRoomList("", m_rooms, m_names);

			break;

		default:

			break;

	}

	//qDebug() << "numeric message received:" << receiver() << origin << code << params;

}

void MyIrcSession::onMessageReceived(IrcMessage *message) {

	LOG4CXX_INFO(logger, user << ": " << TO_UTF8(message->toString()));

	switch (message->type()) {

		case IrcMessage::Join:

			on_joined(message);

			break;

		case IrcMessage::Part:

			on_parted(message);

			break;

		case IrcMessage::Quit:

			on_quit(message);

			break;

		case IrcMessage::Nick:

			on_nickChanged(message);

			break;

		case IrcMessage::Mode:

			on_modeChanged(message);

			break;

		case IrcMessage::Topic:

			on_topicChanged(message);

			break;

		case IrcMessage::Private:

			on_messageReceived(message);

			break;

		case IrcMessage::Numeric:

			on_numericMessageReceived(message);

			break;

		default:break;

	}

}

	if (!transfer.ft) {

		handleFTRejected(user, payload.buddyname(), payload.filename(), payload.size());

		return;

	}

	m_filetransfers[++bytestream_id] = transfer;

	transfer.ft->onStateChange.connect(boost::bind(&NetworkPluginServer::handleFTStateChanged, this, _1, payload.username(), payload.buddyname(), payload.filename(), payload.size(), bytestream_id));

	transfer.ft->start();

}

void NetworkPluginServer::handleFTFinishPayload(const std::string &data) {

	pbnetwork::File payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	if (payload.has_ftid()) {

		if (m_filetransfers.find(payload.ftid()) != m_filetransfers.end()) {

			FileTransferManager::Transfer &transfer = m_filetransfers[payload.ftid()];

			transfer.ft->cancel();

		}

		else {

			LOG4CXX_ERROR(logger, "FTFinishPayload for unknown ftid=" << payload.ftid());

		}

	}

}

void NetworkPluginServer::handleFTDataPayload(Backend *b, const std::string &data) {

	pbnetwork::FileTransferData payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

// 	User *user = m_userManager->getUser(payload.username());

// 	if (!user)

// 		return;

	if (m_filetransfers.find(payload.ftid()) == m_filetransfers.end()) {

		LOG4CXX_ERROR(logger, "Uknown filetransfer with id " << payload.ftid());

		return;

	}

	FileTransferManager::Transfer &transfer = m_filetransfers[payload.ftid()];

	MemoryReadBytestream *bytestream = (MemoryReadBytestream *) transfer.readByteStream.get();

	if (bytestream->appendData(payload.data()) > 5000000) {

		pbnetwork::FileTransferData f;

		f.set_ftid(payload.ftid());

		f.set_data("");

		std::string message;

		f.SerializeToString(&message);

		WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_PAUSE);

		send(b->connection, message);

	}

}

void NetworkPluginServer::handleFTDataNeeded(Backend *b, unsigned long ftid) {

	pbnetwork::FileTransferData f;

	f.set_ftid(ftid);

	f.set_data("");

	std::string message;

	f.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_FT_CONTINUE);

	send(b->connection, message);

}

void NetworkPluginServer::handlePongReceived(Backend *c) {

	// This could be first PONG from the backend

	if (c->pongReceived == -1) {

		// Backend is fully ready to handle requests

		c->willDie = false;

		if (m_clients.size() == 1) {

			// first backend connected, start the server, we're ready.

			m_component->start();

		}

		// some users are in queue waiting for this backend

		while(!m_waitingUsers.empty()) {

			// There's no new backend, so stop associating users and wait for new backend,

			// which has been already spawned in getFreeClient() call.

			if (getFreeClient() == NULL)

				break;

			User *u = m_waitingUsers.front();

			m_waitingUsers.pop_front();

			LOG4CXX_INFO(logger, "Associating " << u->getJID().toString() << " with this backend");

			// associate backend with user

			handleUserCreated(u);

			// connect user if it's ready

			if (u->isReadyToConnect()) {

				handleUserReadyToConnect(u);

			}

		}

	}

	c->pongReceived = true;

}

void NetworkPluginServer::handleQueryPayload(Backend *b, const std::string &data) {

	pbnetwork::BackendConfig payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	if (!m_adminInterface) {

		return;

	}

	boost::shared_ptr<Swift::Message> msg(new Swift::Message());

	msg->setBody(payload.config());

	m_adminInterface->handleQuery(msg);

	pbnetwork::BackendConfig response;

	response.set_config(msg->getBody());

	std::string message;

	response.SerializeToString(&message);

	WRAP(message, pbnetwork::WrapperMessage_Type_TYPE_QUERY);

	send(b->connection, message);

}

void NetworkPluginServer::handleBackendConfigPayload(const std::string &data) {

	pbnetwork::BackendConfig payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	m_config->updateBackendConfig(payload.config());

}

void NetworkPluginServer::handleRoomListPayload(const std::string &data) {

	pbnetwork::RoomList payload;

	if (payload.ParseFromString(data) == false) {

		// TODO: ERROR

		return;

	}

	m_discoItemsResponder->clearRooms();

	for (int i = 0; i < payload.room_size() && i < payload.name_size(); i++) {

		m_discoItemsResponder->addRoom(Swift::JID::getEscapedNode(payload.room(i)) + "@" + m_component->getJID().toString(), payload.name(i));

	}

}

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

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

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_CHANGED:

				handleBuddyChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_CONV_MESSAGE:

				handleConvMessagePayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_SUBJECT_CHANGED:

				handleConvMessagePayload(wrapper.payload(), true);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_PONG:

				handlePongReceived(c);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_PARTICIPANT_CHANGED:

				handleParticipantChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_NICKNAME_CHANGED:

				handleRoomChangedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_VCARD:

				handleVCardPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPING:

				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Composing);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_TYPED:

				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Paused);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_STOPPED_TYPING:

				handleChatStatePayload(wrapper.payload(), Swift::ChatState::Active);

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_AUTH_REQUEST:

				handleAuthorizationPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ATTENTION:

				handleAttentionPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_STATS:

				handleStatsPayload(c, wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_START:

				handleFTStartPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_FINISH:

				handleFTFinishPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_FT_DATA:

				handleFTDataPayload(c, wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BUDDY_REMOVED:

				handleBuddyRemovedPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_QUERY:

				handleQueryPayload(c, wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_BACKEND_CONFIG:

				handleBackendConfigPayload(wrapper.payload());

				break;

			case pbnetwork::WrapperMessage_Type_TYPE_ROOM_LIST:

				handleRoomListPayload(wrapper.payload());

				break;

			default:

				return;

		}

	}

}

void NetworkPluginServer::send(boost::shared_ptr<Swift::Connection> &c, const std::string &data) {

	// generate header - size of wrapper message

	uint32_t size = htonl(data.size());

	char *header = (char *) &size;

	// send header together with wrapper message

	c->write(Swift::createSafeByteArray(std::string(header, 4) + data));

}

void NetworkPluginServer::pingTimeout() {

	// TODO: move to separate timer, those 2 loops could be expensive

	// Some users are connected for weeks and they are blocking backend to be destroyed and its memory

	// to be freed. We are finding users who are inactive for more than "idle_reconnect_time" seconds and

	// reconnect them to long-running backend, where they can idle hapilly till the end of ages.

	time_t now = time(NULL);

	std::vector<User *> usersToMove;

	unsigned long diff = CONFIG_INT(m_config, "service.idle_reconnect_time");

	if (diff != 0) {

		for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

			// Users from long-running backends can't be moved

			if ((*it)->longRun) {

				continue;

			}

			// Find users which are inactive for more than 'diff'

			BOOST_FOREACH(User *u, (*it)->users) {

				if (now - u->getLastActivity() > diff) {

					usersToMove.push_back(u);

				}

			}

		}

		// Move inactive users to long-running backend.

		BOOST_FOREACH(User *u, usersToMove) {

			LOG4CXX_INFO(logger, "Moving user " << u->getJID().toString() << " to long-running backend");

			if (!moveToLongRunBackend(u))

				break;

		}

	}

	// We have to remove startingBackend flag otherwise 1 broken backend start could

	// block the backend.

	m_startingBackend = false;

	// check ping responses

	std::vector<Backend *> toRemove;

	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

		// pong has been received OR backend just connected and did not have time to answer the ping

		// request.

		if ((*it)->pongReceived || (*it)->pongReceived == -1) {

			// Don't send another ping if pongReceived == -1, because we've already sent one

			// when registering backend.

			if ((*it)->pongReceived) {

				sendPing((*it));

			}

		}

		else {

			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). PING response not received.");

			toRemove.push_back(*it);

#ifndef WIN32

			// generate coredump for this backend to find out why it wasn't able to respond to PING

			std::string pid = (*it)->id;

			if (!pid.empty()) {

				try {

					kill(boost::lexical_cast<int>(pid), SIGABRT);

				}

				catch (...) { }

			}

#endif

		}

		if ((*it)->users.size() == 0) {

			LOG4CXX_INFO(logger, "Disconnecting backend " << (*it) << " (ID=" << (*it)->id << "). There are no users.");

			toRemove.push_back(*it);

		}

	}

	BOOST_FOREACH(Backend *b, toRemove) {

		handleSessionFinished(b);

	}

	m_pingTimer->start();

}

void NetworkPluginServer::collectBackend() {

	// Stop accepting new users to backend with the biggest memory usage. This prevents backends

	// which are leaking to eat whole memory by connectin new users to legacy network.

	LOG4CXX_INFO(logger, "Collect backend called, finding backend which will be set to die");

	unsigned long max = 0;

	Backend *backend = NULL;

	for (std::list<Backend *>::const_iterator it = m_clients.begin(); it != m_clients.end(); it++) {

		if ((*it)->res > max) {

			max = (*it)->res;

			backend = (*it);

		}

	}

	if (backend) {

		if (m_collectTimer) {

			m_collectTimer->start();

		}

		LOG4CXX_INFO(logger, "Backend " << backend << " (ID=" << backend->id << ") is set to die");

		backend->acceptUsers = false;

	}

}

bool NetworkPluginServer::moveToLongRunBackend(User *user) {

	// Check if user has already some backend

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

	if (!old) {

		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " does not have old backend. Not moving.");

		return true;

	}

	// if he's already on long run, do nothing

	if (old->longRun) {

		LOG4CXX_INFO(logger, "User " << user->getJID().toString() << " is already on long-running backend. Not moving.");