#include "backports.h"

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

	m_awayTimer = new QTimer(this);

	connect(m_awayTimer, SIGNAL(timeout()), this, SLOT(awayTimeout()));

	m_awayTimer->start(5*1000);

}

MyIrcSession::~MyIrcSession() {

	delete m_awayTimer;

}

void MyIrcSession::on_connected() {

	m_connected = true;

	if (suffix.empty()) {

		np->handleConnected(user);

// 		if (!sentList) {

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

// 			sentList = true;

// 		}

	}

// 	sendCommand(IrcCommand::createCapability("REQ", QStringList("away-notify")));

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

		LOG4CXX_INFO(logger, user << ": Sending IDENTIFY message to " << to);

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

	}

}

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

	std::string reason;

	switch(error) {

		case QAbstractSocket::ConnectionRefusedError: reason = "The connection was refused by the peer (or timed out)."; break;

		case QAbstractSocket::RemoteHostClosedError: reason = "The remote host closed the connection."; break;

		case QAbstractSocket::HostNotFoundError: reason = "The host address was not found."; break;

		case QAbstractSocket::SocketAccessError: reason = "The socket operation failed because the application lacked the required privileges."; break;

		case QAbstractSocket::SocketResourceError: reason = "The local system ran out of resources."; break;

		case QAbstractSocket::SocketTimeoutError: reason = "The socket operation timed out."; break;

		case QAbstractSocket::DatagramTooLargeError: reason = "The datagram was larger than the operating system's limit."; break;

		case QAbstractSocket::NetworkError: reason = "An error occurred with the network."; break;

		case QAbstractSocket::SslHandshakeFailedError: reason = "The SSL/TLS handshake failed, so the connection was closed"; break;

		case QAbstractSocket::UnknownSocketError: reason = "An unidentified error occurred."; break;

		default: reason= "Unknown error."; break;

	};

	if (!suffix.empty()) {

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

			np->handleParticipantChanged(user, TO_UTF8(nickName()), it->second->getChannel() + suffix, pbnetwork::PARTICIPANT_FLAG_ROOM_NOT_FOUND, pbnetwork::STATUS_NONE, reason);

		}

	}

	else {

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

		np->tryNextServer();

	}

	m_connected = false;

}

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;

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

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

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

			default: break;

		}

	return flags;

}

void MyIrcSession::on_joined(IrcMessage *message) {

	IrcJoinMessage *m = (IrcJoinMessage *) message;

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

	bool op = correctNickname(nickname);

	getIRCBuddy(TO_UTF8(m->channel().toLower()), nickname).setOp(op);

	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel().toLower()) + suffix, op, pbnetwork::STATUS_ONLINE);

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

}

void MyIrcSession::on_parted(IrcMessage *message) {

	IrcPartMessage *m = (IrcPartMessage *) message;

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

	bool op = correctNickname(nickname);

	removeIRCBuddy(TO_UTF8(m->channel().toLower()), nickname);

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

	np->handleParticipantChanged(user, nickname, TO_UTF8(m->channel().toLower()) + suffix, op, pbnetwork::STATUS_NONE, TO_UTF8(m->reason()));

}

void MyIrcSession::on_quit(IrcMessage *message) {

	IrcQuitMessage *m = (IrcQuitMessage *) message;

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

	bool op = correctNickname(nickname);

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

		if (!hasIRCBuddy(it->second->getChannel(), nickname)) {

			continue;

		}

		removeIRCBuddy(it->second->getChannel(), nickname);

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

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

	}

}

void MyIrcSession::on_nickChanged(IrcMessage *message) {

	IrcNickMessage *m = (IrcNickMessage *) message;

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

	correctNickname(nickname);

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

		if (!hasIRCBuddy(it->second->getChannel(), nickname)) {

			continue;

		}

		IRCBuddy &buddy = getIRCBuddy(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) buddy.isOp(), 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;

	correctNickname(nickname);

	if (!hasIRCBuddy(TO_UTF8(m->target().toLower()), nickname)) {

		return;

	}

	IRCBuddy &buddy = getIRCBuddy(TO_UTF8(m->target().toLower()), nickname);

	if (mode == "+o") {

		buddy.setOp(true);

	}

	else {

		buddy.setOp(false);

	}

	np->handleParticipantChanged(user, nickname, TO_UTF8(m->target().toLower()) + suffix,(int) buddy.isOp(), pbnetwork::STATUS_ONLINE, "");

	LOG4CXX_INFO(logger, user << ": " << nickname << " changed mode to " << mode << " in " << TO_UTF8(m->target().toLower()));

}

void MyIrcSession::on_topicChanged(IrcMessage *message) {

	IrcTopicMessage *m = (IrcTopicMessage *) message;

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

	correctNickname(nickname);

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

	np->handleSubject(user, TO_UTF8(m->channel().toLower()) + 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;