/*
* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Test installer that uses Usif::RSoftwareInstall API.
*
*/

#include "testinstaller.h"
#include "activerunner.h"
#include <hbmainwindow.h>
#include <hbview.h>
#include <hbtoolbar.h>
#include <hbpushbutton.h>
#include <hbcheckbox.h>
#include <hbcombobox.h>
#include <hblabel.h>
#include <hbmessagebox.h>
#include <QGraphicsLinearLayout>
#include <QDir>
#include <xqappmgr.h>                       // XQApplicationManager
#include <usif/scr/scr.h>                   // RSoftwareComponentRegistry

using namespace Usif;

#define INSTALLS_PATH_1 "C:\\Data\\Installs\\"
#define INSTALLS_PATH_2 "E:\\Installs\\"
#define INSTALLS_PATH_3 "F:\\Installs\\"
#define INSTALLS_PATH_4 "C:\\"
#define INSTALLS_PATH_5 "E:\\"
#define INSTALLS_PATH_6 "F:\\"


TestInstaller::TestInstaller(int& argc, char* argv[]) : HbApplication(argc, argv),
    mMainWindow(0), mInstallView(0), mRemoveView(0),
    mUseSilentInstall(false), mUseSilentUninstall(false), mUseRFileInstall(false), mOcsp(false),
    mInstallDirectories(0), mInstallableFiles(0), mRemovableApps(0),
    mCurrentDirPath(), mCurrentFile(), mRunner(0)
{
    mMainWindow = new HbMainWindow();

    // Install view
    mInstallView = new HbView();
    mInstallView->setTitle(tr("Test Installer"));

    QGraphicsLinearLayout *installLayout = new QGraphicsLinearLayout(Qt::Vertical);

    HbLabel *installTitle = new HbLabel(tr("Install:"));
    installLayout->addItem(installTitle);

    mInstallDirectories = new HbComboBox;
    mInstallDirectories->setEditable(false);
    QStringList dirList;
    getInstallDirs(dirList);
    mInstallDirectories->setItems(dirList);
    connect(mInstallDirectories, SIGNAL(currentIndexChanged(int)),
        this, SLOT(installableDirChanged(int)));
    installLayout->addItem(mInstallDirectories);

    mInstallableFiles = new HbComboBox;
    mInstallableFiles->setEditable(false);
    connect(mInstallableFiles, SIGNAL(currentIndexChanged(int)),
            this, SLOT(installableFileChanged(int)));
    installLayout->addItem(mInstallableFiles);

    QGraphicsLinearLayout *checkboxesLayout = new QGraphicsLinearLayout(Qt::Horizontal);
    HbCheckBox *silentInstallCheckBox = new HbCheckBox;
    silentInstallCheckBox->setText(tr("Silent"));
    connect(silentInstallCheckBox, SIGNAL(stateChanged(int)),
            this, SLOT(silentInstallCheckChanged(int)));
    checkboxesLayout->addItem(silentInstallCheckBox);
    HbCheckBox *rfileCheckBox = new HbCheckBox;
    rfileCheckBox->setText(tr("Use RFile"));
    connect(rfileCheckBox, SIGNAL(stateChanged(int)), this, SLOT(rfileCheckChanged(int)));
    checkboxesLayout->addItem(rfileCheckBox);
    HbCheckBox *ocspCheckBox = new HbCheckBox;
    ocspCheckBox->setText(tr("OCSP"));
    connect(ocspCheckBox, SIGNAL(stateChanged(int)), this, SLOT(ocspCheckChanged(int)));
    checkboxesLayout->addItem(ocspCheckBox);
    installLayout->addItem(checkboxesLayout);
    installLayout->addStretch();

    HbPushButton *installNew = new HbPushButton(tr("Install using new API"));
    installLayout->addItem(installNew);
    HbPushButton *installOld = new HbPushButton(tr("Install using old API"));
    installLayout->addItem(installOld);
    HbPushButton *launchApp = new HbPushButton(tr("Install by opening file"));
    installLayout->addItem(launchApp);
    installLayout->addStretch();
    connect(installNew, SIGNAL(clicked()), this, SLOT(installUsingNewApi()));
    connect(installOld, SIGNAL(clicked()), this, SLOT(installUsingOldApi()));
    connect(launchApp, SIGNAL(clicked()), this, SLOT(installByOpeningFile()));

    HbToolBar *installToolBar = new HbToolBar();
    installToolBar->addAction(tr("RemoveView"), this, SLOT(removeViewActivated()));
    installToolBar->addAction(tr("Exit"), this, SLOT(closeApp()));
    mInstallView->setToolBar(installToolBar);

    mInstallView->setLayout(installLayout);
    mMainWindow->addView(mInstallView);

    // Remove view
    mRemoveView = new HbView();
    mRemoveView->setTitle(tr("Test Uninstaller"));

    QGraphicsLinearLayout *removeLayout = new QGraphicsLinearLayout(Qt::Vertical);

    HbLabel *uninstallTitle = new HbLabel(tr("Uninstall:"));
    removeLayout->addItem(uninstallTitle);

    mRemovableApps = new HbComboBox;
    mRemovableApps->setEditable(false);
    removeLayout->addItem(mRemovableApps);

    HbCheckBox *silentRemoveCheckBox = new HbCheckBox;
    silentRemoveCheckBox->setText(tr("Silent"));
    connect(silentRemoveCheckBox, SIGNAL(stateChanged(int)),
            this, SLOT(silentCheckChanged(int)));
    removeLayout->addItem(silentRemoveCheckBox);
    removeLayout->addStretch();

    HbPushButton *removeNew = new HbPushButton(tr("Remove using new API"));
    removeLayout->addItem(removeNew);
    HbPushButton *removeOld = new HbPushButton(tr("Remove using old API"));
    removeLayout->addItem(removeOld);
    removeLayout->addStretch();
    connect(removeNew, SIGNAL(clicked()), this, SLOT(removeUsingNewApi()));
    connect(removeOld, SIGNAL(clicked()), this, SLOT(removeUsingOldApi()));

    mRemoveView->setLayout(removeLayout);
    mMainWindow->addView(mRemoveView);

    HbToolBar *removeToolBar = new HbToolBar();
    removeToolBar->addAction(tr("InstallView"), this, SLOT(installViewActivated()));
    removeToolBar->addAction(tr("Exit"), this, SLOT(closeApp()));
    mRemoveView->setToolBar(removeToolBar);

    mMainWindow->setCurrentView(mInstallView);
    mMainWindow->show();

    changeDir(mInstallDirectories->currentText());
    getRemovableApps();
}

