class Faraday::Request::Retry

def build_exception_matcher(exceptions)
  matcher = Module.new
  (
  class << matcher
    self
  end).class_eval do
    define_method(:===) do |error|
      exceptions.any? do |ex|
        if ex.is_a? Module
          error.is_a? ex
        else
          Object.const_defined?(ex.to_s) && error.is_a?(Object.const_get(ex.to_s))
        end
      end
    end
  end
  matcher
end

def calculate_retry_after(env)
  response_headers = env[:response_headers]
  return unless response_headers
  retry_after_value = env[:response_headers]['Retry-After']
  # Try to parse date from the header value
  begin
    datetime = DateTime.rfc2822(retry_after_value)
    datetime.to_time - Time.now.utc
  rescue ArgumentError
    retry_after_value.to_f
  end
end

def calculate_retry_interval(retries)
  retry_index = @options.max - retries
  current_interval = @options.interval *
                     (@options.backoff_factor**retry_index)
  current_interval = [current_interval, @options.max_interval].min
  random_interval = rand * @options.interval_randomness.to_f *
                    @options.interval
  current_interval + random_interval
end

def calculate_sleep_amount(retries, env)
  retry_after = calculate_retry_after(env)
  retry_interval = calculate_retry_interval(retries)
  return if retry_after && retry_after > @options.max_interval
  if retry_after && retry_after >= retry_interval
    retry_after
  else
    retry_interval
  end
end

def call(env)
  retries = @options.max
  request_body = env[:body]
  begin
    # after failure env[:body] is set to the response body
    env[:body] = request_body
    @app.call(env).tap do |resp|
      if @options.retry_statuses.include?(resp.status)
        raise Faraday::RetriableResponse.new(nil, resp)
      end
    end
  rescue @errmatch => e
    if retries.positive? && retry_request?(env, e)
      retries -= 1
      rewind_files(request_body)
      @options.retry_block.call(env, @options, retries, e)
      if (sleep_amount = calculate_sleep_amount(retries + 1, env))
        sleep sleep_amount
        retry
      end
    end
    raise unless e.is_a?(Faraday::RetriableResponse)
    e.response
  end
end

def initialize(app, options = nil)
  super(app)
  @options = Options.from(options)
  @errmatch = build_exception_matcher(@options.exceptions)
end

def retry_request?(env, exception)
  @options.methods.include?(env[:method]) ||
    @options.retry_if.call(env, exception)
end

def rewind_files(body)
  return unless body.is_a?(Hash)
  body.each do |_, value|
    value.rewind if value.is_a?(UploadIO)
  end
end