/* global CANNON */

/**
 * Kinematic body.
 *
 * Managed dynamic body, which moves but is not affected (directly) by the
 * physics engine. This is not a true kinematic body, in the sense that we are
 * letting the physics engine _compute_ collisions against it and selectively
 * applying those collisions to the object. The physics engine does not decide
 * the position/velocity/rotation of the element.
 *
 * Used for the camera object, because full physics simulation would create
 * movement that feels unnatural to the player. Bipedal movement does not
 * translate nicely to rigid body physics.
 *
 * See: http://www.learn-cocos2d.com/2013/08/physics-engine-platformer-terrible-idea/
 * And: http://oxleygamedev.blogspot.com/2011/04/player-physics-part-2.html
 */
const EPS = 0.000001;

module.exports = AFRAME.registerComponent('kinematic-body', {
  dependencies: ['velocity'],

  /*******************************************************************
   * Schema
   */

  schema: {
    mass:           { default: 5 },
    radius:         { default: 1.3 },
    linearDamping:  { default: 0.05 },
    enableSlopes:   { default: true },
    enableJumps:    { default: false },
  },

  /*******************************************************************
   * Lifecycle
   */

  init: function () {
    this.system = this.el.sceneEl.systems.physics;
    this.system.addComponent(this);

    const el = this.el,
        data = this.data,
        position = (new CANNON.Vec3()).copy(el.object3D.getWorldPosition(new THREE.Vector3()));

    this.body = new CANNON.Body({
      material: this.system.getMaterial('staticMaterial'),
      position: position,
      mass: data.mass,
      linearDamping: data.linearDamping,
      fixedRotation: true
    });
    this.body.addShape(
      new CANNON.Sphere(data.radius),
      new CANNON.Vec3(0, data.radius, 0)
    );

    this.body.el = this.el;
    this.el.body = this.body;
    this.system.addBody(this.body);

    if (el.hasAttribute('wasd-controls')) {
      console.warn('[kinematic-body] Not compatible with wasd-controls, use movement-controls.');
    }
  },

  remove: function () {
    this.system.removeBody(this.body);
    this.system.removeComponent(this);
    delete this.el.body;
  },

  /*******************************************************************
   * Update
   */

  /**
   * Checks CANNON.World for collisions and attempts to apply them to the
   * element automatically, in a player-friendly way.
   *
   * There's extra logic for horizontal surfaces here. The basic requirements:
   * (1) Only apply gravity when not in contact with _any_ horizontal surface.
   * (2) When moving, project the velocity against exactly one ground surface.
   *     If in contact with two ground surfaces (e.g. ground + ramp), choose
   *     the one that collides with current velocity, if any.
   */
  beforeStep: function (t, dt) {
    if (!dt) return;

    const el = this.el;
    const data = this.data
    const body = this.body;

    if (!data.enableJumps) body.velocity.set(0, 0, 0);
    body.position.copy(el.getAttribute('position'));
  },

  step: (function () {
    const velocity = new THREE.Vector3(),
        normalizedVelocity = new THREE.Vector3(),
        currentSurfaceNormal = new THREE.Vector3(),
        groundNormal = new THREE.Vector3();

    return function (t, dt) {
      if (!dt) return;

      let body = this.body,
          data = this.data,
          didCollide = false,
          height, groundHeight = -Infinity,
          groundBody,
          contacts = this.system.getContacts();

      dt = Math.min(dt, this.system.data.maxInterval * 1000);

      groundNormal.set(0, 0, 0);
      velocity.copy(this.el.getAttribute('velocity'));
      body.velocity.copy(velocity);

      for (var i = 0, contact; contact = contacts[i]; i++) {
        // 1. Find any collisions involving this element. Get the contact
        // normal, and make sure it's oriented _out_ of the other object and
        // enabled (body.collisionReponse is true for both bodies)
        if (!contact.enabled) { continue; }
        if (body.id === contact.bi.id) {
          contact.ni.negate(currentSurfaceNormal);
        } else if (body.id === contact.bj.id) {
          currentSurfaceNormal.copy(contact.ni);
        } else {
          continue;
        }

        didCollide = body.velocity.dot(currentSurfaceNormal) < -EPS;
        if (didCollide && currentSurfaceNormal.y <= 0.5) {
          // 2. If current trajectory attempts to move _through_ another
          // object, project the velocity against the collision plane to
          // prevent passing through.
          velocity.projectOnPlane(currentSurfaceNormal);
        } else if (currentSurfaceNormal.y > 0.5) {
          // 3. If in contact with something roughly horizontal (+/- 45º) then
          // consider that the current ground. Only the highest qualifying
          // ground is retained.
          height = body.id === contact.bi.id
            ? Math.abs(contact.rj.y + contact.bj.position.y)
            : Math.abs(contact.ri.y + contact.bi.position.y);
          if (height > groundHeight) {
            groundHeight = height;
            groundNormal.copy(currentSurfaceNormal);
            groundBody = body.id === contact.bi.id ? contact.bj : contact.bi;
          }
        }
      }

      normalizedVelocity.copy(velocity).normalize();
      if (groundBody && (!data.enableJumps || normalizedVelocity.y < 0.5)) {
        if (!data.enableSlopes) {
          groundNormal.set(0, 1, 0);
        } else if (groundNormal.y < 1 - EPS) {
          groundNormal.copy(this.raycastToGround(groundBody, groundNormal));
        }

        // 4. Project trajectory onto the top-most ground object, unless
        // trajectory is > 45º.
        velocity.projectOnPlane(groundNormal);

      } else if (this.system.driver.world) {
        // 5. If not in contact with anything horizontal, apply world gravity.
        // TODO - Why is the 4x scalar necessary.
        // NOTE: Does not work if physics runs on a worker.
        velocity.add(this.system.driver.world.gravity.scale(dt * 4.0 / 1000));
      }

      body.velocity.copy(velocity);
      this.el.setAttribute('velocity', body.velocity);
      this.el.setAttribute('position', body.position);
    };
  }()),

  /**
   * When walking on complex surfaces (trimeshes, borders between two shapes),
   * the collision normals returned for the player sphere can be very
   * inconsistent. To address this, raycast straight down, find the collision
   * normal, and return whichever normal is more vertical.
   * @param  {CANNON.Body} groundBody
   * @param  {CANNON.Vec3} groundNormal
   * @return {CANNON.Vec3}
   */
  raycastToGround: function (groundBody, groundNormal) {
    let ray,
        hitNormal,
        vFrom = this.body.position,
        vTo = this.body.position.clone();

    ray = new CANNON.Ray(vFrom, vTo);
    ray._updateDirection(); // TODO - Report bug.
    ray.intersectBody(groundBody);

    if (!ray.hasHit) return groundNormal;

    // Compare ABS, in case we're projecting against the inside of the face.
    hitNormal = ray.result.hitNormalWorld;
    return Math.abs(hitNormal.y) > Math.abs(groundNormal.y) ? hitNormal : groundNormal;
  }
});


/**
 * Gamepad controls for A-Frame.
 *
 * Stripped-down version of: https://github.com/donmccurdy/aframe-gamepad-controls
 *
 * For more information about the Gamepad API, see:
 * https://developer.mozilla.org/en-US/docs/Web/API/Gamepad_API/Using_the_Gamepad_API
 */

const GamepadButton = require('../../lib/GamepadButton'),
    GamepadButtonEvent = require('../../lib/GamepadButtonEvent');

const JOYSTICK_EPS = 0.2;

module.exports = AFRAME.registerComponent('gamepad-controls', {

  /*******************************************************************
   * Statics
   */

  GamepadButton: GamepadButton,

  /*******************************************************************
   * Schema
   */

  schema: {
    // Controller 0-3
    controller:        { default: 0, oneOf: [0, 1, 2, 3] },

    // Enable/disable features
    enabled:           { default: true },

    // Debugging
    debug:             { default: false },

    // Heading element for rotation
    camera:          { default: '[camera]', type: 'selector' },

    // Rotation sensitivity
    rotationSensitivity:  { default: 2.0 },
  },

  /*******************************************************************
   * Core
   */

  /**
   * Called once when component is attached. Generally for initial setup.
   */
  init: function () {
    const scene = this.el.sceneEl;
    this.prevTime = window.performance.now();

    // Button state
    this.buttons = {};

    // Rotation
    const rotation = this.el.object3D.rotation;
    this.pitch = new THREE.Object3D();
    this.pitch.rotation.x = THREE.Math.degToRad(rotation.x);
    this.yaw = new THREE.Object3D();
    this.yaw.position.y = 10;
    this.yaw.rotation.y = THREE.Math.degToRad(rotation.y);
    this.yaw.add(this.pitch);

    scene.addBehavior(this);
  },

  /**
   * Called when component is attached and when component data changes.
   * Generally modifies the entity based on the data.
   */
  update: function () { this.tick(); },

  /**
   * Called on each iteration of main render loop.
   */
  tick: function (t, dt) {
    this.updateButtonState();
    this.updateRotation(dt);
  },

  /**
   * Called when a component is removed (e.g., via removeAttribute).
   * Generally undoes all modifications to the entity.
   */
  remove: function () { },

  /*******************************************************************
   * Movement
   */

  isVelocityActive: function () {
    if (!this.data.enabled || !this.isConnected()) return false;

    const dpad = this.getDpad(),
        joystick0 = this.getJoystick(0),
        inputX = dpad.x || joystick0.x,
        inputY = dpad.y || joystick0.y;

    return Math.abs(inputX) > JOYSTICK_EPS || Math.abs(inputY) > JOYSTICK_EPS;
  },

  getVelocityDelta: function () {
    const dpad = this.getDpad(),
        joystick0 = this.getJoystick(0),
        inputX = dpad.x || joystick0.x,
        inputY = dpad.y || joystick0.y,
        dVelocity = new THREE.Vector3();

    if (Math.abs(inputX) > JOYSTICK_EPS) {
      dVelocity.x += inputX;
    }
    if (Math.abs(inputY) > JOYSTICK_EPS) {
      dVelocity.z += inputY;
    }

    return dVelocity;
  },

  /*******************************************************************
   * Rotation
   */

  isRotationActive: function () {
    if (!this.data.enabled || !this.isConnected()) return false;

    const joystick1 = this.getJoystick(1);

    return Math.abs(joystick1.x) > JOYSTICK_EPS || Math.abs(joystick1.y) > JOYSTICK_EPS;
  },

  updateRotation: function (dt) {
    if (!this.isRotationActive()) return;

    const data = this.data;
    const yaw = this.yaw;
    const pitch = this.pitch;
    const lookControls = data.camera.components['look-controls'];
    const hasLookControls = lookControls && lookControls.pitchObject && lookControls.yawObject;

    // Sync with look-controls pitch/yaw if available.
    if (hasLookControls) {
      pitch.rotation.copy(lookControls.pitchObject.rotation);
      yaw.rotation.copy(lookControls.yawObject.rotation);
    }

    const lookVector = this.getJoystick(1);

    if (Math.abs(lookVector.x) <= JOYSTICK_EPS) lookVector.x = 0;
    if (Math.abs(lookVector.y) <= JOYSTICK_EPS) lookVector.y = 0;

    lookVector.multiplyScalar(data.rotationSensitivity * dt / 1000);
    yaw.rotation.y -= lookVector.x;
    pitch.rotation.x -= lookVector.y;
    pitch.rotation.x = Math.max(- Math.PI / 2, Math.min(Math.PI / 2, pitch.rotation.x));
    data.camera.object3D.rotation.set(pitch.rotation.x, yaw.rotation.y, 0);

    // Sync with look-controls pitch/yaw if available.
    if (hasLookControls) {
      lookControls.pitchObject.rotation.copy(pitch.rotation);
      lookControls.yawObject.rotation.copy(yaw.rotation);
    }
  },

  /*******************************************************************
   * Button events
   */

  updateButtonState: function () {
    const gamepad = this.getGamepad();
    if (this.data.enabled && gamepad) {

      // Fire DOM events for button state changes.
      for (var i = 0; i < gamepad.buttons.length; i++) {
        if (gamepad.buttons[i].pressed && !this.buttons[i]) {
          this.emit(new GamepadButtonEvent('gamepadbuttondown', i, gamepad.buttons[i]));
        } else if (!gamepad.buttons[i].pressed && this.buttons[i]) {
          this.emit(new GamepadButtonEvent('gamepadbuttonup', i, gamepad.buttons[i]));
        }
        this.buttons[i] = gamepad.buttons[i].pressed;
      }

    } else if (Object.keys(this.buttons)) {
      // Reset state if controls are disabled or controller is lost.
      this.buttons = {};
    }
  },

  emit: function (event) {
    // Emit original event.
    this.el.emit(event.type, event);

    // Emit convenience event, identifying button index.
    this.el.emit(
      event.type + ':' + event.index,
      new GamepadButtonEvent(event.type, event.index, event)
    );
  },

  /*******************************************************************
   * Gamepad state
   */

  /**
   * Returns the Gamepad instance attached to the component. If connected,
   * a proxy-controls component may provide access to Gamepad input from a
   * remote device.
   *
   * @return {Gamepad}
   */
  getGamepad: function () {
    const localGamepad = navigator.getGamepads
          && navigator.getGamepads()[this.data.controller],
        proxyControls = this.el.sceneEl.components['proxy-controls'],
        proxyGamepad = proxyControls && proxyControls.isConnected()
          && proxyControls.getGamepad(this.data.controller);
    return proxyGamepad || localGamepad;
  },

  /**
   * Returns the state of the given button.
   * @param  {number} index The button (0-N) for which to find state.
   * @return {GamepadButton}
   */
  getButton: function (index) {
    return this.getGamepad().buttons[index];
  },

  /**
   * Returns state of the given axis. Axes are labelled 0-N, where 0-1 will
   * represent X/Y on the first joystick, and 2-3 X/Y on the second.
   * @param  {number} index The axis (0-N) for which to find state.
   * @return {number} On the interval [-1,1].
   */
  getAxis: function (index) {
    return this.getGamepad().axes[index];
  },

  /**
   * Returns the state of the given joystick (0 or 1) as a THREE.Vector2.
   * @param  {number} id The joystick (0, 1) for which to find state.
   * @return {THREE.Vector2}
   */
  getJoystick: function (index) {
    const gamepad = this.getGamepad();
    switch (index) {
      case 0: return new THREE.Vector2(gamepad.axes[0], gamepad.axes[1]);
      case 1: return new THREE.Vector2(gamepad.axes[2], gamepad.axes[3]);
      default: throw new Error('Unexpected joystick index "%d".', index);
    }
  },

  /**
   * Returns the state of the dpad as a THREE.Vector2.
   * @return {THREE.Vector2}
   */
  getDpad: function () {
    const gamepad = this.getGamepad();
    if (!gamepad.buttons[GamepadButton.DPAD_RIGHT]) {
      return new THREE.Vector2();
    }
    return new THREE.Vector2(
      (gamepad.buttons[GamepadButton.DPAD_RIGHT].pressed ? 1 : 0)
      + (gamepad.buttons[GamepadButton.DPAD_LEFT].pressed ? -1 : 0),
      (gamepad.buttons[GamepadButton.DPAD_UP].pressed ? -1 : 0)
      + (gamepad.buttons[GamepadButton.DPAD_DOWN].pressed ? 1 : 0)
    );
  },

  /**
   * Returns true if the gamepad is currently connected to the system.
   * @return {boolean}
   */
  isConnected: function () {
    const gamepad = this.getGamepad();
    return !!(gamepad && gamepad.connected);
  },

  /**
   * Returns a string containing some information about the controller. Result
   * may vary across browsers, for a given controller.
   * @return {string}
   */
  getID: function () {
    return this.getGamepad().id;
  }
});


