/*
    SPDX-FileCopyrightText: 1998-2008 Sebastian Trueg <trueg@k3b.org>

    SPDX-License-Identifier: GPL-2.0-or-later
*/

#include <config-k3b.h>
#include "k3bglobals.h"

#include "k3bisoimager.h"
#include "k3bdiritem.h"
#include "k3bbootitem.h"
#include "k3bdatadoc.h"
#include "k3bdatapreparationjob.h"
#include "k3bexternalbinmanager.h"
#include "k3bdevice.h"
#include "k3bprocess.h"
#include "k3bcore.h"
#include "k3bversion.h"
#include "k3bfilesplitter.h"
#include "k3bisooptions.h"
#include "k3b_i18n.h"

#include <KIO/CopyJob>
#include <KIO/Global>
#include <KIO/Job>
#include <KStringHandler>

#include <QDebug>
#include <QDir>
#include <QFile>
#include <QRegExp>
#include <QStandardPaths>
#include <QTemporaryFile>
#include <QApplication>

#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <utime.h>


int K3b::IsoImager::s_imagerSessionCounter = 0;


class K3b::IsoImager::Private
{
public:
    const K3b::ExternalBin* mkisofsBin;

    enum LinkHandling {
        KEEP_ALL,
        FOLLOW,
        DISCARD_ALL,
        DISCARD_BROKEN
    };

    int usedLinkHandling;

    bool knownError;

    K3b::DataPreparationJob* dataPreparationJob;
};


K3b::IsoImager::IsoImager( K3b::DataDoc* doc, K3b::JobHandler* hdl, QObject* parent )
    : K3b::Job( hdl, parent ),
      m_pathSpecFile(0),
      m_rrHideFile(0),
      m_jolietHideFile(0),
      m_sortWeightFile(0),
      m_process( 0 ),
      m_doc( doc ),
      m_noDeepDirectoryRelocation( false ),
      m_importSession( false ),
      m_device(0),
      m_mkisofsPrintSizeResult( 0 )
{
    d = new Private();
    d->dataPreparationJob = new K3b::DataPreparationJob( doc, this, this );
    connectSubJob( d->dataPreparationJob,
                   SLOT(slotDataPreparationDone(bool)),
                   DEFAULT_SIGNAL_CONNECTION );
}


K3b::IsoImager::~IsoImager()
{
    qDebug();
    cleanup();
    delete d;
}


bool K3b::IsoImager::active() const
{
    return K3b::Job::active();
}


void K3b::IsoImager::slotReceivedStderr( const QString& line )
{
    parseMkisofsOutput( line );
    emit debuggingOutput( "mkisofs", line );
}


void K3b::IsoImager::handleMkisofsProgress( int p )
{
    emit percent( p );
}


void K3b::IsoImager::handleMkisofsInfoMessage( const QString& line, int type )
{
    emit infoMessage( line, type );
    if( type == MessageError )
        d->knownError = true;
}


void K3b::IsoImager::slotProcessExited( int exitCode, QProcess::ExitStatus exitStatus )
{
    qDebug();

    cleanup();

    if( m_canceled ) {
        emit canceled();
        jobFinished(false);
    }
    else {
        if( exitStatus == QProcess::NormalExit ) {
            if( exitCode == 0 ) {
                jobFinished( !mkisofsReadError() );
            }
            else {
                switch( exitCode ) {
                case 104:
                    // connection reset by peer
                    // This only happens if cdrecord does not finish successfully
                    // so we may leave the error handling to it meaning we handle this
                    // as a known error
                    break;

                case 2:
                    // mkisofs seems to have a bug that prevents to use filenames
                    // that contain one or more backslashes
                    // mkisofs 1.14 has the bug, 1.15a40 not
                    // TODO: find out the version that fixed the bug
                    if( m_containsFilesWithMultibleBackslashes && d->mkisofsBin &&
                        !d->mkisofsBin->hasFeature( "backslashed_filenames" ) ) {
                        emit infoMessage( i18n("Due to a bug in mkisofs <= 1.15a40, K3b is unable to handle "
                                               "filenames that contain more than one backslash:"), MessageError );

                        break;
                    }
                    Q_FALLTHROUGH();

                default:
                    if( !d->knownError && !mkisofsReadError() ) {
                        emit infoMessage( i18n("%1 returned an unknown error (code %2).", QLatin1String("mkisofs"), exitCode ),
                                          K3b::Job::MessageError );
                        emit infoMessage( i18n("Please send me an email with the last output."), K3b::Job::MessageError );
                    }
                }

                jobFinished( false );
            }
        }
        else {
            emit infoMessage( i18n("%1 crashed.", QLatin1String("mkisofs")), MessageError );
            jobFinished( false );
        }
    }
}


