var fs = require('fs');

var level = 1;

var constants = {
    escape   : 0xFD,
    nodeStart: 0xFE,
    nodeEnd  : 0xFF
};

var Reader = function(data) {
    var self = this;
    self.data = data;
    self.offset = 0;

    self.byte = function() {
        ++self.offset;
        return self.data[self.offset - 1];
    };

    self.uint8 = function() {
        ++self.offset;
        return self.data.readUInt8(self.offset - 1);
    };

    self.peekUint8 = function() {
        return self.data[self.offset];
    };

    self.uint16 = function() {
        self.offset += 2;
        return self.data.readUInt16LE(self.offset - 2);
    };

    self.uint32 = function() {
        self.offset += 4;
        return self.data.readUInt32LE(self.offset - 4);
    };
};

var Node = function(begin, size) {
    var self = this;
    self.data = '';
    self.nodes = [];
    self.begin = begin;
    self.size = size;
    self.index = 0;

    self.handleBlock = function(begin, size) {
        ++level;
        var node = new Node(begin, size);
        self.nodes.push(node);
        return node;
    };

    self.next = function() {
        if (self.index < self.nodes.length) {
            delete self.data;

            var node = self.nodes[self.index];
            ++self.index;
            node.parse();
            return node;
        } else {
            delete self.nodes;
            return undefined;
        }
    };

    self.parse = function() {
        otbm.offset = self.begin;
        var byte = otbm.byte();
        var nextIsEscaped = false;
        var size = 1;

        while (otbm.offset < (self.begin + self.size)) {
            if (byte == constants.nodeStart && !nextIsEscaped) {
                var blockSize = self.sizer();
                var node = self.handleBlock(otbm.offset, blockSize);
                otbm.offset += blockSize;
            } else if (byte == constants.nodeEnd && !nextIsEscaped) {
                if (--level < 0) {
                    throw 'Error!'
                }
                break;
            } else if (byte == constants.escape && !nextIsEscaped) {
                nextIsEscaped = true;
            } else {
                nextIsEscaped = false;
                ++size;
            }
            byte = otbm.byte();
        }
        self.data = new Reader(otbm.data.slice(self.begin, self.begin + size));
    };

    self.sizer = function() {
        var oldOffset = otbm.offset;
        var subLevels = 1;

        var byte = otbm.uint8();
        var nextIsEscaped = false;

        while (byte != undefined) {
            if (byte == constants.nodeStart && !nextIsEscaped) {
                ++subLevels;
            } else if (byte == constants.nodeEnd && !nextIsEscaped) {
                if (--subLevels == 0) {
                    break;
                }
            } else {
                nextIsEscaped = byte == constants.escape && !nextIsEscaped;
            }
            byte = otbm.uint8();
        }
        var size = otbm.offset - oldOffset;
        otbm.offset = oldOffset;
        return size;
    }
};

var start = Date.now();

var dummyItems = {};
var genItem = function(itemId) {
    if (typeof dummyItems[itemId] === 'undefined') {
        dummyItems[itemId] = new Item(itemId);
    }
    return dummyItems[itemId];
};

var otbm = new Reader(fs.readFileSync('sample.otbm'));
var root = new Node(5, otbm.data.length);
root.parse();
++root.data.offset;

var version = root.data.uint32();
var width = root.data.uint16();
var height = root.data.uint16();
console.log('OTBM version:', version, '\nDimensions:', width, 'x', height);

var itemsVersion = {
    major: root.data.uint32(),
    minor: root.data.uint32()
};

var nodes = root.next();
++nodes.data.offset;

var description = '';
while (nodes.data.peekUint8()) {
    var attr = nodes.data.uint8();
    if (attr == 1) {
        description += nodes.data.toString() + '\n';
    }
}

console.log('Description:', description);