package ca.cdr.api.model.json;

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

import ca.cdr.api.model.enm.OAuth2AuthorizedGrantTypeEnum;
import ca.cdr.api.model.enm.PermissionEnum;
import ca.cdr.api.security.ScopeValidation;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.annotation.Nonnull;
import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Pattern;
import org.apache.commons.lang3.Validate;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.oauth2.provider.ClientDetails;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;

import static org.apache.commons.lang3.StringUtils.defaultString;
import static org.apache.commons.lang3.StringUtils.isNotBlank;
import static org.apache.commons.lang3.StringUtils.join;

public class OAuth2WritableClientDetailsJson implements ClientDetails, IHasAuthorities, IModelJson {

        public static final String CLIENTID_PATTERN = "[^ ]+";
        public static final String CLIENT_ID = "clientId";
        public static final String CLIENT_NAME = "clientName";
        public static final String ENABLED = "enabled";
        public static final String PID = "pid";
        private static final long serialVersionUID = 1L;

        public static final String CLIENT_SECRET_JOINED_DELIMITER = " ";

        @Schema(accessMode = Schema.AccessMode.READ_ONLY, description = "The internal ID for this client.")
        @JsonProperty(PID)
        private Long myPid;

        @JsonProperty("accessTokenValiditySeconds")
        @Schema(description = "The number of seconds that an access token should be valid once it has been created.")
        private Integer myAccessTokenValiditySeconds;

        @JsonProperty("allowedGrantTypes")
        @Schema(
                        description =
                                        "The grant types that this client is permitted to perform. See [Authorization Flows](/docs/smart/smart_on_fhir_authorization_flows.html) for a description of the possible flows.")
        private TreeSet<OAuth2AuthorizedGrantTypeEnum> myAllowedGrantTypes;

        @JsonProperty("autoApproveScopes")
        @Schema(
                        description =
                                        "Scopes listed here will be automatically approved if requested by the client during the initial authorization request, without requiring the user to explicitly accept them.")
        private TreeSet<String> myAutoApproveScopes;

        @JsonProperty("autoGrantScopes")
        @Schema(
                        description =
                                        "Scopes listed here will be automatically granted during every successful authorization by this client. These scopes do not have to be explicitly requested by the client during the initial authorization request.")
        private TreeSet<String> myAutoGrantScopes;

        @NotBlank
        @JsonProperty(CLIENT_ID)
        @Schema(description = "The Client ID (corresponds to the `iss` field in many OAuth2 exchanges).")
        @Pattern(regexp = CLIENTID_PATTERN, message = "module_validation.invalid_client_id")
        private String myClientId;

        @JsonProperty(CLIENT_NAME)
        @Schema(description = "A human friendly description/name for the client.")
        private String myClientName;

        @JsonProperty("clientSecrets")
        @Schema(description = "Optionally contains client secrets to be used by the client in some grant types.")
        private List<OAuth2ClientSecretJson> myClientSecrets;

        @JsonProperty("fixedScope")
        @Schema(
                        description =
                                        "Is this client fixed scope? When authorizing a fixed scope client, the list of scopes requested in the initial authorization request will be ignored, and the complete list of scopes in the Scope property will be assumed. If these scopes are not listed as Auto-Approve, the user will still be required to approve them.")
        private boolean myFixedScope;

        @JsonProperty("refreshTokenValiditySeconds")
        @Schema(description = "The number of seconds that a refresh token will be valid for.")
        private Integer myRefreshTokenValiditySeconds;

        @JsonProperty("registeredRedirectUris")
        @Schema(description = "The allowable redirect URIs that may be requested.")
        private TreeSet<String> myRegisteredRedirectUris;

        @JsonProperty("scopes")
        @Schema(description = "A list of OAuth2 scopes that the client is allowed to request user approval for.")
        private TreeSet<String> myScope;

        @JsonProperty("secretRequired")
        @Schema(description = "Is the client secret required in order to authenticate this client?")
        private boolean mySecretRequired;

        @JsonProperty("secretClientCanChange")
        @Schema(description = "Can the client change their own secret?")
        private boolean mySecretClientCanChange;

        @JsonProperty(ENABLED)
        @Schema(description = "Is the client enabled?")
        private boolean myEnabled;

