#include "leinputstream.h"

#include "pole.h"

#include <QBuffer>

#include <QCoreApplication>

#include <QXmlStreamWriter>

#include <QDebug>

#include <QFile>

#include <QMap>

#include <QTextStream>

#include <QStringList>

#include <QCoreApplication>

#include <QDomDocument>

#include <cstdio>

using namespace std;

class RecordType {

public:

    QString name;

    QList<int> rectInstances;

};

QString

getRecordNameString(const QList<RecordType>& rts, quint16 recInstance) {

    QString name;

    foreach (const RecordType& rt, rts) {

        if (rt.rectInstances.size() == 0 || rt.rectInstances.contains(recInstance)) {

            if (name.isNull()) {

                name = rt.name;

            } else {

                name += "/" + rt.name;

            }

        }

    }

    return name;

}

void

printStructure(LEInputStream& in, int depth, QTextStream& out,

        const QMap<int, QList<RecordType> >& recordTypeNames) {

    quint8 recVer = in.readuint4();

    quint16 recInstance = in.readuint12();

    quint16 recType = in.readuint16();

    quint32 recLen = in.readuint32();

    QString hexinstance = QString::number(recInstance, 16);

    QString hextype = QString::number(recType, 16);

    QString t = "\t";

    QString recordTypeName = getRecordNameString(recordTypeNames.value(recType),

        recInstance);

    out << depth << t << recVer << t << hexinstance << t << hextype << t << recLen << t << in.getPosition() << t << recordTypeName << endl;

    if ((recVer == 0xF && recType != 0x428) || recType == 0x138B) {

        int end = in.getPosition() + recLen;

        while (in.getPosition() != end) {

            if (in.getPosition() > end) {

                throw IOException("structure is too long");

            }

            printStructure(in, depth + 1, out, recordTypeNames);

        }

    } else {

        in.skip(recLen);

    }

}

bool

parse(const QString& file, const QMap<int, QList<RecordType> >& recordTypeNames) {

    QFile out;

    out.open(stdout, QIODevice::WriteOnly);

    QTextStream textout(&out);

    POLE::Storage storage(file.toLocal8Bit());

    if (!storage.open()) return false;

    string prefix;

    if (storage.isDirectory("PP97_DUALSTORAGE")) {

        prefix = "PP97_DUALSTORAGE/";

    } else {

        prefix = "/";

    }

    list<string> entries = storage.entries(prefix);

    for (list<string>::const_iterator i=entries.begin(); i!=entries.end(); ++i) {

        if (!storage.isDirectory(prefix+*i)) {

            try {

                POLE::Stream stream(&storage, prefix+*i);

                QString streamname(QString::fromStdString(*i));

                textout << "Stream '" << streamname << "' of size "

                        << stream.size() << ":" << endl;

                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;

                    return false;

                }

                QBuffer buffer;

                buffer.setData(array);

                buffer.open(QIODevice::ReadOnly);

                LEInputStream listream(&buffer);

                while (listream.getPosition() != buffer.size()) {

                    printStructure(listream, 0, textout, recordTypeNames);

                }

            } catch (IOException& e) {

                qDebug() << "Error: " << e.msg;

            }

        }

    }

    return true;

}

QList<int>

getNumbers(const QString& value) {

    QList<int> numbers;

    foreach (QString s, value.split("|")) {

        int base = 10;

        if (s.startsWith("0x")) {

            s.replace("0x", "");

            base = 16;

        }

        bool ok;

        int value = s.toInt(&ok, base);

        if (!ok) return QList<int>();

        numbers.append(value);

    }

    return numbers;

}

QMap<int, QList<RecordType> >

getRecordTypeNames(const QString& filename) {

    QDomDocument dom;

    QFile f(filename);

    f.open(QIODevice::ReadOnly);

    dom.setContent(&f);

    QMap<int, QList<RecordType> > map;

    QDomNodeList structs = dom.elementsByTagName("struct");

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

        QDomElement s = structs.item(i).toElement();

        QDomElement rh = s.elementsByTagName("type").item(0).toElement();

        if (rh.isNull() || rh.attribute("name") != "rh") continue;

        QList<int> typeNumbers;

        RecordType rt;

        rt.name = s.attribute("name");

        QDomNodeList limits = rh.elementsByTagName("limitation");

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

            QDomElement l = limits.item(i).toElement();

            if (l.attribute("name") == "recType") {

                typeNumbers = getNumbers(l.attribute("value"));

            } else if (l.attribute("name") == "recInstance") {

                rt.rectInstances = getNumbers(l.attribute("value"));

            }

        }

        foreach (int typeNumber, typeNumbers) {

            map[typeNumber].append(rt);

        }

    }

    return map;

}

int

main(int argc, char** argv) {

    QCoreApplication app(argc, argv);

    //if (argc < 2) return -1;

    const QMap<int, QList<RecordType> > recordTypeNames

        = getRecordTypeNames(":/src/mso.xml");

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

        QString file(argv[i]);

        qDebug() << "Parsing of " << file;

        if (parse(file, recordTypeNames)) {

            qDebug() << "Parsing of " << file << " succeedded.";

        } else {

            qDebug() << "Parsing of " << file << " failed.";

        }

    }

    return 0;

}