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

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the tools applications of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

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

#include "tcftrkdevice.h"

#include "json.h"

#include <QtNetwork/QAbstractSocket>

#include <QtCore/QDebug>

#include <QtCore/QVector>

#include <QtCore/QQueue>

#include <QtCore/QTextStream>

#include <QtCore/QDateTime>

#include <QtCore/QFileInfo>

enum { debug = 0 };

static const char messageTerminatorC[] = "\003\001";

namespace tcftrk {

// ------------- TcfTrkCommandError

TcfTrkCommandError::TcfTrkCommandError() : timeMS(0), code(0), alternativeCode(0)

{

}

void TcfTrkCommandError::clear()

{

    timeMS = 0;

    code = alternativeCode = 0;

    format.clear();

    alternativeOrganization.clear();

}

void TcfTrkCommandError::write(QTextStream &str) const

{

    if (timeMS) {

        const QDateTime time(QDate(1970, 1, 1));

        str << time.addMSecs(timeMS).toString(Qt::ISODate) << ": Error code: " << code

                << " '" << format << '\'';

        if (!alternativeOrganization.isEmpty())

            str << " ('" << alternativeOrganization << "', code: " << alternativeCode << ')';

    } else{

        str << "<No error>";

    }

}

QString TcfTrkCommandError::toString() const

{

    QString rc;

    QTextStream str(&rc);

    write(str);

    return rc;

}

/* {"Time":1277459762255,"Code":1,"AltCode":-6,"AltOrg":"POSIX","Format":"Unknown error: -6"} */

bool TcfTrkCommandError::parse(const QVector<JsonValue> &values)

{

    // Parse an arbitrary hash (that could as well be a command response)

    // and check for error elements.

    unsigned errorKeyCount = 0;

    clear();

    do {

        if (values.isEmpty() || values.front().type() != JsonValue::Object)

            break;

        foreach (const JsonValue &c, values.front().children()) {

            if (c.name() == "Time") {

                timeMS = c.data().toULongLong();

                errorKeyCount++;

            } else if (c.name() == "Code") {

                code = c.data().toInt();

                errorKeyCount++;

            } else if (c.name() == "Format") {

                format = c.data();

                errorKeyCount++;

            } else if (c.name() == "AltCode") {

                alternativeCode = c.data().toInt();

                errorKeyCount++;

            } else if (c.name() == "AltOrg") {

                alternativeOrganization = c.data();

                errorKeyCount++;

            }

        }

    } while (false);

    const bool errorFound = errorKeyCount >= 2u; // Should be at least 'Time', 'Code'.

    if (!errorFound)

        clear();

    if (debug) {

        qDebug() << "TcfTrkCommandError::parse: Found error: " << errorFound;

        if (!values.isEmpty())

            qDebug() << values.front().toString();

    }

    return errorFound;

}

// ------------ TcfTrkCommandResult

TcfTrkCommandResult::TcfTrkCommandResult(Type t) :

    type(t), service(LocatorService)

{

}

TcfTrkCommandResult::TcfTrkCommandResult(char typeChar, Services s,

                                         const QByteArray &r,

                                         const QVector<JsonValue> &v,

                                         const QVariant &ck) :