/**
 * Flat-shaded ocean primitive.
 *
 * Based on a Codrops tutorial:
 * http://tympanus.net/codrops/2016/04/26/the-aviator-animating-basic-3d-scene-threejs/
 */
module.exports.Primitive = AFRAME.registerPrimitive('a-ocean', {
  defaultComponents: {
    ocean: {},
    rotation: {x: -90, y: 0, z: 0}
  },
  mappings: {
    width: 'ocean.width',
    depth: 'ocean.depth',
    density: 'ocean.density',
    amplitude: 'ocean.amplitude',
    amplitudeVariance: 'ocean.amplitudeVariance',
    speed: 'ocean.speed',
    speedVariance: 'ocean.speedVariance',
    color: 'ocean.color',
    opacity: 'ocean.opacity'
  }
});

module.exports.Component = AFRAME.registerComponent('ocean', {
  schema: {
    // Dimensions of the ocean area.
    width: {default: 10, min: 0},
    depth: {default: 10, min: 0},

    // Density of waves.
    density: {default: 10},

    // Wave amplitude and variance.
    amplitude: {default: 0.1},
    amplitudeVariance: {default: 0.3},

    // Wave speed and variance.
    speed: {default: 1},
    speedVariance: {default: 2},

    // Material.
    color: {default: '#7AD2F7', type: 'color'},
    opacity: {default: 0.8}
  },

  /**
   * Use play() instead of init(), because component mappings – unavailable as dependencies – are
   * not guaranteed to have parsed when this component is initialized.
   */
  play: function () {
    const el = this.el,
        data = this.data;
    let material = el.components.material;

    const geometry = new THREE.PlaneGeometry(data.width, data.depth, data.density, data.density);
    geometry.mergeVertices();
    this.waves = [];
    for (let v, i = 0, l = geometry.vertices.length; i < l; i++) {
      v = geometry.vertices[i];
      this.waves.push({
        z: v.z,
        ang: Math.random() * Math.PI * 2,
        amp: data.amplitude + Math.random() * data.amplitudeVariance,
        speed: (data.speed + Math.random() * data.speedVariance) / 1000 // radians / frame
      });
    }

    if (!material) {
      material = {};
      material.material = new THREE.MeshPhongMaterial({
        color: data.color,
        transparent: data.opacity < 1,
        opacity: data.opacity,
        shading: THREE.FlatShading,
      });
    }

    this.mesh = new THREE.Mesh(geometry, material.material);
    el.setObject3D('mesh', this.mesh);
  },

  remove: function () {
    this.el.removeObject3D('mesh');
  },

  tick: function (t, dt) {
    if (!dt) return;

    const verts = this.mesh.geometry.vertices;
    for (let v, vprops, i = 0; (v = verts[i]); i++){
      vprops = this.waves[i];
      v.z = vprops.z + Math.sin(vprops.ang) * vprops.amp;
      vprops.ang += vprops.speed * dt;
    }
    this.mesh.geometry.verticesNeedUpdate = true;
  }
});


/**
 *
 *
 * @author Jerry Bendy <jerry@icewingcc.com>
 * @licence MIT
 *
 */

(function(self) {
    'use strict';

    var nativeURLSearchParams = (self.URLSearchParams && self.URLSearchParams.prototype.get) ? self.URLSearchParams : null,
        isSupportObjectConstructor = nativeURLSearchParams && (new nativeURLSearchParams({a: 1})).toString() === 'a=1',
        // There is a bug in safari 10.1 (and earlier) that incorrectly decodes `%2B` as an empty space and not a plus.
        decodesPlusesCorrectly = nativeURLSearchParams && (new nativeURLSearchParams('s=%2B').get('s') === '+'),
        __URLSearchParams__ = "__URLSearchParams__",
        // Fix bug in Edge which cannot encode ' &' correctly
        encodesAmpersandsCorrectly = nativeURLSearchParams ? (function() {
            var ampersandTest = new nativeURLSearchParams();
            ampersandTest.append('s', ' &');
            return ampersandTest.toString() === 's=+%26';
        })() : true,
        prototype = URLSearchParamsPolyfill.prototype,
        iterable = !!(self.Symbol && self.Symbol.iterator);

    if (nativeURLSearchParams && isSupportObjectConstructor && decodesPlusesCorrectly && encodesAmpersandsCorrectly) {
        return;
    }

    /**
     * Make a URLSearchParams instance
     *
     * @param {object|string|URLSearchParams} search
     * @constructor
     */
    function URLSearchParamsPolyfill(search) {
        search = search || "";

        // support construct object with another URLSearchParams instance
        if (search instanceof URLSearchParams || search instanceof URLSearchParamsPolyfill) {
            search = search.toString();
        }
        this [__URLSearchParams__] = parseToDict(search);
    }

    /**
     * Appends a specified key/value pair as a new search parameter.
     *
     * @param {string} name
     * @param {string} value
     */
    prototype.append = function(name, value) {
        appendTo(this [__URLSearchParams__], name, value);
    };

    /**
     * Deletes the given search parameter, and its associated value,
     * from the list of all search parameters.
     *
     * @param {string} name
     */
    prototype['delete'] = function(name) {
        delete this [__URLSearchParams__] [name];
    };

    /**
     * Returns the first value associated to the given search parameter.
     *
     * @param {string} name
     * @returns {string|null}
     */
    prototype.get = function(name) {
        var dict = this [__URLSearchParams__];
        return name in dict ? dict[name][0] : null;
    };

    /**
     * Returns all the values association with a given search parameter.
     *
     * @param {string} name
     * @returns {Array}
     */
    prototype.getAll = function(name) {
        var dict = this [__URLSearchParams__];
        return name in dict ? dict [name].slice(0) : [];
    };

    /**
     * Returns a Boolean indicating if such a search parameter exists.
     *
     * @param {string} name
     * @returns {boolean}
     */
    prototype.has = function(name) {
        return name in this [__URLSearchParams__];
    };

    /**
     * Sets the value associated to a given search parameter to
     * the given value. If there were several values, delete the
     * others.
     *
     * @param {string} name
     * @param {string} value
     */
    prototype.set = function set(name, value) {
        this [__URLSearchParams__][name] = ['' + value];
    };

    /**
     * Returns a string containg a query string suitable for use in a URL.
     *
     * @returns {string}
     */
    prototype.toString = function() {
        var dict = this[__URLSearchParams__], query = [], i, key, name, value;
        for (key in dict) {
            name = encode(key);
            for (i = 0, value = dict[key]; i < value.length; i++) {
                query.push(name + '=' + encode(value[i]));
            }
        }
        return query.join('&');
    };

    // There is a bug in Safari 10.1 and `Proxy`ing it is not enough.
    var forSureUsePolyfill = !decodesPlusesCorrectly;
    var useProxy = (!forSureUsePolyfill && nativeURLSearchParams && !isSupportObjectConstructor && self.Proxy)
    /*
     * Apply polifill to global object and append other prototype into it
     */
    Object.defineProperty(self, 'URLSearchParams', {
        value: (useProxy ?
            // Safari 10.0 doesn't support Proxy, so it won't extend URLSearchParams on safari 10.0
            new Proxy(nativeURLSearchParams, {
                construct: function(target, args) {
                    return new target((new URLSearchParamsPolyfill(args[0]).toString()));
                }
            }) :
            URLSearchParamsPolyfill)
    });

    var USPProto = self.URLSearchParams.prototype;

    USPProto.polyfill = true;

    /**
     *
     * @param {function} callback
     * @param {object} thisArg
     */
    USPProto.forEach = USPProto.forEach || function(callback, thisArg) {
        var dict = parseToDict(this.toString());
        Object.getOwnPropertyNames(dict).forEach(function(name) {
            dict[name].forEach(function(value) {
                callback.call(thisArg, value, name, this);
            }, this);
        }, this);
    };

    /**
     * Sort all name-value pairs
     */
    USPProto.sort = USPProto.sort || function() {
        var dict = parseToDict(this.toString()), keys = [], k, i, j;
        for (k in dict) {
            keys.push(k);
        }
        keys.sort();

        for (i = 0; i < keys.length; i++) {
            this['delete'](keys[i]);
        }
        for (i = 0; i < keys.length; i++) {
            var key = keys[i], values = dict[key];
            for (j = 0; j < values.length; j++) {
                this.append(key, values[j]);
            }
        }
    };

    /**
     * Returns an iterator allowing to go through all keys of
     * the key/value pairs contained in this object.
     *
     * @returns {function}
     */
    USPProto.keys = USPProto.keys || function() {
        var items = [];
        this.forEach(function(item, name) {
            items.push(name);
        });
        return makeIterator(items);
    };

    /**
     * Returns an iterator allowing to go through all values of
     * the key/value pairs contained in this object.
     *
     * @returns {function}
     */
    USPProto.values = USPProto.values || function() {
        var items = [];
        this.forEach(function(item) {
            items.push(item);
        });
        return makeIterator(items);
    };

    /**
     * Returns an iterator allowing to go through all key/value
     * pairs contained in this object.
     *
     * @returns {function}
     */
    USPProto.entries = USPProto.entries || function() {
        var items = [];
        this.forEach(function(item, name) {
            items.push([name, item]);
        });
        return makeIterator(items);
    };

    if (iterable) {
        USPProto[self.Symbol.iterator] = USPProto[self.Symbol.iterator] || USPProto.entries;
    }

    function encode(str) {
        var replace = {
            '!': '%21',
            "'": '%27',
            '(': '%28',
            ')': '%29',
            '~': '%7E',
            '%20': '+',
            '%00': '\x00'
        };
        return encodeURIComponent(str).replace(/[!'\(\)~]|%20|%00/g, function(match) {
            return replace[match];
        });
    }

    function decode(str) {
        return str
            .replace(/[ +]/g, '%20')
            .replace(/(%[a-f0-9]{2})+/ig, function(match) {
                return decodeURIComponent(match);
            });
    }

    function makeIterator(arr) {
        var iterator = {
            next: function() {
                var value = arr.shift();
                return {done: value === undefined, value: value};
            }
        };

        if (iterable) {
            iterator[self.Symbol.iterator] = function() {
                return iterator;
            };
        }

        return iterator;
    }

    function parseToDict(search) {
        var dict = {};

        if (typeof search === "object") {
            for (var key in search) {
                if (search.hasOwnProperty(key)) {
                    appendTo(dict, key, search[key])
                }
            }

        } else {
            // remove first '?'
            if (search.indexOf("?") === 0) {
                search = search.slice(1);
            }

            var pairs = search.split("&");
            for (var j = 0; j < pairs.length; j++) {
                var value = pairs [j],
                    index = value.indexOf('=');

                if (-1 < index) {
                    appendTo(dict, decode(value.slice(0, index)), decode(value.slice(index + 1)));

                } else {
                    if (value) {
                        appendTo(dict, decode(value), '');
                    }
                }
            }
        }

        return dict;
    }

    function appendTo(dict, name, value) {
        var val = typeof value === 'string' ? value : (
            value !== null && value !== undefined && typeof value.toString === 'function' ? value.toString() : JSON.stringify(value)
        )

        if (name in dict) {
            dict[name].push(val);
        } else {
            dict[name] = [val];
        }
    }

})(typeof global !== 'undefined' ? global : (typeof window !== 'undefined' ? window : this));


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert-plus');
var util = require('util');

