source: java/main/src/main/java/com/framsticks/params/ParamCandidate.java @ 107

package com.framsticks.params;

import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.IdentityHashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import com.framsticks.params.annotations.FramsClassAnnotation;
import com.framsticks.params.annotations.ParamAnnotation;
import com.framsticks.params.types.ProcedureParam;
// import com.framsticks.util.FramsticksException;

public class ParamCandidate {

        public class OneTime<T> {
                protected final String name;
                T value;

                /**
                 * @param name
                 */
                public OneTime(String name) {
                        this.name = name;
                }

                final void set(T value) {
                        if (this.value == null) {
                                this.value = value;
                                return;
                        }
                        if (!this.value.equals(value)) {
                                throw new ConstructionException().msg("already set")
                                        .arg("name", name)
                                        .arg("in", ParamCandidate.this)
                                        .arg("already", this.value)
                                        .arg("now", value);
                        }
                }

                public final T get() {
                        return value;
                }

                public final boolean has() {
                        return value != null;
                }

                @Override
                public String toString() {
                        return value == null ? "<null>" : value.toString();
                }


        }

        protected final String id;
        protected final OneTime<String> name = new OneTime<>("name");
        protected final OneTime<Type> type = new OneTime<>("type");
        protected final OneTime<Field> field = new OneTime<>("field");
        protected final OneTime<Method> setter = new OneTime<>("setter");
        protected final OneTime<Method> getter = new OneTime<>("getter");
        protected final OneTime<Method> caller = new OneTime<>("caller");
        protected final OneTime<Method> adder = new OneTime<>("adder");
        protected final OneTime<Method> remover = new OneTime<>("remover");
        protected final OneTime<Class<? extends Param>> paramType = new OneTime<>("paramType");
        protected final OneTime<String> stringType = new OneTime<>("stringType");

        protected int flags = 0;

        protected final List<ParamAnnotation> annotations = new LinkedList<>();

        /**
         * @param id
         */
        public ParamCandidate(String id) {
                this.id = id;
        }

        /**
         * @return the id
         */
        public String getId() {
                return id;
        }

        /**
         * @return the name
         */
        public String getName() {
                return name.get();
        }

        /**
         * @return the type
         */
        public Type getType() {
                return type.get();
        }

        public Class<?> getRawType() {
                return getRawClass(type.get());
        }

        void setType(Type type) {
                this.type.set(type);
        }


        /**
         * @return the field
         */
        public Field getField() {
                return field.get();
        }

        /**
         * @return the setter
         */
        public Method getSetter() {
                return setter.get();
        }

        /**
         * @return the getter
         */
        public Method getGetter() {
                return getter.get();
        }

        /**
         * @return the getter
         */
        public Method getCaller() {
                return caller.get();
        }

        /**
         * @return the getter
         */
        public Method getAdder() {
                return adder.get();
        }

        /**
         * @return the getter
         */
        public Method getRemover() {
                return remover.get();
        }

        /**
         * @return the annotations
         */
        public List<ParamAnnotation> getAnnotations() {
                return Collections.unmodifiableList(annotations);
        }

        protected final java.util.Set<Class<?>> dependantClasses = new HashSet<>();

        // public void addDependantClass(Class<?> javaClass) {
        //      dependantClasses.add(javaClass);
        // }

        /**
         * @return the dependantClasses
         */
        public java.util.Set<Class<?>> getDependantClasses() {
                return Collections.unmodifiableSet(dependantClasses);
        }

        void validate() throws ConstructionException {
                try {
                        if (adder.has() != remover.has()) {
                                throw new ConstructionException().msg("only one of event manipulator methods is defined");
                        }
                        if (adder.has() && remover.has()) {
                                return;
                        }
                        if (caller.has()) {
                                if (!isPublic(caller)) {
                                        throw new ConstructionException().msg("method is not public");
                                }
                                if (getter.has() || setter.has()) {
                                        throw new ConstructionException().msg("getter or setter coexist with caller");
                                }
                                return;
                        }
                        if (isPublic(field)) {
                                if (getter.has()) {
                                        throw new ConstructionException().msg("getter and public field coexist");
                                }
                                return;
                        }
                        if (isPublic(field)) {
                                if (setter.has()) {
                                        throw new ConstructionException().msg("setter and field coexist");
                                }
                        }

                        if (!getter.has() && !field.has()) {
                                throw new ConstructionException().msg("missing getter or field");
                        }
                        if (getter.has() || field.has() || setter.has()) {
                                if (type.get().equals(Void.TYPE)) {
                                        throw new ConstructionException().msg("type of field is void");
                                }
                        }
                } catch (ConstructionException e) {
                        throw e.arg("in", this);
                }
        }

