#include "leinputstream.h"
#include "leoutputstream.h"
#include "introspection.h"
#include "pole.h"
#include <QBuffer>
#include <QCoreApplication>
#include <QDebug>
#include <QFile>
#include <QVariant>
#include <cstdio>

const Introspectable* parse(const QString& key, LEInputStream& in);
void serialize(const Introspectable* i, const QString& key, LEOutputStream& out);

using namespace std;

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

bool
parse(const QString& file) {
    try {
        POLE::Storage storage(file.toLocal8Bit());
        if (!storage.open()) {
            qDebug() << "Cannot open file " << file << ".";
            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 encrypted, do not report failure.
            if (*i == "EncryptedSummary") return true;
        }
        for (list<string>::const_iterator i=entries.begin(); i!=entries.end(); ++i) {
            if (!storage.isDirectory(prefix+*i)) {
                POLE::Stream stream(&storage, prefix+*i);
                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;
                    return false;
                }
//                write("/tmp/"+streamname+".in", array);
                QBuffer buffer;
                buffer.setData(array);
                buffer.open(QIODevice::ReadOnly);
                LEInputStream listream(&buffer);
                qDebug() << "Parsing stream '" << streamname << "' of size "
                        << array.size();
                const Introspectable* i = parse(streamname, listream);
                if (listream.getPosition() != (qint64)stream.size()) {
                    qDebug() << stream.size() - listream.getPosition()
                        << "trailing bytes in stream " << streamname
                        << ", so probably an error at position "
                        << listream.getMaxPosition();
                    return false;
                }
                buffer.close();

                buffer.buffer().clear();
                buffer.open(QIODevice::WriteOnly);
                LEOutputStream lostream(&buffer);
                serialize(i, streamname, lostream);
//                write("/tmp/"+streamname+".out", buffer.data());
                if (array != buffer.data()) {
                    qDebug() << "Serialized data different from original in "
                        << streamname;
                    return false;
                }


                delete i;
            }
        }
    } catch (IOException& e) {
        qDebug() << "Error: " << e.msg;
        return false;
    }
    return true;
}

int
main(int argc, char** argv) {
    QCoreApplication app(argc, argv);
    if (argc < 2) return -1;

    for (int i=1; i<argc; ++i) {
        QString file(argv[i]);
        qDebug() << "Parsing of " << file;
        if (parse(file)) {
            qDebug() << "Parsing of " << file << " succeedded.";
        } else {
            qDebug() << "Parsing of " << file << " failed.";
        }
    }

    return 0;
}