        @JsonProperty("canIntrospectOwnTokens")
        @Schema(description = "Can this client perform token introspection on tokens that it issued?")
        private boolean myCanIntrospectOwnTokens;

        @JsonProperty("canIntrospectAnyTokens")
        @Schema(
                        description =
                                        "Can this client perform token introspecton on any tokens issued by the security module it is registered against?")
        private boolean myCanIntrospectAnyTokens;

        @JsonProperty("alwaysRequireApproval")
        @Schema(
                        description =
                                        "Should the user approval page be displayed even if the client has not requested any scopes that require user approval?")
        private boolean myAlwaysRequireApproval;

        @JsonProperty("canReissueTokens")
        @Schema(
                        description =
                                        "Can the OAuth2 server reissue tokens that have been previously issued for this client, if the token request is the same (e.g. for the same user, requesting the same scopes, etc.) and the token is not close to expiry?")
        private boolean myCanReissueTokens;

        @JsonProperty("permissions")
        @Schema(
                        description =
                                        "Any permission that should be granted directly to the client when it authenticates using the [Client Credentials Grant](/docs/smart/smart_on_fhir_authorization_flows.html#client-credentials-flow).")
        private List<GrantedAuthorityJson> myPermissions;

        @JsonProperty("rememberApprovedScopes")
        @Schema(
                        description =
                                        "When a user performs an OAuth2 authentication/authorization flow for this client, should their approved scopes be remembered the next time they authenticate?")
        private boolean myRememberApprovedScopes;

        @JsonProperty("attestationAccepted")
        @Schema(description = "Has the client developer attested to the policy?")
        private boolean myAttestationAccepted;

        @JsonProperty("publicJwks")
        @Schema(
                        description =
                                        "The public JWKS Keystore for this client. Used when the client authenticated using a bearer token.")
        private String myPublicJwks;

        @JsonProperty("jwksUrl")
        @Schema(
                        description =
                                        "A public endpoint location of the JWK Set. If present, this will be used before any public JWKS on the client directly.")
        private String myJwksUrl;

        @JsonProperty("archivedAt")
        @Schema(description = "The time at which this client was archived, if it has been.")
        private Date myArchivedAt;

        @JsonProperty("createdByAppSphere")
        private boolean myCreatedByAppSphere;

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

        public OAuth2WritableClientDetailsJson(OAuth2WritableClientDetailsJson theClientDetailsJson) {
                myPid = theClientDetailsJson.myPid;
                myAccessTokenValiditySeconds = theClientDetailsJson.myAccessTokenValiditySeconds;
                myAllowedGrantTypes = nullSafeClone(theClientDetailsJson.myAllowedGrantTypes);
                myAutoApproveScopes = nullSafeClone(theClientDetailsJson.myAutoApproveScopes);
                myAutoGrantScopes = nullSafeClone(theClientDetailsJson.myAutoGrantScopes);
                myClientId = theClientDetailsJson.myClientId;
                myClientName = theClientDetailsJson.myClientName;
                myClientSecrets = nullSafeClone(theClientDetailsJson.myClientSecrets);
                myFixedScope = theClientDetailsJson.myFixedScope;
                myRefreshTokenValiditySeconds = theClientDetailsJson.myRefreshTokenValiditySeconds;
                myRegisteredRedirectUris = nullSafeClone(theClientDetailsJson.myRegisteredRedirectUris);
                myScope = nullSafeClone(theClientDetailsJson.myScope);
                mySecretRequired = theClientDetailsJson.mySecretRequired;
                mySecretClientCanChange = theClientDetailsJson.mySecretClientCanChange;
                myEnabled = theClientDetailsJson.myEnabled;
                myCanIntrospectOwnTokens = theClientDetailsJson.myCanIntrospectOwnTokens;
                myCanIntrospectAnyTokens = theClientDetailsJson.myCanIntrospectAnyTokens;
                myAlwaysRequireApproval = theClientDetailsJson.myAlwaysRequireApproval;
                myCanReissueTokens = theClientDetailsJson.myCanReissueTokens;
                myPermissions = nullSafeClone(theClientDetailsJson.myPermissions);
                myRememberApprovedScopes = theClientDetailsJson.myRememberApprovedScopes;
                myAttestationAccepted = theClientDetailsJson.myAttestationAccepted;
                myPublicJwks = theClientDetailsJson.myPublicJwks;
                myJwksUrl = theClientDetailsJson.myJwksUrl;
                myArchivedAt = theClientDetailsJson.myArchivedAt;
                myCreatedByAppSphere = theClientDetailsJson.myCreatedByAppSphere;
        }