void K3b::IsoImager::cleanup()
{
    qDebug();

    // remove all temp files
    delete m_pathSpecFile;
    delete m_rrHideFile;
    delete m_jolietHideFile;
    delete m_sortWeightFile;

    // remove boot-images-temp files
    for( QStringList::iterator it = m_tempFiles.begin();
         it != m_tempFiles.end(); ++it )
        QFile::remove( *it );
    m_tempFiles.clear();

    m_pathSpecFile = m_jolietHideFile = m_rrHideFile = m_sortWeightFile = 0;

    clearDummyDirs();
}


void K3b::IsoImager::init()
{
    jobStarted();

    cleanup();

    d->dataPreparationJob->start();
}


void K3b::IsoImager::slotDataPreparationDone( bool success )
{
    if( success ) {
        //
        // We always calculate the image size. It does not take long and at least the mixed job needs it
        // anyway
        //
        startSizeCalculation();
    }
    else {
        if( d->dataPreparationJob->hasBeenCanceled() ) {
            m_canceled = true;
            emit canceled();
        }
        jobFinished( false );
    }
}


void K3b::IsoImager::calculateSize()
{
    jobStarted();
    startSizeCalculation();
}


void K3b::IsoImager::startSizeCalculation()
{
    d->mkisofsBin = initMkisofs();
    if( !d->mkisofsBin ) {
        jobFinished( false );
        return;
    }

    initVariables();

    delete m_process;
    m_process = new K3b::Process( this );
    m_process->setSplitStdout(true);

    emit debuggingOutput( QLatin1String( "Used versions" ), QString::fromLatin1( "mkisofs: %1").arg(d->mkisofsBin->version()) );

    *m_process << d->mkisofsBin;

    if( !prepareMkisofsFiles() ||
        !addMkisofsParameters(true) ) {
        cleanup();
        jobFinished( false );
        return;
    }

    // add empty dummy dir since one path-spec is needed
    // ??? Seems it is not needed after all. At least mkisofs 1.14 and above don't need it. ???
    //  *m_process << dummyDir();

    qDebug() << "***** mkisofs calculate size parameters:";
    QString s = m_process->joinedArgs();
    qDebug() << s << Qt::endl << Qt::flush;
    emit debuggingOutput("mkisofs calculate size command:", s);

    // since output changed during mkisofs version changes we grab both
    // stdout and stderr

    // mkisofs version >= 1.15 (don't know about 1.14!)
    // the extends on stdout (as lonely number)
    // and error and warning messages on stderr

    // mkisofs >= 1.13
    // everything is written to stderr
    // last line is: "Total extents scheduled to be written = XXXXX"

    connect( m_process, SIGNAL(stdoutLine(QString)),
             this, SLOT(slotCollectMkisofsPrintSizeStdout(QString)) );
    connect( m_process, SIGNAL(stderrLine(QString)),
             this, SLOT(slotCollectMkisofsPrintSizeStderr(QString)) );
    connect( m_process, SIGNAL(finished(int,QProcess::ExitStatus)),
             this, SLOT(slotMkisofsPrintSizeFinished()) );

    // we also want error messages
    connect( m_process, SIGNAL(stderrLine(QString)),
             this, SLOT(slotReceivedStderr(QString)) );

    m_collectedMkisofsPrintSizeStdout = QString();
    m_collectedMkisofsPrintSizeStderr = QString();
    m_mkisofsPrintSizeResult = 0;

    if( !m_process->start( KProcess::SeparateChannels ) ) {
        emit infoMessage( i18n("Could not start %1.",QString("mkisofs")), K3b::Job::MessageError );
        cleanup();

        jobFinished( false );
        return;
    }
}


void K3b::IsoImager::slotCollectMkisofsPrintSizeStderr( const QString& line )
{
    m_collectedMkisofsPrintSizeStderr.append( line + '\n' );
}


void K3b::IsoImager::slotCollectMkisofsPrintSizeStdout( const QString& line )
{
    // newer versions of mkisofs output additional lines of junk before the size :(
    // so we only use the last line
    emit debuggingOutput( "mkisofs", line );
    m_collectedMkisofsPrintSizeStdout = line;
}


