#include "msoxmlnodemodel.h"

#include "utils.h"

#include <QtXmlPatterns/QXmlNamePool>

#include <QtCore/QUrl>

#include <QDebug>

using namespace std;

/** This XML model spans one OLE stream file.

 * The root node corresponds to the file. The child elements of the root

 * correspond to streams.

 * Below the streams, the elements can correspond to introspectables or values.

 * Each Introspectable contains a colleciont of Introspectables and values.

 * Each value is represented by a value element and a value text field.

 * There is a tree of introspectables available. Values (QVariants) do not know

 * about their parents and have to have a the pointer to their introspectable of

 * stream as a parent. The additionalData() filed of the QXmlNodeindex should

 * contain this information.

 * The data() field is a pointer to the introspectable also for the stream.

 **/

namespace {

/** The field additionalData() in QXmlNodeModelIndex is used for storing four

 *  bits of information while keeping the field increasing in value with

 *  document order. The value of the field data() is the same for each node

 *  below another node that is not a numbers: field type, member number and

 *  index in the member. These fields are

 **/

class Node {

public:

    enum Type { Document, RootElement, Stream, Introspectable, ValueElement };

    const void* data;

    int parent;

    int prev;

    int next;

    int firstChild;

    Type type;

    int memberno;

    int arrayno;

    Node() :data(0), parent(-1), prev(-1), next(-1), firstChild(-1) {}

};

int

countItems(const Introspectable* i) {

    if (i == 0) return 0;

    const Introspection* is = i->getIntrospection();

    int n = 0;

    for (int j=0; j<is->numberOfMembers; ++j) {

        for (int k=0; k<is->numberOfInstances[j](i); ++k) {

            const Introspectable* ci = is->introspectable[j](i, k);

            if (ci) {

                n += 1 + countItems(ci);

            } else {

                n += 1; // empty value element

            }

        }

    }

    return n;

}

int

countItems(const QMap<QString, QSharedPointer<const Introspectable> >& streams){

    int n = 2;

    QMap<QString, QSharedPointer<const Introspectable> >::const_iterator it

        = streams.begin();

    while (it != streams.end()) {

        n += 1 + countItems(it.value().data());

        it++;

    }

    return n;

}

void

addIntrospectable(QVector<Node>& nodes, const Introspectable* i, int pos,

        int parent) {

    if (i == 0) return;

    const Introspection* is = i->getIntrospection();

    nodes[pos].parent = parent;

    nodes[pos].data = i;

    nodes[pos].type = Node::Introspectable;

    int prevp = -1;

    int p = pos+1;

    for (int j=0; j<is->numberOfMembers; ++j) {

        for (int k=0; k<is->numberOfInstances[j](i); ++k) {

            const Introspectable* ci = is->introspectable[j](i, k);

            if (nodes[pos].firstChild == -1) {

                nodes[pos].firstChild = p;

            }

            if (prevp != -1) {

                nodes[p].prev = prevp;

                nodes[prevp].next = p;

            }

            prevp = p;

            nodes[p].memberno = j;

            nodes[p].arrayno = k;

            if (ci) {

                addIntrospectable(nodes, ci, p, pos);

                p += 1 + countItems(ci);

            } else {

                nodes[p].parent = pos;

                nodes[p].data = i;

                nodes[p].type = Node::ValueElement;

                p += 1; // skip empty position

            }

        }

    }

}

QVector<Node>

createNodes(const QMap<QString, QSharedPointer<const Introspectable> >&

        streams) {

    QVector<Node> nodes(countItems(streams));

    nodes[0].parent = -1; nodes[0].prev = -1; nodes[0].next = -1;

    nodes[0].firstChild = 1; nodes[0].type = Node::Document;

    nodes[1].parent =  0; nodes[1].prev = -1; nodes[1].next = -1;

    nodes[1].firstChild = (streams.size()) ?2 :-1;

    nodes[1].type = Node::RootElement;

    int prevp = -1;

    int p = 2;

    QMap<QString, QSharedPointer<const Introspectable> >::const_iterator it

        = streams.begin();

    while (it != streams.end()) {

        const Introspectable* i = it.value().data();

        addIntrospectable(nodes, i, p, 1);

        if (prevp != -1) {

            nodes[p].prev = prevp;

            nodes[prevp].next = p;

        }

        nodes[p].type = Node::Stream;

        prevp = p;

        p += 1 + countItems(i);

        it++;

    }

    return nodes;

}

}

