module ActiveSupport::NumberHelper

def self.private_module_and_instance_method(method_name) #:nodoc:
  private method_name
  private_class_method method_name
end

def default_format_options(namespace = nil) #:nodoc:
  options = DEFAULTS[:format].dup
  options.merge!(DEFAULTS[namespace][:format]) if namespace
  options
end

def format_options(locale, namespace = nil) #:nodoc:
  default_format_options(namespace).merge!(i18n_format_options(locale, namespace))
end

def i18n_format_options(locale, namespace = nil) #:nodoc:
  options = I18n.translate(:'number.format', locale: locale, default: {}).dup
  if namespace
    options.merge!(I18n.translate(:"number.#{namespace}.format", locale: locale, default: {}))
  end
  options
end

def number_to_currency(number, options = {})
  return unless number
  options = options.symbolize_keys
  currency = i18n_format_options(options[:locale], :currency)
  currency[:negative_format] ||= "-" + currency[:format] if currency[:format]
  defaults  = default_format_options(:currency).merge!(currency)
  defaults[:negative_format] = "-" + options[:format] if options[:format]
  options   = defaults.merge!(options)
  unit      = options.delete(:unit)
  format    = options.delete(:format)
  if number.to_f.phase != 0
    format = options.delete(:negative_format)
    number = number.respond_to?("abs") ? number.abs : number.sub(/^-/, '')
  end
  format.gsub('%n', self.number_to_rounded(number, options)).gsub('%u', unit)
end

