module Numerals

  module Conversions

    class <<self
      def [](type, options = nil)
        if type.respond_to?(:numerals_conversion)
          type.numerals_conversion(options || {})
        end
      end

      def order_of_magnitude(number, options={})
        self[number.class, options[:type_options]].order_of_magnitude(number, options)
      end

      def number_of_digits(number, options={})
        self[number.class, options[:type_options]].number_of_digits(number, options)
      end

      # Convert Numeral to Number
      #
      #   read numeral, options={}
      #
      # If the input numeral is approximate and the destination type
      # allows for arbitrary precision, then the destination context
      # precision will be ignored and the precision of the input will be
      # preserved. The :simplify option affects this case by generating
      # only the mininimun number of digits needed.
      #
      # The :exact option will prevent this behaviour and always treat
      # input as exact.
      #
      # Valid output options:
      #
      # * :type class of the output number
      # * :context context (in the case of Flt::Num, Float) for the output
      # * :simplify (for approximate input numeral/arbitrary precision type only)
      # * :exact treat input numeral as if exact
      #
      def read(numeral, options={})
        selector = options[:context] || options[:type]
        exact_input = options[:exact]
        approximate_simplified = options[:simplify]
        conversions = self[selector, options[:type_options]]
        conversions.read(numeral, exact_input, approximate_simplified)
      end

      # Convert Number to Numeral
      #
      #   write number, options={}
      #
      # Valid options:
      #
      # * :rounding (a Rounding) (which defines output base as well)
      # * :exact (exact input indicator)
      #
      # Approximate mode:
      #
      # If the input is treated as an approximation
      # (which is the case for types such as Flt::Num, Float,...
      # unless the :exact option is true) then no 'spurious' digits
      # will be shown (digits that can take any value and the numeral
      # still would convert to the original number if rounded to the same precision)
      #
      # In approximate mode, if rounding is simplifying? (:short), the shortest representation
      # which rounds back to the origina number with the same precision is used.
      # If rounding is :free and the output base is the same as the number
      # internal radix, the exact precision (trailing zeros) of the number
      # is represented.
      #
      # Exact mode:
      #
      # Is used for 'exact' types (such as Integer, Rational) or when the :exact
      # option is defined to be true.
      #
      # The number is treated as an exact value, and converted according to
      # Rounding. (in this case the :free and :short precision roundings are
      # equivalent)
      #
      def write(number, options = {})
        output_rounding = Rounding[options[:rounding] || Rounding[]]
        conversion = self[number.class, options[:type_options]]
        exact_input = conversion.exact?(number, options)
        conversion.write(number, exact_input, output_rounding)
      end

      def exact?(number, options = {})
        self[number.class, options[:type_options]].exact?(number, options)
      end

      private

      def extract_mode_from_args!(args)
        if [:fixed, :free, :exact, :approximate].include?(args.first)
          args.shift
        end
      end
    end

  end

end