/*
 * 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.gwt.user.server.rpc;

import static com.google.gwt.user.client.rpc.impl.AbstractSerializationStream.RPC_SEPARATOR_CHAR;

import com.google.gwt.user.client.rpc.SerializationException;
import com.google.gwt.user.client.rpc.impl.AbstractSerializationStream;
import com.google.gwt.user.server.rpc.RPCTypeCheckCollectionsTest.TestHashSet;
import com.google.gwt.user.server.rpc.impl.SerializabilityUtil;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.LinkedHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;

/**
 * Generates RPC messages for use in testing server message handling.
 * 
 * This class is designed to make it easy to generate arbitrary messages, in the
 * sense that the elements in the string do not need to match the method's
 * expected elements in any way.
 * 
 */
public class RPCTypeCheckFactory {
  /**
   * A Serialization policy that allows anything to be serialized.
   */
  public static class TestSerializationPolicy extends SerializationPolicy {
    @Override
    public boolean shouldDeserializeFields(Class<?> clazz) {
      return true;
    }

    @Override
    public boolean shouldSerializeFields(Class<?> clazz) {
      return true;
    }

    @SuppressWarnings("unused")
    @Override
    public void validateDeserialize(Class<?> clazz) throws SerializationException {
    }

    @SuppressWarnings("unused")
    @Override
    public void validateSerialize(Class<?> clazz) throws SerializationException {
    }
  }

  private static final TestSerializationPolicy testSerializationPolicy =
      new TestSerializationPolicy();

  /**
   * Generates a HashMap containing HashSet for testing.
   */
  @SuppressWarnings({"rawtypes", "unchecked"})
  public static HashMap<HashSet, Integer> generateTestHashMap() {
    HashMap<HashSet, Integer> result = new HashMap<HashSet, Integer>();
    HashSet entry1 = new HashSet();
    entry1.add(0);
    result.put(entry1, 12345);

    return result;
  }

  /**
   * Generates a HashSet of HashSet for testing.
   */
  @SuppressWarnings({"rawtypes", "unchecked"})
  public static HashSet generateTestHashSet() {
    HashSet result = new HashSet();
    HashSet entry1 = new HashSet();
    HashSet entry2 = new HashSet();
    entry1.add(12345);
    entry1.add(67890);
    result.add(entry1);
    result.add(entry2);

    return result;
  }
  /**
   * Generates a HashSet that contains a HashSet of HashSets for testing.
   */
  @SuppressWarnings({"rawtypes", "unchecked"})
  public static HashSet generateTestHashSetHashSet() {
    HashSet result = new HashSet();
    HashSet entry0 = new HashSet();
    HashSet entry1 = new HashSet();
    HashSet entry2 = new HashSet();
    entry1.add(12345);
    entry2.add(67890);
    entry0.add(entry1);
    entry0.add(entry2);
    result.add(entry0);

    return result;
  }

  /**
   * Generates a IdentityHashMap that contains a HashSet for testing.
   */
  @SuppressWarnings({"rawtypes", "unchecked"})
  public static IdentityHashMap<HashSet, Integer> generateTestIdentityHashMap() {
    IdentityHashMap<HashSet, Integer> result = new IdentityHashMap<HashSet, Integer>();
    HashSet entry1 = new HashSet();
    HashSet entry2 = new HashSet();
    entry1.add(12345);
    entry2.add(67890);
    result.put(entry1, 12345);
    result.put(entry2, 67890);

    return result;
  }
  /**
   * Generates a LinkedHashMap that contains a HashSet for testing.
   */
  @SuppressWarnings({"unchecked", "rawtypes"})
  public static LinkedHashMap<HashSet, Integer> generateTestLinkedHashMap() {
    LinkedHashMap<HashSet, Integer> result = new LinkedHashMap<HashSet, Integer>();
    HashSet entry1 = new HashSet();
    HashSet entry2 = new HashSet();
    entry1.add(12345);
    entry2.add(67890);
    result.put(entry1, 12345);
    result.put(entry2, 67890);

    return result;
  }

