/**
 *
 * Copyright 2003-2007 Jive Software, 2015-2020 Florian Schmaus
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.jivesoftware.smackx.pep;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.WeakHashMap;
import java.util.concurrent.CopyOnWriteArraySet;
import java.util.logging.Logger;

import org.jivesoftware.smack.AsyncButOrdered;
import org.jivesoftware.smack.Manager;
import org.jivesoftware.smack.SmackException.NoResponseException;
import org.jivesoftware.smack.SmackException.NotConnectedException;
import org.jivesoftware.smack.StanzaListener;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException.XMPPErrorException;
import org.jivesoftware.smack.filter.AndFilter;
import org.jivesoftware.smack.filter.MessageTypeFilter;
import org.jivesoftware.smack.filter.StanzaFilter;
import org.jivesoftware.smack.filter.jidtype.FromJidTypeFilter;
import org.jivesoftware.smack.packet.ExtensionElement;
import org.jivesoftware.smack.packet.Message;
import org.jivesoftware.smack.packet.NamedElement;
import org.jivesoftware.smack.packet.Stanza;
import org.jivesoftware.smack.util.CollectionUtil;
import org.jivesoftware.smack.util.MultiMap;

import org.jivesoftware.smackx.disco.ServiceDiscoveryManager;
import org.jivesoftware.smackx.pubsub.EventElement;
import org.jivesoftware.smackx.pubsub.Item;
import org.jivesoftware.smackx.pubsub.ItemsExtension;
import org.jivesoftware.smackx.pubsub.LeafNode;
import org.jivesoftware.smackx.pubsub.PayloadItem;
import org.jivesoftware.smackx.pubsub.PubSubException.NotALeafNodeException;
import org.jivesoftware.smackx.pubsub.PubSubFeature;
import org.jivesoftware.smackx.pubsub.PubSubManager;
import org.jivesoftware.smackx.pubsub.filter.EventItemsExtensionFilter;

import org.jxmpp.jid.BareJid;
import org.jxmpp.jid.EntityBareJid;

/**
 *
 * Manages Personal Event Publishing (XEP-163). A PEPManager provides a high level access to
 * PubSub personal events. It also provides an easy way
 * to hook up custom logic when events are received from another XMPP client through PEPListeners.
 *
 * Use example:
 *
 * <pre>
 *   PepManager pepManager = PepManager.getInstanceFor(smackConnection);
 *   pepManager.addPepListener(new PepListener() {
 *       public void eventReceived(EntityBareJid from, EventElement event, Message message) {
 *           LOGGER.debug("Event received: " + event);
 *       }
 *   });
 * </pre>
 *
 * @author Jeff Williams
 * @author Florian Schmaus
 */
public final class PepManager extends Manager {

    private static final Logger LOGGER = Logger.getLogger(PepManager.class.getName());

    private static final Map<XMPPConnection, PepManager> INSTANCES = new WeakHashMap<>();

    public static synchronized PepManager getInstanceFor(XMPPConnection connection) {
        PepManager pepManager = INSTANCES.get(connection);
        if (pepManager == null) {
            pepManager = new PepManager(connection);
            INSTANCES.put(connection, pepManager);
        }
        return pepManager;
    }

    // TODO: Ideally PepManager would re-use PubSubManager for this. But the functionality in PubSubManager does not yet
    // exist.
    private static final StanzaFilter PEP_EVENTS_FILTER = new AndFilter(
            MessageTypeFilter.NORMAL_OR_HEADLINE,
            FromJidTypeFilter.ENTITY_BARE_JID,
            EventItemsExtensionFilter.INSTANCE);

    private final Set<PepListener> pepListeners = new CopyOnWriteArraySet<>();

    private final AsyncButOrdered<EntityBareJid> asyncButOrdered = new AsyncButOrdered<>();

    private final ServiceDiscoveryManager serviceDiscoveryManager;

    private final PubSubManager pepPubSubManager;

    private final MultiMap<String, PepEventListenerCoupling<? extends ExtensionElement>> pepEventListeners = new MultiMap<>();

