Junction

var xmpp = require('node-xmpp')
  , uuid = require('node-uuid')
  , util = require('util')
  , assert = require('assert')
  , NullStream = require('./nullstream');

function Client(options) {
  options = options || {}
  // WORKAROUND: Disable socket streams in underlying node-xmpp, useful in cases
  //             where one is not necessary (such as mounted connections or
  //             tests).
  this._disableStream = options.disableStream || false;
  
  xmpp.Client.call(this, options);
  this._stack = [];
  this._filters = [];
  this.addListener('stanza', this.handle);
}

util.inherits(Client, xmpp.Client);

Client.prototype.use = function(ns, handle) {
  // TODO: Allow ns to be set as an XPath expression, in order to limit the
  //       scope of the handler.
  // TODO: Alternatively, let the qualifier be the JID to which the stanza is
  //       addressed.  This would be beneficial for components that handle a
  //       domain, but want to be addressed using node@domain.  I'm leaning in
  //       favor of this approach, rather than the XPath one.
  if ('string' != typeof ns) {
    handle = ns;
    ns = null;
  }
  
  // wrap sub-apps
  // TODO: Implement test cases for this functionality
  if ('function' == typeof handle.handle) {
    var connection = handle;
    connection.send = this.send.bind(this);
    connection.generateID = this.generateID.bind(this);
    handle = function(stanza, next){
      connection.handle(stanza, next);
    };
  }
  
  this._stack.push({ ns: ns, handle: handle });
  return this;
}

Client.prototype.filter = function(handle) {
  this._filters.push({ handle: handle });
  return this;
}

Client.prototype.send = function(stanza) {
  if (stanza.toXML) {
    stanza = stanza.toXML();
  }
  
  if (stanza.root) {
      console.log('SEND: ' + stanza.root().toString() + '\n');
  } else {
      console.log('SEND: ' + stanza + '\n');
  }
  
  var filters = this._filters;
  var idx = 0;
  function next() {
    var filter = filters[idx++];
    
    // all done
    if (!filter) { return; }
    
    // TODO: Implement error handling
    try {
      filter.handle(stanza, next);
    } catch (e) {
      if (e instanceof assert.AssertionError) {
        console.error(e.stack + '\n');
        next();
      } else {
        console.error(e.stack + '\n');
        next();
      }
    }
  }
  if (stanza instanceof xmpp.Element) { next(); }
  
  xmpp.Client.prototype.send.call(this, stanza);
}

Client.prototype.generateID = function() {
  return uuid();
}

module.exports = Client;

var xmpp = require('node-xmpp')
  , util = require('util')
  , Client = require('./client');

function Component(options) {
  options = options || {}
  // WORKAROUND: Disable socket streams in underlying node-xmpp, useful in cases
  //             where one is not necessary.  See Client.prototype.setupStream
  //             for implementation.
  this._disableStream = options.disableStream || false;
  
  xmpp.Component.call(this, options);
  this._stack = [];
  this._filters = [];
  this.addListener('stanza', this.handle);
}

util.inherits(Component, xmpp.Component);

Object.keys(Client.prototype).forEach(function(method){
  Component.prototype[method] = Client.prototype[method];
});

module.exports = Component;

var util = require('util')
  , XMLElement = require('node-xmpp').Element;

function Element(name, xmlns) {
  if (!name) { throw new Error('Element requires a name'); }
  
  this.parent = null;
  this.name = name;
  this.xmlns = xmlns;
  this.children = [];
}

Element.prototype.c = function(child, attrs) {
  if (attrs) {
    child = new XMLElement(child, attrs);
  }
  this.children.push(child);
  child.parent = this;
  return child;
}

Element.prototype.t = function(text) {
  this.children.push(text);
  return this;
};

Element.prototype.up = function() {
  if (this.parent) {
    return this.parent;
  } else {
    return this;
  }
};

Element.prototype.toXML = function() {
  var attrs = this.xmlAttributes();
  attrs['xmlns'] = this.xmlns;
  var xml = new XMLElement(this.name, attrs);
  this.children.forEach(function(child) {
    if (child.toXML) { // instances of junction.Element
      xml.children.push(child.toXML());
    } else if (child.toString) { // instances of ltx.Element
      xml.children.push(child);
    } else if (typeof child === 'string') {
      xml.children.push(child);
    }
  });
  return xml;
}

