#= require ./base
#= require ./tag

#module I18n
#  class ExceptionHandler
#    include Module.new {
#      def call(exception, locale, key, options)
#        exception.is_a?(MissingTranslation) && options[:rescue_format] == :html ? super.html_safe : super
#      end
#    }
#  end
#end

@Ultimate.Helpers.Translation =

  ###**
  * Delegates to <tt>I18n#translate</tt> but also performs three additional functions.
  *
  * First, it'll pass the <tt>:rescue_format => :html</tt> option to I18n so that any
  * thrown +MissingTranslation+ messages will be turned into inline spans that
  *
  *   * have a "translation-missing" class set,
  *   * contain the missing key as a title attribute and
  *   * a titleized version of the last key segment as a text.
  *
  * E.g. the value returned for a missing translation key :"blog.post.title" will be
  * <span class="translation_missing" title="translation missing: en.blog.post.title">Title</span>.
  * This way your views will display rather reasonable strings but it will still
  * be easy to spot missing translations.
  *
  * Second, it'll scope the key by the current partial if the key starts
  * with a period. So if you call <tt>translate(".foo")</tt> from the
  * <tt>people/index.html.erb</tt> template, you'll actually be calling
  * <tt>I18n.translate("people.index.foo")</tt>. This makes it less repetitive
  * to translate many keys within the same partials and gives you a simple framework
  * for scoping them consistently. If you don't prepend the key with a period,
  * nothing is converted.
  *
  * Third, it'll mark the translation as safe HTML if the key has the suffix
  * "_html" or the last element of the key is the word "html". For example,
  * calling translate("footer_html") or translate("footer.html") will return
  * a safe HTML string that won't be escaped by other HTML helper methods. This
  * naming convention helps to identify translations that include HTML tags so that
  * you know what kind of output to expect when you call translate in a template.
  ###
  translate: (key, options = {}) ->
    _.extend(options, rescue_format: 'html')  unless _.has(options, 'rescue_format')
    options['default'] = @wrap_translate_defaults(options['default'])  if options['default']
    if @html_safe_translation_key(key)
      html_safe_options = _.clone(options)
      options.except(I18n.RESERVED_KEYS).each do |name, value|
        unless name == :count && value.is_a?(Numeric)
          html_safe_options[name] = ERB::Util.html_escape(value.to_s)
        end
      end
      translation = I18n.translate(scope_key_by_partial(key), html_safe_options)

      translation.respond_to?(:html_safe) ? translation.html_safe : translation
    else
      I18n.translate(scope_key_by_partial(key), options)
    end
  end
  alias :t :translate

  # Delegates to <tt>I18n.localize</tt> with no additional functionality.
  #
  # See http://rubydoc.info/github/svenfuchs/i18n/master/I18n/Backend/Base:localize
  # for more information.
  localize: ->
    I18n.localize(arguments...)

  l: -> @localize(arguments...)

  # private

  scope_key_by_partial: (key) ->
    if /^\./.test(key)
      if @virtual_path?
        @virtual_path.replace(/_/g, ".") + key
      else
        throw new Error("Cannot use t(#{key.inspect}) shortcut because path is not available")
    else
      key

  html_safe_translation_key: (key) ->
    /(\b|_|\.)html$/.test(key)

  wrap_translate_defaults: (defaults) ->
    new_defaults = []
    defaults     = _.toArray(defaults)
    while key = defaults.shift()
      if _.isString(key)
        new_defaults.push (_, options) -> @translate(key, _.extend(options, default: defaults))
        break
      else
        new_defaults.push key
    new_defaults