    private final Map<PepEventListener<?>, PepEventListenerCoupling<?>> listenerToCouplingMap = new HashMap<>();

    /**
     * Creates a new PEP exchange manager.
     *
     * @param connection an XMPPConnection which is used to send and receive messages.
     */
    private PepManager(XMPPConnection connection) {
        super(connection);

        serviceDiscoveryManager = ServiceDiscoveryManager.getInstanceFor(connection);
        pepPubSubManager = PubSubManager.getInstanceFor(connection, null);

        StanzaListener packetListener = new StanzaListener() {
            @Override
            public void processStanza(Stanza stanza) {
                final Message message = (Message) stanza;
                final EventElement event = EventElement.from(stanza);
                assert event != null;
                final EntityBareJid from = message.getFrom().asEntityBareJidIfPossible();
                assert from != null;

                asyncButOrdered.performAsyncButOrdered(from, new Runnable() {
                    @Override
                    public void run() {
                        ItemsExtension itemsExtension = (ItemsExtension) event.getEvent();
                        String node = itemsExtension.getNode();

                        for (PepListener listener : pepListeners) {
                            listener.eventReceived(from, event, message);
                        }

                        List<PepEventListenerCoupling<? extends ExtensionElement>> nodeListeners;
                        synchronized (pepEventListeners) {
                            nodeListeners = pepEventListeners.getAll(node);
                            if (nodeListeners.isEmpty()) {
                                return;
                            }

                            // Make a copy of the list. Note that it is important to do this within the synchronized
                            // block.
                            nodeListeners = CollectionUtil.newListWith(nodeListeners);
                        }

                        for (PepEventListenerCoupling<? extends ExtensionElement> listener : nodeListeners) {
                            // TODO: Can there be more than one item?
                            List<? extends NamedElement> items = itemsExtension.getItems();
                            for (NamedElement namedElementItem : items) {
                                Item item = (Item) namedElementItem;
                                String id = item.getId();
                                @SuppressWarnings("unchecked")
                                PayloadItem<ExtensionElement> payloadItem = (PayloadItem<ExtensionElement>) item;
                                ExtensionElement payload = payloadItem.getPayload();

                                listener.invoke(from, payload, id, message);
                            }
                        }
                    }
                });
            }
        };
        // TODO Add filter to check if from supports PubSub as per xep163 2 2.4
        connection.addSyncStanzaListener(packetListener, PEP_EVENTS_FILTER);
    }

    private static final class PepEventListenerCoupling<E extends ExtensionElement> {
        private final String node;
        private final Class<E> extensionElementType;
        private final PepEventListener<E> pepEventListener;

        private PepEventListenerCoupling(String node, Class<E> extensionElementType,
                        PepEventListener<E> pepEventListener) {
            this.node = node;
            this.extensionElementType = extensionElementType;
            this.pepEventListener = pepEventListener;
        }

        private void invoke(EntityBareJid from, ExtensionElement payload, String id, Message carrierMessage) {
            if (!extensionElementType.isInstance(payload)) {
                LOGGER.warning("Ignoring " + payload + " from " + carrierMessage + " as it is not of type "
                                + extensionElementType);
                return;
            }

            E extensionElementPayload = extensionElementType.cast(payload);
            pepEventListener.onPepEvent(from, extensionElementPayload, id, carrierMessage);
        }
    }

    public <E extends ExtensionElement> boolean addPepEventListener(String node, Class<E> extensionElementType,
                    PepEventListener<E> pepEventListener) {
        PepEventListenerCoupling<E> pepEventListenerCoupling = new PepEventListenerCoupling<>(node,
                        extensionElementType, pepEventListener);

        synchronized (pepEventListeners) {
            if (listenerToCouplingMap.containsKey(pepEventListener)) {
                return false;
            }
            listenerToCouplingMap.put(pepEventListener, pepEventListenerCoupling);
            /*
             * TODO: Replace the above with the below using putIfAbsent() if Smack's minimum required Android SDK level
             * is 24 or higher. PepEventListenerCoupling<?> currentPepEventListenerCoupling =
             * listenerToCouplingMap.putIfAbsent(pepEventListener, pepEventListenerCoupling); if
             * (currentPepEventListenerCoupling != null) { return false; }
             */

            boolean listenerForNodeExisted = pepEventListeners.put(node, pepEventListenerCoupling);
            if (!listenerForNodeExisted) {
                serviceDiscoveryManager.addFeature(node + PubSubManager.PLUS_NOTIFY);
            }
        }
        return true;
    }