void K3b::IsoImager::slotMkisofsPrintSizeFinished()
{
    if( m_canceled ) {
        emit canceled();
        jobFinished( false );
        return;
    }

    bool success = true;

    // if m_collectedMkisofsPrintSizeStdout is not empty we have a recent version of
    // mkisofs and parsing is very easy (s.o.)
    if( !m_collectedMkisofsPrintSizeStdout.isEmpty() ) {
        qDebug() << "(K3b::IsoImager) iso size: " << m_collectedMkisofsPrintSizeStdout;
        m_mkisofsPrintSizeResult = m_collectedMkisofsPrintSizeStdout.toInt( &success );
    }
    else {
        // parse the stderr output
        // I hope parsing the last line is enough!
        int pos = m_collectedMkisofsPrintSizeStderr.lastIndexOf( "extents scheduled to be written" );

        if( pos == -1 )
            success = false;
        else
            m_mkisofsPrintSizeResult = m_collectedMkisofsPrintSizeStderr.mid( pos+33 ).toInt( &success );
    }

    emit debuggingOutput( "K3b::IsoImager",
                          QString("mkisofs print size result: %1 (%2 bytes)")
                          .arg(m_mkisofsPrintSizeResult)
                          .arg(quint64(m_mkisofsPrintSizeResult)*2048ULL) );

    cleanup();


    if( success ) {
        jobFinished( true );
    }
    else {
        m_mkisofsPrintSizeResult = 0;
        qDebug() << "(K3b::IsoImager) Parsing mkisofs -print-size failed: " << m_collectedMkisofsPrintSizeStdout;
        emit infoMessage( i18n("Could not determine size of resulting image file."), MessageError );
        jobFinished( false );
    }
}


void K3b::IsoImager::initVariables()
{
    m_containsFilesWithMultibleBackslashes = false;
    m_canceled = false;
    d->knownError = false;

    // determine symlink handling
    // follow links supersedes discard all links which supersedes discard broken links
    // without rockridge we follow the links or discard all
    if( m_doc->isoOptions().followSymbolicLinks() )
        d->usedLinkHandling = Private::FOLLOW;
    else if( m_doc->isoOptions().discardSymlinks() )
        d->usedLinkHandling = Private::DISCARD_ALL;
    else if( m_doc->isoOptions().createRockRidge() ) {
        if( m_doc->isoOptions().discardBrokenSymlinks() )
            d->usedLinkHandling = Private::DISCARD_BROKEN;
        else
            d->usedLinkHandling = Private::KEEP_ALL;
    }
    else {
        d->usedLinkHandling = Private::FOLLOW;
    }

    m_sessionNumber = s_imagerSessionCounter++;
}


void K3b::IsoImager::start()
{
    jobStarted();

    cleanup();

    d->mkisofsBin = initMkisofs();
    if( !d->mkisofsBin ) {
        jobFinished( false );
        return;
    }

    initVariables();

    delete m_process;
    m_process = new K3b::Process( this );
    m_process->setFlags( K3bQProcess::RawStdout );

    *m_process << d->mkisofsBin;

    // prepare the filenames as written to the image
    m_doc->prepareFilenames();

    if( !prepareMkisofsFiles() ||
        !addMkisofsParameters() ) {
        cleanup();
        jobFinished( false );
        return;
    }

    connect( m_process, SIGNAL(finished(int,QProcess::ExitStatus)),
             this, SLOT(slotProcessExited(int,QProcess::ExitStatus)) );
    connect( m_process, SIGNAL(stderrLine(QString)),
             this, SLOT(slotReceivedStderr(QString)) );

    qDebug() << "***** mkisofs parameters:\n";
    QString s = m_process->joinedArgs();
    qDebug() << s << Qt::endl << Qt::flush;
    emit debuggingOutput("mkisofs command:", s);

    if( !m_process->start( KProcess::SeparateChannels ) ) {
        // something went wrong when starting the program
        // it "should" be the executable
        qDebug() << "(K3b::IsoImager) could not start mkisofs";
        emit infoMessage( i18n("Could not start %1.", QLatin1String("mkisofs")), K3b::Job::MessageError );
        jobFinished( false );
        cleanup();
    }
}


void K3b::IsoImager::cancel()
{
    qDebug();
    m_canceled = true;

    if( m_process && m_process->isRunning() ) {
        qDebug() << "terminating process";
        m_process->terminate();
    }
    else if( active() ) {
        emit canceled();
        jobFinished(false);
    }
}


void K3b::IsoImager::setMultiSessionInfo( const QString& info, K3b::Device::Device* dev )
{
    m_multiSessionInfo = info;
    m_device = dev;
}