class MsoXmlNodeModel::Private {

public:

    QXmlNamePool namepool;

    QString filepath;

    const QMap<QString, QSharedPointer<const Introspectable> > streams;

    const QVector<Node> nodes;

    const QXmlName ppt;

    const QXmlName directory;

    const QXmlName file;

    const QXmlName olestream;

    const QXmlName olestreamdir;

    const QXmlName name;

    const QXmlName size;

    const QXmlName type;

    static const QMap<QString, QSharedPointer<const Introspectable> > read(

            const char* filepath) {

        QString file = QString::fromLocal8Bit(filepath);

        const QMap<QString, QByteArray> streams = readStreams(file);

        return parseStreams(streams);

    }

    Private(const QXmlNamePool& pool, const char* filepath_) :namepool(pool),

            filepath(filepath_),

            streams(read(filepath_)),

            nodes(createNodes(streams)),

            ppt(QXmlName(namepool, QLatin1String("ppt"))),

            directory(QXmlName(namepool, QLatin1String("directory"))),

            file(QXmlName(namepool, QLatin1String("file"))),

            olestream(QXmlName(namepool, QLatin1String("olestream"))),

            olestreamdir(QXmlName(namepool, QLatin1String("olestreamdir"))),

            name(QXmlName(namepool, QLatin1String("name"))),

            size(QXmlName(namepool, QLatin1String("size"))),

            type(QXmlName(namepool, QLatin1String("type"))) {

    }

    void getIndex(QAbstractXmlNodeModel::SimpleAxis axis, qint64& data,

            qint64& additionalData) {

        if (additionalData == 1) {

            additionalData = 0;

            if (axis != Parent) data = -1;

            return;

        }

        const Node& node = nodes[data];

        // additionalData = 0;

        if (axis == Parent) {

            data = node.parent;

            return;

        }

        if (axis == FirstChild) {

            if (node.type == Node::ValueElement) {

                additionalData = 1;

            } else {

                data = node.firstChild;

            }

            return;

        }

        data = (axis == NextSibling) ?node.next :node.prev;

    }

    QXmlName getName(qint64 n, qint64 a) {

        if (a) return type;

        const Node& node = nodes[n];

        const Introspectable* i

            = static_cast<const Introspectable*>(nodes[node.parent].data);

        const Introspection* si = i->getIntrospection();

        return QXmlName(namepool, si->names[node.memberno]);

    }

};

MsoXmlNodeModel::MsoXmlNodeModel(const QXmlNamePool& pool, const char* filepath)

        :d(new Private(pool, filepath)) {

}

MsoXmlNodeModel::~MsoXmlNodeModel() {

    delete d;

}

QVector<QXmlNodeModelIndex>

MsoXmlNodeModel::attributes(const QXmlNodeModelIndex& element) const {

    QVector<QXmlNodeModelIndex> v;

    const Node& node = d->nodes[element.data()];

    if (node.type == Node::Introspectable && element.additionalData() == 0) {

        v.append(createIndex(element.data(), 1));

    }

    return v;

}

QXmlNodeModelIndex

