class ActiveSupport::Cache::Store

def cleanup(options = nil)
  raise NotImplementedError.new("#{self.class.name} does not support cleanup")
end

def clear(options = nil)
  raise NotImplementedError.new("#{self.class.name} does not support clear")
end

def decrement(name, amount = 1, options = nil)
  raise NotImplementedError.new("#{self.class.name} does not support decrement")
end

def default_coder
  Coders[Cache.format_version]
end

def delete(name, options = nil)
  options = merged_options(options)
  instrument(:delete, name) do
    delete_entry(normalize_key(name, options), **options)
  end
end

def delete_entry(key, **options)
  raise NotImplementedError.new
end

def delete_matched(matcher, options = nil)
  raise NotImplementedError.new("#{self.class.name} does not support delete_matched")
end

def delete_multi(names, options = nil)
  options = merged_options(options)
  names.map! { |key| normalize_key(key, options) }
  instrument :delete_multi, names do
    delete_multi_entries(names, **options)
  end
end

def delete_multi_entries(entries, **options)
  entries.count { |key| delete_entry(key, **options) }
end

def deserialize_entry(payload)
  payload.nil? ? nil : @coder.load(payload)
end

def ensure_connection_pool_added!
  require "connection_pool"
rescue LoadError => e
  $stderr.puts "You don't have connection_pool installed in your application. Please add it to your Gemfile and run bundle install"
  raise e
end

def exist?(name, options = nil)
  options = merged_options(options)
  instrument(:exist?, name) do |payload|
    entry = read_entry(normalize_key(name, options), **options, event: payload)
    (entry && !entry.expired? && !entry.mismatched?(normalize_version(name, options))) || false
  end
end

def expanded_key(key)
  return key.cache_key.to_s if key.respond_to?(:cache_key)
  case key
  when Array
    if key.size > 1
      key.collect { |element| expanded_key(element) }
    else
      expanded_key(key.first)
    end
  when Hash
    key.collect { |k, v| "#{k}=#{v}" }.sort!
  else
    key
  end.to_param
end

def expanded_version(key)
  case
  when key.respond_to?(:cache_version) then key.cache_version.to_param
  when key.is_a?(Array)                then key.map { |element| expanded_version(element) }.tap(&:compact!).to_param
  when key.respond_to?(:to_a)          then expanded_version(key.to_a)
  end
end

def fetch(name, options = nil, &block)
  if block_given?
    options = merged_options(options)
    key = normalize_key(name, options)
    entry = nil
    instrument(:read, name, options) do |payload|
      cached_entry = read_entry(key, **options, event: payload) unless options[:force]
      entry = handle_expired_entry(cached_entry, key, options)
      entry = nil if entry && entry.mismatched?(normalize_version(name, options))
      payload[:super_operation] = :fetch if payload
      payload[:hit] = !!entry if payload
    end
    if entry
      get_entry_value(entry, name, options)
    else
      save_block_result_to_cache(name, options, &block)
    end
  elsif options && options[:force]
    raise ArgumentError, "Missing block: Calling `Cache#fetch` with `force: true` requires a block."
  else
    read(name, options)
  end
end

def fetch_multi(*names)
  raise ArgumentError, "Missing block: `Cache#fetch_multi` requires a block." unless block_given?
  options = names.extract_options!
  options = merged_options(options)
  instrument :read_multi, names, options do |payload|
    reads   = read_multi_entries(names, **options)
    writes  = {}
    ordered = names.index_with do |name|
      reads.fetch(name) { writes[name] = yield(name) }
    end
    payload[:hits] = reads.keys
    payload[:super_operation] = :fetch_multi
    write_multi(writes, options)
    ordered
  end
end

def get_entry_value(entry, name, options)
  instrument(:fetch_hit, name, options) { }
  entry.value
end

def handle_expired_entry(entry, key, options)
  if entry && entry.expired?
    race_ttl = options[:race_condition_ttl].to_i
    if (race_ttl > 0) && (Time.now.to_f - entry.expires_at <= race_ttl)
      # When an entry has a positive :race_condition_ttl defined, put the stale entry back into the cache
      # for a brief period while the entry is being recalculated.
      entry.expires_at = Time.now.to_f + race_ttl
      write_entry(key, entry, expires_in: race_ttl * 2)
    else
      delete_entry(key, **options)
    end
    entry = nil
  end
  entry
end

def increment(name, amount = 1, options = nil)
  raise NotImplementedError.new("#{self.class.name} does not support increment")
end

def initialize(options = nil)
  @options = options ? normalize_options(options) : {}
  @options[:compress] = true unless @options.key?(:compress)
  @options[:compress_threshold] = DEFAULT_COMPRESS_LIMIT unless @options.key?(:compress_threshold)
  @coder = @options.delete(:coder) { default_coder } || NullCoder
  @coder_supports_compression = @coder.respond_to?(:dump_compressed)
