/*-
 * #%L
 * Smile CDR - CDR
 * %%
 * Copyright (C) 2016 - 2025 Smile CDR, Inc.
 * %%
 * All rights reserved.
 * #L%
 */
package ca.cdr.api.model.json.oauth;

import ca.uhn.fhir.model.api.IModelJson;
import ca.uhn.fhir.rest.server.exceptions.InternalErrorException;
import com.fasterxml.jackson.annotation.JsonAnySetter;
import com.fasterxml.jackson.annotation.JsonIgnoreProperties;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.swagger.v3.oas.annotations.media.Schema;

import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * OpenId is built off of oauth2
 * <a href="https://openid.net/specs/openid-connect-discovery-1_0.html">
 *   Open id spec.</a>
 *   <a href="https://datatracker.ietf.org/doc/html/rfc8414#section-3.2">OAuth 2 spec</a>
 * NB: Some properties are not listed as "required" because they are required
 *              for most cases, but not all auth servers will require them.
 *              This model is meant to be usable for *all* .well-known endpoints
 *              (not just SMILE ones), so we will leave them as unrequired (default: optional)
 * NB2: There may be other properties provided (this is a non-exhaustive list).
 */
@JsonIgnoreProperties(ignoreUnknown = true)
@Schema(
                name = "OpenIdWellKnownOpenIdConfigurationResponse",
                description = "This object represents the response from an Identity Provider's .well-known endpoint.")
public class OpenIdWellKnownOpenIdConfigurationResponse implements IModelJson {

        /* CHECKSTYLE.OFF: RegexpSingleLine - these json property names are spec compliant and should not be changed */

        /**
         * Authorization server's issuer identifier url
         */
        @JsonProperty(value = "issuer", required = true)
        private String myIssuer;

        /**
         * URL of the authorization server's authorization endpoint
         * REQUIRED unless no grant types are supported that use authorization endpoint
         */
        @JsonProperty("authorization_endpoint")
        private String myAuthorizationEndpoint;

        /**
         * URL of the auth server's token endpoint
         * REQUIRED unless only the implicit grant type is supported
         */
        @JsonProperty("token_endpoint")
        private String myTokenEndpoint;

        /**
         * JSON array of subject identifier types that this OP supports
         * (pairwise, public)
         */
        @JsonProperty(value = "subject_types_supported", required = true)
        private List<String> mySubjectTypesSupported;

        /**
         * URL of the auth server's JWK Set document
         */
        @JsonProperty(value = "jwks_uri", required = false)
        private String myJwkUri;

        /**
         * URL of the auth server's OAuth 2.0 Dynamic Client Registration Endpoint
         */
        @JsonProperty(value = "registration_endpoint", required = false)
        private String myDynamicClientRegistrationEndpoint;

        /**
         * JSON array containing a list of the OAuth 2.0 "scopes" values that this auth
         * server supports.
         * RECOMMENDED
         */
        @JsonProperty("scopes_supported")
        private List<String> mySupportedScopes;

        /**
         * JSON array containing a list of the oauth 2.0 "response_type" values
         * that this auth server supports.
         */
        @JsonProperty(value = "response_types_supported", required = true)
        private List<String> mySupportedResponseTypes;

        /**
         * JSON array containing a list of the oauth 2.0 "response_mode" values that this
         * auth server supports
         */
        @JsonProperty(value = "response_modes_supported", required = false)
        private List<String> mySupportedResponseModes;

        /**
         * JSON array containing a list of the oauth
         * 2.0 grant type values that this auth server supports
         */
        @JsonProperty(value = "grant_types_supported", required = false)
        private List<String> mySupportedGrantTypes;

        /**
         * JSON array containing a list of the client authentication methods supported by this token
         * endpoint
         */
        @JsonProperty(value = "token_endpoint_auth_methods_supported", required = false)
        private List<String> mySupportedAuthenticationMethods;

        /**
         * JSON array of list of the JWS Signing algorithms supported by
         * the token endpoint for the signature on the JWT used
         * to authenticate the client at the token endpoint
         */
        @JsonProperty(value = "token_endpoint_auth_signing_alg_values_supported", required = false)
        private List<String> mySupportedJWSSigningAlgorithms;

