package me.tojatta.api.event;

import me.tojatta.api.event.types.Event;
import me.tojatta.api.management.MapManager;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.*;

/**
 * Created by Tojatta on 6/28/2016.
 */
public final class EventSystem extends MapManager<Class<? extends Event>, EnumMap<Priority, HashSet<MethodData>>> {

    private static EventSystem instance;

    public EventSystem() {
        setup();
    }

    @Override
    public void setup() {
        if (map == null) {
            map = new HashMap<>();
        }
        map.clear();
    }

    public static EventSystem getInstance() {
        if (instance == null) {
            instance = new EventSystem();
        }
        return instance;
    }

    public void callEvent(Event event) {
        EnumMap<Priority, HashSet<MethodData>> prioritizedMethodMap = map.get(event.getClass());

        if (prioritizedMethodMap == null) {
            return;
        }

        Arrays.stream(Priority.values())
                .filter(priority -> prioritizedMethodMap.get(priority) != null)
                .forEach(priority -> prioritizedMethodMap.get(priority).stream().forEach(methodData -> {

                    boolean accessible = methodData.getMethod().isAccessible();

                    methodData.getMethod().setAccessible(true);

                    try {

                        methodData.getMethod().invoke(methodData.getObject(), event);

                    } catch (IllegalAccessException | InvocationTargetException e) {
                        e.printStackTrace();
                    }

                    methodData.getMethod().setAccessible(accessible);

                }));
    }

    public void registerListener(Object object) {

        Arrays.stream(object.getClass().getDeclaredMethods())
                .filter(method -> method.getAnnotation(EventListener.class) != null)
                .filter(method -> method.getParameterTypes().length != 0)
                .forEach(method -> handleRegister(method, object));

    }

    public void unregisterListener(Object object) {
        HashSet<MethodData> remove = new HashSet<>();

        Arrays.stream(object.getClass().getDeclaredMethods())
                .forEach(method -> map.values().stream()
                        .forEach(priorityHashSetEnumMap -> Arrays.stream(Priority.values())
                                .filter(priority -> priorityHashSetEnumMap.get(priority) != null)
                                .forEach(priority -> {

                                    priorityHashSetEnumMap.get(priority).stream()
                                            .filter(methodData -> methodData.getMethod().toString().equals(method.toString()))
                                            .forEach(methodData -> remove.add(methodData));

                                    remove.stream().forEach(methodData -> priorityHashSetEnumMap.get(priority).remove(methodData));

                                })));

    }

    private void handleRegister(Method method, Object object) {
        EventListener listener = method.getAnnotation(EventListener.class);
        if (!map.containsKey(listener.event())) {
            HashSet<MethodData> hashSet = new HashSet<>();
            EnumMap<Priority, HashSet<MethodData>> enumMap = new EnumMap<>(Priority.class);
            hashSet.add(new MethodData(method, object));
            enumMap.put(listener.priority(), hashSet);
            map.put(listener.event(), enumMap);
        } else {
            Map<Priority, HashSet<MethodData>> eventTypeMap = map.get(listener.event());
            if (!eventTypeMap.containsKey(listener.priority())) {
                HashSet<MethodData> hashSet = new HashSet<>();
                hashSet.add(new MethodData(method, object));
                eventTypeMap.put(listener.priority(), hashSet);
            } else {
                eventTypeMap.get(listener.priority()).add(new MethodData(method, object));
            }
        }
    }
}