TestInstaller::~TestInstaller()
{
    delete mRunner;
    delete mInstallView;
    delete mRemoveView;
    delete mMainWindow;
}

void TestInstaller::installViewActivated()
{
    mMainWindow->setCurrentView(mInstallView);
}

void TestInstaller::removeViewActivated()
{
    mMainWindow->setCurrentView(mRemoveView);
}

void TestInstaller::silentInstallCheckChanged(int state)
{
    Qt::CheckState s = static_cast<Qt::CheckState>(state);
    mUseSilentInstall = (s == Qt::Checked);
}

void TestInstaller::silentRemoveCheckChanged(int state)
{
    Qt::CheckState s = static_cast<Qt::CheckState>(state);
    mUseSilentUninstall = (s == Qt::Checked);
}

void TestInstaller::rfileCheckChanged(int state)
{
    Qt::CheckState s = static_cast<Qt::CheckState>(state);
    mUseRFileInstall = (s == Qt::Checked);
}

void TestInstaller::ocspCheckChanged(int state)
{
    Qt::CheckState s = static_cast<Qt::CheckState>(state);
    mOcsp = (s == Qt::Checked);
}

void TestInstaller::installableDirChanged(int /*index*/)
{
    if (mInstallDirectories) {
        changeDir(mInstallDirectories->currentText());
    }
}

