class TZInfo::Timezone

def self._load(data)
  Timezone.get(data)
end

def self.all
  get_proxies(all_identifiers)
end

def self.all_country_zone_identifiers
  Country.all_codes.inject([]) {|zones,country|
    zones += Country.get(country).zone_identifiers
  }
end

def self.all_country_zones
  Country.all_codes.inject([]) {|zones,country|
    zones += Country.get(country).zones
  }
end

def self.all_data_zone_identifiers
  load_index
  Indexes::Timezones.data_timezones
end

def self.all_data_zones
  get_proxies(all_data_zone_identifiers)
end

def self.all_identifiers
  load_index
  Indexes::Timezones.timezones
end

def self.all_linked_zone_identifiers
  load_index
  Indexes::Timezones.linked_timezones
end

def self.all_linked_zones
  get_proxies(all_linked_zone_identifiers)      
end

def self.default_dst
  @@default_dst
end

def self.default_dst=(value)
  @@default_dst = value.nil? ? nil : !!value
end

def self.get(identifier)
  instance = @@loaded_zones[identifier]
  unless instance  
    raise InvalidTimezoneIdentifier, 'Invalid identifier' if identifier !~ /^[A-Za-z0-9\+\-_]+(\/[A-Za-z0-9\+\-_]+)*$/
    identifier = identifier.gsub(/-/, '__m__').gsub(/\+/, '__p__')
    begin
      # Use a temporary variable to avoid an rdoc warning
      file = "tzinfo/definitions/#{identifier}".untaint
      require file
      
      m = Definitions
      identifier.split(/\//).each {|part|
        m = m.const_get(part)
      }
      
      info = m.get
      
      # Could make Timezone subclasses register an interest in an info
      # type. Since there are currently only two however, there isn't
      # much point.
      if info.kind_of?(DataTimezoneInfo)
        instance = DataTimezone.new(info)
      elsif info.kind_of?(LinkedTimezoneInfo)
        instance = LinkedTimezone.new(info)
      else
        raise InvalidTimezoneIdentifier, "No handler for info type #{info.class}"
      end
      
      @@loaded_zones[instance.identifier] = instance         
    rescue LoadError, NameError => e
      raise InvalidTimezoneIdentifier, e.message
    end
  end
  
  instance
end

def self.get_proxies(identifiers)
  identifiers.collect {|identifier| get_proxy(identifier)}
end

def self.get_proxy(identifier)
  TimezoneProxy.new(identifier)
end

def self.load_index
  unless @@index_loaded
    require 'tzinfo/indexes/timezones'
    @@index_loaded = true
  end        
end

def self.new(identifier = nil)
  if identifier        
    get(identifier)
  else
    super()
  end
end

def self.us_zone_identifiers
  Country.get('US').zone_identifiers
end

def self.us_zones
  Country.get('US').zones
end

def <=>(tz)
  identifier <=> tz.identifier
end

def _dump(limit)
  identifier
end

def current_period
  period_for_utc(Time.now.utc)
end

def current_period_and_time
  utc = Time.now.utc
  period = period_for_utc(utc)
  [period.to_local(utc), period]
end

def eql?(tz)
  self == tz
end

def friendly_identifier(skip_first_part = false)
  parts = identifier.split('/')
  if parts.empty?
    # shouldn't happen
    identifier
  elsif parts.length == 1        
    parts[0]
  else
    if skip_first_part
      result = ''
    else
      result = parts[0] + ' - '
    end
    
    parts[1, parts.length - 1].reverse_each {|part|
      part.gsub!(/_/, ' ')
      
      if part.index(/[a-z]/)
        # Missing a space if a lower case followed by an upper case and the
        # name isn't McXxxx.
        part.gsub!(/([^M][a-z])([A-Z])/, '\1 \2')
        part.gsub!(/([M][a-bd-z])([A-Z])/, '\1 \2')
        
        # Missing an apostrophe if two consecutive upper case characters.
        part.gsub!(/([A-Z])([A-Z])/, '\1\'\2')
      end
      
      result << part
      result << ', '
    }
    
    result.slice!(result.length - 2, 2)
    result
  end
end

def hash
  identifier.hash
end

def identifier
  raise UnknownTimezone, 'TZInfo::Timezone constructed directly'
end

def inspect
  "#<#{self.class}: #{identifier}>"
end

def local_to_utc(local, dst = Timezone.default_dst)
  TimeOrDateTime.wrap(local) {|wrapped|
    if block_given?
      period = period_for_local(wrapped, dst) {|periods| yield periods }
    else
      period = period_for_local(wrapped, dst)
    end
    
    period.to_utc(wrapped)
  }
end

def name
  # Don't use alias, as identifier gets overridden.
  identifier
end

def now
  utc_to_local(Time.now.utc)
end

def period_for_local(local, dst = Timezone.default_dst)
  results = periods_for_local(local)
  
  if results.empty?
    raise PeriodNotFound
  elsif results.size < 2
    results.first
  else
    # ambiguous result try to resolve
    
    if !dst.nil?
      matches = results.find_all {|period| period.dst? == dst}
      results = matches if !matches.empty?            
    end
    
    if results.size < 2
      results.first
    else
      # still ambiguous, try the block
                
      if block_given?
        results = yield results
      end
      
      if results.is_a?(TimezonePeriod)
        results
      elsif results && results.size == 1
        results.first
      else          
        raise AmbiguousTime, "#{local} is an ambiguous local time."
      end
    end
  end      
end

def period_for_utc(utc)            
  raise UnknownTimezone, 'TZInfo::Timezone constructed directly'      
end

def periods_for_local(local)
  raise UnknownTimezone, 'TZInfo::Timezone constructed directly'
end

def strftime(format, utc = Time.now.utc)      
  period = period_for_utc(utc)
  local = period.to_local(utc)      
  local = Time.at(local).utc unless local.kind_of?(Time) || local.kind_of?(DateTime)
  abbreviation = period.abbreviation.to_s.gsub(/%/, '%%')
  
  format = format.gsub(/(.?)%Z/) do
    if $1 == '%'
      # return %%Z so the real strftime treats it as a literal %Z too
      '%%Z'
    else
      "#$1#{abbreviation}"
    end
  end
  
  local.strftime(format)
end

def to_s
  friendly_identifier
end

def utc_to_local(utc)
  TimeOrDateTime.wrap(utc) {|wrapped|
    period_for_utc(wrapped).to_local(wrapped)
  }
end