        /**
         * URL of the auth server's oauth 2.0
         * revocation endpoint
         */
        @JsonProperty(value = "revocation_endpoint", required = false)
        private String myRevocationEndpoint;

        /**
         * JSON array of client auth methods supported by this
         * revocation endpoint.
         */
        @JsonProperty(value = "revocation_endpoint_auth_methods_supported", required = false)
        private List<String> mySupportedAuthMethodsForRevocation;

        /**
         * JSON array of the JWS signing algorithms supported by the
         * revocation endpoint for the signature on the JWT used to authenticate the client.
         */
        @JsonProperty(value = "revocation_endpoint_auth_signing_alg_values_supported", required = false)
        private List<String> myRevocationEndpointSigningAlgorithms;

        /**
         * URL of the auth server's oauth2.0 introspection endpoint
         */
        @JsonProperty(value = "introspection_endpoint", required = false)
        private String myIntrospectionEndpoint;

        /**
         * JSON array of the client auth methods supported by this introspection
         * endpoint.
         */
        @JsonProperty(value = "introspection_endpoint_auth_methods_supported", required = false)
        private List<String> mySupportedIntrospectionEndpointAuthMethods;

        /**
         * User info url.
         * RECOMMENDED
         */
        @JsonProperty("userinfo_endpoint")
        private String myUserInfoEndpoint;

        /**
         * JSON array of signing algs supported for id token
         */
        @JsonProperty(value = "id_token_signing_alg_values_supported", required = true)
        private List<String> mySupportedIdTokenSigningAlgs;

        /**
         * JSON array containing a list of proof key for code exchange (PCKE flow) code
         * challenge methods supported by this auth server
         */
        @JsonProperty(value = "code_challenge_methods_supported", required = false)
        private List<String> myCodeChallengeMethodsSupported;

        /* CHECKSTYLE.ON: RegexpSingleLine */

        /**
         * We will store all unknown properties in a map during deserialization;
         * if these properties are not in fact "unknown" but part of the spec,
         * please add them above, but leave this map.
         */
        private final Map<String, Object> myUnknownProperties = new HashMap<>();

        public String getIssuer() {
                return myIssuer;
        }

        public void setIssuer(String theIssuer) {
                myIssuer = theIssuer;
        }

        public String getAuthorizationEndpoint() {
                return myAuthorizationEndpoint;
        }

        public void setAuthorizationEndpoint(String theAuthorizationEndpoint) {
                myAuthorizationEndpoint = theAuthorizationEndpoint;
        }

        public String getTokenEndpoint() {
                return myTokenEndpoint;
        }

        public void setTokenEndpoint(String theTokenEndpoint) {
                myTokenEndpoint = theTokenEndpoint;
        }

        public String getJwkUri() {
                return myJwkUri;
        }

        public void setJwkUri(String theJwkUri) {
                myJwkUri = theJwkUri;
        }

        public String getDynamicClientRegistrationEndpoint() {
                return myDynamicClientRegistrationEndpoint;
        }

        public void setDynamicClientRegistrationEndpoint(String theDynamicClientRegistrationEndpoint) {
                myDynamicClientRegistrationEndpoint = theDynamicClientRegistrationEndpoint;
        }

        public List<String> getSupportedScopes() {
                if (mySupportedScopes == null) {
                        mySupportedScopes = new ArrayList<>();
                }
                return mySupportedScopes;
        }

        public void setSupportedScopes(List<String> theSupportedScopes) {
                mySupportedScopes = theSupportedScopes;
        }

        public void addSupportedScope(String theScope) {
                getSupportedScopes().add(theScope);
        }

        public List<String> getSupportedResponseTypes() {
                if (mySupportedResponseTypes == null) {
                        mySupportedResponseTypes = new ArrayList<>();
                }
                return mySupportedResponseTypes;
        }