  /**
   * Generates a LinkedHashSet that takes a very long time to deserialize.
   * 
   * @return A LinkedHashSet that cannot be used but requires computation of an
   *         exponential number of hash codes.
   */
  @SuppressWarnings({"rawtypes", "unchecked"})
  public static TestHashSet generateTestLinkedHashSet() {
    TestHashSet result = new TestHashSet();
    HashSet entry1 = new HashSet();
    HashSet entry2 = new HashSet();
    entry1.add(12345);
    entry2.add(67890);
    result.add(entry1);
    result.add(entry2);

    return result;
  }

  private static String generateSerializedClassString(Class<?> instanceType) {
    if (instanceType == int.class) {
      return "I";
    }

    return instanceType.getName() + "/"
        + SerializabilityUtil.getSerializationSignature(instanceType, testSerializationPolicy);
  }

  private String headerString = "";

  private String bodyString = "";

  private LinkedHashMap<String, Integer> stringTable;

  private IdentityHashMap<Object, Integer> encodedObjectTable;

  /**
   * Create a new Factory that will generate an RPC string to invoke the given
   * method found in the given class.
   * 
   * @throws NoSuchMethodException when the method requested does not exist on
   *           the class provided.
   */
  public RPCTypeCheckFactory(Class<?> testMethodClass, String testMethodName)
      throws NoSuchMethodException {
    headerString +=
        Integer.toString(AbstractSerializationStream.SERIALIZATION_STREAM_VERSION)
            + RPC_SEPARATOR_CHAR + // version
            "0" + RPC_SEPARATOR_CHAR; // flags

    stringTable = new LinkedHashMap<String, Integer>(20);
    writeStringFromTable("moduleBaseURL");
    writeStringFromTable("whitelistHashcode");

    encodedObjectTable = new IdentityHashMap<Object, Integer>(20);

    writeMethodSignature(testMethodClass, testMethodName);
  }

  /**
   * Convert the accumulated contents of this object to the final RPC message
   * string.
   */
  @Override
  public String toString() {
    String result = headerString;

    result += Integer.toString(stringTable.size()) + RPC_SEPARATOR_CHAR;
    for (String strEntry : stringTable.keySet()) {
      result += strEntry + RPC_SEPARATOR_CHAR;
    }

    result += bodyString;

    return result;
  }

  /**
   * Add data for an int object.
   */
  public void write(int integer) throws SerializationException {
    try {
      bodyString += Integer.toString(integer) + RPC_SEPARATOR_CHAR;
    } catch (Exception e) {
      throw new SerializationException(e);
    }
  }

  /**
   * Add data for an int array object.
   */
  public void write(int[] intArray) {
    writeStringFromTable(generateSerializedClassString(intArray.getClass()));
    bodyString += Integer.toString(intArray.length) + RPC_SEPARATOR_CHAR;
    for (int i : intArray) {
      bodyString += Integer.toString(i) + RPC_SEPARATOR_CHAR;
    }
  }

  /**
   * Add data for an {@link Integer} object.
   */
  public void write(Integer integer) throws SerializationException {
    if (getEncodedIndex(integer)) {
      return;
    }
    try {
      writeStringFromTable(generateSerializedClassString(Integer.class));
      bodyString += integer.toString() + RPC_SEPARATOR_CHAR;
    } catch (Exception e) {
      throw new SerializationException(e);
    }
  }

  /**
   * Add data for a {@link java.util.List} object.
   */
  public void write(List<?> list) throws SerializationException {
    if (getEncodedIndex(list)) {
      return;
    }
    writeStringFromTable(generateSerializedClassString(list.getClass()));
    writeListBody(list);
  }

