/*
 * Decompiled with CFR 0.152.
 */
package gearth.extensions;

import gearth.extensions.Extension;
import gearth.extensions.ExtensionInfo;
import gearth.extensions.IExtension;
import gearth.extensions.OnConnectionListener;
import gearth.misc.HostInfo;
import gearth.misc.listenerpattern.Observable;
import gearth.misc.listenerpattern.ObservableObject;
import gearth.protocol.HMessage;
import gearth.protocol.HPacket;
import gearth.services.packet_info.PacketInfo;
import gearth.services.packet_info.PacketInfoManager;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

public abstract class ExtensionBase
extends IExtension {
    protected final Map<Integer, List<MessageListener>> incomingMessageListeners = new HashMap<Integer, List<MessageListener>>();
    protected final Map<Integer, List<MessageListener>> outgoingMessageListeners = new HashMap<Integer, List<MessageListener>>();
    protected final Map<String, List<MessageListener>> hashOrNameIncomingListeners = new HashMap<String, List<MessageListener>>();
    protected final Map<String, List<MessageListener>> hashOrNameOutgoingListeners = new HashMap<String, List<MessageListener>>();
    volatile PacketInfoManager packetInfoManager = PacketInfoManager.EMPTY;
    ObservableObject<HostInfo> observableHostInfo = new ObservableObject<Object>(null);
    private Observable<OnConnectionListener> onConnectionObservable = new Observable();

    void updateHostInfo(HostInfo hostInfo) {
        this.observableHostInfo.setObject(hostInfo);
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    @Override
    public void intercept(HMessage.Direction direction, int headerId, MessageListener messageListener) {
        Map<Integer, List<MessageListener>> listeners;
        Map<Integer, List<MessageListener>> map = listeners = direction == HMessage.Direction.TOCLIENT ? this.incomingMessageListeners : this.outgoingMessageListeners;
        synchronized (map) {
            if (!listeners.containsKey(headerId)) {
                listeners.put(headerId, new ArrayList());
            }
            listeners.get(headerId).add(messageListener);
        }
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    @Override
    public void intercept(HMessage.Direction direction, String hashOrName, MessageListener messageListener) {
        Map<String, List<MessageListener>> listeners;
        Map<String, List<MessageListener>> map = listeners = direction == HMessage.Direction.TOCLIENT ? this.hashOrNameIncomingListeners : this.hashOrNameOutgoingListeners;
        synchronized (map) {
            if (!listeners.containsKey(hashOrName)) {
                listeners.put(hashOrName, new ArrayList());
            }
            listeners.get(hashOrName).add(messageListener);
        }
    }

    @Override
    public void intercept(HMessage.Direction direction, MessageListener messageListener) {
        this.intercept(direction, -1, messageListener);
    }

    @Override
    public void writeToConsole(String s) {
        this.writeToConsole("black", s);
    }

    protected boolean isOnClickMethodUsed() {
        for (Class<?> c = this.getClass(); c != Extension.class; c = c.getSuperclass()) {
            try {
                c.getDeclaredMethod("onClick", new Class[0]);
                return true;
            }
            catch (NoSuchMethodException noSuchMethodException) {
                continue;
            }
        }
        return false;
    }

    /*
     * WARNING - Removed try catching itself - possible behaviour change.
     */
    public void modifyMessage(HMessage habboMessage) {
        HPacket habboPacket = habboMessage.getPacket();
        Map<Integer, List<MessageListener>> listeners = habboMessage.getDestination() == HMessage.Direction.TOCLIENT ? this.incomingMessageListeners : this.outgoingMessageListeners;
        Map<String, List<MessageListener>> hashOrNameListeners = habboMessage.getDestination() == HMessage.Direction.TOCLIENT ? this.hashOrNameIncomingListeners : this.hashOrNameOutgoingListeners;
        HashSet<MessageListener> correctListeners = new HashSet<MessageListener>();
        Object object = listeners;
        synchronized (object) {
            int i;
            if (listeners.containsKey(-1)) {
                for (i = listeners.get(-1).size() - 1; i >= 0; --i) {
                    correctListeners.add(listeners.get(-1).get(i));
                }
            }
            if (listeners.containsKey(habboPacket.headerId())) {
                for (i = listeners.get(habboPacket.headerId()).size() - 1; i >= 0; --i) {
                    correctListeners.add(listeners.get(habboPacket.headerId()).get(i));
                }
            }
        }
        object = hashOrNameListeners;
        synchronized (object) {
            List<PacketInfo> packetInfos = this.packetInfoManager.getAllPacketInfoFromHeaderId(habboMessage.getDestination(), habboPacket.headerId());
            ArrayList identifiers = new ArrayList();
            packetInfos.forEach(packetInfo -> {
                String name = packetInfo.getName();
                String hash = packetInfo.getHash();
                if (name != null && hashOrNameListeners.containsKey(name)) {
                    identifiers.add(name);
                }
                if (hash != null && hashOrNameListeners.containsKey(hash)) {
                    identifiers.add(hash);
                }
            });
            for (String identifier : identifiers) {
                for (int i = hashOrNameListeners.get(identifier).size() - 1; i >= 0; --i) {
                    correctListeners.add(hashOrNameListeners.get(identifier).get(i));
                }
            }
        }
        for (MessageListener listener : correctListeners) {
            habboMessage.getPacket().resetReadIndex();
            listener.act(habboMessage);
        }
        habboMessage.getPacket().resetReadIndex();
    }

    @Override
    void onClick() {
    }

    @Override
    protected ExtensionInfo getInfoAnnotations() {
        return this.getClass().getAnnotation(ExtensionInfo.class);
    }

    @Override
    public void onConnect(OnConnectionListener listener) {
        this.onConnectionObservable.addListener(listener);
    }

    Observable<OnConnectionListener> getOnConnectionObservable() {
        return this.onConnectionObservable;
    }

    void setPacketInfoManager(PacketInfoManager packetInfoManager) {
        this.packetInfoManager = packetInfoManager;
    }

    @Override
    public PacketInfoManager getPacketInfoManager() {
        return this.packetInfoManager;
    }

    public HostInfo getHostInfo() {
        return this.observableHostInfo.getObject();
    }

    public static interface FlagsCheckListener {
        public void act(String[] var1);
    }

    public static interface MessageListener {
        public void act(HMessage var1);
    }
}