path: root/uitest/src/main/java/com/vaadin/tests/widgetset/client/SerializerTestConnector.java

package com.vaadin.tests.widgetset.client;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import com.vaadin.client.ServerConnector;
import com.vaadin.client.communication.StateChangeEvent;
import com.vaadin.client.extensions.AbstractExtensionConnector;
import com.vaadin.shared.Connector;
import com.vaadin.shared.ui.Connect;
import com.vaadin.shared.ui.ContentMode;
import com.vaadin.tests.widgetset.server.SerializerTestExtension;

import elemental.json.Json;
import elemental.json.JsonBoolean;
import elemental.json.JsonObject;
import elemental.json.JsonString;
import elemental.json.JsonType;
import elemental.json.JsonValue;

@Connect(SerializerTestExtension.class)
public class SerializerTestConnector extends AbstractExtensionConnector {

    private SerializerTestRpc rpc = getRpcProxy(SerializerTestRpc.class);

    public SerializerTestConnector() {
        registerRpc(SerializerTestRpc.class, new SerializerTestRpc() {
            @Override
            public void sendWrappedGenerics(
                    Map<Set<SimpleTestBean>, Map<Integer, List<SimpleTestBean>>> generics) {
                Map<Set<SimpleTestBean>, Map<Integer, List<SimpleTestBean>>> updated = new HashMap<>();

                SimpleTestBean firstValue = generics.values().iterator().next()
                        .get(Integer.valueOf(1)).get(0);
                Set<SimpleTestBean> key = new HashSet<>(
                        Arrays.asList(firstValue));

                Map<Integer, List<SimpleTestBean>> value = new HashMap<>();
                Set<SimpleTestBean> firstKeyValue = generics.keySet().iterator()
                        .next();
                value.put(Integer.valueOf(1), new ArrayList<>(firstKeyValue));

                updated.put(key, value);

                rpc.sendWrappedGenerics(updated);
            }

            @Override
            public void sendString(String value, String[] array) {
                char[] chars = value.toCharArray();
                Arrays.sort(chars);
                rpc.sendString(new String(chars),
                        new String[] { array[1], array[0] });
            }

            @Override
            public void sendSet(Set<Integer> intSet,
                    Set<Connector> connectorSet, Set<SimpleTestBean> beanSet) {

                beanSet.iterator().next().setValue(intSet.size());
                Set<Integer> updatedIntSet = new HashSet<>();

                for (Integer integer : intSet) {
                    updatedIntSet.add(Integer.valueOf(-integer.intValue()));
                }
                rpc.sendSet(updatedIntSet,
                        Collections.singleton(getUIConnector()), beanSet);
            }

            @Override
            public void sendNestedArray(int[][] nestedIntArray,
                    SimpleTestBean[][] nestedBeanArray) {
                rpc.sendNestedArray(
                        new int[][] { { nestedIntArray[1][0],
                                nestedIntArray[0][0] } },
                        new SimpleTestBean[][] { { nestedBeanArray[0][1] },
                                { nestedBeanArray[0][0] } });
            }

            @Override
            public void sendMap(Map<String, SimpleTestBean> stringMap,
                    Map<Connector, SimpleTestBean> connectorMap,
                    Map<Integer, Connector> intMap,
                    Map<SimpleTestBean, SimpleTestBean> beanMap) {
                Map<SimpleTestBean, SimpleTestBean> updatedBeanMap = new HashMap<>();
                for (Entry<SimpleTestBean, SimpleTestBean> entry : beanMap
                        .entrySet()) {
                    updatedBeanMap.put(entry.getValue(), entry.getKey());
                }

                rpc.sendMap(Collections.singletonMap("a", stringMap.get("1")),
                        Collections.singletonMap(getThisConnector(),
                                connectorMap.get(getUIConnector())),
                        Collections.singletonMap(
                                Integer.valueOf(stringMap.size()),
                                getThisConnector()),
                        updatedBeanMap);
            }

            @Override
            public void sendLong(long value, Long boxedValue, long[] array) {
                rpc.sendLong(array[0], Long.valueOf(value),
                        new long[] { array[1], boxedValue.longValue() });
            }

            @Override
            public void sendList(List<Integer> intList,
                    List<Connector> connectorList,
                    List<SimpleTestBean> beanList) {
                Collections.sort(intList);
                Collections.reverse(beanList);
                rpc.sendList(intList,
                        Arrays.asList(getThisConnector(), getUIConnector()),
                        beanList);
            }

            @Override
            public void sendInt(int value, Integer boxedValue, int[] array) {
                rpc.sendInt(array.length, Integer.valueOf(array[0]),
                        new int[] { value, boxedValue.intValue() });
            }

            @Override
            public void sendFloat(float value, Float boxedValue,
                    float[] array) {
                Arrays.sort(array);
                rpc.sendFloat(boxedValue.floatValue(), Float.valueOf(value),
                        array);
            }

            @Override
            public void sendDouble(double value, Double boxedValue,
                    double[] array) {
                rpc.sendDouble(value + boxedValue.doubleValue(),
                        Double.valueOf(value - boxedValue.doubleValue()),
                        new double[] { array.length, array[0], array[1] });
            }

            @Override
            public void sendConnector(Connector connector) {
                rpc.sendConnector(getThisConnector());
            }

            @Override
            public void sendChar(char value, Character boxedValue,
                    char[] array) {
                rpc.sendChar(Character.toUpperCase(boxedValue.charValue()),
                        Character.valueOf(value), new String(array)
                                .toLowerCase(Locale.ROOT).toCharArray());
            }

            @Override
            public void sendByte(byte value, Byte boxedValue, byte[] array) {
                // There will most certainly be a bug that is not discovered
                // because this particular method doesn't do anything with it's
                // values...
                rpc.sendByte(value, boxedValue, array);
            }

            @Override
            public void sendBoolean(boolean value, Boolean boxedValue,
                    boolean[] array) {
                boolean[] inverseArray = new boolean[array.length];
                for (int i = 0; i < array.length; i++) {
                    inverseArray[i] = !array[i];
                }
                rpc.sendBoolean(boxedValue == Boolean.TRUE,
                        Boolean.valueOf(!value), inverseArray);
            }

            @Override
            public void sendBean(ComplexTestBean complexBean,
                    SimpleTestBean simpleBean, SimpleTestBean[] array) {
                SimpleTestBean updatedSimpleBean = new SimpleTestBean();
                updatedSimpleBean
                        .setValue(complexBean.getInnerBean1().getValue());

                ComplexTestBean updatedComplexBean = new ComplexTestBean();
                updatedComplexBean.setInnerBean1(complexBean.getInnerBean2());
                updatedComplexBean.setInnerBean2(
                        complexBean.getInnerBeanCollection().get(0));
                updatedComplexBean.setInnerBeanCollection(
                        Arrays.asList(simpleBean, updatedSimpleBean));
                updatedComplexBean.setPrivimite(complexBean.getPrivimite() + 1);

                List<SimpleTestBean> arrayList = new ArrayList<>(
                        Arrays.asList(array));
                Collections.reverse(arrayList);

                rpc.sendBean(updatedComplexBean, updatedSimpleBean,
                        arrayList.toArray(new SimpleTestBean[array.length]));
            }

            @Override
            public void sendArrayList(List<int[]> primitiveArrayList,
                    List<Integer[]> objectArrayList,
                    List<SimpleTestBean[]> beanArrayList) {
                Collections.reverse(beanArrayList);
                List<Integer[]> updatedObjectArrayList = new ArrayList<>();
                for (int[] array : primitiveArrayList) {
                    updatedObjectArrayList
                            .add(new Integer[] { Integer.valueOf(array.length),
                                    Integer.valueOf(array[0]) });
                }

                rpc.sendArrayList(
                        Arrays.asList(new int[] { primitiveArrayList.size() },
                                new int[] { objectArrayList.get(0).length }),
                        updatedObjectArrayList, beanArrayList);
            }

            @Override
            public void sendNull(String value1, String value2) {
                rpc.sendNull(value2, value1);
            }

            @Override
            public void sendListArray(List<Integer>[] objectListArray,
                    List<SimpleTestBean>[] beanListArray) {
                rpc.sendListArray(
                        new List[] { objectListArray[1], objectListArray[0] },
                        new List[] { Collections
                                .singletonList(beanListArray[0].get(0)) });
            }

            @Override
            public void sendEnum(ContentMode contentMode, ContentMode[] array,
                    List<ContentMode> list) {
                ContentMode nextContentMode = ContentMode
                        .values()[contentMode.ordinal() + 1];
                rpc.sendEnum(nextContentMode,
                        list.toArray(new ContentMode[list.size()]),
                        Arrays.asList(array));
            }

            @Override
            public void sendBeanSubclass(final SimpleTestBean bean) {
                rpc.sendBeanSubclass(new SimpleTestBean() {
                    @Override
                    public int getValue() {
                        return bean.getValue() + 1;
                    }
                });
            }

            @Override
            public void sendDate(Date date) {
                rpc.sendDate(date);
            }

            @Override
            public void sendDateArray(Date[] date) {
                rpc.sendDateArray(date);
            }

            @Override
            public void sendJson(JsonValue value1, JsonValue value2,
                    JsonString string) {
                if (value1.getType() != JsonType.BOOLEAN) {
                    throw new RuntimeException(
                            "Expected boolean, got " + value1.toJson());
                }

                if (value2.getType() != JsonType.NULL) {
                    throw new RuntimeException(
                            "Expected null, got " + value2.toJson());
                }

                JsonObject returnObject = Json.createObject();
                returnObject.put("b", !((JsonBoolean) value1).asBoolean());
                returnObject.put("s", string);

                rpc.sendJson(returnObject, Json.createNull(),
                        Json.create("value"));
            }

            @Override
            public void log(String message) {
                // Do nothing, used only in the other direction
            }
        });
    }

