module I18n::Base

def available_locales_initialized?
  config.available_locales_initialized?
end

def config
  Thread.current[:i18n_config] ||= I18n::Config.new
end

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

def eager_load!
  config.backend.eager_load!
end

def enforce_available_locales!(locale)
  if locale != false && config.enforce_available_locales
    raise I18n::InvalidLocale.new(locale) if !locale_available?(locale)
  end
end

def exists?(key, _locale = nil, locale: _locale, **options)
  locale ||= config.locale
  raise Disabled.new('exists?') if locale == false
  raise I18n::ArgumentError if key.is_a?(String) && key.empty?
  config.backend.exists?(locale, key, options)
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 locale_available?(locale)
  I18n.config.available_locales_set.include?(locale)
end

def localize(object, locale: nil, format: nil, **options)
  locale ||= config.locale
  raise Disabled.new('l') if locale == false
  enforce_available_locales!(locale)
  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.flat_map { |k| normalize_key(k, separator) }
    else
      keys = key.to_s.split(separator)
      keys.delete('')
      keys.map! do |k|
        case k
        when /\A[-+]?([1-9]\d*|0)\z/ # integer
          k.to_i
        when 'true'
          true
        when 'false'
          false
        else
          k.to_sym
        end
      end
      keys
    end
end

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

def reload!
  config.clear_available_locales_set
  config.backend.reload!
end