module Mail::CommonAddress

def <<(val)
  case
  when val.nil?
    raise ArgumentError, "Need to pass an address to <<"
  when val.blank?
    parse(encoded)
  else
    parse((formatted + [val]).join(", "))
  end
end

def addresses
  list = tree.addresses.map { |a| a.address }
  Mail::AddressContainer.new(self, list)
end

def addrs
  list = tree.addresses
  Mail::AddressContainer.new(self, list)
end

def charset
  @charset
end

def default
  addresses
end

def display_names
  list = tree.addresses.map { |a| a.display_name }
  Mail::AddressContainer.new(self, list)
end

def do_decode
  return nil if value.blank?
  address_array = tree.addresses.reject { |a| group_addresses.include?(a.decoded) }.map { |a| a.decoded }
  address_text  = address_array.join(", ")
  group_array = groups.map { |k,v| "#{k}: #{v.map { |a| a.decoded }.join(", ")};" }
  group_text  = group_array.join(" ")
  return_array = [address_text, group_text].reject { |a| a.blank? }
  return_array.join(", ")
end

def do_encode(field_name)
  return '' if value.blank?
  address_array = tree.addresses.reject { |a| group_addresses.include?(a.encoded) }.compact.map { |a| a.encoded }
  address_text  = address_array.join(", \r\n\s")
  group_array = groups.map { |k,v| "#{k}: #{v.map { |a| a.encoded }.join(", \r\n\s")};" }
  group_text  = group_array.join(" \r\n\s")
  return_array = [address_text, group_text].reject { |a| a.blank? }
  "#{field_name}: #{return_array.join(", \r\n\s")}\r\n"
end

def each
  tree.addresses.each do |address|
    yield(address)
  end
end

def encode_if_needed(val)
  Encodings.address_encode(val, charset)
end

def formatted
  list = tree.addresses.map { |a| a.format }
  Mail::AddressContainer.new(self, list)
end

def get_group_addresses(group_list)
  if group_list.respond_to?(:addresses)
    group_list.addresses.map do |address_tree|
      Mail::Address.new(address_tree)
    end
  else
    []
  end
end

def group_addresses
  groups.map { |k,v| v.map { |a| a.format } }.flatten
end

def group_names # :nodoc:
  tree.group_names
end

def groups
  @groups = Hash.new
  tree.group_recipients.each do |group|
    @groups[group.group_name.text_value.to_str] = get_group_addresses(group.group_list)
  end
  @groups
end

def parse(val = value)
  unless val.blank?
    @tree = AddressList.new(encode_if_needed(val))
  else
    nil
  end
end

def tree # :nodoc:
  @tree ||= AddressList.new(value)
end