package dev.wiing.gossip.lib;

import dev.wiing.gossip.lib.packets.*;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.stream.Collectors;

public class PacketHandler {

    private final Map<Class<? extends Packet>, Packet> packetClassMap = new HashMap<>();

    private final Map<Class<? extends Packet>, Set<PacketListener<? extends Packet>>> listeners = new ConcurrentHashMap<>();

    public void clearPacketMap() {
        packetClassMap.clear();
    }

    public void addPacketToMap(Packet packet) {
        packetClassMap.put(packet.getClass(), packet);
    }

    public void addAllPacketsToMap(Collection<Packet> packets) {
        packetClassMap.putAll(packets.stream()
                .collect(Collectors.toMap(Packet::getClass, o -> o)));
    }

    public <T extends Packet> void addListener(Class<T> type, PacketListener<T> listener) {
        if (!listeners.containsKey(type)) {
            listeners.put(type, new HashSet<>());
        }

        listeners.get(type).add(listener);
    }

    public <T extends Packet> void removeListener(Class<T> type, PacketListener<T> listener) {
        if (!listeners.containsKey(type)) {
            return;
        }

        listeners.get(type).remove(listener);
    }

    public <T extends Packet> boolean runPacket(Class<T> packetClass, T packet) {
        Set<PacketListener<T>> result = getListeners(packetClass);

        if (result == null || result.isEmpty()) return false;

        for (PacketListener<T> packetListener : result) {
            packetListener.onReceive(packet);
        }

        return true;
    }

    public boolean runPacket(Packet packet) {
        return runPacket((Class<Packet>)packet.getClass(), packet);
    }

    public <T extends Packet> Set<PacketListener<T>> getListeners(Class<T> packetClass) {
        if (!listeners.containsKey(packetClass))
            return null;

        return listeners.get(packetClass).stream()
                .map(listener -> (PacketListener<T>) listener)
                .collect(Collectors.toSet());
    }

    public List<Short> getListeningTypes() {
        return listeners.entrySet().stream()
                .filter(classSetEntry -> !classSetEntry.getValue().isEmpty())
                .map(Map.Entry::getKey)
                .map(packetClassMap::get)
                .map(Packet::getType)
                .collect(Collectors.toList());
    }

}