module Locale

def app_language_tags
  @@app_language_tags
end

def candidates(options = {})
  opts = {
    :supported_language_tags => nil,
    :current                 => current,
    :type                    => :common,
  }.merge(options)
  Thread.current[:candidates_caches] ||= {}
  Thread.current[:candidates_caches][opts] ||=
    collect_candidates(opts[:type], opts[:current],
                       opts[:supported_language_tags])
end

def cgi=(cgi)
  set_cgi(cgi)
  cgi
end

def charset
  driver_module.charset || "UTF-8"
end

def clear
  Thread.current[:current_languages] = nil
  Thread.current[:candidates_caches] = nil
  self
end

def clear_all
  Thread.list.each do |thread|
    thread[:current_languages] = nil
    thread[:candidates_caches] = nil
  end
  self
end

def collect_candidates(type, tags, supported_tags) # :nodoc:
  candidate_tags = tags.collect{|v| v.send("to_#{type}").candidates}
  default_tags = default.send("to_#{type}").candidates
  if app_language_tags
    app_tags = app_language_tags.collect{|v| v.send("to_#{type}")}.flatten.uniq
  end
  if supported_tags
    supported_tags = supported_tags.collect{|v| Locale::Tag.parse(v).send("to_#{type}")}.flatten.uniq
  end
  tags = []
  unless candidate_tags.empty?
    (0...candidate_tags[0].size).each {|i|
      tags += candidate_tags.collect{|v| v[i]}
    }
  end
  tags += default_tags
  tags.uniq!
  all_tags = nil
  if app_tags
    if supported_tags
      all_tags = app_tags & supported_tags
    else
      all_tags = app_tags
    end
  elsif supported_tags
    all_tags = supported_tags
  end
  if all_tags
    tags &= all_tags
    tags = default_tags.uniq if tags.size == 0
  end
  Locale::TagList.new(tags)
end

def create_language_tag(tag)  #:nodoc:
  case tag
  when nil
  when Locale::Tag::Simple
    tag
  when Locale::TagList
    tag[0]
  else
    Locale::Tag.parse(tag)
  end
end

def current
  unless Thread.current[:current_languages]
    loc = driver_module.locales
    Thread.current[:current_languages] = loc ? loc : Locale::TagList.new([default])
  end
  Thread.current[:current_languages]
end

def current=(tag)
  set_current(tag)
  Thread.current[:current_languages]
end

def default
  @@default_tag || DEFAULT_LANGUAGE_TAG
end

def default=(tag)
  set_default(tag)
  @@default_tag
end

def driver_module 
  Locale.init if @@driver_name.nil?
  Driver::MODULES[@@driver_name]
end

def get #:nodoc: 
  current
end

def init(opts = {})
  if opts[:driver]
    require_driver opts[:driver]
  else
    if /cygwin|mingw|win32/ =~ RUBY_PLATFORM
      require_driver 'win32' 
    elsif /java/ =~ RUBY_PLATFORM
      require_driver 'jruby' 
    else
      require_driver 'posix' 
    end
  end
end

def require_driver(name)  #:nodoc:
  require "locale/driver/#{name}"
  @@driver_name = name.to_sym
end

def set(tag)  #:nodoc:
  set_current(tag)
end

def set_app_language_tags(*tags)
  if tags[0]
    @@app_language_tags = tags.collect{|v| Locale::Tag.parse(v)}
  else
    @@app_language_tags = nil
  end
  
  clear_all
  self
end

def set_cgi(cgi)
  set_request(cgi.params["lang"], cgi.cookies["lang"],
              cgi.accept_language, cgi.accept_charset)
  self
end

def set_current(*tags)
  languages = nil
  if tags[0]
    languages = Locale::TagList.new
    tags.each do |tag|
      case tag
      when Locale::TagList
        languages.concat(tag)
      else
        languages << create_language_tag(tag)
      end
    end
  end
  Thread.current[:current_languages] = languages
  Thread.current[:candidates_caches] = nil
  self
end

def set_default(tag)
  Thread.list.each do |thread|
    thread[:current_languages] = nil
    thread[:candidates_caches] = nil
  end
  @@default_tag = create_language_tag(tag)
  self
end

def set_request(query_langs, cookie_langs, accept_language, accept_charset)
  driver_module.set_request(query_langs, cookie_langs, accept_language, accept_charset)
  self
end