class MiGA::Taxonomy

def <<(value)
  case value
  when Hash
    value.each do |r, n|
      next if n.nil? || n == ''
      @ranks[self.class.normalize_rank(r)] = n.tr('_', ' ')
    end
  when Array
    value.each { |v| self << v }
  when String
    self << Hash[*value.split(':', 2)]
  else
    raise 'Unsupported class: ' + value.class.name
  end
end

def KNOWN_RANKS()
  @@KNOWN_RANKS
end

def LONG_RANKS()
  @@LONG_RANKS
end

def [](rank)
  @ranks[rank.to_sym]
end

def add_alternative(tax, replace = true)
  return if tax.nil?
  raise 'Unsupported taxonomy class.' unless tax.is_a? MiGA::Taxonomy
  alt_ns = alternative(tax.namespace)
  if !replace || tax.namespace.nil? || alt_ns.nil?
    @alt << tax
  else
    alt_ns.reset(tax.to_s)
  end
end

def alternative(which = nil)
  case which
  when nil
    @alt
  when Integer
    ([self] + @alt)[which]
  else
    ([self] + @alt).find { |i| i.namespace.to_s == which.to_s }
  end
end

def delete_alternative
  alt = @alt.dup
  @alt = []
  alt
end

def domain
  self[:d]
end

def dup
  self.class.new(to_s, nil, alternative.map(&:dup))
end

def highest(force_ranks = false)
  sorted_ranks(force_ranks).first
end

def in?(taxon)
  r = taxon.ranks.keys.first
  return false if self[r].nil?
  self[r].casecmp(taxon[r]).zero?
end

def initialize(str, ranks = nil, alt = [])
  reset(str, ranks)
  @alt = (alt || []).map { |i| Taxonomy.new(i) }
end

def initialize_by_ranks(str, ranks)
  ranks = ranks.split(/\s+/) unless ranks.is_a? Array
  str = str.split(/\s+/) unless str.is_a? Array
  unless ranks.size == str.size
    raise "Unequal number of ranks and names: #{ranks} => #{str}"
  end
  str.each_with_index { |i, k| self << "#{ranks[k]}:#{i}" }
end

def initialize_by_str(str)
  case str
  when Array, Hash
    self << str
  else
    "#{str} ".scan(/([A-Za-z]+):([^:]*)( )/) { |r, n, _| self << { r => n } }
  end
end

def json_create(o)
  new(o['str'], nil, o['alt'])
end

def lowest(force_ranks = false)
  sorted_ranks(force_ranks).last
end

def namespace
  self[:ns]
end

def normalize_rank(rank)
  return unless rank
  return rank.to_sym if @@_KNOWN_RANKS_H[rank.to_sym]
  rank = rank.to_s.downcase
  return if rank == 'no rank'
  rank = @@RANK_SYNONYMS[rank] unless @@RANK_SYNONYMS[rank].nil?
  rank = rank.to_sym
  return unless @@_KNOWN_RANKS_H[rank]
  rank
end

def reset(str, ranks = nil)
  @ranks = {}
  if ranks.nil?
    initialize_by_str(str)
  else
    initialize_by_ranks(str, ranks)
  end
end

def sorted_ranks(force_ranks = false, with_namespace = false)
  @@KNOWN_RANKS.map do |r|
    next if
      (r == :ns && !with_namespace) || (ranks[r].nil? && !force_ranks)
    [r, ranks[r]]
  end.compact
end

def to_json(*a)
  hsh = { JSON.create_id => self.class.name, 'str' => to_s }
  hsh['alt'] = alternative.map(&:to_s) unless alternative.empty?
  hsh.to_json(*a)
end

def to_s(force_ranks = false)
  sorted_ranks(force_ranks, true)
    .map { |r| "#{r[0]}:#{(r[1] || '').gsub(/[\s:]/, '_')}" }.join(' ')
end