#include "utils.h"
#include "pole.h"
#include "leinputstream.h"
#include "leoutputstream.h"
#include <QByteArray>
#include <QBuffer>
#include <QFile>
#include <QXmlStreamWriter>
#include <QDebug>

using namespace std;

QByteArray
escapeByteArray(const QByteArray& b) {
    // we escape all non printable byte values
    // printable is 9, 10, 13, 32-126
    QByteArray exclude(96, ' ');
    exclude[0] = 9; exclude[1] = 10; exclude[2] = 13;
    for (int i=3; i<8; ++i) {
        exclude[i] = i+29;
    }
    for (int i=8; i<96; ++i) {
        exclude[i] = i+30;
    }

    QByteArray result = b.toPercentEncoding(exclude);
    if (QByteArray::fromPercentEncoding(result) != b) {
        qDebug() << "Escaping of bytearray " << b << " is not reversible.";
        exit(1);
    }
    return result;
}

QVector<quint16>
toUInt16Vector(const QString& s) {
    QVector<quint16> v;
    QString z = QString::fromUtf8(QByteArray::fromPercentEncoding(s.toUtf8()));
    v.resize(z.size());
    for (int i=0; i<z.size(); ++i) {
        v[i] = z.utf16()[i];
    }
    return v;
}

QString
toString(const QVector<quint16>& v) {
    QString s;
    foreach(quint16 c, v) {
        s.append(c);
    }
    s = QString::fromUtf8(escapeByteArray(s.toUtf8()));
    // TODO: implement and check reversibility
/*
    if (toUInt16Vector(s) != v) {
        qDebug() << "Escaping of string " << v << " is not reversible.";
        qDebug() << toUInt16Vector(s);
        exit(1);
    }
*/
    return s;
}

void
print(QXmlStreamWriter& out, const Introspectable* i) {
    const Introspection* is = i->getIntrospection();
    for (int j=0; j<is->numberOfMembers; ++j) {
        for (int k=0; k<is->numberOfInstances[j](i); ++k) {
            out.writeStartElement(is->names[j]);
            const Introspectable* ci = is->introspectable[j](i, k);
            if (ci) {
                QString type = ci->getIntrospection()->name;
                out.writeAttribute("type", type);
                uint32_t offset = ci->streamOffset;
                out.writeAttribute("offset", QString::number(offset));
                print(out, ci);
            } else {
                QVariant v(is->value[j](i, k));
                if (v.canConvert<QVector<quint16> >()) {
                    out.writeCharacters(toString(v.value<QVector<quint16> >()));
                } else {
                    if (v.type() == QVariant::ByteArray) {
                        v = escapeByteArray(v.toByteArray());
                    }
                    out.writeCharacters(v.toString());
                }
            }
            out.writeEndElement();
        }
    }
}

QMap<QString, QByteArray>
readStreams(const QString& file) {
    QMap<QString, QByteArray> streams;
    POLE::Storage storage(file.toLocal8Bit());
    if (!storage.open()) return streams;

    // TODO add support for directories
    string prefix = "/";
    list<string> entries = storage.entries(prefix);
    for (list<string>::const_iterator i=entries.begin(); i!=entries.end(); ++i){
        string path(prefix+*i);
        if (!storage.isDirectory(path)) {
            POLE::Stream stream(&storage, path);
            QString streamname(QString::fromStdString(*i));
            QByteArray array;
            array.resize(stream.size());
            unsigned long read = stream.read((unsigned char*)array.data(),
                    stream.size());
            if (read != stream.size()) {
                qDebug() << "Error reading stream " << streamname;
                streams.clear();
                return streams;
            }
            streams[path.c_str()] = array;
        }
    }

    return streams;
}

QMap<QString, QSharedPointer<const Introspectable> >
parseStreams(const QMap<QString, QByteArray>& streams) {
    QMap<QString, QSharedPointer<const Introspectable> > result;
    QMap<QString, QByteArray>::const_iterator i;
    for (i = streams.begin(); i!= streams.end(); ++i) {
        const QString streampath(i.key());
        const QString streamname = streampath.mid(streampath.lastIndexOf('/')+1);
        const QByteArray array(i.value());
        QBuffer buffer;
        buffer.setData(array);
        buffer.open(QIODevice::ReadOnly);
        LEInputStream listream(&buffer);
        qDebug() << "Parsing stream '" << streampath << "'";

        const Introspectable* i;
        try {
            i = parse(streamname, listream);
        } catch (IOException& e) {
            qDebug() << "Error: " << e.msg;
            continue;
        }

        if (listream.getPosition() != (qint64)array.size()) {
            qDebug() << array.size() - listream.getPosition()
                << "trailing bytes in stream " << streampath;
            result.clear();
            return result;
        }
        buffer.close();

        // test if serialization gives the same bytearray as that which came in
        buffer.buffer().clear();
        buffer.open(QIODevice::WriteOnly);
        LEOutputStream lostream(&buffer);
        serialize(i, streamname, lostream);
        if (array != buffer.data()) {
            qDebug() << "Serialized data different from original in "
                << streampath;
        }

        result[streampath] = QSharedPointer<const Introspectable>(i);
    }
    return result;
}

QMap<QString, QByteArray>
serialize(const QMap<QString, QSharedPointer<const Introspectable> >& m) {
    QMap<QString, QByteArray> streams;
    QMap<QString, QSharedPointer<const Introspectable> >::const_iterator i;
    for (i = m.begin(); i!= m.end(); ++i) {
        const QString streampath(i.key());
        const QString streamname
            = streampath.mid(streampath.lastIndexOf('/')+1);
        QBuffer buffer;
        buffer.open(QIODevice::WriteOnly);
        LEOutputStream lostream(&buffer);
        const Introspectable* is = i.value().data();
        serialize(is, streamname, lostream);
        streams[streampath] = buffer.data();
    }
    return streams;
}