end

def instrument(operation, key, options = nil)
  if logger && logger.debug? && !silence?
    logger.debug "Cache #{operation}: #{normalize_key(key, options)}#{options.blank? ? "" : " (#{options.inspect})"}"
  end
  payload = { key: key, store: self.class.name }
  payload.merge!(options) if options.is_a?(Hash)
  ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload) { yield(payload) }
end

def key_matcher(pattern, options) # :doc:
  prefix = options[:namespace].is_a?(Proc) ? options[:namespace].call : options[:namespace]
  if prefix
    source = pattern.source
    if source.start_with?("^")
      source = source[1, source.length]
    else
      source = ".*#{source[0, source.length]}"
    end
    Regexp.new("^#{Regexp.escape(prefix)}:#{source}", pattern.options)
  else
    pattern
  end
end

def merged_options(call_options)
  if call_options
    call_options = normalize_options(call_options)
    if options.empty?
      call_options
    else
      options.merge(call_options)
    end
  else
    options
  end
end

def mute
  previous_silence, @silence = defined?(@silence) && @silence, true
  yield
ensure
  @silence = previous_silence
end

def namespace_key(key, options = nil)
  options = merged_options(options)
  namespace = options[:namespace]
  if namespace.respond_to?(:call)
    namespace = namespace.call
  end
  if key && key.encoding != Encoding::UTF_8
    key = key.dup.force_encoding(Encoding::UTF_8)
  end
  if namespace
    "#{namespace}:#{key}"
  else
    key
  end
end

def new_entry(value, options = nil) # :nodoc:
  Entry.new(value, **merged_options(options))
end

def normalize_key(key, options = nil)
  namespace_key expanded_key(key), options
end

def normalize_options(options)
  options = options.dup
  OPTION_ALIASES.each do |canonical_name, aliases|
    alias_key = aliases.detect { |key| options.key?(key) }
    options[canonical_name] ||= options[alias_key] if alias_key
    options.except!(*aliases)
  end
  options
end

def normalize_version(key, options = nil)
  (options && options[:version].try(:to_param)) || expanded_version(key)
end

def read(name, options = nil)
  options = merged_options(options)
  key     = normalize_key(name, options)
  version = normalize_version(name, options)
  instrument(:read, name, options) do |payload|
    entry = read_entry(key, **options, event: payload)
    if entry
      if entry.expired?
        delete_entry(key, **options)
        payload[:hit] = false if payload
        nil
      elsif entry.mismatched?(version)
        payload[:hit] = false if payload
        nil
      else
        payload[:hit] = true if payload
        entry.value
      end
    else
      payload[:hit] = false if payload
      nil
    end
  end
end

def read_entry(key, **options)
  raise NotImplementedError.new
end

def read_multi(*names)
  options = names.extract_options!
  options = merged_options(options)
  instrument :read_multi, names, options do |payload|
    read_multi_entries(names, **options, event: payload).tap do |results|
      payload[:hits] = results.keys
    end
  end
end

def read_multi_entries(names, **options)
  names.each_with_object({}) do |name, results|
    key   = normalize_key(name, options)
    entry = read_entry(key, **options)
    next unless entry
    version = normalize_version(name, options)
    if entry.expired?
      delete_entry(key, **options)
    elsif !entry.mismatched?(version)
      results[name] = entry.value
    end
  end
end

def retrieve_pool_options(options)
  {}.tap do |pool_options|
    pool_options[:size] = options.delete(:pool_size) if options[:pool_size]
    pool_options[:timeout] = options.delete(:pool_timeout) if options[:pool_timeout]
  end
end

def save_block_result_to_cache(name, options)
  result = instrument(:generate, name, options) do
    yield(name)
  end
  write(name, result, options) unless result.nil? && options[:skip_nil]
  result
end

def serialize_entry(entry, **options)
  options = merged_options(options)
  if @coder_supports_compression && options[:compress]
    @coder.dump_compressed(entry, options[:compress_threshold] || DEFAULT_COMPRESS_LIMIT)
  else
    @coder.dump(entry)
  end
end

def silence!
  @silence = true
  self
end

def write(name, value, options = nil)
  options = merged_options(options)
  instrument(:write, name, options) do
    entry = Entry.new(value, **options.merge(version: normalize_version(name, options)))
    write_entry(normalize_key(name, options), entry, **options)
  end
end

def write_entry(key, entry, **options)
  raise NotImplementedError.new
end

def write_multi(hash, options = nil)
  options = merged_options(options)
  instrument :write_multi, hash, options do |payload|
    entries = hash.each_with_object({}) do |(name, value), memo|
      memo[normalize_key(name, options)] = Entry.new(value, **options.merge(version: normalize_version(name, options)))
    end
    write_multi_entries entries, **options
  end
end

def write_multi_entries(hash, **options)
  hash.each do |key, entry|
    write_entry key, entry, **options
  end
end