        boolean isFinal() {
                if (caller.has()) {
                        return false;
                }
                if (adder.has() || remover.has()) {
                        return false;
                }
                if (field.has()) {
                        return Modifier.isFinal(field.get().getModifiers());
                }
                if (setter.has()) {
                        return false;
                }
                if (Collection.class.isAssignableFrom(getRawType())) {
                        return false;
                }
                return true;
        }

        boolean isReadOnly() {
                if (caller.has()) {
                        return false;
                }
                if (adder.has() || remover.has()) {
                        return false;
                }
                if (Collection.class.isAssignableFrom(getRawType())) {
                        return false;
                }
                if (isPublic(setter)) {
                        return false;
                }
                if (isPublic(field)) {
                        return Modifier.isFinal(field.get().getModifiers());
                }
                return true;
        }

        // public static <T extends Param> boolean isParamAnnorationOfTypeOrUnspecified(ParamAnnotation paramAnnotation, Class<T> paramType) {
        //      return paramAnnotation.paramType().equals(Param.class) || paramAnnotation.paramType().equals(paramType);
        // }

        // public static <T extends Param> boolean isParamAnnorationOfType(ParamAnnotation paramAnnotation, Class<T> paramType) {
        //      return paramAnnotation.paramType().equals(paramType);
        // }

        void add(ParamAnnotation paramAnnotation, Member member, String name) {
                this.name.set(name);
                annotations.add(paramAnnotation);
                flags |= paramAnnotation.flags();
                if (!paramAnnotation.paramType().equals(Param.class)) {
                        paramType.set(paramAnnotation.paramType());
                }
                if (!"".equals(paramAnnotation.stringType())) {
                        stringType.set(paramAnnotation.stringType());
                }
                if (member instanceof Field) {
                        field.set((Field) member);
                        setType(field.get().getGenericType());
                        return;
                }
                if (member instanceof Method) {
                        Method m = (Method) member;
                        if (paramAnnotation.paramType().equals(ProcedureParam.class)) {
                                caller.set(m);
                                return;
                        }
                        Type[] ps = m.getGenericParameterTypes();
                        Class<?>[] pts = m.getParameterTypes();
                        if (ps.length == 0) {
                                if (m.getReturnType().equals(Void.TYPE)) {
                                        throw new ConstructionException().msg("failed to add getter of void return type");
                                }
                                getter.set(m);
                                setType(m.getGenericReturnType());
                                return;
                        }
                        if (ps.length == 1) {
                                if (pts[0].equals(EventListener.class)) {
                                        if (member.getName().startsWith("add")) {
                                                adder.set(m);
                                                setType(ps[0]);
                                                return;
                                        }
                                        if (member.getName().startsWith("remove")) {
                                                remover.set(m);
                                                setType(ps[0]);
                                                return;
                                        }
                                        throw new ConstructionException().msg("invalid name of event manipulator").arg("method", m).arg("in", this);
                                }
                                setter.set(m);
                                setType(ps[0]);
                                return;
                        }
                        throw new ConstructionException().msg("invalid number of arguments").arg("method", m).arg("in", this);
                }
                throw new ConstructionException().msg("invalid kind of member").arg("member", member).arg("in", this);
        }

        public boolean isPrimitive() {
                return getRawType().isPrimitive();
        }

        public int getFlags() {
                int f = flags;
                if (isReadOnly()) {
                        f |= ParamFlags.READONLY;
                }
                return f;
        }

        @Override
        public String toString() {
                return id + "(" + type.toString() + ")";
        }

        public static boolean isPublic(Member member) {
                return Modifier.isPublic(member.getModifiers());
        }

        public static boolean isPublic(OneTime<? extends Member> v) {
                return v.has() ? isPublic(v.get()) : false;
        }