Element.prototype.xmlAttributes = function() {
  return {};
}

exports = module.exports = Element;

var util = require('util')
  , Element = require('./element');

function IQ(to, from, type) {
  if ('string' != typeof type) {
    type = from;
    from = null;
  }
  type = type || 'get';
  
  Element.call(this, 'iq');
  this.id = null;
  this.to = to;
  this.from = from;
  this.type = type;
}

util.inherits(IQ, Element);

exports = module.exports = IQ;

var util = require('util')
  , Element = require('./element');

function Message(to, from, type) {
  if ('string' != typeof type) {
    type = from;
    from = null;
  }
  
  Element.call(this, 'message');
  this.to = to || null;
  this.from = from || null;
  this.type = type || null;
}

util.inherits(Message, Element);

exports = module.exports = Message;

var util = require('util')
  , Element = require('./element');

function Presence(to, from, type) {
  if ('string' != typeof type) {
    type = from;
    from = null;
  }
  
  Element.call(this, 'presence');
  this.to = to || null;
  this.from = from || null;
  this.type = type || null;
}

util.inherits(Presence, Element);

exports = module.exports = Presence;

var util = require('util');

module.exports = function pending(options) {
  options = options || {};
  var store = options.store;
  
  if (!store) throw new Error('pending filter requires a store');
  
  return function pending(stanza, next) {
    if (!stanza.attrs.id || !stanza.pending) {
      return next();
    }
    
    var key = stanza.attrs.to + ':' + stanza.attrs.id;
    store.set(key, stanza.pending, function(err) {
      next(err);
    });
  }
}

var fs = require('fs')
  , xmpp = require('node-xmpp')
  , Client = require('./client')
  , Component = require('./component')
  , StanzaError = require('./stanzaerror');

exports.version = '0.1.0';

exports.createConnection = function (options) {
  if (options.type == 'component') {
    return new Component(options);
  }
  return new Client(options);
};

exports.Client = Client;
exports.Component = Component;
exports.JID = xmpp.JID;
exports.XMLElement = xmpp.Element;
exports.StanzaError = StanzaError;

exports.elements = {};
exports.elements.Element = require('./elements/element');
exports.elements.IQ = require('./elements/iq');
exports.elements.Message = require('./elements/message');
exports.elements.Presence = require('./elements/presence');

exports.filters = {};
exports.filters.pending = require('./filters/pending');

exports.middleware = {};

fs.readdirSync(__dirname + '/middleware').forEach(function(filename) {
  if (/\.js$/.test(filename)) {
    var name = filename.substr(0, filename.lastIndexOf('.'));
    exports.middleware.__defineGetter__(name, function(){
      return require('./middleware/' + name);
    });
  }
});

exports.__proto__ = exports.middleware;

module.exports = function attentionParser() {
  
  return function attentionParser(stanza, next) {
    if (!stanza.is('message')) { return next(); }
    var attention = stanza.getChild('attention', 'urn:xmpp:attention:0');
    if (!attention) { return next(); }
    
    stanza.attention = true;
    next();
  }
}

module.exports = function capabilitiesParser() {
  
  return function capabilitiesParser(stanza, next) {
    if (!stanza.is('presence')) { return next(); }
    var c = stanza.getChild('c', 'http://jabber.org/protocol/caps');
    if (!c) { return next(); }
    
    stanza.capabilities = {};
    stanza.capabilities.node = c.attrs.node;
    stanza.capabilities.verification = c.attrs.ver;
    stanza.capabilities.hash = c.attrs.hash;
    next();
  }
}

var JID = require('node-xmpp').JID;

module.exports = function delayParser() {
  
  return function delayParser(stanza, next) {
    if (!(stanza.is('message') || stanza.is('presence'))) { return next(); }
    var delay = stanza.getChild('delay', 'urn:xmpp:delay');
    if (!delay) { return next(); }
    
    stanza.delayedBy = new JID(delay.attrs.from);
    stanza.originallySentAt = new Date(delay.attrs.stamp);
    next();
  }
}

var StanzaError = require('../stanzaerror');

