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

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module 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 <qglobal.h>

#ifndef QT_NO_TEXTODFWRITER

#include "qtextodfwriter_p.h"

#include <QImageWriter>

#include <QTextListFormat>

#include <QTextList>

#include <QBuffer>

#include <QUrl>

#include "qtextdocument_p.h"

#include "qtexttable.h"

#include "qtextcursor.h"

#include "qtextimagehandler_p.h"

#include "qzipwriter_p.h"

#include <QDebug>

QT_BEGIN_NAMESPACE

/// Convert pixels to postscript point units

static QString pixelToPoint(qreal pixels)

{

    // we hardcode 96 DPI, we do the same in the ODF importer to have a perfect roundtrip.

    return QString::number(pixels * 72 / 96) + QString::fromLatin1("pt");

}

// strategies

class QOutputStrategy {

public:

    QOutputStrategy() : contentStream(0), counter(1) { }

    virtual ~QOutputStrategy() {}

    virtual void addFile(const QString &fileName, const QString &mimeType, const QByteArray &bytes) = 0;

    QString createUniqueImageName()

    {

        return QString::fromLatin1("Pictures/Picture%1").arg(counter++);

    }

    QIODevice *contentStream;

    int counter;

};

class QXmlStreamStrategy : public QOutputStrategy {

public:

    QXmlStreamStrategy(QIODevice *device)

    {

        contentStream = device;

    }

    virtual ~QXmlStreamStrategy()

    {

        if (contentStream)

            contentStream->close();

    }

    virtual void addFile(const QString &, const QString &, const QByteArray &)

    {

        // we ignore this...

    }

};

class QZipStreamStrategy : public QOutputStrategy {

public:

    QZipStreamStrategy(QIODevice *device)

        : zip(device),

        manifestWriter(&manifest)

    {

        QByteArray mime("application/vnd.oasis.opendocument.text");

        zip.setCompressionPolicy(QZipWriter::NeverCompress);

        zip.addFile(QString::fromLatin1("mimetype"), mime); // for mime-magick

        zip.setCompressionPolicy(QZipWriter::AutoCompress);

        contentStream = &content;

        content.open(QIODevice::WriteOnly);

        manifest.open(QIODevice::WriteOnly);

        manifestNS = QString::fromLatin1("urn:oasis:names:tc:opendocument:xmlns:manifest:1.0");

        // prettyfy

        manifestWriter.setAutoFormatting(true);

        manifestWriter.setAutoFormattingIndent(1);

        manifestWriter.writeNamespace(manifestNS, QString::fromLatin1("manifest"));

        manifestWriter.writeStartDocument();

        manifestWriter.writeStartElement(manifestNS, QString::fromLatin1("manifest"));

        addFile(QString::fromLatin1("/"), QString::fromLatin1("application/vnd.oasis.opendocument.text"));

        addFile(QString::fromLatin1("content.xml"), QString::fromLatin1("text/xml"));

    }

    ~QZipStreamStrategy()

    {

        manifestWriter.writeEndDocument();

        manifest.close();

        zip.addFile(QString::fromLatin1("META-INF/manifest.xml"), &manifest);

        content.close();

        zip.addFile(QString::fromLatin1("content.xml"), &content);

        zip.close();

    }

    virtual void addFile(const QString &fileName, const QString &mimeType, const QByteArray &bytes)

    {

        zip.addFile(fileName, bytes);

        addFile(fileName, mimeType);

    }

private:

    void addFile(const QString &fileName, const QString &mimeType)

    {

        manifestWriter.writeEmptyElement(manifestNS, QString::fromLatin1("file-entry"));

        manifestWriter.writeAttribute(manifestNS, QString::fromLatin1("media-type"), mimeType);

        manifestWriter.writeAttribute(manifestNS, QString::fromLatin1("full-path"), fileName);

    }

    QBuffer content;

    QBuffer manifest;

    QZipWriter zip;

    QXmlStreamWriter manifestWriter;

    QString manifestNS;

};

static QString bulletChar(QTextListFormat::Style style)

