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

**

** 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 Qt Linguist 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 "translator.h"

#include <QtCore/QDebug>

#include <QtCore/QIODevice>

#include <QtCore/QHash>

#include <QtCore/QString>

#include <QtCore/QTextCodec>

#include <QtCore/QTextStream>

#include <ctype.h>

#define MAGIC_OBSOLETE_REFERENCE "Obsolete_PO_entries"

// Uncomment if you wish to hard wrap long lines in .po files. Note that this

// affects only msg strings, not comments.

//#define HARD_WRAP_LONG_WORDS

QT_BEGIN_NAMESPACE

static const int MAX_LEN = 79;

static QString poEscapedString(const QString &prefix, const QString &keyword,

                               bool noWrap, const QString &ba)

{

    QStringList lines;

    int off = 0;

    QString res;

    while (off < ba.length()) {

        ushort c = ba[off++].unicode();

        switch (c) {

        case '\n':

            res += QLatin1String("\\n");

            lines.append(res);

            res.clear();

            break;

        case '\r':

            res += QLatin1String("\\r");

            break;

        case '\t':

            res += QLatin1String("\\t");

            break;

        case '\v':

            res += QLatin1String("\\v");

            break;

        case '\a':

            res += QLatin1String("\\a");

            break;

        case '\b':

            res += QLatin1String("\\b");

            break;

        case '\f':

            res += QLatin1String("\\f");

            break;

        case '"':

            res += QLatin1String("\\\"");

            break;

        case '\\':

            res += QLatin1String("\\\\");

            break;

        default:

            if (c < 32) {

                res += QLatin1String("\\x");

                res += QString::number(c, 16);

                if (off < ba.length() && isxdigit(ba[off].unicode()))

                    res += QLatin1String("\"\"");

            } else {

                res += QChar(c);

            }

            break;

        }

    }

    if (!res.isEmpty())

        lines.append(res);

    if (!lines.isEmpty()) {

        if (!noWrap) {

            if (lines.count() != 1 ||

                lines.first().length() > MAX_LEN - keyword.length() - prefix.length() - 3)

            {

                QStringList olines = lines;

                lines = QStringList(QString());

                const int maxlen = MAX_LEN - prefix.length() - 2;

                foreach (const QString &line, olines) {

                    int off = 0;

                    while (off + maxlen < line.length()) {

                        int idx = line.lastIndexOf(QLatin1Char(' '), off + maxlen - 1) + 1;

                        if (idx == off) {

#ifdef HARD_WRAP_LONG_WORDS

                            // This doesn't seem too nice, but who knows ...

                            idx = off + maxlen;

#else

                            idx = line.indexOf(QLatin1Char(' '), off + maxlen) + 1;

                            if (!idx)

                                break;

#endif

                        }

                        lines.append(line.mid(off, idx - off));

                        off = idx;

                    }

                    lines.append(line.mid(off));

                }

            }

        } else if (lines.count() > 1) {

            lines.prepend(QString());

        }

    }

    return prefix + keyword + QLatin1String(" \"") +

           lines.join(QLatin1String("\"\n") + prefix + QLatin1Char('"')) +

           QLatin1String("\"\n");

}

static QString poEscapedLines(const QString &prefix, bool addSpace, const QStringList &lines)

{

    QString out;

    foreach (const QString &line, lines) {

        out += prefix;

        if (addSpace && !line.isEmpty())

            out += QLatin1Char(' ' );

        out += line;

        out += QLatin1Char('\n');

    }

    return out;

}

static QString poEscapedLines(const QString &prefix, bool addSpace, const QString &in0)

{

    QString in = in0;

    if (in.endsWith(QLatin1Char('\n')))

        in.chop(1);

    return poEscapedLines(prefix, addSpace, in.split(QLatin1Char('\n')));

}

static QString poWrappedEscapedLines(const QString &prefix, bool addSpace, const QString &line)

{

    const int maxlen = MAX_LEN - prefix.length();

    QStringList lines;

    int off = 0;

    while (off + maxlen < line.length()) {

        int idx = line.lastIndexOf(QLatin1Char(' '), off + maxlen - 1);

        if (idx < off) {

#if 0 //def HARD_WRAP_LONG_WORDS

            // This cannot work without messing up semantics, so do not even try.

#else

            idx = line.indexOf(QLatin1Char(' '), off + maxlen);

            if (idx < 0)

                break;

#endif

        }

        lines.append(line.mid(off, idx - off));

        off = idx + 1;

    }

    lines.append(line.mid(off));

    return poEscapedLines(prefix, addSpace, lines);

}

