/*
 * 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 Copyrighted [year] [name of copyright owner]".
 *
 * Copyright 2013-2017 ForgeRock AS.
 */

package org.forgerock.json.jose.jwk;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.forgerock.json.JsonException;
import org.forgerock.json.JsonValue;
import org.forgerock.json.jose.jwt.Algorithm;
import org.forgerock.json.jose.jwt.JWObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.fasterxml.jackson.databind.ObjectMapper;

/**
 * Holds a Set of JWKs.
 */
public class JWKSet extends JWObject {

    private static final Logger logger = LoggerFactory.getLogger(JWKSet.class);

    /**
     * Constructs an empty JWKSet.
     */
    public JWKSet() {
        put("keys", Collections.EMPTY_LIST);
    }

    /**
     * Construct a JWKSet from a single JWK.
     * @param jwk the jwk to construct the set from
     */
    public JWKSet(JWK jwk) {
        if (jwk == null) {
            throw new JsonException("JWK must not be null");
        }
        put("keys", Collections.singletonList(jwk.toJsonValue().asMap()));
    }

    /**
     * Construct a JWKSet from a single JWK.
     * @param jwks contains a list of json web keys
     */
    public JWKSet(JsonValue jwks) {
        if (jwks == null) {
            throw new JsonException("JWK set must not be null");
        }
        put("keys", jwks.expect(List.class));
    }

    /**
     * Construct a JWKSet from a List of JWKs.
     * @param jwkList a list of jwks
     */
    public JWKSet(List<JWK> jwkList) {
        if (jwkList == null) {
            throw new JsonException("The list cannot be null");
        }
        //transform to json, as it's our current way of storing jwks
        List<Map<String, Object>> jwkListAsJson = new ArrayList<>();
        for (JWK jwk : jwkList) {
            jwkListAsJson.add(jwk.toJsonValue().asMap());
        }
        put("keys", jwkListAsJson);
    }

    /**
     * Get the JWKs in the set.
     * @return a list of JWKs
     */
    public List<JWK> getJWKsAsList() {
        List<JWK> listOfJWKs = new LinkedList<>();
        JsonValue jwks = get("keys");
        Iterator<JsonValue> i = jwks.iterator();
        while (i.hasNext()) {
            listOfJWKs.add(JWK.parse(i.next()));
        }
        return listOfJWKs;
    }

    /**
     * Get the JWKs in the set.
     * @return a list of JWKs as JsonValues
     */
    public JsonValue getJWKsAsJsonValue() {
        return get("keys");
    }

    /**
     * Converts a json string to a jsonValue.
     * @param json a json jwk set object string
     * @return a json value of the son string
     * @throws JsonException if unable to parse
     */
    protected static JsonValue toJsonValue(String json) {
        ObjectMapper mapper = new ObjectMapper();
        try {
            return new JsonValue(mapper.readValue(json, Map.class));
        } catch (IOException e) {
            throw new JsonException("Failed to parse json", e);
        }
    }

    /**
     * Parses a JWKSet object from a string json object.
     * @param json string json object
     * @return a JWKSet
     */
    public static JWKSet parse(String json) {
        JsonValue jwkSet = new JsonValue(toJsonValue(json));
        return parse(jwkSet);
    }

    /**
     * Parses a JWKSet object from a jsonValue object.
     * @param json an JsonValue object
     * @return a JWKSet
     */
    public static JWKSet parse(JsonValue json) {
        if (json == null) {
            throw new JsonException("Cant parse JWKSet. No json data.");
        }
        return new JWKSet(json.get("keys"));
    }

    /**
     * Prints the JWK Set as a json string.
     * @return A String representing JWK
     */
    public String toJsonString() {
        return super.toString();
    }

    /**
     * Search for a JWK that matches the algorithm and the key usage.
     *
     * @param algorithm the algorithm needed
     * @param keyUse the key usage. If null, only the algorithm will be used as a search criteria.
     * @return A jwk that matches the search criteria. If no JWK found for the key usage, then it searches for a JWK
     * without key usage defined. If still no JWK found, then returns null.
     */
    public JWK findJwk(Algorithm algorithm, KeyUse keyUse) {
        //First, we try to find a JWK that matches the keyUse
        for (JWK jwk : getJWKsAsList()) {
            try {
                if (algorithm.getJwaAlgorithmName().equalsIgnoreCase(jwk.getAlgorithm()) && (keyUse == jwk.getUse())) {
                    return jwk;
                }
            } catch (IllegalArgumentException e) {
                // We raise a warning as the JWKs could be the client one, with some non-compliant JWK.
                logger.warn("Can't load JWK with kid'" + jwk.getKeyId() + "'", e);
            }
        }

        //At this point, no jwk was found. We can try to find a JWK without a keyUse now
        return keyUse != null ? findJwk(algorithm, null) :  null;
    }

    /**
     * Search for a JWK that matches the kid.
     *
     * @param kid Key ID
     * @return A jwk that matches the kid. If no JWK found, returns null
     */
    public JWK findJwk(String kid) {
        for (JWK jwk : getJWKsAsList()) {
            if (kid.equals(jwk.getKeyId())) {
                return jwk;
            }
        }
        return null;
    }
}