var asn1 = require('asn1');

var dtrace = require('../dtrace');
var LDAPMessage = require('./message');
var Protocol = require('../protocol');

///--- Globals

var Ber = asn1.Ber;
var BerWriter = asn1.BerWriter;

///--- API

function LDAPResult(options) {
  options = options || {};
  assert.object(options);
  assert.optionalNumber(options.status);
  assert.optionalString(options.matchedDN);
  assert.optionalString(options.errorMessage);
  assert.optionalArrayOfString(options.referrals);

  LDAPMessage.call(this, options);

  this.status = options.status || 0; // LDAP SUCCESS
  this.matchedDN = options.matchedDN || '';
  this.errorMessage = options.errorMessage || '';
  this.referrals = options.referrals || [];

  this.connection = options.connection || null;
}
util.inherits(LDAPResult, LDAPMessage);
Object.defineProperties(LDAPResult.prototype, {
  type: {
    get: function getType() { return 'LDAPResult'; },
    configurable: false
  }
});

LDAPResult.prototype.end = function (status) {
  assert.ok(this.connection);

  if (typeof (status) === 'number')
    this.status = status;

  var ber = this.toBer();
  if (this.log.debug())
    this.log.debug('%s: sending:  %j', this.connection.ldap.id, this.json);

  try {
    var self = this;
    this.connection.write(ber);

    if (self._dtraceOp && self._dtraceId) {
      dtrace.fire('server-' + self._dtraceOp + '-done', function () {
        var c = self.connection || {ldap: {}};
        return [
          self._dtraceId || 0,
          (c.remoteAddress || ''),
          c.ldap.bindDN ? c.ldap.bindDN.toString() : '',
          (self.requestDN ? self.requestDN.toString() : ''),
          status || self.status,
          self.errorMessage
        ];
      });
    }

  } catch (e) {
    this.log.warn(e, '%s failure to write message %j',
                  this.connection.ldap.id, this.json);
  }

};

LDAPResult.prototype._parse = function (ber) {
  assert.ok(ber);

  this.status = ber.readEnumeration();
  this.matchedDN = ber.readString();
  this.errorMessage = ber.readString();

  var t = ber.peek();

  if (t === Protocol.LDAP_REP_REFERRAL) {
    var end = ber.offset + ber.length;
    while (ber.offset < end)
      this.referrals.push(ber.readString());
  }

  return true;
};

LDAPResult.prototype._toBer = function (ber) {
  assert.ok(ber);

  ber.writeEnumeration(this.status);
  ber.writeString(this.matchedDN || '');
  ber.writeString(this.errorMessage || '');

  if (this.referrals.length) {
    ber.startSequence(Protocol.LDAP_REP_REFERRAL);
    ber.writeStringArray(this.referrals);
    ber.endSequence();
  }

  return ber;
};

LDAPResult.prototype._json = function (j) {
  assert.ok(j);

  j.status = this.status;
  j.matchedDN = this.matchedDN;
  j.errorMessage = this.errorMessage;
  j.referrals = this.referrals;

  return j;
};

///--- Exports

module.exports = LDAPResult;


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert-plus');
var util = require('util');

var LDAPResult = require('./result');
var Protocol = require('../protocol');

///--- API

function BindResponse(options) {
  options = options || {};
  assert.object(options);

  options.protocolOp = Protocol.LDAP_REP_BIND;
  LDAPResult.call(this, options);
}
util.inherits(BindResponse, LDAPResult);

///--- Exports

module.exports = BindResponse;


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert-plus');

var Attribute = require('./attribute');
var Protocol = require('./protocol');

///--- API

function Change(options) {
  if (options) {
    assert.object(options);
    assert.optionalString(options.operation);
  } else {
    options = {};
  }

  this._modification = false;
  this.operation = options.operation || options.type || 'add';
  this.modification = options.modification || {};
}
Object.defineProperties(Change.prototype, {
  operation: {
    get: function getOperation() {
      switch (this._operation) {
      case 0x00: return 'add';
      case 0x01: return 'delete';
      case 0x02: return 'replace';
      default:
        throw new Error('0x' + this._operation.toString(16) + ' is invalid');
      }
    },
    set: function setOperation(val) {
      assert.string(val);
      switch (val.toLowerCase()) {
      case 'add':
        this._operation = 0x00;
        break;
      case 'delete':
        this._operation = 0x01;
        break;
      case 'replace':
        this._operation = 0x02;
        break;
      default:
        throw new Error('Invalid operation type: 0x' + val.toString(16));
      }
    },
    configurable: false
  },
  modification: {
    get: function getModification() {
      return this._modification;
    },
    set: function setModification(val) {
      if (Attribute.isAttribute(val)) {
        this._modification = val;
        return;
      }
      // Does it have an attribute-like structure
      if (Object.keys(val).length == 2 &&
          typeof (val.type) === 'string' &&
          Array.isArray(val.vals)) {
        this._modification = new Attribute({
          type: val.type,
          vals: val.vals
        });
        return;
      }

      var keys = Object.keys(val);
      if (keys.length > 1) {
        throw new Error('Only one attribute per Change allowed');
      } else if (keys.length === 0) {
        return;
      }

      var k = keys[0];
      var _attr = new Attribute({type: k});
      if (Array.isArray(val[k])) {
        val[k].forEach(function (v) {
          _attr.addValue(v.toString());
        });
      } else {
        _attr.addValue(val[k].toString());
      }
      this._modification = _attr;
    },
    configurable: false
  },
  json: {
    get: function getJSON() {
      return {
        operation: this.operation,
        modification: this._modification ? this._modification.json : {}
      };
    },
    configurable: false
  }
});

Change.isChange = function isChange(change) {
  if (!change || typeof (change) !== 'object') {
    return false;
  }
  if ((change instanceof Change) ||
      ((typeof (change.toBer) === 'function') &&
      (change.modification !== undefined) &&
      (change.operation !== undefined))) {
    return true;
  }
  return false;
};

Change.compare = function (a, b) {
  if (!Change.isChange(a) || !Change.isChange(b))
    throw new TypeError('can only compare Changes');

  if (a.operation < b.operation)
    return -1;
  if (a.operation > b.operation)
    return 1;

  return Attribute.compare(a.modification, b.modification);
};

/**
 * Apply a Change to properties of an object.
 *
 * @param {Object} change the change to apply.
 * @param {Object} obj the object to apply it to.
 * @param {Boolean} scalar convert single-item arrays to scalars. Default: false
 */
Change.apply = function apply(change, obj, scalar) {
  assert.string(change.operation);
  assert.string(change.modification.type);
  assert.ok(Array.isArray(change.modification.vals));
  assert.object(obj);

  var type = change.modification.type;
  var vals = change.modification.vals;
  var data = obj[type];
  if (data !== undefined) {
    if (!Array.isArray(data)) {
      data = [data];
    }
  } else {
    data = [];
  }
  switch (change.operation) {
  case 'replace':
    if (vals.length === 0) {
      // replace empty is a delete
      delete obj[type];
      return obj;
    } else {
      data = vals;
    }
    break;
  case 'add':
    // add only new unique entries
    var newValues = vals.filter(function (entry) {
      return (data.indexOf(entry) === -1);
    });
    data = data.concat(newValues);
    break;
  case 'delete':
    data = data.filter(function (entry) {
      return (vals.indexOf(entry) === -1);
    });
    if (data.length === 0) {
      // Erase the attribute if empty
      delete obj[type];
      return obj;
    }
    break;
  default:
    break;
  }
  if (scalar && data.length === 1) {
    // store single-value outputs as scalars, if requested
    obj[type] = data[0];
  } else {
    obj[type] = data;
  }
  return obj;
};

Change.prototype.parse = function (ber) {
  assert.ok(ber);

  ber.readSequence();
  this._operation = ber.readEnumeration();
  this._modification = new Attribute();
  this._modification.parse(ber);

  return true;
};

Change.prototype.toBer = function (ber) {
  assert.ok(ber);

  ber.startSequence();
  ber.writeEnumeration(this._operation);
  ber = this._modification.toBer(ber);
  ber.endSequence();

  return ber;
};

///--- Exports

module.exports = Change;


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert-plus');
var util = require('util');

var LDAPResult = require('./result');
var Protocol = require('../protocol');

///--- API

function DeleteResponse(options) {
  options = options || {};
  assert.object(options);

  options.protocolOp = Protocol.LDAP_REP_DELETE;
  LDAPResult.call(this, options);
}
util.inherits(DeleteResponse, LDAPResult);

///--- Exports

module.exports = DeleteResponse;


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert-plus');
var util = require('util');

var asn1 = require('asn1');

