module I18n

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 config
  Thread.current[:i18n_config] ||= I18n::Config.new
end

def config=(value)
  Thread.current[:i18n_config] = value
end

def default_exception_handler(exception, locale, key, options)
  puts "I18n.default_exception_handler is deprecated. Please use the class I18n::ExceptionHandler instead " +
       "(an instance of which is set to I18n.exception_handler by default)."
  exception.is_a?(MissingTranslation) ? exception.message : raise(exception)
end

def fallbacks
  @@fallbacks ||= I18n::Locale::Fallbacks.new
end

def fallbacks=(fallbacks)
  @@fallbacks = fallbacks
end

def handle_exception(handling, exception, locale, key, options)
  case handling
  when :raise
    raise(exception.respond_to?(:to_exception) ? exception.to_exception : exception)
  when :throw
    throw :exception, exception
  else
    case handler = options[:exception_handler] || config.exception_handler
    when Symbol
      send(handler, exception, locale, key, options)
    else
      handler.call(exception, locale, key, options)
    end
  end
end

def interpolate(string, values)
  raise ReservedInterpolationKey.new($1.to_sym, string) if string =~ 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)
  string.gsub(INTERPOLATION_PATTERN) do |match|
    if match == '%%'
      '%'
    else
      key = ($1 || $2).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
end

def localize(object, options = nil)
  options = options ? options.dup : {}
  locale = options.delete(:locale) || config.locale
  format = options.delete(:format) || :default
  config.backend.localize(locale, object, format, options)
end

def normalize_key(key, separator)
  normalized_key_cache[separator][key] ||=
    case key
    when Array
      key.map { |k| normalize_key(k, separator) }.flatten
    else
      keys = key.to_s.split(separator)
      keys.delete('')
      keys.map! { |k| k.to_sym }
      keys
    end
end

def normalize_keys(locale, key, scope, separator = nil)
  separator ||= I18n.default_separator
  keys = []
  keys.concat normalize_key(locale, separator)
  keys.concat normalize_key(scope, separator)
  keys.concat normalize_key(key, separator)
  keys
end

def normalize_translation_keys(locale, key, scope, separator = nil)
  puts "I18n.normalize_translation_keys is deprecated. Please use the class I18n.normalize_keys instead."
  normalize_keys(locale, key, scope, separator)
end

def normalized_key_cache
  @normalized_key_cache ||= Hash.new { |h,k| h[k] = {} }
end

def perform_caching?
  !cache_store.nil?
end

def reload!
  config.backend.reload!
end