        public void setSupportedResponseTypes(List<String> theSupportedResponseTypes) {
                mySupportedResponseTypes = theSupportedResponseTypes;
        }

        public void addSupportedResponseType(String theResponseType) {
                getSupportedResponseTypes().add(theResponseType);
        }

        public List<String> getSupportedResponseModes() {
                if (mySupportedResponseModes == null) {
                        mySupportedResponseModes = new ArrayList<>();
                }
                return mySupportedResponseModes;
        }

        public void setSupportedResponseModes(List<String> theSupportedResponseModes) {
                mySupportedResponseModes = theSupportedResponseModes;
        }

        public void addSupportedResponseMode(String theMode) {
                getSupportedResponseModes().add(theMode);
        }

        public List<String> getSupportedGrantTypes() {
                if (mySupportedGrantTypes == null) {
                        mySupportedGrantTypes = new ArrayList<>();
                }
                return mySupportedGrantTypes;
        }

        public void setSupportedGrantTypes(List<String> theSupportedGrantTypes) {
                mySupportedGrantTypes = theSupportedGrantTypes;
        }

        public void addSupportedGrantType(String theGrantType) {
                getSupportedGrantTypes().add(theGrantType);
        }

        public List<String> getSupportedAuthenticationMethods() {
                if (mySupportedAuthenticationMethods == null) {
                        mySupportedAuthenticationMethods = new ArrayList<>();
                }
                return mySupportedAuthenticationMethods;
        }

        public void setSupportedAuthenticationMethods(List<String> theSupportedAuthenticationMethods) {
                mySupportedAuthenticationMethods = theSupportedAuthenticationMethods;
        }

        public void addSupportedAuthenticationMethod(String theMethod) {
                getSupportedAuthenticationMethods().add(theMethod);
        }

        public List<String> getSupportedJWSSigningAlgorithms() {
                if (mySupportedJWSSigningAlgorithms == null) {
                        mySupportedJWSSigningAlgorithms = new ArrayList<>();
                }
                return mySupportedJWSSigningAlgorithms;
        }

        public void setSupportedJWSSigningAlgorithms(List<String> theSupportedJWSSigningAlgorithms) {
                mySupportedJWSSigningAlgorithms = theSupportedJWSSigningAlgorithms;
        }

        public void addSupportedJWSSigningAlgorithm(String theAlg) {
                getSupportedJWSSigningAlgorithms().add(theAlg);
        }

        public String getRevocationEndpoint() {
                return myRevocationEndpoint;
        }

        public void setRevocationEndpoint(String theRevocationEndpoint) {
                myRevocationEndpoint = theRevocationEndpoint;
        }

        public List<String> getSupportedAuthMethodsForRevocation() {
                if (mySupportedAuthMethodsForRevocation == null) {
                        mySupportedAuthMethodsForRevocation = new ArrayList<>();
                }
                return mySupportedAuthMethodsForRevocation;
        }

        public void setSupportedAuthMethodsForRevocation(List<String> theSupportedAuthMethodsForRevocation) {
                mySupportedAuthMethodsForRevocation = theSupportedAuthMethodsForRevocation;
        }

        public void addSupportedAuthMethodForRevocation(String theMethod) {
                getSupportedAuthenticationMethods().add(theMethod);
        }

        public List<String> getRevocationEndpointSigningAlgorithms() {
                if (myRevocationEndpointSigningAlgorithms == null) {
                        myRevocationEndpointSigningAlgorithms = new ArrayList<>();
                }
                return myRevocationEndpointSigningAlgorithms;
        }

        public void setRevocationEndpointSigningAlgorithms(List<String> theRevocationEndpointSigningAlgorithms) {
                myRevocationEndpointSigningAlgorithms = theRevocationEndpointSigningAlgorithms;
        }

        public void addRevocationEndpointSigningAlgorithm(String theAlg) {
                getRevocationEndpointSigningAlgorithms().add(theAlg);
        }

        public String getIntrospectionEndpoint() {
                return myIntrospectionEndpoint;
        }

        public void setIntrospectionEndpoint(String theIntrospectionEndpoint) {
                myIntrospectionEndpoint = theIntrospectionEndpoint;
        }