MsoXmlNodeModel::nextFromSimpleAxis(SimpleAxis axis,

        const QXmlNodeModelIndex& origin) const {

    qint64 data = -1;

    qint64 additionalData = 0;

    const Node& node = d->nodes[origin.data()];

    if (node.type == Node::Introspectable || node.type == Node::ValueElement) {

        data = origin.data();

        additionalData = origin.additionalData();

        d->getIndex(axis, data, additionalData);

    } else {

        switch (axis) {

            case Parent:          data = node.parent;     break;

            case FirstChild:      data = node.firstChild; break;

            case PreviousSibling: data = node.prev;       break;

            case NextSibling:     data = node.next;       break;

            default: break;

        }

    }

    return (data == -1)

        ?QXmlNodeModelIndex() :createIndex(data, additionalData);

}

QUrl

MsoXmlNodeModel::baseUri(const QXmlNodeModelIndex& n) const {

    return documentUri(n);

}

QXmlNodeModelIndex::DocumentOrder

MsoXmlNodeModel::compareOrder(const QXmlNodeModelIndex& ni1,

        const QXmlNodeModelIndex& ni2) const {

    if (ni1.data() < ni2.data()) return QXmlNodeModelIndex::Precedes;

    if (ni1.data() == ni2.data()) {

        if (ni1.additionalData() < ni2.additionalData())

            return QXmlNodeModelIndex::Precedes;

        if (ni1.additionalData() == ni2.additionalData())

            return QXmlNodeModelIndex::Is;

    }

    return QXmlNodeModelIndex::Follows;

}

QUrl

MsoXmlNodeModel::documentUri(const QXmlNodeModelIndex& n) const {

    return QUrl::fromLocalFile(d->filepath);

}

QXmlNodeModelIndex

MsoXmlNodeModel::elementById(const QXmlName& id) const {

    return QXmlNodeModelIndex();

}

QXmlNodeModelIndex::NodeKind

MsoXmlNodeModel::kind(const QXmlNodeModelIndex& ni) const {

    if (ni.data() == 0) return QXmlNodeModelIndex::Document;

    if (ni.additionalData() == 1) {

        const Node& node = d->nodes[ni.data()];

        if (node.type == Node::Introspectable) {

            return QXmlNodeModelIndex::Attribute;

        }

        return QXmlNodeModelIndex::Text;

    }

    return QXmlNodeModelIndex::Element; // no attributes yet

}

QXmlName

MsoXmlNodeModel::name(const QXmlNodeModelIndex& ni) const {

    const Node& node = d->nodes[ni.data()];

    const Introspectable* i = static_cast<const Introspectable*>(node.data);

    const Introspection* si = (i) ?i->getIntrospection() :0;

    switch (node.type) {

        case Node::Document: return d->name; // should not matter

        case Node::RootElement: return d->ppt; 

        case Node::Stream: return QXmlName(d->namepool, si->name);

        case Node::Introspectable:

            return d->getName(ni.data(), ni.additionalData());

        case Node::ValueElement:

            return d->getName(ni.data(), ni.additionalData());

        default: break;

    }

    return QXmlName();

}

QVector<QXmlName>

MsoXmlNodeModel::namespaceBindings(const QXmlNodeModelIndex& n) const {

    return QVector<QXmlName>();

}

QVector<QXmlNodeModelIndex>

MsoXmlNodeModel::nodesByIdref(const QXmlName& idref) const {

    return QVector<QXmlNodeModelIndex>();

}

QXmlNodeModelIndex

MsoXmlNodeModel::root(const QXmlNodeModelIndex& n) const {

    return createIndex((qint64)0);

}

QString

MsoXmlNodeModel::stringValue(const QXmlNodeModelIndex& n) const {

    return typedValue(n).toString();

}

QVariant

MsoXmlNodeModel::typedValue(const QXmlNodeModelIndex& n) const {

    if (n.additionalData() == 1) { //attribute or value type

        const Node& node = d->nodes[n.data()];

        const Introspectable* i

            = static_cast<const Introspectable*>(d->nodes[n.data()].data);

        const Introspection* si = i->getIntrospection();

        if (node.type == Node::Introspectable) {

            return si->name;

        }

        return si->value[node.memberno](i, node.arrayno);

    }

    return QVariant();

}