#include "deepfiletree.h"
#include <QUrl>
#include <QFileInfo>
#include <QDir>
#include <QVector>
#include <QVariant>
#include <QXmlQuery>
#include <QDomElement>
#include "pole.h"
#include <QDebug>

using namespace std;

/** This XML model spans the file system, OLE streams in OLE files and data structures in some
 *  OLE streams.
 **/

namespace {
class ElementNode {
public:
    // if parent, firstSibling, next or previous are -1, they corresponding node does not exist
    // if the value is -2, the corresponding node has not been searched yet
    int parentId;
    int firstSiblingId;
    int nextId;
    int previousId;

    ElementNode() :parentId(-2), firstSiblingId(-2), nextId(-2), previousId(-2) {}
};

class OleStreamElementNode : public ElementNode {
public:
    string streamname;
    int size;
    bool isdir;
};

class XmlElementNode : public ElementNode {
public:
    QDomElement element;
};

enum Type {
    File,
    OLEStream,
    XmlElement
};

const int typeSize = 3;
const int indexSize = sizeof(int)*8 - typeSize;

Type getType(int id) {
    return (Type)(id >> indexSize);
}
// last bits are used for the type
int getIndex(int id) {
    return (id << typeSize) >> typeSize;
}
int getId(Type t, int index) {
    return (t << indexSize) | index;
}

enum Kind {
    Element,
    AttributeName,
    AttributeSize
};

}

class DeepFileTree::Private {
public:
    QXmlNamePool namepool;
    QList<ElementNode> fileinfonodes;
    QList<QFileInfo> fileinfos;
    QList<OleStreamElementNode> olestreams;
    QList<XmlElementNode> xmlelements;
    QDomDocument doc;
    const QXmlName directory;
    const QXmlName file;
    const QXmlName olestream;
    const QXmlName olestreamdir;
    const QXmlName name;
    const QXmlName size;

    Private(const QXmlNamePool& pool) :namepool(pool),
            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"))) {
    }

    ElementNode& getElementNode(int id) {
        int index = getIndex(id);
        switch (getType(id)) {
            case File: return fileinfonodes[index];
            case OLEStream: return olestreams[index];
            case XmlElement:
            default:
            return xmlelements[index];
        }
    }
    QFileInfo* getFileInfo(int id) {
        return (getType(id) == File) ?&fileinfos[getIndex(id)] :0;
    }

    int getFileIndex(const QFileInfo& fileinfo) {
        // find the parent
        QDir dir = fileinfo.dir();
        QFileInfo parentInfo(dir.path());
        if (fileinfo == parentInfo) { // parent does not exist
            ElementNode node;
            node.parentId = node.nextId = node.previousId = -1;
            fileinfos.append(fileinfo);
            fileinfonodes.append(node);
            return fileinfonodes.count() - 1;
        }

        int parentIndex = getFileIndex(parentInfo);
        if (parentIndex == -1) return -1;
        ElementNode& parent = fileinfonodes[parentIndex];
        if (parent.firstSiblingId != -2) return -1;

        // the parent has not initialized its siblings yet
        const int indexOf = fileinfos.indexOf(parentInfo);
        if (indexOf != -1) return indexOf;

        int offset = fileinfos.count();
        loadFileSiblings(dir, parentIndex, parent);
        return fileinfos.indexOf(fileinfo, offset);
    }

    void loadFileSiblings(const QDir& dir, int parentIndex, ElementNode& parent) {
        QFileInfoList list = dir.entryInfoList(QStringList(),
            QDir::AllEntries|QDir::AllDirs|QDir::NoDotAndDotDot|QDir::Hidden, QDir::Name);
        int offset = fileinfos.count();
        fileinfos.append(list);
        parent.firstSiblingId = (list.count()) ?getId(File, offset) :-1;
        for (int i=0; i<list.size(); ++i) {
            ElementNode n;
            n.parentId = getId(File, parentIndex);
            n.previousId = (i) ?getId(File, offset + i - 1) :-1;
            n.nextId = (i == list.size()-1) ?-1 :getId(File, offset + i + 1);
            fileinfonodes.append(n);
        }
    }

    void loadStreamSiblings(const QFileInfo& info, int parentIndex, ElementNode& parent) {
//        if (info.suffix().toLower() != "ppt") return;
        POLE::Storage storage(info.absoluteFilePath().toLocal8Bit());
        if (!storage.open()) return;
        int offset = olestreams.count();
        int count = 0;
        list<string> entries = storage.entries();
        for (list<string>::const_iterator i=entries.begin(); i!=entries.end(); ++i) {
            if (!storage.isDirectory(*i)) {
                POLE::Stream stream(&storage, "/"+*i);
                OleStreamElementNode n;
                n.streamname = *i;
                n.size = stream.size();
                n.isdir = false;
                n.parentId = getId(File, parentIndex);
                n.previousId = (count) ?getId(OLEStream, offset + count - 1) :-1;
                n.nextId = getId(OLEStream, offset + count + 1);
                olestreams.append(n);
                count++;
            }
        }
        if (count) {
            parent.firstSiblingId = getId(OLEStream, offset);
            olestreams[olestreams.count()-1].nextId = -1;
        }
    }

    QDomElement createTestElement() {
        QDomElement e(doc.createElement("TESTING"));
        e.setAttribute("e", "E");
        QDomElement a(doc.createElement("suba"));
        a.setAttribute("a", "A");
        QDomElement b(doc.createElement("subb"));
        b.setAttribute("b", "B");
        b.setAttribute("c", "C");
        e.appendChild(a);
        e.appendChild(b);
        return e;
    }

    void loadStreamAsXmlElements(int parentId, ElementNode& parent) {
        parent.firstSiblingId = getId(XmlElement, xmlelements.count());
        QDomElement e = createTestElement();
        XmlElementNode& en = addXmlElement(e);
        en.parentId = parentId;
        en.nextId = -1;
        en.previousId = -1;
    }

    XmlElementNode& addXmlElement(const QDomElement& e) {
        int eindex = xmlelements.count();
        xmlelements.append(XmlElementNode());
        XmlElementNode& xe = xmlelements[eindex];
        xe.element = e;

        int eid = getId(XmlElement, eindex);
        int count = 0;
        QDomElement ce = e.firstChildElement();
        while (!ce.isNull()) {
            count++;
            XmlElementNode& cen = addXmlElement(ce);
            cen.parentId = eid; 
            cen.previousId = (count) ?eid + count - 1:-1;
            ce = ce.nextSiblingElement();
            cen.nextId = (ce.isNull()) ?-1 :eid + count + 1;
        }
        xe.firstSiblingId = (count > 0) ?eid + 1 :-1;
        return xe;
    }
};

