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

**

** 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 "trkdevice.h"

#include "trkutils.h"

#include <QtCore/QString>

#include <QtCore/QDebug>

#include <QtCore/QQueue>

#include <QtCore/QHash>

#include <QtCore/QMap>

#include <QtCore/QThread>

#include <QtCore/QMutex>

#include <QtCore/QWaitCondition>

#include <QtCore/QSharedPointer>

#include <QtCore/QMetaType>

#ifdef Q_OS_WIN

#  include <windows.h>

#else

#  include <QtCore/QFile>

#  include <stdio.h>

#  include <sys/ioctl.h>

#  include <sys/types.h>

#  include <termios.h>

#  include <errno.h>

#  include <string.h>

#  include <unistd.h>

/* Required headers for select() according to POSIX.1-2001 */

#  include <sys/select.h>

/* Required headers for select() according to earlier standards:

       #include <sys/time.h>

       #include <sys/types.h>

       #include <unistd.h>

*/

#endif

#ifdef Q_OS_WIN

// Format windows error from GetLastError() value:

// TODO: Use the one provided by the utils lib.

QString winErrorMessage(unsigned long error)

{

    QString rc = QString::fromLatin1("#%1: ").arg(error);

    ushort *lpMsgBuf;

    const int len = FormatMessage(

            FORMAT_MESSAGE_ALLOCATE_BUFFER

                | FORMAT_MESSAGE_FROM_SYSTEM

                | FORMAT_MESSAGE_IGNORE_INSERTS,

            NULL, error, 0, (LPTSTR)&lpMsgBuf, 0, NULL);

    if (len) {

        rc = QString::fromUtf16(lpMsgBuf, len);

        LocalFree(lpMsgBuf);

    } else {

        rc += QString::fromLatin1("<unknown error>");

    }

    return rc;

}

#endif

enum { verboseTrk = 0 };

namespace trk {

///////////////////////////////////////////////////////////////////////

//

// TrkMessage

//

///////////////////////////////////////////////////////////////////////

/* A message to be send to TRK, triggering a callback on receipt

 * of the answer. */

struct TrkMessage

{

    explicit TrkMessage(byte code = 0u, byte token = 0u,

                        TrkCallback callback = TrkCallback());

    byte code;

    byte token;

    QByteArray data;

    QVariant cookie;

    TrkCallback callback;

};

TrkMessage::TrkMessage(byte c, byte t, TrkCallback cb) :

    code(c),

    token(t),

    callback(cb)

{

}

QDebug operator<<(QDebug d, const TrkMessage &msg)

{

    return d << "Message: Code: " << msg.code

        << " Token: " << msg.token << " " << msg.data.toHex();

}

} // namespace trk

Q_DECLARE_METATYPE(trk::TrkMessage)

Q_DECLARE_METATYPE(trk::TrkResult)

namespace trk {

///////////////////////////////////////////////////////////////////////

//

// TrkWriteQueue: Mixin class that manages a write queue of Trk messages.

// pendingMessage()/notifyWriteResult() should be called from a worked/timer

// that writes the messages. The class does not take precautions for multithreading.

// A no-op message is simply taken off the queue. The calling class

// can use the helper invokeNoopMessage() to trigger its callback.

//

///////////////////////////////////////////////////////////////////////

class TrkWriteQueue

{    

    Q_DISABLE_COPY(TrkWriteQueue)

public:

    explicit TrkWriteQueue();

    // Enqueue messages.

    void queueTrkMessage(byte code, TrkCallback callback,

                        const QByteArray &data, const QVariant &cookie);

    void queueTrkInitialPing();

    // Call this from the device read notification with the results.

    void slotHandleResult(const TrkResult &result, QMutex *mutex = 0);

    // pendingMessage() can be called periodically in a timer to retrieve

    // the pending messages to be sent.

    enum PendingMessageResult {

        NoMessage,               // No message in queue.