    public boolean removePepEventListener(PepEventListener<?> pepEventListener) {
        synchronized (pepEventListeners) {
            PepEventListenerCoupling<?> pepEventListenerCoupling = listenerToCouplingMap.remove(pepEventListener);
            if (pepEventListenerCoupling == null) {
                return false;
            }

            String node = pepEventListenerCoupling.node;

            boolean mappingExisted = pepEventListeners.removeOne(node, pepEventListenerCoupling);
            assert mappingExisted;

            if (!pepEventListeners.containsKey(pepEventListenerCoupling.node)) {
                // This was the last listener for the node. Remove the +notify feature.
                serviceDiscoveryManager.removeFeature(node + PubSubManager.PLUS_NOTIFY);
            }
        }

        return true;
    }

    public PubSubManager getPepPubSubManager() {
        return pepPubSubManager;
    }

    /**
     * Adds a listener to PEPs. The listener will be fired anytime PEP events are received from remote XMPP clients.
     *
     * @param pepListener a roster exchange listener.
     * @return true if pepListener was added.
     * @deprecated use {@link #addPepEventListener(String, Class, PepEventListener)} instead.
     */
    // TODO: Remove in Smack 4.5
    @Deprecated
    public boolean addPepListener(PepListener pepListener) {
        return pepListeners.add(pepListener);
    }

    /**
     * Removes a listener from PEP events.
     *
     * @param pepListener a roster exchange listener.
     * @return true, if pepListener was removed.
     * @deprecated use {@link #removePepEventListener(PepEventListener)} instead.
     */
    // TODO: Remove in Smack 4.5.
    @Deprecated
    public boolean removePepListener(PepListener pepListener) {
        return pepListeners.remove(pepListener);
    }

    /**
     * Publish an event.
     *
     * @param nodeId the ID of the node to publish on.
     * @param item the item to publish.
     * @return the leaf node the item was published on.
     * @throws NotConnectedException if the XMPP connection is not connected.
     * @throws InterruptedException if the calling thread was interrupted.
     * @throws XMPPErrorException if there was an XMPP error returned.
     * @throws NoResponseException if there was no response from the remote entity.
     * @throws NotALeafNodeException if a PubSub leaf node operation was attempted on a non-leaf node.
     */
    public LeafNode publish(String nodeId, Item item) throws NotConnectedException, InterruptedException,
                    NoResponseException, XMPPErrorException, NotALeafNodeException {
        // PEP nodes are auto created if not existent. Hence Use PubSubManager.tryToPublishAndPossibleAutoCreate() here.
        return pepPubSubManager.tryToPublishAndPossibleAutoCreate(nodeId, item);
    }

    /**
     * XEP-163 5.
     */
    private static final PubSubFeature[] REQUIRED_FEATURES = new PubSubFeature[] {
        // @formatter:off
        PubSubFeature.auto_create,
        PubSubFeature.auto_subscribe,
        PubSubFeature.filtered_notifications,
        // @formatter:on
    };

    public boolean isSupported()
                    throws NoResponseException, XMPPErrorException, NotConnectedException, InterruptedException {
        XMPPConnection connection = connection();
        ServiceDiscoveryManager serviceDiscoveryManager = ServiceDiscoveryManager.getInstanceFor(connection);
        BareJid localBareJid = connection.getUser().asBareJid();
        return serviceDiscoveryManager.supportsFeatures(localBareJid, REQUIRED_FEATURES);
    }
}