        public String getJwksUrl() {
                return myJwksUrl;
        }

        public void setJwksUrl(String theJwksUrl) {
                myJwksUrl = theJwksUrl;
        }

        public String getPublicJwks() {
                return myPublicJwks;
        }

        public void setPublicJwks(String thePublicJwks) {
                myPublicJwks = thePublicJwks;
        }

        @Override
        public List<GrantedAuthorityJson> getPermissions() {
                if (myPermissions == null) {
                        myPermissions = new ArrayList<>();
                }
                return myPermissions;
        }

        public void setPermissions(List<GrantedAuthorityJson> thePermissions) {
                myPermissions = thePermissions;
        }

        public void addAllowedGrantType(String theName) {
                addAllowedGrantType(OAuth2AuthorizedGrantTypeEnum.valueOf(theName));
        }

        public void addAllowedGrantType(@Nonnull OAuth2AuthorizedGrantTypeEnum theGrantType) {
                getAllowedGrantTypes().add(theGrantType);
        }

        public void addAutoApproveScopeIfNotBlank(String theScope) {
                if (isNotBlank(theScope)) {
                        getAutoApproveScopes().add(theScope.trim());
                }
        }

        public void addRedirectUrlIfNotBlank(String theRedirectUrl) {
                if (isNotBlank(theRedirectUrl)) {
                        getRegisteredRedirectUri().add(theRedirectUrl.trim());
                }
        }

        public OAuth2WritableClientDetailsJson addScopeIfNotBlank(String theScope) {
                if (isNotBlank(theScope)) {
                        getScope().add(theScope.trim());
                }
                return this;
        }

        @Override
        public Integer getAccessTokenValiditySeconds() {
                return myAccessTokenValiditySeconds;
        }

        public void setAccessTokenValiditySeconds(Integer theAccessTokenValiditySeconds) {
                myAccessTokenValiditySeconds = theAccessTokenValiditySeconds;
        }

        @Override
        public Map<String, Object> getAdditionalInformation() {
                return new HashMap<>();
        }

        public TreeSet<OAuth2AuthorizedGrantTypeEnum> getAllowedGrantTypes() {
                if (myAllowedGrantTypes == null) {
                        myAllowedGrantTypes = new TreeSet<>();
                }
                return myAllowedGrantTypes;
        }

        public void setAllowedGrantTypes(TreeSet<OAuth2AuthorizedGrantTypeEnum> theAllowedGrantTypes) {
                myAllowedGrantTypes = theAllowedGrantTypes;
        }

        /**
         * This method is a part of the Spring Security framework, and returns
         * an <b>unmodifiable</b> copy of the client authorities. Use
         * {@link #getPermissions()} if you want to modify the actual
         * values.
         */
        @Override
        public Collection<GrantedAuthority> getAuthorities() {
                ArrayList<GrantedAuthorityJson> retVal = new ArrayList<>();
                retVal.addAll(getPermissions());
                return Collections.unmodifiableList(retVal);
        }

        @Override
        public Set<String> getAuthorizedGrantTypes() {
                TreeSet<String> retVal =
                                getAllowedGrantTypes().stream().map(t -> t.getCode()).collect(Collectors.toCollection(TreeSet::new));
                return Collections.unmodifiableSet(retVal);
        }

        public boolean hasAutoApproveScopes() {
                return myAutoApproveScopes != null && !myAutoApproveScopes.isEmpty();
        }

        public boolean hasAutoGrantScopes() {
                return myAutoGrantScopes != null && !myAutoGrantScopes.isEmpty();
        }

        @Nonnull
        public TreeSet<String> getAutoApproveScopes() {
                if (myAutoApproveScopes == null) {
                        myAutoApproveScopes = new TreeSet<>();
                }
                return myAutoApproveScopes;
        }

