require "eymiha/units/units"

module Eymiha

  # The unit part of a NumericWithUnits is a UnitsHash - a Hash from UnitsUnit
  # instances to powers.
  class UnitsHash < Hash
    
    @@debug = false
    
    def self.debug=(value)
      @@debug = value
    end
    
    def initialize(unit = nil,power = 1) # :nodoc
      if unit
        if unit.kind_of? UnitsUnit
          self[unit] = power
        elsif unit.kind_of? UnitsHash
          unit.each { |k,v| self[k] = v*power }
        else
          raise UnitsException.new("invalid unit: #{unit}")
        end
      end
    end
    
    # Returns a String reprentation of the instance. If there is only one item
    # in the UnitsHash, whole names are rendered; otherwise abbreviations are
    # used.
    def to_s(numeric = 1,use_abbrevs = false)
      if size == 1 &&
          (su = select {|k,v| v == 1}).size == 1 &&
          !use_abbrevs
        su = su.to_a[0][0]
        ((numeric == 1)? su.name : su.plural).gsub(/_/,' ')
      else
        abbrevs_to_s
      end
    end
    
    def abbrevs_to_s # :nodoc:
      p = select {|k,v| v > 0}.sort{|e1,e2| e1[1] <=> e2[1]}.collect {|e|
        "#{e[0].abbrevs[0] || e[0].name}#{(e[1] == 1) ? "" : "^#{e[1]}"}"}
      n = select {|k,v| v < 0}.sort{|e1,e2| e1[1] <=> e2[1]}.collect {|e|
        "#{e[0].abbrevs[0] || e[0].name}#{(e[1] == -1) ? "" : "^#{-e[1]}"}"}
      numerator = (p.size > 0)? p.join(" ") : (n.size > 0)? "1" : ""
      denominator = (n.size > 0)? ((p.size > 0)? " / " : "/")+n.join(" ") : ""
      "#{numerator}#{denominator}"
    end
    
    # Raises and returns the instance after each of its exponents has been
    # raised by the given power.
    def power!(power)
      self.each { |k,v| self[k] = v*power }
    end
    
    # Returns a new UnitsHash whose value is the instance raised to the given
    # power.
    def **(power)
      clone.power!(power)
    end
    
    # Returns a new UnitsHash whose value is the instance's units and powers
    # have been merged with the given value raised to the power.
    def merge(value,power=1)
      clone.merge!(value,power)
    end
    
    # Merges and returns the instance after the value raised to the power has
    # been merged into it.
    def merge!(value,power=1)
      value.unit.each { |k,v|
        self[k] = (self[k] || 0) + v*power
        delete k if self[k] == 0
      }
      self
    end
    
    alias :* :merge
    
    # Returns the UnitsMeasure of the instance if defined.
    def measure
      measure = UnitsMeasure.new
      each { |unit,power|
        measure.merge_derivation unit.units_system.units_measure => power }
      Units.find_by_derivation(measure.derived)
    end
    
    # Returns true is any of the instance's components are derived.
    def derived?
      keys.select{|unit|
        unit.units_system.units_measure.derived != nil}.size > 0
    end
    
    # Return a NumericWithUnits that represents the instance when all derived
    # units have been replaced with the units from which they derive.
    def reduce
      puts "UnitsHash:reduce #{to_s}" if @@debug
      factor = 1.0
      new_unit = UnitsHash.new
      each do |unit,power|
        puts "  #{unit} #{power}" if @@debug
        factor *= unit.equals.numeric**power
        puts "  #{factor}" if @@debug
        new_unit.merge!(unit.equals,power)
      end
      factor.unite new_unit
    end
    
    # Return true if the instance is not equal to 1, ie. has at least one
    # non-zero exponent.
    def has_units?
      (self.select {|k,v| v != 0.0}).size > 0
    end
    
  end
  
end