module Mail::CommonAddress

def <<(val)
  case
  when val.nil?
    raise ArgumentError, "Need to pass an address to <<"
  when Utilities.blank?(val)
    parse(encoded)
  else
    self.value = [self.value, val].reject {|a| Utilities.blank?(a) }.join(", ")
  end
end

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

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

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

def charset
  @charset
end

def decoded_group_addresses
  groups.map { |k,v| v.map { |a| a.decoded } }.flatten
end

def default
  addresses
end

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

def do_decode
  return nil if Utilities.blank?(value)
  address_array = address_list.addresses.reject { |a| decoded_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| Utilities.blank?(a) }
  return_array.join(", ")
end

def do_encode(field_name)
  return '' if Utilities.blank?(value)
  address_array = address_list.addresses.reject { |a| encoded_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| Utilities.blank?(a) }
  "#{field_name}: #{return_array.join(", \r\n\s")}\r\n"
end

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

def encode_if_needed(val) #:nodoc:
  # Need to join arrays of addresses into a single value
  if val.kind_of?(Array)
    val.compact.map { |a| encode_if_needed a }.join(', ')
  # Pass through UTF-8; encode non-UTF-8.
  else
    utf8_if_needed(val) || Encodings.encode_non_usascii(val, charset)
  end
end

def encoded_group_addresses
  groups.map { |k,v| v.map { |a| a.encoded } }.flatten
end

def formatted
  list = address_list.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|
      Mail::Address.new(address)
    end
  else
    []
  end
end

def group_addresses
  decoded_group_addresses
end

def group_names # :nodoc:
  address_list.group_names
end

def groups
  address_list.addresses_grouped_by_group
end

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

def utf8_if_needed(val)
  if charset =~ /\AUTF-?8\z/i
    val
  elsif val.encoding == Encoding::UTF_8
    val
  elsif (utf8 = val.dup.force_encoding(Encoding::UTF_8)).valid_encoding?
    utf8
  end
end

def utf8_if_needed(val)
  if charset =~ /\AUTF-?8\z/i
    val
  end
end

def value=(val)
  super
  parse(self.value)
end