package uk.co.datumedge.hamcrest.json;

 import static uk.co.datumedge.hamcrest.json.JSONArrayComparatorFactory.jsonArrayComparison;

 import static uk.co.datumedge.hamcrest.json.JSONAssertComparator.modalComparatorFor;

 import static uk.co.datumedge.hamcrest.json.JSONObjectComparatorFactory.jsonObjectComparison;

 import static uk.co.datumedge.hamcrest.json.StringComparatorFactory.stringComparison;

 import java.io.PrintWriter;

 import java.io.StringWriter;

 import org.hamcrest.Description;

 import org.hamcrest.Factory;

 import org.hamcrest.TypeSafeDiagnosingMatcher;

 import org.json.JSONArray;

 import org.json.JSONException;

 import org.json.JSONObject;

 /**

  * Matcher that asserts that one JSON document is the same as another.

  *

  * @param <T>

  *            the type of the JSON document. This is typically {@code JSONObject}, {@code JSONArray} or {@code String}.

  */

 public final class SameJSONAs<T> extends TypeSafeDiagnosingMatcher<T> {

         private final T expected;

         private final JSONModalComparator<T> comparator;

         public SameJSONAs(T expected, JSONModalComparator<T> comparator) {

                 this.expected = expected;

                 this.comparator = comparator;

         }

         @Override

         public void describeTo(Description description) {

                 description.appendValue(expected.toString());

         }

         @Override

         protected boolean matchesSafely(T actual, Description mismatchDescription) {

                 try {

                         JSONComparisonResult result = comparator.compare(expected, actual);

                         if (result.failed()) {

                                 mismatchDescription.appendDescriptionOf(result);

                         }

                         return result.passed();

                 } catch (JSONException e) {

                         StringWriter out = new StringWriter();

                         e.printStackTrace(new PrintWriter(out));

                         mismatchDescription.appendText(out.toString());

                         return false;

                 }

         }

         /**

          * Creates a matcher that allows any element ordering within JSON arrays. For example,

          * <code>{"fib":[0,1,1,2,3]}</code> will match <code>{"fib":[3,1,0,2,1]}</code>.

          *

          * @return the configured matcher

          */

         public SameJSONAs<T> allowingAnyArrayOrdering() {

                 return new SameJSONAs<T>(expected, comparator.butAllowingAnyArrayOrdering());

         }

         /**

          * Creates a matcher that allows fields not present in the expected JSON document.  For example, if the expected

          * document is

 <pre>{

     "name" : "John Smith",

     "address" : {

         "street" : "29 Acacia Road"

     }

 }</pre>

          * then the following document will match:

 <pre>{

     "name" : "John Smith",

     "age" : 34,

     "address" : {

         "street" : "29 Acacia Road",

         "city" : "Huddersfield"

     }

 }</pre>

          *

          * All array elements must exist in both documents, so the expected document

 <pre>[

     { "name" : "John Smith" }

 ]</pre>

          *  will not match the actual document

 <pre>[

     { "name" : "John Smith" },

     { "name" : "Bob Jones" }

 ]</pre>

          *

          * @return the configured matcher

          */

         public SameJSONAs<T> allowingExtraUnexpectedFields() {

                 return new SameJSONAs<T>(expected, comparator.butAllowingExtraUnexpectedFields());

         }

         /**

          * Creates a matcher that compares {@code JSONObject}s.

          *

          * @param expected the expected {@code JSONObject} instance

          * @return the {@code Matcher} instance

          */

         @Factory

         public static SameJSONAs<JSONObject> sameJSONObjectAs(JSONObject expected) {

                 return new SameJSONAs<JSONObject>(expected, modalComparatorFor(jsonObjectComparison()));

         }

         @Factory

         public static SameJSONAs<JSONObject> sameJSONObjectAs(JSONObject expected, JSONModalComparator<JSONObject> comparator) {

                 return new SameJSONAs<JSONObject>(expected, comparator);

         }

         /**

          * Creates a matcher that compares {@code JSONArray}s.

          *

          * @param expected the expected {@code JSONArray} instance

          * @return the {@code Matcher} instance

          */

         @Factory

         public static SameJSONAs<JSONArray> sameJSONArrayAs(JSONArray expected) {

                 return new SameJSONAs<JSONArray>(expected, modalComparatorFor(jsonArrayComparison()));

         }

         @Factory

         public static SameJSONAs<? super JSONArray> sameJSONArrayAs(JSONArray expected, JSONModalComparator<JSONArray> comparator) {

                 return new SameJSONAs<JSONArray>(expected, comparator);

         }

         /**

          * Creates a matcher that compares JSONObjects or JSONArrays.

          *

          * @param expected the expected JSON document

          * @return the {@code Matcher} instance

          */

         @Factory

         public static SameJSONAs<? super String> sameJSONAs(String expected) {

                 return new SameJSONAs<String>(expected, modalComparatorFor(stringComparison()));

         }

         @Factory

         public static SameJSONAs<? super String> sameJSONAs(String expected, JSONModalComparator<String> comparator) {

                 return new SameJSONAs<String>(expected, comparator);

         }

 }