class Faraday::HttpCache

def call(env)
  dup.call!(env)
end

def call!(env)
  @trace = []
  @request = create_request(env)
  response = nil
  if @request.cacheable?
    response = process(env)
  else
    trace :unacceptable
    response = @app.call(env)
  end
  response.on_complete do
    delete(@request, response) if should_delete?(response.status, @request.method)
    log_request
    response.env[:http_cache_trace] = @trace
    instrument(response.env)
  end
end

def create_request(env)
  Request.from_env(env)
end

def create_response(env)
  hash = env.to_hash
  {
    status: hash[:status],
    body: hash[:body],
    response_headers: hash[:response_headers]
  }
end

def delete(request, response)
  headers = %w(Location Content-Location)
  headers.each do |header|
    url = response.headers[header]
    @storage.delete(url) if url
  end
  @storage.delete(request.url)
  trace :delete
end

def extract_status(trace)
  CACHE_STATUSES.find { |status| trace.include?(status) }
end

def fetch(env)
  trace :miss
  @app.call(env).on_complete do |fresh_env|
    response = Response.new(create_response(fresh_env))
    store(response)
  end
end

def initialize(app, store: nil, serializer: nil, shared_cache: true, instrumenter: nil, instrument_name: EVENT_NAME, logger: nil) # rubocop:disable Metrics/ParameterLists
  super(app)
  @logger = logger
  @shared_cache = shared_cache
  @instrumenter = instrumenter
  @instrument_name = instrument_name
  @storage = Storage.new(store: store, serializer: serializer, logger: logger)
end

def instrument(env)
  return unless @instrumenter
  payload = {
    env: env,
    cache_status: extract_status(env[:http_cache_trace])
  }
  @instrumenter.instrument(@instrument_name, payload)
  # DEPRECATED: Event name from the 1.1.1 release that isn't compatible
  # with the `ActiveSupport::LogSubscriber` API.
  @instrumenter.instrument('process_request.http_cache.faraday', payload)
end

def log_request
  return unless @logger
  method = @request.method.to_s.upcase
  path = @request.url.request_uri
  @logger.debug { "HTTP Cache: [#{method} #{path}] #{@trace.join(', ')}" }
end

def process(env)
  entry = @storage.read(@request)
  return fetch(env) if entry.nil?
  if entry.fresh? && !@request.no_cache?
    response = entry.to_response(env)
    trace :fresh
  else
    trace :must_revalidate
    response = validate(entry, env)
  end
  response
end

def shared_cache?
  @shared_cache
end

def should_delete?(status, method)
  UNSAFE_METHODS.include?(method) && !ERROR_STATUSES.cover?(status)
end

def store(response)
  if shared_cache? ? response.cacheable_in_shared_cache? : response.cacheable_in_private_cache?
    trace :store
    @storage.write(@request, response)
  else
    trace :uncacheable
  end
end

def trace(operation)
  @trace << operation
end

def validate(entry, env)
  headers = env[:request_headers]
  headers['If-Modified-Since'] = entry.last_modified if entry.last_modified
  headers['If-None-Match'] = entry.etag if entry.etag
  @app.call(env).on_complete do |requested_env|
    response = Response.new(requested_env)
    if response.not_modified?
      trace :valid
      updated_response_headers = response.payload[:response_headers]
      # These headers are not allowed in 304 responses, yet some proxy
      # servers add them in. Don't override the values from the original
      # response.
      updated_response_headers.delete('Content-Type')
      updated_response_headers.delete('Content-Length')
      updated_payload = entry.payload
      updated_payload[:response_headers].update(updated_response_headers)
      requested_env.update(updated_payload)
      response = Response.new(updated_payload)
    else
      trace :invalid
    end
    store(response)
  end
end