class ActiveSupport::Cache::Store

def _instrument(operation, multi: false, options: nil, **payload, &block)
  if logger && logger.debug? && !silence?
    debug_key =
      if multi
        ": #{payload[:key].size} key(s) specified"
      elsif payload[:key]
        ": #{normalize_key(payload[:key], options)}"
      end
    debug_options = " (#{options.inspect})" unless options.blank?
    logger.debug "Cache #{operation}#{debug_key}#{debug_options}"
  end
  payload[:store] = self.class.name
  payload.merge!(options) if options.is_a?(Hash)
  ActiveSupport::Notifications.instrument("cache_#{operation}.active_support", payload) do
    block&.call(payload)
  end
end

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_serializer
  case Cache.format_version
  when 6.1
    ActiveSupport.deprecator.warn <<~EOM
      Support for `config.active_support.cache_format_version = 6.1` has been deprecated and will be removed in Rails 7.2.
      Check the Rails upgrade guide at https://guides.rubyonrails.org/upgrading_ruby_on_rails.html#new-activesupport-cache-serialization-format
      for more information on how to upgrade.
    EOM
    Cache::SerializerWithFallback[:marshal_6_1]
  when 7.0
    Cache::SerializerWithFallback[:marshal_7_0]
  when 7.1
    Cache::SerializerWithFallback[:marshal_7_1]
  else
    raise ArgumentError, "Unrecognized ActiveSupport::Cache.format_version: #{Cache.format_version.inspect}"
  end
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)
  return 0 if names.empty?
  options = merged_options(options)
  names.map! { |key| normalize_key(key, options) }
  instrument_multi :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)
rescue DeserializationError
  nil
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
    unless options[:force]
      instrument(:read, name, options) do |payload|
        cached_entry = read_entry(key, **options, event: payload)
        entry = handle_expired_entry(cached_entry, key, options)
        if entry
          if entry.mismatched?(normalize_version(name, options))
            entry = nil
          else
            begin
              entry.value
            rescue DeserializationError
              entry = nil
            end
          end
        end
        payload[:super_operation] = :fetch if payload
        payload[:hit] = !!entry if payload
      end
    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?
  return {} if names.empty?
  options = names.extract_options!
  options = merged_options(options)
  instrument_multi :read_multi, names, options do |payload|
    if options[:force]
      reads = {}
    else
      reads = read_multi_entries(names, **options)
    end
    writes  = {}
    ordered = names.index_with do |name|
      reads.fetch(name) { writes[name] = yield(name) }
    end
    writes.compact! if options[:skip_nil]
    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
      options[:expires_in] = race_ttl * 2
      write_entry(key, entry, **options)
    else
      delete_entry(key, **options)
    end
    entry = nil
  end
  entry
end

def handle_invalid_expires_in(message)
  error = ArgumentError.new(message)
  if ActiveSupport::Cache::Store.raise_on_invalid_cache_expiration_time
    raise error
  else
    ActiveSupport.error_reporter&.report(error, handled: true, severity: :warning)
    logger.error("#{error.class}: #{error.message}") if logger
  end
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 ? validate_options(normalize_options(options)) : {}
  @options[:compress] = true unless @options.key?(:compress)
  @options[:compress_threshold] ||= DEFAULT_COMPRESS_LIMIT
  @coder = @options.delete(:coder) do
    legacy_serializer = Cache.format_version < 7.1 && !@options[:serializer]
    serializer = @options.delete(:serializer) || default_serializer
    serializer = Cache::SerializerWithFallback[serializer] if serializer.is_a?(Symbol)
    compressor = @options.delete(:compressor) { Zlib }
    Cache::Coder.new(serializer, compressor, legacy_serializer: legacy_serializer)
  end
  @coder ||= Cache::SerializerWithFallback[:passthrough]
  @coder_supports_compression = @coder.respond_to?(:dump_compressed)
end

def instrument(operation, key, options = nil, &block)
  _instrument(operation, key: key, options: options, &block)
end

def instrument_multi(operation, keys, options = nil, &block)
  _instrument(operation, multi: true, key: keys, options: options, &block)
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 call_options.key?(:expires_in) && call_options.key?(:expires_at)
      raise ArgumentError, "Either :expires_in or :expires_at can be supplied, but not both"
    end
    expires_at = call_options.delete(:expires_at)
    call_options[:expires_in] = (expires_at - Time.now) if expires_at
    if call_options[:expires_in].is_a?(Time)
      expires_in = call_options[:expires_in]
      raise ArgumentError.new("expires_in parameter should not be a Time. Did you mean to use expires_at? Got: #{expires_in}")
    end
    if call_options[:expires_in]&.negative?
      expires_in = call_options.delete(:expires_in)
      handle_invalid_expires_in("Cache expiration time is invalid, cannot be negative: #{expires_in}")
    end
    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)
  str_key = expanded_key(key)
  raise(ArgumentError, "key cannot be blank") if !str_key || str_key.empty?
  namespace_key str_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
        begin
          entry.value
        rescue DeserializationError
          payload[:hit] = false
          nil
        end
      end
    else
      payload[:hit] = false if payload
      nil
    end
  end
end

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

def read_multi(*names)
  return {} if names.empty?
  options = names.extract_options!
  options = merged_options(options)
  instrument_multi :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)
  if options.key?(:pool)
    pool_options = options.delete(:pool)
  elsif options.key?(:pool_size) || options.key?(:pool_timeout)
    pool_options = {}
    if options.key?(:pool_size)
      ActiveSupport.deprecator.warn(<<~MSG)
        Using :pool_size is deprecated and will be removed in Rails 7.2.
        Use `pool: { size: #{options[:pool_size].inspect} }` instead.
      MSG
      pool_options[:size] = options.delete(:pool_size)
    end
    if options.key?(:pool_timeout)
      ActiveSupport.deprecator.warn(<<~MSG)
        Using :pool_timeout is deprecated and will be removed in Rails 7.2.
        Use `pool: { timeout: #{options[:pool_timeout].inspect} }` instead.
      MSG
      pool_options[:timeout] = options.delete(:pool_timeout)
    end
  else
    pool_options = true
  end
  case pool_options
  when false, nil
    return false
  when true
    pool_options = DEFAULT_POOL_OPTIONS
  when Hash
    pool_options[:size] = Integer(pool_options[:size]) if pool_options.key?(:size)
    pool_options[:timeout] = Float(pool_options[:timeout]) if pool_options.key?(:timeout)
    pool_options = DEFAULT_POOL_OPTIONS.merge(pool_options)
  else
    raise TypeError, "Invalid :pool argument, expected Hash, got: #{pool_options.inspect}"
  end
  pool_options unless pool_options.empty?
end

def save_block_result_to_cache(name, options)
  options = options.dup
  result = instrument(:generate, name, options) do
    yield(name, WriteOptions.new(options))
  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])
  else
    @coder.dump(entry)
  end
end

def silence!
  @silence = true
  self
end

def validate_options(options)
  if options.key?(:coder) && options[:serializer]
    raise ArgumentError, "Cannot specify :serializer and :coder options together"
  end
  if options.key?(:coder) && options[:compressor]
    raise ArgumentError, "Cannot specify :compressor and :coder options together"
  end
  if Cache.format_version < 7.1 && !options[:serializer] && options[:compressor]
    raise ArgumentError, "Cannot specify :compressor option when using" \
      " default serializer and cache format version is < 7.1"
  end
  options
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)
  return hash if hash.empty?
  options = merged_options(options)
  instrument_multi :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