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

**

** 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 qmake application 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 "symbiancommon.h"

#include <qdebug.h>

//QTP: loc change start

#include <qxmlstream.h>

#include <QSettings>

//QTP: loc change end

// Included from tools/shared

#include <symbian/epocroot.h>

#define RESOURCE_DIRECTORY_RESOURCE "\\\\resource\\\\apps\\\\"

#define RSS_RULES "RSS_RULES"

#define RSS_RULES_BASE "RSS_RULES."

#define RSS_TAG_NBROFICONS "number_of_icons"

#define RSS_TAG_ICONFILE "icon_file"

#define RSS_TAG_HEADER "header"

#define RSS_TAG_SERVICE_LIST "service_list"

#define RSS_TAG_FILE_OWNERSHIP_LIST "file_ownership_list"

#define RSS_TAG_DATATYPE_LIST "datatype_list"

#define RSS_TAG_FOOTER "footer"

#define RSS_TAG_DEFAULT "default_rules" // Same as just giving rules without tag

#define MANUFACTURER_NOTE_FILE "manufacturer_note.txt"

#define DEFAULT_MANUFACTURER_NOTE \

    "The package is not supported for devices from this manufacturer. Please try the selfsigned " \

    "version of the package instead."

SymbianCommonGenerator::SymbianCommonGenerator(MakefileGenerator *generator)

    : generator(generator)

{

}

void SymbianCommonGenerator::init()

{

    QMakeProject *project = generator->project;

    fixedTarget = project->first("QMAKE_ORIG_TARGET");

    if (fixedTarget.isEmpty())

        fixedTarget = project->first("TARGET");

    fixedTarget = generator->unescapeFilePath(fixedTarget);

    fixedTarget = removePathSeparators(fixedTarget);

    //QTP: loc change start

    translationFileName = project->first("TRANSLATIONS");

    if (!translationFileName.isEmpty()) {

        translationFileName = generator->fileInfo(translationFileName).completeBaseName();

        translationFileName = generator->unescapeFilePath(translationFileName);

        translationFileName = removePathSeparators(translationFileName);

    } else {

        translationFileName = fixedTarget;

    }

    //QTP: loc chang end

    if (project->first("MAKEFILE_GENERATOR") == "SYMBIAN_ABLD"

        || project->first("MAKEFILE_GENERATOR") == "SYMBIAN_SBSV2")

        removeEpocSpecialCharacters(fixedTarget);

    else

        removeSpecialCharacters(fixedTarget);

    // This should not be empty since the mkspecs are supposed to set it if missing.

    uid3 = project->first("TARGET.UID3").trimmed();

    if ((project->values("TEMPLATE")).contains("app"))

        targetType = TypeExe;

    else if ((project->values("TEMPLATE")).contains("lib")) {

        // Check CONFIG to see if we are to build staticlib or dll

        if (project->isActiveConfig("staticlib") || project->isActiveConfig("static"))

            targetType = TypeLib;

        else if (project->isActiveConfig("plugin"))

            targetType = TypePlugin;

        else

            targetType = TypeDll;

    } else {

        targetType = TypeSubdirs;

    }

    // UID is valid as either hex or decimal, so just convert it to number and back to hex

    // to get proper string for private dir

    bool conversionOk = false;

    uint uidNum = uid3.toUInt(&conversionOk, 0);

    if (!conversionOk) {

        fprintf(stderr, "Error: Invalid UID \"%s\".\n", uid3.toUtf8().constData());

    } else {

        privateDirUid.setNum(uidNum, 16);

        while (privateDirUid.length() < 8)

            privateDirUid.insert(0, QLatin1Char('0'));

    }

}

bool SymbianCommonGenerator::containsStartWithItem(const QChar &c, const QStringList& src)

{

    bool result = false;

    foreach(QString str, src) {

        if (str.startsWith(c)) {

            result =  true;

            break;

        }

    }

    return result;

}

void SymbianCommonGenerator::removeSpecialCharacters(QString& str)