{

    switch(style) {

    case QTextListFormat::ListDisc:

        return QChar(0x25cf); // bullet character

    case QTextListFormat::ListCircle:

        return QChar(0x25cb); // white circle

    case QTextListFormat::ListSquare:

        return QChar(0x25a1); // white square

    case QTextListFormat::ListDecimal:

        return QString::fromLatin1("1");

    case QTextListFormat::ListLowerAlpha:

        return QString::fromLatin1("a");

    case QTextListFormat::ListUpperAlpha:

        return QString::fromLatin1("A");

    case QTextListFormat::ListLowerRoman:

        return QString::fromLatin1("i");

    case QTextListFormat::ListUpperRoman:

        return QString::fromLatin1("I");

    default:

    case QTextListFormat::ListStyleUndefined:

        return QString();

    }

}

void QTextOdfWriter::writeFrame(QXmlStreamWriter &writer, const QTextFrame *frame)

{

    Q_ASSERT(frame);

    const QTextTable *table = qobject_cast<const QTextTable*> (frame);

    if (table) { // Start a table.

        writer.writeStartElement(tableNS, QString::fromLatin1("table"));

        writer.writeEmptyElement(tableNS, QString::fromLatin1("table-column"));

        writer.writeAttribute(tableNS, QString::fromLatin1("number-columns-repeated"), QString::number(table->columns()));

    } else if (frame->document() && frame->document()->rootFrame() != frame) { // start a section

        writer.writeStartElement(textNS, QString::fromLatin1("section"));

    }

    QTextFrame::iterator iterator = frame->begin();

    QTextFrame *child = 0;

    int tableRow = -1;

    while (! iterator.atEnd()) {

        if (iterator.currentFrame() && child != iterator.currentFrame())

            writeFrame(writer, iterator.currentFrame());

        else { // no frame, its a block

            QTextBlock block = iterator.currentBlock();

            if (table) {

                QTextTableCell cell = table->cellAt(block.position());

                if (tableRow < cell.row()) {

                    if (tableRow >= 0)

                        writer.writeEndElement(); // close table row

                    tableRow = cell.row();

                    writer.writeStartElement(tableNS, QString::fromLatin1("table-row"));

                }

                writer.writeStartElement(tableNS, QString::fromLatin1("table-cell"));

                if (cell.columnSpan() > 1)

                    writer.writeAttribute(tableNS, QString::fromLatin1("number-columns-spanned"), QString::number(cell.columnSpan()));

                if (cell.rowSpan() > 1)

                    writer.writeAttribute(tableNS, QString::fromLatin1("number-rows-spanned"), QString::number(cell.rowSpan()));

                if (cell.format().isTableCellFormat()) {

                    writer.writeAttribute(tableNS, QString::fromLatin1("style-name"), QString::fromLatin1("T%1").arg(cell.tableCellFormatIndex()));

                }

            }

            writeBlock(writer, block);

            if (table)

                writer.writeEndElement(); // table-cell

        }

        child = iterator.currentFrame();

        ++iterator;

    }

    if (tableRow >= 0)

        writer.writeEndElement(); // close table-row

    if (table || (frame->document() && frame->document()->rootFrame() != frame))

        writer.writeEndElement();  // close table or section element

}

void QTextOdfWriter::writeBlock(QXmlStreamWriter &writer, const QTextBlock &block)