        PendingMessage,          /* There is a queued message. The calling class

                                  * can write it out and use notifyWriteResult()

                                  * to notify about the result. */

        NoopMessageDequeued      // A no-op message has been dequeued. see invokeNoopMessage().

    };

    PendingMessageResult pendingMessage(TrkMessage *message);

    // Notify the queue about the success of the write operation

    // after taking the pendingMessage off.

    enum WriteResult {

        WriteOk,

        WriteFailedDiscard, // Discard failed message

        WriteFailedKeep,    // Keep failed message

    };

    void notifyWriteResult(WriteResult ok);

    // Helper function that invokes the callback of a no-op message

    static void invokeNoopMessage(trk::TrkMessage);

private:

    typedef QMap<byte, TrkMessage> TokenMessageMap;

    byte nextTrkWriteToken();

    byte m_trkWriteToken;

    QQueue<TrkMessage> m_trkWriteQueue;

    TokenMessageMap m_writtenTrkMessages;

    bool m_trkWriteBusy;

};

TrkWriteQueue::TrkWriteQueue() :

    m_trkWriteToken(0),

    m_trkWriteBusy(false)

{

}

byte TrkWriteQueue::nextTrkWriteToken()

{

    ++m_trkWriteToken;

    if (m_trkWriteToken == 0)

        ++m_trkWriteToken;

    if (verboseTrk)

        qDebug() << "Write token: " << m_trkWriteToken;

    return m_trkWriteToken;

}

void TrkWriteQueue::queueTrkMessage(byte code, TrkCallback callback,

    const QByteArray &data, const QVariant &cookie)

{

    const byte token = code == TRK_WRITE_QUEUE_NOOP_CODE ?

                                byte(0) : nextTrkWriteToken();

    TrkMessage msg(code, token, callback);

    msg.data = data;

    msg.cookie = cookie;

    m_trkWriteQueue.append(msg);

}

TrkWriteQueue::PendingMessageResult TrkWriteQueue::pendingMessage(TrkMessage *message)

{

    // Invoked from timer, try to flush out message queue

    if (m_trkWriteBusy || m_trkWriteQueue.isEmpty())

        return NoMessage;

    // Handle the noop message, just invoke CB in slot (ower thread)

    if (m_trkWriteQueue.front().code == TRK_WRITE_QUEUE_NOOP_CODE) {

        *message = m_trkWriteQueue.dequeue();

        return NoopMessageDequeued;

    }

    // Insert into map fir answers (as reading threads might get an

    // answer before notifyWriteResult(true)) is called.

    *message = m_trkWriteQueue.front();

    m_writtenTrkMessages.insert(message->token, *message);

    m_trkWriteBusy = true;

    return PendingMessage;

}

void TrkWriteQueue::invokeNoopMessage(trk::TrkMessage noopMessage)

{

    TrkResult result;

    result.code = noopMessage.code;

    result.token = noopMessage.token;

    result.data = noopMessage.data;

    result.cookie = noopMessage.cookie;

    noopMessage.callback(result);

}

void TrkWriteQueue::notifyWriteResult(WriteResult wr)

{

    // On success, dequeue message and await result

    const byte token = m_trkWriteQueue.front().token;

    switch (wr) {

    case WriteOk:

        m_trkWriteQueue.dequeue();

        break;

    case WriteFailedKeep:

    case WriteFailedDiscard:

        m_writtenTrkMessages.remove(token);

        m_trkWriteBusy = false;

        if (wr == WriteFailedDiscard)

            m_trkWriteQueue.dequeue();

        break;

    }

}

void TrkWriteQueue::slotHandleResult(const TrkResult &result, QMutex *mutex)

{

    // Find which request the message belongs to and invoke callback

    // if ACK or on NAK if desired.

    if (mutex)

        mutex->lock();

    m_trkWriteBusy = false;

    const TokenMessageMap::iterator it = m_writtenTrkMessages.find(result.token);

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

        if (mutex)

            mutex->unlock();

        return;

    }