        public void setAutoApproveScopes(TreeSet<String> theAutoApproveScopes) {
                myAutoApproveScopes = theAutoApproveScopes;
        }

        @Nonnull
        public TreeSet<String> getAutoGrantScopes() {
                if (myAutoGrantScopes == null) {
                        myAutoGrantScopes = new TreeSet<>();
                }
                return myAutoGrantScopes;
        }

        public void setAutoGrantScopes(TreeSet<String> theAutoGrantScopes) {
                myAutoGrantScopes = theAutoGrantScopes;
        }

        public String getAutoApproveScopesSpaceSeparated() {
                return defaultString(join(getAutoApproveScopes(), ' '));
        }

        public String getAutoGrantScopesSpaceSeparated() {
                return defaultString(join(getAutoGrantScopes(), ' '));
        }

        @Override
        public String getClientId() {
                return myClientId;
        }

        public OAuth2WritableClientDetailsJson setClientId(String theClientId) {
                myClientId = theClientId;
                return this;
        }

        public String getClientName() {
                return myClientName;
        }

        public void setClientName(String theClientName) {
                myClientName = theClientName;
        }

        @Override
        public String getClientSecret() {
                // NB: If you ever decide to cache the return value of this method, note that
                // we sometimes mask the secrets after generating the JSON entity (e.g. if the
                // client def is going to be returned to a user)
                return getClientSecrets().stream()
                                .filter(t -> t.getExpiration() == null || t.getExpiration().getTime() >= System.currentTimeMillis())
                                .filter(t -> t.getActivation() == null || t.getActivation().getTime() <= System.currentTimeMillis())
                                .map(t -> t.getSecret())
                                .collect(Collectors.joining(CLIENT_SECRET_JOINED_DELIMITER));
        }

        public List<OAuth2ClientSecretJson> getClientSecrets() {
                if (myClientSecrets == null) {
                        myClientSecrets = new ArrayList<>();
                }
                return myClientSecrets;
        }

        public void setClientSecrets(List<OAuth2ClientSecretJson> theClientSecrets) {
                myClientSecrets = theClientSecrets;
        }

        public Long getPid() {
                return myPid;
        }

        public OAuth2WritableClientDetailsJson setPid(Long myPid) {
                this.myPid = myPid;
                return this;
        }

        @Override
        public Integer getRefreshTokenValiditySeconds() {
                return myRefreshTokenValiditySeconds;
        }

        public void setRefreshTokenValiditySeconds(Integer theRefreshTokenValiditySeconds) {
                myRefreshTokenValiditySeconds = theRefreshTokenValiditySeconds;
        }

        @Nonnull
        @Override
        public TreeSet<String> getRegisteredRedirectUri() {
                if (myRegisteredRedirectUris == null) {
                        myRegisteredRedirectUris = new TreeSet<>();
                }
                return myRegisteredRedirectUris;
        }

        public TreeSet<String> getRegisteredRedirectUris() {
                return getRegisteredRedirectUri();
        }

        public void setRegisteredRedirectUris(TreeSet<String> theRegisteredRedirectUris) {
                myRegisteredRedirectUris = theRegisteredRedirectUris;
        }

        public void setRegisteredRedirectUris(Iterable<String> theRegisteredRedirectUri) {
                myRegisteredRedirectUris = new TreeSet<>();
                if (theRegisteredRedirectUri != null) {
                        theRegisteredRedirectUri.forEach(t -> myRegisteredRedirectUris.add(t));
                }
        }

        public String getRegisteredRedirectUriOnePerLine() {
                return defaultString(join(getRegisteredRedirectUri(), '\n'));
        }

        @Override
        public Set<String> getResourceIds() {
                return Collections.emptySet();
        }

        public boolean hasScope() {
                return myScope != null && !myScope.isEmpty();
        }

        @Nonnull
        @Override
        public Set<String> getScope() {
                if (myScope == null) {
                        myScope = new TreeSet<>();
                }
                return new ScopeSetWrapper(myScope);
        }

        public void setScope(TreeSet<String> theScope) {
                myScope = theScope;
        }

        public Set<String> getScopes() {
                return getScope();
        }

        public void setScopes(TreeSet<String> theScope) {
                setScope(theScope);
        }

