Express

var exports = module.exports = require('connect').middleware;

exports.version = '1.0.0';

var Server = exports.Server = require('./server');

exports.createServer = function(){
  return new Server(Array.prototype.slice.call(arguments));
};

require('./view');

require('./response');

require('./request');

var http = require('http')
  , utils = require('./utils')
  , mime = require('connect/utils').mime;

var flashFormatters = exports.flashFormatters = {
  s: function(val){
    return String(val);
  }
};

http.IncomingMessage.prototype.header = function(name, defaultValue){
  return this.headers[name.toLowerCase()] || defaultValue;
};

http.IncomingMessage.prototype.accepts = function(type){
  var accept = this.header('Accept');
  if (!accept || accept === '*

http.IncomingMessage.prototype.param = function(name){
  // Route params like /user/:id
  if (this.params[name] !== undefined) {
    return this.params[name]; 
  }
  // Query string params
  if (this.query[name] !== undefined) {
    return this.query[name]; 
  }
  // Request body params via connect.bodyDecoder
  if (this.body && this.body[name] !== undefined) {
    return this.body[name];
  }
};

http.IncomingMessage.prototype.flash = function(type, msg){
  var msgs = this.session.flash = this.session.flash || {};
  if (type && msg) {
    var i = 2
      , args = arguments
      , formatters = this.app.flashFormatters || {};
    formatters.__proto__ = flashFormatters;
    msg = utils.miniMarkdown(utils.htmlEscape(msg));
    msg = msg.replace(/%([a-zA-Z])/g, function(_, format){
      var formatter = formatters[format];
      if (formatter) return formatter(args[i++]);
    });
    return (msgs[type] = msgs[type] || []).push(msg);
  } else if (type) {
    var arr = msgs[type];
    delete msgs[type];
    return arr || [];
  } else {
    this.session.flash = {};
    return msgs;
  }
};

http.IncomingMessage.prototype.is = function(type){
  var fn = this.app.is(type);
  if (fn) return fn(this);
  var contentType = this.headers['content-type'];
  if (!contentType) return;
  if (!~type.indexOf('/')) type = mime.type('.' + type);
  // TODO: remove when connect no longer appends charset...
  if (~type.indexOf(';')) type = type.split(';')[0];
  if (~type.indexOf('*')) {
    type = type.split('/')
    contentType = contentType.split('/');
    if ('*' == type[0] && type[1] == contentType[1]) return true;
    if ('*' == type[1] && type[0] == contentType[0]) return true;
  }
  return ~contentType.indexOf(type);
};

// Callback for isXMLHttpRequest / xhr

function isxhr() {
  return this.header('X-Requested-With', '').toLowerCase() === 'xmlhttprequest';
}

http.IncomingMessage.prototype.__defineGetter__('isXMLHttpRequest', isxhr);
http.IncomingMessage.prototype.__defineGetter__('xhr', isxhr);

var fs = require('fs')
  , http = require('http')
  , path = require('path')
  , pump = require('sys').pump
  , utils = require('connect/utils')
  , mime = require('connect/utils').mime
  , parseRange = require('./utils').parseRange;

var multiple = ['Set-Cookie'];

http.ServerResponse.prototype.send = function(body, headers, status){
  // Allow status as second arg
  if (typeof headers === 'number') {
    status = headers,
    headers = null;
  }

  // Defaults
  status = status || 200;

  // Allow 0 args as 204
  if (!arguments.length) {
    body = status = 204;
  }

  // Determine content type
  switch (typeof body) {
    case 'number':
      if (!this.headers['Content-Type']) {
        this.contentType('.txt');
      }
      body = http.STATUS_CODES[status = body];
      break;
    case 'string':
      if (!this.headers['Content-Type']) {
        this.contentType('.html');
      }
      break;
    case 'object':
      if (body instanceof Buffer) {
        if (!this.headers['Content-Type']) {
          this.contentType('.bin');
        }
      } else {
        if (!this.headers['Content-Type']) {
          this.contentType('.json');
        }
        body = JSON.stringify(body);
        if (this.req.query.callback && this.app.settings['jsonp callback']) {
          this.header('Content-Type', 'text/javascript');
          body = this.req.query.callback + '(' + body + ');';
        }
      }
      break;
  }

  // Populate Content-Length
  if (!this.headers['Content-Length']) {
    this.header('Content-Length', body instanceof Buffer
      ? body.length
      : Buffer.byteLength(body));
  }

  // Merge headers passed
  if (headers) {
    var fields = Object.keys(headers);
    for (var i = 0, len = fields.length; i < len; ++i) {
      var field = fields[i];
      this.header(field, headers[field]);
    }
  }

  // Strip irrelevant headers
  if (204 === status) {
    delete this.headers['Content-Type'];
    delete this.headers['Content-Length'];
  }

  // Respond
  this.writeHead(status, this.headers);
  this.end('HEAD' == this.req.method ? undefined : body);
};

http.ServerResponse.prototype.sendfile = function(path, fn){
  var self = this
    , streamThreshold = this.app.set('stream threshold') || 32 * 1024
    , ranges = self.req.headers.range;

  if (~path.indexOf('..')) this.send(403);

  function error(err) {
    delete self.headers['Content-Disposition'];
    if (fn) {
      fn(err, path);
    } else {
      self.req.next(err);
    }
  }

  fs.stat(path, function(err, stat){
    if (err) return error(err);
    if (stat.size >= streamThreshold) {
      var status = 200;
      if (ranges) ranges = parseRange(stat.size, ranges);
      if (ranges) {
        var stream = fs.createReadStream(path, ranges[0])
          , start = ranges[0].start
          , end = ranges[0].end;
        status = 206;
        self.header('Content-Range', 'bytes '
          + start
          + '-'
          + end
          + '/'
          + stat.size);
      } else {
        var stream = fs.createReadStream(path);
      }
      self.contentType(path);
      self.header('Accept-Ranges', 'bytes');
      self.writeHead(status, self.headers);
      pump(stream, self, function(err){
        fn && fn(err, path, true);
      });
    } else {
      fs.readFile(path, function(err, buf){
        if (err) return error(err);
        self.contentType(path);
        self.send(buf);
        fn && fn(null, path);
      });
    }
  });
};

http.ServerResponse.prototype.contentType = function(type){
  return this.header('Content-Type', mime.type(type));
};

http.ServerResponse.prototype.attachment = function(filename){
  this.header('Content-Disposition', filename
    ? 'attachment; filename="' + path.basename(filename) + '"'
    : 'attachment');
  return this;
};

http.ServerResponse.prototype.download = function(path, filename, fn){
  this.attachment(filename || path).sendfile(path, fn);
};

http.ServerResponse.prototype.header = function(name, val){
  if (val === undefined) {
    return this.headers[name];
  } else {
    if (this.headers[name] && ~multiple.indexOf(name)) {
      return this.headers[name] += '\r\n' + name + ': ' + val;
    } else {
      return this.headers[name] = val;
    }
  }
};

http.ServerResponse.prototype.clearCookie = function(name){
  this.cookie(name, '', { expires: new Date(1) });
};

http.ServerResponse.prototype.cookie = function(name, val, options){
  var cookie = utils.serializeCookie(name, val, options);
  this.header('Set-Cookie', cookie);
};

http.ServerResponse.prototype.redirect = function(url, status){
  var basePath = this.app.set('home') || '/'
    , status = status || 302
    , body;

  // Setup redirect map
  var map = {
    back: this.req.headers.referrer || this.req.headers.referer || basePath,
    home: basePath
  };

  // Support custom redirect map
  map.__proto__ = this.app.redirects;

  // Attempt mapped redirect
  var mapped = typeof map[url] === 'function'
    ? map[url](this.req, this)
    : map[url];

  // Perform redirect
  url = mapped || url;

  // Support text/{plain,html} by default
  if (this.req.accepts('html')) {
    body = '<p>' + http.STATUS_CODES[status] + '. Redirecting to <a href="' + url + '">' + url + '</a></p>';
    this.header('Content-Type', 'text/html');
  } else {
    body = http.STATUS_CODES[status] + '. Redirecting to ' + url;
    this.header('Content-Type', 'text/plain');
  }

  // Respond
  this.send(body, { Location: url }, status);
};

var url = require('url')
  , view = require('./view')
  , connect = require('connect')
  , utils = connect.utils
  , queryString = require('querystring')
  , router = require('connect/middleware/router');

var Server = exports = module.exports = function Server(middleware){
  var self = this;
  this.config = {};
  this.settings = {};
  this.redirects = {};
  this.isCallbacks = {};
  this.viewHelpers = {};
  this.dynamicViewHelpers = {};
  this.errorHandlers = [];
  connect.Server.call(this, middleware || []);

  // Default "home" to / 
  this.set('home', '/');

  // DEPRECATED: remove in 1.0
  if (process.env.EXPRESS_ENV) {
    process.env.NODE_ENV = process.env.EXPRESS_ENV;
    console.warn('\x1b[33mWarning\x1b[0m: EXPRESS_ENV is deprecated, use NODE_ENV.');
  }

  // TODO: remove when Connect removes "Server" ...
  this.showVersion = false;

  // Set "env" to NODE_ENV, defaulting to "development"
  this.set('env', process.env.NODE_ENV || 'development');

  // Expose objects to each other
  this.use(function(req, res, next){
    req.query = {};
    res.headers = { 'X-Powered-By': 'Express' };
    req.app = res.app = self;
    req.res = res;
    res.req = req;
    req.next = next;
    // Assign req.params.get
    if (req.url.indexOf('?') > 0) {
      var query = url.parse(req.url).query;
      req.query = exports.parseQueryString(query);
    }
    next();
  });

  // Use router, expose as app.get(), etc
  var fn = router(function(app){ self.routes = app; });
  this.__defineGetter__('router', function(){
    this.__usedRouter = true;
    return fn;
  });
};

Server.prototype.__proto__ = connect.Server.prototype;

exports.parseQueryString = queryString.parse;

Server.prototype.listen = function(){
  this.registerErrorHandlers();
  connect.Server.prototype.listen.apply(this, arguments);
};

Server.prototype.listenFD = function(){
  this.registerErrorHandlers();
  connect.Server.prototype.listenFD.apply(this, arguments);
};

Server.prototype.registerErrorHandlers = function(){
  this.errorHandlers.forEach(function(fn){
    this.use(function(err, req, res, next){
      fn.apply(this, arguments);
    });
  }, this);
  return this;
};

Server.prototype.use = function(route, middleware){
  if (typeof route !== 'string') {
    middleware = route, route = '/';
  }

  connect.Server.prototype.use.call(this, route, middleware);

  // Mounted an app
  if (middleware instanceof Server) {
    // Home is /:route/:home
    var app = middleware
      , home = app.set('home');
    if (home === '/') home = '';
    app.set('home', (app.route || '') + home);
    app.parent = this;
    // Mounted hook
    if (app.__mounted) app.__mounted.call(app, this);
  }

  return this;
};

Server.prototype.mounted = function(fn){
  this.__mounted = fn;
  return this;
};

Server.prototype.register = function(){
  view.register.apply(this, arguments);
  return this;
};

Server.prototype.helpers = function(obj){
  utils.merge(this.viewHelpers, obj);
  return this;
};

Server.prototype.dynamicHelpers = function(obj){
  utils.merge(this.dynamicViewHelpers, obj);
  return this;
};

Server.prototype.error = function(fn){
  this.errorHandlers.push(fn);
  return this;
};

Server.prototype.is = function(type, fn){
  if (!fn) return this.isCallbacks[type];
  this.isCallbacks[type] = fn;
  return this;
};

Server.prototype.set = function(setting, val){
  if (val === undefined) {
    if (this.settings.hasOwnProperty(setting)) {
      return this.settings[setting];
    } else if (this.parent) {
      return this.parent.set(setting);
    }
  } else {
    this.settings[setting] = val;
    return this;
  }
};

Server.prototype.enable = function(setting){
  return this.set(setting, true);
};

Server.prototype.disable = function(setting){
  return this.set(setting, false);
};

Server.prototype.redirect = function(key, url){
  this.redirects[key] = url;
  return this;
};

Server.prototype.configure = function(env, fn){
  if (typeof env === 'function') {
    fn = env, env = 'all';
  }
  if (env === 'all' || this.set('env') === env) {
    fn.call(this);
  }
  return this;
};

// Generate routing methods

(function(method){
  Server.prototype[method] = function(path, fn){
    var self = this;

    // Ensure router is mounted
    if (!this.__usedRouter) {
      this.use(this.router);
    }

    // Route specific middleware support
    if (arguments.length > 2) {
      var args = Array.prototype.slice.call(arguments, 1);
      fn = args.pop();
      (function stack(middleware){
        middleware.forEach(function(fn){
          if (Array.isArray(fn)) {
            stack(fn);
          } else {
            self[method](path, fn);
          }
        });
      })(args);
    }

    // Generate the route
    this.routes[method](path, fn);
    return this;
  };
  return arguments.callee;
})('get')('post')('put')('delete')('all');

// Alias delete as "del"

Server.prototype.del = Server.prototype.delete;

exports.miniMarkdown = function(str){
  return String(str)
    .replace(/(__|\*\*)(.*?)\1/g, '<strong>$2</strong>')
    .replace(/(_|\*)(.*?)\1/g, '<em>$2</em>')
    .replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
};

exports.htmlEscape = function(html) {
  return String(html)
    .replace(/&/g, '&')
    .replace(/"/g, '"')
    .replace(/</g, '<')
    .replace(/>/g, '>');
};

exports.parseRange = function(size, str){
  var valid = true;
  var arr = str.substr(6).split(',').map(function(range){
    var range = range.split('-')
      , start = parseInt(range[0], 10)
      , end = parseInt(range[1], 10);

    // -500
    if (isNaN(start)) {
      start = size - end;
      end = size - 1;
    // 500-
    } else if (isNaN(end)) {
      end = size - 1;
    }

    // Invalid
    if (isNaN(start) || isNaN(end) || start > end) valid = false;

    return { start: start, end: end };
  });
  return valid ? arr : undefined;
};

var extname = require('path').extname
  , utils = require('connect').utils
  , http = require('http')
  , fs = require('fs')
  , mime = utils.mime;

var cache = {};

var viewCache = {};

var viewNameCache = {};

function cacheViewSync(path) {
  return viewCache[path] = fs.readFileSync(path, 'utf8');
}

function viewRoot(app) {
  return app.set('views') || process.cwd() + '/views';
}

function objectName(view) {
  return view.split('/').slice(-1)[0].split('.')[0];
}

exports.register = function(ext, exports) {
  cache[ext] = exports;
};

http.ServerResponse.prototype.partial = function(view, options, ext, locals){
  locals = locals || {};

  // Inherit parent view extension when not present
  if (ext && view.indexOf('.') < 0) {
    view += ext;
  }

  // Allow collection to be passed as second param
  if (options) {
    if ('length' in options) {
      options = { collection: options };
    } else if (!options.collection && !options.locals && !options.object) {
      options = { object: options };
    }
  } else {
    options = {};
  }

  // Inherit locals from parent
  options.locals = options.locals
    ? utils.merge(locals, options.locals)
    : locals;

  // Partials dont need layouts
  options.partial = true;
  options.layout = false;

  // Deduce name from view path
  var name = options.as
    || viewNameCache[view]
    || (viewNameCache[view] = objectName(view));

  // Collection support
  var collection = options.collection;
  if (collection) {
    var len = collection.length
      , buf = '';
    delete options.collection;
    options.locals.collectionLength = len;
    for (var i = 0; i < len; ++i) {
      var val = collection[i];
      options.locals.firstInCollection = i === 0;
      options.locals.indexInCollection = i;
      options.locals.lastInCollection = i === len - 1;
      options.object = val;
      buf += this.partial(view, options);
    }
    return buf;
  } else {
    if (options.object) {
      if ('string' == typeof name) {
        options.locals[name] = options.object;
      } else if (name === global) {
        utils.merge(options.locals, options.object);
      } else {
        options.scope = options.object;
      }
    }
    return this.render(view, options);
  }
};

http.ServerResponse.prototype.render = function(view, options, fn){
  // Support callback function as second arg
  if (typeof options === 'function') {
    fn = options, options = {};
  }
  
  var options = options || {}
    , app = this.app
    , viewOptions = app.settings['view options']
    , defaultEngine = app.settings['view engine'];

  // Mixin "view options"
  if (viewOptions) options.__proto__ = viewOptions;

  // Support "view engine" setting
  if (view.indexOf('.') < 0 && defaultEngine) {
    view += '.' + defaultEngine;
  }

  // Defaults
  var self = this
    , helpers = this.app.viewHelpers
    , dynamicHelpers = this.app.dynamicViewHelpers
    , root = viewRoot(this.app)
    , ext = extname(view)
    , partial = options.partial
    , layout = options.layout === undefined ? true : options.layout
    , layout = layout === true
      ? 'layout' + ext
      : layout;

  // Allow layout name without extension
  if (typeof layout === 'string' && layout.indexOf('.') < 0) {
    layout += ext;
  }

  // Default execution scope to the response
  options.scope = options.scope || this.req;

  // Auto-cache in production
  if ('production' == app.settings.env) {
    options.cache = true;
  }

  // Partials support
  if (options.partial) {
    root = app.settings.partials || root + '/partials';
  }

  // View path
  var path = view[0] === '/'
    ? view
    : root + '/' + view;

  // Pass filename to the engine and view
  var locals = options.locals = options.locals || {};
  options.locals.__filename = options.filename = path;

  // Dynamic helper support
  if (false !== options.dynamicHelpers) {
    // cache
    if (!this.__dynamicHelpers) {
      this.__dynamicHelpers = {};
      var keys = Object.keys(dynamicHelpers);
      for (var i = 0, len = keys.length; i < len; ++i) {
        var key = keys[i]
          , val = dynamicHelpers[key];
        if (typeof val === 'function') {
          this.__dynamicHelpers[key] = val.call(
                this.app
              , this.req
              , this);
        }
      }
    }

    // apply
    helpers.__proto__ = this.__dynamicHelpers;
  }

  // Merge view helpers
  options.locals.__proto__ = helpers;

  // Always expose partial() as a local
  options.locals.partial = function(view, options){
    return self.partial.call(self, view, options, ext, locals);
  };

  function error(err) {
    if (fn) {
      fn(err);
    } else {
      self.req.next(err);
    }
  }

  // Cache contents
  try {
    var str = (options.cache ? viewCache[path] : null) || cacheViewSync(path);
  } catch (err) {
    return error(err);
  }

  // Cache template engine exports
  var engine = cache[ext] || (cache[ext] = require(ext.substr(1)));

  // Attempt render
  try {
    var str = engine.render(str, options);
  } catch (err) {
    return error(err);
  }

  // Layout support
  if (layout) {
    options.layout = false;
    options.locals.body = str;
    options.isLayout = true;
    self.render(layout, options, fn);
  } else if (partial) {
    return str;
  } else if (fn) {
    fn(null, str);
  } else {
    this.send(str, options.headers, options.status);
  }
};