    TrkCallback callback = it.value().callback;

    const QVariant cookie = it.value().cookie;

    m_writtenTrkMessages.erase(it);

    if (mutex)

        mutex->unlock();

    // Invoke callback

    if (callback) {

        TrkResult result1 = result;

        result1.cookie = cookie;

        callback(result1);

    }

}

void TrkWriteQueue::queueTrkInitialPing()

{

    // Ping, reset sequence count

    m_trkWriteToken = 0;

    m_trkWriteQueue.append(TrkMessage(TrkPing, 0));

}

///////////////////////////////////////////////////////////////////////

//

// DeviceContext to be shared between threads

//

///////////////////////////////////////////////////////////////////////

struct DeviceContext {

    DeviceContext();

#ifdef Q_OS_WIN

    HANDLE device;

    OVERLAPPED readOverlapped;

    OVERLAPPED writeOverlapped;

#else

    QFile file;

#endif

    bool serialFrame;

    QMutex mutex;

};

DeviceContext::DeviceContext() :

#ifdef Q_OS_WIN

    device(INVALID_HANDLE_VALUE),

#endif

    serialFrame(true)

{

}

///////////////////////////////////////////////////////////////////////

//

// TrkWriterThread: A thread operating a TrkWriteQueue.

// with exception of the handling of the  TRK_WRITE_QUEUE_NOOP_CODE

// synchronization message. The invocation of the callback is then

// done by the thread owning the TrkWriteQueue, while pendingMessage() is called

// from another thread. This happens via a Qt::BlockingQueuedConnection.

///////////////////////////////////////////////////////////////////////

class WriterThread : public QThread

{

    Q_OBJECT

    Q_DISABLE_COPY(WriterThread)

public:            

    explicit WriterThread(const QSharedPointer<DeviceContext> &context);

    // Enqueue messages.

    void queueTrkMessage(byte code, TrkCallback callback,

                        const QByteArray &data, const QVariant &cookie);

    void queueTrkInitialPing();

    // Call this from the device read notification with the results.

    void slotHandleResult(const TrkResult &result);

    virtual void run();

signals:

    void error(const QString &);

    void internalNoopMessageDequeued(const trk::TrkMessage&);

public slots:

    bool trkWriteRawMessage(const TrkMessage &msg);

    void terminate();

    void tryWrite();

private slots:

    void invokeNoopMessage(const trk::TrkMessage &);

private:    

    bool write(const QByteArray &data, QString *errorMessage);

    inline int writePendingMessage();

    const QSharedPointer<DeviceContext> m_context;

    QMutex m_dataMutex;

    QMutex m_waitMutex;

    QWaitCondition m_waitCondition;

    TrkWriteQueue m_queue;

    bool m_terminate;

};

WriterThread::WriterThread(const QSharedPointer<DeviceContext> &context) :

    m_context(context),

    m_terminate(false)

{

    static const int trkMessageMetaId = qRegisterMetaType<trk::TrkMessage>();

    Q_UNUSED(trkMessageMetaId)

    connect(this, SIGNAL(internalNoopMessageDequeued(trk::TrkMessage)),

            this, SLOT(invokeNoopMessage(trk::TrkMessage)), Qt::BlockingQueuedConnection);

}

void WriterThread::run()

{

    while (writePendingMessage() == 0) ;

}

int WriterThread::writePendingMessage()