var Protocol = require('../protocol');

///--- Globals

var Ber = asn1.Ber;

///--- API

function Control(options) {
  assert.optionalObject(options);
  options = options || {};
  assert.optionalString(options.type);
  assert.optionalBool(options.criticality);
  if (options.value) {
    assert.buffer(options.value);
  }

  this.type = options.type || '';
  this.criticality = options.critical || options.criticality || false;
  this.value = options.value || null;
}
Object.defineProperties(Control.prototype, {
  json: {
    get: function getJson() {
      var obj = {
        controlType: this.type,
        criticality: this.criticality,
        controlValue: this.value
      };
      return (typeof (this._json) === 'function' ? this._json(obj) : obj);
    }
  }
});

Control.prototype.toBer = function toBer(ber) {
  assert.ok(ber);

  ber.startSequence();
  ber.writeString(this.type || '');
  ber.writeBoolean(this.criticality);
  if (typeof (this._toBer) === 'function') {
    this._toBer(ber);
  } else {
    if (this.value)
      ber.writeString(this.value);
  }

  ber.endSequence();
  return;
};

Control.prototype.toString = function toString() {
  return this.json;
};

///--- Exports
module.exports = Control;


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert-plus');
var util = require('util');

var LDAPMessage = require('./message');
var dn = require('../dn');
var Protocol = require('../protocol');

///--- Globals

var DN = dn.DN;
var RDN = dn.RDN;

///--- API

function UnbindRequest(options) {
  options = options || {};
  assert.object(options);

  options.protocolOp = Protocol.LDAP_REQ_UNBIND;
  LDAPMessage.call(this, options);
}
util.inherits(UnbindRequest, LDAPMessage);
Object.defineProperties(UnbindRequest.prototype, {
  type: {
    get: function getType() { return 'UnbindRequest'; },
    configurable: false
  },
  _dn: {
    get: function getDN() {
      if (this.connection) {
        return this.connection.ldap.bindDN;
      } else {
        return new DN([new RDN({cn: 'anonymous'})]);
      }
    },
    configurable: false
  }
});

UnbindRequest.prototype._parse = function (ber) {
  assert.ok(ber);

  return true;
};

UnbindRequest.prototype._toBer = function (ber) {
  assert.ok(ber);

  return ber;
};

UnbindRequest.prototype._json = function (j) {
  assert.ok(j);

  return j;
};

///--- Exports

module.exports = UnbindRequest;


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert-plus');
var util = require('util');

var LDAPResult = require('./result');
var SearchEntry = require('./search_entry');
var SearchReference = require('./search_reference');

var dtrace = require('../dtrace');
var parseDN = require('../dn').parse;
var parseURL = require('../url').parse;
var Protocol = require('../protocol');

///--- API

function SearchResponse(options) {
  options = options || {};
  assert.object(options);

  options.protocolOp = Protocol.LDAP_REP_SEARCH;
  LDAPResult.call(this, options);

  this.attributes = options.attributes ? options.attributes.slice() : [];
  this.notAttributes = [];
  this.sentEntries = 0;
}
util.inherits(SearchResponse, LDAPResult);

/**
 * Allows you to send a SearchEntry back to the client.
 *
 * @param {Object} entry an instance of SearchEntry.
 * @param {Boolean} nofiltering skip filtering notAttributes and '_' attributes.
 *                  Defaults to 'false'.
 */
SearchResponse.prototype.send = function (entry, nofiltering) {
  if (!entry || typeof (entry) !== 'object')
    throw new TypeError('entry (SearchEntry) required');
  if (nofiltering === undefined)
    nofiltering = false;
  if (typeof (nofiltering) !== 'boolean')
    throw new TypeError('noFiltering must be a boolean');

  var self = this;

  if (entry instanceof SearchEntry || entry instanceof SearchReference) {
    if (!entry.messageID)
      entry.messageID = this.messageID;
    if (entry.messageID !== this.messageID)
      throw new Error('SearchEntry messageID mismatch');
  } else {
    if (!entry.attributes)
      throw new Error('entry.attributes required');

    var savedAttrs = {};
    var all = (self.attributes.indexOf('*') !== -1);
    Object.keys(entry.attributes).forEach(function (a) {
      var _a = a.toLowerCase();
      if (!nofiltering && _a.length && _a[0] === '_') {
        savedAttrs[a] = entry.attributes[a];
        delete entry.attributes[a];
      } else if (!nofiltering && self.notAttributes.indexOf(_a) !== -1) {
        savedAttrs[a] = entry.attributes[a];
        delete entry.attributes[a];
      } else if (all) {
        return;
      } else if (self.attributes.length && self.attributes.indexOf(_a) === -1) {
        savedAttrs[a] = entry.attributes[a];
        delete entry.attributes[a];
      }
    });

    var save = entry;
    entry = new SearchEntry({
      objectName: typeof (save.dn) === 'string' ? parseDN(save.dn) : save.dn,
      messageID: self.messageID,
      log: self.log
    });
    entry.fromObject(save);
  }

  try {
    if (this.log.debug())
      this.log.debug('%s: sending:  %j', this.connection.ldap.id, entry.json);

    this.connection.write(entry.toBer());
    this.sentEntries++;

    if (self._dtraceOp && self._dtraceId) {
      dtrace.fire('server-search-entry', function () {
        var c = self.connection || {ldap: {}};
        return [
          self._dtraceId || 0,
          (c.remoteAddress || ''),
          c.ldap.bindDN ? c.ldap.bindDN.toString() : '',
          (self.requestDN ? self.requestDN.toString() : ''),
          entry.objectName.toString(),
          entry.attributes.length
        ];
      });
    }

    // Restore attributes
    Object.keys(savedAttrs || {}).forEach(function (k) {
      save.attributes[k] = savedAttrs[k];
    });

  } catch (e) {
    this.log.warn(e, '%s failure to write message %j',
                  this.connection.ldap.id, this.json);
  }
};

SearchResponse.prototype.createSearchEntry = function (object) {
  assert.object(object);

  var entry = new SearchEntry({
    messageID: this.messageID,
    log: this.log,
    objectName: object.objectName || object.dn
  });
  entry.fromObject((object.attributes || object));
  return entry;
};

SearchResponse.prototype.createSearchReference = function (uris) {
  if (!uris)
    throw new TypeError('uris ([string]) required');

  if (!Array.isArray(uris))
    uris = [uris];

  for (var i = 0; i < uris.length; i++) {
    if (typeof (uris[i]) == 'string')
      uris[i] = parseURL(uris[i]);
  }

  var self = this;
  return new SearchReference({
    messageID: self.messageID,
    log: self.log,
    uris: uris
  });
};

///--- Exports

module.exports = SearchResponse;


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert-plus');
var util = require('util');

var LDAPResult = require('./result');
var Protocol = require('../protocol');

///--- API

function ModifyResponse(options) {
  options = options || {};
  assert.object(options);

  options.protocolOp = Protocol.LDAP_REP_MODIFY;
  LDAPResult.call(this, options);
}
util.inherits(ModifyResponse, LDAPResult);

///--- Exports

module.exports = ModifyResponse;


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var EventEmitter = require('events').EventEmitter;
var net = require('net');
var tls = require('tls');
var util = require('util');

var once = require('once');
var backoff = require('backoff');
var vasync = require('vasync');
var assert = require('assert-plus');
var VError = require('verror').VError;

var Attribute = require('../attribute');
var Change = require('../change');
var Control = require('../controls/index').Control;
var SearchPager = require('./search_pager');
var Protocol = require('../protocol');
var dn = require('../dn');
var errors = require('../errors');
var filters = require('../filters');
var messages = require('../messages');
var url = require('../url');

///--- Globals

var AbandonRequest = messages.AbandonRequest;
var AddRequest = messages.AddRequest;
var BindRequest = messages.BindRequest;
var CompareRequest = messages.CompareRequest;
var DeleteRequest = messages.DeleteRequest;
var ExtendedRequest = messages.ExtendedRequest;
var ModifyRequest = messages.ModifyRequest;
var ModifyDNRequest = messages.ModifyDNRequest;
var SearchRequest = messages.SearchRequest;
var UnbindRequest = messages.UnbindRequest;
var UnbindResponse = messages.UnbindResponse;

var LDAPResult = messages.LDAPResult;
var SearchEntry = messages.SearchEntry;
var SearchReference = messages.SearchReference;
var SearchResponse = messages.SearchResponse;
var Parser = messages.Parser;

var PresenceFilter = filters.PresenceFilter;

var ConnectionError = errors.ConnectionError;

var CMP_EXPECT = [errors.LDAP_COMPARE_TRUE, errors.LDAP_COMPARE_FALSE];
var MAX_MSGID = Math.pow(2, 31) - 1;

// node 0.6 got rid of FDs, so make up a client id for logging
var CLIENT_ID = 0;

///--- Internal Helpers

function nextClientId() {
  if (++CLIENT_ID === MAX_MSGID)
    return 1;

  return CLIENT_ID;
}

function validateControls(controls) {
  if (Array.isArray(controls)) {
    controls.forEach(function (c) {
      if (!(c instanceof Control))
        throw new TypeError('controls must be [Control]');
    });
  } else if (controls instanceof Control) {
    controls = [controls];
  } else {
    throw new TypeError('controls must be [Control]');
  }

  return controls;
}

function ensureDN(input, strict) {
  if (dn.DN.isDN(input)) {
    return dn;
  } else if (strict) {
    return dn.parse(input);
  } else if (typeof (input) === 'string') {
    return input;
  } else {
    throw new Error('invalid DN');
  }
}

/**
 * Queue to contain LDAP requests.
 *
 * @param {Object} opts queue options
 *
 * Accepted Options:
 * - size: Maximum queue size
 * - timeout: Set timeout between first queue insertion and queue flush.
 */
function RequestQueue(opts) {
  if (!opts || typeof (opts) !== 'object') {
    opts = {};
  }
  this.size = (opts.size > 0) ? opts.size : Infinity;
  this.timeout = (opts.timeout > 0) ? opts.timeout : 0;
  this._queue = [];
  this._timer = null;
  this._frozen = false;
}

/**
 * Insert request into queue.
 *
 */
RequestQueue.prototype.enqueue = function enqueue(msg, expect, emitter, cb) {
  if (this._queue.length >= this.size || this._frozen) {
    return false;
  }
  var self = this;
  this._queue.push([msg, expect, emitter, cb]);
  if (this.timeout > 0) {
    if (this._timer !== null) {
      this._timer = setTimeout(function () {
          // If queue times out, don't allow new entries until thawed
          self.freeze();
          self.purge();
      }, this.timeout);
    }
  }
  return true;
};

/**
 * Process all queued requests with callback.
 */
RequestQueue.prototype.flush = function flush(cb) {
  if (this._timer) {
    clearTimeout(this._timer);
    this._timer = null;
  }
  var items = this._queue;
  this._queue = [];
  items.forEach(function (req) {
    cb(req[0], req[1], req[2], req[3]);
  });
};

/**
 * Purge all queued requests with an error.
 */
RequestQueue.prototype.purge = function purge() {
  this.flush(function (msg, expect, emitter, cb) {
    cb(new errors.TimeoutError('request queue timeout'));
  });
};

/**
 * Freeze queue, refusing any new entries.
 */
RequestQueue.prototype.freeze = function freeze() {
  this._frozen = true;
};

/**
 * Thaw queue, allowing new entries again.
 */
RequestQueue.prototype.thaw = function thaw() {
  this._frozen = false;
};

/**
 * Track message callback by messageID.
 */
function MessageTracker(opts) {
  assert.object(opts);
  assert.string(opts.id);
  assert.object(opts.parser);

  this.id = opts.id;
  this._msgid = 0;
  this._messages = {};
  this._abandoned = {};
  this.parser = opts.parser;

  var self = this;
  this.__defineGetter__('pending', function () {
    return Object.keys(self._messages);
  });
}