QString K3b::IsoImager::multiSessionInfo() const
{
    return m_multiSessionInfo;
}


K3b::Device::Device* K3b::IsoImager::multiSessionImportDevice() const
{
    return m_device;
}


// iso9660 + RR use some latin1 variant. So we need to cut the desc fields
// counting 8bit chars. The GUI should take care of restricting the length
// and the charset
static void truncateTheHardWay( QString& s, int max )
{
    QByteArray cs = s.toUtf8();
    cs.truncate(max);
    s = QString::fromUtf8( cs );
}


bool K3b::IsoImager::addMkisofsParameters( bool printSize )
{
    // add multisession info
    if( !m_multiSessionInfo.isEmpty() ) {
        *m_process << "-cdrecord-params" << m_multiSessionInfo;
        if( m_device && !m_doc->isoOptions().doNotImportSession() ) {
            *m_process << "-prev-session" << m_device->blockDeviceName();
        }
    }

    // add the arguments
    *m_process << "-gui";
    *m_process << "-graft-points";

    if( printSize )
        *m_process << "-print-size" << "-quiet";

    if( !m_doc->isoOptions().volumeID().isEmpty() ) {
        QString s = m_doc->isoOptions().volumeID();
        truncateTheHardWay(s, 32);  // ensure max length
        *m_process << "-volid" << s;
    }
    else {
        emit infoMessage( i18n("No volume id specified. Using default."), MessageWarning );
        *m_process << "-volid" << "CDROM";
    }

    QString s = m_doc->isoOptions().volumeSetId();
    truncateTheHardWay(s, 128);  // ensure max length
    *m_process << "-volset" << s;

    s = m_doc->isoOptions().applicationID();
    truncateTheHardWay(s, 128);  // ensure max length
    *m_process << "-appid" << s;

    s = m_doc->isoOptions().publisher();
    truncateTheHardWay(s, 128);  // ensure max length
    *m_process << "-publisher" << s;

    s = m_doc->isoOptions().preparer();
    truncateTheHardWay(s, 128);  // ensure max length
    *m_process << "-preparer" << s;

    s = m_doc->isoOptions().systemId();
    truncateTheHardWay(s, 32);  // ensure max length
    *m_process << "-sysid" << s;

    s = m_doc->isoOptions().abstractFile();
    truncateTheHardWay(s, 37);  // ensure max length
    if ( !s.isEmpty() )
        *m_process << "-abstract" << s;

    s = m_doc->isoOptions().copyrightFile();
    truncateTheHardWay(s, 37);  // ensure max length
    if ( !s.isEmpty() )
        *m_process << "-copyright" << s;

    s = m_doc->isoOptions().bibliographFile();
    truncateTheHardWay(s, 37);  // ensure max length
    if ( !s.isEmpty() )
        *m_process << "-biblio" << s;

    int volsetSize = m_doc->isoOptions().volumeSetSize();
    int volsetSeqNo = m_doc->isoOptions().volumeSetNumber();
    if( volsetSeqNo > volsetSize ) {
        qDebug() << "(K3b::IsoImager) invalid volume set sequence number: " << volsetSeqNo
                 << " with volume set size: " << volsetSize << Qt::endl;
        volsetSeqNo = volsetSize;
    }
    *m_process << "-volset-size" << QString::number(volsetSize);
    *m_process << "-volset-seqno" << QString::number(volsetSeqNo);

    if( m_sortWeightFile ) {
        *m_process << "-sort" << m_sortWeightFile->fileName();
    }

    if( m_doc->isoOptions().createRockRidge() ) {
        if( m_doc->isoOptions().preserveFilePermissions() )
            *m_process << "-rock";
        else
            *m_process << "-rational-rock";
        if( m_rrHideFile )
            *m_process << "-hide-list" << m_rrHideFile->fileName();
    }

    if( m_doc->isoOptions().createJoliet() ) {
        *m_process << "-joliet";
        if( m_doc->isoOptions().jolietLong() )
            *m_process << "-joliet-long";
        if( m_jolietHideFile )
            *m_process << "-hide-joliet-list" << m_jolietHideFile->fileName();
    }

    if( m_doc->isoOptions().doNotCacheInodes() )
        *m_process << "-no-cache-inodes";

    //
    // Check if we have files > 2 GB and enable udf in that case.
    //
    bool filesGreaterThan2Gb = false;
    bool filesGreaterThan4Gb = false;
    K3b::DataItem* item = m_doc->root();
    while( (item = item->nextSibling()) ) {
        if ( item->isFile() && item->size() >= 0xFFFFFFFFULL ) {
            filesGreaterThan4Gb = filesGreaterThan2Gb = true;
            break;
        }
        else if( item->isFile() && item->size() > 2LL*1024LL*1024LL*1024LL ) {
            filesGreaterThan2Gb = true;
            if ( filesGreaterThan4Gb )
                break;
        }
    }

    if ( filesGreaterThan4Gb ) {
        if ( d->mkisofsBin && !d->mkisofsBin->hasFeature( "no-4gb-limit" ) ) {
            emit infoMessage( i18n( "Found files bigger than 4 GB. K3b needs at least %1 to continue." ,
                              QString( "mkisofs >= 2.01.01a33 / genisoimage >= 1.1.4" ) ),
                              MessageError );
            return false;
        }
    }

    // in genisoimage 1.1.3 "they" silently introduced this awful parameter
    if (filesGreaterThan2Gb && d->mkisofsBin && d->mkisofsBin->hasFeature("genisoimage") && d->mkisofsBin->version() >= K3b::Version(1, 1, 3)) {
        *m_process << "-allow-limited-size";
        emit infoMessage(i18n("Found files bigger than 2 GB. These files will be fully accessible."),
                MessageInfo);
    }

    bool udf = m_doc->isoOptions().createUdf();
    if( !udf && filesGreaterThan2Gb ) {
        emit infoMessage( i18n("Enabling UDF extension."), MessageInfo );
        udf = true;
    }
    if( udf )
        *m_process << "-udf";

    if( m_doc->isoOptions().ISOuntranslatedFilenames()  ) {
        *m_process << "-untranslated-filenames";
    }
    else {
        if( m_doc->isoOptions().ISOallowPeriodAtBegin()  )
            *m_process << "-allow-leading-dots";
        if( m_doc->isoOptions().ISOallow31charFilenames()  )
            *m_process << "-full-iso9660-filenames";
        if( m_doc->isoOptions().ISOomitVersionNumbers() && !m_doc->isoOptions().ISOmaxFilenameLength() )
            *m_process << "-omit-version-number";
        if( m_doc->isoOptions().ISOrelaxedFilenames()  )
            *m_process << "-relaxed-filenames";
        if( m_doc->isoOptions().ISOallowLowercase()  )
            *m_process << "-allow-lowercase";
        if( m_doc->isoOptions().ISOnoIsoTranslate()  )
            *m_process << "-no-iso-translate";
        if( m_doc->isoOptions().ISOallowMultiDot()  )
            *m_process << "-allow-multidot";
        if( m_doc->isoOptions().ISOomitTrailingPeriod() )
            *m_process << "-omit-period";
    }

    if( m_doc->isoOptions().ISOmaxFilenameLength()  )
        *m_process << "-max-iso9660-filenames";

    if( m_noDeepDirectoryRelocation  )
        *m_process << "-disable-deep-relocation";

    // We do our own following
//   if( m_doc->isoOptions().followSymbolicLinks() || !m_doc->isoOptions().createRockRidge() )
//     *m_process << "-follow-links";

    if( m_doc->isoOptions().createTRANS_TBL()  )
        *m_process << "-translation-table";
    if( m_doc->isoOptions().hideTRANS_TBL()  )
        *m_process << "-hide-joliet-trans-tbl";

    int isoLevel = m_doc->isoOptions().ISOLevel();
    if ( filesGreaterThan4Gb && isoLevel < 3 ) {
        emit infoMessage( i18n( "Setting iso level to 3 to support files bigger than 4 GB." ), MessageWarning );
        isoLevel = 3;
    }
    *m_process << "-iso-level" << QString::number( isoLevel );

    *m_process << "-path-list" << m_pathSpecFile->fileName();


    // boot stuff
    if( !m_doc->bootImages().isEmpty() ) {
        bool first = true;
        QList<K3b::BootItem*> bootItems = m_doc->bootImages();
        Q_FOREACH( K3b::BootItem* bootItem, bootItems ) {
            if( !first )
                *m_process << "-eltorito-alt-boot";

            *m_process << "-eltorito-boot";
            *m_process << bootItem->writtenPath();

            if( bootItem->imageType() == K3b::BootItem::HARDDISK ) {
                *m_process << "-hard-disk-boot";
            }
            else if( bootItem->imageType() == K3b::BootItem::NONE ) {
                *m_process << "-no-emul-boot";
                if( bootItem->loadSegment() > 0 )
                    *m_process << "-boot-load-seg" << QString::number(bootItem->loadSegment());
                if( bootItem->loadSize() > 0 )
                    *m_process << "-boot-load-size" << QString::number(bootItem->loadSize());
            }

            if( bootItem->imageType() != K3b::BootItem::NONE && bootItem->noBoot() )
                *m_process << "-no-boot";
            if( bootItem->bootInfoTable() )
                *m_process << "-boot-info-table";

            first = false;
        }

        *m_process << "-eltorito-catalog" << m_doc->bootCataloge()->writtenPath();
    }


    // additional parameters from config
    
    if ( d->mkisofsBin) {
        const QStringList& params = d->mkisofsBin->userParameters();
        for( QStringList::const_iterator it = params.begin(); it != params.end(); ++it )
            *m_process << *it;
    }

    return true;
}