        public static <M extends Member & AnnotatedElement> void filterParamsCandidates(Set set, M[] members) {
                for (M m : members) {
                        ParamAnnotation pa = m.getAnnotation(ParamAnnotation.class);
                        if (pa == null) {
                                continue;
                        }
                        String id = FramsClassBuilder.getId(pa, m);
                        ParamCandidate pc = null;
                        if (set.getCandidates().containsKey(id)) {
                                pc = set.getCandidates().get(id);
                        } else {
                                pc = new ParamCandidate(id);
                                set.getCandidates().put(id, pc);
                                set.getOrder().add(pc);
                        }
                        pc.add(pa, m, FramsClassBuilder.getName(pa, m));
                }
        }

        public static class Set {
                protected final Map<String, ParamCandidate> candidates;
                protected final List<ParamCandidate> order;
                protected final java.util.Set<Class<?>> dependantClasses = new HashSet<>();
                protected final java.util.Set<String> dependantClassesFromInfo = new HashSet<>();

                /**
                 * @param candidates
                 * @param order
                 */
                public Set(Map<String, ParamCandidate> candidates, List<ParamCandidate> order) {
                        this.candidates = candidates;
                        this.order = order;
                }

                /**
                 * @return the candidates
                 */
                public Map<String, ParamCandidate> getCandidates() {
                        return candidates;
                }

                /**
                 * @return the order
                 */
                public List<ParamCandidate> getOrder() {
                        return order;
                }

                public java.util.Set<Class<?>> getDependentClasses() {
                        return dependantClasses;
                }

                public java.util.Set<String> getDependentClassesFromInfo() {
                        return dependantClassesFromInfo;
                }
        }

        protected static final Map<Class<?>, Set> setsCache = Collections.synchronizedMap(new IdentityHashMap<Class<?>, Set>());

        public static Set getAllCandidates(final Class<?> javaClass) throws ConstructionException {
                Set result = setsCache.get(javaClass);
                if (result != null) {
                        return result;
                }

                List<Class<?>> javaClasses = new LinkedList<>();
                Class<?> jc = javaClass;
                while (jc != null) {
                        javaClasses.add(0, jc);
                        jc = jc.getSuperclass();
                }

                result = new Set(new HashMap<String, ParamCandidate>(), new LinkedList<ParamCandidate>());

                for (Class<?> j : javaClasses) {
                        Set set = new Set(result.getCandidates(), new LinkedList<ParamCandidate>());

                        filterParamsCandidates(set, j.getDeclaredFields());
                        filterParamsCandidates(set, j.getDeclaredMethods());

                        FramsClassAnnotation fa = j.getAnnotation(FramsClassAnnotation.class);
                        if (fa != null) {

                                if (j != javaClass) {
                                        result.dependantClasses.add(j);
                                }
                                for (Class<?> r : fa.register()) {
                                        result.dependantClasses.add(r);
                                }
                                for (String i : fa.registerFromInfo()) {
                                        result.dependantClassesFromInfo.add(i);
                                }

                                final List<String> order = Arrays.asList(fa.order());
                                Collections.sort(set.getOrder(), new Comparator<ParamCandidate>() {
                                        @Override
                                        public int compare(ParamCandidate pc0, ParamCandidate pc1) {
                                                int u0 = order.indexOf(pc0.getId());
                                                int u1 = order.indexOf(pc1.getId());
                                                if (u0 == -1 || u1 == -1) {
                                                        return 0;
                                                }
                                                return u0 - u1;
                                        }
                                });
                        }
                        result.getOrder().addAll(0, set.getOrder());
                }

                for (ParamCandidate pc : result.getOrder()) {
                        pc.validate();
                        pc.induceParamType(Param.build());
                        result.dependantClasses.addAll(pc.getDependantClasses());
                }

                setsCache.put(javaClass, result);

                return result;
        }

        public static Class<?> getRawClass(final Type type) {
                if (type == null) {
                        throw new IllegalArgumentException();
                }
                if (Class.class.isInstance(type)) {
                        return Class.class.cast(type);
                }
                if (ParameterizedType.class.isInstance(type)) {
                        final ParameterizedType parameterizedType = ParameterizedType.class.cast(type);
                        return getRawClass(parameterizedType.getRawType());
                } else if (GenericArrayType.class.isInstance(type)) {
                        GenericArrayType genericArrayType = GenericArrayType.class.cast(type);
                        Class<?> c = getRawClass(genericArrayType.getGenericComponentType());
                        return Array.newInstance(c, 0).getClass();
                } else {
                        return null;
                }
        }

