class HTTP::Message

def body_encoding
  @http_header.body_encoding
end

def content
  @http_body.content
end

def content_type
  @http_header.content_type
end

def content_type=(content_type)
  @http_header.content_type = content_type
end

def cookies
  set_cookies = http_header['set-cookie']
  unless set_cookies.empty?
    uri = http_header.request_uri
    set_cookies.map { |str|
      cookie = WebAgent::Cookie.new
      cookie.parse(str, uri)
      cookie
    }
  end
end

def create_query_part_str(query) # :nodoc:
  if multiparam_query?(query)
    escape_query(query)
  elsif query.respond_to?(:read)
    query = query.read
  else
    query.to_s
  end
end

def dump(dev = '')
  str = @http_header.dump + CRLF
  if @http_header.chunked
    dev = @http_body.dump_chunked(str, dev)
  elsif @http_body
    dev = @http_body.dump(str, dev)
  else
    dev << str
  end
  dev
end

def escape(str) # :nodoc:
  str.dup.force_encoding(Encoding::ASCII_8BIT).gsub(/([^ a-zA-Z0-9_.-]+)/) {
    '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
  }.tr(' ', '+')
end

def escape(str) # :nodoc:
  str.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
    '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
  }.tr(' ', '+')
end

def escape_query(query) # :nodoc:
  pairs = []
  query.each { |attr, value|
    left = escape(attr.to_s) << '='
    if values = Array.try_convert(value)
      values.each { |value|
        if value.respond_to?(:read)
          value = value.read
        end
        pairs.push(left + escape(value.to_s))
      }
    else
      if value.respond_to?(:read)
        value = value.read
      end
      pairs.push(left << escape(value.to_s))
    end
  }
  pairs.join('&')
end

def file?(obj)
  obj.respond_to?(:read) and obj.respond_to?(:pos) and
    obj.respond_to?(:pos=)
end

def headers
  Hash[*http_header.all.flatten]
end

def http_body=(body)
  @http_body = body
  @http_header.body_size = @http_body.size if @http_header
end

def http_version
  @http_header.http_version
end

def http_version=(http_version)
  @http_header.http_version = http_version
end

def initialize # :nodoc:
  @http_header = Headers.new
  @http_body = @peer_cert = nil
end

def internal_mime_type(path)
  case path
  when /\.txt$/i
    'text/plain'
  when /\.(htm|html)$/i
    'text/html'
  when /\.doc$/i
    'application/msword'
  when /\.png$/i
    'image/png'
  when /\.gif$/i
    'image/gif'
  when /\.(jpg|jpeg)$/i
    'image/jpeg'
  else
    'application/octet-stream'
  end
end

def keep_alive_enabled?(version)
  version >= '1.1'
end

def mime_type(path) # :nodoc:
  if @@mime_type_handler
    res = @@mime_type_handler.call(path)
    if !res || res.to_s == ''
      return 'application/octet-stream'
    else
      return res
    end
  else
    internal_mime_type(path)
  end
end

def mime_type_handler
  @@mime_type_handler
end

def mime_type_handler=(handler)
  @@mime_type_handler = handler
end

def multiparam_query?(query)
  query.is_a?(Array) or query.is_a?(Hash)
end

def new_connect_request(uri)
  m = new
  m.http_header.init_connect_request(uri)
  m.http_header.body_size = nil
  m
end

def new_request(method, uri, query = nil, body = nil, boundary = nil)
  m = new
  m.http_header.init_request(method, uri, query)
  m.http_body = Body.new
  m.http_body.init_request(body || '', boundary)
  if body
    m.http_header.body_size = m.http_body.size
    m.http_header.chunked = true if m.http_body.size.nil?
  else
    m.http_header.body_size = nil
  end
  m
end

def new_response(body, req = nil)
  m = new
  m.http_header.init_response(Status::OK, req)
  m.http_body = Body.new
  m.http_body.init_response(body)
  m.http_header.body_size = m.http_body.size || 0
  m
end

def ok?
  HTTP::Status.successful?(status)
end

def parse(query)
  params = Hash.new([].freeze)
  query.split(/[&;]/n).each do |pairs|
    key, value = pairs.split('=',2).collect{|v| unescape(v) }
    if params.has_key?(key)
      params[key].push(value)
    else
      params[key] = [value]
    end
  end
  params
end

def reason
  @http_header.reason_phrase
end

def reason=(reason)
  @http_header.reason_phrase = reason
end

def redirect?
  HTTP::Status.redirect?(status)
end

def see_other?
  status == HTTP::Status::SEE_OTHER
end

def status
  @http_header.status_code
end

def status=(status)
  @http_header.status_code = status
end

def unescape(string)
  string.tr('+', ' ').gsub(/((?:%[0-9a-fA-F]{2})+)/n) do
    [$1.delete('%')].pack('H*')
  end
end

def version
  warn(VERSION_WARNING)
  @http_header.http_version.to_f
end

def version=(version)
  warn(VERSION_WARNING)
  @http_header.http_version = version
end