void TestInstaller::installableFileChanged(int /*index*/)
{
    if (mInstallableFiles) {
        mCurrentFile = mCurrentDirPath;
        mCurrentFile.append(mInstallableFiles->currentText());
    }
}

void TestInstaller::installUsingNewApi()
{
    if (isFileSelected() && createRunner(true)) {
        doInstall(mCurrentFile);
    }
}

void TestInstaller::installUsingOldApi()
{
    if (isFileSelected() && createRunner(false)) {
        doInstall(mCurrentFile);
    }
}

void TestInstaller::installByOpeningFile()
{
    if (mInstallableFiles) {
        doOpenFile(mCurrentFile);
    }
}

void TestInstaller::removeUsingNewApi()
{
    if (isFileSelected() && createRunner(true)) {
        removeSelectedUsingNewApi();
    }
}

void TestInstaller::removeUsingOldApi()
{
    if (isFileSelected() && createRunner(false)) {
        removeSelectedUsingOldApi();
    }
}

void TestInstaller::handleComplete()
{
    HbMessageBox::information(tr("Completed"));

    delete mRunner;
    mRunner = 0;

    changeDir(mCurrentDirPath);
    getRemovableApps();
}

void TestInstaller::handleError(int error)
{
    QString messageText;
    if (error == KErrCancel) {
        messageText = tr("Cancelled");
    } else {
        messageText = tr("Error %1").arg(error);
    }
    HbMessageBox::warning(messageText);

    delete mRunner;
    mRunner = 0;
}

void TestInstaller::closeApp()
{
    qApp->exit();
}

void TestInstaller::fileOpenOk(const QVariant &/*result*/)
{
    HbMessageBox::information(tr("Open ok"));
}

void TestInstaller::fileOpenFailed(int errorCode, const QString &errorMsg)
{
    HbMessageBox::warning(tr("Open failed: %1: %2").arg(errorCode).arg(errorMsg));
}

void TestInstaller::getInstallDirs(QStringList& dirList)
{
    QStringList possibleDirs;
    possibleDirs << INSTALLS_PATH_1 << INSTALLS_PATH_2 << INSTALLS_PATH_3
        << INSTALLS_PATH_4 << INSTALLS_PATH_5 << INSTALLS_PATH_6;

    QListIterator<QString> iter(possibleDirs);
    while (iter.hasNext()) {
        QString dirName(iter.next());
        QDir dir(dirName);
        if (dir.exists()) {
            dirList.append(dirName);
        }
    }
}

void TestInstaller::changeDir(const QString& dirPath)
{
    QDir dir(dirPath);
    if (dir.exists()) {
        mCurrentDirPath = dirPath;
        mInstallableFiles->clear();

        QFileInfoList list = dir.entryInfoList(QDir::Files);
        QListIterator<QFileInfo> iter(list);
        while (iter.hasNext()) {
            const QFileInfo &info(iter.next());
            mInstallableFiles->addItem(info.fileName());
        }

        mCurrentFile.clear();
        if (mInstallableFiles->count()) {
            mCurrentFile = mCurrentDirPath;
            mCurrentFile.append(mInstallableFiles->currentText());
        }
    }
}

void TestInstaller::getRemovableApps()
{
    TRAP_IGNORE(doGetRemovableAppsL());
}