def number_to_delimited(number, options = {})
  options = options.symbolize_keys
  return number unless valid_float?(number)
  options = format_options(options[:locale]).merge!(options)
  parts = number.to_s.split('.')
  parts[0].gsub!(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{options[:delimiter]}")
  parts.join(options[:separator])
end

def number_to_human(number, options = {})
  options = options.symbolize_keys
  return number unless valid_float?(number)
  number = Float(number)
  defaults = format_options(options[:locale], :human)
  options  = defaults.merge!(options)
  #for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
  options[:strip_insignificant_zeros] = true if not options.key?(:strip_insignificant_zeros)
  inverted_du = DECIMAL_UNITS.invert
  units = options.delete :units
  unit_exponents = case units
  when Hash
    units
  when String, Symbol
    I18n.translate(:"#{units}", :locale => options[:locale], :raise => true)
  when nil
    translate_number_value_with_default("human.decimal_units.units", :locale => options[:locale], :raise => true)
  else
    raise ArgumentError, ":units must be a Hash or String translation scope."
  end.keys.map{|e_name| inverted_du[e_name] }.sort_by{|e| -e}
  number_exponent = number != 0 ? Math.log10(number.abs).floor : 0
  display_exponent = unit_exponents.find{ |e| number_exponent >= e } || 0
  number  /= 10 ** display_exponent
  unit = case units
  when Hash
    units[DECIMAL_UNITS[display_exponent]] || ''
  when String, Symbol
    I18n.translate(:"#{units}.#{DECIMAL_UNITS[display_exponent]}", :locale => options[:locale], :count => number.to_i)
  else
    translate_number_value_with_default("human.decimal_units.units.#{DECIMAL_UNITS[display_exponent]}", :locale => options[:locale], :count => number.to_i)
  end
  decimal_format = options[:format] || translate_number_value_with_default('human.decimal_units.format', :locale => options[:locale])
  formatted_number = self.number_to_rounded(number, options)
  decimal_format.gsub(/%n/, formatted_number).gsub(/%u/, unit).strip
end

def number_to_human_size(number, options = {})
  options = options.symbolize_keys
  return number unless valid_float?(number)
  number = Float(number)
  defaults = format_options(options[:locale], :human)
  options  = defaults.merge!(options)
  #for backwards compatibility with those that didn't add strip_insignificant_zeros to their locale files
  options[:strip_insignificant_zeros] = true if not options.key?(:strip_insignificant_zeros)
  storage_units_format = translate_number_value_with_default('human.storage_units.format', :locale => options[:locale], :raise => true)
  base = options[:prefix] == :si ? 1000 : 1024
  if number.to_i < base
    unit = translate_number_value_with_default('human.storage_units.units.byte', :locale => options[:locale], :count => number.to_i, :raise => true)
    storage_units_format.gsub(/%n/, number.to_i.to_s).gsub(/%u/, unit)
  else
    max_exp  = STORAGE_UNITS.size - 1
    exponent = (Math.log(number) / Math.log(base)).to_i # Convert to base
    exponent = max_exp if exponent > max_exp # we need this to avoid overflow for the highest unit
    number  /= base ** exponent
    unit_key = STORAGE_UNITS[exponent]
    unit = translate_number_value_with_default("human.storage_units.units.#{unit_key}", :locale => options[:locale], :count => number, :raise => true)
    formatted_number = self.number_to_rounded(number, options)
    storage_units_format.gsub(/%n/, formatted_number).gsub(/%u/, unit)
  end
end

def number_to_percentage(number, options = {})
  return unless number
  options = options.symbolize_keys
  defaults = format_options(options[:locale], :percentage)
  options  = defaults.merge!(options)
  format = options[:format] || "%n%"
  format.gsub('%n', self.number_to_rounded(number, options))
end

def number_to_phone(number, options = {})
  return unless number
  options = options.symbolize_keys
  number       = number.to_s.strip
  area_code    = options[:area_code]
  delimiter    = options[:delimiter] || "-"
  extension    = options[:extension]
  country_code = options[:country_code]
  if area_code
    number.gsub!(/(\d{1,3})(\d{3})(\d{4}$)/,"(\\1) \\2#{delimiter}\\3")
  else
    number.gsub!(/(\d{0,3})(\d{3})(\d{4})$/,"\\1#{delimiter}\\2#{delimiter}\\3")
    number.slice!(0, 1) if number.start_with?(delimiter) && !delimiter.blank?
  end
  str = ''
  str << "+#{country_code}#{delimiter}" unless country_code.blank?
  str << number
  str << " x #{extension}" unless extension.blank?
  str
end

def number_to_rounded(number, options = {})
  return number unless valid_float?(number)
  number  = Float(number)
  options = options.symbolize_keys
  defaults = format_options(options[:locale], :precision)
  options  = defaults.merge!(options)
  precision = options.delete :precision
  significant = options.delete :significant
  strip_insignificant_zeros = options.delete :strip_insignificant_zeros
  if significant && precision > 0
    if number == 0
      digits, rounded_number = 1, 0
    else
      digits = (Math.log10(number.abs) + 1).floor
      multiplier = 10 ** (digits - precision)
      rounded_number = (BigDecimal.new(number.to_s) / BigDecimal.new(multiplier.to_f.to_s)).round.to_f * multiplier
      digits = (Math.log10(rounded_number.abs) + 1).floor # After rounding, the number of digits may have changed
    end
    precision -= digits
    precision = 0 if precision < 0 # don't let it be negative
  else
    rounded_number = BigDecimal.new(number.to_s).round(precision).to_f
    rounded_number = rounded_number.abs if rounded_number.zero? # prevent showing negative zeros
  end
  formatted_number = self.number_to_delimited("%01.#{precision}f" % rounded_number, options)
  if strip_insignificant_zeros
    escaped_separator = Regexp.escape(options[:separator])
    formatted_number.sub(/(#{escaped_separator})(\d*[1-9])?0+\z/, '\1\2').sub(/#{escaped_separator}\z/, '')
  else
    formatted_number
  end
end

def translate_number_value_with_default(key, i18n_options = {}) #:nodoc:
  default = key.split('.').reduce(DEFAULTS) { |defaults, k| defaults[k.to_sym] }
  I18n.translate(key, { default: default, scope: :number }.merge!(i18n_options))
end

def valid_float?(number) #:nodoc:
  Float(number)
rescue ArgumentError, TypeError
  false
end