class ActiveSupport::TimeZone

def <=>(zone)
  return unless zone.respond_to? :utc_offset
  result = (utc_offset <=> zone.utc_offset)
  result = (name <=> zone.name) if result == 0
  result
end

def =~(re)
  re === name || re === MAPPING[name]
end

def [](arg)
  case arg
    when String
    begin
      @lazy_zones_map[arg] ||= create(arg)
    rescue TZInfo::InvalidTimezoneIdentifier
      nil
    end
    when Numeric, ActiveSupport::Duration
      arg *= 3600 if arg.abs <= 13
      all.find { |z| z.utc_offset == arg.to_i }
    else
      raise ArgumentError, "invalid argument to TimeZone[]: #{arg.inspect}"
  end
end

def all
  @zones ||= zones_map.values.sort
end

def at(secs)
  Time.at(secs).utc.in_time_zone(self)
end

def country_zones(country_code)
  code = country_code.to_s.upcase
  @country_zones[code] ||= load_country_zones(code)
end

def encode_with(coder) #:nodoc:
  coder.tag ="!ruby/object:#{self.class}"
  coder.map = { 'name' => tzinfo.name }
end

def find_tzinfo(name)
  TZInfo::Timezone.new(MAPPING[name] || name)
end

def formatted_offset(colon=true, alternate_utc_string = nil)
  utc_offset == 0 && alternate_utc_string || self.class.seconds_to_utc_offset(utc_offset, colon)
end

def init_with(coder) #:nodoc:
  initialize(coder['name'])
end

def initialize(name, utc_offset = nil, tzinfo = nil)
  @name = name
  @utc_offset = utc_offset
  @tzinfo = tzinfo || TimeZone.find_tzinfo(name)
end

def load_country_zones(code)
  country = TZInfo::Country.get(code)
  country.zone_identifiers.map do |tz_id|
    if MAPPING.value?(tz_id)
      self[MAPPING.key(tz_id)]
    else
      create(tz_id, nil, TZInfo::Timezone.new(tz_id))
    end
  end.sort!
end

def local(*args)
  time = Time.utc(*args)
  ActiveSupport::TimeWithZone.new(nil, self, time)
end

def local_to_utc(time, dst=true)
  tzinfo.local_to_utc(time, dst)
end

def new(name)
  self[name]
end

def now
  time_now.utc.in_time_zone(self)
end

def parse(str, now=now())
  parts_to_time(Date._parse(str, false), now)
end

def parts_to_time(parts, now)
  raise ArgumentError, "invalid date" if parts.nil?
  return if parts.empty?
  time = Time.new(
    parts.fetch(:year, now.year),
    parts.fetch(:mon, now.month),
    parts.fetch(:mday, parts[:year] || parts[:mon] ? 1 : now.day),
    parts.fetch(:hour, 0),
    parts.fetch(:min, 0),
    parts.fetch(:sec, 0) + parts.fetch(:sec_fraction, 0),
    parts.fetch(:offset, 0)
  )
  if parts[:offset]
    TimeWithZone.new(time.utc, self)
  else
    TimeWithZone.new(nil, self, time)
  end
end

def period_for_local(time, dst=true)
  tzinfo.period_for_local(time, dst)
end

def period_for_utc(time)
  tzinfo.period_for_utc(time)
end

def periods_for_local(time) #:nodoc:
  tzinfo.periods_for_local(time)
end

def seconds_to_utc_offset(seconds, colon = true)
  format = colon ? UTC_OFFSET_WITH_COLON : UTC_OFFSET_WITHOUT_COLON
  sign = (seconds < 0 ? '-' : '+')
  hours = seconds.abs / 3600
  minutes = (seconds.abs % 3600) / 60
  format % [sign, hours, minutes]
end

def strptime(str, format, now=now())
  parts_to_time(DateTime._strptime(str, format), now)
end

def time_now
  Time.now
end

def to_s
  "(GMT#{formatted_offset}) #{name}"
end

def today
  tzinfo.now.to_date
end

def tomorrow
  today + 1
end

def us_zones
  country_zones(:us)
end

def utc_offset
  if @utc_offset
    @utc_offset
  else
    tzinfo.current_period.utc_offset if tzinfo && tzinfo.current_period
  end
end

def utc_to_local(time)
  tzinfo.utc_to_local(time)
end

def yesterday
  today - 1
end

def zones_map
  @zones_map ||= begin
    MAPPING.each_key {|place| self[place]} # load all the zones
    @lazy_zones_map
  end
end