module I18n

def self.new_double_nested_cache # :nodoc:
  Concurrent::Map.new { |h, k| h[k] = Concurrent::Map.new }
end

def self.reserve_key(key)
  RESERVED_KEYS << key.to_sym
  @reserved_keys_pattern = nil
end

def self.reserved_keys_pattern # :nodoc:
  @reserved_keys_pattern ||= /(?<!%)%\{(#{RESERVED_KEYS.join("|")})\}/
end

def cache_key_digest
  @@cache_key_digest
end

def cache_key_digest=(key_digest)
  @@cache_key_digest = key_digest
end

def cache_namespace
  @@cache_namespace
end

def cache_namespace=(namespace)
  @@cache_namespace = namespace
end

def cache_store
  @@cache_store
end

def cache_store=(store)
  @@cache_store = store
end

def fallbacks
  @@fallbacks ||= I18n::Locale::Fallbacks.new
  Thread.current[:i18n_fallbacks] || @@fallbacks
end

def fallbacks=(fallbacks)
  @@fallbacks = fallbacks.is_a?(Array) ? I18n::Locale::Fallbacks.new(fallbacks) : fallbacks
  Thread.current[:i18n_fallbacks] = @@fallbacks
end

def interpolate(string, values)
  raise ReservedInterpolationKey.new($1.to_sym, string) if string =~ I18n.reserved_keys_pattern
  raise ArgumentError.new('Interpolation values must be a Hash.') unless values.kind_of?(Hash)
  interpolate_hash(string, values)
end

def interpolate_hash(string, values)
  pattern = INTERPOLATION_PATTERNS_CACHE[config.interpolation_patterns]
  interpolated = false
  interpolated_string = string.gsub(pattern) do |match|
    interpolated = true
    if match == '%%'
      '%'
    else
      key = ($1 || $2 || match.tr("%{}", "")).to_sym
      value = if values.key?(key)
                values[key]
              else
                config.missing_interpolation_argument_handler.call(key, values, string)
              end
      value = value.call(values) if value.respond_to?(:call)
      $3 ? sprintf("%#{$3}", value) : value
    end
  end
  interpolated ? interpolated_string : string
end

def perform_caching?
  !cache_store.nil?
end