/*
    * The contents of this file are subject to the terms of the Common Development and
    * Distribution License (the License). You may not use this file except in compliance with the
    * License.
    *
    * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
    * specific language governing permission and limitations under the License.
    *
    * When distributing Covered Software, include this CDDL Header Notice in each file and include
   * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
   * Header, with the fields enclosed by brackets [] replaced by your own identifying
   * information: "Portions copyright [year] [name of copyright owner]".
   *
   * Copyright 2013-2016 ForgeRock AS.
   */
  
  package org.forgerock.json.jose.jwt;
  
  import static java.util.Collections.*;
  import static org.forgerock.json.jose.jwt.JwtClaimsSetKey.*;
  
  import java.net.URI;
  import java.util.ArrayList;
  import java.util.Date;
  import java.util.List;
  import java.util.Map;
  
  import org.forgerock.json.JsonValue;
  import org.forgerock.json.jose.utils.IntDate;
  import org.forgerock.json.jose.utils.StringOrURI;
  
  /**
   * An implementation that holds a JWT's Claims Set.
   * <p>
   * Provides methods to set claims for all the reserved claim names as well as custom claims.
   *
   * @since 2.0.0
   */
  public class JwtClaimsSet extends JWObject implements Payload {
  
      /**
       * Constructs a new, empty JwtClaimsSet.
       */
      public JwtClaimsSet() {
      }
  
      /**
       * Constructs a new JwtClaimsSet, with its claims set to the contents of the given Map.
       *
       * @param claims A Map containing the claims to be set in the Claims Set.
       */
      public JwtClaimsSet(Map<String, Object> claims) {
          setClaims(claims);
      }
  
      /**
       * Gets the type of the contents of the Claims Set.
       * <p>
       * The values used for this claim SHOULD come from the same value space as the JWT header parameter "typ",
       * with the same rules applying.
       *
       * @param type The Claims Set content type.
       */
      public void setType(String type) {
          put(TYP.value(), type);
      }
  
      /**
       * Gets the type of the contents of the Claims Set.
       * <p>
       * The values used for this claim SHOULD come from the same value space as the JWT header parameter "typ",
       * with the same rules applying.
       *
       * @return The Claims Set content type.
       */
      public String getType() {
          return get(TYP.value()).asString();
      }
  
      /**
       * Sets the unique ID of the JWT.
       *
       * @param jwtId The JWT's ID.
       */
      public void setJwtId(String jwtId) {
          put(JTI.value(), jwtId);
      }
  
      /**
       * Gets the unique ID of the JWT.
       *
       * @return The JWT's ID or {@code null} if claim not present.
       */
      public String getJwtId() {
          return get(JTI.value()).asString();
      }
  
      /**
       * Sets the issuer this JWT was issued by.
      * <p>
      * The given issuer can be any arbitrary string without any ":" characters, if the string does contain a ":"
      * character then it must be a valid URI.
      *
      * @param issuer The JWT's issuer.
      */
     public void setIssuer(String issuer) {
         StringOrURI.validateStringOrURI(issuer);
         put(ISS.value(), issuer);
     }
 
     /**
      * Sets the issuer this JWT was issued by.
      *
      * @param issuer The JWT's issuer.
      */
     public void setIssuer(URI issuer) {
         put(ISS.value(), issuer.toString());
     }
 
     /**
      *
      * Gets the issuer this JWT was issued by.
      *
      * @return The JWT's issuer or {@code null} if claim not present.
      */
     public String getIssuer() {
         return get(ISS.value()).asString();
     }
 
     /**
      * Sets the subject this JWT is issued to.
      * <p>
      * The given subject can be any arbitrary string without any ":" characters, if the string does contain a ":"
      * character then it must be a valid URI.
      *
      * @param subject The JWT's principal.
      * @see #setSubject(java.net.URI)
      */
     public void setSubject(String subject) {
         StringOrURI.validateStringOrURI(subject);
         put(SUB.value(), subject);
     }
 
     /**
      * Sets the subject this JWT is issued to.
      *
      * @param subject The JWT's principal.
      * @see #setSubject(String)
      */
     public void setSubject(URI subject) {
         put(SUB.value(), subject.toString());
     }
 
     /**
      * Gets the subject this JWT is issued to.
      *
      * @return The JWT's principal or {@code null} if claim not present.
      */
     public String getSubject() {
         return get(SUB.value()).asString();
     }
 
     /**
      * Adds an entry to the JWT's intended audience list, in the Claims Set.
      * <p>
      * The given audience can be any arbitrary string without any ":" characters, if the string does contain a ":"
      * character then it must be a valid URI.
      *
      * @param audience The JWT's intended audience.
      * @see #addAudience(java.net.URI)
      */
     public void addAudience(String audience) {
         StringOrURI.validateStringOrURI(audience);
         addAudienceWithTypeCheck(audience);
     }
 
     /**
      * Adds an entry to the JWT's intended audience list, in the Claims Set.
      *
      * @param audience The JWT's intended audience.
      * @see #addAudience(String)
      */
     public void addAudience(URI audience) {
         addAudienceWithTypeCheck(audience.toString());
     }
 
     private void addAudienceWithTypeCheck(String audience) {
         JsonValue audienceClaim = get(AUD.value());
 
         if (audienceClaim.isNull()) {
             put(AUD.value(), audience);
         } else if (audienceClaim.isList()) {
             audienceClaim.asList().add(audience);
         } else {
             List<String> audienceList = new ArrayList<>();
             audienceList.add(audienceClaim.asString());
             audienceList.add(audience);
             put(AUD.value(), audienceList);
         }
     }
 
     /**
      * Gets the intended audience for the JWT from the Claims Set.
      *
      * @return The JWT's intended audience or {@code null} if claim not present.
      */
     public List<String> getAudience() {
         JsonValue audience = get(AUD.value());
         if (audience.isNull()) {
             return null;
         } else if (audience.isList()) {
             return audience.asList(String.class);
         } else {
             return singletonList(audience.asString());
         }
     }
 
     /**
      * Sets the time the JWT was issued at, in the Claims Set.
      * <p>
      * The given date will be converted into an {@link IntDate} to be stored in the JWT Claims Set.
      *
      * @param issuedAtTime The JWT's issued at time.
      */
     public void setIssuedAtTime(Date issuedAtTime) {
         put(IAT.value(), IntDate.toIntDate(issuedAtTime));
     }
 
     /**
      * Sets the time the JWT was issued at, in the Claims Set.
      * <p>
      * This method takes a long representation of the number of <strong>seconds</strong> have passed since epoch.
      *
      * @param issuedAtTime The JWT's issued at time as a long in seconds.
      * @see #setIssuedAtTime(java.util.Date)
      */
     private void setIssuedAtTime(long issuedAtTime) {
         put(IAT.value(), issuedAtTime);
     }
 
     /**
      * Gets the time the JWT was issued at, from the Claims Set.
      *
      * @return The JWT's issued at time or {@code null} if claim not present.
      */
     public Date getIssuedAtTime() {
         return getDate(IAT.value());
     }
 
     /**
      * Sets the time the JWT is not allowed to be processed before, in the Claims Set.
      * <p>
      * The given date will be converted into an {@link IntDate} to be stored in the JWT Claims Set.
      *
      * @param notBeforeTime The JWT's not before time.
      */
     public void setNotBeforeTime(Date notBeforeTime) {
         put(NBF.value(), IntDate.toIntDate(notBeforeTime));
     }
 
     /**
      * Sets the time the JWT is not allowed to be processed before, in the Claims Set.
      * <p>
      * The method takes a long representation of the number of <strong>seconds</strong> have passed since epoch.
      *
      * @param notBeforeTime The JWT's not before time.
      * @see #setNotBeforeTime(java.util.Date)
      */
     private void setNotBeforeTime(long notBeforeTime) {
         put(NBF.value(), notBeforeTime);
     }
 
     /**
      * Gets the time the JWT is not allowed to be processed before, from the Claims Set.
      *
      * @return The JWT's not before time or {@code null} if claim not present.
      */
     public Date getNotBeforeTime() {
         return getDate(NBF.value());
     }
 
     /**
      * Sets the expiration time of the JWT in the Claims Set.
      * <p>
      * The given date will be converted into an {@link IntDate} to be stored in the JWT Claims Set.
      *
      * @param expirationTime The JWT's expiration time.
      */
     public void setExpirationTime(Date expirationTime) {
         put(EXP.value(), IntDate.toIntDate(expirationTime));
     }
 
     /**
      * Sets the expiration time of the JWT in the Claims Set.
      * <p>
      * This method takes a long representation of the number of <strong>seconds</strong> have passed since epoch.
      *
      * @param expirationTime The JWT's expiration time as a long in seconds.
      * @see #setExpirationTime(java.util.Date)
      */
     private void setExpirationTime(long expirationTime) {
         put(EXP.value(), expirationTime);
     }
 
     /**
      * Gets the expiration time of the JWT from the Claims Set.
      *
      * @return The JWT's expiration time or {@code null} if claim not present.
      */
     public Date getExpirationTime() {
         return getDate(EXP.value());
     }
 
     /**
      * Sets a claim with the specified name and value.
      * <p>
      * If the key matches one of the reserved claim names, then the relevant <tt>set</tt> method is called to set that
      * claim with the specified name and value.
      *
      * @param key The claim name.
      * @param value The claim value.
      */
     public void setClaim(String key, Object value) {
 
         JwtClaimsSetKey claimsSetKey = getClaimSetKey(key.toUpperCase());
 
         switch (claimsSetKey) {
         case TYP: {
             checkValueIsOfType(value, String.class);
             setType((String) value);
             break;
         }
         case JTI: {
             checkValueIsOfType(value, String.class);
             setJwtId((String) value);
             break;
         }
         case ISS: {
             if (isValueOfType(value, URI.class)) {
                 setIssuer((URI) value);
             } else {
                 checkValueIsOfType(value, String.class);
                 setIssuer((String) value);
             }
             break;
         }
         case SUB: {
             if (isValueOfType(value, URI.class)) {
                 setSubject((URI) value);
             } else {
                 checkValueIsOfType(value, String.class);
                 setSubject((String) value);
             }
             break;
         }
         case AUD: {
             if (isValueOfType(value, List.class)) {
                 List<?> audienceList = (List<?>) value;
                 for (Object audience : audienceList) {
                     if (isValueOfType(audience, URI.class)) {
                         addAudience((URI) audience);
                     } else {
                         checkValueIsOfType(audience, String.class);
                         addAudience((String) audience);
                     }
                 }
             } else {
                 if (isValueOfType(value, URI.class)) {
                     addAudience((URI) value);
                 } else {
                     checkValueIsOfType(value, String.class);
                     addAudience((String) value);
                 }
             }
             break;
         }
         case IAT: {
             if (isValueOfType(value, Number.class)) {
                 setIssuedAtTime(((Number) value).longValue());
             } else {
                 checkValueIsOfType(value, Date.class);
                 setIssuedAtTime((Date) value);
             }
             break;
         }
         case NBF: {
             if (isValueOfType(value, Number.class)) {
                 setNotBeforeTime(((Number) value).longValue());
             } else {
                 checkValueIsOfType(value, Date.class);
                 setNotBeforeTime((Date) value);
             }
             break;
         }
         case EXP: {
             if (isValueOfType(value, Number.class)) {
                 setExpirationTime(((Number) value).longValue());
             } else {
                 checkValueIsOfType(value, Date.class);
                 setExpirationTime((Date) value);
             }
             break;
         }
         default: {
             put(key, value);
         }
         }
     }
 
     /**
      * Sets claims using the values contained in the specified map.
      *
      * @param claims The Map to use to set the claims.
      */
     public void setClaims(Map<String, Object> claims) {
         for (String key : claims.keySet()) {
             setClaim(key, claims.get(key));
         }
     }
 
     /**
      * Gets a claim value for the specified key.
      * <p>
      * If the key matches one of the reserved claim names, then the relevant <tt>get</tt> method is called to get that
      * claim value.
      *
      * @param key The claim name.
      * @return The value stored against the claim name.
      */
     public Object getClaim(String key) {
 
         JwtClaimsSetKey claimsSetKey = getClaimSetKey(key.toUpperCase());
 
         Object value;
 
         switch (claimsSetKey) {
         case TYP: {
             value = getType();
             break;
         }
         case JTI: {
             value = getJwtId();
             break;
         }
         case ISS: {
             value = getIssuer();
             break;
         }
         case SUB: {
             value = getSubject();
             break;
         }
         case AUD: {
             value = getAudience();
             break;
         }
         case IAT: {
             value = getIssuedAtTime();
             break;
         }
         case NBF: {
             value = getNotBeforeTime();
             break;
         }
         case EXP: {
             value = getExpirationTime();
             break;
         }
         default: {
             value = get(key).getObject();
         }
         }
 
         return value;
     }
 
     /**
      * Gets a claim value for the specified claim name and then casts it to the specified type.
      *
      * @param key The claim name.
      * @param clazz The class of the required type.
      * @param <T> The required type for the claim value.
      * @return The value stored against the claim name.
      * @see #getClaim(String)
      */
     public <T> T getClaim(String key, Class<T> clazz) {
         return clazz.cast(getClaim(key));
     }
 
     /**
      * Builds the JWT's Claims Set into a <code>String</code> representation of a JSON object.
      *
      * @return A JSON string.
      */
     public String build() {
         return toString();
     }
 
     /**
      * Returns the specified item value as a {@link Date}. If no such member value exists, then a JSON value containing
      * {@code null} is returned.
      *
      * @param key the {@code Map} key identifying the item to return.
      * @return a {@link Date} representing the value or {@code null}.
      */
     private Date getDate(final String key) {
         final JsonValue value = get(key);
         return value.isNull() ? null : IntDate.fromIntDate(value.asLong());
     }
 }