/*
 * Copyright 2011 Google Inc.
 * 
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not
 * use this file except in compliance with the License. You may obtain a copy of
 * the License at
 * 
 * http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.web.bindery.autobean.shared;

import com.google.web.bindery.autobean.gwt.client.impl.JsoSplittable;
import com.google.web.bindery.autobean.shared.impl.AutoBeanCodexImpl;
import com.google.web.bindery.autobean.shared.impl.AutoBeanCodexImpl.Coder;
import com.google.web.bindery.autobean.shared.impl.AutoBeanCodexImpl.EncodeState;
import com.google.web.bindery.autobean.shared.impl.SplittableList;
import com.google.web.bindery.autobean.shared.impl.SplittableSimpleMap;
import com.google.web.bindery.autobean.shared.impl.StringQuoter;
import com.google.gwt.core.client.GWT;
import com.google.gwt.junit.client.GWTTestCase;

import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

/**
 * Tests for the underlying Splittable implementation. This test class is not
 * indicative of code that users would write, it's simply doing spot-checks of
 * functionality that AbstractAutoBean depends on.
 */
public class SplittableTest extends GWTTestCase {

  /**
   * 
   */
  private static final EncodeState testState = EncodeState.forTesting();

  @Override
  public String getModuleName() {
    return "com.google.web.bindery.autobean.AutoBean";
  }

  public void testBasicProperties() {
    Splittable data = StringQuoter.split("{\"a\":true, \"b\":3, \"c\":\"string\", \"d\":null}");
    assertTrue("isBoolean", data.get("a").isBoolean());
    assertTrue("asBoolean", data.get("a").asBoolean());
    assertTrue("isNumber", data.get("b").isNumber());
    assertEquals(3.0, data.get("b").asNumber());
    assertTrue("isString", data.get("c").isString());
    assertEquals("string", data.get("c").asString());
    assertTrue("isNull", data.isNull("d"));
    assertNull("should be null", data.get("d"));
  }

  /**
   * Ensure that hashcodes don't leak into the payload.
   */
  public void testHashCode() {
    Splittable data = StringQuoter.split("{\"a\":\"b\"}");
    int hash = data.hashCode();
    String payload = data.getPayload();
    assertFalse(payload, payload.contains("$H"));
    assertFalse(payload, payload.contains(String.valueOf(hash)));
    assertEquals(hash, data.hashCode());
  }

  /**
   * Splittables are implemented by a couple of different concrete types. We'll
   * use this method to make sure that the correct implementation type is being
   * used in various circumstances.
   */
  public void testImplementationChoice() {
    Splittable s = StringQuoter.split("[1,false,\"true\"]");
    if (GWT.isScript()) {
      assertTrue("s should be JsoSplittable", s instanceof JsoSplittable);
      assertTrue("s[0] should be JsoSplittable", s.get(0) instanceof JsoSplittable);
      assertTrue("s[1] should be JsoSplittable", s.get(1) instanceof JsoSplittable);
      assertTrue("s[2] should be JsoSplittable", s.get(2) instanceof JsoSplittable);
    } else {
      // Using the same types in both pure-JRE and DevMode to avoid JSNI
      // overhead
      assertTrue("s should be JsonSplittable", s.getClass().getName().endsWith("JsonSplittable"));
      assertTrue("s[0] should be JsonSplittable", s.get(0).getClass().getName().endsWith(
          "JsonSplittable"));
      assertTrue("s[1] should be JsonSplittable", s.get(1).getClass().getName().endsWith(
          "JsonSplittable"));
      assertTrue("s[2] should be JsonSplittable", s.get(2).getClass().getName().endsWith(
          "JsonSplittable"));
    }
  }

  public void testIndexed() {
    Splittable s = StringQuoter.createIndexed();
    assertTrue(s.isIndexed());
    assertFalse(s.isKeyed());
    assertFalse(s.isString());
    assertEquals(0, s.size());

    string("foo").assign(s, 0);
    string("bar").assign(s, 1);
    string("baz").assign(s, 2);

    assertEquals(3, s.size());
    assertEquals("[\"foo\",\"bar\",\"baz\"]", s.getPayload());

    string("quux").assign(s, 1);
    assertEquals("[\"foo\",\"quux\",\"baz\"]", s.getPayload());

    Splittable s2 = s.deepCopy();
    assertNotSame(s, s2);
    assertEquals(s.size(), s2.size());
    for (int i = 0, j = s.size(); i < j; i++) {
      assertEquals(s.get(i).asString(), s2.get(i).asString());
    }

    s.setSize(2);
    assertEquals(2, s.size());
    assertEquals("[\"foo\",\"quux\"]", s.getPayload());

    // Make sure reified values aren't in the payload
    Object o = new Object();
    s.setReified("reified", o);
    assertFalse(s.getPayload().contains("reified"));
    assertFalse(s.getPayload().contains("__s"));
    assertSame(o, s.getReified("reified"));
  }