int K3b::IsoImager::writePathSpec()
{
    delete m_pathSpecFile;
    m_pathSpecFile = new QTemporaryFile();
    if ( m_pathSpecFile->open() ) {
        qDebug() << "Opened path spec file" << m_pathSpecFile->fileName();
        QTextStream s( m_pathSpecFile );

        // recursive path spec writing
        return writePathSpecForDir( m_doc->root(), s );
    }
    else {
        return -1;
    }
}


int K3b::IsoImager::writePathSpecForDir( K3b::DirItem* dirItem, QTextStream& stream )
{
    if( !m_noDeepDirectoryRelocation && dirItem->depth() > 7 ) {
        qDebug() << "(K3b::IsoImager) found directory depth > 7. Enabling no deep directory relocation.";
        m_noDeepDirectoryRelocation = true;
    }

    // now create the graft points
    int num = 0;
    Q_FOREACH( K3b::DataItem* item, dirItem->children() ) {
        bool writeItem = item->writeToCd();

        if( item->isSymLink() ) {
            if( d->usedLinkHandling == Private::DISCARD_ALL ||
                ( d->usedLinkHandling == Private::DISCARD_BROKEN &&
                  !item->isValid() ) )
                writeItem = false;

            else if( d->usedLinkHandling == Private::FOLLOW ) {
                QFileInfo f( K3b::resolveLink( item->localPath() ) );
                if( !f.exists() ) {
                    emit infoMessage( i18n("Could not follow link %1 to non-existing file %2. Skipping...", item->k3bName(), f.filePath()), MessageWarning );
                    writeItem = false;
                }
                else if( f.isDir() ) {
                    emit infoMessage( i18n("Ignoring link %1 to folder %2. K3b is unable to follow links to folders.", item->k3bName(), f.filePath()), MessageWarning );
                    writeItem = false;
                }
            }
        }
        else if( item->isFile() ) {
            QFileInfo f( item->localPath() );
            if( !f.exists() ) {
                emit infoMessage( i18n("Could not find file %1. Skipping...",item->localPath()), MessageWarning );
                writeItem = false;
            }
            else if( !f.isReadable() ) {
                emit infoMessage( i18n("Could not read file %1. Skipping...",item->localPath()), MessageWarning );
                writeItem = false;
            }
        }

        if( writeItem ) {
            num++;

            // some versions of mkisofs seem to have a bug that prevents to use filenames
            // that contain one or more backslashes
            if( item->writtenPath().contains("\\") )
                m_containsFilesWithMultibleBackslashes = true;


            if( item->isDir() ) {
                stream << escapeGraftPoint( item->writtenPath() )
                       << "="
                       << escapeGraftPoint( dummyDir( static_cast<K3b::DirItem*>(item) ) ) << "\n";

                int x = writePathSpecForDir( dynamic_cast<K3b::DirItem*>(item), stream );
                if( x >= 0 )
                    num += x;
                else
                    return -1;
            }
            else {
                writePathSpecForFile( static_cast<K3b::FileItem*>(item), stream );
            }
        }
    }

    return num;
}