{

    if (block.textList()) { // its a list-item

        const int listLevel = block.textList()->format().indent();

        if (m_listStack.isEmpty() || m_listStack.top() != block.textList()) {

            // not the same list we were in.

            while (m_listStack.count() >= listLevel && !m_listStack.isEmpty() && m_listStack.top() != block.textList() ) { // we need to close tags

                m_listStack.pop();

                writer.writeEndElement(); // list

                if (m_listStack.count())

                    writer.writeEndElement(); // list-item

            }

            while (m_listStack.count() < listLevel) {

                if (m_listStack.count())

                    writer.writeStartElement(textNS, QString::fromLatin1("list-item"));

                writer.writeStartElement(textNS, QString::fromLatin1("list"));

                if (m_listStack.count() == listLevel - 1) {

                    m_listStack.push(block.textList());

                    writer.writeAttribute(textNS, QString::fromLatin1("style-name"), QString::fromLatin1("L%1")

                            .arg(block.textList()->formatIndex()));

                }

                else {

                    m_listStack.push(0);

                }

            }

        }

        writer.writeStartElement(textNS, QString::fromLatin1("list-item"));

    }

    else {

        while (! m_listStack.isEmpty()) {

            m_listStack.pop();

            writer.writeEndElement(); // list

            if (m_listStack.count())

                writer.writeEndElement(); // list-item

        }

    }

    if (block.length() == 1) { // only a linefeed

        writer.writeEmptyElement(textNS, QString::fromLatin1("p"));

        writer.writeAttribute(textNS, QString::fromLatin1("style-name"), QString::fromLatin1("p%1")

            .arg(block.blockFormatIndex()));

        if (block.textList())

            writer.writeEndElement(); // numbered-paragraph

        return;

    }

    writer.writeStartElement(textNS, QString::fromLatin1("p"));

    writer.writeAttribute(textNS, QString::fromLatin1("style-name"), QString::fromLatin1("p%1")

        .arg(block.blockFormatIndex()));

    for (QTextBlock::Iterator frag= block.begin(); !frag.atEnd(); frag++) {

        writer.writeCharacters(QString()); // Trick to make sure that the span gets no linefeed in front of it.

        writer.writeStartElement(textNS, QString::fromLatin1("span"));

        QString fragmentText = frag.fragment().text();

        if (fragmentText.length() == 1 && fragmentText[0] == 0xFFFC) { // its an inline character.

            writeInlineCharacter(writer, frag.fragment());

            writer.writeEndElement(); // span

            continue;

        }

        writer.writeAttribute(textNS, QString::fromLatin1("style-name"), QString::fromLatin1("c%1")

            .arg(frag.fragment().charFormatIndex()));

        bool escapeNextSpace = true;

        int precedingSpaces = 0;

        int exportedIndex = 0;

        for (int i=0; i <= fragmentText.count(); ++i) {

            bool isSpace = false;

                QChar character = fragmentText[i];

                isSpace = character.unicode() == ' ';

            // find more than one space. -> <text:s text:c="2" />

            if (!isSpace && escapeNextSpace && precedingSpaces > 1) {

                const bool startParag = exportedIndex == 0 && i == precedingSpaces;

                if (!startParag)

                    writer.writeCharacters(fragmentText.mid(exportedIndex, i - precedingSpaces + 1 - exportedIndex));

                writer.writeEmptyElement(textNS, QString::fromLatin1("s"));

                const int count = precedingSpaces - (startParag?0:1);

                if (count > 1)

                    writer.writeAttribute(textNS, QString::fromLatin1("c"), QString::number(count));

                precedingSpaces = 0;

                exportedIndex = i;

            }

            if (i < fragmentText.count()) {

                if (character.unicode() == 0x2028) { // soft-return

                    //if (exportedIndex < i)

                        writer.writeCharacters(fragmentText.mid(exportedIndex, i - exportedIndex));

                    writer.writeEmptyElement(textNS, QString::fromLatin1("line-break"));

                    exportedIndex = i+1;

                    continue;

                } else if (character.unicode() == '\t') { // Tab

                    //if (exportedIndex < i)

                        writer.writeCharacters(fragmentText.mid(exportedIndex, i - exportedIndex));

                    writer.writeEmptyElement(textNS, QString::fromLatin1("tab"));

                    exportedIndex = i+1;

                    precedingSpaces = 0;

                } else if (isSpace) {

                    ++precedingSpaces;

                    escapeNextSpace = true;

                } else if (!isSpace) {

                    precedingSpaces = 0;

                }

            }

        }

        writer.writeCharacters(fragmentText.mid(exportedIndex));

        writer.writeEndElement(); // span

    }

    writer.writeCharacters(QString()); // Trick to make sure that the span gets no linefeed behind it.

    writer.writeEndElement(); // p

    if (block.textList())

        writer.writeEndElement(); // list-item

}

void QTextOdfWriter::writeInlineCharacter(QXmlStreamWriter &writer, const QTextFragment &fragment) const

