class DateTime

def self.civil_from_format(utc_or_local, year, month = 1, day = 1, hour = 0, min = 0, sec = 0)
  if utc_or_local.to_sym == :local
    offset = ::Time.local(year, month, day).utc_offset.to_r / 86400
  else
    offset = 0
  end
  civil(year, month, day, hour, min, sec, offset)
end

def <=>(other)
  if other.respond_to? :to_datetime
    super other.to_datetime rescue nil
  else
    super
  end
end

def acts_like_date?
  true
end

def acts_like_time?
  true
end

def advance(options)
  unless options[:weeks].nil?
    options[:weeks], partial_weeks = options[:weeks].divmod(1)
    options[:days] = options.fetch(:days, 0) + 7 * partial_weeks
  end
  unless options[:days].nil?
    options[:days], partial_days = options[:days].divmod(1)
    options[:hours] = options.fetch(:hours, 0) + 24 * partial_days
  end
  d = to_date.advance(options)
  datetime_advanced_by_date = change(year: d.year, month: d.month, day: d.day)
  seconds_to_advance = \
    options.fetch(:seconds, 0) +
    options.fetch(:minutes, 0) * 60 +
    options.fetch(:hours, 0) * 3600
  if seconds_to_advance.zero?
    datetime_advanced_by_date
  else
    datetime_advanced_by_date.since(seconds_to_advance)
  end
end

def ago(seconds)
  since(-seconds)
end

def as_json(options = nil) # :nodoc:
  if ActiveSupport::JSON::Encoding.use_standard_json_time_format
    xmlschema(ActiveSupport::JSON::Encoding.time_precision)
  else
    strftime("%Y/%m/%d %H:%M:%S %z")
  end
end

def beginning_of_day
  change(hour: 0)
end

def beginning_of_hour
  change(min: 0)
end

def beginning_of_minute
  change(sec: 0)
end

def blank?
  false
end

def change(options)
  if new_nsec = options[:nsec]
    raise ArgumentError, "Can't change both :nsec and :usec at the same time: #{options.inspect}" if options[:usec]
    new_fraction = Rational(new_nsec, 1000000000)
  else
    new_usec = options.fetch(:usec, (options[:hour] || options[:min] || options[:sec]) ? 0 : Rational(nsec, 1000))
    new_fraction = Rational(new_usec, 1000000)
  end
  raise ArgumentError, "argument out of range" if new_fraction >= 1
  ::DateTime.civil(
    options.fetch(:year, year),
    options.fetch(:month, month),
    options.fetch(:day, day),
    options.fetch(:hour, hour),
    options.fetch(:min, options[:hour] ? 0 : min),
    options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec) + new_fraction,
    options.fetch(:offset, offset),
    options.fetch(:start, start)
  )
end

def current
  ::Time.zone ? ::Time.zone.now.to_datetime : ::Time.now.to_datetime
end

def end_of_day
  change(hour: 23, min: 59, sec: 59, usec: Rational(999999999, 1000))
end

def end_of_hour
  change(min: 59, sec: 59, usec: Rational(999999999, 1000))
end

def end_of_minute
  change(sec: 59, usec: Rational(999999999, 1000))
end

def formatted_offset(colon = true, alternate_utc_string = nil)
  utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, colon)
end

def localtime(utc_offset = nil)
  utc = new_offset(0)
  Time.utc(
    utc.year, utc.month, utc.day,
    utc.hour, utc.min, utc.sec + utc.sec_fraction
  ).getlocal(utc_offset)
end

def middle_of_day
  change(hour: 12)
end

def nsec
  (sec_fraction * 1_000_000_000).to_i
end

def offset_in_seconds
  (offset * 86400).to_i
end

def readable_inspect
  to_fs(:rfc822)
end

def seconds_since_midnight
  sec + (min * 60) + (hour * 3600)
end

def seconds_since_unix_epoch
  (jd - 2440588) * 86400 - offset_in_seconds + seconds_since_midnight
end

def seconds_until_end_of_day
  end_of_day.to_i - to_i
end

def since(seconds)
  self + Rational(seconds, 86400)
end

def subsec
  sec_fraction
end

def to_f
  seconds_since_unix_epoch.to_f + sec_fraction
end

def to_fs(format = :default)
  if formatter = ::Time::DATE_FORMATS[format]
    formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
  else
    to_default_s
  end
end

def to_i
  seconds_since_unix_epoch.to_i
end

def to_s(format = NOT_SET) # :nodoc:
  if formatter = ::Time::DATE_FORMATS[format]
    ActiveSupport::Deprecation.warn(
      "DateTime#to_s(#{format.inspect}) is deprecated. Please use DateTime#to_fs(#{format.inspect}) instead."
    )
    formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
  elsif format == NOT_SET
    to_default_s
  else
    ActiveSupport::Deprecation.warn(
      "DateTime#to_s(#{format.inspect}) is deprecated. Please use DateTime#to_fs(#{format.inspect}) instead."
    )
    to_default_s
  end
end

def to_time
  preserve_timezone ? getlocal(utc_offset) : getlocal
end

def usec
  (sec_fraction * 1_000_000).to_i
end

def utc
  utc = new_offset(0)
  Time.utc(
    utc.year, utc.month, utc.day,
    utc.hour, utc.min, utc.sec + utc.sec_fraction
  )
end

def utc?
  offset == 0
end

def utc_offset
  (offset * 86400).to_i
end