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

**

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

#include <QtCore/QDebug>

#include <QtCore/QFileInfo>

#include <QtCore/QDir>

#include <QtCore/QProcess>

#ifdef Q_OS_WINCE

#include <windows.h>

#endif

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

//       Abstract Command Implementation           //

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

AbstractCommand::AbstractCommand()

: m_socket(0)

{

}

AbstractCommand::~AbstractCommand()

{

}

void AbstractCommand::reportSuccess()

{

    m_socket->write(COMMAND_SUCCESS, strlen(COMMAND_SUCCESS));

    m_socket->waitForBytesWritten();

}

void AbstractCommand::reportError()

{

    m_socket->write(COMMAND_ERROR, strlen(COMMAND_ERROR));

    m_socket->waitForBytesWritten();

}

void AbstractCommand::dataReceived(QByteArray&)

{

    debugOutput(1, "AbstractCommand::dataReceived NOT SUPPOSED TO BE HERE");

}

void AbstractCommand::commandFinished()

{

    debugOutput(1, "AbstractCommand::commandFinished()NOT SUPPOSED TO BE HERE");

}

void AbstractCommand::setSocket(QTcpSocket* socket) 

{

    debugOutput(0, "AbstractCommand::setSocket()");

    Q_ASSERT(socket);

    m_socket = socket;

    connect(m_socket, SIGNAL(readyRead()), this, SLOT(_readData()));

    reportSuccess();

}

QTcpSocket* AbstractCommand::socket() 

{ 

    return m_socket; 

}

void AbstractCommand::_readData()

{

    QByteArray arr = m_socket->readAll();

    dataReceived(arr);

}

void AbstractCommand::_disconnect()

{

}

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

//       Create File Command Implementation        //

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

CreateFileCommand::CreateFileCommand()

: m_dataCount(0)

{

    debugOutput(0, "CreateFileCommand::CreateFileCommand");

    m_options.fileSize= -1;

}

CreateFileCommand::~CreateFileCommand()

{

    debugOutput(0, "CreateFileCommand::~CreateFileCommand");

    if (m_file.isOpen()) {

        fprintf(stderr, "****************FILE IS STILL OPENED AND HAVENT FINISHED WRITING**********************\n");

        fprintf(stderr, "Current: %d Expected: %d\n", m_dataCount , m_options.fileSize);

        m_file.close();

    }

}

void CreateFileCommand::dataReceived(QByteArray &data)

{

    bool successful = true;

    // If we haven't received the options yet

    if (m_options.fileSize == -1) {

        CreateFileOptions* opt = (CreateFileOptions*) data.data();

        memcpy(&m_options , opt , sizeof(CreateFileOptions));

        if (QFileInfo(QString::fromLatin1(m_options.fileName)).exists()) {

            if (m_options.overwriteExisting) {

#ifdef Q_OS_WINCE

                SetFileAttributes(QFileInfo(m_options.fileName).absoluteFilePath().utf16(), FILE_ATTRIBUTE_NORMAL);

#endif

                QFile::remove(m_options.fileName);

            } else

                successful = false;

        }

        m_file.setFileName(QString::fromLatin1(m_options.fileName));

        if (!m_file.open(QIODevice::WriteOnly))

            successful = false;

        else

            debugOutput(3, QString::fromLatin1("Creating file: %1").arg(m_options.fileName));

    } else { // write buffer on disc

        if (!m_file.isOpen())

            return;

        m_file.write(data);

        m_dataCount += data.size();

        if (m_dataCount >= m_options.fileSize) {

            // We do not care about more data than announced

            m_file.close();

        }

    }

    if (successful)

        reportSuccess();

    else

        reportError();

}

void CreateFileCommand::commandFinished()

{

    debugOutput(0, "CreateFileCommand::commandFinished");

#ifdef Q_OS_WIN

    // We need to set the file attributes for intelligent time comparisons

    QString tmpFile = QString::fromLatin1(m_options.fileName);

    HANDLE handle = CreateFile(tmpFile.utf16(), GENERIC_WRITE, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);

    if (handle != INVALID_HANDLE_VALUE) {

        SetFileTime(handle, &(m_options.fileTime), NULL, NULL);

        CloseHandle(handle);

    }

    SetFileAttributes(tmpFile.utf16(), m_options.fileAttributes);

#endif

}

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

//    Create Directory Command Implementation      //

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

CreateDirectoryCommand::CreateDirectoryCommand()

        : AbstractCommand()

{

    debugOutput(0, "CreateDirectoryCommand::CreateDirectoryCommand");

}

CreateDirectoryCommand::~CreateDirectoryCommand()

{

    debugOutput(0, "CreateDirectoryCommand::~CreateDirectoryCommand()");

}

void CreateDirectoryCommand::dataReceived(QByteArray &data)

{

    debugOutput(0, "CreateDirectoryCommand::dataReceived()");

    CreateDirectoryOptions* options = (CreateDirectoryOptions*) data.data();

    debugOutput(3, QString::fromLatin1("Creating directory: %1").arg(options->dirName));

    bool success = true;

    QDir dir;

    if (options->recursively)

        success = dir.mkpath(options->dirName);

    else

        success = dir.mkdir(options->dirName);

    if (success)

        reportSuccess();

    else

        reportError();

}

