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

**

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

#include "trkutils.h"

#include "trkutils_p.h"

#include "trkdevice.h"

#include "bluetoothlistener.h"

#include <QtCore/QTimer>

#include <QtCore/QDateTime>

#include <QtCore/QVariant>

#include <QtCore/QDebug>

#include <QtCore/QQueue>

#include <QtCore/QFile>

#include <QtCore/QScopedPointer>

namespace trk {

struct LauncherPrivate {

    struct CopyState {

        QString sourceFileName;

        QString destinationFileName;

        uint copyFileHandle;

        QScopedPointer<QByteArray> data;

        int position;

    };

    explicit LauncherPrivate(const TrkDevicePtr &d);

    TrkDevicePtr m_device;

    QByteArray m_trkReadBuffer;

    Launcher::State m_state;

    void logMessage(const QString &msg);

    // Debuggee state

    Session m_session; // global-ish data (process id, target information)

    CopyState m_copyState;

    QString m_fileName;

    QStringList m_commandLineArgs;

    QString m_installFileName;

    int m_verbose;

    Launcher::Actions m_startupActions;

    bool m_closeDevice;

};

LauncherPrivate::LauncherPrivate(const TrkDevicePtr &d) :

    m_device(d),

    m_state(Launcher::Disconnected),

    m_verbose(0),

    m_closeDevice(true)

{

    if (m_device.isNull())

        m_device = TrkDevicePtr(new TrkDevice);

}

Launcher::Launcher(Actions startupActions,

                   const TrkDevicePtr &dev,

                   QObject *parent) :

    QObject(parent),