struct PoItem

{

public:

    PoItem()

      : isPlural(false), isFuzzy(false)

    {}

public:

    QByteArray id;

    QByteArray context;

    QByteArray tscomment;

    QByteArray oldTscomment;

    QByteArray lineNumber;

    QByteArray fileName;

    QByteArray references;

    QByteArray translatorComments;

    QByteArray automaticComments;

    QByteArray msgId;

    QByteArray oldMsgId;

    QList<QByteArray> msgStr;

    bool isPlural;

    bool isFuzzy;

    QHash<QString, QString> extra;

};

static bool isTranslationLine(const QByteArray &line)

{

    return line.startsWith("#~ msgstr") || line.startsWith("msgstr");

}

static QByteArray slurpEscapedString(const QList<QByteArray> &lines, int &l,

        int offset, const QByteArray &prefix, ConversionData &cd)

{

    QByteArray msg;

    int stoff;

    for (; l < lines.size(); ++l) {

        const QByteArray &line = lines.at(l);

        if (line.isEmpty() || !line.startsWith(prefix))

            break;

        while (isspace(line[offset])) // No length check, as string has no trailing spaces.

            offset++;

        if (line[offset] != '"')

            break;

        offset++;

        forever {

            if (offset == line.length())

                goto premature_eol;

            uchar c = line[offset++];

            if (c == '"') {

                if (offset == line.length())

                    break;

                while (isspace(line[offset]))

                    offset++;

                if (line[offset++] != '"') {

                    cd.appendError(QString::fromLatin1(

                            "PO parsing error: extra characters on line %1.")

                            .arg(l + 1));

                    break;

                }

                continue;

            }

            if (c == '\\') {

                if (offset == line.length())

                    goto premature_eol;

                c = line[offset++];

                switch (c) {

                case 'r':

                    msg += '\r'; // Maybe just throw it away?

                    break;

                case 'n':

                    msg += '\n';

                    break;

                case 't':

                    msg += '\t';

                    break;

                case 'v':

                    msg += '\v';

                    break;

                case 'a':

                    msg += '\a';

                    break;

                case 'b':

                    msg += '\b';

                    break;

                case 'f':

                    msg += '\f';

                    break;

                case '"':

                    msg += '"';

                    break;

                case '\\':

                    msg += '\\';

                    break;

                case '0':

                case '1':

                case '2':

                case '3':

                case '4':

                case '5':

                case '6':

                case '7':

                    stoff = offset - 1;

                    while ((c = line[offset]) >= '0' && c <= '7')

                        if (++offset == line.length())

                            goto premature_eol;

                    msg += line.mid(stoff, offset - stoff).toUInt(0, 8);

                    break;

                case 'x':

                    stoff = offset;

                    while (isxdigit(line[offset]))

                        if (++offset == line.length())

                            goto premature_eol;

                    msg += line.mid(stoff, offset - stoff).toUInt(0, 16);

                    break;

                default:

                    cd.appendError(QString::fromLatin1(

                            "PO parsing error: invalid escape '\\%1' (line %2).")

                            .arg(QChar((uint)c)).arg(l + 1));

                    msg += '\\';

                    msg += c;

                    break;

                }

            } else {

                msg += c;

            }

        }

        offset = prefix.size();

    }

    --l;

    return msg;

premature_eol:

    cd.appendError(QString::fromLatin1(

            "PO parsing error: premature end of line %1.").arg(l + 1));

    return QByteArray();

}

static void slurpComment(QByteArray &msg, const QList<QByteArray> &lines, int & l)

{

    QByteArray prefix = lines.at(l);

    for (int i = 1; ; i++) {

        if (prefix.at(i) != ' ') {

            prefix.truncate(i);

            break;

        }

    }

    for (; l < lines.size(); ++l) {

        const QByteArray &line = lines.at(l);

        if (line.startsWith(prefix))

            msg += line.mid(prefix.size());

        else if (line != "#")

            break;

        msg += '\n';

    }

    --l;

}

static QString makePoHeader(const QString &str)

{

    return QLatin1String("po-header-") + str.toLower().replace(QLatin1Char('-'), QLatin1Char('_'));

}

