docs: @GetMapping(path = SamlIdPConstants.ENDPOINT_SAML2_IDP_INIT_PROFILE_SSO)
      protected void handleIdPInitiatedSsoRequest(final HttpServletResponse response,
                                                  final HttpServletRequest request) throws Exception {
  
          val providerId = CommonUtils.safeGetParameter(request, SamlIdPConstants.PROVIDER_ID);
          if (StringUtils.isBlank(providerId)) {
              LOGGER.warn("No providerId parameter given in unsolicited SSO authentication request.");
              throw new MessageDecodingException("No providerId parameter given in unsolicited SSO authentication request.");
          }
  
          val registeredService = verifySamlRegisteredService(providerId);
          val adaptor = getSamlMetadataFacadeFor(registeredService, providerId);
          if (adaptor.isEmpty()) {
              throw new UnauthorizedServiceException(UnauthorizedServiceException.CODE_UNAUTHZ_SERVICE, "Cannot find metadata linked to " + providerId);
          }
  
          /*
           The URL of the response location at the SP (called the "Assertion Consumer Service")
           but can be omitted in favor of the IdP picking the default endpoint location from metadata.
            */
          var shire = CommonUtils.safeGetParameter(request, SamlIdPConstants.SHIRE);
          val facade = adaptor.get();
          if (StringUtils.isBlank(shire)) {
              LOGGER.warn("Resolving service provider assertion consumer service URL for [{}] and binding [{}]",
                  providerId, SAMLConstants.SAML2_POST_BINDING_URI);
              val acs = facade.getAssertionConsumerService(SAMLConstants.SAML2_POST_BINDING_URI);
              if (acs == null || StringUtils.isBlank(acs.getLocation())) {
                  throw new MessageDecodingException("Unable to resolve SP ACS URL location for binding " + SAMLConstants.SAML2_POST_BINDING_URI);
              }
              shire = acs.getLocation();
          }
          if (StringUtils.isBlank(shire)) {
              LOGGER.warn("Unable to resolve service provider assertion consumer service URL for AuthnRequest construction for entityID: [{}]", providerId);
              throw new MessageDecodingException("Unable to resolve SP ACS URL for AuthnRequest construction");
          }
  
          val target = CommonUtils.safeGetParameter(request, SamlIdPConstants.TARGET);
  
          val time = CommonUtils.safeGetParameter(request, SamlIdPConstants.TIME);
  
          val builder = (SAMLObjectBuilder) getSamlProfileHandlerConfigurationContext()
              .getOpenSamlConfigBean().getBuilderFactory().getBuilder(AuthnRequest.DEFAULT_ELEMENT_NAME);
          val authnRequest = (AuthnRequest) builder.buildObject();
          authnRequest.setAssertionConsumerServiceURL(shire);
  
          val isBuilder = (SAMLObjectBuilder) getSamlProfileHandlerConfigurationContext()
              .getOpenSamlConfigBean().getBuilderFactory().getBuilder(Issuer.DEFAULT_ELEMENT_NAME);
          val issuer = (Issuer) isBuilder.buildObject();
          issuer.setValue(providerId);
          authnRequest.setIssuer(issuer);
  
          authnRequest.setProtocolBinding(SAMLConstants.SAML2_POST_BINDING_URI);
          val pBuilder = (SAMLObjectBuilder) getSamlProfileHandlerConfigurationContext()
              .getOpenSamlConfigBean().getBuilderFactory().getBuilder(NameIDPolicy.DEFAULT_ELEMENT_NAME);
          val nameIDPolicy = (NameIDPolicy) pBuilder.buildObject();
          nameIDPolicy.setAllowCreate(Boolean.TRUE);
          authnRequest.setNameIDPolicy(nameIDPolicy);
  
          if (NumberUtils.isCreatable(time)) {
              authnRequest.setIssueInstant(new DateTime(TimeUnit.SECONDS.convert(Long.parseLong(time), TimeUnit.MILLISECONDS),
                  ISOChronology.getInstanceUTC()));
          } else {
              authnRequest.setIssueInstant(new DateTime(DateTime.now(), ISOChronology.getInstanceUTC()));
          }
          authnRequest.setForceAuthn(Boolean.FALSE);
          if (StringUtils.isNotBlank(target)) {
              request.setAttribute(SamlProtocolConstants.PARAMETER_SAML_RELAY_STATE, target);
          }
  
          val ctx = new MessageContext();
          ctx.setAutoCreateSubcontexts(true);
  
          if (facade.isAuthnRequestsSigned()) {
              getSamlProfileHandlerConfigurationContext().getSamlObjectSigner().encode(authnRequest, registeredService,
                  facade, response, request, SAMLConstants.SAML2_POST_BINDING_URI, authnRequest);
          }
          ctx.setMessage(authnRequest);
          ctx.getSubcontext(SAMLBindingContext.class, true).setHasBindingSignature(false);
          SAMLBindingSupport.setRelayState(ctx, target);
  
          val pair = Pair.<SignableSAMLObject, MessageContext>of(authnRequest, ctx);
          initiateAuthenticationRequest(pair, response, request);
      }