    type(FailReply), service(s), request(r), values(v), cookie(ck)

{

    switch (typeChar) {

    case 'N':

        type = FailReply;

        break;

    case 'P':

        type = ProgressReply;

        break;

    case 'R':

        type = commandError.parse(values) ? CommandErrorReply : SuccessReply;

        break;

    default:

        qWarning("Unknown TCF reply type '%c'", typeChar);

    }

}

QString TcfTrkCommandResult::errorString() const

{

    QString rc;

    QTextStream str(&rc);

    switch (type) {

    case SuccessReply:

    case ProgressReply:

        str << "<No error>";

        return rc;

    case FailReply:

        str << "NAK";

    case CommandErrorReply:

        commandError.write(str);

        break;

    }

    // Append the failed command for reference

    str << " (Command was: '";

    QByteArray printableRequest = request;

    printableRequest.replace('\0', '|');

    str << printableRequest << "')";

    return rc;

}

QString TcfTrkCommandResult::toString() const

{

    QString rc;

    QTextStream str(&rc);

    str << "Command answer ";

    switch (type) {

    case SuccessReply:

        str << "[success]";

        break;

    case CommandErrorReply:

        str << "[command error]";

        break;

    case FailReply:

        str << "[fail (NAK)]";

        break;

    case ProgressReply:

        str << "[progress]";

        break;

    }

    str << ", " << values.size() << " values(s) to request: '";

    QByteArray printableRequest = request;

    printableRequest.replace('\0', '|');

    str << printableRequest << "' ";

    if (cookie.isValid())

        str << " cookie: " << cookie.toString();

    str << '\n';

    for (int i = 0, count = values.size(); i < count; i++)

        str << '#' << i << ' ' << values.at(i).toString() << '\n';

    if (type == CommandErrorReply)

        str << "Error: " << errorString();

    return rc;

}

struct TcfTrkSendQueueEntry

{

    typedef TcfTrkDevice::MessageType MessageType;

    explicit TcfTrkSendQueueEntry(MessageType mt,

                                  int tok,

                                  Services s,

                           const QByteArray &d,

                           const TcfTrkCallback &cb= TcfTrkCallback(),

                           const QVariant &ck = QVariant()) :

    messageType(mt), service(s), data(d), token(tok), cookie(ck), callback(cb)  {}

    MessageType messageType;

    Services service;

    QByteArray data;

    int token;

    QVariant cookie;

    TcfTrkCallback callback;

};

struct TcfTrkDevicePrivate {

    typedef TcfTrkDevice::IODevicePtr IODevicePtr;

    typedef QHash<int, TcfTrkSendQueueEntry> TokenWrittenMessageMap;

    TcfTrkDevicePrivate();

    const QByteArray m_messageTerminator;

    IODevicePtr m_device;

    unsigned m_verbose;

    QByteArray m_readBuffer;

    int m_token;

    QQueue<TcfTrkSendQueueEntry> m_sendQueue;

    TokenWrittenMessageMap m_writtenMessages;

    QVector<QByteArray> m_registerNames;

};

TcfTrkDevicePrivate::TcfTrkDevicePrivate() :

    m_messageTerminator(messageTerminatorC),

    m_verbose(0), m_token(0)

{

}

TcfTrkDevice::TcfTrkDevice(QObject *parent) :