{

    // When modifying this method check also application_icon.prf

    str.replace(QString("/"), QString("_"));

    str.replace(QString("\\"), QString("_"));

    str.replace(QString(" "), QString("_"));

}

void SymbianCommonGenerator::removeEpocSpecialCharacters(QString& str)

{

    // When modifying this method check also application_icon.prf

    str.replace(QString("-"), QString("_"));

    str.replace(QString(":"), QString("_"));

    str.replace(QString("."), QString("_"));

    removeSpecialCharacters(str);

}

QString romPath(const QString& path)

{

    if(path.length() > 2 && path[1] == ':')

        return QLatin1String("z:") + path.mid(2);

    return QLatin1String("z:") + path;

}

void SymbianCommonGenerator::generatePkgFile(const QString &iconFile, bool epocBuild)

{

    QMakeProject *project = generator->project;

    QString pkgTarget = project->first("QMAKE_ORIG_TARGET");

    if (pkgTarget.isEmpty())

        pkgTarget = project->first("TARGET");

    pkgTarget = generator->unescapeFilePath(pkgTarget);

    pkgTarget = removePathSeparators(pkgTarget);

    QString pkgFilename = Option::output_dir + QLatin1Char('/') +

                          QString("%1_template.pkg").arg(pkgTarget);

    QFile pkgFile(pkgFilename);

    if (!pkgFile.open(QIODevice::WriteOnly | QIODevice::Text)) {

        PRINT_FILE_CREATE_ERROR(pkgFilename);

        return;

    }

    QString stubPkgFileName = Option::output_dir + QLatin1Char('/') +

                          QString("%1_stub.pkg").arg(pkgTarget);

    QFile stubPkgFile(stubPkgFileName);

    if (!stubPkgFile.open(QIODevice::WriteOnly | QIODevice::Text)) {

        PRINT_FILE_CREATE_ERROR(stubPkgFileName);

        return;

    }

    generatedFiles << pkgFile.fileName();

    QTextStream t(&pkgFile);

    generatedFiles << stubPkgFile.fileName();

    QTextStream ts(&stubPkgFile);

    QString installerSisHeader = project->values("DEPLOYMENT.installer_header").join("\n");

    if (installerSisHeader.isEmpty())

        installerSisHeader = "0xA000D7CE"; // Use default self-signable UID if not defined

    QString wrapperStreamBuffer;

    QTextStream tw(&wrapperStreamBuffer);

    QString dateStr = QDateTime::currentDateTime().toString(Qt::ISODate);

    // Header info

    QString wrapperPkgFilename = Option::output_dir + QLatin1Char('/') + QString("%1_installer.%2")

                                 .arg(pkgTarget).arg("pkg");

    QString headerComment = "; %1 generated by qmake at %2\n"

        "; This file is generated by qmake and should not be modified by the user\n"

        ";\n\n";

    t << headerComment.arg(pkgFilename).arg(dateStr);

    tw << headerComment.arg(wrapperPkgFilename).arg(dateStr);

    ts << headerComment.arg(stubPkgFileName).arg(dateStr);

    // Construct QStringList from pkg_prerules since we need search it before printed to file

    // Note: Though there can't be more than one language or header line, use stringlists

    // in case user wants comments to go with the rules.

    QStringList rawPkgPreRules;

    QStringList languageRules;

    QStringList headerRules;

    foreach(QString deploymentItem, project->values("DEPLOYMENT")) {

        foreach(QString pkgrulesItem, project->values(deploymentItem + ".pkg_prerules")) {

            QStringList pkgrulesValue = project->values(pkgrulesItem);

            // If there is no stringlist defined for a rule, use rule name directly

            // This is convenience for defining single line mmp statements

            if (pkgrulesValue.isEmpty()) {

                if (pkgrulesItem.startsWith("&"))

                    languageRules << pkgrulesItem;

                else if (pkgrulesItem.startsWith("#"))

                    headerRules << pkgrulesItem;

                else

                    rawPkgPreRules << pkgrulesItem;

            } else {

                if (containsStartWithItem('&', pkgrulesValue)) {

                    foreach(QString pkgrule, pkgrulesValue) {

                        languageRules << pkgrule;

                    }

                } else if (containsStartWithItem('#', pkgrulesValue)) {

                    foreach(QString pkgrule, pkgrulesValue) {

                        headerRules << pkgrule;

                    }

                } else {

                    foreach(QString pkgrule, pkgrulesValue) {

                        rawPkgPreRules << pkgrule;

                    }

                }

            }

        }

    }

    // Apply some defaults if specific data does not exist in PKG pre-rules

    if (languageRules.isEmpty()) {

        // language, (*** hardcoded to english atm, should be parsed from TRANSLATIONS)

        languageRules << "; Language\n&EN\n\n";

    } else if (headerRules.isEmpty()) {

        // In case user defines langs, he must take care also about SIS header

        fprintf(stderr, "Warning: If language is defined with DEPLOYMENT pkg_prerules, also the SIS header must be defined\n");

    }

    t << languageRules.join("\n") << endl;

    tw << languageRules.join("\n") << endl;

    ts << languageRules.join("\n") << endl;

    // name of application, UID and version

    QString applicationVersion = project->first("VERSION").isEmpty() ? "1,0,0" : project->first("VERSION").replace('.', ',');

    QString sisHeader = "; SIS header: name, uid, version\n#{\"%1\"},(%2),%3\n\n";

    QString visualTarget = generator->escapeFilePath(project->first("TARGET"));

    visualTarget = removePathSeparators(visualTarget);

    QString wrapperTarget = visualTarget + " installer";

    if (installerSisHeader.startsWith("0x", Qt::CaseInsensitive)) {

        tw << sisHeader.arg(wrapperTarget).arg(installerSisHeader).arg(applicationVersion);

    } else {

        tw << installerSisHeader << endl;

    }

    if (headerRules.isEmpty()) {

        t << sisHeader.arg(visualTarget).arg(uid3).arg(applicationVersion);

        ts << sisHeader.arg(visualTarget).arg(uid3).arg(applicationVersion);

    }

    else {

        t << headerRules.join("\n") << endl;

        ts << headerRules.join("\n") << endl;

    }

    // Localized vendor name

    QString vendorName;

    if (!containsStartWithItem('%', rawPkgPreRules)) {

        vendorName += "; Localised Vendor name\n%{\"Vendor\"}\n\n";

    }

    // Unique vendor name

    if (!containsStartWithItem(':', rawPkgPreRules)) {

        vendorName += "; Unique Vendor name\n:\"Vendor\"\n\n";

    }

    t << vendorName;

    tw << vendorName;

    ts << vendorName;

    // PKG pre-rules - these are added before actual file installations i.e. SIS package body

    if (rawPkgPreRules.size()) {

        QString comment = "\n; Manual PKG pre-rules from PRO files\n";

        t << comment;

        tw << comment;

        ts << comment;

        foreach(QString item, rawPkgPreRules) {

            // Only regular pkg file should have package dependencies

            if (item.startsWith("(")) {

                t << item << endl;

            }

            // stub pkg file should not have platform dependencies

            else if (item.startsWith("[")) {

                t << item << endl;

                tw << item << endl;

            }

            else {

                t << item << endl;

                ts << item << endl;

                tw << item << endl;

            }

        }

        t << endl;

        ts << endl;

        tw << endl;

    }

    // Begin Manufacturer block

    if (!project->values("DEPLOYMENT.manufacturers").isEmpty()) {

        QString manufacturerStr("IF ");

        foreach(QString manufacturer, project->values("DEPLOYMENT.manufacturers")) {

            manufacturerStr.append(QString("(MANUFACTURER)=(%1) OR \n   ").arg(manufacturer));

        }

        // Remove the final OR

        manufacturerStr.chop(8);

        t << manufacturerStr << endl;

    }

    // Install paths on the phone *** should be dynamic at some point

    QString installPathBin = "!:\\sys\\bin";

    QString installPathResource = "!:\\resource\\apps";

    QString installPathRegResource = "!:\\private\\10003a3f\\import\\apps";

    // Find location of builds

    QString destDirBin;

    QString destDirResource;

    QString destDirRegResource;

    if (epocBuild) {

        destDirBin = QString("%1epoc32/release/$(PLATFORM)/$(TARGET)").arg(epocRoot());

        destDirResource = QString("%1epoc32/data/z/resource/apps").arg(epocRoot());

        destDirRegResource = QString("%1epoc32/data/z/private/10003a3f/import/apps").arg(epocRoot());

    } else {

        destDirBin = project->first("DESTDIR");

        if (destDirBin.isEmpty())

            destDirBin = ".";

        else if (destDirBin.endsWith('/') || destDirBin.endsWith('\\'))

            destDirBin.chop(1);

        destDirResource = destDirBin;

        destDirRegResource = destDirBin;

    }

    if (targetType == TypeExe) {

        // deploy .exe file

        t << "; Executable and default resource files" << endl;

        QString exeFile = fixedTarget + ".exe";

        t << QString("\"%1/%2\" - \"%3\\%4\"")

             .arg(destDirBin)

             .arg(exeFile)

             .arg(installPathBin)

             .arg(exeFile) << endl;

        ts << QString("\"\" - \"%1\\%2\"")

             .arg(romPath(installPathBin))

             .arg(exeFile) << endl;

        // deploy rsc & reg_rsc file

        if (!project->isActiveConfig("no_icon")) {

            t << QString("\"%1/%2\" - \"%3\\%4\"")

                 .arg(destDirResource)

                 .arg(fixedTarget + ".rsc")

                 .arg(installPathResource)

                 .arg(fixedTarget + ".rsc") << endl;

            ts << QString("\"\" - \"%1\\%2\"")

                 .arg(romPath(installPathResource))

                 .arg(fixedTarget + ".rsc") << endl;

            t << QString("\"%1/%2\" - \"%3\\%4\"")

                 .arg(destDirRegResource)

                 .arg(fixedTarget + "_reg.rsc")

                 .arg(installPathRegResource)

                 .arg(fixedTarget + "_reg.rsc") << endl;

            ts << QString("\"\" - \"%1\\%2\"")

                 .arg(romPath(installPathRegResource))

                 .arg(fixedTarget + "_reg.rsc") << endl;

            if (!iconFile.isEmpty())  {

                if (epocBuild) {

                    t << QString("\"%1epoc32/data/z%2\" - \"!:%3\"")

                         .arg(epocRoot())

                         .arg(iconFile)

                         .arg(QDir::toNativeSeparators(iconFile)) << endl << endl;

                    ts << QString("\"\" - \"%1\"")

                         .arg(romPath(QDir::toNativeSeparators(iconFile))) << endl << endl;

                } else {

                    QDir mifIconDir(project->first("DESTDIR"));

                    QFileInfo mifIcon(mifIconDir.relativeFilePath(project->first("TARGET")));

                    QString mifIconFileName = mifIcon.fileName();

                    mifIconFileName.append(".mif");

                    t << QString("\"%1/%2\" - \"!:%3\"")

                         .arg(mifIcon.path())

                         .arg(mifIconFileName)

                         .arg(QDir::toNativeSeparators(iconFile)) << endl << endl;

                    ts << QString("\"\" - \"%1\"")

                         .arg(romPath(QDir::toNativeSeparators(iconFile))) << endl << endl;

                }

            }

        }

    }

    // deploy any additional DEPLOYMENT  files

    QString remoteTestPath;

    QString zDir;

    remoteTestPath = QString("!:\\private\\%1").arg(privateDirUid);

    if (epocBuild)

        zDir = epocRoot() + QLatin1String("epoc32/data/z");

    DeploymentList depList;

    initProjectDeploySymbian(project, depList, remoteTestPath, true, epocBuild, "$(PLATFORM)", "$(TARGET)", generatedDirs, generatedFiles);

    if (depList.size())

        t << "; DEPLOYMENT" << endl;

    for (int i = 0; i < depList.size(); ++i)  {

        QString from = depList.at(i).from;

        QString to = depList.at(i).to;

        if (epocBuild) {

            // Deploy anything not already deployed from under epoc32 instead from under

            // \epoc32\data\z\ to enable using pkg file without rebuilding

            // the project, which can be useful for some binary only distributions.

            if (!from.contains(QLatin1String("epoc32"), Qt::CaseInsensitive)) {

                from = to;

                if (from.size() > 1 && from.at(1) == QLatin1Char(':'))

                    from = from.mid(2);

                from.prepend(zDir);

        }

        t << QString("\"%1\" - \"%2\"").arg(from.replace('\\','/')).arg(to) << endl;

        ts << QString("\"\" - \"%1\"").arg(romPath(to)) << endl;

    }

    t << endl;

    ts << endl;

    // PKG post-rules - these are added after actual file installations i.e. SIS package body

    t << "; Manual PKG post-rules from PRO files" << endl;

    foreach(QString deploymentItem, project->values("DEPLOYMENT")) {

        foreach(QString pkgrulesItem, project->values(deploymentItem + ".pkg_postrules")) {

            QStringList pkgrulesValue = project->values(pkgrulesItem);

            // If there is no stringlist defined for a rule, use rule name directly

            // This is convenience for defining single line statements

            if (pkgrulesValue.isEmpty()) {

                t << pkgrulesItem << endl;

            } else {

                foreach(QString pkgrule, pkgrulesValue) {

                    t << pkgrule << endl;

                }

            }

            t << endl;

        }

    }

    // Close Manufacturer block

    if (!project->values("DEPLOYMENT.manufacturers").isEmpty()) {

        QString manufacturerFailNoteFile;

        if (project->values("DEPLOYMENT.manufacturers.fail_note").isEmpty()) {

            manufacturerFailNoteFile = QString("%1_" MANUFACTURER_NOTE_FILE).arg(uid3);

            QFile ft(manufacturerFailNoteFile);

            if (ft.open(QIODevice::WriteOnly)) {

                generatedFiles << ft.fileName();

                QTextStream t2(&ft);

                t2 << QString(DEFAULT_MANUFACTURER_NOTE) << endl;

            } else {

                PRINT_FILE_CREATE_ERROR(manufacturerFailNoteFile)

            }

        } else {

            manufacturerFailNoteFile = project->values("DEPLOYMENT.manufacturers.fail_note").join("");

        }

        t << "ELSEIF NOT(0) ; MANUFACTURER" << endl

          << "\"" << generator->fileInfo(manufacturerFailNoteFile).absoluteFilePath() << "\""

          << " - \"\", FILETEXT, TEXTEXIT" << endl

          << "ENDIF ; MANUFACTURER" << endl;

    }

    // Write wrapper pkg

    if (!installerSisHeader.isEmpty()) {

        QFile wrapperPkgFile(wrapperPkgFilename);

        if (!wrapperPkgFile.open(QIODevice::WriteOnly | QIODevice::Text)) {

            PRINT_FILE_CREATE_ERROR(wrapperPkgFilename);

            return;

        }

        generatedFiles << wrapperPkgFile.fileName();

        QTextStream twf(&wrapperPkgFile);

        twf << wrapperStreamBuffer << endl;

        // Wrapped files deployment

        QString currentPath = qmake_getpwd();

        QString sisName = QString("%1.sis").arg(pkgTarget);

        QString bootStrapPath = QLibraryInfo::location(QLibraryInfo::PrefixPath);

        bootStrapPath.append("/smartinstaller.sis");

        QFileInfo fi(generator->fileInfo(bootStrapPath));