{

    enum { MaxAttempts = 100, RetryIntervalMS = 200 };

    // Wait. Use a timeout in case something is already queued before we

    // start up or some weird hanging exit condition

    m_waitMutex.lock();

    m_waitCondition.wait(&m_waitMutex, 100);

    m_waitMutex.unlock();

    if (m_terminate)

        return 1;

    // Send off message

    m_dataMutex.lock();

    TrkMessage message;

    const TrkWriteQueue::PendingMessageResult pr = m_queue.pendingMessage(&message);

    m_dataMutex.unlock();

    switch (pr) {

    case TrkWriteQueue::NoMessage:

        break;

    case TrkWriteQueue::PendingMessage: {

            //qDebug() << "Write pending message " << message;

            // Untested: try to re-send a few times

            bool success = false;

            for (int r = 0; !success && (r < MaxAttempts); r++) {

                success = trkWriteRawMessage(message);

                if (!success) {

                    emit error(QString::fromLatin1("Write failure, attempt %1 of %2.").arg(r).arg(int(MaxAttempts)));

                    if (m_terminate)

                        return 1;

                    QThread::msleep(RetryIntervalMS);

                }

            }

            // Notify queue. If still failed, give up.

            m_dataMutex.lock();

            m_queue.notifyWriteResult(success ? TrkWriteQueue::WriteOk : TrkWriteQueue::WriteFailedDiscard);

            m_dataMutex.unlock();

        }

        break;

    case TrkWriteQueue::NoopMessageDequeued:

        // Sync with thread that owns us via a blocking signal

        if (verboseTrk)

            qDebug() << "Noop message dequeued" << message;

        emit internalNoopMessageDequeued(message);

        break;

    } // switch

    return 0;

}

void WriterThread::invokeNoopMessage(const trk::TrkMessage &msg)

{

    TrkWriteQueue::invokeNoopMessage(msg);

}

void WriterThread::terminate()

{

    m_terminate = true;

    m_waitCondition.wakeAll();

    wait();

    m_terminate = false;

}

#ifdef Q_OS_WIN

static inline QString msgTerminated(int size)

{

    return QString::fromLatin1("Terminated with %1 bytes pending.").arg(size);

}

// Interruptible synchronous write function.

static inline bool overlappedSyncWrite(HANDLE file,

                                       const bool &terminateFlag,

                                       const char *data,

                                       DWORD size, DWORD *charsWritten,

                                       OVERLAPPED *overlapped,

                                       QString *errorMessage)

{

    if (WriteFile(file, data, size, charsWritten, overlapped))

        return true;

    const DWORD writeError = GetLastError();

    if (writeError != ERROR_IO_PENDING) {

        *errorMessage = QString::fromLatin1("WriteFile failed: %1").arg(winErrorMessage(writeError));

        return false;

    }

    // Wait for written or thread terminated

    const DWORD timeoutMS = 200;

    const unsigned maxAttempts = 20;

    DWORD wr = WaitForSingleObject(overlapped->hEvent, timeoutMS);

    for (unsigned n = 0; wr == WAIT_TIMEOUT && n < maxAttempts && !terminateFlag;

         wr = WaitForSingleObject(overlapped->hEvent, timeoutMS), n++);

    if (terminateFlag) {

        *errorMessage = msgTerminated(size);

        return false;

    }

    switch (wr) {

    case WAIT_OBJECT_0:

        break;

    case WAIT_TIMEOUT:

        *errorMessage = QString::fromLatin1("Write timed out.");

        return false;

    default:

        *errorMessage = QString::fromLatin1("Error while waiting for WriteFile results: %1").arg(winErrorMessage(GetLastError()));

        return false;

    }

    if (!GetOverlappedResult(file, overlapped, charsWritten, TRUE)) {

        *errorMessage = QString::fromLatin1("Error writing %1 bytes: %2").arg(size).arg(winErrorMessage(GetLastError()));

        return false;

    }

    return true;

}

#endif

bool WriterThread::write(const QByteArray &data, QString *errorMessage)

{

    if (verboseTrk)

        qDebug() << "Write raw data: " << data.toHex();

    QMutexLocker locker(&m_context->mutex);

#ifdef Q_OS_WIN

    DWORD charsWritten;

    if (!overlappedSyncWrite(m_context->device, m_terminate, data.data(), data.size(), &charsWritten, &m_context->writeOverlapped, errorMessage)) {

        return false;

    }

    FlushFileBuffers(m_context->device);