module Rufus

# File lib/rufus/sc/rtime.rb, line 316
def Rufus.at_to_f(at)

  # TODO : use chronic if present

  at = Rufus::to_ruby_time(at) if at.is_a?(String)
  at = Rufus::to_gm_time(at) if at.is_a?(DateTime)
  #at = at.to_f if at.is_a?(Time)
  at = at.to_f if at.respond_to?(:to_f)

  raise ArgumentError.new(
    "cannot determine 'at' time from : #{at.inspect}"
  ) unless at.is_a?(Float)

  at
end

# File lib/rufus/sc/rtime.rb, line 94
def Rufus.current_time_millis

  (Time.new.to_f * 1000).to_i
end

# File lib/rufus/sc/rtime.rb, line 306
def Rufus.duration_to_f(s)

  return s if s.kind_of?(Float)
  return parse_time_string(s) if s.kind_of?(String)
  Float(s.to_s)
end

# File lib/rufus/sc/rtime.rb, line 50
def Rufus.now

  to_iso8601_date(Time.new)
end

# File lib/rufus/sc/rtime.rb, line 123
def Rufus.parse_time_string(string)

  if m = string.match(%r^(\d*)\.?(\d*)([A-Za-z])(.*)$/)

    number = "#{m[1]}.#{m[2]}".to_f
    multiplier = DURATIONS[m[3]]

    raise ArgumentError.new("unknown time char '#{m[3]}'") unless multiplier

    return number * multiplier + parse_time_string(m[4])

  else

    return string.to_i / 1000.0 if string.match(%r^\d+$/)
    return string.to_f if string.match(%r^\d*\.?\d*$/)

    raise ArgumentError.new("cannot parse '#{string}'")
  end
end

# File lib/rufus/sc/rtime.rb, line 74
def Rufus.time_to_iso8601_date(time)

  s = time.getutc.strftime(TIME_FORMAT)
  o = time.utc_offset / 3600
  o = "#{o}00"
  o = "0#{o}" if o.length < 4
  o = "+#{o}" unless o[0..1] == '-'

  "#{s} #{o}"
end

# File lib/rufus/sc/rtime.rb, line 159
def Rufus.to_datetime(time)

  s = time.sec + Rational(time.usec, 10**6)
  o = Rational(time.utc_offset, 3600 * 24)

  begin

    DateTime.new(time.year, time.month, time.day, time.hour, time.min, s, o)

  rescue Exception => e

    DateTime.new(
      time.year,
      time.month,
      time.day,
      time.hour,
      time.min,
      time.sec,
      time.utc_offset)
  end
end

# File lib/rufus/sc/rtime.rb, line 273
def Rufus.to_duration_hash(seconds, options={})

  h = {}

  if seconds.is_a?(Float)
    h[:ms] = (seconds % 1 * 1000).to_i
    seconds = seconds.to_i
  end

  if options[:drop_seconds]
    h.delete :ms
    seconds = (seconds - seconds % 60)
  end

  durations = options[:months] ? DURATIONS2M : DURATIONS2

  durations.each do |key, duration|

    count = seconds / duration
    seconds = seconds % duration

    h[key.to_sym] = count if count > 0
  end

  h
end

# File lib/rufus/sc/rtime.rb, line 231
def Rufus.to_duration_string(seconds, options={})

  return (options[:drop_seconds] ? '0m' : '0s') if seconds <= 0

  h = to_duration_hash seconds, options

  s = DU_KEYS.inject('') { |r, key|
    count = h[key]
    count = nil if count == 0
    r << "#{count}#{key}" if count
    r
  }

  ms = h[:ms]
  s << ms.to_s if ms

  s
end

# File lib/rufus/sc/rtime.rb, line 181
def Rufus.to_gm_time(dtime)

  to_ttime(dtime.new_offset, :gm)
end

# File lib/rufus/sc/rtime.rb, line 57
def Rufus.to_iso8601_date(date)

  date = case date
    when Date then date
    when Float then to_datetime(Time.at(date))
    when Time then to_datetime(date)
    else DateTime.parse(date)
  end

  s = date.to_s # this is costly
  s[10] = ' '

  s
end

# File lib/rufus/sc/rtime.rb, line 186
def Rufus.to_local_time(dtime)

  to_ttime(dtime.new_offset(DateTime.now.offset-offset), :local)
end

# File lib/rufus/sc/rtime.rb, line 87
def Rufus.to_ruby_time(sdate)

  DateTime.parse(sdate)
end

# File lib/rufus/sc/rtime.rb, line 191
def Rufus.to_ttime(d, method)

  usec = (d.sec_fraction * 3600 * 24 * (10**6)).to_i
  Time.send(method, d.year, d.month, d.day, d.hour, d.min, d.sec, usec)
end