  /**
   * Add data for a {@link java.util.Map} object.
   */
  public void write(Map<?, ?> map) throws SerializationException {
    if (getEncodedIndex(map)) {
      return;
    }
    writeStringFromTable(generateSerializedClassString(map.getClass()));
    if (map instanceof LinkedHashMap) {
      // Set the iteration order for the linked hash map, always insertion
      // order.
      bodyString += "0" + RPC_SEPARATOR_CHAR;
    }
    if (map instanceof TreeMap) {
      // Set the iteration order for the linked hash map, always insertion
      // order.
      Comparator<?> comp = ((TreeMap<?, ?>) map).comparator();
      if (comp == null) {
        bodyString += "0" + RPC_SEPARATOR_CHAR;
      } else {
        writeStringFromTable(generateSerializedClassString(comp.getClass()));
      }
    }
    bodyString += Integer.toString(map.size()) + RPC_SEPARATOR_CHAR;
    for (Map.Entry<?, ?> entry : map.entrySet()) {
      writeCollectionElement(entry.getKey());
      writeCollectionElement(entry.getValue());
    }
  }

  /**
   * Add data for an {@link Object} where no more specific write method exists.
   */
  public void write(Object object) throws SerializationException {
    if (getEncodedIndex(object)) {
      return;
    }

    try {
      Class<?> clazz = object.getClass();
      writeStringFromTable(generateSerializedClassString(clazz));

      writeClass(object, clazz);
    } catch (Exception e) {
      throw new SerializationException(e);
    }
  }

  /**
   * Add data for a {@link Object} array.
   */
  public void write(Object[] objectArray) throws SerializationException {
    if (getEncodedIndex(objectArray)) {
      return;
    }
    writeStringFromTable(generateSerializedClassString(objectArray.getClass()));
    bodyString += Integer.toString(objectArray.length) + RPC_SEPARATOR_CHAR;
    for (Object element : objectArray) {
      writeCollectionElement(element);
    }
  }

  /**
   * Add data for a {@link java.util.Set} object.
   */
  public void write(Set<?> set) throws SerializationException {
    if (getEncodedIndex(set)) {
      return;
    }
    writeStringFromTable(generateSerializedClassString(set.getClass()));
    if (set instanceof TreeSet) {
      writeStringFromTable(generateSerializedClassString(((TreeSet<?>) set).comparator().getClass()));
    }
    bodyString += Integer.toString(set.size()) + RPC_SEPARATOR_CHAR;
    for (Object element : set) {
      writeCollectionElement(element);
    }
  }

  /**
   * Add data for a {@link String} object.
   */
  public void write(String string) {
    writeStringFromTable(string);
  }

  /**
   * Add data for a {@link java.util.Vector} object.
   */
  public void write(Vector<?> vector) throws SerializationException {
    if (getEncodedIndex(vector)) {
      return;
    }
    writeStringFromTable(generateSerializedClassString(vector.getClass()));
    bodyString += Integer.toString(vector.size()) + RPC_SEPARATOR_CHAR;
    for (Object element : vector) {
      writeCollectionElement(element);
    }
  }

  /**
   * Add data for an empty list object (as returned by
   * {@link java.util.Collections}).
   */
  public void writeEmptyList() {
    List<?> emptyList = java.util.Collections.emptyList();
    writeStringFromTable(generateSerializedClassString(emptyList.getClass()));
  }

  /**
   * Add data for an empty map object (as returned by
   * {@link java.util.Collections}).
   */
  public void writeEmptyMap() {
    Map<?, ?> emptyMap = java.util.Collections.emptyMap();
    writeStringFromTable(generateSerializedClassString(emptyMap.getClass()));
  }

  /**
   * Add data for an empty set object (as returned by
   * {@link java.util.Collections}).
   */
  public void writeEmptySet() {
    Set<?> emptySet = java.util.Collections.emptySet();
    writeStringFromTable(generateSerializedClassString(emptySet.getClass()));
  }

  private boolean getEncodedIndex(Object obj) {
    Integer foundIndex = encodedObjectTable.get(obj);
    if (foundIndex == null) {
      foundIndex = encodedObjectTable.size();
      encodedObjectTable.put(obj, foundIndex);
      return false;
    }

    bodyString += Integer.toString(-(foundIndex.intValue() + 1)) + RPC_SEPARATOR_CHAR;

    return true;
  }

