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.transform_values { |number| number * other.value }, @variable || other.variable?)
  elsif Numeric === other
    Duration.new(value * other, @parts.transform_values { |number| number * other }, @variable)
  else
    raise_type_error(other)
  end
end

def +(other)
  if Duration === other
    parts = @parts.merge(other._parts) do |_key, value, other_value|
      value + other_value
    end
    Duration.new(value + other.value, parts, @variable || other.variable?)
  else
    seconds = @parts.fetch(:seconds, 0) + other
    Duration.new(value + other, @parts.merge(seconds: seconds), @variable)
  end
end

def +@ # :nodoc:
  self
end

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

def -@ # :nodoc:
  Duration.new(-value, @parts.transform_values(&:-@), @variable)
end

def /(other)
  if Scalar === other
    Duration.new(value / other.value, @parts.transform_values { |number| number / other.value }, @variable)
  elsif Duration === other
    value / other.value
  elsif Numeric === other
    Duration.new(value / other, @parts.transform_values { |number| number / other }, @variable)
  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 _parts # :nodoc:
  @parts
end

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

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

def build(value)
  unless value.is_a?(::Numeric)
    raise TypeError, "can't build an #{self.name} from a #{value.class.name}"
  end
  parts = {}
  remainder_sign = value <=> 0
  remainder = value.round(9).abs
  variable = false
  PARTS.each do |part|
    unless part == :seconds
      part_in_seconds = PARTS_IN_SECONDS[part]
      parts[part] = remainder.div(part_in_seconds) * remainder_sign
      remainder %= part_in_seconds
      unless parts[part].zero?
        variable ||= VARIABLE_PARTS.include?(part)
      end
    end
  end unless value == 0
  parts[:seconds] = remainder * remainder_sign
  new(value, parts, variable)
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 }, true)
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 }, false)
end

def in_days
  in_seconds / SECONDS_PER_DAY.to_f
end

def in_hours
  in_seconds / SECONDS_PER_HOUR.to_f
end

def in_minutes
  in_seconds / SECONDS_PER_MINUTE.to_f
end

def in_months
  in_seconds / SECONDS_PER_MONTH.to_f
end

def in_weeks
  in_seconds / SECONDS_PER_WEEK.to_f
end

def in_years
  in_seconds / SECONDS_PER_YEAR.to_f
end

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

def initialize(value, parts, variable = nil) # :nodoc:
  @value, @parts = value, parts
  @parts.reject! { |k, v| v.zero? } unless value == 0
  @parts.freeze
  @variable = variable
  if @variable.nil?
    @variable = @parts.any? { |part, _| VARIABLE_PARTS.include?(part) }
  end
end

def inspect # :nodoc:
  return "#{value} 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: false)
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 }, false)
end

def months(value) # :nodoc:
  new(value * SECONDS_PER_MONTH, { months: value }, true)
end

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

def parts
  @parts.dup
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 }, false)
end

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

def sum(sign, time = ::Time.current)
  unless time.acts_like?(:time) || time.acts_like?(:date)
    raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
  end
  if @parts.empty?
    time.since(sign * value)
  else
    @parts.inject(time) do |t, (type, number)|
      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
    end
  end
end

def to_i
  @value.to_i
end

def to_s
  @value.to_s
end

def variable? # :nodoc:
  @variable
end

def weeks(value) # :nodoc:
  new(value * SECONDS_PER_WEEK, { weeks: value }, true)
end

def years(value) # :nodoc:
  new(value * SECONDS_PER_YEAR, { years: value }, true)
end