static QByteArray QByteArrayList_join(const QList<QByteArray> &that, char sep)

{

    int totalLength = 0;

    const int size = that.size();

    for (int i = 0; i < size; ++i)

        totalLength += that.at(i).size();

    if (size > 0)

        totalLength += size - 1;

    QByteArray res;

    if (totalLength == 0)

        return res;

    res.reserve(totalLength);

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

        if (i)

            res += sep;

        res += that.at(i);

    }

    return res;

}

bool loadPO(Translator &translator, QIODevice &dev, ConversionData &cd)

{

    QTextCodec *codec = QTextCodec::codecForName(

            cd.m_codecForSource.isEmpty() ? QByteArray("UTF-8") : cd.m_codecForSource);

    bool error = false;

    // format of a .po file entry:

    // white-space

    // #  translator-comments

    // #. automatic-comments

    // #: reference...

    // #, flag...

    // #~ msgctxt, msgid*, msgstr - used for obsoleted messages

    // #| msgctxt, msgid* previous untranslated-string - for fuzzy message

    // msgctx string-context

    // msgid untranslated-string

    // -- For singular:

    // msgstr translated-string

    // -- For plural:

    // msgid_plural untranslated-string-plural

    // msgstr[0] translated-string

    // ...

    // we need line based lookahead below.

    QList<QByteArray> lines;

    while (!dev.atEnd())

        lines.append(dev.readLine().trimmed());

    lines.append(QByteArray());

    int l = 0, lastCmtLine = -1;

    PoItem item;

    for (; l != lines.size(); ++l) {

        QByteArray line = lines.at(l);

        if (line.isEmpty())

           continue;

        if (isTranslationLine(line)) {

            bool isObsolete = line.startsWith("#~ msgstr");

            const QByteArray prefix = isObsolete ? "#~ " : "";

            while (true) {

                int idx = line.indexOf(' ', prefix.length());

                QByteArray str = slurpEscapedString(lines, l, idx, prefix, cd);

                item.msgStr.append(str);

                if (l + 1 >= lines.size() || !isTranslationLine(lines.at(l + 1)))

                    break;

                ++l;

                line = lines.at(l);

            }

            if (item.msgId.isEmpty()) {

                QHash<QString, QByteArray> extras;

                QList<QByteArray> hdrOrder;

                QByteArray pluralForms;

                foreach (const QByteArray &hdr, item.msgStr.first().split('\n')) {

                    if (hdr.isEmpty())

                        continue;

                    int idx = hdr.indexOf(':');

                    if (idx < 0) {

                            .arg(QString::fromLatin1(hdr)));

                        error = true;

                        break;

                    }

                    QByteArray hdrName = hdr.left(idx).trimmed();

                    QByteArray hdrValue = hdr.mid(idx + 1).trimmed();

                    hdrOrder << hdrName;

                    if (hdrName == "X-Language") {

                        translator.setLanguageCode(QString::fromLatin1(hdrValue));

                    } else if (hdrName == "X-Source-Language") {

                        translator.setSourceLanguageCode(QString::fromLatin1(hdrValue));

                    } else if (hdrName == "Plural-Forms") {

                        pluralForms  = hdrValue;

                    } else if (hdrName == "MIME-Version") {

                        // just assume it is 1.0

                    } else if (hdrName == "Content-Type") {

                        if (cd.m_codecForSource.isEmpty()) {

                            if (!hdrValue.startsWith("text/plain; charset=")) {

                                    .arg(QString::fromLatin1(hdrValue)));

                                error = true;

                                // This will avoid a flood of conversion errors.

                                codec = QTextCodec::codecForName("latin1");

                            } else {

                                QByteArray cod = hdrValue.mid(20);

                                QTextCodec *cdc = QTextCodec::codecForName(cod);

                                if (!cdc) {

                                            .arg(QString::fromLatin1(cod)));

                                    error = true;

                                    // This will avoid a flood of conversion errors.

                                    codec = QTextCodec::codecForName("latin1");

                                } else {

                                    codec = cdc;

                                }

                            }

                        }

                    } else if (hdrName == "Content-Transfer-Encoding") {

                        if (hdrValue != "8bit") {

                                .arg(QString::fromLatin1(hdrValue)));

                            return false;

                        }

                    } else if (hdrName == "X-Virgin-Header") {