var Negotiation = require("./negotiate");
  var HtmlApps = require("./html");
  
  /**
   * {Object * String} a mapping of HTTP status codes to
   * their standard descriptions.
   */
  // Every standard HTTP code mapped to the appropriate message.
  // Stolen from Rack which stole from Mongrel
  exports.statusCodes = {
      100: 'Continue',
      101: 'Switching Protocols',
      102: 'Processing',
      200: 'OK',
      201: 'Created',
      202: 'Accepted',
      203: 'Non-Authoritative Information',
      204: 'No Content',
      205: 'Reset Content',
      206: 'Partial Content',
      207: 'Multi-Status',
      300: 'Multiple Choices',
      301: 'Moved Permanently',
      302: 'Found',
      303: 'See Other',
      304: 'Not Modified',
      305: 'Use Proxy',
      307: 'Temporary Redirect',
      400: 'Bad Request',
      401: 'Unauthorized',
      402: 'Payment Required',
      403: 'Forbidden',
      404: 'Not Found',
      405: 'Method Not Allowed',
      406: 'Not Acceptable',
      407: 'Proxy Authentication Required',
      408: 'Request Timeout',
      409: 'Conflict',
      410: 'Gone',
      411: 'Length Required',
      412: 'Precondition Failed',
      413: 'Request Entity Too Large',
      414: 'Request-URI Too Large',
      415: 'Unsupported Media Type',
      416: 'Request Range Not Satisfiable',
      417: 'Expectation Failed',
      422: 'Unprocessable Entity',
      423: 'Locked',
      424: 'Failed Dependency',
      500: 'Internal Server Error',
      501: 'Not Implemented',
      502: 'Bad Gateway',
      503: 'Service Unavailable',
      504: 'Gateway Timeout',
      505: 'HTTP Version Not Supported',
      507: 'Insufficient Storage'
  };
  
  /**
   * {Object * Number} a mapping from HTTP status descriptions
   * to HTTP status codes.
   */
  exports.statusMessages = {};
  for (var code in exports.statusCodes)
      exports.statusMessages[exports.statusCodes[code]] = +code;
  
  /**
   * Determines whether an HTTP response should have a
   * response body, based on its status code.
   * @param {Number} status
   * @returns whether the HTTP response for the given status
   * code has content.
   */
  exports.statusWithNoEntityBody = function (status) {
      return (status >= 100 && status <= 199) ||
          status == 204 || status == 304;
  };
  
  /**
   * @param {Number} status
   * @returns {Function(Request) :Response} a JSGI app that returns
   * a plain text response with the given status code.
   */
  exports.appForStatus = function (status) {
      return function (request) {
          return exports.responseForStatus(request, status, request.method + " " + request.path);
      };
  };
  
  /**
   * @param {Number} status an HTTP status code
   * @param {String} message (optional) a message to include
   * in the response body.
   * @returns a JSGI HTTP response object with the given status
   * code and message as its body, if the status supports
   * a body.
   */
  exports.responseForStatus = function(request, status, addendum) {
      if (exports.statusCodes[status] === undefined)
          throw "Unknown status code";
  
      var message = exports.statusCodes[status];
  
      // RFC 2616, 10.2.5:
      // The 204 response MUST NOT include a message-body, and thus is always
      // terminated by the first empty line after the header fields.
      // RFC 2616, 10.3.5:
      // The 304 response MUST NOT contain a message-body, and thus is always
      // terminated by the first empty line after the header fields.
      if (exports.statusWithNoEntityBody(status)) {
          return {status: status, headers: {}};
      } else {
          var handlers = {};
          handlers["text/plain"] = exports.textResponseForStatus;
          if (request.handleHtmlFragmentResponse) {
              handlers["text/html"] = exports.htmlResponseForStatus;
          }
          var responseForStatus = Negotiation.negotiate(request, handlers) || exports.textResponseForStatus;
          return responseForStatus(request, status, message, addendum);
      }
  };
  
  exports.textResponseForStatus = function (request, status, message, addendum) {
      var content = message + "\n";
      if (addendum) {
          content += addendum + "\n";
      }
      var contentLength = content.length;
      return {
          status: status,
          statusMessage: message,
          headers: {
              "content-length": contentLength
          },
          body: [content]
      };
  };
  
  exports.htmlResponseForStatus = function (request, status, message, addendum) {
      return {
          status: status,
          statusMessage: message,
          headers: {},
          htmlTitle: message,
          htmlFragment: {
              forEach: function (write) {
                  write("<h1>" + HtmlApps.escapeHtml(message) + "</h1>\n");
                  write("<p>Status: " + status + "</p>\n");
                  if (addendum) {
                      write("<pre>" + HtmlApps.escapeHtml(addendum) + "</pre>\n");
                  }
              }
          }
      }
  };
  
  /**
   * {App} an application that returns a 400 response.
   */
  exports.badRequest = exports.appForStatus(400);
  /**
   * {App} an application that returns a 404 response.
   */
  exports.notFound = exports.appForStatus(404);
  /**
   * {App} an application that returns a 405 response.
   */
  exports.methodNotAllowed = exports.appForStatus(405);
  /**
   * {App} an application that returns a 405 response.
   */
  exports.noLanguage =
  exports.notAcceptable = exports.appForStatus(406);