/**
   * Module dependencies.
   */
  
  var parser = require('socket.io-parser');
  var debug = require('debug')('socket.io:client');
  
  /**
   * Module exports.
   */
  
  module.exports = Client;
  
  /**
   * Client constructor.
   *
   * @param {Server} server instance
   * @param {Socket} conn
   * @api private
   */
  
  function Client(server, conn){
    this.server = server;
    this.conn = conn;
    this.encoder = new parser.Encoder();
    this.decoder = new parser.Decoder();
    this.id = conn.id;
    this.request = conn.request;
    this.setup();
    this.sockets = {};
    this.nsps = {};
    this.connectBuffer = [];
  }
  
  /**
   * Sets up event listeners.
   *
   * @api private
   */
  
  Client.prototype.setup = function(){
    this.onclose = this.onclose.bind(this);
    this.ondata = this.ondata.bind(this);
    this.onerror = this.onerror.bind(this);
    this.ondecoded = this.ondecoded.bind(this);
  
    this.decoder.on('decoded', this.ondecoded);
    this.conn.on('data', this.ondata);
    this.conn.on('error', this.onerror);
    this.conn.on('close', this.onclose);
  };
  
  /**
   * Connects a client to a namespace.
   *
   * @param {String} name namespace
   * @api private
   */
  
  Client.prototype.connect = function(name){
    debug('connecting to namespace %s', name);
    var nsp = this.server.nsps[name];
    if (!nsp) {
      this.packet({ type: parser.ERROR, nsp: name, data : 'Invalid namespace'});
      return;
    }
  
    if ('/' != name && !this.nsps['/']) {
      this.connectBuffer.push(name);
      return;
    }
  
    var self = this;
    var socket = nsp.add(this, function(){
      self.sockets[socket.id] = socket;
      self.nsps[nsp.name] = socket;
  
      if ('/' == nsp.name && self.connectBuffer.length > 0) {
        self.connectBuffer.forEach(self.connect, self);
        self.connectBuffer = [];
      }
    });
  };
  
  /**
   * Disconnects from all namespaces and closes transport.
   *
   * @api private
   */
  
  Client.prototype.disconnect = function(){
    for (var id in this.sockets) {
      if (this.sockets.hasOwnProperty(id)) {
        this.sockets[id].disconnect();
      }
    }
    this.sockets = {};
    this.close();
  };
  
  /**
   * Removes a socket. Called by each `Socket`.
   *
   * @api private
   */
  
  Client.prototype.remove = function(socket){
    if (this.sockets.hasOwnProperty(socket.id)) {
      var nsp = this.sockets[socket.id].nsp.name;
      delete this.sockets[socket.id];
      delete this.nsps[nsp];
    } else {
      debug('ignoring remove for %s', socket.id);
    }
  };
  
  /**
   * Closes the underlying connection.
   *
   * @api private
   */
  
  Client.prototype.close = function(){
    if ('open' == this.conn.readyState) {
      debug('forcing transport close');
      this.conn.close();
      this.onclose('forced server close');
    }
  };
  
  /**
   * Writes a packet to the transport.
   *
   * @param {Object} packet object
   * @param {Object} opts
   * @api private
   */
  
  Client.prototype.packet = function(packet, opts){
    opts = opts || {};
    var self = this;
  
    // this writes to the actual connection
    function writeToEngine(encodedPackets) {
      if (opts.volatile && !self.conn.transport.writable) return;
      for (var i = 0; i < encodedPackets.length; i++) {
        self.conn.write(encodedPackets[i], { compress: opts.compress });
      }
    }
  
    if ('open' == this.conn.readyState) {
      debug('writing packet %j', packet);
      if (!opts.preEncoded) { // not broadcasting, need to encode
        this.encoder.encode(packet, function (encodedPackets) { // encode, then write results to engine
          writeToEngine(encodedPackets);
        });
      } else { // a broadcast pre-encodes a packet
        writeToEngine(packet);
      }
    } else {
      debug('ignoring packet write %j', packet);
    }
  };
  
  /**
   * Called with incoming transport data.
   *
   * @api private
   */
  
  Client.prototype.ondata = function(data){
    // try/catch is needed for protocol violations (GH-1880)
    try {
      this.decoder.add(data);
    } catch(e) {
      this.onerror(e);
    }
  };
  
  /**
   * Called when parser fully decodes a packet.
   *
   * @api private
   */
  
  Client.prototype.ondecoded = function(packet) {
    if (parser.CONNECT == packet.type) {
      this.connect(packet.nsp);
    } else {
      var socket = this.nsps[packet.nsp];
      if (socket) {
        socket.onpacket(packet);
      } else {
        debug('no socket for namespace %s', packet.nsp);
      }
    }
  };
  
  /**
   * Handles an error.
   *
   * @param {Object} err object
   * @api private
   */
  
  Client.prototype.onerror = function(err){
    for (var id in this.sockets) {
      if (this.sockets.hasOwnProperty(id)) {
        this.sockets[id].onerror(err);
      }
    }
    this.onclose('client error');
  };
  
  /**
   * Called upon transport close.
   *
   * @param {String} reason
   * @api private
   */
  
  Client.prototype.onclose = function(reason){
    debug('client close with reason %s', reason);
  
    // ignore a potential subsequent `close` event
    this.destroy();
  
    // `nsps` and `sockets` are cleaned up seamlessly
    for (var id in this.sockets) {
      if (this.sockets.hasOwnProperty(id)) {
        this.sockets[id].onclose(reason);
      }
    }
    this.sockets = {};
  
    this.decoder.destroy(); // clean up decoder
  };
  
  /**
   * Cleans up event listeners.
   *
   * @api private
   */
  
  Client.prototype.destroy = function(){
    this.conn.removeListener('data', this.ondata);
    this.conn.removeListener('error', this.onerror);
    this.conn.removeListener('close', this.onclose);
    this.decoder.removeListener('decoded', this.ondecoded);
  };