#include "tmsgcore.h"

#include <qlocalserver.h></qlocalserver.h>

#include <qlocalsocket.h></qlocalsocket.h>

#include <qstringlist></qstringlist>

#include <qcoreapplication></qcoreapplication>

#include <qtcpserver></qtcpserver>

#include <qtcpsocket></qtcpsocket>

TMsgCore *TMsgCore::instance()

{

	static TMsgCore *theInstance = 0;

	if (!theInstance)

		theInstance = new TMsgCore();

	return theInstance;

}

//----------------------------------

TMsgCore::TMsgCore()

	: m_tcpServer(0), m_clientSocket(0)

{

}

//----------------------------------

void TMsgCore::OnNewConnection() //server side

{

	QTcpSocket *socket;

	if (m_tcpServer)

		socket = m_tcpServer->nextPendingConnection();

	assert(socket);

	bool ret = connect(socket, SIGNAL(readyRead()), SLOT(OnReadyRead()));

	ret = ret && connect(socket, SIGNAL(disconnected()), SLOT(OnDisconnected()));

	assert(ret);

	m_sockets.insert(socket);

}

//----------------------------------------------------------

#define TMSG_PORT 10545

bool TMsgCore::openConnection() //server side

{

	//QHostAddress host = (remoteConnection) ? QHostAddress::AnyQHostAddress::LocalHost : ;

	if (m_tcpServer != 0 && m_tcpServer->serverAddress() == QHostAddress::Any)

		return true;

	if (m_tcpServer != 0)

		delete m_tcpServer;

	m_tcpServer = new QTcpServer();

	bool ret = connect(m_tcpServer, SIGNAL(newConnection()), SLOT(OnNewConnection()));

	//bool listen = m_tcpServer->listen(QString("tmsg")+QString::number(QCoreApplication::applicationPid()));

	bool listen = m_tcpServer->listen(QHostAddress::Any, TMSG_PORT); //QString("tmsg")+QString::number(QCoreApplication::applicationPid()));

	if (!listen) {

		QString err = m_tcpServer->errorString();

	}

	assert(ret && listen);

	return true;

}

//---------------------------

QString TMsgCore::getConnectionName() //server side

{

	assert(m_tcpServer);

	QString serverName = "pippo"; //m_tcpServer->serverName();

	return serverName;

}

//-----------------------------------------------------------------------

void TMsgCore::OnDisconnected() //server side

{

	std::set<qtcpsocket *="">::iterator it = m_sockets.begin();</qtcpsocket>

	while (it != m_sockets.end()) {

		if ((*it)->state() != QTcpSocket::ConnectedState)

			m_sockets.erase(it++);

		else

			it++;

	}

	//if (m_socketIn)

	//delete m_socketIn;

	//m_socketIn = 0;

}

//------------------------------------------------------------------

void TMsgCore::OnReadyRead() //server side

{

	std::set<qtcpsocket *="">::iterator it = m_sockets.begin();</qtcpsocket>

	for (; it != m_sockets.end(); it++) //devo scorrerli tutti perche' non so da quale socket viene il messaggio...

	{

		if ((*it)->state() == QTcpSocket::ConnectedState && (*it)->bytesAvailable() > 0)

			break;

	}

	if (it != m_sockets.end()) {

		readFromSocket(*it);

		OnReadyRead();

	}

}

//-------------------------------------------------

void TMsgCore::readFromSocket(QTcpSocket *socket) //server side

{

	static char data[1024];

	static QString prevMessage;

	QString str;

	int byteread;

	while ((byteread = socket->read(data, 1023)) != 0) {

		data[byteread] = '\0';

		str += QString(data);

	}

	QString message = prevMessage + str;

	prevMessage = QString();

	if (message.isEmpty())

		return;

	int lastEnd = message.lastIndexOf("#END");

	int lastbegin = message.lastIndexOf("#TMSG");

	if (lastbegin == -1 && lastEnd == -1) {

		prevMessage = message;

		return;

	} else if (lastbegin != -1 && lastEnd != -1 && lastEnd < lastbegin) {

		prevMessage = message.right(message.size() - lastbegin);

		message.chop(lastbegin);

	}

	QStringList messages = message.split("#TMSG", QString::SkipEmptyParts);

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

		QString str = messages.at(i).simplified();

		str.chop(4); //rimuovo i "#END" alla fine

		if (str.startsWith("ERROR"))

			DVGui::MsgBox(CRITICAL, str.right(str.size() - 5));

		else if (str.startsWith("WARNING"))

			DVGui::MsgBox(WARNING, str.right(str.size() - 7));

		else if (str.startsWith("INFO"))

			DVGui::MsgBox(INFORMATION, str.right(str.size() - 4));

		else

			assert(false);

	}

}

//------------------------------------------------------

TMsgCore::~TMsgCore()

{

	if (m_tcpServer == 0 && m_clientSocket != 0) //client side

	{

		//m_socketIn->waitForBytesWritten (-1);

		//   m_clientSocket->disconnectFromServer();

		// m_clientSocket->waitForDisconnected();

		delete m_clientSocket;

		m_clientSocket = 0;

	}

}

//----------------------------------

bool TMsgCore::send(MsgType type, const QString &message) //client side

{

	if (receivers(SIGNAL(sendMessage(int, const QString &))) == 0) {

		if (m_clientSocket == 0 || m_clientSocket->state() != QTcpSocket::ConnectedState)

			return false;

		QString socketMessage = (type == CRITICAL ? "#TMSG ERROR " : (type == WARNING ? "#TMSG WARNING " : "#TMSG INFO ")) + message + " #END\n";

#if QT_VERSION >= 0x050000

		m_clientSocket->write(socketMessage.toLatin1());

#else

		m_clientSocket->write(socketMessage.toAscii());

#endif

		m_clientSocket->flush();

		//m_clientSocket->waitForBytesWritten (1000);

	} else

		Q_EMIT sendMessage(type, message);

	return true;

}

//-------------------------------------------------------------------

void TMsgCore::connectTo(const QString &address) //client side

{

	m_clientSocket = new QTcpSocket();

	m_clientSocket->connectToHost(address == "" ? QHostAddress::LocalHost : QHostAddress(address), TMSG_PORT);

	//m_clientSocket->connectToServer (connectionName, QIODevice::ReadWrite | QIODevice::Text);

	bool ret = m_clientSocket->waitForConnected(1000);

	if (!ret) {

		// std::cout << "cannot connect to "<< address.toStdString() << std::endl;

		//std::cout << "error "<< m_clientSocket->errorString().toStdString() << std::endl;

		int err = m_clientSocket->error();

	}

}

//-----------------------------------------------------------------------

void DVGui::MsgBox(MsgType type, const QString &text)

{

	TMsgCore::instance()->send(type, text);

}

//-----------------------------------------------------------------------

void DVGui::error(const QString &msg)

{

	MsgBox(DVGui::CRITICAL, msg);

}

//-----------------------------------------------------------------------------

void DVGui::warning(const QString &msg)

{

	MsgBox(DVGui::WARNING, msg);

}

//-----------------------------------------------------------------------------

void DVGui::info(const QString &msg)

{

	MsgBox(DVGui::INFORMATION, msg);

}