/**
 * Record a messageID and callback.
 */
MessageTracker.prototype.track = function track(message, callback) {
  var msgid = this._nextID();
  message.messageID = msgid;
  this._messages[msgid] = callback;
  return msgid;
};

/**
 * Fetch callback based on messageID.
 */
MessageTracker.prototype.fetch = function fetch(msgid) {
  var msg = this._messages[msgid];
  if (msg) {
    this._purgeAbandoned(msgid);
    return msg;
  }
  // It's possible that the server has not received the abandon request yet.
  // While waiting for evidence that the abandon has been received, incoming
  // messages that match the abandoned msgid will be handled as normal.
  msg = this._abandoned[msgid];
  if (msg) {
    return msg.cb;
  }
  return null;
};

/**
 * Cease tracking for a given messageID.
 */
MessageTracker.prototype.remove = function remove(msgid) {
  if (this._messages[msgid]) {
    delete this._messages[msgid];
  } else if (this._abandoned[msgid]) {
    delete this._abandoned[msgid];
  }
};

/**
 * Mark a messageID as abandoned.
 */
MessageTracker.prototype.abandon = function abandonMsg(msgid) {
  if (this._messages[msgid]) {
    // Keep track of "when" the message was abandoned
    this._abandoned[msgid] = {
      age: this._msgid,
      cb: this._messages[msgid]
    };
    delete this._messages[msgid];
  }
};

/**
 * Purge old items from abandoned list.
 */
MessageTracker.prototype._purgeAbandoned = function _purgeAbandoned(msgid) {
  var self = this;
  // Is (comp >= ref) according to sliding window
  function geWindow(ref, comp) {
    var max = ref + (MAX_MSGID/2);
    var min = ref;
    if (max >= MAX_MSGID) {
      // Handle roll-over
      max = max - MAX_MSGID - 1;
      return ((comp <= max) || (comp >= min));
    } else {
      return ((comp <= max) && (comp >= min));
    }
  }

  Object.keys(this._abandoned).forEach(function (id) {
    // Abandoned messageIDs can be forgotten if a received messageID is "newer"
    if (geWindow(self._abandoned[id].age, msgid)) {
      self._abandoned[id].cb(new errors.AbandonedError(
        'client request abandoned'));
      delete self._abandoned[id];
    }
  });
};

/**
 * Allocate the next messageID according to a sliding window.
 */
MessageTracker.prototype._nextID = function _nextID() {
  if (++this._msgid >= MAX_MSGID)
    this._msgid = 1;

  return this._msgid;
};

///--- API

/**
 * Constructs a new client.
 *
 * The options object is required, and must contain either a URL (string) or
 * a socketPath (string); the socketPath is only if you want to talk to an LDAP
 * server over a Unix Domain Socket.  Additionally, you can pass in a bunyan
 * option that is the result of `new Logger()`, presumably after you've
 * configured it.
 *
 * @param {Object} options must have either url or socketPath.
 * @throws {TypeError} on bad input.
 */
function Client(options) {
  assert.ok(options);

  EventEmitter.call(this, options);

  var self = this;
  var _url;
  if (options.url)
    _url = url.parse(options.url);
  this.host = _url ? _url.hostname : undefined;
  this.port = _url ? _url.port : false;
  this.secure = _url ? _url.secure : false;
  this.url = _url;
  this.tlsOptions = options.tlsOptions;
  this.socketPath = options.socketPath || false;

  this.log = options.log.child({clazz: 'Client'}, true);

  this.timeout = parseInt((options.timeout || 0), 10);
  this.connectTimeout = parseInt((options.connectTimeout || 0), 10);
  this.idleTimeout = parseInt((options.idleTimeout || 0), 10);
  if (options.reconnect) {
    // Fall back to defaults if options.reconnect === true
    var rOpts = (typeof (options.reconnect) === 'object') ?
      options.reconnect : {};
    this.reconnect = {
      initialDelay: parseInt(rOpts.initialDelay || 100, 10),
      maxDelay: parseInt(rOpts.maxDelay || 10000, 10),
      failAfter: parseInt(rOpts.failAfter, 10) || Infinity
    };
  }
  this.strictDN = (options.strictDN !== undefined) ? options.strictDN : true;

  this.queue = new RequestQueue({
    size: parseInt((options.queueSize || 0), 10),
    timeout: parseInt((options.queueTimeout || 0), 10)
  });
  if (options.queueDisable) {
    this.queue.freeze();
  }

  // Implicitly configure setup action to bind the client if bindDN and
  // bindCredentials are passed in.  This will more closely mimic PooledClient
  // auto-login behavior.
  if (options.bindDN !== undefined &&
      options.bindCredentials !== undefined) {
    this.on('setup', function (clt, cb) {
      clt.bind(options.bindDN, options.bindCredentials, function (err) {
        if (err) {
          self.emit('error', err);
        }
        cb(err);
      });
    });
  }

  this._socket = null;
  this.connected = false;
  this.connect();
}
util.inherits(Client, EventEmitter);
module.exports = Client;

/**
 * Sends an abandon request to the LDAP server.
 *
 * The callback will be invoked as soon as the data is flushed out to the
 * network, as there is never a response from abandon.
 *
 * @param {Number} messageID the messageID to abandon.
 * @param {Control} controls (optional) either a Control or [Control].
 * @param {Function} callback of the form f(err).
 * @throws {TypeError} on invalid input.
 */
Client.prototype.abandon = function abandon(messageID, controls, callback) {
  assert.number(messageID, 'messageID');
  if (typeof (controls) === 'function') {
    callback = controls;
    controls = [];
  } else {
    controls = validateControls(controls);
  }
  assert.func(callback, 'callback');

  var req = new AbandonRequest({
    abandonID: messageID,
    controls: controls
  });

  return this._send(req, 'abandon', null, callback);
};

/**
 * Adds an entry to the LDAP server.
 *
 * Entry can be either [Attribute] or a plain JS object where the
 * values are either a plain value or an array of values.  Any value (that's
 * not an array) will get converted to a string, so keep that in mind.
 *
 * @param {String} name the DN of the entry to add.
 * @param {Object} entry an array of Attributes to be added or a JS object.
 * @param {Control} controls (optional) either a Control or [Control].
 * @param {Function} callback of the form f(err, res).
 * @throws {TypeError} on invalid input.
 */
Client.prototype.add = function add(name, entry, controls, callback) {
  assert.ok(name !== undefined, 'name');
  assert.object(entry, 'entry');
  if (typeof (controls) === 'function') {
    callback = controls;
    controls = [];
  } else {
    controls = validateControls(controls);
  }
  assert.func(callback, 'callback');

  if (Array.isArray(entry)) {
    entry.forEach(function (a) {
      if (!Attribute.isAttribute(a))
        throw new TypeError('entry must be an Array of Attributes');
    });
  } else {
    var save = entry;

    entry = [];
    Object.keys(save).forEach(function (k) {
      var attr = new Attribute({type: k});
      if (Array.isArray(save[k])) {
        save[k].forEach(function (v) {
          attr.addValue(v.toString());
        });
      } else {
        attr.addValue(save[k].toString());
      }
      entry.push(attr);
    });
  }

  var req = new AddRequest({
    entry: ensureDN(name, this.strictDN),
    attributes: entry,
    controls: controls
  });

  return this._send(req, [errors.LDAP_SUCCESS], null, callback);
};

/**
 * Performs a simple authentication against the server.
 *
 * @param {String} name the DN to bind as.
 * @param {String} credentials the userPassword associated with name.
 * @param {Control} controls (optional) either a Control or [Control].
 * @param {Function} callback of the form f(err, res).
 * @throws {TypeError} on invalid input.
 */
Client.prototype.bind = function bind(name,
                                      credentials,
                                      controls,
                                      callback,
                                      _bypass) {
  if (typeof (name) !== 'string' && !(name instanceof dn.DN))
    throw new TypeError('name (string) required');
  assert.optionalString(credentials, 'credentials');
  if (typeof (controls) === 'function') {
    callback = controls;
    controls = [];
  } else {
    controls = validateControls(controls);
  }
  assert.func(callback, 'callback');

  var req = new BindRequest({
    name: name || '',
    authentication: 'Simple',
    credentials: credentials || '',
    controls: controls
  });

  return this._send(req, [errors.LDAP_SUCCESS], null, callback, _bypass);
};

/**
 * Compares an attribute/value pair with an entry on the LDAP server.
 *
 * @param {String} name the DN of the entry to compare attributes with.
 * @param {String} attr name of an attribute to check.
 * @param {String} value value of an attribute to check.
 * @param {Control} controls (optional) either a Control or [Control].
 * @param {Function} callback of the form f(err, boolean, res).
 * @throws {TypeError} on invalid input.
 */
Client.prototype.compare = function compare(name,
                                            attr,
                                            value,
                                            controls,
                                            callback) {
  assert.ok(name !== undefined, 'name');
  assert.string(attr, 'attr');
  assert.string(value, 'value');
  if (typeof (controls) === 'function') {
    callback = controls;
    controls = [];
  } else {
    controls = validateControls(controls);
  }
  assert.func(callback, 'callback');

  var req = new CompareRequest({
    entry: ensureDN(name, this.strictDN),
    attribute: attr,
    value: value,
    controls: controls
  });

  return this._send(req, CMP_EXPECT, null, function (err, res) {
    if (err)
      return callback(err);

    return callback(null, (res.status === errors.LDAP_COMPARE_TRUE), res);
  });
};

/**
 * Deletes an entry from the LDAP server.
 *
 * @param {String} name the DN of the entry to delete.
 * @param {Control} controls (optional) either a Control or [Control].
 * @param {Function} callback of the form f(err, res).
 * @throws {TypeError} on invalid input.
 */
Client.prototype.del = function del(name, controls, callback) {
  assert.ok(name !== undefined, 'name');
  if (typeof (controls) === 'function') {
    callback = controls;
    controls = [];
  } else {
    controls = validateControls(controls);
  }
  assert.func(callback, 'callback');

  var req = new DeleteRequest({
    entry: ensureDN(name, this.strictDN),
    controls: controls
  });

  return this._send(req, [errors.LDAP_SUCCESS], null, callback);
};

/**
 * Performs an extended operation on the LDAP server.
 *
 * Pretty much none of the LDAP extended operations return an OID
 * (responseName), so I just don't bother giving it back in the callback.
 * It's on the third param in `res` if you need it.
 *
 * @param {String} name the OID of the extended operation to perform.
 * @param {String} value value to pass in for this operation.
 * @param {Control} controls (optional) either a Control or [Control].
 * @param {Function} callback of the form f(err, value, res).
 * @throws {TypeError} on invalid input.
 */
Client.prototype.exop = function exop(name, value, controls, callback) {
  assert.string(name, 'name');
  if (typeof (value) === 'function') {
    callback = value;
    controls = [];
    value = '';
  }
  if (!(Buffer.isBuffer(value) || typeof (value) === 'string'))
    throw new TypeError('value (Buffer || string) required');
  if (typeof (controls) === 'function') {
    callback = controls;
    controls = [];
  } else {
    controls = validateControls(controls);
  }
  assert.func(callback, 'callback');

  var req = new ExtendedRequest({
    requestName: name,
    requestValue: value,
    controls: controls
  });

  return this._send(req, [errors.LDAP_SUCCESS], null, function (err, res) {
    if (err)
      return callback(err);

    return callback(null, res.responseValue || '', res);
  });
};

/**
 * Performs an LDAP modify against the server.
 *
 * @param {String} name the DN of the entry to modify.
 * @param {Change} change update to perform (can be [Change]).
 * @param {Control} controls (optional) either a Control or [Control].
 * @param {Function} callback of the form f(err, res).
 * @throws {TypeError} on invalid input.
 */
