class HTTP::Request

def caching
  Caching.new self
end

def connect_using_proxy(socket)
  Request::Writer.new(socket, nil, proxy_connect_headers, proxy_connect_header).connect_through_proxy
end

def default_host_header_value
  PORTS[@scheme] != port ? "#{host}:#{port}" : host
end

def headline
  request_uri = using_proxy? ? uri : uri.omit(:scheme, :authority)
  "#{verb.to_s.upcase} #{request_uri} HTTP/#{version}"
end

def include_proxy_authorization_header
  headers["Proxy-Authorization"] = proxy_authorization_header
end

def initialize(verb, uri, headers = {}, proxy = {}, body = nil, version = "1.1") # rubocop:disable ParameterLists
  @verb   = verb.to_s.downcase.to_sym
  @uri    = HTTP::URI.parse(uri).normalize
  @scheme = @uri.scheme && @uri.scheme.to_s.downcase.to_sym
  fail(UnsupportedMethodError, "unknown method: #{verb}") unless METHODS.include?(@verb)
  fail(UnsupportedSchemeError, "unknown scheme: #{scheme}") unless SCHEMES.include?(@scheme)
  @proxy, @body, @version = proxy, body, version
  @headers = HTTP::Headers.coerce(headers || {})
  @headers["Host"]        ||= default_host_header_value
  @headers["User-Agent"]  ||= USER_AGENT
end

def port
  @uri.port || @uri.default_port
end

def proxy_authorization_header
  digest = Base64.strict_encode64("#{proxy[:proxy_username]}:#{proxy[:proxy_password]}")
  "Basic #{digest}"
end

def proxy_connect_header
  "CONNECT #{@uri.host}:#{@uri.port} HTTP/#{version}"
end

def proxy_connect_headers
  connect_headers = HTTP::Headers.coerce(
    "Host" => headers["Host"],
    "User-Agent" => headers["User-Agent"]
  )
  connect_headers["Proxy-Authorization"] = proxy_authorization_header if using_authenticated_proxy?
  connect_headers
end

def redirect(uri, verb = @verb)
  req = self.class.new(verb, @uri.join(uri), headers, proxy, body, version)
  req["Host"] = req.uri.host
  req
end

def socket_host
  using_proxy? ? proxy[:proxy_address] : host
end

def socket_port
  using_proxy? ? proxy[:proxy_port] : port
end

def stream(socket)
  include_proxy_authorization_header if using_authenticated_proxy? && !@uri.https?
  Request::Writer.new(socket, body, headers, headline).stream
end

def using_authenticated_proxy?
  proxy && proxy.keys.size == 4
end

def using_proxy?
  proxy && proxy.keys.size >= 2
end