    d(new LauncherPrivate(dev))

{

    d->m_startupActions = startupActions;

    connect(d->m_device.data(), SIGNAL(messageReceived(trk::TrkResult)), this, SLOT(handleResult(trk::TrkResult)));    

    connect(this, SIGNAL(finished()), d->m_device.data(), SLOT(close()));

}

Launcher::~Launcher()

{

    logMessage("Shutting down.\n");

    delete d;

}

Launcher::State Launcher::state() const

{

    return d->m_state;

}

void Launcher::setState(State s)

{

    if (s != d->m_state) {

        d->m_state = s;

        emit stateChanged(s);

    }

}

void Launcher::addStartupActions(trk::Launcher::Actions startupActions)

{

    d->m_startupActions = Actions(d->m_startupActions | startupActions);

}

void Launcher::setTrkServerName(const QString &name)

{

    d->m_device->setPort(name);

}

QString Launcher::trkServerName() const

{

    return d->m_device->port();

}

TrkDevicePtr Launcher::trkDevice() const

{

    return d->m_device;

}

void Launcher::setFileName(const QString &name)

{

    d->m_fileName = name;

}

void Launcher::setCopyFileName(const QString &srcName, const QString &dstName)

{

    d->m_copyState.sourceFileName = srcName;

    d->m_copyState.destinationFileName = dstName;

}

void Launcher::setInstallFileName(const QString &name)

{

    d->m_installFileName = name;

}

void Launcher::setCommandLineArgs(const QStringList &args)

{

    d->m_commandLineArgs = args;

}

void Launcher::setSerialFrame(bool b)

{

    d->m_device->setSerialFrame(b);

}

bool Launcher::serialFrame() const

{

    return d->m_device->serialFrame();

}

bool Launcher::closeDevice() const

{

    return d->m_closeDevice;

}

void Launcher::setCloseDevice(bool c)

{

    d->m_closeDevice = c;

}

bool Launcher::startServer(QString *errorMessage)

{

    errorMessage->clear();

    if (d->m_verbose) {

        const QString msg = QString::fromLatin1("Port=%1 Executable=%2 Arguments=%3 Package=%4 Remote Package=%5 Install file=%6")

                            .arg(trkServerName(), d->m_fileName,

                                 d->m_commandLineArgs.join(QString(QLatin1Char(' '))),

                                 d->m_copyState.sourceFileName, d->m_copyState.destinationFileName, d->m_installFileName);

        logMessage(msg);

    }

    if (d->m_startupActions & ActionCopy) {

        if (d->m_copyState.sourceFileName.isEmpty()) {

            qWarning("No local filename given for copying package.");

            return false;

        } else if (d->m_copyState.destinationFileName.isEmpty()) {

            qWarning("No remote filename given for copying package.");

            return false;

        }

    }

    if (d->m_startupActions & ActionInstall && d->m_installFileName.isEmpty()) {

        qWarning("No package name given for installing.");

        return false;

    }

    if (d->m_startupActions & ActionRun && d->m_fileName.isEmpty()) {

        qWarning("No remote executable given for running.");

        return false;

    }

    if (!d->m_device->isOpen() && !d->m_device->open(errorMessage))

        return false;

    if (d->m_closeDevice) {

        connect(this, SIGNAL(finished()), d->m_device.data(), SLOT(close()));

    } else {

        disconnect(this, SIGNAL(finished()), d->m_device.data(), 0);

    }

    setState(Connecting);

    // Set up the temporary 'waiting' state if we do not get immediate connection

    QTimer::singleShot(1000, this, SLOT(slotWaitingForTrk()));

    d->m_device->sendTrkInitialPing();

    d->m_device->sendTrkMessage(TrkDisconnect); // Disconnect, as trk might be still connected

    d->m_device->sendTrkMessage(TrkSupported, TrkCallback(this, &Launcher::handleSupportMask));

    d->m_device->sendTrkMessage(TrkCpuType, TrkCallback(this, &Launcher::handleCpuType));

    d->m_device->sendTrkMessage(TrkVersions, TrkCallback(this, &Launcher::handleTrkVersion));

    if (d->m_startupActions != ActionPingOnly)

        d->m_device->sendTrkMessage(TrkConnect, TrkCallback(this, &Launcher::handleConnect));

    return true;

}

void Launcher::slotWaitingForTrk()

{

    // Set temporary state if we are still in connected state

    if (state() == Connecting)

        setState(WaitingForTrk);

}

void Launcher::handleConnect(const TrkResult &result)

{

    if (result.errorCode()) {

        emit canNotConnect(result.errorString());

        return;

    }

    setState(Connected);

    if (d->m_startupActions & ActionCopy)

        copyFileToRemote();

    else if (d->m_startupActions & ActionInstall)

        installRemotePackageSilently();

    else if (d->m_startupActions & ActionRun)

        startInferiorIfNeeded();

}

void Launcher::setVerbose(int v)

{

    d->m_verbose = v;

    d->m_device->setVerbose(v);

}

void Launcher::logMessage(const QString &msg)

{

    if (d->m_verbose)

        qDebug() << "LAUNCHER: " << qPrintable(msg);

}

void Launcher::terminate()

{

    switch (state()) {

    case DeviceDescriptionReceived:

    case Connected:

        if (d->m_session.pid) {

            QByteArray ba;

            appendShort(&ba, 0x0000, TargetByteOrder);

            appendInt(&ba, d->m_session.pid, TargetByteOrder);

            d->m_device->sendTrkMessage(TrkDeleteItem, TrkCallback(this, &Launcher::handleRemoteProcessKilled), ba);

            return;

        }

        if (d->m_copyState.copyFileHandle)

            closeRemoteFile(true);

        disconnectTrk();

        break;

    case Disconnected:

        break;

    case Connecting:

    case WaitingForTrk:

        setState(Disconnected);

        emit finished();

        break;

    }

}

void Launcher::handleRemoteProcessKilled(const TrkResult &result)

{

    Q_UNUSED(result)

    disconnectTrk();

}

QString Launcher::msgStopped(uint pid, uint tid, uint address, const QString &why)

{

    return QString::fromLatin1("Process %1, thread %2 stopped at 0x%3: %4").

            arg(pid).arg(tid).arg(address, 0, 16).

            arg(why.isEmpty() ? QString::fromLatin1("<Unknown reason>") : why);

}

bool Launcher::parseNotifyStopped(const QByteArray &dataBA,

                                  uint *pid, uint *tid, uint *address,

                                  QString *why /* = 0 */)

{

    if (why)

        why->clear();

    *address = *pid = *tid = 0;

    if (dataBA.size() < 12)

        return false;

    const char *data = dataBA.data();

    *address = extractInt(data);

    *pid = extractInt(data + 4);

    *tid = extractInt(data + 8);

    if (why && dataBA.size() >= 14) {

        const unsigned short len = extractShort(data + 12);

        if (len > 0)

            *why = QString::fromLatin1(data + 14, len);

    }

    return true;

}

void Launcher::handleResult(const TrkResult &result)

{

    QByteArray prefix = "READ BUF:                                       ";

    QByteArray str = result.toString().toUtf8();

    if (result.isDebugOutput) { // handle application output

        logMessage("APPLICATION OUTPUT: " + result.data);

        emit applicationOutputReceived(result.data);

        return;

    }

    switch (result.code) {

        case TrkNotifyAck:

            break;

        case TrkNotifyNak: { // NAK

            logMessage(prefix + "NAK: " + str);

            //logMessage(prefix << "TOKEN: " << result.token);

            logMessage(prefix + "ERROR: " + errorMessage(result.data.at(0)));

            break;

        }

        case TrkNotifyStopped: { // Notified Stopped

            QString reason;

            uint pc;

            uint pid;

            uint tid;

            parseNotifyStopped(result.data, &pid, &tid, &pc, &reason);

            logMessage(prefix + msgStopped(pid, tid, pc, reason));

            emit(processStopped(pc, pid, tid, reason));

            d->m_device->sendTrkAck(result.token);

            break;

        }

        case TrkNotifyException: { // Notify Exception (obsolete)

            logMessage(prefix + "NOTE: EXCEPTION  " + str);

            d->m_device->sendTrkAck(result.token);

            break;

        }

        case TrkNotifyInternalError: { //

            logMessage(prefix + "NOTE: INTERNAL ERROR: " + str);

            d->m_device->sendTrkAck(result.token);

            break;

        }

        // target->host OS notification

        case TrkNotifyCreated: { // Notify Created

            /*

            const char *data = result.data.data();

            byte error = result.data.at(0);

            byte type = result.data.at(1); // type: 1 byte; for dll item, this value is 2.

            uint pid = extractInt(data + 2); //  ProcessID: 4 bytes;

            uint tid = extractInt(data + 6); //threadID: 4 bytes

            uint codeseg = extractInt(data + 10); //code address: 4 bytes; code base address for the library

            uint dataseg = extractInt(data + 14); //data address: 4 bytes; data base address for the library

            uint len = extractShort(data + 18); //length: 2 bytes; length of the library name string to follow

            QByteArray name = result.data.mid(20, len); // name: library name

            logMessage(prefix + "NOTE: LIBRARY LOAD: " + str);

            logMessage(prefix + "TOKEN: " + result.token);

            logMessage(prefix + "ERROR: " + int(error));

            logMessage(prefix + "TYPE:  " + int(type));

            logMessage(prefix + "PID:   " + pid);

            logMessage(prefix + "TID:   " + tid);

            logMessage(prefix + "CODE:  " + codeseg);

            logMessage(prefix + "DATA:  " + dataseg);

            logMessage(prefix + "LEN:   " + len);

            logMessage(prefix + "NAME:  " + name);

            */

            if (result.data.size() < 10)

                break;

            QByteArray ba;

            ba.append(result.data.mid(2, 8));

            d->m_device->sendTrkMessage(TrkContinue, TrkCallback(), ba, "CONTINUE");

            //d->m_device->sendTrkAck(result.token)

            break;

        }

        case TrkNotifyDeleted: { // NotifyDeleted

            const ushort itemType = (unsigned char)result.data.at(1);

            const ushort len = result.data.size() > 12 ? extractShort(result.data.data() + 10) : ushort(0);

            const QString name = len ? QString::fromAscii(result.data.mid(12, len)) : QString();

            logMessage(QString::fromLatin1("%1 %2 UNLOAD: %3").

                       arg(QString::fromAscii(prefix)).arg(itemType ? QLatin1String("LIB") : QLatin1String("PROCESS")).

                       arg(name));

            d->m_device->sendTrkAck(result.token);

            if (itemType == 0 // process

                && result.data.size() >= 10

                && d->m_session.pid == extractInt(result.data.data() + 6)) {

                disconnectTrk();

            }

            break;

        }

        case TrkNotifyProcessorStarted: { // NotifyProcessorStarted

            logMessage(prefix + "NOTE: PROCESSOR STARTED: " + str);

            d->m_device->sendTrkAck(result.token);

            break;

        }

        case TrkNotifyProcessorStandBy: { // NotifyProcessorStandby

            logMessage(prefix + "NOTE: PROCESSOR STANDBY: " + str);

            d->m_device->sendTrkAck(result.token);

            break;

        }

        case TrkNotifyProcessorReset: { // NotifyProcessorReset

            logMessage(prefix + "NOTE: PROCESSOR RESET: " + str);

            d->m_device->sendTrkAck(result.token);

            break;

        }

        default: {

            logMessage(prefix + "INVALID: " + str);

            break;

        }

    }

}

QString Launcher::deviceDescription(unsigned verbose) const

{

    return d->m_session.deviceDescription(verbose);

}

void Launcher::handleTrkVersion(const TrkResult &result)

{

    if (result.errorCode() || result.data.size() < 5) {

        if (d->m_startupActions == ActionPingOnly) {

            setState(Disconnected);

            emit finished();

        }

        return;

    }

    d->m_session.trkAppVersion.trkMajor = result.data.at(1);

    d->m_session.trkAppVersion.trkMinor = result.data.at(2);

    d->m_session.trkAppVersion.protocolMajor = result.data.at(3);

    d->m_session.trkAppVersion.protocolMinor = result.data.at(4);

    setState(DeviceDescriptionReceived);

    // Ping mode: Log & Terminate

    if (d->m_startupActions == ActionPingOnly) {

        qWarning("%s", qPrintable(deviceDescription()));

        setState(Disconnected);

        emit finished();

    }

}

void Launcher::handleFileCreation(const TrkResult &result)

{

    if (result.errorCode() || result.data.size() < 6) {

        emit canNotCreateFile(d->m_copyState.destinationFileName, result.errorString());

        disconnectTrk();

        return;

    }

    const char *data = result.data.data();

    d->m_copyState.copyFileHandle = extractInt(data + 2);

    QFile file(d->m_copyState.sourceFileName);

    file.open(QIODevice::ReadOnly);

    d->m_copyState.data.reset(new QByteArray(file.readAll()));

    d->m_copyState.position = 0;

    file.close();

    continueCopying();

}

void Launcher::handleCopy(const TrkResult &result)

{

    if (result.errorCode() || result.data.size() < 4) {

        closeRemoteFile(true);

        emit canNotWriteFile(d->m_copyState.destinationFileName, result.errorString());

        disconnectTrk();

    } else {

        continueCopying(extractShort(result.data.data() + 2));

    }

}

void Launcher::continueCopying(uint lastCopiedBlockSize)

{

    int size = d->m_copyState.data->length();

    d->m_copyState.position += lastCopiedBlockSize;

    if (size == 0)

        emit copyProgress(100);

    else {

        int percent = qMin((d->m_copyState.position*100)/size, 100);

        emit copyProgress(percent);

    }

    if (d->m_copyState.position < size) {

        QByteArray ba;

        appendInt(&ba, d->m_copyState.copyFileHandle, TargetByteOrder);

        appendString(&ba, d->m_copyState.data->mid(d->m_copyState.position, 2048), TargetByteOrder, false);

        d->m_device->sendTrkMessage(TrkWriteFile, TrkCallback(this, &Launcher::handleCopy), ba);

    } else {

        closeRemoteFile();

    }

}

void Launcher::closeRemoteFile(bool failed)

{

    QByteArray ba;

    appendInt(&ba, d->m_copyState.copyFileHandle, TargetByteOrder);

    appendDateTime(&ba, QDateTime::currentDateTime(), TargetByteOrder);

    d->m_device->sendTrkMessage(TrkCloseFile,

                               failed ? TrkCallback() : TrkCallback(this, &Launcher::handleFileCopied),

                               ba);

    d->m_copyState.data.reset();

    d->m_copyState.copyFileHandle = 0;

    d->m_copyState.position = 0;

}

void Launcher::handleFileCopied(const TrkResult &result)

{