Client.prototype.modify = function modify(name, change, controls, callback) {
  assert.ok(name !== undefined, 'name');
  assert.object(change, 'change');

  var changes = [];

  function changeFromObject(change) {
    if (!change.operation && !change.type)
      throw new Error('change.operation required');
    if (typeof (change.modification) !== 'object')
      throw new Error('change.modification (object) required');

    if (Object.keys(change.modification).length == 2 &&
        typeof (change.modification.type) === 'string' &&
        Array.isArray(change.modification.vals)) {
      // Use modification directly if it's already normalized:
      changes.push(new Change({
        operation: change.operation || change.type,
        modification: change.modification
      }));
    } else {
      // Normalize the modification object
      Object.keys(change.modification).forEach(function (k) {
        var mod = {};
        mod[k] = change.modification[k];
        changes.push(new Change({
          operation: change.operation || change.type,
          modification: mod
        }));
      });
    }
  }

  if (Change.isChange(change)) {
    changes.push(change);
  } else if (Array.isArray(change)) {
    change.forEach(function (c) {
      if (Change.isChange(c)) {
        changes.push(c);
      } else {
        changeFromObject(c);
      }
    });
  } else {
    changeFromObject(change);
  }

  if (typeof (controls) === 'function') {
    callback = controls;
    controls = [];
  } else {
    controls = validateControls(controls);
  }
  assert.func(callback, 'callback');

  var req = new ModifyRequest({
    object: ensureDN(name, this.strictDN),
    changes: changes,
    controls: controls
  });

  return this._send(req, [errors.LDAP_SUCCESS], null, callback);
};

/**
 * Performs an LDAP modifyDN against the server.
 *
 * This does not allow you to keep the old DN, as while the LDAP protocol
 * has a facility for that, it's stupid. Just Search/Add.
 *
 * This will automatically deal with "new superior" logic.
 *
 * @param {String} name the DN of the entry to modify.
 * @param {String} newName the new DN to move this entry to.
 * @param {Control} controls (optional) either a Control or [Control].
 * @param {Function} callback of the form f(err, res).
 * @throws {TypeError} on invalid input.
 */
Client.prototype.modifyDN = function modifyDN(name,
                                              newName,
                                              controls,
                                              callback) {
  assert.ok(name !== undefined, 'name');
  assert.string(newName, 'newName');
  if (typeof (controls) === 'function') {
    callback = controls;
    controls = [];
  } else {
    controls = validateControls(controls);
  }
  assert.func(callback);

  var DN = ensureDN(name);
  // TODO: is non-strict handling desired here?
  var newDN = dn.parse(newName);

  var req = new ModifyDNRequest({
    entry: DN,
    deleteOldRdn: true,
    controls: controls
  });

  if (newDN.length !== 1) {
    req.newRdn = dn.parse(newDN.rdns.shift().toString());
    req.newSuperior = newDN;
  } else {
    req.newRdn = newDN;
  }

  return this._send(req, [errors.LDAP_SUCCESS], null, callback);
};

/**
 * Performs an LDAP search against the server.
 *
 * Note that the defaults for options are a 'base' search, if that's what
 * you want you can just pass in a string for options and it will be treated
 * as the search filter.  Also, you can either pass in programatic Filter
 * objects or a filter string as the filter option.
 *
 * Note that this method is 'special' in that the callback 'res' param will
 * have two important events on it, namely 'entry' and 'end' that you can hook
 * to.  The former will emit a SearchEntry object for each record that comes
 * back, and the latter will emit a normal LDAPResult object.
 *
 * @param {String} base the DN in the tree to start searching at.
 * @param {Object} options parameters:
 *                           - {String} scope default of 'base'.
 *                           - {String} filter default of '(objectclass=*)'.
 *                           - {Array} attributes [string] to return.
 *                           - {Boolean} attrsOnly whether to return values.
 * @param {Control} controls (optional) either a Control or [Control].
 * @param {Function} callback of the form f(err, res).
 * @throws {TypeError} on invalid input.
 */
Client.prototype.search = function search(base,
                                          options,
                                          controls,
                                          callback,
                                          _bypass) {
  assert.ok(base !== undefined, 'search base');
  if (Array.isArray(options) || (options instanceof Control)) {
    controls = options;
    options = {};
  } else if (typeof (options) === 'function') {
    callback = options;
    controls = [];
    options = {
      filter: new PresenceFilter({attribute: 'objectclass'})
    };
  } else if (typeof (options) === 'string') {
    options = {filter: filters.parseString(options)};
  } else if (typeof (options) !== 'object') {
    throw new TypeError('options (object) required');
  }
  if (typeof (options.filter) === 'string') {
    options.filter = filters.parseString(options.filter);
  } else if (!options.filter) {
    options.filter = new PresenceFilter({attribute: 'objectclass'});
  } else if (!filters.isFilter(options.filter)) {
    throw new TypeError('options.filter (Filter) required');
  }
  if (typeof (controls) === 'function') {
    callback = controls;
    controls = [];
  } else {
    controls = validateControls(controls);
  }
  assert.func(callback, 'callback');

  if (options.attributes) {
    if (!Array.isArray(options.attributes)) {
      if (typeof (options.attributes) === 'string') {
        options.attributes = [options.attributes];
      } else {
        throw new TypeError('options.attributes must be an Array of Strings');
      }
    }
  }

  var self = this;
  var baseDN = ensureDN(base, this.strictDN);

  function sendRequest(ctrls, emitter, cb) {
    var req = new SearchRequest({
      baseObject: baseDN,
      scope: options.scope || 'base',
      filter: options.filter,
      derefAliases: options.derefAliases || Protocol.NEVER_DEREF_ALIASES,
      sizeLimit: options.sizeLimit || 0,
      timeLimit: options.timeLimit || 10,
      typesOnly: options.typesOnly || false,
      attributes: options.attributes || [],
      controls: ctrls
    });

    return self._send(req,
        [errors.LDAP_SUCCESS],
        emitter,
        cb,
        _bypass);
  }

  if (options.paged) {
    // Perform automated search paging
    var pageOpts = typeof (options.paged) === 'object' ? options.paged : {};
    var size = 100; // Default page size
    if (pageOpts.pageSize > 0) {
      size = pageOpts.pageSize;
    } else if (options.sizeLimit > 1)  {
      // According to the RFC, servers should ignore the paging control if
      // pageSize >= sizelimit.  Some might still send results, but it's safer
      // to stay under that figure when assigning a default value.
      size = options.sizeLimit - 1;
    }

    var pager = new SearchPager({
      callback: callback,
      controls: controls,
      pageSize: size,
      pagePause: pageOpts.pagePause
    });
    pager.on('search', sendRequest);
    pager.begin();
  } else {
    sendRequest(controls, new EventEmitter(), callback);
  }
};

/**
 * Unbinds this client from the LDAP server.
 *
 * Note that unbind does not have a response, so this callback is actually
 * optional; either way, the client is disconnected.
 *
 * @param {Function} callback of the form f(err).
 * @throws {TypeError} if you pass in callback as not a function.
 */
Client.prototype.unbind = function unbind(callback) {
  if (!callback)
    callback = function () {};

  if (typeof (callback) !== 'function')
    throw new TypeError('callback must be a function');

  // When the socket closes, it is useful to know whether it was due to a
  // user-initiated unbind or something else.
  this.unbound = true;

  if (!this._socket)
    return callback();

  var req = new UnbindRequest();
  return this._send(req, 'unbind', null, callback);
};

/**
 * Attempt to secure connection with StartTLS.
 */
Client.prototype.starttls = function starttls(options,
                                              controls,
                                              callback,
                                              _bypass) {
  assert.optionalObject(options);
  options = options || {};
  callback = once(callback);
  var self = this;

  if (this._starttls) {
    return callback(new Error('STARTTLS already in progress or active'));
  }

  function onSend(err, emitter) {
    if (err) {
      callback(err);
      return;
    }
    /*
     * Now that the request has been sent, block all outgoing messages
     * until an error is received or we successfully complete the setup.
     */
    // TODO: block traffic
    self._starttls = {
      started: true
    };

    emitter.on('error', function (err) {
      self._starttls = null;
      callback(err);
    });
    emitter.on('end', function (res) {
      var sock = self._socket;
      /*
       * Unplumb socket data during SSL negotiation.
       * This will prevent the LDAP parser from stumbling over the TLS
       * handshake and raising a ruckus.
       */
      sock.removeAllListeners('data');

      options.socket = sock;
      var secure = tls.connect(options);
      secure.once('secureConnect', function () {
        /*
         * Wire up 'data' and 'error' handlers like the normal socket.
         * Handling 'end' events isn't necessary since the underlying socket
         * will handle those.
         */
        secure.removeAllListeners('error');
        secure.on('data', function onData(data) {
          if (self.log.trace())
            self.log.trace('data event: %s', util.inspect(data));

          self._tracker.parser.write(data);
        });
        secure.on('error', function (err)  {
          if (self.log.trace())
            self.log.trace({err: err}, 'error event: %s', new Error().stack);

          self.emit('error', err);
          sock.destroy();
        });
        callback(null);
      });
      secure.once('error', function (err) {
        // If the SSL negotiation failed, to back to plain mode.
        self._starttls = null;
        secure.removeAllListeners();
        callback(err);
      });
      self._starttls.success = true;
      self._socket = secure;
    });
  }

  var req = new ExtendedRequest({
    requestName: '1.3.6.1.4.1.1466.20037',
    requestValue: null,
    controls: controls
  });

  return this._send(req,
      [errors.LDAP_SUCCESS],
      new EventEmitter(),
      onSend,
      _bypass);
};

/**
 * Disconnect from the LDAP server and do not allow reconnection.
 *
 * If the client is instantiated with proper reconnection options, it's
 * possible to initiate new requests after a call to unbind since the client
 * will attempt to reconnect in order to fulfill the request.
 *
 * Calling destroy will prevent any further reconnection from occurring.
 *
 * @param {Object} err (Optional) error that was cause of client destruction
 */
Client.prototype.destroy = function destroy(err) {
  this.destroyed = true;
  this.queue.freeze();
  // Purge any queued requests which are now meaningless
  this.queue.flush(function (msg, expect, emitter, cb) {
    if (typeof (cb) === 'function') {
      cb(new Error('client destroyed'));
      }
  });
  if (this.connected) {
    this.unbind();
  } else if (this._socket) {
    this._socket.destroy();
  }
  this.emit('destroy', err);
};

/**
 * Initiate LDAP connection.
 */