void K3b::IsoImager::writePathSpecForFile( K3b::FileItem* item, QTextStream& stream )
{
    stream << escapeGraftPoint( item->writtenPath() )
           << "=";

    if( m_doc->bootImages().contains( dynamic_cast<K3b::BootItem*>(item) ) ) { // boot-image-backup-hack

        // create temp file
        QTemporaryFile temp;
        temp.setAutoRemove( false );
        temp.open();
        QString tempPath = temp.fileName();
        temp.remove();

        KIO::CopyJob* copyJob = KIO::copyAs(QUrl::fromLocalFile(item->localPath()), QUrl::fromLocalFile(tempPath), KIO::HideProgressInfo);
        bool copyJobSucceed = true;
        connect(copyJob, &KJob::result, [&](KJob*) {
            if( copyJob->error() != KJob::NoError ) {
                emit infoMessage( i18n("Failed to backup boot image file %1",item->localPath()), MessageError );
                copyJobSucceed = false;
            }
        } );
        if( !copyJob->exec() || !copyJobSucceed ) {
            return;
        }

        static_cast<K3b::BootItem*>(item)->setTempPath( tempPath );

        m_tempFiles.append(tempPath);
        stream << escapeGraftPoint( tempPath ) << "\n";
    }
    else if( item->isSymLink() && d->usedLinkHandling == Private::FOLLOW )
        stream << escapeGraftPoint( K3b::resolveLink( item->localPath() ) ) << "\n";
    else
        stream << escapeGraftPoint( item->localPath() ) << "\n";
}


