package nl.edsn.common.shared.security.token;

import nl.edsn.common.shared.security.token.converter.TokenConverter;
import org.slf4j.Logger;
import org.springframework.security.oauth2.jwt.Jwt;
import org.springframework.stereotype.Component;

import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * Mapper that maps a data exchange access token into an internal representation.
 */
@Component
public class TokenMapper {

    private static final Logger log = org.slf4j.LoggerFactory.getLogger(TokenMapper.class);
    private final AuthorizationServerJwtDecoder jwtDecoder;

    private final List<TokenConverter<? extends AccessToken>> accessTokenConverters;

    public TokenMapper(AuthorizationServerJwtDecoder jwtDecoder, List<TokenConverter<? extends AccessToken>> accessTokenConverters) {
        this.jwtDecoder = jwtDecoder;
        this.accessTokenConverters = accessTokenConverters;
    }

    /**
     * Maps the {@code token} into an {@link AccessToken} object.
     *
     * @param token the token as {@link String}.
     * @return the mapped {@link AccessToken}.
     * @throws TokenException when something went wrong mapping the {@code token}
     */
    public <T extends AccessToken> T map(String token, Class<T> accessTokenClass) throws TokenException {
        try {
            final Jwt jwt = jwtDecoder.decode(token);
            return map(jwt, accessTokenClass);
        } catch (org.springframework.security.oauth2.jwt.JwtException | io.jsonwebtoken.JwtException ex) {
            final String errorMessage = ex.getMessage();
            log.warn("Jwt validation failed due to; {}", errorMessage);
            throw new TokenException(errorMessage, ex);
        }
    }

    @SuppressWarnings("unchecked")
    public <T extends AccessToken> T map(Jwt jwt, Class<T> accessTokenClass) throws TokenException {
        try {
            log.debug("Parsing token");

            return accessTokenConverters.stream()
                    .map(converter -> (TokenConverter<T>) converter)
                    .filter(converter -> converter.supports(accessTokenClass))
                    .filter(converter -> hasRequiredClaims(jwt, converter))
                    .map(converter -> converter.convert(jwt))
                    .findFirst()
                    .orElseThrow(() -> new TokenException("Token invalid", null));
        } catch (org.springframework.security.oauth2.jwt.JwtException | io.jsonwebtoken.JwtException ex) {
            log.warn("Failed parsing token", ex);
            throw new TokenException("Token invalid", ex);
        }
    }

    private static boolean hasRequiredClaims(Jwt jwt, TokenConverter<? extends AccessToken> converter) {
        final Set<String> requiredClaimNames = converter.requiredClaimNames();

        final List<String> missingClaims = requiredClaimNames.stream()
                .filter(claim -> !jwt.hasClaim(claim))
                .collect(Collectors.toList());

        if (!missingClaims.isEmpty()) {
            log.warn("Not all claims for converter '{}' are found in jwt, missing {}", converter.getClass(), missingClaims);
        }

        return missingClaims.isEmpty();
    }

}

package nl.edsn.common.shared.security.token;

import java.time.Instant;
import java.util.List;


public class ConsentAccessToken extends AccessToken {
    private String consentId;
    private List<String> eans;

    public ConsentAccessToken(final String consumingServiceId,
                              final String consentId,
                              final List<AccessTokenResource> resources,
                              final List<String> eans,
                              final List<String> scope,
                              final Instant expiresAt) {
        super(consumingServiceId, resources, scope, expiresAt);
        this.consentId = consentId;
        this.eans = eans;
    }

    public ConsentAccessToken() {
    }

    public String getConsentId() {
        return this.consentId;
    }

    public List<String> getEans() {
        return this.eans;
    }

    public void setConsentId(String consentId) {
        this.consentId = consentId;
    }

    public void setEans(List<String> eans) {
        this.eans = eans;
    }

    public String toString() {
        return "ConsentAccessToken(consentId=" + this.getConsentId() + ", eans=" + this.getEans() + ")";
    }

    public boolean equals(final Object o) {
        if (o == this) {
            return true;
        }
        if (!(o instanceof ConsentAccessToken)) {
            return false;
        }
        final ConsentAccessToken other = (ConsentAccessToken) o;
        if (!other.canEqual((Object) this)) {
            return false;
        }
        if (!super.equals(o)) {
            return false;
        }
        final Object this$consentId = this.getConsentId();
        final Object other$consentId = other.getConsentId();
        if (this$consentId == null ? other$consentId != null : !this$consentId.equals(other$consentId)) {
            return false;
        }
        final Object this$eans = this.getEans();
        final Object other$eans = other.getEans();
        if (this$eans == null ? other$eans != null : !this$eans.equals(other$eans)) {
            return false;
        }
        return true;
    }

    protected boolean canEqual(final Object other) {
        return other instanceof ConsentAccessToken;
    }

    public int hashCode() {
        final int PRIME = 59;
        int result = super.hashCode();
        final Object $consentId = this.getConsentId();
        result = result * PRIME + ($consentId == null ? 43 : $consentId.hashCode());
        final Object $eans = this.getEans();
        result = result * PRIME + ($eans == null ? 43 : $eans.hashCode());
        return result;
    }
}