    QObject(parent), d(new TcfTrkDevicePrivate)

{

}

TcfTrkDevice::~TcfTrkDevice()

{

    delete d;

}

QVector<QByteArray> TcfTrkDevice::registerNames() const

{

    return d->m_registerNames;

}

void TcfTrkDevice::setRegisterNames(const QVector<QByteArray>& n)

{

    d->m_registerNames = n;

    if (d->m_verbose) {

        QString msg;

        QTextStream str(&msg);

        const int count = n.size();

        str << "Registers (" << count << "): ";

        for (int i = 0; i < count; i++)

            str << '#' << i << '=' << n.at(i) << ' ';

        emitLogMessage(msg);

    }

}

TcfTrkDevice::IODevicePtr TcfTrkDevice::device() const

{

    return d->m_device;

}

TcfTrkDevice::IODevicePtr TcfTrkDevice::takeDevice()

{

    const IODevicePtr old = d->m_device;

    if (!old.isNull()) {

        old.data()->disconnect(this);

        d->m_device = IODevicePtr();

    }

    d->m_readBuffer.clear();

    d->m_token = 0;

    d->m_sendQueue.clear();

    return old;

}

void TcfTrkDevice::setDevice(const IODevicePtr &dp)

{

    if (dp.data() == d->m_device.data())

        return;

    if (dp.isNull()) {

        emitLogMessage(QLatin1String("Internal error: Attempt to set NULL device."));

        return;

    }

    takeDevice();

    d->m_device = dp;

    connect(dp.data(), SIGNAL(readyRead()), this, SLOT(slotDeviceReadyRead()));

    if (QAbstractSocket *s = qobject_cast<QAbstractSocket *>(dp.data())) {

        connect(s, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(slotDeviceError()));

        connect(s, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(slotDeviceSocketStateChanged()));

    }

}

void TcfTrkDevice::slotDeviceError()

{

    const QString message = d->m_device->errorString();

    emitLogMessage(message);

    emit error(message);

}

void TcfTrkDevice::slotDeviceSocketStateChanged()

{

    if (const QAbstractSocket *s = qobject_cast<const QAbstractSocket *>(d->m_device.data())) {

        const QAbstractSocket::SocketState st = s->state();

        switch (st) {

        case QAbstractSocket::UnconnectedState:

            emitLogMessage(QLatin1String("Unconnected"));

            break;

        case QAbstractSocket::HostLookupState:

            emitLogMessage(QLatin1String("HostLookupState"));

            break;

        case QAbstractSocket::ConnectingState:

            emitLogMessage(QLatin1String("Connecting"));

            break;

        case QAbstractSocket::ConnectedState:

            emitLogMessage(QLatin1String("Connected"));

            break;

        case QAbstractSocket::ClosingState:

            emitLogMessage(QLatin1String("Closing"));

            break;

        default:

            emitLogMessage(QString::fromLatin1("State %1").arg(st));

            break;

        }

    }

}

static inline QString debugMessage(QByteArray  message, const char *prefix = 0)

{

    message.replace('\0', '|');

    const QString messageS = QString::fromLatin1(message);

    return prefix ?

            (QLatin1String(prefix) + messageS) :  messageS;

}

void TcfTrkDevice::slotDeviceReadyRead()

{

    d->m_readBuffer += d->m_device->readAll();

    // Take complete message off front of readbuffer.

    do {

        const int messageEndPos = d->m_readBuffer.indexOf(d->m_messageTerminator);

        if (messageEndPos == -1)

            break;

        const QByteArray message = d->m_readBuffer.left(messageEndPos);

        if (debug)

            qDebug("Read:\n%s", qPrintable(formatData(message)));

        if (const int errorCode = parseMessage(message)) {

            emitLogMessage(QString::fromLatin1("Parse error %1 for: %2").arg(errorCode).arg(debugMessage(message)));

        }

        d->m_readBuffer.remove(0, messageEndPos + d->m_messageTerminator.size());

    } while (!d->m_readBuffer.isEmpty());

    checkSendQueue(); // Send off further message

}

// Split \0-terminated message into tokens, skipping the initial type character

static inline QVector<QByteArray> splitMessage(const QByteArray &message)

{

    QVector<QByteArray> tokens;

    tokens.reserve(7);

    const int messageSize = message.size();

    for (int pos = 2; pos < messageSize; ) {

        const int nextPos = message.indexOf('\0', pos);

        if (nextPos == -1)

            break;

        tokens.push_back(message.mid(pos, nextPos - pos));

        pos = nextPos + 1;

    }

    return tokens;

}

int TcfTrkDevice::parseMessage(const QByteArray &message)

{

    if (d->m_verbose)

        emitLogMessage(debugMessage(message, "TCF ->"));

    // Special JSON parse error message or protocol format error.

    // The port is usually closed after receiving it.

    // "\3\2{"Time":1276096098255,"Code":3,"Format": "Protocol format error"}"

    if (message.startsWith("\003\002")) {

        QByteArray text = message.mid(2);

        const QString errorMessage = QString::fromLatin1("Parse error received: %1").arg(QString::fromAscii(text));

        emit error(errorMessage);

        return 0;

    }

    if (message.size() < 4 || message.at(1) != '\0')

        return 1;

    // Split into tokens

    const char type = message.at(0);

    const QVector<QByteArray> tokens = splitMessage(message);

    switch (type) {

    case 'E':

        return parseTcfEvent(tokens);

    case 'R': // Command replies

    case 'N':

    case 'P':

        return parseTcfCommandReply(type, tokens);

    default:

        emitLogMessage(QString::fromLatin1("Unhandled message type: %1").arg(debugMessage(message)));

        return 756;

    }

    return 0;

}

int TcfTrkDevice::parseTcfCommandReply(char type, const QVector<QByteArray> &tokens)

{

    typedef TcfTrkDevicePrivate::TokenWrittenMessageMap::iterator TokenWrittenMessageMapIterator;

    // Find the corresponding entry in the written messages hash.

    const int tokenCount = tokens.size();

    if (tokenCount < 1)

        return 234;

    bool tokenOk;

    const int token = tokens.at(0).toInt(&tokenOk);

    if (!tokenOk)

        return 235;

    const TokenWrittenMessageMapIterator it = d->m_writtenMessages.find(token);

    if (it == d->m_writtenMessages.end()) {

        qWarning("TcfTrkDevice: Internal error: token %d not found for '%s'",

                 token, qPrintable(joinByteArrays(tokens)));

        return 236;

    }

    // No callback: remove entry from map, happy

    if (!it.value().callback) {

        d->m_writtenMessages.erase(it);

        return 0;

    }

    // Parse values into JSON

    QVector<JsonValue> values;

    values.reserve(tokenCount);

    for (int i = 1; i < tokenCount; i++) {

        if (!tokens.at(i).isEmpty()) { // Strange: Empty tokens occur.

            const JsonValue value(tokens.at(i));

            if (value.isValid()) {

                values.push_back(value);

            } else {

                qWarning("JSON parse error for reply to command token %d: #%d '%s'",

                         token, i, tokens.at(i).constData());

                d->m_writtenMessages.erase(it);

                return -1;

            }

        }

    }

    // Construct result and invoke callback, remove entry from map.

    TcfTrkCallback callback = it.value().callback;

    TcfTrkCommandResult result(type, it.value().service, it.value().data,

                               values, it.value().cookie);

    d->m_writtenMessages.erase(it);

    callback(result);

    return 0;

}

static const char locatorAnswerC[] = "E\0Locator\0Hello\0[\"Locator\"]";

int TcfTrkDevice::parseTcfEvent(const QVector<QByteArray> &tokens)

{

    // Event: Ignore the periodical heartbeat event, answer 'Hello',

    // emit signal for the rest

    if (tokens.size() < 3)

        return 433;

    const Services service = serviceFromName(tokens.at(0).constData());

    if (service == LocatorService && tokens.at(1) == "peerHeartBeat")

        return 0;

    QVector<JsonValue> values;

    for (int i = 2; i < tokens.size(); i++) {

        const JsonValue value(tokens.at(i));

        if (!value.isValid())

            return 434;

        values.push_back(value);

    }

    // Parse known events, emit signals

    QScopedPointer<TcfTrkEvent> knownEvent(TcfTrkEvent::parseEvent(service, tokens.at(1), values));

    if (!knownEvent.isNull()) {

        // Answer hello event.

        if (knownEvent->type() == TcfTrkEvent::LocatorHello)

            writeMessage(QByteArray(locatorAnswerC, sizeof(locatorAnswerC)));

        emit tcfEvent(*knownEvent);

    }

    emit genericTcfEvent(service, tokens.at(1), values);

    if (debug || d->m_verbose) {

        QString msg;

        QTextStream str(&msg);

        if (knownEvent.isNull()) {

            str << "Event: " << tokens.at(0) << ' ' << tokens.at(1) << '\n';

            foreach(const JsonValue &val, values)

                str << "  " << val.toString() << '\n';

        } else {

            str << knownEvent->toString();

        }

        emitLogMessage(msg);

    }

    return 0;

}

unsigned TcfTrkDevice::verbose() const

{

    return d->m_verbose;

}