class HTTP::Client

def close
  @connection.close if @connection
  @connection = nil
  @state = :clean
end

def initialize(default_options = {})
  @default_options = HTTP::Options.new(default_options)
  @connection = nil
  @state = :clean
end

def make_request_body(opts, headers)
  case
  when opts.body
    opts.body
  when opts.form
    form = HTTP::FormData.create opts.form
    headers[Headers::CONTENT_TYPE]   ||= form.content_type
    headers[Headers::CONTENT_LENGTH] ||= form.content_length
    form.to_s
  when opts.json
    headers[Headers::CONTENT_TYPE] ||= "application/json"
    MimeType[:json].encode opts.json
  end
end

def make_request_headers(opts)
  headers = opts.headers
  # Tell the server to keep the conn open
  if default_options.persistent?
    headers[Headers::CONNECTION] = KEEP_ALIVE
  else
    headers[Headers::CONNECTION] = CLOSE
  end
  cookies = opts.cookies.values
  unless cookies.empty?
    cookies = opts.headers.get(Headers::COOKIE).concat(cookies).join("; ")
    headers[Headers::COOKIE] = cookies
  end
  headers
end

def make_request_uri(uri, opts)
  uri = uri.to_s
  if default_options.persistent? && uri !~ HTTP_OR_HTTPS_RE
    uri = "#{default_options.persistent}#{uri}"
  end
  uri = HTTP::URI.parse uri
  if opts.params && !opts.params.empty?
    uri.query = [uri.query, HTTP::URI.form_encode(opts.params)].compact.join("&")
  end
  # Some proxies (seen on WEBRick) fail if URL has
  # empty path (e.g. `http://example.com`) while it's RFC-complaint:
  # http://tools.ietf.org/html/rfc1738#section-3.1
  uri.path = "/" if uri.path.empty?
  uri
end

def perform(req, options)
  verify_connection!(req.uri)
  @state = :dirty
  @connection ||= HTTP::Connection.new(req, options)
  unless @connection.failed_proxy_connect?
    @connection.send_request(req)
    @connection.read_headers!
  end
  res = Response.new(
    :status     => @connection.status_code,
    :version    => @connection.http_version,
    :headers    => @connection.headers,
    :connection => @connection,
    :encoding   => options.encoding,
    :uri        => req.uri
  )
  @connection.finish_response if req.verb == :head
  @state = :clean
  res
rescue
  close
  raise
end

def request(verb, uri, opts = {})
  opts    = @default_options.merge(opts)
  uri     = make_request_uri(uri, opts)
  headers = make_request_headers(opts)
  body    = make_request_body(opts, headers)
  proxy   = opts.proxy
  req = HTTP::Request.new(
    :verb    => verb,
    :uri     => uri,
    :headers => headers,
    :proxy   => proxy,
    :body    => body
  )
  res = perform(req, opts)
  return res unless opts.follow
  Redirector.new(opts.follow).perform(req, res) do |request|
    perform(request, opts)
  end
end

def verify_connection!(uri)
  if default_options.persistent? && uri.origin != default_options.persistent
    fail StateError, "Persistence is enabled for #{default_options.persistent}, but we got #{uri.origin}"
  # We re-create the connection object because we want to let prior requests
  # lazily load the body as long as possible, and this mimics prior functionality.
  elsif @connection && (!@connection.keep_alive? || @connection.expired?)
    close
  # If we get into a bad state (eg, Timeout.timeout ensure being killed)
  # close the connection to prevent potential for mixed responses.
  elsif @state == :dirty
    close
  end
end