void
write(const QString& name, const QByteArray& data) {
    QFile out(name);
    out.open(QIODevice::WriteOnly);
    out.write(data);
    out.close();
}

void printWithExtendedParser(QXmlStreamWriter& out, const Introspectable* i);

void
printStyleTextPropAtom(QXmlStreamWriter& out, const Introspectable* i,
            int characterCount) {
    const Introspection* is = i->getIntrospection();

    // rh
    const Introspectable* ci = is->introspectable[0](i, 0);
    out.writeStartElement(is->names[0]);
    QString type = ci->getIntrospection()->name;
    out.writeAttribute("type", type);
    printWithExtendedParser(out, is->introspectable[0](i, 0)); // rh
    out.writeEndElement();

    // styles
    QByteArray blob = is->value[1](i, 0).toByteArray();
    QBuffer buffer;
    buffer.setData(blob);
    buffer.open(QIODevice::ReadOnly);
    LEInputStream listream(&buffer);

    try {
        int sum = 0;
        do {
            ci = parse("textPFRun", listream);
            const Introspection* cis = ci->getIntrospection();
            sum += cis->value[0](ci, 0).toInt();
            out.writeStartElement("rgTextPFRun");
            out.writeAttribute("type", "TextPFRun");
            printWithExtendedParser(out, ci);
            //qDebug() << "PF " << characterCount << " " << cis->value[0](ci, 0).toInt() << " " << sum;
            delete ci;
            out.writeEndElement();
        } while (sum <= characterCount);
        sum = 0;
        do {
            ci = parse("textCFRun", listream);
            const Introspection* cis = ci->getIntrospection();
            sum += cis->value[0](ci, 0).toInt();
            out.writeStartElement("rgTextCFRun");
            out.writeAttribute("type", "TextCFRun");
            printWithExtendedParser(out, ci);
            //qDebug() << "CF " << characterCount << " " << cis->value[0](ci, 0).toInt() << " " << sum;
            delete ci;
            out.writeEndElement();
        } while (sum <= characterCount);
    } catch (IOException& e) {
        qDebug() << "Error: " << e.msg;
    }
    if (buffer.size() != listream.getPosition()) {
        qDebug() << "Error: " << buffer.size() - listream.getPosition()
            << " bytes left for StyleTextPropAtom at position "
            << i->streamOffset;
    }
}

void
printWithExtendedParser(QXmlStreamWriter& out, const Introspectable* i) {
    int lastCharacterCount = 0; // needed for parsing StyleTextPropAtom

    const Introspection* is = i->getIntrospection();
    for (int j=0; j<is->numberOfMembers; ++j) {
        for (int k=0; k<is->numberOfInstances[j](i); ++k) {
            out.writeStartElement(is->names[j]);
            const Introspectable* ci = is->introspectable[j](i, k);
            if (ci) {
                QString type = ci->getIntrospection()->name;
                out.writeAttribute("type", type);
                uint32_t offset = ci->streamOffset;
                out.writeAttribute("offset", QString::number(offset));
                if (type == "StyleTextPropAtom") {
                    // StyleTextPropAtom is currently too hard to parse by the generated code
                    printStyleTextPropAtom(out, ci, lastCharacterCount);
                } else if (type == "TextCharsAtom") {
                    const Introspection* cis = ci->getIntrospection();
                    lastCharacterCount = cis->value[1](ci, 0).value<QVector<quint16> >().count();
                    printWithExtendedParser(out, ci);
                } else if (type == "TextBytesAtom") {
                    const Introspection* cis = ci->getIntrospection();
                    lastCharacterCount = cis->value[1](ci, 0).toByteArray().count();
                    printWithExtendedParser(out, ci);
                } else {
                    printWithExtendedParser(out, ci);
                }
            } else {
                QVariant v(is->value[j](i, k));
                if (v.canConvert<QVector<quint16> >()) {
                    out.writeCharacters(toString(v.value<QVector<quint16> >()));
                } else {
                    if (v.type() == QVariant::ByteArray) {
                        v = escapeByteArray(v.toByteArray());
                    }
                    out.writeCharacters(v.toString());
                }
            }
            out.writeEndElement();
        }
    }
}

QByteArray
streamsToXml(
            const QMap<QString, QSharedPointer<const Introspectable> >& streams,
            void (*printFunction)(QXmlStreamWriter&,const Introspectable*)) {
    QBuffer xml;
    xml.open(QBuffer::WriteOnly);
    QXmlStreamWriter xmlout(&xml);
    xmlout.setAutoFormatting(true);
    xmlout.writeStartDocument();
    xmlout.writeStartElement("ppt");
    QMap<QString, QSharedPointer<const Introspectable> >::const_iterator i;
    for (i = streams.begin(); i!= streams.end(); ++i) {
        const Introspection* in = i.value()->getIntrospection();
        xmlout.writeStartElement(in->name);
        xmlout.writeAttribute("stream-path", i.key());
        if (in->name != "TODOS") {
            printFunction(xmlout, i.value().data());
        }
        xmlout.writeEndElement();
    }
    xmlout.writeEndElement();
    xmlout.writeEndDocument();
    return xml.data();
}

QByteArray
streamsToXml(const QMap<QString,
            QSharedPointer<const Introspectable> >& streams) {
    return streamsToXml(streams, print);
}

QByteArray
streamsToExtendedXml(const QMap<QString,
            QSharedPointer<const Introspectable> >& streams) {
    return streamsToXml(streams, printWithExtendedParser);
}