Object.defineProperty(CsInsn.prototype, "_toNative", {
    "value" : function () {
        if (this._nativeInsn) {
            return this._nativeInsn;
        }

        // Convert arch number to string
        var archStr = exports.ARCH.toString(this.arch);

        var insn = new InsnType();

        insn.id.set(this.id);
        insn.address.set(this.address);
        insn.size.set(this.bytes.length);

        new Buffer(this.bytes).copy(insn.bytes);

        insn.mnemonic.writeCString(0, this.mnemonic);
        insn.op_str.writeCString(0, this.op_str);

        if (this.detail) {
            insn.detail = ref.alloc(DetailType);
            var detail = insn.detail.deref();

            detail.regs_read.buffer.fill(0);
            detail.regs_write.buffer.fill(0);
            detail.groups.buffer.fill(0);

            new Buffer(this.detail.regs_read).copy(detail.regs_read.buffer);
            new Buffer(this.detail.regs_write).copy(detail.regs_write.buffer);
            new Buffer(this.detail.groups).copy(detail.groups.buffer);

            detail.regs_read_count.set(this.detail.regs_read.length);
            detail.regs_write_count.set(this.detail.regs_write.length);
            detail.groups_count.set(this.detail.groups.length);

            detail.arch[archStr]._load(this.detail[archStr]);
        }

        Object.defineProperty(this, "_nativeInsn", {
            "get" : function () {
                return insn;
            }
        });

        return insn;
    }
});

exports.INSN_OFFSET = function (insns, pos) {
    return insns[pos - 1].address - insns[0].address;
};

exports.version = function () {
    var major = ref.alloc("int");
    var minor = ref.alloc("int");
    var combined = capstone.cs_version(major, minor);
    return [ combined, major.deref(), minor.deref() ];
};

exports.version_bind = function () {
    return [ VERSION[0] << 8 | VERSION[1], VERSION[0], VERSION[1] ];
};

exports.support = capstone.cs_support;

exports.strerror = capstone.cs_strerror;

exports.Cs.prototype.close = function () {
    var errno = capstone.cs_close(this.csh);
    if (errno) {
        throw "cs_close returned " + errno + ": " + exports.strerror(errno);
    }
};

exports.Cs.prototype.errno = function () {
    return capstone.cs_errno(this.csh.deref());
};

exports.Cs.prototype.disasm = function (buffer, addr, max) {
    var insn = ref.alloc(new ArrayType(InsnType));

    var count = capstone.cs_disasm(
        this.csh.deref(),
        buffer,
        buffer.length,
        addr,
        max || 0,
        insn
    );
    if (!count) {
        var errno = this.errno();
        throw "cs_disasm returned " + errno + ": " + exports.strerror(errno);
    }

    // Get instruction array, and fix length
    var insns = insn.deref();
    insns.length = count;

    // Create a JavaScript view of the instruction array
    var instructions = [];
    for (var i = 0; i < count; i++) {
        instructions.push(new CsInsn(insns[i], this.arch));
    }

    // Free the native instruction array
    capstone.cs_free(insns.buffer, count);

    return instructions;
};

exports.Cs.prototype.disasm_lite = function (buffer, addr, max) {
    var insn = ref.alloc(new ArrayType(InsnType));

    var count = capstone.cs_disasm(
        this.csh.deref(),
        buffer,
        buffer.length,
        addr,
        max || 0,
        insn
    );
    if (!count) {
        var errno = this.errno();
        throw "cs_disasm_lite returned " + errno + ": " +
            exports.strerror(errno);
    }

    // Get instruction array, and fix length
    var insns = insn.deref();
    insns.length = count;

    // Create a JavaScript view of the instruction array
    var instructions = [];
    for (var i = 0; i < count; i++) {
        instructions.push([
            insns[i].address,
            insns[i].size,
            insns[i].mnemonic.buffer.readCString(0),
            insns[i].op_str.buffer.readCString(0)
        ]);
    }

    // Free the native instruction array
    capstone.cs_free(insns.buffer, count);

    return instructions;
};

exports.Cs.prototype.disasm_iter = function () { //(iter, callback) {
    // TODO
    // `iter` is a dictionary that the iterator will update
    // `callback` is called for each iteration, receiving the CsInsn
    // Will need to interally allocate a cs_insn buffer for this method
};

exports.Cs.prototype.reg_name = function (id) {
    return capstone.cs_reg_name(this.csh.deref(), id);
};

exports.Cs.prototype.insn_name = function (id) {
    return capstone.cs_insn_name(this.csh.deref(), id);
};

exports.Cs.prototype.insn_group = function (insn, id) {
    return capstone.cs_insn_group(this.csh.deref(), insn._toNative(), id);
};

exports.Cs.prototype.reg_read = function (insn, id) {
    return capstone.cs_reg_read(this.csh.deref(), insn._toNative(), id);
};

exports.Cs.prototype.reg_write = function (insn, id) {
    return capstone.cs_reg_write(this.csh.deref(), insn._toNative(), id);
};

exports.Cs.prototype.op_count = function (insn, op_type) {
    return capstone.cs_op_count(this.csh.deref(), insn._toNative(), op_type);
};

exports.Cs.prototype.op_index = function (insn, op_type, position) {
    return capstone.cs_op_index(
        this.csh.deref(),
        insn._toNative(),
        op_type,
        position
    );
};

exports.REL_ADDR = function (insn) {
    return insn.address + insn.size + insn.detail.arch.x86.disp;
};