{

    writer.writeStartElement(drawNS, QString::fromLatin1("frame"));

    if (m_strategy == 0) {

        // don't do anything.

    }

    else if (fragment.charFormat().isImageFormat()) {

        QTextImageFormat imageFormat = fragment.charFormat().toImageFormat();

        writer.writeAttribute(drawNS, QString::fromLatin1("name"), imageFormat.name());

        // vvv  Copy pasted mostly from Qt =================

        QImage image;

        QString name = imageFormat.name();

        if (name.startsWith(QLatin1String(":/"))) // auto-detect resources

            name.prepend(QLatin1String("qrc"));

        QUrl url = QUrl::fromEncoded(name.toUtf8());

        const QVariant data = m_document->resource(QTextDocument::ImageResource, url);

        if (data.type() == QVariant::Image) {

            image = qvariant_cast<QImage>(data);

        } else if (data.type() == QVariant::ByteArray) {

            image.loadFromData(data.toByteArray());

        }

        if (image.isNull()) {

            QString context;

            if (QTextImageHandler::externalLoader)

                image = QTextImageHandler::externalLoader(name, context);

            if (image.isNull()) { // try direct loading

                name = imageFormat.name(); // remove qrc:/ prefix again

                image.load(name);

            }

        }

        // ^^^ Copy pasted mostly from Qt =================

        if (! image.isNull()) {

            QBuffer imageBytes;

            QImageWriter imageWriter(&imageBytes, "png");

            imageWriter.write(image);

            QString filename = m_strategy->createUniqueImageName();

            m_strategy->addFile(filename, QString::fromLatin1("image/png"), imageBytes.data());

            // get the width/height from the format.

            qreal width = (imageFormat.hasProperty(QTextFormat::ImageWidth)) ? imageFormat.width() : image.width();

            writer.writeAttribute(svgNS, QString::fromLatin1("width"), pixelToPoint(width));

            qreal height = (imageFormat.hasProperty(QTextFormat::ImageHeight)) ? imageFormat.height() : image.height();

            writer.writeAttribute(svgNS, QString::fromLatin1("height"), pixelToPoint(height));

            writer.writeStartElement(drawNS, QString::fromLatin1("image"));

            writer.writeAttribute(xlinkNS, QString::fromLatin1("href"), filename);

            writer.writeEndElement(); // image

        }

    }

    writer.writeEndElement(); // frame

}

void QTextOdfWriter::writeFormats(QXmlStreamWriter &writer, QSet<int> formats) const

{

    writer.writeStartElement(officeNS, QString::fromLatin1("automatic-styles"));

    QVector<QTextFormat> allStyles = m_document->allFormats();

    QSetIterator<int> formatId(formats);

    while(formatId.hasNext()) {

        int formatIndex = formatId.next();

        QTextFormat textFormat = allStyles.at(formatIndex);

        switch (textFormat.type()) {

        case QTextFormat::CharFormat:

            if (textFormat.isTableCellFormat())

                writeTableCellFormat(writer, textFormat.toTableCellFormat(), formatIndex);

            else

                writeCharacterFormat(writer, textFormat.toCharFormat(), formatIndex);

            break;

        case QTextFormat::BlockFormat:

            writeBlockFormat(writer, textFormat.toBlockFormat(), formatIndex);

            break;

        case QTextFormat::ListFormat:

            writeListFormat(writer, textFormat.toListFormat(), formatIndex);

            break;

        case QTextFormat::FrameFormat:

            writeFrameFormat(writer, textFormat.toFrameFormat(), formatIndex);

            break;

        case QTextFormat::TableFormat:

            ;break;

        }

    }

    writer.writeEndElement(); // automatic-styles

}

void QTextOdfWriter::writeBlockFormat(QXmlStreamWriter &writer, QTextBlockFormat format, int formatIndex) const