  public void testKeyed() {
    Splittable s = StringQuoter.createSplittable();
    assertFalse(s.isIndexed());
    assertTrue(s.isKeyed());
    assertFalse(s.isString());
    assertTrue(s.getPropertyKeys().isEmpty());

    string("bar").assign(s, "foo");
    string("quux").assign(s, "baz");

    // Actual iteration order is undefined
    assertEquals(new HashSet<String>(Arrays.asList("foo", "baz")), new HashSet<String>(s
        .getPropertyKeys()));

    assertFalse(s.isNull("foo"));
    assertTrue(s.isNull("bar"));

    assertEquals("bar", s.get("foo").asString());
    assertEquals("quux", s.get("baz").asString());

    String payload = s.getPayload();
    assertTrue(payload.startsWith("{"));
    assertTrue(payload.endsWith("}"));
    assertTrue(payload.contains("\"foo\":\"bar\""));
    assertTrue(payload.contains("\"baz\":\"quux\""));

    Splittable s2 = s.deepCopy();
    assertNotSame(s, s2);
    assertEquals("bar", s2.get("foo").asString());
    assertEquals("quux", s2.get("baz").asString());

    // Make sure reified values aren't in the payload
    Object o = new Object();
    s.setReified("reified", o);
    assertFalse("Should not see reified in " + s.getPayload(), s.getPayload().contains("reified"));
    assertFalse("Should not see __s in " + s.getPayload(), s.getPayload().contains("__s"));
    assertSame(o, s.getReified("reified"));
  }

  public void testNested() {
    Splittable s = StringQuoter.split("{\"a\":{\"foo\":\"bar\"}}");
    Splittable a = s.get("a");
    assertNotNull(a);
    assertEquals("bar", a.get("foo").asString());
    assertSame(a, s.get("a"));
    assertEquals(a, s.get("a"));
  }

  /**
   * Tests attributes of the {@link Splittable#NULL} field.
   */
  public void testNull() {
    Splittable n = Splittable.NULL;
    if (GWT.isScript()) {
      assertNull(n);
    } else {
      assertNotNull(n);
    }
    assertFalse("boolean", n.isBoolean());
    assertFalse("indexed", n.isIndexed());
    assertFalse("keyed", n.isKeyed());
    assertFalse("string", n.isString());
    assertEquals("null", n.getPayload());
  }

  /**
   * Extra tests in here due to potential to confuse {@code false} and
   * {@code null} values.
   */
  public void testSplittableListBoolean() {
    Coder boolCoder = AutoBeanCodexImpl.valueCoder(Boolean.class);
    Splittable s = StringQuoter.createIndexed();
    bool(false).assign(s, 0);
    assertFalse("0 should not be null", s.isNull(0));
    assertTrue("s[0] should be a boolean", s.get(0).isBoolean());
    assertFalse("s[0] should be false", s.get(0).asBoolean());
    assertNotNull("Null decode", ValueCodex.decode(Boolean.class, s.get(0)));
    Object decodedBoolean = boolCoder.decode(testState, s.get(0));
    assertNotNull("decode should not return null", decodedBoolean);
    assertFalse("decoded value should be false", (Boolean) decodedBoolean);

    bool(true).assign(s, 1);
    assertTrue("s[1] should be a boolean", s.get(1).isBoolean());
    assertTrue("s[1] should be true", s.get(1).asBoolean());
    assertTrue("boolCoder 1", (Boolean) boolCoder.decode(testState, s.get(1)));

    Splittable.NULL.assign(s, 2);
    assertTrue("3 should be null", s.isNull(3));
    assertEquals("payload", "[false,true,null]", s.getPayload());
    List<Boolean> boolList = new SplittableList<Boolean>(s, boolCoder, testState);
    assertEquals("boolList", Arrays.<Boolean> asList(false, true, null), boolList);
  }

