"""

Parses a variety of ``Accept-*`` headers.

These headers generally take the form of::

    value1; q=0.5, value2; q=0

Where the ``q`` parameter is optional.  In theory other parameters

exists, but this ignores them.

"""

import re

part_re = re.compile(

    r',\s*([^\s;,\n]+)(?:[^,]*?;\s*q=([0-9.]*))?')

def parse_accept(value):

    """

    Parses an ``Accept-*`` style header.

    A list of ``[(value, quality), ...]`` is returned.  ``quality``

    will be 1 if it was not given.

    """

    result = []

    for match in part_re.finditer(','+value):

        name = match.group(1)

        if name == 'q':

            continue

        quality = match.group(2) or ''

        if not quality:

            quality = 1

        else:

            try:

                quality = max(min(float(quality), 1), 0)

            except ValueError:

                quality = 1

        result.append((name, quality))

    return result

class Accept(object):

    """

    Represents a generic ``Accept-*`` style header.

    This object should not be modified.  To add items you can use

    ``accept_obj + 'accept_thing'`` to get a new object

    """

    def __init__(self, header_name, header_value):

        self.header_name = header_name

        self.header_value = header_value

        self._parsed = parse_accept(header_value)

    def __repr__(self):

        return '<%s at %x %s: %s>' % (

            self.__class__.__name__,

            abs(id(self)),

            self.header_name, str(self))

    def __str__(self):

        result = []

        for match, quality in self._parsed:

            if quality != 1:

                match = '%s;q=%0.1f' % (match, quality)

            result.append(match)

        return ', '.join(result)

    # FIXME: should subtraction be allowed?

    def __add__(self, other, reversed=False):

        if isinstance(other, Accept):

            other = other.header_value

        if hasattr(other, 'items'):

            other = sorted(other.items(), key=lambda item: -item[1])

        if isinstance(other, (list, tuple)):

            result = []

            for item in other:

                if isinstance(item, (list, tuple)):

                    name, quality = item

                    result.append('%s; q=%s' % (name, quality))

                else:

                    result.append(item)

            other = ', '.join(result)

        other = str(other)

        my_value = self.header_value

        if reversed:

            other, my_value = my_value, other

        if not other:

            new_value = my_value

        elif not my_value:

            new_value = other

        else:

            new_value = my_value + ', ' + other

        return self.__class__(self.header_name, new_value)

    def __radd__(self, other):

        return self.__add__(other, True)

    def __contains__(self, match):

        """

        Returns true if the given object is listed in the accepted

        types.

        """

        for item, quality in self._parsed:

            if self._match(item, match):

                return True

    def quality(self, match):

        """

        Return the quality of the given match.  Returns None if there

        is no match (not 0).

        """

        for item, quality in self._parsed:

            if self._match(item, match):

                return quality

        return None

    def first_match(self, matches):

        """

        Returns the first match in the sequences of matches that is

        allowed.  Ignores quality.  Returns the first item if nothing

        else matches; or if you include None at the end of the match

        list then that will be returned.

        """

        if not matches:

            raise ValueError(

                "You must pass in a non-empty list")

        for match in matches:

            for item, quality in self._parsed:

                if self._match(item, match):

                    return match

            if match is None:

                return None

        return matches[0]

    def best_match(self, matches, default_match=None):

        """

        Returns the best match in the sequence of matches.

        The sequence can be a simple sequence, or you can have

        ``(match, server_quality)`` items in the sequence.  If you

        have these tuples then the client quality is multiplied by the

        server_quality to get a total.

        default_match (default None) is returned if there is no intersection.

        """

        best_quality = -1

        best_match = default_match

        for match_item in matches:

            if isinstance(match_item, (tuple, list)):

                match, server_quality = match_item

            else:

                match = match_item

                server_quality = 1

            for item, quality in self._parsed:

                possible_quality = server_quality * quality

                if possible_quality < best_quality:

                    continue

                if self._match(item, match):

                    best_quality = possible_quality

                    best_match = match

        return best_match

    def best_matches(self, fallback=None):

        """

        Return all the matches in order of quality, with fallback (if

        given) at the end.

        """

        items = [

            i for i, q in sorted(self._parsed, key=lambda iq: -iq[1])]

        if fallback:

            for index, item in enumerate(items):

                if self._match(item, fallback):

                    items[index+1:] = []

                    break

            else:

                items.append(fallback)

        return items

    def _match(self, item, match):

        return item.lower() == match.lower() or item == '*'

class NilAccept(object):

    """

    Represents an Accept header with no value.

    """

    MasterClass = Accept

    def __init__(self, header_name):

        self.header_name = header_name

    def __repr__(self):

        return '<%s for %s: %s>' % (

            self.__class__.__name__, self.header_name, self.MasterClass)

    def __str__(self):

        return ''

    def __add__(self, item):

        if isinstance(item, self.MasterClass):

            return item

        else:

            return self.MasterClass(self.header_name, '') + item

    def __radd__(self, item):

        if isinstance(item, self.MasterClass):

            return item

        else:

            return item + self.MasterClass(self.header_name, '')

    def __contains__(self, item):

        return True

    def quality(self, match, default_quality=1):

        return 0

    def first_match(self, matches):

        return matches[0]

    def best_match(self, matches, default_match=None):

        best_quality = -1

        best_match = default_match

        for match_item in matches:

            if isinstance(match_item, (list, tuple)):

                match, quality = match_item

            else:

                match = match_item

                quality = 1

            if quality > best_quality:

                best_match = match

                best_quality = quality

        return best_match

    def best_matches(self, fallback=None):

        if fallback:

            return [fallback]

        else:

            return []

class NoAccept(NilAccept):

    def __contains__(self, item):

        return False

class MIMEAccept(Accept):

    """

    Represents the ``Accept`` header, which is a list of mimetypes.

    This class knows about mime wildcards, like ``image/*``

    """

    def _match(self, item, match):

        item = item.lower()

        if item == '*':

            item = '*/*'

        match = match.lower()

        if match == '*':

            match = '*/*'

        if '/' not in item:

            # Bad, but we ignore

            return False

        if '/' not in match:

            raise ValueError(

                "MIME matches must include / (bad: %r)" % match)

        item_major, item_minor = item.split('/', 1)

        match_major, match_minor = match.split('/', 1)

        if match_major == '*' and match_minor != '*':

            raise ValueError(

                "A MIME type of %r doesn't make sense" % match)

        if item_major == '*' and item_minor != '*':

            # Bad, but we ignore

            return False

        if ((item_major == '*' and item_minor == '*')

            or (match_major == '*' and match_minor == '*')):

            return True

        if (item_major == match_major

            and ((item_minor == '*' or match_minor == '*')

                 or item_minor == match_minor)):

            return True

        return False

    def accept_html(self):

        """

        Returns true if any HTML-like type is accepted

        """

        return ('text/html' in self

                or 'application/xhtml+xml' in self

                or 'application/xml' in self

                or 'text/xml' in self)

class MIMENilAccept(NilAccept):

    MasterClass = MIMEAccept