void CreateDirectoryCommand::commandFinished()

{

    debugOutput(0, "CreateDirectoryCommand::commandFinished()");

}

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

//        Copy File Command Implementation         //

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

CopyFileCommand::CopyFileCommand()

        : AbstractCommand()

{

    debugOutput(0, "CopyFileCommand::CopyFileCommand()");

}

CopyFileCommand::~CopyFileCommand()

{

    debugOutput(0, "CopyFileCommand::~CopyFileCommand()");

}

void CopyFileCommand::dataReceived(QByteArray &data)

{

    debugOutput(0, "CopyFileCommand::dataReceived()");

    CopyFileOptions* options = (CopyFileOptions*) data.data();

    debugOutput(3, QString::fromLatin1("Copy File: %1 ->  %2").arg(options->from).arg(options->to));

    bool success = true;

    if (QFileInfo(options->to).exists()) {

        if (options->overwriteExisting)

            QFile::remove(options->to);

        else

            success = false;

    }

    if (success)

        if (!QFile::copy(options->from , options->to))

            success = false;

    if (success)

        reportSuccess();

    else

        reportError();

}

void CopyFileCommand::commandFinished()

{

    debugOutput(0, "CopyFileCommand::commandFinished()");

}

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

//      Copy Directory Command Implementation      //

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

CopyDirectoryCommand::CopyDirectoryCommand()

        : AbstractCommand()

{

    debugOutput(0, "CopyDirectoryCommand::CopyDirectoryCommand()");

}

CopyDirectoryCommand::~CopyDirectoryCommand()

{

    debugOutput(0, "CopyDirectoryCommand::~CopyDirectoryCommand()");

}

void CopyDirectoryCommand::dataReceived(QByteArray &data)

{

    debugOutput(0, "CopyDirectoryCommand::dataReceived()");

    CopyDirectoryOptions* options = (CopyDirectoryOptions*) data.data();

    debugOutput(3, QString::fromLatin1("Copy Directory: %1 %2").arg(options->from).arg(options->to));

    if (copyDir(QLatin1String(options->from) , QLatin1String(options->to) , options->recursive))

        reportSuccess();

    else

        reportError();

}

void CopyDirectoryCommand::commandFinished()

{

    debugOutput(0, "CopyDirectoryCommand::commandFinished()");

}

bool CopyDirectoryCommand::copyDir(const QString &from, const QString &to, bool recursive)

{

    QDir().mkpath(to);

    QDir sourceDir(from);

    QDir destDir(to);

    QStringList entries = sourceDir.entryList(QDir::Dirs | QDir::Files | QDir::NoDotAndDotDot);

    foreach (QString item , entries) {

        QString itemFrom = sourceDir.absoluteFilePath(item);

        QString itemTo = destDir.absoluteFilePath(item);

        if (QFileInfo(item).isDir()) {

            if (recursive && !copyDir(itemFrom, itemTo, recursive))

                return false;

        } else {

            if (!QFile::copy(itemFrom, itemTo))

                return false;

        }

    }

    return true;

}

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

//        Delete File Command Implementation       //

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

DeleteFileCommand::DeleteFileCommand()

        : AbstractCommand()

{

    debugOutput(0, "DeleteFileCommand::DeleteFileCommand()");

}

DeleteFileCommand::~DeleteFileCommand()

{

    debugOutput(0, "DeleteFileCommand::~DeleteFileCommand()");

}

void DeleteFileCommand::dataReceived(QByteArray &data)

{

    debugOutput(0, "DeleteFileCommand::dataReceived()");

    DeleteFileOptions* options = (DeleteFileOptions*) data.data();

    debugOutput(3, QString::fromLatin1("Delete File: %1").arg(options->fileName));

    bool success = true;

    QFile file(options->fileName);

    if (file.exists()) {

#ifdef Q_OS_WINCE

        SetFileAttributes(QFileInfo(options->fileName).absoluteFilePath().utf16(), FILE_ATTRIBUTE_NORMAL);

#endif

        success = file.remove();

    } else

        success = false;

    if (success)

        reportSuccess();

    else

        reportError();

}

void DeleteFileCommand::commandFinished()

{

    debugOutput(0, "DeleteFileCommand::commandFinished()");

}

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

//     Delete Directory Command Implementation     //

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

DeleteDirectoryCommand::DeleteDirectoryCommand()

        : AbstractCommand()

{

    debugOutput(0, "DeleteDirectoryCommand::DeleteDirectoryCommand()");

}

DeleteDirectoryCommand::~DeleteDirectoryCommand()

{

    debugOutput(0, "DeleteDirectoryCommand::~DeleteDirectoryCommand()");

}

void DeleteDirectoryCommand::dataReceived(QByteArray &data)

