module CSL
  #
  # CSL::Locales contain locale specific date formatting options, term
  # translations, and a number ordinalizer.
  #
  class Locale < Node
    
    include Comparable
    
    @default = 'en-US'.freeze

    @root = File.expand_path('../../../vendor/locales', __FILE__).freeze
        
    @extension = '.xml'.freeze
    @prefix = 'locales-'.freeze
    
    
    # Default languages/regions.
    # Auto-detection is based on these lists.
    @regions = Hash[*%w{
      af ZA ar AR bg BG ca AD cs CZ da DK de DE el GR en US es ES et EE fa IR
      fr FR he IL hu HU is IS it IT ja JP km KH ko KR mn MN nb NO nl NL nn NO
      pl PL pt PT ro RO ru RU sk SK sl SI sr RS sv SE th TH tr TR uk UA vi VN
      zh CN zh TW
    }.map(&:to_sym)].freeze

    @languages = @regions.invert.merge(Hash[*%w{
      AT de BR pt CA en CH de GB en
    }.map(&:to_sym)]).freeze
    
    
    class << self
      
      include Loader
      
      attr_accessor :default
      attr_reader :languages, :regions

      def parse(data)
        node = CSL.parse!(data, self)
        
        raise ParseError, "root node is not a locale: #{node.inspect}" unless
          node.is_a?(self)
        
        node
      end
      
    end
    
    attr_defaults :version => Schema.version, :xmlns => Schema.namespace
    attr_struct :xmlns, :version

    attr_children :'style-options', :info, :date, :terms
    
    attr_accessor :language, :region
    
    alias metadata info
    alias dates    date
    alias options  style_options

    private :attributes
    undef_method :[]=
        
    # call-seq:
    #   Locale.new                                         -> default
    #   Locale.new('en')                                   -> American English
    #   Locale.new('en', :'punctuation-in-quote' => fales) -> with style-options
    #   Locale.new(:lang => 'en-GB', :version => '1.0')    -> British English
    #
    # Returns a new locale. In the first form, the language/regions is set
    # to the default language and region. In the second form the
    # language/region is set by the passed-in IETF tag. The third form
    # additionally accepts a hash of localize style-options. The fourth form
    # is the standard node attribute initialize signature.
    def initialize(*arguments)
      case arguments.length
      when 0
        locale, attributes, options = Locale.default, {}, nil
      when 1
        if arguments[0].is_a?(Hash)
          arguments[0] = arguments[0].symbolize_keys
          
          locale = arguments[0].delete(:lang) ||
            arguments[0].delete(:'xml:lang') || Locale.default
            
          attributes, options = arguments
        else
          attributes, locale, options = {}, arguments
        end
      when 2
        attributes, locale, options = {}, *arguments
      else
        raise ArgumentError, "wrong number of arguments (#{arguments.length} for 0..2)"
      end
        
      super(attributes)
      
      set(locale) unless locale.nil?
      
      unless options.nil?
        children[:'style-options'] = StyleOptions.new(options)
      end
      
      yield self if block_given?
    end

    # TODO
    # def initialize_copy(other)
    #   @options = other.options.dup
    # end
    
    
    def added_to(node)
      raise ValidationError, "not allowed to add locale to #{node.nodename}" unless
        node.nodename == 'style'
    end
    
    
    def version
      attributes[:version]
    end
    
    def version=(version)
      raise ArgumentError, "failed to set version to #{version}" unless
        version.respond_to?(:to_s)
        
      version = version.to_s.strip
      
      raise ArgumentError, "failed to set version to #{version}: not a version string" unless
        version =~ /^\d[\d\.]+$/

      if version > Schema.version
        warn "setting version to #{version}; latest supported version is #{Schema.version}"
      end
      
      attributes[:version] = version
    end

    # @return [Boolean] whether or not the Locale's version is less than CSL-Ruby's default version
    def legacy?
      version < Schema.version
    end
    
    # call-seq:
    #   locale.set('en')    -> sets language to :en, region to :US
    #   locale.set('de-AT') -> sets language to :de, region to :AT
    #   locale.set('-DE')   -> sets langauge to :de, region to :DE
    #
    # Sets language and region according to the passed-in locale string. If
    # the region part is not defined by the string, this method will set the
    # region to the default region for the given language.
    #
    # Raises ArgumentError if the argument is no valid locale string. A valid
    # locale string is based on the syntax of IETF language tags; it consists
    # of either a language or region tag (or both), separated by a hyphen.
    def set(locale)
      language, region = locale.to_s.scan(/([a-z]{2})?(?:-([A-Z]{2}))?/)[0].map do |tag|
        tag.respond_to?(:to_sym) ? tag.to_sym : nil
      end
      
      case
      when language && region
        @language, @region = language, region
      when language
        @language, @region = language, Locale.regions[language]
      when region
        @language, @region = Locale.languages[region], region
      else
        raise ArgumentError, "not a valid locale string: #{locale.inspect}"
      end
      
      self
    end
    
    # Sets the locale's language and region to nil.
    def clear
      @language, @region = nil
      self
    end
    
    def translate(*arguments)
      raise 'not implemented'
    end

    alias _ translate
    alias t translate
    
    # call-seq:
    #   locale.each_term { |term| block } -> locale
    #   locale.each_term                  -> enumerator
    #
    # Calls block once for each term defined by the locale. If no block is
    # given, an enumerator is returned instead.
    def each_term
      if block_given?
        terms.each(&Proc.new)
        self
      else
        enum_for :each_term
      end
    end
    
    # call-seq:
    #   locale.each_date { |date_format| block } -> locale
    #   locale.each_date                         -> enumerator
    #
    # Calls block once for each date format defined by the locale. If no
    # block is given, an enumerator is returned instead.
    def each_date
      if block_given?
        date.each(&Proc.new)
      else
        enum_for :each_date
      end
    end
    
    # @returns [Boolean] whether or not the Locale is the default locale
    def default?
      to_s == Locale.default
    end
    
    # @return [Boolean] whehter or not the Locale's region is the default
    #   region for its language
    def default_region?
      region && region == Locale.regions[language]
    end

    # @return [Boolean] whether or not the Locale's language is the default
    #   language for its region
    def default_language?
      language && language == Locale.languages[region]
    end

    # Ordinalizes the passed-in number using either the ordinal or
    # long-ordinal forms defined by the locale. If a long-ordinal form is
    # requested but not available, the regular ordinal will be returned
    # instead.
    #
    # @example
    #   Locale.load('en').ordinalize(13)
    #   #-> "13th"
    #
    #   de = Locale.load('de')
    #   de.ordinalize(13)
    #   #-> "13."
    #
    #   de.ordinalize(3, :form => :long, :gender => :feminine)
    #   #-> "dritte"
    #
    # @note
    #   For CSL 1.0 (and older) locales that do not define an "ordinal-00"
    #   term the algorithm specified by CSL 1.0 is used; otherwise uses the
    #   CSL 1.0.1 algorithm with improved support for languages other than
    #   English.
    #
    # @param number [#to_i] the number to ordinalize
    # @param options [Hash] formatting options
    #
    # @option options [:short,:long] :form (:short) which ordinals form to use
    # @option options [:feminine,:masculine,:neutral] :gender (:neutral)
    #   which ordinals gender-form to use
    #
    # @raise [ArgumentError] if number cannot be converted to an integer
    #
    # @return [String] the ordinal for the passed-in number
    def ordinalize(number, options = {})
      raise ArgumentError, "unable to ordinalize #{number}; integer expected" unless
        number.respond_to?(:to_i)
        
      number, query = number.to_i, ordinalize_query_for(options)
      
      key = query[:name]
      
      # try to match long-ordinals first
      if key.start_with?('l')
        query[:name] = key % number.abs 
        ordinal = terms[query]
        
        if ordinal.nil?
          key = 'ordinal-%02d'
        else
          return ordinal.to_s(options)
        end
      end
      
      # CSL 1.0
      if legacy? || terms['ordinal-00'].nil? 
        return legacy_ordinalize(number)
      end
      
      # CSL 1.0.1
      # 1. try to find exact match
      # 2. if no match is found, try to match modulus of number,
      #    dividing mod by 10 at each iteration
      # 3. repeat until a match is found or mod reaches 0

      mod = 10 ** Math.log10([number.abs, 1].max).to_i

      query[:name] = key % number.abs
      ordinal = terms[query]
      
      while ordinal.nil? && mod > 0
        query[:name] = key % (number.abs % mod)
        ordinal = terms[query]
        mod = mod / 10
      end
      
      if ordinal.nil? && query.key?(:'gender-form')
        query.delete(:'gender-form')
        ordinal = terms[query]
      end
      
      [number, ordinal.to_s(options)].join
    end
    
    def validate
      Schema.validate self
    end
    
    def valid?
      validate.empty?
    end

    # Locales are sorted first by language, then by region; sort order is
    # alphabetical with the following exceptions: the default locale is
    # prioritised; in case of a language match the default region of that
    # language will be prioritised (e.g., de-DE will come before de-AT even
    # though the alphabetical order would be different).
    #
    # @param other [Locale] the locale used for comparison
    # @return [1,0,-1,nil] the result of the comparison
    def <=>(other)
      case
      when !other.is_a?(Locale)
        nil
      when [language, region] == [other.language, other.region]
        0
      when default?
        -1
      when other.default?
        1
      when language == other.language
        case
        when default_region?
          -1
        when other.default_region?
          1
        else
          region <=> other.region
        end
      else
        language <=> other.language
      end
    end

    # @return [String] the Locale's IETF tag
    def to_s
      [language, region].compact.join('-')
    end
    
    # @return [String] a string representation of the Locale
    def inspect
      "#<#{self.class.name} #{to_s}: dates=[#{dates.length}] terms=[#{terms.length}]>"
    end
    
    private
    
    def attribute_assignments
      if root?
        super.push('xml:lang="%s"' % to_s)
      else
        'xml:lang="%s"' % to_s
      end
    end
    
    def preamble
      Schema.preamble.dup
    end 

    # @return [Hash] a valid ordinalize query; the name attribute is a format string
    def ordinalize_query_for(options)
      q = { :name => 'ordinal-%02d' }

      unless options.nil?
        if options.key?(:form) && options[:form].to_s =~ /^long(-ordinal)?$/i
          q[:name] = 'long-ordinal-%02d'
        end
      
        gender = (options[:'gender-form'] || options[:gender]).to_s
        unless gender.empty? || gender =~ /^n/i
          q[:'gender-form'] = (gender =~ /^m/i) ? 'masculine' : 'feminine'
        end
      end
      
      q
    end
    
    def legacy_ordinalize(number)
      case
      when (11..13).include?(number.abs % 100)
        [number, terms['ordinal-04']].join
      when (1..3).include?(number.abs % 10)
        [number, terms['ordinal-%02d' % (number.abs % 10)]].join
      else
        [number, terms['ordinal-04']].join
      end
    end
  end
  
end