"""Module that is responsible for parsing parameterized header values
encoded in accordance to rfc2231 (new style) or rfc1342 (old style)
"""
from collections import deque
from itertools import groupby

import regex as re
import six
from six.moves import urllib_parse

from flanker.mime.message import charsets
from flanker.mime.message.headers import encodedword

_PARAM_STYLE_OLD = 'old'
_PARAM_STYLE_NEW = 'new'


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
    """
    if six.PY3 and isinstance(header, six.binary_type):
        header = header.decode('utf-8')

    value, rest = split(encodedword.unfold(header))
    if value is None:
        return None, {}

    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 = _RE_HEADER_VALUE.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))

    return ''.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 = _RE_OLD_STYLE_PARAM.match(rest)
    if match:
        name = match.group('name')
        value = match.group('value')
        return parameter(_PARAM_STYLE_OLD, name, value), rest[match.end():]

    return None, rest


def match_new(rest):
    match = _RE_NEW_STYLE_PARAM.match(rest)
    if match:
        name = parse_parameter_name(match.group('name'))
        value = match.group('value')
        return parameter(_PARAM_STYLE_NEW, name, value), rest[match.end():]

    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 = _RE_REVERSE_CONTINUATION.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_parse.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] == _PARAM_STYLE_NEW


def is_old_style(parameter):
    return parameter[0] == _PARAM_STYLE_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
_RE_HEADER_VALUE = re.compile(r'''
       # don't care about the spaces
       ^[\ \t]*
       #main type and sub type or any other value
       ([^\ \t;]+)
       # grab the trailing spaces, colons
       [\ \t;]*''', re.IGNORECASE | re.VERBOSE)


_RE_OLD_STYLE_PARAM = 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)

_RE_NEW_STYLE_PARAM = 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>
       (?:
         "(?:
             # so this works for unicode too
             [^\x00-\x10\x12-\x19\x22\x5c\x7f]
             |
             (?:\\[\x21-\x7e\t\ ])
          )+"
       )
     |
     # any (US-ASCII) CHAR except SPACE, CTLs, or tspecials
     [^\x00-\x1f\s\(\)<>@,;:\\"/\[\]\?=]+
     )
     # skip spaces
     [\ \t]*
     ;?
''', re.IGNORECASE | re.VERBOSE)

_RE_REVERSE_CONTINUATION = re.compile(
    r'^(?P<encoded>\*)?(?P<part>\d+\*)?(?P<key>.*)')