class Time

def ===(other)
  super || (self == Time && other.is_a?(ActiveSupport::TimeWithZone))
end

def _dump(*args)
  obj = dup
  obj.instance_variable_set('@marshal_with_utc_coercion', utc?)
  obj.send :_dump_without_utc_flag, *args
end

def _dump(*args)
  obj = dup
  obj.instance_variable_set('@_zone', zone)
  obj.send :_dump_without_zone, *args
end

def _load(marshaled_time)
  time = _load_without_utc_flag(marshaled_time)
  time.instance_eval do
    if defined?(@marshal_with_utc_coercion)
      val = remove_instance_variable("@marshal_with_utc_coercion")
    end
    val ? utc : self
  end
end

def _load(marshaled_time)
  time = _load_without_zone(marshaled_time)
  time.instance_eval do
    if zone = defined?(@_zone) && remove_instance_variable('@_zone')
      ary = to_a
      ary[0] += subsec if ary[0] == sec
      ary[-1] = zone
      utc? ? Time.utc(*ary) : Time.local(*ary)
    else
      self
    end
  end
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[:days] || 0) + 7 * partial_weeks
  end
  unless options[:days].nil?
    options[:days], partial_days = options[:days].divmod(1)
    options[:hours] = (options[:hours] || 0) + 24 * partial_days
  end
  d = to_date.advance(options)
  time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
  seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600
  seconds_to_advance == 0 ? time_advanced_by_date : time_advanced_by_date.since(seconds_to_advance)
end

def ago(seconds)
  since(-seconds)
end

def all_day
  beginning_of_day..end_of_day
end

def all_month
  beginning_of_month..end_of_month
end

def all_quarter
  beginning_of_quarter..end_of_quarter
end

def all_week(start_day = :monday)
  beginning_of_week(start_day)..end_of_week(start_day)
end

def all_year
  beginning_of_year..end_of_year
end

def as_json(options = nil) #:nodoc:
  if ActiveSupport.use_standard_json_time_format
    xmlschema
  else
    %(#{strftime("%Y/%m/%d %H:%M:%S")} #{formatted_offset(false)})
  end
end

def at_with_coercion(*args)
  return at_without_coercion(*args) if args.size != 1
  # Time.at can be called with a time or numerical value
  time_or_number = args.first
  if time_or_number.is_a?(ActiveSupport::TimeWithZone) || time_or_number.is_a?(DateTime)
    at_without_coercion(time_or_number.to_f).getlocal
  else
    at_without_coercion(time_or_number)
  end
end

def beginning_of_day
  #(self - seconds_since_midnight).change(:usec => 0)
  change(:hour => 0)
end

def beginning_of_hour
  change(:min => 0)
end

def beginning_of_month
  #self - ((self.mday-1).days + self.seconds_since_midnight)
  change(:day => 1, :hour => 0)
end

def beginning_of_quarter
  beginning_of_month.change(:month => [10, 7, 4, 1].detect { |m| m <= month })
end

def beginning_of_week(start_day = :monday)
  days_to_start = days_to_week_start(start_day)
  (self - days_to_start.days).midnight
end

def beginning_of_year
  change(:month => 1, :day => 1, :hour => 0)
end

def change(options)
  ::Time.send(
    utc? ? :utc_time : :local_time,
    options[:year]  || year,
    options[:month] || month,
    options[:day]   || day,
    options[:hour]  || hour,
    options[:min]   || (options[:hour] ? 0 : min),
    options[:sec]   || ((options[:hour] || options[:min]) ? 0 : sec),
    options[:usec]  || ((options[:hour] || options[:min] || options[:sec]) ? 0 : usec)
  )
end

def compare_with_coercion(other)
  # we're avoiding Time#to_datetime cause it's expensive
  other.is_a?(Time) ? compare_without_coercion(other.to_time) : to_datetime <=> other
end

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

def days_in_month(month, year = now.year)
  return 29 if month == 2 && ::Date.gregorian_leap?(year)
  COMMON_YEAR_DAYS_IN_MONTH[month]
end

def days_to_week_start(start_day = :monday)
  start_day_number = DAYS_INTO_WEEK[start_day]
  current_day_number = wday != 0 ? wday - 1 : 6
  days_span = current_day_number - start_day_number
  days_span >= 0 ? days_span : 7 + days_span
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_month
  #self - ((self.mday-1).days + self.seconds_since_midnight)
  last_day = ::Time.days_in_month(month, year)
  change(:day => last_day, :hour => 23, :min => 59, :sec => 59, :usec => Rational(999999999, 1000))
end

def end_of_quarter
  beginning_of_month.change(:month => [3, 6, 9, 12].detect { |m| m >= month }).end_of_month
end

def end_of_week(start_day = :monday)
  days_to_end =  6 - days_to_week_start(start_day)
  (self + days_to_end.days).end_of_day
end

def end_of_year
  change(:month => 12, :day => 31, :hour => 23, :min => 59, :sec => 59, :usec => Rational(999999999, 1000))
end

def eql_with_coercion(other)
  # if other is an ActiveSupport::TimeWithZone, coerce a Time instance from it so we can do eql? comparison
  other = other.comparable_time if other.respond_to?(:comparable_time)
  eql_without_coercion(other)
end

def find_zone(time_zone)
  find_zone!(time_zone) rescue nil
end

def find_zone!(time_zone)
  return time_zone if time_zone.nil? || time_zone.is_a?(ActiveSupport::TimeZone)
  # lookup timezone based on identifier (unless we've been passed a TZInfo::Timezone)
  unless time_zone.respond_to?(:period_for_local)
    time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone)
  end
  # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
  time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