bool K3b::IsoImager::writeRRHideFile()
{
    delete m_rrHideFile;
    m_rrHideFile = new QTemporaryFile();
    m_rrHideFile->open();

    QTextStream s( m_rrHideFile );

    K3b::DataItem* item = m_doc->root();
    while( item ) {
        if( item->hideOnRockRidge() ) {
            if( !item->isDir() )  // hiding directories does not work (all dirs point to the dummy-dir)
                s << escapeGraftPoint( item->localPath() ) << Qt::endl;
        }
        item = item->nextSibling();
    }

    return true;
}


bool K3b::IsoImager::writeJolietHideFile()
{
    delete m_jolietHideFile;
    m_jolietHideFile = new QTemporaryFile();
    m_jolietHideFile->open();

    QTextStream s( m_jolietHideFile );

    K3b::DataItem* item = m_doc->root();
    while( item ) {
        if( item->hideOnRockRidge() ) {
            if( !item->isDir() )  // hiding directories does not work (all dirs point to the dummy-dir but we could introduce a second hidden dummy dir)
                s << escapeGraftPoint( item->localPath() ) << Qt::endl;
        }
        item = item->nextSibling();
    }

    return true;
}


bool K3b::IsoImager::writeSortWeightFile()
{
    delete m_sortWeightFile;
    m_sortWeightFile = new QTemporaryFile();
    m_sortWeightFile->open();

    QTextStream s( m_sortWeightFile );

    //
    // We need to write the local path in combination with the sort weight
    // mkisofs will take care of multiple entries for one local file and always
    // use the highest weight
    //
    K3b::DataItem* item = m_doc->root();
    while( (item = item->nextSibling()) ) {  // we skip the root here
        if( item->sortWeight() != 0 ) {
            if( m_doc->bootImages().contains( dynamic_cast<K3b::BootItem*>(item) ) ) { // boot-image-backup-hack
                s << escapeGraftPoint( static_cast<K3b::BootItem*>(item)->tempPath() ) << " " << item->sortWeight() << Qt::endl;
            }
            else if( item->isDir() ) {
                //
                // Since we use dummy dirs for all directories in the filesystem and mkisofs uses the local path
                // for sorting we need to create a different dummy dir for every sort weight value.
                //
                s << escapeGraftPoint( dummyDir( static_cast<K3b::DirItem*>(item) ) ) << " " << item->sortWeight() << Qt::endl;
            }
            else
                s << escapeGraftPoint( item->localPath() ) << " " << item->sortWeight() << Qt::endl;
        }
    }

    return true;
}


QString K3b::IsoImager::escapeGraftPoint( const QString& str )
{
    QString enc = str;

    //
    // mkisofs manpage (-graft-points) is incorrect (as of mkisofs 2.01.01)
    //
    // Actually an equal sign needs to be escaped with one backslash only
    // Single backslashes inside a filename can be used without change
    // while single backslashes at the end of a filename need to be escaped
    // with two backslashes.
    //
    // There is one more problem though: the name in the iso tree can never
    // in any number of backslashes. mkisofs simply cannot handle it. So we
    // need to remove these slashes somewhere or ignore those files (we do
    // that in K3b::DataDoc::addUrls)
    //

    //
    // we do not use QString::replace to have full control
    // this might be slow since QString::insert is slow but we don't care
    // since this is only called to prepare the iso creation which is not
    // time critical. :)
    //

    int pos = 0;
    while( pos < enc.length() ) {
        // escape every equal sign with one backslash
        if( enc[pos] == '=' ) {
            enc.insert( pos, "\\" );
            pos += 2;
        }
        else if( enc[pos] == '\\' ) {
            // escape every occurrence of two backslashes with two backslashes
            if( pos+1 < enc.length() && enc[pos+1] == '\\' ) {
                enc.insert( pos, "\\\\" );
                pos += 4;
            }
            // escape the last single backslash in the filename (see above)
            else if( pos == enc.length()-1 ) {
                enc.insert( pos, "\\" );
                pos += 2;
            }
            else
                ++pos;
        }
        else
            ++pos;
    }

//   enc.replace( "\\\\", "\\\\\\\\" );
//   enc.replace( "=", "\\=" );

    return enc;
}