void TestInstaller::doGetRemovableAppsL()
{
    mRemovableApps->clear();
    mRemovableComponentIds.clear();
    mRemovableUids.clear();
    mRemovableSoftwareTypes.clear();

    RSoftwareComponentRegistry registry;
    User::LeaveIfError(registry.Connect());
    CleanupClosePushL(registry);

    RArray<TComponentId> componentIdList;
    CleanupClosePushL( componentIdList );
    registry.GetComponentIdsL(componentIdList);
    for (int i = 0; i < componentIdList.Count(); ++i) {
        TComponentId compId = componentIdList[i];
        CComponentEntry *compEntry = CComponentEntry::NewLC();
        if (registry.GetComponentL(compId, *compEntry)) {
            if (compEntry->IsRemovable()) {
                TPtrC compName = compEntry->Name();
                QString name = QString::fromUtf16(compName.Ptr(), compName.Length());
                mRemovableApps->addItem(name);

                mRemovableComponentIds.append(compId);

                _LIT(KCompUid, "CompUid");
                CPropertyEntry *property = registry.GetComponentPropertyL(compId, KCompUid);
                CleanupStack::PushL(property);
                CIntPropertyEntry* intProperty = dynamic_cast<CIntPropertyEntry*>(property);
                mRemovableUids.append(TUid::Uid(intProperty->IntValue()));
                CleanupStack::PopAndDestroy(property);

                TPtrC softwareType = compEntry->SoftwareType();
                if (softwareType == KSoftwareTypeNative) {
                    mRemovableSoftwareTypes.append(Native);
                } else if (softwareType == KSoftwareTypeJava) {
                    mRemovableSoftwareTypes.append(Java);
                } else {
                    mRemovableSoftwareTypes.append(Unknown);
                }
            }
        }
        CleanupStack::PopAndDestroy(compEntry);
    }

    CleanupStack::PopAndDestroy(2, &registry);  // componentIdList, registry
}

bool TestInstaller::isFileSelected()
{
    if (mCurrentFile.isEmpty()) {
        HbMessageBox::warning(tr("No files selected"));
        changeDir(mCurrentDirPath);
        return false;
    }
    return true;
}

bool TestInstaller::createRunner(bool useSif)
{
    if (!mRunner) {
        mRunner = new ActiveRunner(useSif);
        connect(mRunner, SIGNAL(opCompleted()), this, SLOT(handleComplete()));
        connect(mRunner, SIGNAL(opFailed(int)), this, SLOT(handleError(int)));
    } else {
        HbMessageBox::warning(tr("Already running"));
        return false;
    }
    return true;
}

void TestInstaller::doInstall(const QString &fileName)
{
    if (mRunner) {
        mRunner->install(fileName, mUseSilentInstall, mUseRFileInstall, mOcsp );
    }
}

void TestInstaller::doOpenFile(const QString &fileName)
{
    QFile file(fileName);
    if (file.exists()) {
        XQApplicationManager appManager;
        XQAiwRequest *request = appManager.create(file);
        if (request) {
            connect(request, SIGNAL(requestOk(const QVariant &)),
                this, SLOT(fileOpenOk(const QVariant &)));
            connect(request, SIGNAL(requestError(int, const QString &)),
                this, SLOT(fileOpenFailed(int, const QString &)));
            QList<QVariant> args;
            args << file.fileName();
            request->setArguments(args);
            if (request->send()) {
                HbMessageBox::information(tr("Opening..."));
            } else {
                HbMessageBox::warning(tr("Cannot open"));
            }
            delete request;
        } else {
            HbMessageBox::warning(tr("No handler for file '%1'").arg(fileName));
        }
    }
}

void TestInstaller::removeSelectedUsingNewApi()
{
    if (mRemovableApps && mRunner) {
        int index = mRemovableApps->currentIndex();
        const TComponentId &compId(mRemovableComponentIds.at(index));
        mRunner->remove(compId, mUseSilentUninstall);
    }
}

void TestInstaller::removeSelectedUsingOldApi()
{
    if (mRemovableApps && mRunner) {
        int index = mRemovableApps->currentIndex();
        const TUid &uid(mRemovableUids.at(index));

        if (mRemovableSoftwareTypes.at(index) == Native) {
            _LIT8(KSisxMimeType, "x-epoc/x-sisx-app");
            mRunner->remove(uid, KSisxMimeType, mUseSilentInstall);
        } else if (mRemovableSoftwareTypes.at(index) == Java) {
            _LIT8(KJarMIMEType, "application/java-archive");
            mRunner->remove(uid, KJarMIMEType, mUseSilentInstall);
        } else {
            HbMessageBox::warning(tr("Not supported software type"));
            delete mRunner;
            mRunner = 0;
        }
    }
}