def match_preferences(self, pcr=None, issuer=None):
        """
        Match the clients preferences against what the provider can do.
        This is to prepare for later client registration and or what
        functionality the client actually will use.
        In the client configuration the client preferences are expressed.
        These are then compared with the Provider Configuration information.
        If the Provider has left some claims out, defaults specified in the
        standard will be used.

        :param pcr: Provider configuration response if available
        :param issuer: The issuer identifier
        """

        if not pcr:
            pcr = self.service_context.provider_info

        regreq = oidc.RegistrationRequest

        for _pref, _prov in PREFERENCE2PROVIDER.items():
            try:
                vals = self.service_context.client_preferences[_pref]
            except KeyError:
                continue

            try:
                _pvals = pcr[_prov]
            except KeyError:
                try:
                    # If the provider have not specified use what the
                    # standard says is mandatory if at all.
                    _pvals = PROVIDER_DEFAULT[_pref]
                except KeyError:
                    logger.info(
                        'No info from provider on {} and no default'.format(
                            _pref))
                    _pvals = vals

            if isinstance(vals, str):
                if vals in _pvals:
                    self.service_context.behaviour[_pref] = vals
            else:
                try:
                    vtyp = regreq.c_param[_pref]
                except KeyError:
                    # Allow non standard claims
                    if isinstance(vals, list):
                        self.service_context.behaviour[_pref] = [
                            v for v in vals if v in _pvals]
                    elif vals in _pvals:
                        self.service_context.behaviour[_pref] = vals
                else:
                    if isinstance(vtyp[0], list):
                        self.service_context.behaviour[_pref] = []
                        for val in vals:
                            if val in _pvals:
                                self.service_context.behaviour[_pref].append(
                                    val)
                    else:
                        for val in vals:
                            if val in _pvals:
                                self.service_context.behaviour[_pref] = val
                                break

            if _pref not in self.service_context.behaviour:
                raise ConfigurationError(
                    "OP couldn't match preference:%s" % _pref, pcr)

        for key, val in self.service_context.client_preferences.items():
            if key in self.service_context.behaviour:
                continue

            try:
                vtyp = regreq.c_param[key]
                if isinstance(vtyp[0], list):
                    pass
                elif isinstance(val, list) and not isinstance(val, str):
                    val = val[0]
            except KeyError:
                pass
            if key not in PREFERENCE2PROVIDER:
                self.service_context.behaviour[key] = val

        logger.debug(
            'service_context behaviour: {}'.format(
                self.service_context.behaviour))
Match the clients preferences against what the provider can do.
        This is to prepare for later client registration and or what
        functionality the client actually will use.
        In the client configuration the client preferences are expressed.
        These are then compared with the Provider Configuration information.
        If the Provider has left some claims out, defaults specified in the
        standard will be used.

        :param pcr: Provider configuration response if available
        :param issuer: The issuer identifier