/*
    * 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 2011-2016 ForgeRock AS.
   */
  
  package org.forgerock.json;
  
  import static org.forgerock.json.JsonValueFunctions.pointer;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  
  import org.forgerock.util.Reject;
  
  /**
   * Processes partial modifications to JSON values.
   */
  public final class JsonPatch {
  
      /**
       * Internet media type for the JSON Patch format.
       */
      public static final String MEDIA_TYPE = "application/json-patch";
  
      /**
       * Path to the "op" attribute of a patch entry. Required.
       */
      public static final JsonPointer OP_PTR = new JsonPointer("/op");
  
      /**
       * Path to the "path" attribute of a patch entry. Required.
       */
      public static final JsonPointer PATH_PTR = new JsonPointer("/path");
  
      /**
       * Path to the "from" attribute of a patch entry. Required only for "move" and "copy"
       * operations. Ignored for all others.
       */
      public static final JsonPointer FROM_PTR = new JsonPointer("/from");
  
      /**
       * Path to the "value" attribute of a patch entry. Required for "add", "replace" and
       * "test" operations; Ignored for all others.
       *
       * This is public to allow for alternate implementations of {@link JsonPatchValueTransformer}.
       */
      public static final JsonPointer VALUE_PTR = new JsonPointer("/value");
  
      /**
       * Default transform for patch values; Conforms to RFC6902.
       */
      private static final JsonPatchValueTransformer DEFAULT_TRANSFORM =
          new JsonPatchValueTransformer() {
              public Object getTransformedValue(JsonValue target, JsonValue op) {
                  if (op.get(JsonPatch.VALUE_PTR) != null) {
                      return op.get(JsonPatch.VALUE_PTR).getObject();
                  }
                  throw new JsonValueException(op, "expecting a value member");
              }
          };
  
      /**
       * Compares two JSON values, and produces a JSON Patch value, which contains the
       * operations necessary to modify the {@code original} value to arrive at the
       * {@code target} value.
       *
       * @param original the original value.
       * @param target the intended target value.
       * @return the resulting JSON Patch value.
       * @throws NullPointerException if either of {@code original} or {@code target} are {@code null}.
       */
      public static JsonValue diff(JsonValue original, JsonValue target) {
          final List<Object> result = new ArrayList<>();
          if (differentTypes(original, target)) { // different types cause a replace
              result.add(op("replace", original.getPointer(), target));
          } else if (original.isMap()) {
              for (String key : original.keys()) {
                  if (target.isDefined(key)) { // target also has the property
                      JsonValue diff = diff(original.get(key), target.get(key)); // recursively compare properties
                      if (diff.size() > 0) {
                          result.addAll(diff.asList()); // add diff results
                      }
                  } else { // property is missing in target
                      result.add(op("remove", original.getPointer().child(key), null));
                  }
              }
             for (String key : target.keys()) {
                 if (!original.isDefined(key)) { // property is in target, not in original
                     result.add(op("add", original.getPointer().child(key), target.get(key)));
                 }
             }
         } else if (original.isList()) {
             boolean replace = false;
             if (original.size() != target.size()) {
                 replace = true;
             } else {
                 Iterator<JsonValue> i1 = original.iterator();
                 Iterator<JsonValue> i2 = target.iterator();
                 while (i1.hasNext() && i2.hasNext()) {
                     if (diff(i1.next(), i2.next()).size() > 0) { // recursively compare elements
                         replace = true;
                         break;
                     }
                 }
             }
             if (replace) { // replace list entirely
                 result.add(op("replace", original.getPointer(), target));
             }
         } else if (!original.isNull() && !original.getObject().equals(target.getObject())) { // simple value comparison
             result.add(op("replace", original.getPointer(), target));
         }
         return new JsonValue(result);
     }
 
     /**
      * Compares two JSON values, and returns whether the two objects are identical.  Fails fast in that a
      * {@code false} is returned as soon as a difference is detected.
      *
      * @param value a value.
      * @param other another value.
      * @return whether the two inputs are equal.
      * @throws NullPointerException if either of {@code value} or {@code other} are {@code null}.
      * @throws IllegalArgumentException if the {@link JsonValue} contains non-JSON primitive values.
      */
     public static boolean isEqual(JsonValue value, JsonValue other) {
         Reject.ifFalse(isJsonPrimitive(value) && isJsonPrimitive(other),
                 "JsonPatch#isEqual only supports recognizable JSON primitives");
         if (differentTypes(value, other)) {
             return false;
         }
         if (value.size() != other.size()) {
             return false;
         }
         if (value.isMap()) {
             // only need test that other has same keys with same values as value as they are the same size at this point
             for (String key : value.keys()) {
                 if (!other.isDefined(key) // other is missing the property
                             || !isEqual(value.get(key), other.get(key))) { // recursively compare properties
                     return false;
                 }
             }
         } else if (value.isList()) {
             Iterator<JsonValue> i1 = value.iterator();
             Iterator<JsonValue> i2 = other.iterator();
             while (i1.hasNext() && i2.hasNext()) {
                 if (!isEqual(i1.next(), i2.next())) { // recursively compare elements
                     return false;
                 }
             }
         } else if (!value.isNull() && !value.getObject().equals(other.getObject())) { // simple value comparison
             return false;
         }
         return true;
     }
 
     private static boolean isJsonPrimitive(JsonValue value) {
         return value.isNull() || value.isBoolean() || value.isMap() || value.isList() || value.isNumber()
                 || value.isString();
     }
 
     /**
      * Returns {@code true} if the type contained by {@code v1} is different than the type
      * contained by {@code v2}.
      * <p>
      * Note: If an unexpected (non-JSON) type is encountered, this method returns
      * {@code true}, triggering a change in the resulting patch.
      */
     private static boolean differentTypes(JsonValue v1, JsonValue v2) {
         return !(v1.isNull() && v2.isNull())
                 && !(v1.isMap() && v2.isMap())
                 && !(v1.isList() && v2.isList())
                 && !(v1.isString() && v2.isString())
                 && !(v1.isNumber() && v2.isNumber())
                 && !(v1.isBoolean() && v2.isBoolean());
     }
 
     private static HashMap<String, Object> op(String op, JsonPointer pointer, JsonValue value) {
         HashMap<String, Object> result = new HashMap<String, Object>();
         result.put(OP_PTR.leaf(), op);
         result.put(PATH_PTR.leaf(), pointer.toString());
         if (value != null) {
             result.put(VALUE_PTR.leaf(), value.copy().getObject());
         }
         return result;
     }
 
     /**
      * Applies a set of modifications in a JSON patch value to an original value, resulting
      * in the intended target value. In the event of a failure, this method does not revert
      * any modifications applied up to the point of failure.
      *
      * @param original the original value on which to apply the modifications.
      * @param patch the JSON Patch value, specifying the modifications to apply to the original value.
      * @throws JsonValueException if application of the patch failed.
      */
     public static void patch(JsonValue original, JsonValue patch) {
         patch(original, patch, DEFAULT_TRANSFORM);
     }
 
     /**
      * Applies a set of modifications in a JSON patch value to an original value, resulting
      * in the intended target value. In the event of a failure, this method does not revert
      * any modifications applied up to the point of failure.
      *
      * @param original the original value on which to apply the modifications.
      * @param patch the JSON Patch value, specifying the modifications to apply to the original value.
      * @param transform a custom transform used to determine the target value.
      * @throws JsonValueException if application of the patch failed.
      */
     public static void patch(JsonValue original, JsonValue patch, JsonPatchValueTransformer transform) {
         for (JsonValue operation : patch.required().expect(List.class)) {
             if (!operation.isDefined("op")) {
                 throw new JsonValueException(operation, "op not specified");
             }
             PatchOperation op = PatchOperation.valueOf(operation.get(OP_PTR));
             if (op == null) {
                 throw new JsonValueException(operation, "invalid op specified");
             }
             op.execute(original, operation, transform);
         }
     }
 
     private enum PatchOperation {
         ADD {
             // http://tools.ietf.org/html/rfc6902#section-4.1
             @Override
             void execute(JsonValue original, JsonValue operation, JsonPatchValueTransformer transform) {
                 JsonPointer modifyPath = operation.get(PATH_PTR).expect(String.class).as(pointer());
                 JsonValue parent = parentValue(modifyPath, original);
                 if (parent == null) {
                     // patch specifies a new root object
                     if (original.getObject() != null) {
                         throw new JsonValueException(operation, "root value already exists");
                     }
                     original.setObject(transform.getTransformedValue(original, operation));
                 } else {
                     try {
                         if (parent.isList()) {
                             try {
                                 // if the path points to an array index then we should insert the value
                                 Integer index = Integer.valueOf(modifyPath.leaf());
                                 parent.add(index, transform.getTransformedValue(original, operation));
                             } catch (Exception e) {
                                 // leaf is not an array index, replace value
                                 parent.add(modifyPath.leaf(), transform.getTransformedValue(original, operation));
                             }
                         } else if (original.get(modifyPath) != null && original.get(modifyPath).isList()) {
                             // modifyPath does not indicate an index, use the whole object
                             JsonValue target = original.get(modifyPath);
                             target.asList().add(transform.getTransformedValue(original, operation));
                         } else {
                             // this will replace the value even if present
                             parent.add(modifyPath.leaf(), transform.getTransformedValue(original, operation));
                         }
                     } catch (JsonException je) {
                         throw new JsonValueException(operation, je);
                     }
                 }
             }
         },
         REMOVE {
             //http://tools.ietf.org/html/rfc6902#section-4.2
             @Override
             void execute(JsonValue original, JsonValue operation, JsonPatchValueTransformer transform) {
                 JsonPointer modifyPath = operation.get(PATH_PTR).expect(String.class).as(pointer());
                 JsonValue parent = parentValue(modifyPath, original);
                 String leaf = modifyPath.leaf();
                 if (parent == null) {
                     // patch specifies root object
                     original.setObject(null);
                 } else {
                     if (!parent.isDefined(leaf)) {
                         throw new JsonValueException(operation, "value to remove not found");
                     }
                     try {
                         parent.remove(leaf);
                     } catch (JsonException je) {
                         throw new JsonValueException(operation, je);
                     }
                 }
             }
         },
         REPLACE {
             //http://tools.ietf.org/html/rfc6902#section-4.3
             @Override
             void execute(JsonValue original, JsonValue operation, JsonPatchValueTransformer transform) {
                 JsonPointer modifyPath = operation.get(PATH_PTR).expect(String.class).as(pointer());
                 JsonValue parent = parentValue(modifyPath, original);
                 if (parent != null) {
                     // replacing a child
                     String leaf = modifyPath.leaf();
                     if (!parent.isDefined(leaf)) {
                         throw new JsonValueException(operation, "value to replace not found");
                     }
                     parent.put(leaf, transform.getTransformedValue(original, operation));
                 } else {
                     // replacing the root value itself
                     original.setObject(transform.getTransformedValue(original, operation));
                 }
             }
         },
         MOVE {
             // http://tools.ietf.org/html/rfc6902#section-4.4
             @Override
             void execute(JsonValue original, JsonValue operation, JsonPatchValueTransformer transform) {
                 JsonPointer sourcePath = operation.get(FROM_PTR).expect(String.class).as(pointer());
                 JsonPointer destPath = operation.get(PATH_PTR).expect(String.class).as(pointer());
                 JsonValue sourceParent = parentValue(sourcePath, original);
                 if (sourceParent == null) {
                     throw new JsonValueException(operation, "cannot move root object");
                 }
                 JsonValue object = sourceParent.get(sourcePath.leaf());
                 JsonValue destParent = parentValue(destPath, original);
                 if (destParent == null) {
                     // replacing root object with moved object
                     original.setObject(object);
                 } else {
                     sourceParent.remove(sourcePath.leaf());
                     destParent.put(destPath.leaf(), object);
                 }
             }
         },
         COPY {
             // http://tools.ietf.org/html/rfc6902#section-4.5
             @Override
             void execute(JsonValue original, JsonValue operation, JsonPatchValueTransformer transform) {
                 JsonPointer sourcePath = operation.get(FROM_PTR).expect(String.class).as(pointer());
                 JsonPointer destPath = operation.get(PATH_PTR).expect(String.class).as(pointer());
                 JsonValue sourceParent = parentValue(sourcePath, original);
                 JsonValue object = sourceParent.get(sourcePath.leaf());
                 JsonValue destParent = parentValue(destPath, original);
                 if (destParent == null) {
                     // replacing root object with copied object
                     original.setObject(object);
                 } else {
                     destParent.put(destPath.leaf(), object);
                 }
             }
         },
         TEST {
             // http://tools.ietf.org/html/rfc6902#section-4.6
             @Override
             void execute(JsonValue original, JsonValue operation, JsonPatchValueTransformer transform) {
                 JsonPointer testPath = operation.get(PATH_PTR).expect(String.class).as(pointer());
                 JsonValue testTarget = parentValue(testPath, original).get(testPath.leaf());
                 JsonValue testValue = new JsonValue(transform.getTransformedValue(original, operation));
 
                 if (diff(testTarget, testValue).asList().size() > 0) {
                     throw new JsonValueException(operation, "test failed");
                 }
             }
         };
 
         void execute(JsonValue original, JsonValue operation, JsonPatchValueTransformer transform) {
             throw new JsonValueException(original, "unsupported operation");
         }
 
         static PatchOperation valueOf(JsonValue op) {
             return valueOf(op.expect(String.class).asString().toUpperCase());
         }
     }
 
     /**
      * Returns the parent value of the value identified by the JSON pointer.
      *
      * @param pointer the pointer to the value whose parent value is to be returned.
      * @param target the JSON value against which to resolve the JSON pointer.
      * @return the parent value of the value identified by the JSON pointer.
      * @throws JsonException if the parent value could not be found.
      */
     private static JsonValue parentValue(JsonPointer pointer, JsonValue target) {
         JsonValue result = null;
         JsonPointer parent = pointer.parent();
         if (parent != null) {
             result = target.get(parent);
             if (result == null) {
                 throw new JsonException("parent value not found");
             }
         }
         return result;
     }
 
     // prevent construction
     private JsonPatch() {
     }
 }