number_to_french.rb

# on inclue la librairie de test de Ruby pour faires quelques petits test unitaires
require 'test/unit'

# On va gérer toute la conversion dans une classe qui va avoir une méthode `translate` qui s'occupera de tout traduire.
# La classe va nous permettre de mieux organizer le code en plusieurs méthodes plus petites et donc plus lisibles
class Converter
 
  # On va commencer par définir des constantes (aka des variables qui ne changerons jamais)
  # En Ruby, les constantes sont des variables nomées en majuscule
  # La syntaxe avec le `%w[]` permet simplement de définir des tableaux en mode un peu plus sexy.
  # La méthode `freeze` à la fin permet juste d'économiser de la mémoire et d'interdire le changement de la variable

  # @attr [Array] Contient les traductions des chiffres
  DIGITS_TRANSLATIONS = %w[un deux trois quattre cinq six sept huit neuf].freeze
  # @attr [Array] Contient les traductions des dizaines
  DOZEN_TRANSLATIONS = %w[dix vingt trente quarante cinquante soixante soixante-dix quatre-vingt quatre-vingt-dix].freeze
  # @attr [Hash] Contient les traductions merdogènes qu'on va gérer à la main
  SHITTY_TRANSLATIONS = {
    11 => 'onze',
    12 => 'douze',
    13 => 'treize',
    14 => 'quatorze',
    15 => 'quinze',
    16 => 'seize',
    71 => 'soixante et onze',
    72 => 'soixante douze',
    73 => 'soixante treize',
    74 => 'soixante quatorze',
    75 => 'soixante quinze',
    76 => 'soixante seize',
    91 => 'quatre-vingt onze',
    92 => 'quatre-vingt douze',
    93 => 'quatre-vingt treize',
    94 => 'quatre-vingt quatorze',
    95 => 'quatre-vingt quinze',
    96 => 'quatre-vingt seize'
  }.freeze

  # Cette méthodes est appelée automatiquement lorsqu'on fait `Converter.new`
  # On initialize simplement un attribut sur l'instance et on calcule le nombre de centaines, dizaines et chiffres
  # @param [Integer] le nombre à convertir
  def initialize(number)
    @number = number

    # Le nombre de centaines contenu dans le nombre
    @number_of_hundreds = @number / 100
    rest = @number - (@number_of_hundreds * 100)

    # Le nombre de dizaines contenu dans le nombre
    @number_of_dozen = rest / 10

    # Le nombre de chiffres contenu dans le nombre
    @number_of_digits = rest - (@number_of_dozen * 10)
  end

  # @param [String] le nombre convertit en texte
  def translate
    # on utilise les trois méthodes qui traduisent les centaines, dizaines et chiffres
    # qu'on met dans un tableau et on utilise la méthode `join` pour joindre les élements
    # du tableau avec un séparateur (un espace)
    [translate_hundred, translate_dozen, translate_digits].compact.join ' '
  end

  # à partir d'ici, les méthodes sont privées puisqu'elle nous aident juste à découper notre code
  private

  # @return [String] le nombre de centaines convertit en texte
  def translate_hundred
    return nil if @number_of_hundreds == 0

    if @number_of_hundreds == 1
      # ici c'est facile vu qu'on a qu'une centaines
      'cent'
    elsif @number_of_hundreds < 10
      # là on doit traduire le nombre de centaines
      nb_of_hundred_translated = DIGITS_TRANSLATIONS[@number_of_hundreds - 1]
      format('%s cents', nb_of_hundred_translated)
    else
      # là on dépasse le nombre de centaines
      # TODO: gérer le cas du dépassement
      format('%s cents', @number_of_hundreds)
    end
  end

  # @return [String] le nombre de dizaines convertit en texte
  def translate_dozen
    return nil if @number_of_dozen == 0 || is_shitty_translation?

    DOZEN_TRANSLATIONS[@number_of_dozen - 1]
  end

  # @return [String] le nombre de chiffre convertit en texte
  def translate_digits
    return nil if @number_of_digits == 0

    if is_shitty_translation?
      return SHITTY_TRANSLATIONS[shitty_number]
    else
      return DIGITS_TRANSLATIONS[@number_of_digits - 1]
    end
  end

  # @return [Integer] le nombre avec la dizaine (potientiellement merdogème)
  def shitty_number
    @number_of_dozen * 10 + @number_of_digits
  end

  # @return [Boolean] va juste nous dire si c'est une traduction de merde
  def is_shitty_translation?
    SHITTY_TRANSLATIONS.include? shitty_number
  end
end

# On se fait quelques test unitaires en vrac pour vérifier que tout fonctionne
class TestConverter < Test::Unit::TestCase
  def test_with_simple_numbers
    assert_equal 'trente', Converter.new(30).translate
    assert_equal 'trois cents', Converter.new(300).translate
    assert_equal 'trois cents quarante cinq', Converter.new(345).translate
  end

  def test_with_shitty_numbers
    assert_equal 'soixante et onze', Converter.new(71).translate
    assert_equal 'cent soixante et onze', Converter.new(171).translate
  end
end

# puts 'Plz enter a number'
# user_input = gets.to_i
# converter = Converter.new user_input
# puts converter.translate