        public String getScopeSpaceSeparated() {
                return defaultString(join(getScope(), ' '));
        }

        public boolean isAlwaysRequireApproval() {
                return myAlwaysRequireApproval;
        }

        public void setAlwaysRequireApproval(boolean theAlwaysRequireApproval) {
                myAlwaysRequireApproval = theAlwaysRequireApproval;
        }

        @Override
        public boolean isAutoApprove(String theScope) {
                boolean retVal = getAutoApproveScopes().contains(theScope);
                if (!retVal) {
                        retVal = ScopeValidation.isScopeAllowedDirectlyOrIndirectly(getAutoApproveScopes(), theScope);
                }
                return retVal;
        }

        public boolean isCanIntrospectAnyTokens() {
                return myCanIntrospectAnyTokens;
        }

        public void setCanIntrospectAnyTokens(boolean theCanIntrospectAnyTokens) {
                myCanIntrospectAnyTokens = theCanIntrospectAnyTokens;
        }

        public boolean isCanIntrospectOwnTokens() {
                return myCanIntrospectOwnTokens;
        }

        public void setCanIntrospectOwnTokens(boolean theCanIntrospectOwnTokens) {
                myCanIntrospectOwnTokens = theCanIntrospectOwnTokens;
        }

        public boolean isFixedScope() {
                return myFixedScope;
        }

        public void setFixedScope(boolean theFixedScope) {
                myFixedScope = theFixedScope;
        }

        @Override
        public boolean isScoped() {
                return myFixedScope;
        }

        @Override
        public boolean isSecretRequired() {
                return mySecretRequired;
        }

        public void setSecretRequired(boolean theSecretRequired) {
                mySecretRequired = theSecretRequired;
        }

        public boolean isSecretClientCanChange() {
                return mySecretClientCanChange;
        }

        public void setSecretClientCanChange(boolean theSecretClientCanChange) {
                mySecretClientCanChange = theSecretClientCanChange;
        }

        public boolean isEnabled() {
                return myEnabled;
        }

        public void setEnabled(boolean theEnabled) {
                myEnabled = theEnabled;
        }

        public Optional<OAuth2ClientSecretJson> getClientSecret(Long thePid) {
                Validate.notNull(thePid, "thePid must not be null");
                return getClientSecrets().stream()
                                .filter(t -> thePid.equals(t.getPid()))
                                .findFirst();
        }

        public OAuth2WritableClientDetailsJson addClientSecret(OAuth2ClientSecretJson theSecret) {
                Validate.notNull(theSecret, "theSecret must not be null");
                getClientSecrets().add(theSecret);
                return this;
        }

        public OAuth2ClientSecretJson addClientSecret(String theSecret) {
                Validate.notBlank(theSecret, "theSecret must not be null or blank");
                OAuth2ClientSecretJson secret = addClientSecret();
                secret.setSecret(theSecret);
                return secret;
        }

        public OAuth2ClientSecretJson addClientSecret() {
                OAuth2ClientSecretJson secret = new OAuth2ClientSecretJson();
                addClientSecret(secret);
                return secret;
        }

        public OAuth2ClientSecretJson addClientSecret(String theSecret, Date theExpiration) {
                return addClientSecret(theSecret).setExpiration(theExpiration);
        }

        public boolean isCanReissueTokens() {
                return myCanReissueTokens;
        }

        public void setCanReissueTokens(boolean theCanReissueTokens) {
                myCanReissueTokens = theCanReissueTokens;
        }

        public void addAutoGrantScopeIfNotBlank(String theScope) {
                if (isNotBlank(theScope)) {
                        getAutoGrantScopes().add(theScope.trim());
                }
        }

        public void addPermission(GrantedAuthorityJson thePermission) {
                Validate.notNull(thePermission);
                getPermissions().add(thePermission);
        }

        public void addPermission(PermissionEnum thePermission, String theArgument) {
                Validate.notNull(thePermission);
                addPermission(new GrantedAuthorityJson(thePermission, theArgument));
        }

        public void addPermission(PermissionEnum thePermission) {
                Validate.notNull(thePermission);
                addPermission(new GrantedAuthorityJson(thePermission));
        }

