module Money::Arithmetic

def %(val)
  modulo(val)
end

def *(value)
  value = value.value if value.is_a?(CoercedNumeric)
  if value.is_a? Numeric
    dup_with(fractional: fractional * value)
  else
    raise TypeError, "Can't multiply a #{self.class.name} by a #{value.class.name}'s value"
  end
end

def -@
  dup_with(fractional: -fractional)
end

def /(value)
  if value.is_a?(self.class)
    fractional / as_d(value.exchange_to(currency).fractional).to_f
  else
    raise TypeError, 'Can not divide by Money' if value.is_a?(CoercedNumeric)
    dup_with(fractional: fractional / as_d(value))
  end
end

def <=>(other)
  unless other.is_a?(Money)
    return unless other.respond_to?(:zero?) && other.zero?
    return other.is_a?(CoercedNumeric) ? 0 <=> fractional : fractional <=> 0
  end
  # Always allow comparison with zero
  if zero? || other.zero?
    return fractional <=> other.fractional
  end
  other = other.exchange_to(currency)
  fractional <=> other.fractional
rescue Money::Bank::UnknownRate
end

def ==(other)
  if other.is_a?(Numeric) && !other.zero?
    raise ArgumentError, 'Money#== supports only zero numerics'
  end
  super
end

def abs
  dup_with(fractional: fractional.abs)
end

def coerce(other)
  [self, CoercedNumeric.new(other)]
end

def div(value)
  self / value
end

def divmod(val)
  if val.is_a?(Money)
    divmod_money(val)
  else
    divmod_other(val)
  end
end

def divmod_money(val)
  cents = val.exchange_to(currency).cents
  quotient, remainder = fractional.divmod(cents)
  [quotient, dup_with(fractional: remainder)]
end

def divmod_other(val)
  quotient, remainder = fractional.divmod(as_d(val))
  [dup_with(fractional: quotient), dup_with(fractional: remainder)]
end

def eql?(other_money)
  if other_money.is_a?(Money)
    (fractional == other_money.fractional && currency == other_money.currency) ||
      (fractional == 0 && other_money.fractional == 0)
  else
    false
  end
end

def modulo(val)
  divmod(val)[1]
end

def negative?
  fractional < 0
end

def nonzero?
  fractional != 0 ? self : nil
end

def positive?
  fractional > 0
end

def remainder(val)
  if val.is_a?(Money) && currency != val.currency
    val = val.exchange_to(currency)
  end
  if (fractional < 0 && val < 0) || (fractional > 0 && val > 0)
    self.modulo(val)
  else
    self.modulo(val) - (val.is_a?(Money) ? val : dup_with(fractional: val))
  end
end

def zero?
  fractional == 0
end