  private void writeClass(Object object, Class<?> clazz) throws SerializationException {
    Field[] fields = clazz.getDeclaredFields();
    try {
      for (Field field : fields) {
        Type type = field.getGenericType();
        if (type == int.class) {
          write(field.getInt(object));
        } else {
          Object value = field.get(object);
          writeCollectionElement(value);
        }
      }

      Class<?> superClass = clazz.getSuperclass();
      if (superClass == Object.class) {
        return;
      } else if (superClass == LinkedList.class) {
        writeListBody((List<?>) object);
        return;
      }

      writeClass(object, superClass);

    } catch (Exception e) {
      throw new SerializationException(e);
    }
  }

  /**
   * @param element
   * @throws SerializationException
   */
  @SuppressWarnings("cast")
  private void writeCollectionElement(Object element) throws SerializationException {
    if (element == null) {
      bodyString += "0" + RPC_SEPARATOR_CHAR;
    } else if (element instanceof Map) {
      write((Map<?, ?>) element);
    } else if (element instanceof HashSet) {
      write((HashSet<?>) element);
    } else if (element instanceof int[]) {
      write((int[]) element);
    } else if (element instanceof Integer) {
      write((Integer) element);
    } else if (element instanceof Long) {
      writeLong((Long) element);
    } else if (element instanceof Float) {
      writeFloat((Float) element);
    } else if (element instanceof Short) {
      writeShort((Short) element);
    } else if (element instanceof Double) {
      writeDouble((Double) element);
    } else if (element instanceof RPCTypeCheckTest.DClass) {
      write((Object) element);
    } else if (element instanceof String) {
      writeStringInCollection((String) element);
    } else if (element instanceof List) {
      write((List<?>) element);
    } else if (element instanceof Object[]) {
      write((Object[]) element);
    } else {
      write(element);
    }
  }

  private void writeDouble(Double d) {
    writeStringFromTable(generateSerializedClassString(Double.class));
    writeStringFromTable(d.toString());
  }

  private void writeFloat(Float f) {
    writeStringFromTable(generateSerializedClassString(Float.class));
    writeStringFromTable(f.toString());
  }

  private void writeListBody(List<?> list) throws SerializationException {
    if (list.getClass().toString().matches(".*Arrays\\$ArrayList.*")) {
      write(list.toArray());
      return;
    }
    if (!list.getClass().toString().matches(".*Collections\\$SingletonList.*")) {
      bodyString += Integer.toString(list.size()) + RPC_SEPARATOR_CHAR;
    }
    for (Object element : list) {
      writeCollectionElement(element);
    }
  }

  private void writeLong(Long l) {
    writeStringFromTable(generateSerializedClassString(Long.class));
    writeStringFromTable(l.toString());
  }

  private void writeMethodSignature(Class<?> testMethodClass, String testMethodName)
      throws NoSuchMethodException {
    writeStringFromTable(testMethodClass.getName());
    writeStringFromTable(testMethodName);

    Method[] testMethods = testMethodClass.getDeclaredMethods();
    Method targetMethod = null;
    for (Method method : testMethods) {
      if (method.getName().equals(testMethodName)) {
        targetMethod = method;
        break;
      }
    }
    if (targetMethod == null) {
      throw new NoSuchMethodException("Could not find " + testMethodName + " in "
          + testMethodClass.getName());
    }

    Class<?>[] parameterClasses = targetMethod.getParameterTypes();
    bodyString += Integer.toString(parameterClasses.length) + RPC_SEPARATOR_CHAR;
    for (Class<?> parameter : parameterClasses) {
      writeStringFromTable(generateSerializedClassString(parameter));
    }
  }

  private void writeShort(Short s) {
    writeStringFromTable(generateSerializedClassString(Short.class));
    writeStringFromTable(s.toString());
  }

  private void writeStringFromTable(String string) {
    Integer index = stringTable.get(string);
    if (index == null) {
      index = stringTable.size() + 1;
      stringTable.put(string, index);
    }
    bodyString += index.toString() + RPC_SEPARATOR_CHAR;
  }

  private void writeStringInCollection(String string) {
    writeStringFromTable(generateSerializedClassString(string.getClass()));
    writeStringFromTable(string);
  }

}