/**
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You 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.apache.activemq.broker.region;

import java.io.IOException;
import java.util.List;
import java.util.Set;

import org.apache.activemq.broker.Broker;
import org.apache.activemq.broker.ConnectionContext;
import org.apache.activemq.broker.ProducerBrokerExchange;
import org.apache.activemq.broker.region.policy.DeadLetterStrategy;
import org.apache.activemq.broker.region.policy.SlowConsumerStrategy;
import org.apache.activemq.command.ActiveMQDestination;
import org.apache.activemq.command.Message;
import org.apache.activemq.command.MessageAck;
import org.apache.activemq.command.MessageDispatchNotification;
import org.apache.activemq.command.ProducerInfo;
import org.apache.activemq.store.MessageStore;
import org.apache.activemq.usage.MemoryUsage;
import org.apache.activemq.usage.Usage;
import org.apache.activemq.util.SubscriptionKey;

/**
 *
 *
 */
public class DestinationFilter implements Destination {

    protected final Destination next;

    public DestinationFilter(Destination next) {
        this.next = next;
    }

    @Override
    public void acknowledge(ConnectionContext context, Subscription sub, MessageAck ack, MessageReference node) throws IOException {
        next.acknowledge(context, sub, ack, node);
    }

    @Override
    public void addSubscription(ConnectionContext context, Subscription sub) throws Exception {
        next.addSubscription(context, sub);
    }

    @Override
    public Message[] browse() {
        return next.browse();
    }

    @Override
    public void dispose(ConnectionContext context) throws IOException {
        next.dispose(context);
    }

    @Override
    public boolean isDisposed() {
        return next.isDisposed();
    }

    @Override
    public void gc() {
        next.gc();
    }

    @Override
    public void markForGC(long timeStamp) {
        next.markForGC(timeStamp);
    }

    @Override
    public boolean canGC() {
        return next.canGC();
    }

    @Override
    public long getInactiveTimeoutBeforeGC() {
        return next.getInactiveTimeoutBeforeGC();
    }

    @Override
    public ActiveMQDestination getActiveMQDestination() {
        return next.getActiveMQDestination();
    }

    @Override
    public DeadLetterStrategy getDeadLetterStrategy() {
        return next.getDeadLetterStrategy();
    }

    @Override
    public DestinationStatistics getDestinationStatistics() {
        return next.getDestinationStatistics();
    }

    @Override
    public String getName() {
        return next.getName();
    }

    @Override
    public MemoryUsage getMemoryUsage() {
        return next.getMemoryUsage();
    }

    @Override
    public void setMemoryUsage(MemoryUsage memoryUsage) {
        next.setMemoryUsage(memoryUsage);
    }

    @Override
    public void removeSubscription(ConnectionContext context, Subscription sub, long lastDeliveredSequenceId) throws Exception {
        next.removeSubscription(context, sub, lastDeliveredSequenceId);
    }

    @Override
    public void send(ProducerBrokerExchange context, Message messageSend) throws Exception {
        next.send(context, messageSend);
    }

    @Override
    public void start() throws Exception {
        next.start();
    }

    @Override
    public void stop() throws Exception {
        next.stop();
    }

    @Override
    public List<Subscription> getConsumers() {
        return next.getConsumers();
    }

    /**
     * Sends a message to the given destination which may be a wildcard
     *
     * @param context broker context
     * @param message message to send
     * @param destination possibly wildcard destination to send the message to
     * @throws Exception on error
     */
    protected void send(ProducerBrokerExchange context, Message message, ActiveMQDestination destination) throws Exception {
        Broker broker = context.getConnectionContext().getBroker();
        Set<Destination> destinations = broker.getDestinations(destination);

        for (Destination dest : destinations) {
            dest.send(context, message.copy());
        }
    }

    @Override
    public MessageStore getMessageStore() {
        return next.getMessageStore();
    }

    @Override
    public boolean isProducerFlowControl() {
        return next.isProducerFlowControl();
    }

    @Override
    public void setProducerFlowControl(boolean value) {
        next.setProducerFlowControl(value);
    }

    @Override
    public boolean isAlwaysRetroactive() {
        return next.isAlwaysRetroactive();
    }

    @Override
    public void setAlwaysRetroactive(boolean value) {
        next.setAlwaysRetroactive(value);
    }

    @Override
    public void setBlockedProducerWarningInterval(long blockedProducerWarningInterval) {
        next.setBlockedProducerWarningInterval(blockedProducerWarningInterval);
    }

    @Override
    public long getBlockedProducerWarningInterval() {
        return next.getBlockedProducerWarningInterval();
    }

    @Override
    public void addProducer(ConnectionContext context, ProducerInfo info) throws Exception {
        next.addProducer(context, info);
    }

    @Override
    public void removeProducer(ConnectionContext context, ProducerInfo info) throws Exception {
        next.removeProducer(context, info);
    }

    @Override
    public int getMaxAuditDepth() {
        return next.getMaxAuditDepth();
    }

    @Override
    public int getMaxProducersToAudit() {
        return next.getMaxProducersToAudit();
    }

