module HTTP::Chainable

def accept(type)
  headers Headers::ACCEPT => MimeType.normalize(type)
end

def auth(value, opts = nil)
  # shim for deprecated auth(:basic, opts).
  # will be removed in 0.8.0
  return basic_auth(opts) if :basic == value
  headers Headers::AUTHORIZATION => value.to_s
end

def basic_auth(opts)
  user = opts.fetch :user
  pass = opts.fetch :pass
  auth("Basic " << Base64.strict_encode64("#{user}:#{pass}"))
end

def branch(options)
  HTTP::Client.new(options)
end

def connect(uri, options = {})
  request :connect, uri, options
end

def cookies(cookies)
  branch default_options.with_cookies(cookies)
end

def default_headers
  default_options.headers
end

def default_headers=(headers)
  @default_options = default_options.dup do |opts|
    opts.headers = headers
  end
end

def default_options
  @default_options ||= HTTP::Options.new
end

def default_options=(opts)
  @default_options = HTTP::Options.new(opts)
end

def delete(uri, options = {})
  request :delete, uri, options
end

def follow(opts = {})
  branch default_options.with_follow opts
end

def get(uri, options = {})
  request :get, uri, options
end

def head(uri, options = {})
  request :head, uri, options
end

def headers(headers)
  branch default_options.with_headers(headers)
end

def options(uri, options = {})
  request :options, uri, options
end

def patch(uri, options = {})
  request :patch, uri, options
end

def persistent(host)
  p_client = branch default_options.with_persistent host
  return p_client unless block_given?
  yield p_client
ensure
  p_client.close
end

def post(uri, options = {})
  request :post, uri, options
end

def put(uri, options = {})
  request :put, uri, options
end

def request(verb, uri, options = {})
  branch(options).request verb, uri
end

def timeout(klass, options = {})
  klass, options = :per_operation, klass if klass.is_a? Hash
  klass = case klass.to_sym
          when :null          then HTTP::Timeout::Null
          when :global        then HTTP::Timeout::Global
          when :per_operation then HTTP::Timeout::PerOperation
          else fail ArgumentError, "Unsupported Timeout class: #{klass}"
          end
  [:read, :write, :connect].each do |k|
    next unless options.key? k
    options["#{k}_timeout".to_sym] = options.delete k
  end
  branch default_options.merge(
    :timeout_class => klass,
    :timeout_options => options
  )
end

def trace(uri, options = {})
  request :trace, uri, options
end

def via(*proxy)
  proxy_hash = {}
  proxy_hash[:proxy_address]  = proxy[0] if proxy[0].is_a?(String)
  proxy_hash[:proxy_port]     = proxy[1] if proxy[1].is_a?(Integer)
  proxy_hash[:proxy_username] = proxy[2] if proxy[2].is_a?(String)
  proxy_hash[:proxy_password] = proxy[3] if proxy[3].is_a?(String)
  if [2, 4].include?(proxy_hash.keys.size)
    branch default_options.with_proxy(proxy_hash)
  else
    fail(RequestError, "invalid HTTP proxy: #{proxy_hash}")
  end
end