module ActionDispatch::Http::Cache::Response

def cache_control_headers
  cache_control = {}
  cache_control_segments.each do |segment|
    directive, argument = segment.split("=", 2)
    if SPECIAL_KEYS.include? directive
      directive.tr!("-", "_")
      cache_control[directive.to_sym] = argument || true
    else
      cache_control[:extras] ||= []
      cache_control[:extras] << segment
    end
  end
  cache_control
end

def cache_control_segments
  if cache_control = _cache_control
    cache_control.delete(" ").split(",")
  else
    []
  end
end

def date
  if date_header = get_header(DATE)
    Time.httpdate(date_header)
  end
end

def date=(utc_time)
  set_header DATE, utc_time.httpdate
end

def date?
  has_header? DATE
end

def etag=(weak_validators)
  self.weak_etag = weak_validators
end

def etag?; etag; end

def generate_strong_etag(validators)
  %("#{ActiveSupport::Digest.hexdigest(ActiveSupport::Cache.expand_cache_key(validators))}")
end

def generate_weak_etag(validators)
  "W/#{generate_strong_etag(validators)}"
end

def handle_conditional_get!
  # Normally default cache control setting is handled by ETag
  # middleware. But, if an etag is already set, the middleware
  # defaults to `no-cache` unless a default `Cache-Control` value is
  # previously set. So, set a default one here.
  if (etag? || last_modified?) && !self._cache_control
    self._cache_control = DEFAULT_CACHE_CONTROL
  end
end

def last_modified
  if last = get_header(LAST_MODIFIED)
    Time.httpdate(last)
  end
end

def last_modified=(utc_time)
  set_header LAST_MODIFIED, utc_time.httpdate
end

def last_modified?
  has_header? LAST_MODIFIED
end

def merge_and_normalize_cache_control!(cache_control)
  control = cache_control_headers
  return if control.empty? && cache_control.empty?  # Let middleware handle default behavior
  if cache_control.any?
    # Any caching directive coming from a controller overrides
    # no-cache/no-store in the default Cache-Control header.
    control.delete(:no_cache)
    control.delete(:no_store)
    if extras = control.delete(:extras)
      cache_control[:extras] ||= []
      cache_control[:extras] += extras
      cache_control[:extras].uniq!
    end
    control.merge! cache_control
  end
  options = []
  if control[:no_store]
    options << PRIVATE if control[:private]
    options << NO_STORE
  elsif control[:no_cache]
    options << PUBLIC if control[:public]
    options << NO_CACHE
    options.concat(control[:extras]) if control[:extras]
  else
    extras = control[:extras]
    max_age = control[:max_age]
    stale_while_revalidate = control[:stale_while_revalidate]
    stale_if_error = control[:stale_if_error]
    options << "max-age=#{max_age.to_i}" if max_age
    options << (control[:public] ? PUBLIC : PRIVATE)
    options << MUST_REVALIDATE if control[:must_revalidate]
    options << "stale-while-revalidate=#{stale_while_revalidate.to_i}" if stale_while_revalidate
    options << "stale-if-error=#{stale_if_error.to_i}" if stale_if_error
    options.concat(extras) if extras
  end
  self._cache_control = options.join(", ")
end

def prepare_cache_control!
  @cache_control = cache_control_headers
end

def strong_etag=(strong_validators)
  set_header "ETag", generate_strong_etag(strong_validators)
end

def strong_etag?
  etag? && !weak_etag?
end

def weak_etag=(weak_validators)
  set_header "ETag", generate_weak_etag(weak_validators)
end

def weak_etag?
  etag? && etag.start_with?('W/"')
end