rescue TZInfo::InvalidTimezoneIdentifier
  raise ArgumentError, "Invalid Timezone: #{time_zone}"
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 > ::Time.current
end

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

def local_time(*args)
  time_with_datetime_fallback(:local, *args)
end

def minus_with_coercion(other)
  other = other.comparable_time if other.respond_to?(:comparable_time)
  other.is_a?(DateTime) ? to_f - other.to_f : minus_without_coercion(other)
end

def minus_with_duration(other) #:nodoc:
  if ActiveSupport::Duration === other
    other.until(self)
  else
    minus_without_duration(other)
  end
end

def monday
  beginning_of_week
end

def months_ago(months)
  advance(:months => -months)
end

def months_since(months)
  advance(:months => months)
end

def next_month
  months_since(1)
end

def next_week(day = :monday)
  since(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0)
end

def next_year
  years_since(1)
end

def past?
  self < ::Time.current
end

def plus_with_duration(other) #:nodoc:
  if ActiveSupport::Duration === other
    other.since(self)
  else
    plus_without_duration(other)
  end
end

def prev_month
  months_ago(1)
end

def prev_week(day = :monday)
  ago(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0)
end

def prev_year
  years_ago(1)
end

def seconds_since_midnight
  to_i - change(:hour => 0).to_i + (usec / 1.0e+6)
end

def since(seconds)
  self + seconds
rescue
  to_datetime.since(seconds)
end

def sunday
  end_of_week
end

def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
  time = ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
  # This check is needed because Time.utc(y) returns a time object in the 2000s for 0 <= y <= 138.
  time.year == year ? time : ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec)
rescue
  ::DateTime.civil_from_format(utc_or_local, year, month, day, hour, min, sec)
end

def to_date
  ::Date.new(year, month, day)
end unless method_defined?(:to_date)

def to_datetime
  ::DateTime.civil(year, month, day, hour, min, sec, Rational(utc_offset, 86400))
end unless method_defined?(:to_datetime)

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

def to_time
  self
end unless method_defined?(:to_time)

def today?
  to_date == ::Date.current
end

def tomorrow
  advance(:days => 1)
end

def use_zone(time_zone)
  new_zone = find_zone!(time_zone)
  begin
    old_zone, ::Time.zone = ::Time.zone, new_zone
    yield
  ensure
    ::Time.zone = old_zone
  end
end

def utc_time(*args)
  time_with_datetime_fallback(:utc, *args)
end

def weeks_ago(weeks)
  advance(:weeks => -weeks)
end

def years_ago(years)
  advance(:years => -years)
end

def years_since(years)
  advance(:years => years)
end

def yesterday
  advance(:days => -1)
end

def zone
  Thread.current[:time_zone] || zone_default
end

def zone=(time_zone)
  Thread.current[:time_zone] = find_zone!(time_zone)
end