{

    writer.writeStartElement(styleNS, QString::fromLatin1("style"));

    writer.writeAttribute(styleNS, QString::fromLatin1("name"), QString::fromLatin1("p%1").arg(formatIndex));

    writer.writeAttribute(styleNS, QString::fromLatin1("family"), QString::fromLatin1("paragraph"));

    writer.writeStartElement(styleNS, QString::fromLatin1("paragraph-properties"));

    if (format.hasProperty(QTextFormat::BlockAlignment)) {

        QString value;

            value = QString::fromLatin1("start");

            value = QString::fromLatin1("end");

            value = QString::fromLatin1("left");

            value = QString::fromLatin1("right");

            value = QString::fromLatin1("center");

            value = QString::fromLatin1("justify");

        else

            qWarning() << "QTextOdfWriter: unsupported paragraph alignment; " << format.alignment();

        if (! value.isNull())

            writer.writeAttribute(foNS, QString::fromLatin1("text-align"), value);

    }

    if (format.hasProperty(QTextFormat::BlockTopMargin))

        writer.writeAttribute(foNS, QString::fromLatin1("margin-top"), pixelToPoint(qMax(qreal(0.), format.topMargin())) );

    if (format.hasProperty(QTextFormat::BlockBottomMargin))

        writer.writeAttribute(foNS, QString::fromLatin1("margin-bottom"), pixelToPoint(qMax(qreal(0.), format.bottomMargin())) );

    if (format.hasProperty(QTextFormat::BlockLeftMargin) || format.hasProperty(QTextFormat::BlockIndent))

        writer.writeAttribute(foNS, QString::fromLatin1("margin-left"), pixelToPoint(qMax(qreal(0.),

            format.leftMargin() + format.indent())));

    if (format.hasProperty(QTextFormat::BlockRightMargin))

        writer.writeAttribute(foNS, QString::fromLatin1("margin-right"), pixelToPoint(qMax(qreal(0.), format.rightMargin())) );

    if (format.hasProperty(QTextFormat::TextIndent))

        writer.writeAttribute(foNS, QString::fromLatin1("text-indent"), pixelToPoint(format.textIndent()));

    if (format.hasProperty(QTextFormat::PageBreakPolicy)) {

        if (format.pageBreakPolicy() & QTextFormat::PageBreak_AlwaysBefore)

            writer.writeAttribute(foNS, QString::fromLatin1("break-before"), QString::fromLatin1("page"));

        if (format.pageBreakPolicy() & QTextFormat::PageBreak_AlwaysAfter)

            writer.writeAttribute(foNS, QString::fromLatin1("break-after"), QString::fromLatin1("page"));

    }

    if (format.hasProperty(QTextFormat::BlockNonBreakableLines))

        writer.writeAttribute(foNS, QString::fromLatin1("keep-together"),

                format.nonBreakableLines() ? QString::fromLatin1("true") : QString::fromLatin1("false"));

    if (format.hasProperty(QTextFormat::TabPositions)) {

        QList<QTextOption::Tab> tabs = format.tabPositions();

        writer.writeStartElement(styleNS, QString::fromLatin1("style-tab-stops"));

        QList<QTextOption::Tab>::Iterator iterator = tabs.begin();

        while(iterator != tabs.end()) {

            writer.writeEmptyElement(styleNS, QString::fromLatin1("style-tab-stop"));

            writer.writeAttribute(styleNS, QString::fromLatin1("position"), pixelToPoint(iterator->position) );

            QString type;

            switch(iterator->type) {

            case QTextOption::DelimiterTab: type = QString::fromLatin1("char"); break;

            case QTextOption::LeftTab: type = QString::fromLatin1("left"); break;

            case QTextOption::RightTab: type = QString::fromLatin1("right"); break;

            case QTextOption::CenterTab: type = QString::fromLatin1("center"); break;

            }

            writer.writeAttribute(styleNS, QString::fromLatin1("type"), type);

            if (iterator->delimiter != 0)

                writer.writeAttribute(styleNS, QString::fromLatin1("char"), iterator->delimiter);

            ++iterator;

        }

        writer.writeEndElement(); // style-tab-stops

    }

    writer.writeEndElement(); // paragraph-properties

    writer.writeEndElement(); // style

}

void QTextOdfWriter::writeCharacterFormat(QXmlStreamWriter &writer, QTextCharFormat format, int formatIndex) const

{

    writer.writeStartElement(styleNS, QString::fromLatin1("style"));

    writer.writeAttribute(styleNS, QString::fromLatin1("name"), QString::fromLatin1("c%1").arg(formatIndex));

    writer.writeAttribute(styleNS, QString::fromLatin1("family"), QString::fromLatin1("text"));

    writer.writeEmptyElement(styleNS, QString::fromLatin1("text-properties"));

    if (format.fontItalic())

        writer.writeAttribute(foNS, QString::fromLatin1("font-style"), QString::fromLatin1("italic"));

    if (format.hasProperty(QTextFormat::FontWeight) && format.fontWeight() != QFont::Normal) {

        QString value;

        if (format.fontWeight() == QFont::Bold)