  /**
   * Extra tests in here due to potential to confuse 0 and {@code null} values.
   */
  public void testSplittableListNumbers() {
    Coder intCoder = AutoBeanCodexImpl.valueCoder(Integer.class);
    Coder doubleCoder = AutoBeanCodexImpl.valueCoder(Double.class);
    Splittable s = StringQuoter.createIndexed();
    number(0).assign(s, 0);
    assertFalse("0 should not be null", s.isNull(0));
    assertTrue("s[0] should be a number", s.get(0).isNumber());
    assertNotNull("Null decode", ValueCodex.decode(Integer.class, s.get(0)));
    Object decodedInt = intCoder.decode(testState, s.get(0));
    assertNotNull("decode should not return null", decodedInt);
    assertEquals("intCoder 0", Integer.valueOf(0), decodedInt);
    assertEquals("doubleCoder 0", Double.valueOf(0), doubleCoder.decode(testState, s.get(0)));

    number(3.141592).assign(s, 1);
    assertEquals("intCoder 1", Integer.valueOf(3), intCoder.decode(testState, s.get(1)));
    assertEquals("doubleCoder 1", Double.valueOf(3.141592), doubleCoder.decode(testState, s.get(1)));

    number(42).assign(s, 2);
    Splittable.NULL.assign(s, 3);
    assertTrue("3 should be null", s.isNull(3));
    assertEquals("payload", "[0,3.141592,42,null]", s.getPayload());
    List<Double> doubleList = new SplittableList<Double>(s, doubleCoder, testState);
    assertEquals(Double.valueOf(0), doubleList.get(0));
    assertEquals("doubleList", Arrays.<Double> asList(0d, 3.141592, 42d, null), doubleList);

    // Don't share backing data between lists
    s = StringQuoter.split("[0,3.141592,42,null]");
    List<Integer> intList = new SplittableList<Integer>(s, intCoder, testState);
    assertEquals("intList", Arrays.<Integer> asList(0, 3, 42, null), intList);
  }

  public void testSplittableListString() {
    Splittable data = StringQuoter.split("[\"Hello\",\"World\"]");
    SplittableList<String> list =
        new SplittableList<String>(data, AutoBeanCodexImpl.valueCoder(String.class), testState);
    assertEquals(2, list.size());
    assertEquals(Arrays.asList("Hello", "World"), list);
    list.set(0, "Goodbye");
    assertEquals(Arrays.asList("Goodbye", "World"), list);
    assertEquals("[\"Goodbye\",\"World\"]", data.getPayload());
    list.remove(0);
    assertEquals(Arrays.asList("World"), list);
    assertEquals("[\"World\"]", data.getPayload());
    list.add("Wide");
    list.add("Web");
    assertEquals(Arrays.asList("World", "Wide", "Web"), list);
    assertEquals("[\"World\",\"Wide\",\"Web\"]", data.getPayload());
  }

  public void testSplittableMapStringString() {
    Splittable data = StringQuoter.split("{\"foo\":\"bar\",\"baz\":\"quux\",\"isNull\":null}");
    assertTrue("isNull should be null", data.isNull("isNull"));
    assertFalse("isNull should not be undefined", data.isUndefined("isNull"));
    Map<String, String> map =
        new SplittableSimpleMap<String, String>(data, AutoBeanCodexImpl.valueCoder(String.class),
            AutoBeanCodexImpl.valueCoder(String.class), testState);
    assertEquals(3, map.size());
    assertEquals("bar", map.get("foo"));
    assertEquals("quux", map.get("baz"));
    assertTrue("Map should have isNull key", map.containsKey("isNull"));
    assertNull(map.get("isNull"));
    assertFalse("Map should not have unknown key", map.containsKey("unknown"));

    map.put("bar", "foo2");
    assertEquals("foo2", map.get("bar"));
    String payload = data.getPayload();
    assertTrue(payload.contains("\"bar\":\"foo2\""));
    assertTrue(payload.contains("\"isNull\":null"));
  }

  public void testString() {
    Splittable s = string("Hello '\" World!");
    assertFalse(s.isIndexed());
    assertFalse(s.isKeyed());
    assertTrue(s.isString());
    assertEquals("Hello '\" World!", s.asString());
    assertEquals("\"Hello '\\\" World!\"", s.getPayload());
  }

  public void testStringEmpty() {
    Splittable s = string("");
    assertFalse(s.isIndexed());
    assertFalse(s.isKeyed());
    assertTrue(s.isString());
    assertEquals("", s.asString());
    assertEquals("\"\"", s.getPayload());
  }

  private Splittable bool(boolean value) {
    return StringQuoter.split(String.valueOf(value));
  }

  private Splittable number(double number) {
    return StringQuoter.split(String.valueOf(number));
  }

  private Splittable string(String value) {
    return StringQuoter.split(StringQuoter.quote(value));
  }
}