#include "assert.h"

// Qt includes

#include <qdatastream></qdatastream>

#include <qdebug></qdebug>

#include "tipc.h"

#include "tipcmsg.h"

#include "tipcsrvP.h"

#include "tipcsrv.h"

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

//    Diagnostics stuff

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

//#define TIPC_DEBUG

#ifdef TIPC_DEBUG

#define tipc_debug(expr) expr

#else

#define tipc_debug(expr)

#endif

#ifdef TIPC_DEBUG

#include <qtime></qtime>

#endif

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

//    tipc::SocketListener implementation

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

void tipc::SocketController::onReadyRead() {

  // Deliver the message to the server for interpretation.

  m_server->dispatchSocket(m_socket);

}

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

void tipc::SocketController::onDisconnected() {

  m_socket->QObject::disconnect(SIGNAL(readyRead()));

  // Auto-delete this

  delete this;

}

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

//    Server implementation

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

tipc::Server::Server() : m_lock(false) {

  connect(this, SIGNAL(newConnection()), this, SLOT(onNewConnection()));

  // Add default parsers

  addParser(new DefaultMessageParser<shmem_request>);</shmem_request>

  addParser(new DefaultMessageParser<shmem_release>);</shmem_release>

  addParser(new DefaultMessageParser<tmpfile_request>);</tmpfile_request>

  addParser(new DefaultMessageParser<tmpfile_release>);</tmpfile_release>

  addParser(new DefaultMessageParser<quit_on_error>);</quit_on_error>

}

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

tipc::Server::~Server() {

  // Release parsers

  QHash<qstring, *="" messageparser="">::iterator it;</qstring,>

  for (it = m_parsers.begin(); it != m_parsers.end(); ++it) delete it.value();

}

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

void tipc::Server::addParser(MessageParser *parser) {

  m_parsers.insert(parser->header(), parser);

}

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

void tipc::Server::removeParser(QString header) {

  MessageParser *parser = m_parsers.take(header);

  if (parser) delete parser;

}

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

void tipc::Server::onNewConnection() {

  tipc_debug(qDebug("new connection"));

  // Accept the connection

  QLocalSocket *socket = nextPendingConnection();

  // Allocate a controller for the socket

  SocketController *controller = new SocketController;

  controller->m_server         = this;

  controller->m_socket         = socket;

  // Connect the controller to the socket's signals

  connect(socket, SIGNAL(readyRead()), controller, SLOT(onReadyRead()));

  connect(socket, SIGNAL(disconnected()), controller, SLOT(onDisconnected()));

  connect(socket, SIGNAL(disconnected()), socket, SLOT(deleteLater()));

  connect(socket, SIGNAL(error(QLocalSocket::LocalSocketError)), this,

          SLOT(onError(QLocalSocket::LocalSocketError)));

}

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

void tipc::Server::onError(QLocalSocket::LocalSocketError error) {

  tipc_debug(qDebug() << "Server error #" << error << ": " << errorString());

}

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

void tipc::Server::dispatchSocket(QLocalSocket *socket) {

  // The lock is established when a message is currently being processed.

  // Returning if the lock is set avoids having recursive message processing;

  // which is possible if a parser expects further message packets.

  if (m_lock) return;

  tipc::Stream stream(socket);

  QString header;

  while (socket->bytesAvailable() > 0) {

    if (!stream.messageReady()) return;

    Message msg;

    stream >> msg;

    msg >> header;

    assert(!header.isEmpty());

    tipc_debug(qDebug() << header << endl);

    QHash<qstring, *="" messageparser="">::iterator it = m_parsers.find(header);</qstring,>

    if (it == m_parsers.end()) {

      tipc_debug(qDebug() << "Error: Unrecognized command" << endl);

      continue;

    }

    m_lock = true;

    MessageParser *parser = it.value();

    parser->m_socket      = socket;

    parser->m_stream      = &stream;

    parser->operator()(msg);

    m_lock = false;

    // The Message has been read and processed. Send the reply.

    if (msg.ba().size() > 0) stream << msg;

  }

}