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.kind_of?(Infinity)
    super
  elsif other.respond_to? :to_datetime
    super other.to_datetime
  else
    nil
  end
end

def acts_like_date?
  true
end

def acts_like_time?
  true
end

def advance(options)
  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.use_standard_json_time_format
    xmlschema
  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 change(options)
  ::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 + sec_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)
end

def end_of_hour
  change(:min => 59, :sec => 59)
end

def end_of_minute
  change(:sec => 59)
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 future?
  self > ::DateTime.current
end

def in_time_zone(zone = ::Time.zone)
  if zone
    ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.find_zone!(zone))
  else
    self
  end
end

def local_offset
  ActiveSupport::Deprecation.warn 'DateTime.local_offset is deprecated. Use DateTime.civil_from_format directly.'
  ::Time.local(2012).utc_offset.to_r / 86400
end

def nsec
  (sec_fraction * 1_000_000_000).to_i
end

def offset_in_seconds
  (offset * 86400).to_i
end

def past?
  self < ::DateTime.current
end

def readable_inspect
  to_s(: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.round, 86400)
end

def to_f
  seconds_since_unix_epoch.to_f
end

def to_formatted_s(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 usec
  (sec_fraction * 1_000_000).to_i
end

def utc
  new_offset(0)
end

def utc?
  offset == 0
end

def utc_offset
  (offset * 86400).to_i
end