        protected ParamBuilder induceParamType(ParamBuilder builder, Type type) {
                // if (type.equals(Void.TYPE)) {
                //      throw new ConstructionException().msg("void is not a valid type");
                // }


                if (type instanceof ParameterizedType) {
                        ParameterizedType p = (ParameterizedType) type;
                        Type rawType = p.getRawType();
                        Type containedType = null;
                        boolean map = false;
                        StringBuilder b = new StringBuilder();
                        if (rawType.equals(Map.class)) {
                                containedType = p.getActualTypeArguments()[1];
                                map = true;
                                b.append("l");
                        } else if (rawType.equals(List.class)) {
                                containedType = p.getActualTypeArguments()[0];
                                b.append("l");
                        } else if (rawType.equals(EventListener.class)) {
                                containedType = p.getActualTypeArguments()[0];
                                b.append("e");
                        } else {
                                return induceParamType(builder, rawType);
                                // throw new FramsticksException().msg("unknown raw type").arg("raw type", rawType);
                        }
                        if (!(containedType instanceof Class)) {
                                return builder;
                        }
                        b.append(" ");

                        Class<?> containedClass = (Class<?>) containedType;
                        FramsClassAnnotation fca = containedClass.getAnnotation(FramsClassAnnotation.class);
                        if (fca == null) {
                                throw new ConstructionException().msg("the contained class is not annotated").arg("class", containedClass);
                        }
                        dependantClasses.add(containedClass);
                        b.append(FramsClassBuilder.getName(fca, containedClass));
                        if (map) {
                                b.append(" uid");
                        }

                        builder.type(b.toString());
                        return builder;
                }

                if (type instanceof Class) {

                        Class<?> cl = (Class<?>) type;

                        // this is draft implementation of future support for enum
                        // if (cl.isEnum()) {
                        //      Class<? extends Enum<?>> enumType = (Class<? extends Enum<?>>) cl;
                        //      Enum<?>[] enums = enumType.getEnumConstants();
                        //      StringBuilder b = new StringBuilder();

                        //      b.append("d 0 ").append(enums.length - 1).append(" 0 ");
                        //      for (Enum<?> e : enums) {
                        //              b.append("~").append(e.name());
                        //      }
                        //      return b.toString();
                        // }
                        if (cl.equals(Integer.class) || cl.equals(int.class)) {
                                builder.type("d");
                                return builder;
                        }
                        if (cl.equals(String.class)) {
                                builder.type("s");
                                return builder;
                        }
                        if (cl.equals(Double.class) || cl.equals(double.class)) {
                                builder.type("f");
                                return builder;
                        }
                        if (cl.equals(Boolean.class) || cl.equals(boolean.class)) {
                                builder.type( "d 0 1");
                                return builder;
                        }
                        if (cl.equals(Object.class)) {
                                builder.type("x");
                                return builder;
                        }


                        // builder.type("o " + (cl).getCanonicalName());
                        builder.type("o " + cl.getSimpleName());
                        dependantClasses.add(cl);
                        builder.fillStorageType(cl);
                        return builder;
                }

                throw new ConstructionException().msg("failed to find framsticks for native type").arg("type", type);
        }

        public ParamBuilder induceParamType(ParamBuilder builder) {

                if (stringType.has()) {
                        return builder.type(stringType.get());
                }

                Method method = getCaller();
                if (method == null) {
                        if (paramType.has()) {
                                return builder.type(paramType.get());
                        }
                        return induceParamType(builder, getType());
                }

                if (!method.getReturnType().equals(Void.TYPE)) {
                        builder.resultType(induceParamType(Param.build(), method.getGenericReturnType()).finish(ValueParam.class));
                }

                List<ValueParam> arguments = new ArrayList<>();
                int number = 0;
                for (Type arg : method.getGenericParameterTypes()) {
                        arguments.add(induceParamType(Param.build(), arg).idAndName("arg" + (number++)).finish(ValueParam.class));
                }
                builder.argumentsType(arguments);

                return builder;
        }

};