package ca.cdr.api.model.json;

/*-
 * #%L
 * Smile CDR - CDR
 * %%
 * Copyright (C) 2016 - 2026 Smile CDR, Inc.
 * %%
 * All rights reserved.
 * #L%
 */

import ca.cdr.api.util.SmileClaimConstants;
import ca.cdr.api.util.VersionIndependentCoding;
import ca.uhn.fhir.util.JsonUtil;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.v3.oas.annotations.Operation;
import io.swagger.v3.oas.annotations.Parameter;
import io.swagger.v3.oas.annotations.media.Schema;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.Validate;
import org.hl7.fhir.instance.model.api.IBaseCoding;
import org.springframework.security.core.AuthenticatedPrincipal;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;

import static org.apache.commons.lang3.StringUtils.trim;

@Schema(
                name = "UserSessionDetails",
                description = "A user session details object contains details about a logged in user and "
                                + "a specific session they have established with the authorization server.")
public class UserSessionDetailsJson extends UserDetailsJson
                implements IOAuth2Session, IModelJson, AuthenticatedPrincipal, IHasUserData, ISessionConsentDetails {
        public static final String FHIR_CONTEXT = "fhirContext";

        @JsonProperty("launchContextParameters")
        @Schema(
                        description =
                                        "Specifies the parameters that will be returned to the user as launch context if the SMART authorization flow requests a launch context",
                        accessMode = Schema.AccessMode.READ_ONLY)
        private List<LaunchContextParameterJson> myLaunchContextParameters;

        @JsonProperty("launchResourceIds")
        @Schema(
                        description =
                                        "Specifies the IDs that will be returned to the user as launch context if the SMART authorization flow requests a launch context",
                        accessMode = Schema.AccessMode.READ_ONLY)
        private List<LaunchResourceIdJson> myLaunchResourceIds;

        /**
         * This is for launch context, not the Hapi FhirContext.
         * @see <a href='http://hl7.org/fhir/smart-app-launch/scopes-and-launch-context.html#launch-context-arrives-with-your-access_token'>http://hl7.org/fhir/smart-app-launch/scopes-and-launch-context.html#launch-context-arrives-with-your-access_token</a>
         */
        @JsonProperty("fhirContext")
        @Schema(
                        description =
                                        "Specifies the components of the fhirContext, including a reference or a reference/role pair.",
                        accessMode = Schema.AccessMode.READ_ONLY)
        private List<SmartFhirContextEntryJson> myFhirContext;

        @JsonProperty("approvedScopes")
        @Schema(
                        description =
                                        "If the session is an OAuth2 session (i.e. it is accessed via a bearer token that was granted by a SMART Auth server) this field will be populated with the set of scopes that were approved for the client")
        private Set<String> myApprovedScopes;

        @JsonProperty("oidcClientId")
        @Schema(
                        description =
                                        "If the session is an OAuth2 session (i.e. it is accessed via a bearer token that was granted by a SMART Auth server) this field will be populated with the id of the client.")
        private String myOidcClientId;

        @JsonProperty("oidcClientNodeId")
        @Schema(description = "The node ID associated with OIDC client of this user.")
        private String myOidcClientNodeId;

        @Schema(description = "The module ID associated with the OIDC client of this user account.")
        @JsonProperty("oidcClientModuleId")
        private String myOidcClientModuleId;

        @Schema(
                        description =
                                        "The consent details associated with the identity of the user session and purpose of any action.")
        @JsonProperty("consentPurpose")
        private CodingJson myConsentPurpose;

        @Schema(description = "The user data for this session.")
        @JsonProperty("userData")
        private Map<String, Object> myUserData;

        @Schema(
                        description =
                                        "Specifies the FHIR Resource URL associated with this user session. This value will be used to provide the `fhirUser` claim in returned ID Tokens, and is not used for other purposes.")
        @JsonProperty("fhirUserUrl")
        private String myFhirUserUrl;

        /**
         * Constructor
         */
        public UserSessionDetailsJson() {
                super();
        }

        /**
         * Copy Constructor
         */
        public UserSessionDetailsJson(UserDetailsJson theCopyObject) {
                super(theCopyObject);

                if (theCopyObject instanceof UserSessionDetailsJson) {
                        UserSessionDetailsJson copy = (UserSessionDetailsJson) theCopyObject;
                        getApprovedScopes().addAll(copy.getApprovedScopes());
                        getLaunchResourceIds().addAll(copy.getLaunchResourceIds());
                        getFhirContext().addAll(copy.getFhirContext());
                        setOidcClientId(copy.getOidcClientId());
                        setOidcClientModuleId(copy.getOidcClientModuleId());
                        setOidcClientNodeId(copy.getOidcClientNodeId());
                        if (copy.myUserData != null) {
                                myUserData = new HashMap<>(copy.myUserData);
                        }
                }
        }

        /**
         * Does this session have any approved scopes
         */
        @Override
        public boolean hasApprovedScopes() {
                return myApprovedScopes != null && !myApprovedScopes.isEmpty();
        }

        /**
         * If the session is an OAuth2 session (i.e. it is accessed via a bearer token that
         * was granted by a SMART Auth server) this field will be populated with the set of
         * scopes that were approved for the client
         */
        @Override
        public Set<String> getApprovedScopes() {
                if (myApprovedScopes == null) {
                        myApprovedScopes = new HashSet<>();
                }
                return myApprovedScopes;
        }

        public void setApprovedScopes(Set<String> theApprovedScopes) {
                myApprovedScopes = theApprovedScopes;
        }

        @Operation(
                        summary = "addUserData",
                        description =
                                        "Add user data to the session. Custom user data can be added for use within the system or in interceptors.")
        public void addUserData(
                        @Parameter(name = "theKey", description = "The user data key") String theKey,
                        @Parameter(name = "theValue", description = "The user data value") String theValue) {
                String key = trim(theKey);
                String value = trim(theValue);
                Validate.isTrue(!StringUtils.containsWhitespace(key), "Invalid user data key; must not contain any whitespace");
                // we pull claims into the user data
                // so we'll block the user data that has our custom claim prefix so our claims
                // will not be overwritten
                Validate.isTrue(
                                !theKey.startsWith(SmileClaimConstants.SMILE_CLAIM_PREFIX),
                                "Invalid user data key; cannot start with " + SmileClaimConstants.SMILE_CLAIM_PREFIX);
                getClientPopulatedUserData(true).put(theKey, value);
        }

        @Operation(summary = "addApprovedScope", description = "Add an approved scope to the session")
        public void addApprovedScope(
                        @Parameter(name = "theScope", description = "The SMART on FHIR/OIDC scope name") String theScope) {
                String scope = trim(theScope);
                Validate.isTrue(!StringUtils.containsWhitespace(scope), "Invalid scope, must not contain any whitespace");
                getApprovedScopes().add(scope);
        }

        @Operation(
                        summary = "removeApprovedScope",
                        description =
                                        "Remove an approved scope to the session. This method has no effect if the given scope is not in the existing approved scope list.")
        public void removeApprovedScope(
                        @Parameter(name = "theScope", description = "The SMART on FHIR/OIDC scope name") String theScope) {
                String scope = trim(theScope);
                Validate.isTrue(!StringUtils.containsWhitespace(scope), "Invalid scope, must not contain any whitespace");
                getApprovedScopes().remove(scope);
        }

        @Operation(summary = "addLaunchResourceId", description = "Adds a launch context resource id")
        public void addLaunchResourceId(
                        @Parameter(
                                                        name = "theResourceType",
                                                        description =
                                                                        "The launch context resource type. Note that this value is not capitalized, e.g. `patient` or `encounter`.")
                                        String theResourceType,
                        @Parameter(
                                                        name = "theResourceId",
                                                        description = "The resource ID. This value does not include a resource type, e.g. `123`.")
                                        String theResourceId) {
                Validate.notBlank(theResourceType, "The resource type must not be null or empty");
                Validate.notBlank(theResourceId, "The resource ID must not be null or empty");
                Validate.isTrue(!theResourceId.contains("/"), "The resource ID must not contain '/'");

                getLaunchResourceIds()
                                .add(new LaunchResourceIdJson().setResourceType(theResourceType).setResourceId(theResourceId));
        }

        @Operation(
                        summary = "getLaunchResourceIds",
                        description = "Provides the launch context resource IDs associated with this session")
        public List<LaunchResourceIdJson> getLaunchResourceIds() {
                if (myLaunchResourceIds == null) {
                        myLaunchResourceIds = new ArrayList<>();
                }
                return myLaunchResourceIds;
        }

        @Operation(summary = "getFhirContext", description = "Provides the fhirContext entries with this session")
        @Override
        public List<SmartFhirContextEntryJson> getFhirContext() {
                if (myFhirContext == null) {
                        myFhirContext = new ArrayList<>();
                }
                return myFhirContext;
        }

        @Operation(
                        summary = "getLaunchResourceIdForResourceType",
                        description =
                                        "Provides a single launch context resource ID associated with this session for a given resource type, returning the resource ID (e.g. `123`) or `null` if none are found.")
        public String getLaunchResourceIdForResourceType(
                        @Parameter(
                                                        name = "theResourceType",
                                                        description =
                                                                        "The launch context resource type. Note that this value is not capitalized, e.g. `patient` or `encounter`.")
                                        String theResourceType) {
                for (LaunchResourceIdJson next : getLaunchResourceIds()) {
                        if (next.getResourceType().equalsIgnoreCase(theResourceType)) {
                                return next.getResourceId();
                        }
                }
                return null;
        }

        @Operation(
                        summary = "getLaunchResourceIdsForResourceType",
                        description =
                                        "Provides the launch context resource IDs associated with this session for a given resource type, returning an array of `LaunchResourceId` objects.")
        public List<LaunchResourceIdJson> getLaunchResourceIdsForResourceType(
                        @Parameter(
                                                        name = "theResourceType",
                                                        description =
                                                                        "The launch context resource type. Note that this value is not capitalized, e.g. `patient` or `encounter`.")
                                        String theResourceType) {
                List<LaunchResourceIdJson> retVal = new ArrayList<>();
                for (LaunchResourceIdJson next : getLaunchResourceIds()) {
                        if (next.getResourceType().equalsIgnoreCase(theResourceType)) {
                                retVal.add(next);
                        }
                }
                return retVal;
        }

        @Operation(summary = "addLaunchContextParameter", description = "Adds a launch context parameter name/value pair")
        public void addLaunchContextParameter(
                        @Parameter(
                                                        name = "theParameterName",
                                                        description =
                                                                        "The launch context parameter name,e.g. `need_patient_banner` or `smart_style_url`.")
                                        String theParameterName,
                        @Parameter(name = "theParameterValue", description = "The parameter value.") String theParameterValue) {
                Validate.notBlank(theParameterName, "The parameter name must not be null or empty");
                Validate.notBlank(theParameterValue, "The parameter value must not be null or empty");

                getLaunchContextParameters()
                                .add(new LaunchContextParameterJson()
                                                .setParameterName(theParameterName)
                                                .setParameterValue(theParameterValue));
        }

        @Operation(
                        summary = "getLaunchContextParameters",
                        description = "Provides the launch context parameters associated with this session")
        public List<LaunchContextParameterJson> getLaunchContextParameters() {
                if (myLaunchContextParameters == null) {
                        myLaunchContextParameters = new ArrayList<>();
                }

                return myLaunchContextParameters;
        }

        public Optional<String> getLaunchContextParameterValueForParameterName(String theParameterName) {
                for (LaunchContextParameterJson contextParam : getLaunchContextParameters()) {
                        if (contextParam.getParameterName().equalsIgnoreCase(theParameterName)) {
                                return Optional.of(contextParam.getParameterValue());
                        }
                }

                return Optional.empty();
        }

        public void addApprovedScopes(Set<String> theScope) {
                if (theScope != null && theScope.size() > 0) {
                        if (myApprovedScopes == null) {
                                myApprovedScopes = new HashSet<>();
                        }
                        myApprovedScopes.addAll(theScope);
                }
        }

        /**
         * This method caches its output!!
         */
        public String toJsonString() {
                return JsonUtil.serialize(this);
        }

        // Required by Javascript
        @Override
        public String toString() {
                return toJsonString();
        }

        @Override
        public String getName() {
                return getUsername();
        }

        public String getOidcClientId() {
                return this.myOidcClientId;
        }

        public void setOidcClientId(String theClientId) {
                this.myOidcClientId = theClientId;
        }

        public String getOidcClientNodeId() {
                return myOidcClientNodeId;
        }

        public void setOidcClientNodeId(String theOidcNodeId) {
                myOidcClientNodeId = theOidcNodeId;
        }

        public String getOidcClientModuleId() {
                return myOidcClientModuleId;
        }

        public void setOidcClientModuleId(String theModuleId) {
                myOidcClientModuleId = theModuleId;
        }

        public String getFhirUserUrl() {
                return myFhirUserUrl;
        }

        public void setFhirUserUrl(String theFhirUserUrl) {
                myFhirUserUrl = theFhirUserUrl;
        }

        @Override
        public Map<String, Object> getClientPopulatedUserData(boolean theCreateIfNull) {
                if (theCreateIfNull && myUserData == null) {
                        myUserData = new HashMap<>();
                }
                return myUserData;
        }

        /**
         * Adds all claims in the provided map as user data
         */
        public void addClaimsAsUserData(Map<String, Object> theClaims) {
                for (Map.Entry<String, Object> claim : theClaims.entrySet()) {
                        setUserDataInternal(false, claim.getKey(), claim.getValue());
                }
        }

        @Override
        public IBaseCoding getConsentPurpose() {
                return myConsentPurpose == null
                                ? null
                                : new VersionIndependentCoding(myConsentPurpose.getSystem(), myConsentPurpose.getCode(), null);
        }

        @Override
        public void setConsentPurpose(String theSystem, String theCode) {
                if (myConsentPurpose == null) {
                        myConsentPurpose = new CodingJson();
                }
                myConsentPurpose.setSystem(theSystem);
                myConsentPurpose.setCode(theCode);
        }

        public UserSessionDetailsJson setConsentPurposeCoding(IBaseCoding theCoding) {
                if (theCoding == null) {
                        myConsentPurpose = null;
                } else {
                        if (myConsentPurpose == null) {
                                myConsentPurpose = new CodingJson();
                        }
                        myConsentPurpose.setCode(theCoding.getCode());
                        myConsentPurpose.setSystem(theCoding.getSystem());
                }
                return this;
        }

        public UserSessionDetailsJson setConsentPurposeSystem(String theSystem) {
                if (myConsentPurpose == null) {
                        myConsentPurpose = new CodingJson();
                }
                myConsentPurpose.setSystem(theSystem);
                return this;
        }

        public UserSessionDetailsJson setConsentPurposeCode(String theCode) {
                if (myConsentPurpose == null) {
                        myConsentPurpose = new CodingJson();
                }
                myConsentPurpose.setCode(theCode);
                return this;
        }
}