// Copyright 2011 Mark Cavage <mcavage@gmail.com> All rights reserved.

var assert = require('assert');

var ASN1 = require('./types'); var errors = require('./errors');

///— Globals

var newInvalidAsn1Error = errors.newInvalidAsn1Error;

///— API

function Reader(data) {

if (!data || !Buffer.isBuffer(data))
  throw new TypeError('data must be a node Buffer');

this._buf = data;
this._size = data.length;

// These hold the "current" state
this._len = 0;
this._offset = 0;

}

Object.defineProperty(Reader.prototype, 'length', {

enumerable: true,
get: function () { return (this._len); }

});

Object.defineProperty(Reader.prototype, 'offset', {

enumerable: true,
get: function () { return (this._offset); }

});

Object.defineProperty(Reader.prototype, 'remain', {

get: function () { return (this._size - this._offset); }

});

Object.defineProperty(Reader.prototype, 'buffer', {

get: function () { return (this._buf.slice(this._offset)); }

});

/**

* Reads a single byte and advances offset; you can pass in `true` to make this
* a "peek" operation (i.e., get the byte, but don't advance the offset).
*
* @param {Boolean} peek true means don't move offset.
* @return {Number} the next byte, null if not enough data.
*/

Reader.prototype.readByte = function(peek) {

if (this._size - this._offset < 1)
  return null;

var b = this._buf[this._offset] & 0xff;

if (!peek)
  this._offset += 1;

return b;

};

Reader.prototype.peek = function() {

return this.readByte(true);

};

/**

* Reads a (potentially) variable length off the BER buffer.  This call is
* not really meant to be called directly, as callers have to manipulate
* the internal buffer afterwards.
*
* As a result of this call, you can call `Reader.length`, until the
* next thing called that does a readLength.
*
* @return {Number} the amount of offset to advance the buffer.
* @throws {InvalidAsn1Error} on bad ASN.1
*/

Reader.prototype.readLength = function(offset) {

if (offset === undefined)
  offset = this._offset;

if (offset >= this._size)
  return null;

var lenB = this._buf[offset++] & 0xff;
if (lenB === null)
  return null;

if ((lenB & 0x80) == 0x80) {
  lenB &= 0x7f;

  if (lenB == 0)
    throw newInvalidAsn1Error('Indefinite length not supported');

  if (lenB > 4)
    throw newInvalidAsn1Error('encoding too long');

  if (this._size - offset < lenB)
    return null;

  this._len = 0;
  for (var i = 0; i < lenB; i++)
    this._len = (this._len << 8) + (this._buf[offset++] & 0xff);

} else {
  // Wasn't a variable length
  this._len = lenB;
}

return offset;

};

/**

* Parses the next sequence in this BER buffer.
*
* To get the length of the sequence, call `Reader.length`.
*
* @return {Number} the sequence's tag.
*/

Reader.prototype.readSequence = function(tag) {

var seq = this.peek();
if (seq === null)
  return null;
if (tag !== undefined && tag !== seq)
  throw newInvalidAsn1Error('Expected 0x' + tag.toString(16) +
                            ': got 0x' + seq.toString(16));

var o = this.readLength(this._offset + 1); // stored in `length`
if (o === null)
  return null;

this._offset = o;
return seq;

};

Reader.prototype.readInt = function() {

return this._readTag(ASN1.Integer);

};

Reader.prototype.readBoolean = function() {

return (this._readTag(ASN1.Boolean) === 0 ? false : true);

};

Reader.prototype.readEnumeration = function() {

return this._readTag(ASN1.Enumeration);

};

Reader.prototype.readString = function(tag, retbuf) {

if (!tag)
  tag = ASN1.OctetString;

var b = this.peek();
if (b === null)
  return null;

if (b !== tag)
  throw newInvalidAsn1Error('Expected 0x' + tag.toString(16) +
                            ': got 0x' + b.toString(16));

var o = this.readLength(this._offset + 1); // stored in `length`

if (o === null)
  return null;

if (this.length > this._size - o)
  return null;

this._offset = o;

if (this.length === 0)
  return retbuf ? new Buffer(0) : '';

var str = this._buf.slice(this._offset, this._offset + this.length);
this._offset += this.length;

return retbuf ? str : str.toString('utf8');

};

Reader.prototype.readOID = function(tag) {

if (!tag)
  tag = ASN1.OID;

var b = this.readString(tag, true);
if (b === null)
  return null;

var values = [];
var value = 0;

for (var i = 0; i < b.length; i++) {
  var byte = b[i] & 0xff;

  value <<= 7;
  value += byte & 0x7f;
  if ((byte & 0x80) == 0) {
    values.push(value);
    value = 0;
  }
}

value = values.shift();
values.unshift(value % 40);
values.unshift((value / 40) >> 0);

return values.join('.');

};

Reader.prototype._readTag = function(tag) {

assert.ok(tag !== undefined);

var b = this.peek();

if (b === null)
  return null;

if (b !== tag)
  throw newInvalidAsn1Error('Expected 0x' + tag.toString(16) +
                            ': got 0x' + b.toString(16));

var o = this.readLength(this._offset + 1); // stored in `length`
if (o === null)
  return null;

if (this.length > 4)
  throw newInvalidAsn1Error('Integer too long: ' + this.length);

if (this.length > this._size - o)
  return null;
this._offset = o;

var fb = this._buf[this._offset];
var value = 0;

for (var i = 0; i < this.length; i++) {
  value <<= 8;
  value |= (this._buf[this._offset++] & 0xff);
}

if ((fb & 0x80) == 0x80 && i !== 4)
  value -= (1 << (i * 8));

return value >> 0;

};

///— Exported API

module.exports = Reader;