{

    debugOutput(0, "DeleteDirectoryCommand::dataReceived()");

    DeleteDirectoryOptions* options = (DeleteDirectoryOptions*) data.data();

    debugOutput(3, QString::fromLatin1("Delete directory: %1").arg(options->dirName));

    if (deleteDirectory(QLatin1String(options->dirName), options->recursive, options->failIfContentExists))

        reportSuccess();

    else

        reportError();

}

void DeleteDirectoryCommand::commandFinished()

{

    debugOutput(0, "DeleteDirectoryCommand::commandFinished()");

}

bool DeleteDirectoryCommand::deleteDirectory(const QString &dirName, bool recursive, bool failIfContentExists)

{

    QDir dir(dirName);

    if (!dir.exists())

        return false;

    QStringList itemList = dir.entryList(QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot);

    if (itemList.size() > 0 && failIfContentExists)

        return false;

    foreach (QString item, itemList) {

        QString itemName = dir.absoluteFilePath(item);

        if (QFileInfo(itemName).isDir()) {

            if (recursive && !deleteDirectory(itemName, recursive, failIfContentExists))

                return false;

        } else {

            if (!dir.remove(item))

                return false;

        }

    }

    QString lastName = dir.dirName();

    dir.cdUp();

    dir.rmpath(lastName);

    return true;

}

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

//         Execute Command Implementation          //

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

ExecuteCommand::ExecuteCommand()

        : AbstractCommand()

        , m_argumentCount(0)

        , m_timeout(-1)

{

    debugOutput(0, "ExecuteCommand::ExecuteCommand()");

}

ExecuteCommand::~ExecuteCommand()

{

    debugOutput(0, "ExecuteCommand::~ExecuteCommand()");

}

void ExecuteCommand::dataReceived(QByteArray &data)

{

    debugOutput(0, "ExecuteCommand::dataReceived()");

    if (m_argumentCount == 0) {

        ExecuteOptions* options = (ExecuteOptions*) data.data();

        if (!QFileInfo(options->appName).exists()) {

            debugOutput(1, "Error execute: application does not exist");

            reportError();

            return;

        }

        m_program = QLatin1String(options->appName);

        m_argumentCount = options->argumentsCount;

        m_waitFinished = options->waitForFinished;

        m_timeout = options->timeout;

        if (m_argumentCount == 0)

            m_argumentCount = -1; // to trigger startup on next receive

        reportSuccess();

    } else if (m_arguments.size() < m_argumentCount) {

        m_arguments += data;

        reportSuccess();

    } else { // do the execution

        if (data == COMMAND_SUCCESS)

            _doExecute();

    }

}

void ExecuteCommand::_doExecute()

{

    debugOutput(0, "ExecuteCommand::_doExecute()");

    debugOutput(3, QString::fromLatin1("Execute: %1 %2").arg(m_program).arg(m_arguments.join(" ")));

    if (m_waitFinished) {

        QProcess process;

        process.start(m_program, m_arguments);

        if (process.waitForFinished(m_timeout) == false || process.exitCode() < 0)

            reportError();

        else

            reportSuccess();

    } else {

        if (QProcess::startDetached(m_program, m_arguments))

            reportSuccess();

        else

            reportError();

    }

}

void ExecuteCommand::commandFinished()

{

    debugOutput(0,"ExecuteCommand::commandFinished()");

}

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

//           Read File Implementation              //

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

ReadFileCommand::ReadFileCommand()

        : AbstractCommand()

        , m_currentPos(0)

{

    debugOutput(0, "ReadFileCommand::ReadFileCommand()");

    m_fileName.clear();

}

ReadFileCommand::~ReadFileCommand()

{

    debugOutput(0, "ReadFileCommand::~ReadFileCommand()");

    if (m_file.isOpen())

        m_file.close();

}

void ReadFileCommand::dataReceived(QByteArray &data)

{

    debugOutput(0, "ReadFileCommand::dataReceived()");

    if (m_fileName.isEmpty()) {

        ReadFileOptions* option = (ReadFileOptions*) data.data();

        m_fileName = QLatin1String(option->fileName);

        QFileInfo info(m_fileName);

        m_file.setFileName(m_fileName);

        ReadFileReply reply;

        if (!info.exists() || !info.isFile() || !m_file.open(QIODevice::ReadOnly))

            reply.fileValid = false;

        else

            reply.fileValid = true;

        reply.fileSize = info.size();

        m_fileSize = reply.fileSize;

        socket()->write((char*) &reply, sizeof(reply));

        debugOutput(3, QString::fromLatin1("Reading file: %1").arg(m_fileName));

    } else {

        QTcpSocket* sock = socket(); // design failure???

        if (data != COMMAND_SUCCESS || m_currentPos >= m_fileSize) {

            sock->disconnectFromHost();

            return;

        }

        const int bufferSize = 1024;

        QByteArray buffer = m_file.read(bufferSize);

        m_currentPos += buffer.size();

        sock->write(buffer);

        sock->waitForBytesWritten();

    }

}

void ReadFileCommand::commandFinished()

{

    debugOutput(0, "ReadFileCommand::commandFinished()");

}

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