class HTTP::Request

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 =
    if using_proxy? && !uri.https?
      uri.omit(:fragment)
    else
      uri.request_uri
    end
  "#{verb.to_s.upcase} #{request_uri} HTTP/#{version}"
end

def include_proxy_authorization_header
  headers[Headers::PROXY_AUTHORIZATION] = proxy_authorization_header
end

def include_proxy_headers
  headers.merge!(proxy[:proxy_headers]) if proxy.key?(:proxy_headers)
  include_proxy_authorization_header if using_authenticated_proxy?
end

def initialize(opts)
  @verb           = opts.fetch(:verb).to_s.downcase.to_sym
  @uri_normalizer = opts[:uri_normalizer] || HTTP::URI::NORMALIZER
  @uri    = @uri_normalizer.call(opts.fetch(:uri))
  @scheme = @uri.scheme.to_s.downcase.to_sym if @uri.scheme
  raise(UnsupportedMethodError, "unknown method: #{verb}") unless METHODS.include?(@verb)
  raise(UnsupportedSchemeError, "unknown scheme: #{scheme}") unless SCHEMES.include?(@scheme)
  @proxy   = opts[:proxy] || {}
  @version = opts[:version] || "1.1"
  @headers = prepare_headers(opts[:headers])
  @body    = prepare_body(opts[:body])
end

def inspect
  "#<#{self.class}/#{@version} #{verb.to_s.upcase} #{uri}>"
end

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

def prepare_body(body)
  body.is_a?(Request::Body) ? body : Request::Body.new(body)
end

def prepare_headers(headers)
  headers = HTTP::Headers.coerce(headers || {})
  headers[Headers::HOST]        ||= default_host_header_value
  headers[Headers::USER_AGENT]  ||= USER_AGENT
  headers
end

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

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

def proxy_connect_headers
  connect_headers = HTTP::Headers.coerce(
    Headers::HOST        => headers[Headers::HOST],
    Headers::USER_AGENT  => headers[Headers::USER_AGENT]
  )
  connect_headers[Headers::PROXY_AUTHORIZATION] = proxy_authorization_header if using_authenticated_proxy?
  connect_headers.merge!(proxy[:proxy_headers]) if proxy.key?(:proxy_headers)
  connect_headers
end

def redirect(uri, verb = @verb)
  headers = self.headers.dup
  headers.delete(Headers::HOST)
  self.class.new(
    :verb           => verb,
    :uri            => @uri.join(uri),
    :headers        => headers,
    :proxy          => proxy,
    :body           => body.source,
    :version        => version,
    :uri_normalizer => uri_normalizer
  )
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_headers if using_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