Client.prototype.connect = function connect() {
  if (this.connecting || this.connected) {
    return;
  }
  var self = this;
  var log = this.log;
  var socket;
  var tracker;

  // Establish basic socket connection
  function connectSocket(cb) {
    cb = once(cb);

    function onResult(err, res) {
      if (err) {
        if (self.connectTimer) {
          clearTimeout(self.connectTimer);
          self.connectTimer = null;
        }
        self.emit('connectError', err);
      }
      cb(err, res);
    }
    function onConnect() {
      if (self.connectTimer) {
        clearTimeout(self.connectTimer);
        self.connectTimer = null;
      }
      socket.removeAllListeners('error')
        .removeAllListeners('connect')
        .removeAllListeners('secureConnect');

      tracker.id = nextClientId() + '__' + tracker.id;
      self.log = self.log.child({ldap_id: tracker.id}, true);

      // Move on to client setup
      setupClient(cb);
    }

    var port = (self.port || self.socketPath);
    if (self.secure) {
      socket = tls.connect(port, self.host, self.tlsOptions);
      socket.once('secureConnect', onConnect);
    } else {
      socket = net.connect(port, self.host);
      socket.once('connect', onConnect);
    }
    socket.once('error', onResult);
    initSocket();

    // Setup connection timeout handling, if desired
    if (self.connectTimeout) {
      self.connectTimer = setTimeout(function onConnectTimeout() {
        if (!socket || !socket.readable || !socket.writeable) {
          socket.destroy();
          self._socket = null;
          onResult(new ConnectionError('connection timeout'));
        }
      }, self.connectTimeout);
    }
  }

  // Initialize socket events and LDAP parser.
  function initSocket() {
    tracker = new MessageTracker({
      id: self.url ? self.url.href : self.socketPath,
      parser: new Parser({log: log})
    });

    // This won't be set on TLS. So. Very. Annoying.
    if (typeof (socket.setKeepAlive) !== 'function') {
      socket.setKeepAlive = function setKeepAlive(enable, delay) {
        return socket.socket ?
          socket.socket.setKeepAlive(enable, delay) : false;
      };
    }

    socket.on('data', function onData(data) {
      if (log.trace())
        log.trace('data event: %s', util.inspect(data));

      tracker.parser.write(data);
    });

    // The "router"
    tracker.parser.on('message', function onMessage(message) {
      message.connection = self._socket;
      var callback = tracker.fetch(message.messageID);

      if (!callback) {
        log.error({message: message.json}, 'unsolicited message');
        return false;
      }

      return callback(message);
    });

    tracker.parser.on('error', function onParseError(err) {
      self.emit('error', new VError(err, 'Parser error for %s',
            tracker.id));
      self.connected = false;
      socket.end();
    });
  }

  // After connect, register socket event handlers and run any setup actions
  function setupClient(cb) {
    cb = once(cb);

    // Indicate failure if anything goes awry during setup
    function bail(err) {
      socket.destroy();
      cb(err || new Error('client error during setup'));
    }
    // Work around lack of close event on tls.socket in node < 0.11
    ((socket.socket) ? socket.socket : socket).once('close', bail);
    socket.once('error', bail);
    socket.once('end', bail);
    socket.once('timeout', bail);

    self._socket = socket;
    self._tracker = tracker;

    // Run any requested setup (such as automatically performing a bind) on
    // socket before signalling successful connection.
    // This setup needs to bypass the request queue since all other activity is
    // blocked until the connection is considered fully established post-setup.
    // Only allow bind/search/starttls for now.
    var basicClient = {
      bind: function bindBypass(name, credentials, controls, callback) {
        return self.bind(name, credentials, controls, callback, true);
      },
      search: function searchBypass(base, options, controls, callback) {
        return self.search(base, options, controls, callback, true);
      },
      starttls: function starttlsBypass(options, controls, callback) {
        return self.starttls(options, controls, callback, true);
      },
      unbind: self.unbind.bind(self)
    };
    vasync.forEachPipeline({
      func: function (f, callback) {
        f(basicClient, callback);
      },
      inputs: self.listeners('setup')
    }, function (err, res) {
      if (err) {
        self.emit('setupError', err);
      }
      cb(err);
    });
  }

  // Wire up "official" event handlers after successful connect/setup
  function postSetup() {
    socket.removeAllListeners('error')
      .removeAllListeners('close')
      .removeAllListeners('end')
      .removeAllListeners('timeout');

    // Work around lack of close event on tls.socket in node < 0.11
    ((socket.socket) ? socket.socket : socket).once('close',
      self._onClose.bind(self));
    socket.on('end', function onEnd() {
      if (log.trace())
        log.trace('end event');

      self.emit('end');
      socket.end();
    });
    socket.on('error', function onSocketError(err) {
      if (log.trace())
        log.trace({err: err}, 'error event: %s', new Error().stack);

      self.emit('error', err);
      socket.destroy();
    });
    socket.on('timeout', function onTimeout() {
      if (log.trace())
        log.trace('timeout event');

      self.emit('socketTimeout');
      socket.end();
    });
  }

  var retry;
  var failAfter;
  if (this.reconnect) {
    retry = backoff.exponential({
      initialDelay: this.reconnect.initialDelay,
      maxDelay: this.reconnect.maxDelay
    });
    failAfter = this.reconnect.failAfter;
  } else {
    retry = backoff.exponential({
      initialDelay: 1,
      maxDelay: 2
    });
    failAfter = 1;
  }
  retry.failAfter(failAfter);

  retry.on('ready', function (num, delay) {
    if (self.destroyed) {
      // Cease connection attempts if destroyed
      return;
    }
    connectSocket(function (err) {
      if (!err) {
        postSetup();
        self.connecting = false;
        self.connected = true;
        self.emit('connect', socket);
        self.log.debug('connected after %d attempt(s)', num+1);
        // Flush any queued requests
        self._flushQueue();
        self._connectRetry = null;
      } else {
        retry.backoff(err);
      }
    });
  });
  retry.on('fail', function (err) {
    if (self.destroyed) {
      // Silence any connect/setup errors if destroyed
      return;
    }
    self.log.debug('failed to connect after %d attempts', failAfter);
    // Communicate the last-encountered error
    if (err instanceof ConnectionError) {
      self.emit('connectTimeout', err);
    } else {
      self.emit('error', err);
    }
  });

  this._connectRetry = retry;
  this.connecting = true;
  retry.backoff();
};

///--- Private API

/**
 * Flush queued requests out to the socket.
 */
Client.prototype._flushQueue = function _flushQueue() {
  // Pull items we're about to process out of the queue.
  this.queue.flush(this._send.bind(this));
};

/**
 * Clean up socket/parser resources after socket close.
 */
Client.prototype._onClose = function _onClose(had_err) {
  var socket = this._socket;
  var tracker = this._tracker;
  socket.removeAllListeners('connect')
    .removeAllListeners('data')
    .removeAllListeners('drain')
    .removeAllListeners('end')
    .removeAllListeners('error')
    .removeAllListeners('timeout');
  this._socket = null;
  this.connected = false;

  ((socket.socket) ? socket.socket : socket).removeAllListeners('close');

  if (this.log.trace())
    this.log.trace('close event had_err=%s', had_err ? 'yes' : 'no');

  this.emit('close', had_err);
  // On close we have to walk the outstanding messages and go invoke their
  // callback with an error.
  tracker.pending.forEach(function (msgid) {
    var cb = tracker.fetch(msgid);
    tracker.remove(msgid);

    if (socket.unbindMessageID !== parseInt(msgid, 10)) {
      return cb(new ConnectionError(tracker.id + ' closed'));
    } else {
      // Unbinds will be communicated as a success since we're closed
      var unbind = new UnbindResponse({messageID: msgid});
      unbind.status = 'unbind';
      return cb(unbind);
    }
  });

  // Trash any parser or starttls state
  this._tracker = null;
  delete this._starttls;

  // Automatically fire reconnect logic if the socket was closed for any reason
  // other than a user-initiated unbind.
  if (this.reconnect && !this.unbound) {
    this.connect();
  }
  this.unbound = false;
  return false;
};

/**
 * Maintain idle timer for client.
 *
 * Will start timer to fire 'idle' event if conditions are satisfied.  If
 * conditions are not met and a timer is running, it will be cleared.
 *
 * @param {Boolean} override explicitly disable timer.
 */
Client.prototype._updateIdle = function _updateIdle(override) {
  if (this.idleTimeout === 0) {
    return;
  }
  // Client must be connected but not waiting on any request data
  var self = this;
  function isIdle(disable) {
    return ((disable !== true) &&
      (self._socket && self.connected) &&
      (self._tracker.pending.length === 0));
  }
  if (isIdle(override)) {
    if (!this._idleTimer) {
      this._idleTimer = setTimeout(function () {
        // Double-check idleness in case socket was torn down
        if (isIdle()) {
          self.emit('idle');
        }
      }, this.idleTimeout);
    }
  } else {
    if (this._idleTimer) {
      clearTimeout(this._idleTimer);
      this._idleTimer = null;
    }
  }
};

/**
 * Attempt to send an LDAP request.
 */
Client.prototype._send = function _send(message,
                                        expect,
                                        emitter,
                                        callback,
                                        _bypass) {
  assert.ok(message);
  assert.ok(expect);
  assert.optionalObject(emitter);
  assert.ok(callback);

  // Allow connect setup traffic to bypass checks
  if (_bypass && this._socket && this._socket.writable) {
    return this._sendSocket(message, expect, emitter, callback);
  }
  if (!this._socket || !this.connected) {
    if (!this.queue.enqueue(message, expect, emitter, callback)) {
      callback(new ConnectionError('connection unavailable'));
    }
    // Initiate reconnect if needed
    if (this.reconnect) {
      this.connect();
    }
    return false;
  } else {
    this._flushQueue();
    return this._sendSocket(message, expect, emitter, callback);
  }
};

Client.prototype._sendSocket = function _sendSocket(message,
                                                    expect,
                                                    emitter,
                                                    callback) {
  var conn = this._socket;
  var tracker = this._tracker;
  var log = this.log;
  var self = this;
  var timer = false;
  var sentEmitter = false;

  function sendResult(event, obj) {
    if (event === 'error' && self.listeners('resultError')) {
      self.emit('resultError', obj);
    }
    if (emitter) {
      if (event === 'error') {
        // Error will go unhandled if emitter hasn't been sent via callback.
        // Execute callback with the error instead.
        if (!sentEmitter)
          return callback(obj);
      }
      return emitter.emit(event, obj);
    }

    if (event === 'error')
      return callback(obj);

    return callback(null, obj);
  }

  function messageCallback(msg) {
    if (timer)
      clearTimeout(timer);

    if (log.trace())
      log.trace({msg: msg ? msg.json : null}, 'response received');

    if (expect === 'abandon')
      return sendResult('end', null);

    if (msg instanceof SearchEntry || msg instanceof SearchReference) {
      var event = msg.constructor.name;
      event = event[0].toLowerCase() + event.slice(1);
      return sendResult(event, msg);
    } else {
      tracker.remove(message.messageID);
      // Potentially mark client as idle
      self._updateIdle();

      if (msg instanceof LDAPResult) {
        if (expect.indexOf(msg.status) === -1) {
          return sendResult('error', errors.getError(msg));
        }
        return sendResult('end', msg);
      } else if (msg instanceof Error) {
        return sendResult('error', msg);
      } else {
        return sendResult('error', new errors.ProtocolError(msg.type));
      }
    }
  }

  function onRequestTimeout() {
    self.emit('timeout', message);
    var cb = tracker.fetch(message.messageID);
    if (cb) {
      //FIXME: the timed-out request should be abandoned
      cb(new errors.TimeoutError('request timeout (client interrupt)'));
    }
  }

  function writeCallback() {
    if (expect === 'abandon') {
      // Mark the messageID specified as abandoned
      tracker.abandon(message.abandonID);
      // No need to track the abandon request itself
      tracker.remove(message.id);
      return callback(null);
    } else if (expect === 'unbind') {
      conn.unbindMessageID = message.id;
      // Mark client as disconnected once unbind clears the socket
      self.connected = false;
      // Some servers will RST the connection after receiving an unbind.
      // Socket errors are blackholed since the connection is being closed.
      conn.removeAllListeners('error');
      conn.on('error', function () {});
      conn.end();
    } else if (emitter) {
      sentEmitter = true;
      return callback(null, emitter);
    }
    return false;
  }

  // Start actually doing something...
  tracker.track(message, messageCallback);
  // Mark client as active
  this._updateIdle(true);

  if (self.timeout) {
    log.trace('Setting timeout to %d', self.timeout);
    timer = setTimeout(onRequestTimeout, self.timeout);
  }

  if (log.trace())
    log.trace('sending request %j', message.json);

  try {
    return conn.write(message.toBer(), writeCallback);
  } catch (e) {
    if (timer)
      clearTimeout(timer);

    log.trace({err: e}, 'Error writing message to socket');
    return callback(e);
  }
};


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert-plus');
var util = require('util');

var asn1 = require('asn1');

var LDAPMessage = require('./message');
var Attribute = require('../attribute');
var Protocol = require('../protocol');
var lassert = require('../assert');

///--- Globals

var BerWriter = asn1.BerWriter;

///--- API