    private Connector getUIConnector() {
        return getConnection().getUIConnector();
    }

    private Connector getThisConnector() {
        // Cast to Connector for use in e.g. Collections.singleton() to get a
        // Set<Connector>
        return this;
    }

    @Override
    public SerializerTestState getState() {
        return (SerializerTestState) super.getState();
    }

    @Override
    public void onStateChanged(StateChangeEvent stateChangeEvent) {
        rpc.log("state.booleanValue: " + getState().booleanValue);
        rpc.log("state.booleanObjectValue: " + getState().booleanObjectValue);
        rpc.log("state.booleanArray: "
                + Arrays.toString(getState().booleanArray));

        rpc.log("state.byteValue: " + getState().byteValue);
        rpc.log("state.byteObjectValue: " + getState().byteObjectValue);
        rpc.log("state.byteArray: " + Arrays.toString(getState().byteArray));

        rpc.log("state.charValue: " + getState().charValue);
        rpc.log("state.charObjectValue: " + getState().charObjectValue);
        rpc.log("state.charArray: " + String.valueOf(getState().charArray));

        rpc.log("state.intValue: " + getState().intValue);
        rpc.log("state.intObjectValue: " + getState().intObjectValue);
        rpc.log("state.intArray: " + Arrays.toString(getState().intArray));

        rpc.log("state.longValue: " + getState().longValue);
        rpc.log("state.longObjectValue: " + getState().longObjectValue);
        rpc.log("state.longArray: " + Arrays.toString(getState().longArray));

        rpc.log("state.floatValue: " + getState().floatValue);
        rpc.log("state.floatObjectValue: " + getState().floatObjectValue);
        rpc.log("state.floatArray: " + Arrays.toString(getState().floatArray));

        rpc.log("state.doubleValue: " + getState().doubleValue);
        rpc.log("state.doubleObjectValue: " + getState().doubleObjectValue);
        rpc.log("state.doubleArray: "
                + Arrays.toString(getState().doubleArray));

        rpc.log("state.string: " + getState().string);
        rpc.log("state.stringArray: "
                + Arrays.toString(getState().stringArray));

        rpc.log("state.jsonNull: " + getState().jsonNull.getType().name());
        rpc.log("state.jsonString: "
                + ((JsonString) getState().jsonString).getString());
        rpc.log("state.jsonBoolean: " + getState().jsonBoolean.getBoolean());

        rpc.log("state.date1: " + getState().date1);
        rpc.log("state.date2: " + getState().date2);
        String arrStr = "";
        for (Date d : getState().dateArray) {
            arrStr += d + " ";
        }
        rpc.log("state.dateArray: " + arrStr);

        /*
         * TODO public double doubleValue; public Double DoubleValue; public
         * double[] doubleArray; ;
         *
         * public String string;
         *
         * public String nullString;
         *
         * public Connector connector;
         *
         * public ComplexTestBean complexTestBean; public SimpleTestBean
         * simpleTestBean; public SimpleTestBean[] simpleTestBeanArray; public
         * int[][] nestedIntArray; public SimpleTestBean[][] nestedBeanArray;
         *
         * public List<Integer> intList; public List<Connector> connectorList;
         * public List<SimpleTestBean> simpleTestBeanList;
         *
         * public List<int[]> primitiveArrayList; public List<Integer[]>
         * objectArrayList; public List<SimpleTestBean[]> beanArrayList;
         *
         * public List<Integer>[] objectListArray; public List<SimpleTestBean>[]
         * beanListArray;
         *
         * public Set<Integer> intSet; public Set<Connector> connectorSet;
         * public Set<SimpleTestBean> beanSet;
         *
         * public Map<String, SimpleTestBean> stringMap; public Map<Connector,
         * SimpleTestBean> connectorMap; public Map<Integer, Connector> intMap;
         * public Map<SimpleTestBean, SimpleTestBean> beanMap;
         *
         * public Map<Set<SimpleTestBean>, Map<Integer, List<SimpleTestBean>>>
         * generics;
         *
         * public ContentMode contentMode; public ContentMode[] array; public
         * List<ContentMode> list;
         *
         * public SimpleTestBean bean;
         *
         * public Date date1; public Date date2;
         */
    }

    @Override
    protected void extend(ServerConnector target) {
        // TODO Auto-generated method stub

    }

}