DeepFileTree::DeepFileTree(const QXmlNamePool& pool) :d(new Private(pool)) {
}
DeepFileTree::~DeepFileTree() {
    delete d;
}

QXmlNodeModelIndex
DeepFileTree::toNodeIndex(const QFileInfo& fileinfo) const {
    int indexOf = d->fileinfos.indexOf(fileinfo);
    if (indexOf == -1) {
        indexOf = d->getFileIndex(fileinfo);
        if (indexOf == -1) return QXmlNodeModelIndex();
    }
    return createIndex(indexOf, Element);
}

QVector<QXmlNodeModelIndex>
DeepFileTree::attributes(const QXmlNodeModelIndex& element) const {
    QVector<QXmlNodeModelIndex> v;
    Type type = getType(element.data());
    switch (type) {
    case File: {
        v.append(createIndex(element.data(), AttributeName));
        const QFileInfo* info = d->getFileInfo(element.data());
        if (info->isFile()) {
            v.append(createIndex(element.data(), AttributeSize));
        }
        break;
    }
    case OLEStream: {
        v.append(createIndex(element.data(), AttributeName));
        const OleStreamElementNode& e = (const OleStreamElementNode&)d->getElementNode(element.data());
        if (!e.isdir) {
            v.append(createIndex(element.data(), AttributeSize));
        }
        break;
    }
    case XmlElement: {
        QDomElement e = d->xmlelements[getIndex(element.data())].element;
        QDomNamedNodeMap attributes = e.attributes();
        for (uint i=0; i<attributes.length(); ++i) {
             v.append(createIndex(element.data(), i+1));
        }
    }
    }
    return v;
}

QXmlNodeModelIndex
DeepFileTree::nextFromSimpleAxis(SimpleAxis axis, const QXmlNodeModelIndex& origin) const {
    const QFileInfo* info = d->getFileInfo(origin.data());
    ElementNode& node = d->getElementNode(origin.data());

    int data = -1;
    switch (axis) {
        case Parent:
            data = node.parentId; break;

        case FirstChild:
            if (node.firstSiblingId == -2) {
                if (info && info->isDir()) {
                    d->loadFileSiblings(info->filePath(), origin.data(), node);
                } else if (info && info->isFile()) {
                    d->loadStreamSiblings(info->filePath(), origin.data(), node);
                } else if (getType(origin.data()) == OLEStream) {
                    d->loadStreamAsXmlElements(origin.data(), node);
                }
                if (node.firstSiblingId == -2) {
                    node.firstSiblingId = -1;
                }
            }
            data = node.firstSiblingId; break;
 
        case PreviousSibling:
            data = node.previousId; break;

        case NextSibling:
            data = node.nextId; break;
    };
    return (data == -1) ?QXmlNodeModelIndex() :createIndex(data, 0);
}