function SearchEntry(options) {
  options = options || {};
  assert.object(options);
  lassert.optionalStringDN(options.objectName);

  options.protocolOp = Protocol.LDAP_REP_SEARCH_ENTRY;
  LDAPMessage.call(this, options);

  this.objectName = options.objectName || null;
  this.setAttributes(options.attributes || []);
}
util.inherits(SearchEntry, LDAPMessage);
Object.defineProperties(SearchEntry.prototype, {
  type: {
    get: function getType() { return 'SearchEntry'; },
    configurable: false
  },
  _dn: {
    get: function getDN() { return this.objectName; },
    configurable: false
  },
  object: {
    get: function getObject() {
      var obj = {
        dn: this.dn.toString(),
        controls: []
      };
      this.attributes.forEach(function (a) {
        if (a.vals && a.vals.length) {
          if (a.vals.length > 1) {
            obj[a.type] = a.vals.slice();
          } else {
            obj[a.type] = a.vals[0];
          }
        } else {
          obj[a.type] = [];
        }
      });
      this.controls.forEach(function (element, index, array) {
        obj.controls.push(element.json);
      });
      return obj;
    },
    configurable: false
  },
  raw: {
    get: function getRaw() {
      var obj = {
        dn: this.dn.toString(),
        controls: []
      };

      this.attributes.forEach(function (a) {
        if (a.buffers && a.buffers.length) {
          if (a.buffers.length > 1) {
            obj[a.type] = a.buffers.slice();
          } else {
            obj[a.type] = a.buffers[0];
          }
        } else {
          obj[a.type] = [];
        }
          });
      this.controls.forEach(function (element, index, array) {
        obj.controls.push(element.json);
      });
      return obj;
    },
    configurable: false
  }
});

SearchEntry.prototype.addAttribute = function (attr) {
  if (!attr || typeof (attr) !== 'object')
    throw new TypeError('attr (attribute) required');

  this.attributes.push(attr);
};

SearchEntry.prototype.toObject = function () {
  return this.object;
};

SearchEntry.prototype.fromObject = function (obj) {
  if (typeof (obj) !== 'object')
    throw new TypeError('object required');

  var self = this;
  if (obj.controls)
    this.controls = obj.controls;

  if (obj.attributes)
    obj = obj.attributes;
  this.attributes = [];

  Object.keys(obj).forEach(function (k) {
    self.attributes.push(new Attribute({type: k, vals: obj[k]}));
  });

  return true;
};

SearchEntry.prototype.setAttributes = function (obj) {
  if (typeof (obj) !== 'object')
    throw new TypeError('object required');

  if (Array.isArray(obj)) {
    obj.forEach(function (a) {
      if (!Attribute.isAttribute(a))
        throw new TypeError('entry must be an Array of Attributes');
    });
    this.attributes = obj;
  } else {
    var self = this;

    self.attributes = [];
    Object.keys(obj).forEach(function (k) {
      var attr = new Attribute({type: k});
      if (Array.isArray(obj[k])) {
        obj[k].forEach(function (v) {
          attr.addValue(v.toString());
        });
      } else {
        attr.addValue(obj[k].toString());
      }
      self.attributes.push(attr);
    });
  }
};

SearchEntry.prototype._json = function (j) {
  assert.ok(j);

  j.objectName = this.objectName.toString();
  j.attributes = [];
  this.attributes.forEach(function (a) {
    j.attributes.push(a.json || a);
  });

  return j;
};

SearchEntry.prototype._parse = function (ber) {
  assert.ok(ber);

  this.objectName = ber.readString();
  assert.ok(ber.readSequence());

  var end = ber.offset + ber.length;
  while (ber.offset < end) {
    var a = new Attribute();
    a.parse(ber);
    this.attributes.push(a);
  }

  return true;
};

SearchEntry.prototype._toBer = function (ber) {
  assert.ok(ber);

  ber.writeString(this.objectName.toString());
  ber.startSequence();
  this.attributes.forEach(function (a) {
    // This may or may not be an attribute
    ber = Attribute.toBer(a, ber);
  });
  ber.endSequence();

  return ber;
};

///--- Exports

module.exports = SearchEntry;


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert');

var asn1 = require('asn1');

var Protocol = require('./protocol');

///--- API

function Attribute(options) {
  if (options) {
    if (typeof (options) !== 'object')
      throw new TypeError('options must be an object');
    if (options.type && typeof (options.type) !== 'string')
      throw new TypeError('options.type must be a string');
  } else {
    options = {};
  }

  this.type = options.type || '';
  this._vals = [];

  if (options.vals !== undefined && options.vals !== null)
    this.vals = options.vals;
}

module.exports = Attribute;

Object.defineProperties(Attribute.prototype, {
  buffers: {
    get: function getBuffers() {
      return this._vals;
    },
    configurable: false
  },
  json: {
    get: function getJson() {
      return {
        type: this.type,
        vals: this.vals
      };
    },
    configurable: false
  },
  vals: {
    get: function getVals() {
      var eType = _bufferEncoding(this.type);
      return this._vals.map(function (v) {
        return v.toString(eType);
      });
    },
    set: function setVals(vals) {
      var self = this;
      this._vals = [];
      if (Array.isArray(vals)) {
        vals.forEach(function (v) {
          self.addValue(v);
        });
      } else {
        self.addValue(vals);
      }
    },
    configurable: false
  }
});

Attribute.prototype.addValue = function addValue(val) {
  if (Buffer.isBuffer(val)) {
    this._vals.push(val);
  } else {
    this._vals.push(new Buffer(val + '', _bufferEncoding(this.type)));
  }
};

/* BEGIN JSSTYLED */
Attribute.compare = function compare(a, b) {
  if (!(Attribute.isAttribute(a)) || !(Attribute.isAttribute(b))) {
    throw new TypeError('can only compare Attributes');
  }

  if (a.type < b.type) return -1;
  if (a.type > b.type) return 1;
  if (a.vals.length < b.vals.length) return -1;
  if (a.vals.length > b.vals.length) return 1;

  for (var i = 0; i < a.vals.length; i++) {
    if (a.vals[i] < b.vals[i]) return -1;
    if (a.vals[i] > b.vals[i]) return 1;
  }

  return 0;
};
/* END JSSTYLED */

Attribute.prototype.parse = function parse(ber) {
  assert.ok(ber);

  ber.readSequence();
  this.type = ber.readString();

  if (ber.peek() === Protocol.LBER_SET) {
    if (ber.readSequence(Protocol.LBER_SET)) {
      var end = ber.offset + ber.length;
      while (ber.offset < end)
        this._vals.push(ber.readString(asn1.Ber.OctetString, true));
    }
  }

  return true;
};

Attribute.prototype.toBer = function toBer(ber) {
  assert.ok(ber);

  ber.startSequence();
  ber.writeString(this.type);
  ber.startSequence(Protocol.LBER_SET);
  if (this._vals.length) {
    this._vals.forEach(function (b) {
      ber.writeByte(asn1.Ber.OctetString);
      ber.writeLength(b.length);
      for (var i = 0; i < b.length; i++)
        ber.writeByte(b[i]);
    });
  } else {
    ber.writeStringArray([]);
  }
  ber.endSequence();
  ber.endSequence();

  return ber;
};

Attribute.prototype.toString = function () {
  return JSON.stringify(this.json);
};

Attribute.toBer = function (attr, ber) {
  return Attribute.prototype.toBer.call(attr, ber);
};

Attribute.isAttribute = function isAttribute(attr) {
  if (!attr || typeof (attr) !== 'object') {
    return false;
  }
  if (attr instanceof Attribute) {
    return true;
  }
  if ((typeof (attr.toBer) === 'function') &&
      (typeof (attr.type) === 'string') &&
      (Array.isArray(attr.vals)) &&
      (attr.vals.filter(function (item) {
         return (typeof (item) === 'string' ||
                  Buffer.isBuffer(item));
       }).length === attr.vals.length)) {
    return true;
  }
  return false;
};

function _bufferEncoding(type) {
  /* JSSTYLED */
  return /;binary$/.test(type) ? 'base64' : 'utf8';
}


// Copyright 2011 Mark Cavage, Inc.  All rights reserved.

var assert = require('assert-plus');
var util = require('util');

var asn1 = require('asn1');

var LDAPMessage = require('./message');
var LDAPResult = require('./result');
var dn = require('../dn');
var filters = require('../filters');
var Protocol = require('../protocol');

///--- Globals

var Ber = asn1.Ber;

///--- API

function SearchRequest(options) {
  options = options || {};
  assert.object(options);

  options.protocolOp = Protocol.LDAP_REQ_SEARCH;
  LDAPMessage.call(this, options);

  if (options.baseObject !== undefined) {
    this.baseObject = options.baseObject;
  } else {
    this.baseObject = dn.parse('');
  }
  this.scope = options.scope || 'base';
  this.derefAliases = options.derefAliases || Protocol.NEVER_DEREF_ALIASES;
  this.sizeLimit = options.sizeLimit || 0;
  this.timeLimit = options.timeLimit || 0;
  this.typesOnly = options.typesOnly || false;
  this.filter = options.filter || null;
  this.attributes = options.attributes ? options.attributes.slice(0) : [];
}
util.inherits(SearchRequest, LDAPMessage);
Object.defineProperties(SearchRequest.prototype, {
  type: {
    get: function getType() { return 'SearchRequest'; },
    configurable: false
  },
  _dn: {
    get: function getDN() { return this.baseObject; },
    configurable: false
  },
  scope: {
    get: function getScope() {
      switch (this._scope) {
      case Protocol.SCOPE_BASE_OBJECT: return 'base';
      case Protocol.SCOPE_ONE_LEVEL: return 'one';
      case Protocol.SCOPE_SUBTREE: return 'sub';
      default:
        throw new Error(this._scope + ' is an invalid search scope');
      }
    },
    set: function setScope(val) {
      if (typeof (val) === 'string') {
        switch (val) {
        case 'base':
          this._scope = Protocol.SCOPE_BASE_OBJECT;
          break;
        case 'one':
          this._scope = Protocol.SCOPE_ONE_LEVEL;
          break;
        case 'sub':
          this._scope = Protocol.SCOPE_SUBTREE;
          break;
        default:
          throw new Error(val + ' is an invalid search scope');
        }
      } else {
        this._scope = val;
      }
    },
    configurable: false
  }
});

SearchRequest.prototype._parse = function (ber) {
  assert.ok(ber);

  this.baseObject = ber.readString();
  this.scope = ber.readEnumeration();
  this.derefAliases = ber.readEnumeration();
  this.sizeLimit = ber.readInt();
  this.timeLimit = ber.readInt();
  this.typesOnly = ber.readBoolean();

  this.filter = filters.parse(ber);

  // look for attributes
  if (ber.peek() === 0x30) {
    ber.readSequence();
    var end = ber.offset + ber.length;
    while (ber.offset < end)
      this.attributes.push(ber.readString().toLowerCase());
  }

  return true;
};

SearchRequest.prototype._toBer = function (ber) {
  assert.ok(ber);

  ber.writeString(this.baseObject.toString());
  ber.writeEnumeration(this._scope);
  ber.writeEnumeration(this.derefAliases);
  ber.writeInt(this.sizeLimit);
  ber.writeInt(this.timeLimit);
  ber.writeBoolean(this.typesOnly);

  var f = this.filter || new filters.PresenceFilter({attribute: 'objectclass'});
  ber = f.toBer(ber);

  ber.startSequence(Ber.Sequence | Ber.Constructor);
  if (this.attributes && this.attributes.length) {
    this.attributes.forEach(function (a) {
      ber.writeString(a);
    });
  }
  ber.endSequence();

  return ber;
};

SearchRequest.prototype._json = function (j) {
  assert.ok(j);

  j.baseObject = this.baseObject;
  j.scope = this.scope;
  j.derefAliases = this.derefAliases;
  j.sizeLimit = this.sizeLimit;
  j.timeLimit = this.timeLimit;
  j.typesOnly = this.typesOnly;
  j.filter = this.filter.toString();
  j.attributes = this.attributes;

  return j;
};

///--- Exports

module.exports = SearchRequest;