# -*-python-*-
#
# Copyright (C) 1999-2026 The ViewCVS Group. All Rights Reserved.
#
# By using this file, you agree to the terms and conditions set forth in
# the LICENSE.html file which can be found at the top level of the ViewVC
# distribution or at http://viewvc.org/license-1.html.
#
# For more information, visit http://viewvc.org/
#
# -----------------------------------------------------------------------
#
# accept.py: parse/handle the various Accept headers from the client
#
# -----------------------------------------------------------------------

import re


def language(hdr):
    "Parse an Accept-Language header."

    # parse the header, storing results in a _LanguageSelector object
    return _parse(hdr, _LanguageSelector())


_re_token = re.compile(r'\s*([^\s;,"]+|"[^"]*")+\s*')
_re_param = re.compile(r';\s*([^;,"]+|"[^"]*")+\s*')
_re_split_param = re.compile(r"([^\s=])\s*=\s*(.*)")


def _parse(hdr, result):
    # quick exit for empty or not-supplied header
    if not hdr:
        return result

    pos = 0
    while pos < len(hdr):
        name = _re_token.match(hdr, pos)
        if not name:
            raise AcceptLanguageParseError()
        a = result.item_class(name.group(1).lower())
        pos = name.end()
        while 1:
            # are we looking at a parameter?
            match = _re_param.match(hdr, pos)
            if not match:
                break
            param = match.group(1)
            pos = match.end()

            # split up the pieces of the parameter
            match = _re_split_param.match(param)
            if not match:
                # the "=" was probably missing
                continue

            pname = match.group(1).lower()
            if pname == "q" or pname == "qs":
                try:
                    a.quality = float(match.group(2))
                except ValueError:
                    # bad float literal
                    pass
            elif pname == "level":
                try:
                    a.level = float(match.group(2))
                except ValueError:
                    # bad float literal
                    pass
            elif pname == "charset":
                a.charset = match.group(2).lower()

        result.append(a)
        if hdr[pos : (pos + 1)] == ",":
            pos = pos + 1

    return result


class _AcceptItem:
    def __init__(self, name):
        self.name = name
        self.quality = 1.0
        self.level = 0.0
        self.charset = ""

    def __str__(self):
        s = self.name
        if self.quality != 1.0:
            s = f"{s};q={self.quality:.3f}"
        if self.level != 0.0:
            s = f"{s};level={self.level:.3f}"
        if self.charset:
            s = f"{s};charset={self.charset}"
        return s


class _LanguageRange(_AcceptItem):
    def matches(self, tag):
        "Match the tag against self. Returns the qvalue, or None if non-matching."
        if tag == self.name:
            return self.quality

        # are we a prefix of the available language-tag
        name = self.name + "-"
        if tag[: len(name)] == name:
            return self.quality
        return None


class _LanguageSelector:
    """Instances select an available language based on the user's request.

    Languages found in the user's request are added to this object with the
    append() method (they should be instances of _LanguageRange). After the
    languages have been added, then the caller can use select_from() to
    determine which user-request language(s) best matches the set of
    available languages.

    Strictly speaking, this class is pretty close for more than just
    language matching. It has been implemented to enable q-value based
    matching between requests and availability. Some minor tweaks may be
    necessary, but simply using a new 'item_class' should be sufficient
    to allow the _parse() function to construct a selector which holds
    the appropriate item implementations (e.g. _LanguageRange is the
    concrete _AcceptItem class that handles matching of language tags).
    """

    item_class = _LanguageRange

    def __init__(self):
        self.requested = []

    def select_from(self, avail):
        """Select one of the available choices based on the request.

        Note: if there isn't a match, then the first available choice is
        considered the default. Also, if a number of matches are equally
        relevant, then the first-requested will be used.

        avail is a list of language-tag strings of available languages
        """

        # tuples of (qvalue, language-tag)
        matches = []

        # try matching all pairs of desired vs available, recording the
        # resulting qvalues. we also need to record the longest language-range
        # that matches since the most specific range "wins"
        for tag in avail:
            longest = 0
            final = 0.0

            # check this tag against the requests from the user
            for want in self.requested:
                qvalue = want.matches(tag)
                if qvalue is not None and len(want.name) > longest:
                    # we have a match and it is longer than any we may have had.
                    # the final qvalue should be from this tag.
                    final = qvalue
                    longest = len(want.name)

            # a non-zero qvalue is a potential match
            if final:
                matches.append((final, tag))

        # if there are no matches, then return the default language tag
        if not matches:
            return avail[0]

        # get the highest qvalue and its corresponding tag
        matches.sort()
        qvalue, tag = matches[-1]

        # if the qvalue is zero, then we have no valid matches. return the
        # default language tag.
        if not qvalue:
            return avail[0]

        # if there are two or more matches, and the second-highest has a
        # qvalue equal to the best, then we have multiple "best" options.
        # select the one that occurs first in self.requested
        if len(matches) >= 2 and matches[-2][0] == qvalue:
            # remove non-best matches
            while matches[0][0] != qvalue:
                del matches[0]

            # sequence through self.requested, in order
            for want in self.requested:
                # try to find this one in our best matches
                for qvalue, tag in matches:
                    if want.matches(tag):
                        # this requested item is one of the "best" options
                        #
                        # NOTE: this request item could match *other* "best" options,
                        # so returning *this* one is rather non-deterministic.
                        # theoretically, we could go further here, and do another
                        # search based on the ordering in 'avail'. however, note
                        # that this generally means that we are picking from multiple
                        # *SUB* languages, so I'm all right with the non-determinism
                        # at this point. stupid client should send a qvalue if they
                        # want to refine.
                        return tag

            # NOTREACHED

        # return the best match
        return tag

    def append(self, item):
        self.requested.append(item)


class AcceptLanguageParseError(Exception):
    pass


def _test():
    s = language("en")
    assert s.select_from(["en"]) == "en"
    assert s.select_from(["en", "de"]) == "en"
    assert s.select_from(["de", "en"]) == "en"

    # Netscape 4.x and early version of Mozilla may not send a q value
    s = language("en, ja")
    assert s.select_from(["en", "ja"]) == "en"

    s = language("fr, de;q=0.9, en-gb;q=0.7, en;q=0.6, en-gb-foo;q=0.8")
    assert s.select_from(["en"]) == "en"
    assert s.select_from(["en-gb-foo"]) == "en-gb-foo"
    assert s.select_from(["de", "fr"]) == "fr"
    assert s.select_from(["de", "en-gb"]) == "de"
    assert s.select_from(["en-gb", "en-gb-foo"]) == "en-gb-foo"
    assert s.select_from(["en-bar"]) == "en-bar"
    assert s.select_from(["en-gb-bar", "en-gb-foo"]) == "en-gb-foo"