module.exports = function errorHandler(options) {
  options = options || {};
  
  var includeStanza = options.includeStanza || false;
  var showStack = options.showStack || false;
  var dumpExceptions = options.dumpExceptions || false;

  return function errorHandler(err, req, res, next) {
    if (dumpExceptions) { console.error(err.stack); }
    
    // An error was encountered, but no response mechanism is available to
    // return information to the requesting entity.
    if (!res) { return next(err); }
    
    var type = err.type || 'wait';
    var condition = err.condition || 'internal-server-error';
    var message = err.message || '';
    if (showStack) {
      message += '\n';
      message += err.stack;
    }
    
    res.attrs.type = 'error';
    if (includeStanza) {
      // TODO: Implement support for including XML stanza that triggered the
      //       error.
    }
    var errorEl = res.c('error', { type: type }).c(condition, { xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' }).up();
    if (message && message.length) {
      errorEl.c('text', { xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' }).t(message)
    }
    if (err.specificCondition && err.specificCondition.name) {
      errorEl.c(err.specificCondition.name, { xmlns: err.specificCondition.xmlns })
    }
    res.send();
  }
}

var StanzaError = require('../stanzaerror');

module.exports = function lastActivity(callback) {
  callback = callback || uptime;
  
  var start = Date.now();
  function uptime() {
    return Math.round((Date.now() - start) / 1000);
  }
  
  return function lastActivity(req, res, next) {
    if (!req.is('iq')) { return next(); }
    if (req.type == 'result' || req.type == 'error') { return next(); }
    var query = req.getChild('query', 'jabber:iq:last');
    if (!query) { return next(); }
    
    if (req.type != 'get') {
      return next(new StanzaError("Query must be an IQ-get stanza.", 'modify', 'bad-request'));
    }
    
    var now = Date.now();
    var q = res.c('query', { xmlns: 'jabber:iq:last', seconds: callback() });
    res.send();
  }
}

module.exports = function lastActivityResultParser() {
  
  return function lastActivityResultParser(stanza, next) {
    if (!stanza.is('iq')) { return next(); }
    if (stanza.type != 'result') { return next(); }
    var query = stanza.getChild('query', 'jabber:iq:last');
    if (!query) { return next(); }
    
    stanza.lastActivity = query.attrs.seconds;
    stanza.lastStatus = query.getText();
    next();
  }
}

var JID = require('node-xmpp').JID;

module.exports = function legacyDelayParser() {
  
  return function legacyDelayParser(stanza, next) {
    if (!(stanza.is('message') || stanza.is('presence'))) { return next(); }
    var delay = stanza.getChild('x', 'jabber:x:delay');
    if (!delay) { return next(); }
    
    stanza.delayedBy = new JID(delay.attrs.from);
    var match = /(\d{4})(\d{2})(\d{2})T(\d{2}):(\d{2}):(\d{2})/.exec(delay.attrs.stamp);
    if (match) {
      stanza.originallySentAt = new Date(Date.UTC(match[1], match[2] - 1, match[3], match[4], match[5], match[6]));
    }
    
    next();
  }
}

var StanzaError = require('../stanzaerror');

module.exports = function legacyTime(options) {
  options = options || {};
  
  return function legacyTime(req, res, next) {
    if (!req.is('iq')) { return next(); }
    if (req.type == 'result' || req.type == 'error') { return next(); }
    var query = req.getChild('query', 'jabber:iq:time');
    if (!query) { return next(); }
    
    if (req.type != 'get') {
      return next(new StanzaError("Query must be an IQ-get stanza.", 'modify', 'bad-request'));
    }
    
    var now = options.date || new Date();
    var t = res.c('query', { xmlns: 'jabber:iq:time' });
    t.c('utc').t(LegacyXMPPDateTimeString(now));
    if (options.timezone) { t.c('tz').t(options.timezone); }
    if (options.display) { t.c('display').t(options.display); }
    res.send();
  }
}


function LegacyXMPPDateTimeString(d) {
  function pad(n) { return n < 10 ? '0' + n : n.toString() }
  return d.getUTCFullYear()
    + pad(d.getUTCMonth() + 1)
    + pad(d.getUTCDate()) + 'T'
    + pad(d.getUTCHours()) + ':'
    + pad(d.getUTCMinutes()) + ':'
    + pad(d.getUTCSeconds())
}

module.exports = function legacyTimeResultParser() {
  
  return function legacyTimeResultParser(stanza, next) {
    if (!stanza.is('iq')) { return next(); }
    if (stanza.type != 'result') { return next(); }
    var query = stanza.getChild('query', 'jabber:iq:time');
    if (!query) { return next(); }
    
    var utcEl = query.getChild('utc');
    if (utcEl) {
      var match = /(\d{4})(\d{2})(\d{2})T(\d{2}):(\d{2}):(\d{2})/.exec(utcEl.getText());
      if (match) {
        stanza.utcDate = new Date(Date.UTC(match[1], match[2] - 1, match[3], match[4], match[5], match[6]));
      }
    }
    var tzEl = query.getChild('tz');
    if (tzEl) {
      stanza.timezone = tzEl.getText();
    }
    var displayEl = query.getChild('display');
    if (displayEl) {
      stanza.display = displayEl.getText();
    }
    next();
  }
}

var events = require('events');
var util = require('util');
require('../../node-xmpp/element_ext');

module.exports = function message(fn) {
  if (!fn) throw new Error('message middleware requires a callback function');
  
  var handler = new Handler();
  fn.call(this, handler);
  
  return function message(stanza, next) {
    if (!stanza.isMessage()) { return next(); }
    handler._handle(stanza);
    next();
  }
}

util.inherits(Handler, events.EventEmitter);

module.exports = function messageParser() {
  
  return function messageParser(stanza, next) {
    if (!stanza.is('message')) { return next(); }
    
    var subject = stanza.getChild('subject');
    if (subject) { stanza.subject = subject.getText(); }
    
    var body = stanza.getChild('body');
    if (body) { stanza.body = body.getText(); }
    
    var thread = stanza.getChild('thread');
    if (thread) {
      stanza.thread = thread.getText();
      stanza.parentThread = thread.attrs.parent;
    }
    
    next();
  }
}

module.exports = function nicknameParser() {
  
  return function nicknameParser(stanza, next) {
    if (!(stanza.is('message') || stanza.is('presence'))) { return next(); }
    var nick = stanza.getChild('nick', 'http://jabber.org/protocol/nick');
    if (!nick) { return next(); }
    
    stanza.nickname = nick.getText();
    next();
  }
}

var util = require('util')
  , Store = require('./store');

function MemoryStore(options) {
  options = options || {};
  this._hash = {};
  this._timeout = options.timeout;
}

util.inherits(MemoryStore, Store);

MemoryStore.prototype.get = function(key, fn) {
  var self = this;
  process.nextTick(function(){
    var data = self._hash[key];
    if (data) {
      data = JSON.parse(data);
      fn(null, data);
    } else {
      fn();
    }
  });
}

MemoryStore.prototype.set = function(key, data, fn) {
  var self = this;
  process.nextTick(function(){
    self._hash[key] = JSON.stringify(data);
    fn && fn();
  });
  if (this._timeout) {
    setTimeout(function() {
      self.remove(key);
    }, this._timeout);
  }
};

MemoryStore.prototype.remove = function(key, fn) {
  var self = this;
  process.nextTick(function(){
    delete self._hash[key];
    fn && fn();
  });
};

module.exports = MemoryStore;

function Store() {
}

Store.prototype.get = function(key, callback) {
  throw new Error('Store#get must be overridden by subclass');
}

Store.prototype.set = function(key, data, callback) {
  throw new Error('Store#set must be overridden by subclass');
}

Store.prototype.remove = function(key, callback) {
  throw new Error('Store#remove must be overridden by subclass');
}

module.exports = Store;

var util = require('util')
  , Store = require('./pending/store')
  , MemoryStore = require('./pending/memorystore');

function pending(options) {
  options = options || {};
  var store = options.store;
  var autoRemove = (typeof options.autoRemove === 'undefined') ? true : options.autoRemove;
  
  if (!store) throw new Error('pending middleware requires a store');
  
  return function pending(stanza, next) {
    if (!stanza.id || !(stanza.type == 'result' || stanza.type == 'error')) {
      return next();
    }
    
    var key = stanza.from + ':' + stanza.id;
    store.get(key, function(err, data) {
      if (err) {
        next(err);
      } else if (!data) {
        next();
      } else {
        stanza.irt =
        stanza.inReplyTo = 
        stanza.inResponseTo =
        stanza.regarding = data;
        if (autoRemove) { store.remove(key); }
        next();
      }
    });
  }
}

exports = module.exports = pending;

exports.Store = Store;
exports.MemoryStore = MemoryStore;

var StanzaError = require('../stanzaerror');

module.exports = function ping() {
  
  return function ping(req, res, next) {
    if (!req.is('iq')) { return next(); }
    var ping = req.getChild('ping', 'urn:xmpp:ping');
    if (!ping) { return next(); }
    
    if (req.type != 'get') {
      return next(new StanzaError("Ping must be an IQ-get stanza.", 'modify', 'bad-request'));
    }
    
    // Send ping response.
    res.send();
  }
}

var events = require('events');
var util = require('util');
require('../../node-xmpp/element_ext');

module.exports = function presence(fn) {
  if (!fn) throw new Error('presence middleware requires a callback function');
  
  var handler = new Handler();
  fn.call(this, handler);
  
  return function presence(stanza, next) {
    if (!stanza.isPresence()) { return next(); }
    handler._handle(stanza);
    next();
  }
}

util.inherits(Handler, events.EventEmitter);

module.exports = function presenceParser() {
  
  return function presenceParser(stanza, next) {
    if (!stanza.is('presence')) { return next(); }
    
    var show = stanza.getChild('show');
    if (show) {
      stanza.show = show.getText();
    } else if (!stanza.attrs.type) {
      stanza.show = 'online';
    }
    
    var status = stanza.getChild('status');
    if (status) { stanza.status = status.getText(); }
    
    var priority = stanza.getChild('priority');
    if (priority) {
      stanza.priority = parseInt(priority.getText());
    } else {
      stanza.priority = 0;
    }
    
    next();
  }
}

var util = require('util');
var StanzaError = require('../stanzaerror');

module.exports = function serviceDiscovery(identities, features) {
  identities = identities || [];
  features = features || [];
  if (!Array.isArray(identities)) { identities = [ identities ]; }
  if (!Array.isArray(features)) { features = [ features ]; }
  
  return function serviceDiscovery(req, res, next) {
    if (!req.is('iq')) { return next(); }
    if (req.type == 'result' || req.type == 'error') { return next(); }
    var query = req.getChild('query', 'http://jabber.org/protocol/disco#info');
    if (!query) { return next(); }
    
    if (req.type != 'get') {
      return next(new StanzaError("Query must be an IQ-get stanza.", 'modify', 'bad-request'));
    }
    if (query.attrs.node) {
      return next(new StanzaError("", 'cancel', 'item-not-found'));
    }
    
    var info = res.c('query', { xmlns: 'http://jabber.org/protocol/disco#info' });
    identities.forEach(function(identity) {
      var ide = info.c('identity', { category: identity.category,
                                     type: identity.type });
      if (identity.name) { ide.attrs.name = identity.name };
    });
    features.forEach(function(feature) {
      info.c('feature', { var: feature });
    });
    res.send();
  }
}

var StanzaError = require('../stanzaerror');
require('../../node-xmpp/element_ext');

module.exports = function serviceUnavailable() {
  return function serviceUnavailable(req, res, next) {
    if (!req.isIQ()) { return next(); }
    res.attrs.type = 'error';
    res.c('error', { type: 'cancel' }).c('service-unavailable', { xmlns: 'urn:ietf:params:xml:ns:xmpp-stanzas' });
    res.send();
  }
}

var StanzaError = require('../stanzaerror');

module.exports = function softwareVersion(name, version, os) {
  
  return function softwareVersion(req, res, next) {
    if (!req.is('iq')) { return next(); }
    if (req.type == 'result' || req.type == 'error') { return next(); }
    var query = req.getChild('query', 'jabber:iq:version');
    if (!query) { return next(); }
    
    if (req.type != 'get') {
      return next(new StanzaError("Query must be an IQ-get stanza.", 'modify', 'bad-request'));
    }
    
    var ver = res.c('query', { xmlns: 'jabber:iq:version' });
    if (name) { ver.c('name').t(name); }
    if (version) { ver.c('version').t(version); }
    if (os) { ver.c('os').t(os); }
    res.send();
  }
}

module.exports = function softwareVersionResultParser() {
  
  return function softwareVersionResultParser(stanza, next) {
    if (!stanza.is('iq')) { return next(); }
    if (stanza.type != 'result') { return next(); }
    var query = stanza.getChild('query', 'jabber:iq:version');
    if (!query) { return next(); }
    
    var nameEl = query.getChild('name');
    if (nameEl) {
      stanza.application = nameEl.getText();
    }
    var versionEl = query.getChild('version');
    if (versionEl) {
      stanza.version = versionEl.getText();
    }
    var osEl = query.getChild('os');
    if (osEl) {
      stanza.os = osEl.getText();
    }
    next();
  }
}

var StanzaError = require('../stanzaerror');

module.exports = function time(options) {
  options = options || {};
  
  return function time(req, res, next) {
    if (!req.is('iq')) { return next(); }
    if (req.type == 'result' || req.type == 'error') { return next(); }
    var te = req.getChild('time', 'urn:xmpp:time');
    if (!te) { return next(); }
    
    if (req.type != 'get') {
      return next(new StanzaError("Time must be an IQ-get stanza.", 'modify', 'bad-request'));
    }
    
    var now = options.date || new Date();
    var tzo = (typeof options.timezoneOffset !== 'undefined') ? options.timezoneOffset : now.getTimezoneOffset();
    var t = res.c('time', { xmlns: 'urn:xmpp:time' });
    t.c('utc').t(XSDDateTimeString(now));
    t.c('tzo').t(XSDTimeZoneString(tzo));
    res.send();
  }
}


// CREDIT: https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Date
function XSDDateTimeString(d) {
  function pad(n) { return n < 10 ? '0' + n : n }
  return d.getUTCFullYear() + '-'
    + pad(d.getUTCMonth() + 1) + '-'
    + pad(d.getUTCDate()) + 'T'
    + pad(d.getUTCHours()) + ':'
    + pad(d.getUTCMinutes()) + ':'
    + pad(d.getUTCSeconds()) + 'Z'
}

function XSDTimeZoneString(tzo) {
  function sign(n) { return n > 0 ? '+' : '-' }
  function pad(n) { return n < 10 ? '0' + n : n.toString() }
  return sign(0 - tzo)
    + pad(Math.floor(Math.abs(tzo) / 60)) + ':'
    + pad(Math.abs(tzo) % 60);
}

module.exports = function timeResultParser() {
  
  return function timeResultParser(stanza, next) {
    if (!stanza.is('iq')) { return next(); }
    if (stanza.type != 'result') { return next(); }
    var time = stanza.getChild('time', 'urn:xmpp:time');
    if (!time) { return next(); }
    
    var utcEl = time.getChild('utc');
    if (utcEl) {
      stanza.utcDate = new Date(utcEl.getText());
    }
    var tzoEl = time.getChild('tzo');
    if (tzoEl) {
      stanza.timezoneOffset = timezoneOffsetFromUTC(tzoEl.getText());
    }
    next();
  }
}


function timezoneOffsetFromUTC(tzo) {
  function parse(s) {
    var match = /([+\-])([0-9]{2}):(\d{2})/.exec(s);
    if (match) {
      var min = (parseInt(match[2], 10) * 60) + parseInt(match[3], 10);
      return match[1] == '+' ? min : 0 - min;
    }
    return 0;
  }
  return 0 - parse(tzo);
}

var util = require('util')
  , EventEmitter = require('events').EventEmitter;

util.inherits(NullStream, EventEmitter);

module.exports = NullStream;

var util = require('util');

function StanzaError(message, type, condition) {
  Error.apply(this, arguments);
  Error.captureStackTrace(this, arguments.callee);
  this.name = 'StanzaError';
  this.message = message || null;
  this.type = type || 'wait';
  this.condition = condition || 'internal-server-error';
};

util.inherits(StanzaError, Error);

exports = module.exports = StanzaError;