        public List<String> getSupportedIntrospectionEndpointAuthMethods() {
                if (mySupportedIntrospectionEndpointAuthMethods == null) {
                        mySupportedIntrospectionEndpointAuthMethods = new ArrayList<>();
                }
                return mySupportedIntrospectionEndpointAuthMethods;
        }

        public void setSupportedIntrospectionEndpointAuthMethods(
                        List<String> theSupportedIntrospectionEndpointAuthMethods) {
                mySupportedIntrospectionEndpointAuthMethods = theSupportedIntrospectionEndpointAuthMethods;
        }

        public void addSupportedIntrospectionEndpointAuthMethod(String theMethod) {
                getSupportedIntrospectionEndpointAuthMethods().add(theMethod);
        }

        public String getUserInfoEndpoint() {
                return myUserInfoEndpoint;
        }

        public void setUserInfoEndpoint(String theUserInfoEndpoint) {
                myUserInfoEndpoint = theUserInfoEndpoint;
        }

        public List<String> getSupportedIdTokenSigningAlgs() {
                if (mySupportedIdTokenSigningAlgs == null) {
                        mySupportedIdTokenSigningAlgs = new ArrayList<>();
                }
                return mySupportedIdTokenSigningAlgs;
        }

        public void setSupportedIdTokenSigningAlgs(List<String> theSupportedIdTokenSigningAlgs) {
                mySupportedIdTokenSigningAlgs = theSupportedIdTokenSigningAlgs;
        }

        public void addSupportedIdTokenSigningAlg(String theAlg) {
                getSupportedIdTokenSigningAlgs().add(theAlg);
        }

        public List<String> getCodeChallengeMethodsSupported() {
                if (myCodeChallengeMethodsSupported == null) {
                        myCodeChallengeMethodsSupported = new ArrayList<>();
                }
                return myCodeChallengeMethodsSupported;
        }

        public void setCodeChallengeMethodsSupported(List<String> theCodeChallengeMethodsSupported) {
                myCodeChallengeMethodsSupported = theCodeChallengeMethodsSupported;
        }

        public void addCodeChallengeMethodSupported(String theCode) {
                getCodeChallengeMethodsSupported().add(theCode);
        }

        public List<String> getSubjectTypesSupported() {
                if (mySubjectTypesSupported == null) {
                        mySubjectTypesSupported = new ArrayList<>();
                }
                return mySubjectTypesSupported;
        }

        public void setSubjectTypesSupported(List<String> theSubjectTypesSupported) {
                mySubjectTypesSupported = theSubjectTypesSupported;
        }

        public void addSubjectTypeSupported(String theType) {
                getSubjectTypesSupported().add(theType);
        }

        @JsonAnySetter
        public void add(String theProp, Object theVal) {
                myUnknownProperties.put(theProp, theVal);
        }

        Map<String, Object> getUnknownProperties() {
                return myUnknownProperties;
        }

        Map<String, Object> toMap() {
                Map<String, Object> map = new HashMap<>();
                Field[] fields = OpenIdWellKnownOpenIdConfigurationResponse.class.getDeclaredFields();

                try {
                        for (Field field : fields) {
                                if (field.isAnnotationPresent(JsonProperty.class)) {
                                        Object value = field.get(this);
                                        if (value != null) {
                                                // we want the names to be whatever's in the json annotation
                                                JsonProperty jsonProperty = field.getAnnotation(JsonProperty.class);
                                                String name = jsonProperty.value();
                                                map.put(name, value);
                                        }
                                }
                        }
                } catch (IllegalAccessException ex) {
                        throw new InternalErrorException(ex);
                }

                map.putAll(myUnknownProperties);

                return map;
        }

        @Override
        public String toString() {
                ObjectMapper mapper = new ObjectMapper();
                Map<String, Object> map = toMap();

                try {
                        return mapper.writeValueAsString(map);
                } catch (JsonProcessingException ex) {
                        throw new InternalErrorException(ex);
                }
        }
}