/*

 * 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 "Swiften/Elements/StatusShow.h"

MyIrcSession::MyIrcSession(const std::string &user, NetworkPlugin *np, QObject* parent) : Irc::Session(parent)

{

	this->np = np;

	this->user = user;

}

}

void MyIrcSession::on_disconnected()

{

    std::cout << "disconnected:\n";

}

void MyIrcSession::on_bufferAdded(Irc::Buffer* buffer)

{

    qDebug() << "buffer added:" << buffer->receiver();

}

void MyIrcSession::on_bufferRemoved(Irc::Buffer* buffer)

{

    qDebug() << "buffer removed:" << buffer->receiver();

}

Irc::Buffer* MyIrcSession::createBuffer(const QString& receiver)

{

    return new MyIrcBuffer(receiver, user, np, this);

}

MyIrcBuffer::MyIrcBuffer(const QString& receiver, const std::string &user, NetworkPlugin *np, Irc::Session* parent)

    : Irc::Buffer(receiver, parent)

{

	this->np = np;

	this->user = user;

	p = (MyIrcSession *) parent;

    connect(this, SIGNAL(receiverChanged(QString)), SLOT(on_receiverChanged(QString)));

    connect(this, SIGNAL(joined(QString)), SLOT(on_joined(QString)));

    connect(this, SIGNAL(parted(QString, QString)), SLOT(on_parted(QString, QString)));

    connect(this, SIGNAL(quit(QString, QString)), SLOT(on_quit(QString, QString)));

    connect(this, SIGNAL(nickChanged(QString, QString)), SLOT(on_nickChanged(QString, QString)));

    connect(this, SIGNAL(modeChanged(QString, QString, QString)), SLOT(on_modeChanged(QString, QString, QString)));

    connect(this, SIGNAL(topicChanged(QString, QString)), SLOT(on_topicChanged(QString, QString)));

    connect(this, SIGNAL(invited(QString, QString, QString)), SLOT(on_invited(QString, QString, QString)));

    connect(this, SIGNAL(kicked(QString, QString, QString)), SLOT(on_kicked(QString, QString, QString)));

    connect(this, SIGNAL(messageReceived(QString, QString, Irc::Buffer::MessageFlags)),

                  SLOT(on_messageReceived(QString, QString, Irc::Buffer::MessageFlags)));

    connect(this, SIGNAL(noticeReceived(QString, QString, Irc::Buffer::MessageFlags)),

                  SLOT(on_noticeReceived(QString, QString, Irc::Buffer::MessageFlags)));

    connect(this, SIGNAL(ctcpRequestReceived(QString, QString, Irc::Buffer::MessageFlags)),

                  SLOT(on_ctcpRequestReceived(QString, QString, Irc::Buffer::MessageFlags)));

    connect(this, SIGNAL(ctcpReplyReceived(QString, QString, Irc::Buffer::MessageFlags)),

                  SLOT(on_ctcpReplyReceived(QString, QString, Irc::Buffer::MessageFlags)));

    connect(this, SIGNAL(ctcpActionReceived(QString, QString, Irc::Buffer::MessageFlags)),

                  SLOT(on_ctcpActionReceived(QString, QString, Irc::Buffer::MessageFlags)));

    connect(this, SIGNAL(numericMessageReceived(QString, uint, QStringList)), SLOT(on_numericMessageReceived(QString, uint, QStringList)));

	qDebug() << "topic changed:" << receiver() << origin << topic;

	np->handleSubject(user, receiver().toStdString(), topic.toStdString(), origin.toStdString());

}

void MyIrcBuffer::on_invited(const QString& origin, const QString& receiver, const QString& channel)

{

    qDebug() << "invited:" << Irc::Buffer::receiver() << origin << receiver << channel;

}

void MyIrcBuffer::on_kicked(const QString& origin, const QString& nick, const QString& message)

{

    qDebug() << "kicked:" << receiver() << origin << nick << message;

}

void MyIrcBuffer::on_messageReceived(const QString& origin, const QString& message, Irc::Buffer::MessageFlags flags) {

	qDebug() << "message received:" << receiver() << origin << message << (flags & Irc::Buffer::IdentifiedFlag ? "(identified!)" : "(not identified)");

	if (!receiver().startsWith("#") && (flags & Irc::Buffer::EchoFlag))

		return;

	np->handleMessage(user, receiver().toStdString(), message.toStdString(), origin.toStdString());

}

void MyIrcBuffer::on_noticeReceived(const QString& origin, const QString& notice, Irc::Buffer::MessageFlags flags)

{

    qDebug() << "notice received:" << receiver() << origin << notice

             << (flags & Irc::Buffer::IdentifiedFlag ? "(identified!)" : "(not identified)");

}

void MyIrcBuffer::on_ctcpRequestReceived(const QString& origin, const QString& request, Irc::Buffer::MessageFlags flags)

{

    qDebug() << "ctcp request received:" << receiver() << origin << request

             << (flags & Irc::Buffer::IdentifiedFlag ? "(identified!)" : "(not identified)");

}

void MyIrcBuffer::on_ctcpReplyReceived(const QString& origin, const QString& reply, Irc::Buffer::MessageFlags flags)

{

    qDebug() << "ctcp reply received:" << receiver() << origin << reply

             << (flags & Irc::Buffer::IdentifiedFlag ? "(identified!)" : "(not identified)");

}

void MyIrcBuffer::on_ctcpActionReceived(const QString& origin, const QString& action, Irc::Buffer::MessageFlags flags)

{

    qDebug() << "ctcp action received:" << receiver() << origin << action

             << (flags & Irc::Buffer::IdentifiedFlag ? "(identified!)" : "(not identified)");

}

void MyIrcBuffer::on_numericMessageReceived(const QString& origin, uint code, const QStringList& params)

{

	switch (code) {

		case 332:

			m_topicData = params.value(2).toStdString();

			break;

		case 333:

			np->handleSubject(user, params.value(1).toStdString(), m_topicData, params.value(2).toStdString());

			break;

		case 353:

			QString channel = params.value(2);

			QStringList members = params.value(3).split(" ");

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

				int flags = 0;

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

				flags = correctNickname(nickname);

				p->m_modes[channel.toStdString() + nickname] = flags;

				std::cout << channel.toStdString() + nickname << " " << flags << "\n";

				np->handleParticipantChanged(user, nickname, channel.toStdString(), flags, Swift::StatusShow::Online);

			}

			break;

	}

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

}

void MyIrcBuffer::on_unknownMessageReceived(const QString& origin, const QStringList& params)

{

    qDebug() << "unknown message received:" << receiver() << origin << params;

}