        public void removePermission(PermissionEnum thePermission, String theArgument) {
                Validate.notNull(thePermission);
                removePermission(new GrantedAuthorityJson(thePermission, theArgument));
        }

        public void removePermission(GrantedAuthorityJson thePermission) {
                Validate.notNull(thePermission);
                getPermissions().remove(thePermission);
        }

        public boolean isRememberApprovedScopes() {
                return myRememberApprovedScopes;
        }

        public void setRememberApprovedScopes(boolean theRememberApprovedScopes) {
                myRememberApprovedScopes = theRememberApprovedScopes;
        }

        public boolean isAttestationAccepted() {
                return myAttestationAccepted;
        }

        public void setAttestationAccepted(boolean theAttestationAccepted) {
                myAttestationAccepted = theAttestationAccepted;
        }

        public Date getArchivedAt() {
                return myArchivedAt;
        }

        public void setArchivedAt(Date theArchivedAt) {
                myArchivedAt = theArchivedAt;
        }

        public boolean isCreatedByAppSphere() {
                return myCreatedByAppSphere;
        }

        public void setCreatedByAppSphere(boolean theCreatedByAppSphere) {
                myCreatedByAppSphere = theCreatedByAppSphere;
        }

        private static <T> TreeSet<T> nullSafeClone(TreeSet<T> theTreeSet) {
                return theTreeSet != null ? new TreeSet<>(theTreeSet) : null;
        }

        private static <T> List<T> nullSafeClone(List<T> theList) {
                return theList != null ? new ArrayList<>(theList) : null;
        }

        /**
         * This class provides a wrapper around the client scopes property
         * (see {@link #getScope()}) but modifies the behaviour of the
         * {@link #contains(Object)} method. Effectively, any tests for whether
         * the {@link Set#contains(Object)} method contains a given scope will test
         * the scopes, but will also account for {@link #getAutoGrantScopes()} and
         * equivalent but narrower scopes (e.g. we allow <code>patient/Observation.read</code>
         * if the client is allowed <code>patient/*.read</code>).
         * <p>
         * We use this clunky wrapper approach because Spring Security added a test in
         * {@link org.springframework.security.oauth2.provider.authentication.OAuth2AuthenticationManager}
         * that we can't modify.
         * </p>
         */
        private class ScopeSetWrapper implements Set<String> {
                private final TreeSet<String> myWrap;

                public ScopeSetWrapper(TreeSet<String> theWrap) {
                        myWrap = theWrap;
                }

                @Override
                public int size() {
                        return myWrap.size();
                }

                @Override
                public boolean isEmpty() {
                        return myWrap.isEmpty();
                }

                /**
                 * See class documentation for a description of what this method is about
                 */
                @Override
                public boolean contains(Object theScope) {
                        if (!(theScope instanceof String scopeStr)) {
                                return false;
                        } else if (ScopeValidation.isScopeAllowedDirectlyOrIndirectly(myWrap, scopeStr)) {
                                return true;
                        } else {
                                return ScopeValidation.isScopeAllowedDirectlyOrIndirectly(getAutoGrantScopes(), scopeStr);
                        }
                }

                @Nonnull
                @Override
                public Iterator<String> iterator() {
                        return myWrap.iterator();
                }

                @Nonnull
                @Override
                public Object[] toArray() {
                        return myWrap.toArray();
                }

                @Nonnull
                @Override
                public <T> T[] toArray(@Nonnull T[] a) {
                        return myWrap.toArray(a);
                }

                @Override
                public boolean add(String theScope) {
                        return myWrap.add(theScope);
                }

                @Override
                public boolean remove(Object o) {
                        return myWrap.remove(o);
                }

                @Override
                public boolean containsAll(@Nonnull Collection<?> c) {
                        return myWrap.containsAll(c);
                }

                @Override
                public boolean addAll(@Nonnull Collection<? extends String> c) {
                        return myWrap.addAll(c);
                }

                @Override
                public boolean retainAll(@Nonnull Collection<?> c) {
                        return myWrap.retainAll(c);
                }

                @Override
                public boolean removeAll(@Nonnull Collection<?> c) {
                        return myWrap.removeAll(c);
                }

                @Override
                public void clear() {
                        myWrap.clear();
                }
        }
}