bool K3b::IsoImager::prepareMkisofsFiles()
{
    // write path spec file
    // ----------------------------------------------------
    int num = writePathSpec();
    if( num < 0 ) {
        emit infoMessage( i18n("Could not write temporary file"), K3b::Job::MessageError );
        return false;
    }
    else if( num == 0 ) {
        emit infoMessage( i18n("No files to be written."), K3b::Job::MessageError );
        return false;
    }

    if( m_doc->isoOptions().createRockRidge() ) {
        if( !writeRRHideFile() ) {
            emit infoMessage( i18n("Could not write temporary file"), K3b::Job::MessageError );
            return false;
        }
    }

    if( m_doc->isoOptions().createJoliet() ) {
        if( !writeJolietHideFile() ) {
            emit infoMessage( i18n("Could not write temporary file"), K3b::Job::MessageError );
            return false ;
        }
    }

    if( !writeSortWeightFile() ) {
        emit infoMessage( i18n("Could not write temporary file"), K3b::Job::MessageError );
        return false;
    }

    return true;
}


QString K3b::IsoImager::dummyDir( K3b::DirItem* dir )
{
    //
    // since we use virtual folders in order to have folders with different weight factors and different
    // permissions we create different dummy dirs to be passed to mkisofs
    //

    QString path = QStandardPaths::writableLocation( QStandardPaths::AppDataLocation ) + "/temp/";
    QDir().mkpath(path);
    QDir _appDir( path );

    //
    // create a unique isoimager session id
    // This might become important in case we will allow multiple instances of the isoimager
    // to run at the same time.
    //
    QString jobId = qApp->sessionId() + '_' + QString::number( m_sessionNumber );

    if( !_appDir.cd( jobId ) ) {
        _appDir.mkdir( jobId );
        _appDir.cd( jobId );
    }

    QString name( "dummydir_" );
    name += QString::number( dir->sortWeight() );

    bool perm = false;
    k3b_struct_stat statBuf;
    if( !dir->localPath().isEmpty() ) {
        // permissions
        if( k3b_stat( QFile::encodeName(dir->localPath()), &statBuf ) == 0 ) {
            name += '_';
            name += QString::number( statBuf.st_uid );
            name += '_';
            name += QString::number( statBuf.st_gid );
            name += '_';
            name += QString::number( statBuf.st_mode );
            name += '_';
            name += QString::number( statBuf.st_mtime );

            perm = true;
        }
    }


    if( !_appDir.cd( name ) ) {

        qDebug() << "(K3b::IsoImager) creating dummy dir: " << _appDir.absolutePath() << "/" << name;

        _appDir.mkdir( name );
        _appDir.cd( name );

        if( perm ) {
            ::chmod( QFile::encodeName( _appDir.absolutePath() ), statBuf.st_mode );
            ::chown( QFile::encodeName( _appDir.absolutePath() ), statBuf.st_uid, statBuf.st_gid );
            struct utimbuf tb;
            tb.actime = tb.modtime = statBuf.st_mtime;
            ::utime( QFile::encodeName( _appDir.absolutePath() ), &tb );
        }
    }

    return _appDir.absolutePath() + '/';
}


void K3b::IsoImager::clearDummyDirs()
{
    QString jobId = qApp->sessionId() + '_' + QString::number( m_sessionNumber );
    QString path = QStandardPaths::writableLocation( QStandardPaths::AppDataLocation ) + "/temp/";
    QDir().mkpath(path);
    QDir appDir( path );
    if( appDir.cd( jobId ) ) {
        QStringList dummyDirEntries = appDir.entryList( QStringList() << "dummydir*", QDir::Dirs );
        for( QStringList::iterator it = dummyDirEntries.begin(); it != dummyDirEntries.end(); ++it )
            appDir.rmdir( *it );
        appDir.cdUp();
        appDir.rmdir( jobId );
    }
}


bool K3b::IsoImager::hasBeenCanceled() const
{
    return m_canceled;
}


QIODevice* K3b::IsoImager::ioDevice() const
{
    return m_process;
}


