class Mail::CommonAddressField

def self.singular?
  true
end

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

def address
  addresses.first
end

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

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

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

def default
  addresses
end

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

def do_decode
  return nil if Utilities.blank?(value)
  address_array = element.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
  return '' if Utilities.blank?(value)
  address_array = element.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) }
  "#{name}: #{return_array.join(", \r\n\s")}\r\n"
end

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

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

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

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

def formatted
  list = element.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:
  element.group_names
end

def groups
  element.addresses_grouped_by_group
end

def initialize(value = nil, charset = nil)
  super encode_if_needed(value, charset), charset
end

def utf8_if_needed(val, val_charset)
  if val_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, val_charset)
  if val_charset =~ /\AUTF-?8\z/i
    val
  end
end