/**
 * 两种优化方案
 */
public class JudgeOptimize {

    /**
     * 都不为空
     */
    private static final int CODE_CONDITION_ONE = 0000;

    /**
     * abc不为空 d为空
     */
    private static final int CODE_CONDITION_TWO = 0001;

    private static final int CODE_CONDITION_THREE = 0011;

    private static final int CODE_CONDITION_FOUR = 0111;

    private static final int CODE_CONDITION_FIVE = 1111;

    private static void test(String a,String b,String c,String d){
        switch (init(a,b,c,d)){
            case CODE_CONDITION_ONE:
                // DO SOMETHING ...
                break;
            case CODE_CONDITION_TWO:
                //DO SOMETHING ...
                break;
            case CODE_CONDITION_THREE:
                //DO SOMETHING ...
                break;
            case CODE_CONDITION_FOUR:
                //DO SOMETHING ...
                break;
            case CODE_CONDITION_FIVE:
                //DO SOMETHING ...
                break;
        }
    }

    private static int init(String ... allParam){
        if(allParam == null){
            return 1;
        }
        String resultNumberStr = "";
        for (String s : allParam) {
            resultNumberStr += StringUtils.isNotEmpty(s) ? 0 : 1;
        }
        return Integer.valueOf(resultNumberStr);
    }


}

/**
 * 第二种解决方案
 * 全自动 但是涉及反射
 */
@Getter
class SolutionTwo{

    private static Object result;

    @Data
    private static class Action{
        /**
         * 目标类
         */
        private Class targetInvokeClass;

        /**
         * 目标类中目标方法
         */
        private String targetMethodName;

        /**
         * 参数类型
         */
        private Class[] parameterTypes;

        /**
         * 目标方法参数对象
         */
        private Object[] params;

        /**
         * 是否是当前类中方法
         */
        private boolean isCurrentClass;

        /**
         * 是否方法不需要参数
         */
        private boolean isNoParams;

        public Action(){

        }

        public Action(Class targetInvokeClass, String targetMethodName,Class[] parameterTypes, Object[] params, boolean isCurrentClass, boolean isNoParams) {
            this.targetInvokeClass = targetInvokeClass;
            this.targetMethodName = targetMethodName;
            this.parameterTypes = parameterTypes;
            this.params = params;
            this.isCurrentClass = isCurrentClass;
            this.isNoParams = isNoParams;
        }
    }

    /**
     * 映射Map
     * 泛型Object是指令,
     * 泛型Action是指令对应的执行方案
     */
    private static final HashMap<Object,Action> ACTION_MAP = new HashMap<>(16);

    static class ResultAction{

        public void helloWorld(String name){
            System.out.println(name + ",你好世界");
        }

    }


    static {
        //都不为空
        ACTION_MAP.put(0,new Action(ResultAction.class,"helloWorld",new Class[]{String.class},new String[]{"我是张三"},false,false));
        //abc不为空 d为空
        ACTION_MAP.put(1,new Action(ResultAction.class,"helloWorld",new Class[]{String.class},new String[]{"我是李四"},false,false));
        //ab不为空 cd为空
        ACTION_MAP.put(11,new Action(ResultAction.class,"helloWorld",new Class[]{String.class},new String[]{"我是王五"},false,false));
        //a不为空 bcd为空
        ACTION_MAP.put(111,new Action(ResultAction.class,"helloWorld",new Class[]{String.class},new String[]{"我是赵六"},false,false));
        //abcd都为空
        ACTION_MAP.put(1111,new Action(ResultAction.class,"helloWorld",new Class[]{String.class},new String[]{"我是张三他爹"},false,false));
    }

    private static void test(String a,String b,String c,String d){
        int result = init(a, b, c, d);
        Action action = ACTION_MAP.get(result);
        if(action != null){
            handler(action);
        }else{
            System.out.println("未找到对应映射键");
        }
    }

    private static void handler(Action action) {
        try {
            Method method = null;
            Class cls = null;
            if (action.isCurrentClass()) {
                method = getMethod(SolutionTwo.class,action.getTargetMethodName(),action.getParameterTypes());
                cls = SolutionTwo.class;
            }else{
                Class targetClass = action.getTargetInvokeClass();
                method = getMethod(targetClass, action.getTargetMethodName(), action.getParameterTypes());
                cls = action.getTargetInvokeClass();
            }
            result = method.invoke(cls.newInstance(), action.getParams());
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException e) {
            e.printStackTrace();
        }
    }


    private static Method getMethod(Class cls,String methodName,Class[] parameterTypes) throws NoSuchMethodException {
        return cls.getMethod(methodName,parameterTypes);
    }


    private static int init(String ... allParam){
        if(allParam == null){
            return 1;
        }
        String resultNumberStr = "";
        for (String s : allParam) {
            resultNumberStr += StringUtils.isNotEmpty(s) ? 0 : 1;
        }
        return Integer.valueOf(resultNumberStr);
    }

    public static void main(String[] args) {
        test("1",null,null,null);
    }
}