package eu.mikroskeem.utils.reflect;

import lombok.Getter;
import org.jetbrains.annotations.Nullable;

import java.util.Arrays;
import java.util.stream.Stream;

@Deprecated
public class Validate {
    /* Code got from Google Guava */
    private static <T> T checkNotNull(T reference, @Nullable Object errorMessage) {
        if(reference == null) {
            throw new NullPointerException(String.valueOf(errorMessage));
        } else {
            return reference;
        }
    }

    public static void checkMethods(ClassDescriptor classDescriptor, Validate.MethodDescriptor... methods) {
        checkClass(classDescriptor);
        Stream.of(methods).forEach(methodDescriptor ->
            checkNotNull(Reflect.getMethod(classDescriptor.getClazz(),
                    methodDescriptor.getMethodName(),
                    methodDescriptor.getArguments()),
                    String.format("Method %s(%s) not found",
                            methodDescriptor.getMethodName(),
                            Arrays.toString(methodDescriptor.getArguments())
                    ))
        );
    }

    public static void checkConstructors(ClassDescriptor classDescriptor,
                                         Validate.ConstructorDescriptor... constructors) {
        checkClass(classDescriptor);
        Stream.of(constructors).forEach(constructorDescriptor -> {
            try {
                checkNotNull(classDescriptor.getClazz().getConstructor(constructorDescriptor.getArguments()),
                        String.format("Constructor (%s) not found",
                                Arrays.toString(constructorDescriptor.getArguments())
                        ));
            } catch (Exception e){
                throw new NullPointerException(e.getMessage());
            }
        });
    }

    public static void checkClass(ClassDescriptor classDescriptor){
        checkNotNull(classDescriptor.getClazz(), "Class is null");
        Stream.of(classDescriptor.getExtendingClasses()).forEach(clazz->{
            if(!clazz.isAssignableFrom(classDescriptor.getClazz())){
                throw new NullPointerException(String.format("Class doesn't extend %s", clazz.getSimpleName()));
            }
        });
    }

    public static @Getter class ClassDescriptor {
        private final Class<?> clazz;
        private final Class<?>[] extendingClasses;
        private ClassDescriptor(Class<?> clazz, Class<?>... arguments){
            this.clazz = clazz;
            this.extendingClasses = arguments;
        }

        public static ClassDescriptor newClassDescriptor(Class<?> clazz, Class<?>... classes){
            return new ClassDescriptor(clazz, classes);
        }

        public static ClassDescriptor newClassDescriptor(String clazzName, Class<?>... classes){
            Class<?> clazz = Reflect.getClass(clazzName);
            return new ClassDescriptor(clazz, classes);
        }
    }

    public static @Getter class ConstructorDescriptor {
        private final Class[] arguments;
        private ConstructorDescriptor(Class... arguments){
            this.arguments = arguments;
        }

        public static ConstructorDescriptor newConstructorDescriptor(Class... arguments){
            return new ConstructorDescriptor(arguments);
        }
    }

    public static @Getter class MethodDescriptor {
        private final String methodName;
        private final Class[] arguments;
        private MethodDescriptor(String methodName, Class... arguments){
            this.methodName = methodName;
            this.arguments = arguments;
        }

        public static MethodDescriptor newMethodDescriptor(String methodName, Class... arguments){
            return new MethodDescriptor(methodName, arguments);
        }
    }
}