QUrl
DeepFileTree::baseUri(const QXmlNodeModelIndex& n) const {
    return documentUri(n);
}
QXmlNodeModelIndex::DocumentOrder
DeepFileTree::compareOrder(const QXmlNodeModelIndex& ni1, const QXmlNodeModelIndex& ni2) const {
    if (ni1.data() < ni2.data()) return QXmlNodeModelIndex::Precedes;
    return (ni1.data() == ni2.data()) ?QXmlNodeModelIndex::Is :QXmlNodeModelIndex::Follows;
}
QUrl
DeepFileTree::documentUri(const QXmlNodeModelIndex& n) const {
    // TODO: find root and get uri from that
    const QFileInfo& fileinfo = d->fileinfos[n.data()];
    return QUrl::fromLocalFile(fileinfo.filePath());
}
QXmlNodeModelIndex
DeepFileTree::elementById(const QXmlName& id) const {
    return QXmlNodeModelIndex();
}
QXmlNodeModelIndex::NodeKind
DeepFileTree::kind(const QXmlNodeModelIndex& ni) const {
    return ni.additionalData() == Element ? QXmlNodeModelIndex::Element : QXmlNodeModelIndex::Attribute;
}
QXmlName
DeepFileTree::name(const QXmlNodeModelIndex& ni) const {
    QVector<QXmlNodeModelIndex> v;
    Type type = getType(ni.data());
    switch (type) {
        case File:
            switch ((Kind)ni.additionalData()) {
                case Element: return d->getFileInfo(ni.data())->isFile() ?d->file :d->directory;
                case AttributeName: return d->name;
                case AttributeSize: return d->size;
            }
        case OLEStream:
            switch ((Kind)ni.additionalData()) {
                case Element: {
                    const OleStreamElementNode& e
                         = (const OleStreamElementNode&)d->getElementNode(ni.data());
                    return (e.isdir) ?d->olestreamdir :d->olestream;
                }
                case AttributeName: return d->name;
                case AttributeSize: return d->size;
            }
        case XmlElement:
        default: {
            QDomElement e = d->xmlelements[getIndex(ni.data())].element;
            if (ni.additionalData() == 0) {
                return QXmlName(d->namepool, e.nodeName());
            } else {
                return QXmlName(d->namepool, e.attributes().item(ni.additionalData()-1).nodeName());
            }
        }
    }
}
QVector<QXmlName>
DeepFileTree::namespaceBindings(const QXmlNodeModelIndex& n) const {
    return QVector<QXmlName>();
}
QVector<QXmlNodeModelIndex>
DeepFileTree::nodesByIdref(const QXmlName& idref) const {
    return QVector<QXmlNodeModelIndex>();
}
QXmlNodeModelIndex
DeepFileTree::root(const QXmlNodeModelIndex& n) const {
    int index = n.data();
    ElementNode& e = d->getElementNode(n.data());
    while (e.parentId != -1) {
         index = e.parentId;
         e = d->getElementNode(index);
    }
    return createIndex(index, 0);
}
QString
DeepFileTree::stringValue(const QXmlNodeModelIndex& n) const {
    return typedValue(n).toString();
}
QVariant
DeepFileTree::typedValue(const QXmlNodeModelIndex& n) const {
    Type type = getType(n.data());
    switch (type) {
        case File: {
            const QFileInfo* info = d->getFileInfo(n.data());
            switch ((Kind)n.additionalData()) {
                case AttributeName: return info->fileName();
                case AttributeSize: return info->size();
                default:;
            }
        }
        case OLEStream: {
            const OleStreamElementNode& e
                = (const OleStreamElementNode&)d->getElementNode(n.data());
            switch ((Kind)n.additionalData()) {
                case AttributeName: return e.streamname.c_str();
                case AttributeSize: return e.size;
                default:;
            }
        }
        case XmlElement: {
            if (n.additionalData() > 0) {
                QDomElement e = d->xmlelements[getIndex(n.data())].element;
                return e.attributes().item(n.additionalData()-1).nodeValue();
            }
        }
    }
    return QVariant();
}