class Mail::UnstructuredField

def do_decode
  Utilities.blank?(value) ? nil : Encodings.decode_encode(value, :decode)
end

def do_encode
  if value && !value.empty?
    "#{wrapped_value}\r\n"
  else
    ''
  end
end

def encode(value)
  value = [value].pack(Constants::CAPITAL_M).gsub(Constants::EQUAL_LF, Constants::EMPTY)
  value.gsub!(/"/,  '=22')
  value.gsub!(/\(/, '=28')
  value.gsub!(/\)/, '=29')
  value.gsub!(/\?/, '=3F')
  value.gsub!(/_/,  '=5F')
  value.gsub!(/ /,  '_')
  value
end

def encode_crlf(value)
  value.gsub!(Constants::CR, Constants::CR_ENCODED)
  value.gsub!(Constants::LF, Constants::LF_ENCODED)
  value
end

def fold(prepend = 0) # :nodoc:
  encoding       = normalized_encoding
  decoded_string = decoded.to_s
  should_encode  = !decoded_string.ascii_only?
  if should_encode
    first = true
    words = decoded_string.split(/[ \t]/).map do |word|
      if first
        first = !first
      else
        word = " #{word}"
      end
      if !word.ascii_only?
        word
      else
        word.scan(/.{7}|.+$/)
      end
    end.flatten
  else
    words = decoded_string.split(/[ \t]/)
  end
  folded_lines   = []
  while !words.empty?
    limit = 78 - prepend
    limit = limit - 7 - encoding.length if should_encode
    line = String.new
    first_word = true
    while !words.empty?
      break unless word = words.first.dup
      # Convert on 1.9+ only since we aren't sure of the current
      # charset encoding on 1.8. We'd need to track internal/external
      # charset on each field.
      if charset && word.respond_to?(:encoding)
        word = Encodings.transcode_charset(word, word.encoding, charset)
      end
      word = encode(word) if should_encode
      word = encode_crlf(word)
      # Skip to next line if we're going to go past the limit
      # Unless this is the first word, in which case we're going to add it anyway
      # Note: This means that a word that's longer than 998 characters is going to break the spec. Please fix if this is a problem for you.
      # (The fix, it seems, would be to use encoded-word encoding on it, because that way you can break it across multiple lines and
      # the linebreak will be ignored)
      break if !line.empty? && (line.length + word.length + 1 > limit)
      # Remove the word from the queue ...
      words.shift
      # Add word separator
      if first_word
        first_word = false
      else
        line << " " if !should_encode
      end
      # ... add it in encoded form to the current line
      line << word
    end
    # Encode the line if necessary
    line = "=?#{encoding}?Q?#{line}?=" if should_encode
    # Add the line to the output and reset the prepend
    folded_lines << line
    prepend = 0
  end
  folded_lines
end

def initialize(name, value, charset = nil)
  if value.is_a?(Array)
    # Probably has arrived here from a failed parse of an AddressList Field
    value = value.join(', ')
  # Mark UTF-8 strings parsed from ASCII-8BIT
  elsif value.respond_to?(:force_encoding) && value.encoding == Encoding::ASCII_8BIT
    utf8 = value.dup.force_encoding(Encoding::UTF_8)
    value = utf8 if utf8.valid_encoding?
  end
  charset ||=
    if value.respond_to?(:encoding)
      value.encoding
    end
  super name, value.to_s, charset
end

def normalized_encoding
  charset.to_s.upcase.gsub('_', '-')
end

def parse
  self
end

def wrap_lines(name, folded_lines)
  result = ["#{name}: #{folded_lines.shift}"]
  result.concat(folded_lines)
  result.join("\r\n\s")
end

def wrapped_value # :nodoc:
  wrap_lines(name, fold("#{name}: ".length))
end