    @Override
    public boolean isEnableAudit() {
        return next.isEnableAudit();
    }

    @Override
    public void setEnableAudit(boolean enableAudit) {
        next.setEnableAudit(enableAudit);
    }

    @Override
    public void setMaxAuditDepth(int maxAuditDepth) {
        next.setMaxAuditDepth(maxAuditDepth);
    }

    @Override
    public void setMaxProducersToAudit(int maxProducersToAudit) {
        next.setMaxProducersToAudit(maxProducersToAudit);
    }

    @Override
    public boolean isActive() {
        return next.isActive();
    }

    @Override
    public int getMaxPageSize() {
        return next.getMaxPageSize();
    }

    @Override
    public void setMaxPageSize(int maxPageSize) {
        next.setMaxPageSize(maxPageSize);
    }

    @Override
    public boolean isUseCache() {
        return next.isUseCache();
    }

    @Override
    public void setUseCache(boolean useCache) {
        next.setUseCache(useCache);
    }

    @Override
    public int getMinimumMessageSize() {
        return next.getMinimumMessageSize();
    }

    @Override
    public void setMinimumMessageSize(int minimumMessageSize) {
        next.setMinimumMessageSize(minimumMessageSize);
    }

    @Override
    public void wakeup() {
        next.wakeup();
    }

    @Override
    public boolean isLazyDispatch() {
        return next.isLazyDispatch();
    }

    @Override
    public void setLazyDispatch(boolean value) {
        next.setLazyDispatch(value);
    }

    public void messageExpired(ConnectionContext context, PrefetchSubscription prefetchSubscription, MessageReference node) {
        next.messageExpired(context, prefetchSubscription, node);
    }

    @Override
    public boolean iterate() {
        return next.iterate();
    }

    @Override
    public void fastProducer(ConnectionContext context, ProducerInfo producerInfo) {
        next.fastProducer(context, producerInfo);
    }

    @Override
    public void isFull(ConnectionContext context, Usage<?> usage) {
        next.isFull(context, usage);
    }

    @Override
    public void messageConsumed(ConnectionContext context, MessageReference messageReference) {
        next.messageConsumed(context, messageReference);
    }

    @Override
    public void messageDelivered(ConnectionContext context, MessageReference messageReference) {
        next.messageDelivered(context, messageReference);
    }

    @Override
    public void messageDiscarded(ConnectionContext context, Subscription sub, MessageReference messageReference) {
        next.messageDiscarded(context, sub, messageReference);
    }

    @Override
    public void slowConsumer(ConnectionContext context, Subscription subs) {
        next.slowConsumer(context, subs);
    }

    @Override
    public void messageExpired(ConnectionContext context, Subscription subs, MessageReference node) {
        next.messageExpired(context, subs, node);
    }

    @Override
    public int getMaxBrowsePageSize() {
        return next.getMaxBrowsePageSize();
    }

    @Override
    public void setMaxBrowsePageSize(int maxPageSize) {
        next.setMaxBrowsePageSize(maxPageSize);
    }

    @Override
    public void processDispatchNotification(MessageDispatchNotification messageDispatchNotification) throws Exception {
        next.processDispatchNotification(messageDispatchNotification);
    }

    @Override
    public int getCursorMemoryHighWaterMark() {
        return next.getCursorMemoryHighWaterMark();
    }

    @Override
    public void setCursorMemoryHighWaterMark(int cursorMemoryHighWaterMark) {
        next.setCursorMemoryHighWaterMark(cursorMemoryHighWaterMark);
    }

    @Override
    public boolean isPrioritizedMessages() {
        return next.isPrioritizedMessages();
    }

    @Override
    public SlowConsumerStrategy getSlowConsumerStrategy() {
        return next.getSlowConsumerStrategy();
    }

    @Override
    public boolean isDoOptimzeMessageStorage() {
        return next.isDoOptimzeMessageStorage();
    }

    @Override
    public void setDoOptimzeMessageStorage(boolean doOptimzeMessageStorage) {
        next.setDoOptimzeMessageStorage(doOptimzeMessageStorage);
    }

    @Override
    public void clearPendingMessages() {
        next.clearPendingMessages();
    }

    @Override
    public void duplicateFromStore(Message message, Subscription subscription) {
        next.duplicateFromStore(message, subscription);
    }

    public void deleteSubscription(ConnectionContext context, SubscriptionKey key) throws Exception {
        if (next instanceof DestinationFilter) {
            DestinationFilter filter = (DestinationFilter) next;
            filter.deleteSubscription(context, key);
        } else if (next instanceof Topic) {
            Topic topic = (Topic)next;
            topic.deleteSubscription(context, key);
        }
    }

    public Destination getNext() {
        return next;
    }

    public <T> T getAdaptor(Class <? extends T> clazz) {
        if (clazz.isInstance(this)) {
            return clazz.cast(this);
        } else if (next != null && clazz.isInstance(next)) {
            return clazz.cast(next);
        } else if (next instanceof DestinationFilter) {
            return ((DestinationFilter)next).getAdaptor(clazz);
        }
        return null;
    }
}
