class ActiveSupport::Duration

def %(other)
  if Duration === other || Scalar === other
    Duration.build(value % other.value)
  elsif Numeric === other
    Duration.build(value % other)
  else
    raise_type_error(other)
  end
end

def *(other)
  if Scalar === other || Duration === other
    Duration.new(value * other.value, parts.map { |type, number| [type, number * other.value] })
  elsif Numeric === other
    Duration.new(value * other, parts.map { |type, number| [type, number * other] })
  else
    raise_type_error(other)
  end
end

def +(other)
  if Duration === other
    parts = @parts.dup
    other.parts.each do |(key, value)|
      parts[key] += value
    end
    Duration.new(value + other.value, parts)
  else
    seconds = @parts[:seconds] + other
    Duration.new(value + other, @parts.merge(seconds: seconds))
  end
end

def -(other)
  self + (-other)
end

def -@ #:nodoc:
  Duration.new(-value, parts.map { |type, number| [type, -number] })
end

def /(other)
  if Scalar === other
    Duration.new(value / other.value, parts.map { |type, number| [type, number / other.value] })
  elsif Duration === other
    value / other.value
  elsif Numeric === other
    Duration.new(value / other, parts.map { |type, number| [type, number / other] })
  else
    raise_type_error(other)
  end
end

def <=>(other)
  if Duration === other
    value <=> other.value
  elsif Numeric === other
    value <=> other
  end
end

def ==(other)
  if Duration === other
    other.value == value
  else
    other == value
  end
end

def ===(other) #:nodoc:
  other.is_a?(Duration)
rescue ::NoMethodError
  false
end

def ago(time = ::Time.current)
  sum(-1, time)
end

def as_json(options = nil) #:nodoc:
  to_i
end

def build(value)
  parts = {}
  remainder = value.to_f
  PARTS.each do |part|
    unless part == :seconds
      part_in_seconds = PARTS_IN_SECONDS[part]
      parts[part] = remainder.div(part_in_seconds)
      remainder = (remainder % part_in_seconds).round(9)
    end
  end
  parts[:seconds] = remainder
  new(value, parts)
end

def calculate_total_seconds(parts)
  parts.inject(0) do |total, (part, value)|
    total + value * PARTS_IN_SECONDS[part]
  end
end

def coerce(other) #:nodoc:
  case other
  when Scalar
    [other, self]
  when Duration
    [Scalar.new(other.value), self]
  else
    [Scalar.new(other), self]
  end
end

def days(value) #:nodoc:
  new(value * SECONDS_PER_DAY, [[:days, value]])
end

def encode_with(coder) #:nodoc:
  coder.map = { "value" => @value, "parts" => @parts }
end

def eql?(other)
  Duration === other && other.value.eql?(value)
end

def hash
  @value.hash
end

def hours(value) #:nodoc:
  new(value * SECONDS_PER_HOUR, [[:hours, value]])
end

def init_with(coder) #:nodoc:
  initialize(coder["value"], coder["parts"])
end

def initialize(value, parts) #:nodoc:
  @value, @parts = value, parts.to_h
  @parts.default = 0
  @parts.reject! { |k, v| v.zero? }
end

def inspect #:nodoc:
  return "0 seconds" if parts.empty?
  parts.
    sort_by { |unit,  _ | PARTS.index(unit) }.
    map     { |unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}" }.
    to_sentence(locale: ::I18n.default_locale)
end

def instance_of?(klass) # :nodoc:
  Duration == klass || value.instance_of?(klass)
end

def is_a?(klass) #:nodoc:
  Duration == klass || value.is_a?(klass)
end

def iso8601(precision: nil)
  ISO8601Serializer.new(self, precision: precision).serialize
end

def method_missing(method, *args, &block)
  value.public_send(method, *args, &block)
end

def minutes(value) #:nodoc:
  new(value * SECONDS_PER_MINUTE, [[:minutes, value]])
end

def months(value) #:nodoc:
  new(value * SECONDS_PER_MONTH, [[:months, value]])
end

def parse(iso8601duration)
  parts = ISO8601Parser.new(iso8601duration).parse!
  new(calculate_total_seconds(parts), parts)
end

def raise_type_error(other)
  raise TypeError, "no implicit conversion of #{other.class} into #{self.class}"
end

def respond_to_missing?(method, _)
  value.respond_to?(method)
end

def seconds(value) #:nodoc:
  new(value, [[:seconds, value]])
end

def since(time = ::Time.current)
  sum(1, time)
end

def sum(sign, time = ::Time.current)
  parts.inject(time) do |t, (type, number)|
    if t.acts_like?(:time) || t.acts_like?(:date)
      if type == :seconds
        t.since(sign * number)
      elsif type == :minutes
        t.since(sign * number * 60)
      elsif type == :hours
        t.since(sign * number * 3600)
      else
        t.advance(type => sign * number)
      end
    else
      raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
    end
  end
end

def to_i
  @value.to_i
end

def to_s
  @value.to_s
end

def weeks(value) #:nodoc:
  new(value * SECONDS_PER_WEEK, [[:weeks, value]])
end

def years(value) #:nodoc:
  new(value * SECONDS_PER_YEAR, [[:years, value]])
end