class Faraday::Connection

def authorization(type, token)
  set_authorization_header(:authorization, type, token)
end

def basic_auth(login, pass)
  set_authorization_header(:basic_auth, login, pass)
end

def build_exclusive_url(url = nil, params = nil, params_encoder = nil)
  url = nil if url.respond_to?(:empty?) && url.empty?
  base = url_prefix
  if url && base.path && base.path !~ %r{/$}
    base = base.dup
    base.path = "#{base.path}/" # ensure trailing slash
  end
  uri = url ? base + url : base
  if params
    uri.query = params.to_query(params_encoder || options.params_encoder)
  end
  # rubocop:disable Style/SafeNavigation
  uri.query = nil if uri.query && uri.query.empty?
  # rubocop:enable Style/SafeNavigation
  uri
end

def build_request(method)
  Request.create(method) do |req|
    req.params  = params.dup
    req.headers = headers.dup
    req.options = options.dup
    yield(req) if block_given?
  end
end

def build_url(url = nil, extra_params = nil)
  uri = build_exclusive_url(url)
  query_values = params.dup.merge_query(uri.query, options.params_encoder)
  query_values.update(extra_params) if extra_params
  uri.query =
    if query_values.empty?
      nil
    else
      query_values.to_query(options.params_encoder)
    end
  uri
end

def close
  app.close
end

def default_parallel_manager
  @default_parallel_manager ||= begin
    adapter = @builder.adapter.klass if @builder.adapter
    if support_parallel?(adapter)
      adapter.setup_parallel_manager
    elsif block_given?
      yield
    end
  end
end

def dup
  self.class.new(build_exclusive_url,
                 headers: headers.dup,
                 params: params.dup,
                 builder: builder.dup,
                 ssl: ssl.dup,
                 request: options.dup)
end

def find_default_proxy
  uri = ENV['http_proxy']
  return unless uri && !uri.empty?
  uri = "http://#{uri}" unless uri.match?(/^http/i)
  uri
end

def headers=(hash)
  @headers.replace hash
end

def in_parallel(manager = nil)
  @parallel_manager = manager || default_parallel_manager do
    warn 'Warning: `in_parallel` called but no parallel-capable adapter ' \
         'on Faraday stack'
    warn caller[2, 10].join("\n")
    nil
  end
  yield
  @parallel_manager&.run
ensure
  @parallel_manager = nil
end

def in_parallel?
  !!@parallel_manager
end

def initialize(url = nil, options = nil)
  options = ConnectionOptions.from(options)
  if url.is_a?(Hash) || url.is_a?(ConnectionOptions)
    options = options.merge(url)
    url     = options.url
  end
  @parallel_manager = nil
  @headers = Utils::Headers.new
  @params  = Utils::ParamsHash.new
  @options = options.request
  @ssl = options.ssl
  @default_parallel_manager = options.parallel_manager
  @builder = options.builder || begin
    # pass an empty block to Builder so it doesn't assume default middleware
    options.new_builder(block_given? ? proc { |b| } : nil)
  end
  self.url_prefix = url || 'http:/'
  @params.update(options.params)   if options.params
  @headers.update(options.headers) if options.headers
  initialize_proxy(url, options)
  yield(self) if block_given?
  @headers[:user_agent] ||= "Faraday v#{VERSION}"
end

def initialize_proxy(url, options)
  @manual_proxy = !!options.proxy
  @proxy =
    if options.proxy
      ProxyOptions.from(options.proxy)
    else
      proxy_from_env(url)
    end
end

def options(*args)
  return @options if args.size.zero?
  url, params, headers = *args
  run_request(:options, url, nil, headers) do |request|
    request.params.update(params) if params
    yield request if block_given?
  end
end

def params=(hash)
  @params.replace hash
end

def path_prefix=(value)
  url_prefix.path = if value
                      value = "/#{value}" unless value[0, 1] == '/'
                      value
                    end
end

def proxy=(new_value)
  @manual_proxy = true
  @proxy = new_value ? ProxyOptions.from(new_value) : nil
end

def proxy_for_request(url)
  return proxy if @manual_proxy
  if url && Utils.URI(url).absolute?
    proxy_from_env(url)
  else
    proxy
  end
end

def proxy_from_env(url)
  return if Faraday.ignore_env_proxy
  uri = nil
  if URI.parse('').respond_to?(:find_proxy)
    case url
    when String
      uri = Utils.URI(url)
      uri = URI.parse("#{uri.scheme}://#{uri.hostname}").find_proxy
    when URI
      uri = url.find_proxy
    when nil
      uri = find_default_proxy
    end
  else
    warn 'no_proxy is unsupported' if ENV['no_proxy'] || ENV['NO_PROXY']
    uri = find_default_proxy
  end
  ProxyOptions.from(uri) if uri
end

def run_request(method, url, body, headers)
  unless METHODS.include?(method)
    raise ArgumentError, "unknown http method: #{method}"
  end
  request = build_request(method) do |req|
    req.options.proxy = proxy_for_request(url)
    req.url(url)                if url
    req.headers.update(headers) if headers
    req.body = body             if body
    yield(req) if block_given?
  end
  builder.build_response(self, request)
end

def set_authorization_header(header_type, *args)
  header = Faraday::Request
           .lookup_middleware(header_type)
           .header(*args)
  headers[Faraday::Request::Authorization::KEY] = header
end

def support_parallel?(adapter)
  adapter&.respond_to?(:supports_parallel?) && adapter&.supports_parallel?
end

def token_auth(token, options = nil)
  set_authorization_header(:token_auth, token, options)
end

def url_prefix=(url, encoder = nil)
  uri = @url_prefix = Utils.URI(url)
  self.path_prefix = uri.path
  params.merge_query(uri.query, encoder)
  uri.query = nil
  with_uri_credentials(uri) do |user, password|
    basic_auth user, password
    uri.user = uri.password = nil
  end
end

def with_uri_credentials(uri)
  return unless uri.user && uri.password
  yield(Utils.unescape(uri.user), Utils.unescape(uri.password))
end