text: """Module that is responsible for parsing parameterized header values
  encoded in accordance to rfc2231 (new style) or rfc1342 (old style)
  """
  import urllib
  import re
  from flanker.mime.message.headers import encodedword
  from flanker.mime.message import charsets
  from collections import deque
  from itertools import groupby
  
  
  def decode(header):
      """Accepts parameterized header value (encoded in accordance to
       rfc2231 (new style) or rfc1342 (old style)
       and returns tuple:
           value, {'key': u'val'}
       returns None in case of any failure
      """
      value, rest = split(encodedword.unfold(header))
      if value is None:
          return None, {}
      elif value:
          return value, decode_parameters(rest)
  
  
  def is_parametrized(name, value):
      return name in ("Content-Type", "Content-Disposition",
                      "Content-Transfer-Encoding")
  
  
  def fix_content_type(value, default=None):
      """Content-Type value may be badly broken"""
      if not value:
          return default or ('text', 'plain')
      values = value.lower().split("/")
      if len(values) >= 2:
          return values[:2]
      elif len(values) == 1:
          if values[0] == 'text':
              return 'text', 'plain'
          elif values[0] == 'html':
              return 'text', 'html'
          return 'application', 'octet-stream'
  
  
  def split(header):
      """Splits value part and parameters part,
      e.g.
           split("MULTIPART/MIXED;boundary=hal_9000")
      becomes:
           ["multipart/mixed", "boundary=hal_9000"]
      """
      match = headerValue.match(header)
      if not match:
          return (None, None)
      return match.group(1).lower(), header[match.end():]
  
  
  def decode_parameters(string):
      """Parameters can be splitted into several parts, e.g.
  
      title*0*=us-ascii'en'This%20is%20even%20more%20
      title*1*=%2A%2A%2Afun%2A%2A%2A%20
      title*2="isn't it!"
  
      decode them to the dictionary with keys and values"""
      parameters = collect_parameters(string)
      groups = {}
      for k, parts in groupby(parameters, get_key):
          groups[k] = concatenate(list(parts))
      return groups
  
  
  def collect_parameters(rest):
      """Scans the string and collects parts
      that look like parameter, returns deque of strings
      """
      parameters = deque()
      p, rest = match_parameter(rest)
      while p:
          parameters.append(p)
          p, rest = match_parameter(rest)
      return parameters
  
  
  def concatenate(parts):
      """ Concatenates splitted parts of a parameter in a single parameter,
      e.g.
           URL*0="ftp://";
           URL*1="cs.utk.edu/pub/moore/bulk-mailer/bulk-mailer.tar"
  
      becomes:
  
           URL="ftp://cs.utk.edu/pub/moore/bulk-mailer/bulk-mailer.tar"
      """
      part = parts[0]
  
      if is_old_style(part):
          # old-style parameters do not support any continuations
          return encodedword.mime_to_unicode(get_value(part))
      else:
          return u"".join(
              decode_new_style(p) for p in partition(parts))
  
  
  def match_parameter(rest):
      for match in (match_old, match_new):
          p, rest = match(rest)
          if p:
              return p, rest
      return (None, rest)
  
  
  def match_old(rest):
      match = oldStyleParameter.match(rest)
      if match:
          name = match.group('name')
          value = match.group('value')
          return parameter('old', name, value), rest[match.end():]
      else:
          return None, rest
  
  
  def match_new(rest):
      match = newStyleParameter.match(rest)
      if match:
          name = parse_parameter_name(match.group('name'))
          value = match.group('value')
          return parameter('new', name, value), rest[match.end():]
      else:
          return (None, rest)
  
  
  def reverse(string):
      """Native reverse of a string looks a little bit cryptic,
      just a readable wrapper"""
      return string[::-1]
  
  
  def parse_parameter_name(key):
      """New style parameter names can be splitted into parts,
      e.g.
  
      title*0* means that it's the first part that is encoded
      title*1* means that it's the second part that is encoded
      title*2 means that it is the third part that is unencoded
      title means single unencoded
      title* means single encoded part
  
      I found it easier to match against a reversed string,
      as regexp is simpler
      """
      m = reverseContinuation.match(reverse(key))
      key = reverse(m.group('key'))
      part = reverse(m.group('part')) if m.group('part') else None
      encoded = m.group('encoded')
      return (key, part, encoded)
  
  
  def decode_new_style(parameter):
      """Decodes parameter values, quoted or percent encoded, to unicode"""
      if is_quoted(parameter):
          return unquote(parameter)
      if is_encoded(parameter):
          return decode_charset(parameter)
      return get_value(parameter)
  
  
  def partition(parts):
      """Partitions the parts in accordance to the algo here:
      http://tools.ietf.org/html/rfc2231#section-4.1
      """
      encoded = deque()
      for part in parts:
          if is_encoded(part):
              encoded.append(part)
              continue
          if encoded:
              yield join_parameters(encoded)
              encoded = deque()
          yield part
      if encoded:
          yield join_parameters(encoded)
  
  
  def decode_charset(parameter):
      """Decodes things like:
      "us-ascii'en'This%20is%20even%20more%20%2A%2A%2Afun%2A%2A%2A%20"
      to unicode """
  
      v = get_value(parameter)
      parts = v.split("'", 2)
      if len(parts) != 3:
          return v
      charset, language, val = parts
      val = urllib.unquote(val)
      return charsets.convert_to_unicode(charset, val)
  
  
  def unquote(parameter):
      """Simply removes quotes"""
      return get_value(parameter).strip('"')
  
  
  def parameter(ptype, key, value):
      """Parameter is stored as a tuple,
      and below are conventional
      """
      return (ptype, key, value)
  
  
  def is_quoted(part):
      return get_value(part)[0] == '"'
  
  
  def is_new_style(parameter):
      return parameter[0] == 'new'
  
  
  def is_old_style(parameter):
      return parameter[0] == 'old'
  
  
  def is_encoded(part):
      return part[1][2] == '*'
  
  
  def get_key(parameter):
      if is_old_style(parameter):
          return parameter[1].lower()
      else:
          return parameter[1][0].lower()
  
  
  def get_value(parameter):
      return parameter[2]
  
  
  def join_parameters(parts):
      joined = "".join(get_value(p) for p in parts)
      for p in parts:
          return parameter(p[0], p[1], joined)
  
  # used to split header value and parameters
  headerValue = re.compile(r"""
         # don't care about the spaces
         ^[\ \t]*
         #main type and sub type or any other value
         ([a-z0-9\-/\.\*]+)
         # grab the trailing spaces, colons
         [\ \t;]*""", re.IGNORECASE | re.VERBOSE)
  
  
  oldStyleParameter = re.compile(r"""
       # according to rfc1342, param value can be encoded-word
       # and it's actually very popular, so detect this parameter first
       ^
       # skip spaces
       [\ \t]*
       # parameter name
       (?P<name>
           [^\x00-\x1f\s\(\)<>@,;:\\"/\[\]\?=]+
       )
       # skip spaces
       [\ \t]*
       =
       # skip spaces
       [\ \t]*
       #optional quoting sign
       "?
       # skip spaces
       [\ \t]*
       # and a glorious encoded-word sequence
       (?P<value>
         =\?
         .* # non-greedy to match the end sequence chars
         \?=
       )
       # ends with optional quoting sign that we ignore
       "?
  """, re.IGNORECASE | re.VERBOSE)
  
  
  newStyleParameter = re.compile(r"""
       # Here we grab anything that looks like a parameter
       ^
       # skip spaces
       [\ \t]*
       # parameter name
       (?P<name>
           [^\x00-\x1f\s\(\)<>@,;:\\"/\[\]\?=]+
       )
       # skip spaces
       [\ \t]*
       =
       # skip spaces
       [\ \t]*
       (?P<value>
         (?:
           "(?:
               [\x21\x23-\x5b\x5d-\x7e\ \t]
               |
               (?:\\[\x21-\x7e\t\ ])
            )+"
         )
       |
       # any (US-ASCII) CHAR except SPACE, CTLs, or tspecials
       [^\x00-\x1f\s\(\)<>@,;:\\"/\[\]\?=]+
       )
       # skip spaces
       [\ \t]*
       ;?
  """, re.IGNORECASE | re.VERBOSE)
  
  reverseContinuation = re.compile(
      "^(?P<encoded>\*)?(?P<part>\d+\*)?(?P<key>.*)")
  