/*
 * 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.
 */

#ifndef _ACTIVEMQ_COMMANDS_ACTIVEMQDESTINATION_H_
#define _ACTIVEMQ_COMMANDS_ACTIVEMQDESTINATION_H_

#include <activemq/util/Config.h>
#include <activemq/commands/BaseDataStructure.h>
#include <activemq/util/ActiveMQProperties.h>
#include <cms/Destination.h>
#include <decaf/lang/Pointer.h>
#include <decaf/lang/Comparable.h>
#include <decaf/util/ArrayList.h>

#include <vector>
#include <string>
#include <map>

namespace activemq {
namespace commands {

    using decaf::lang::Pointer;

    class AMQCPP_API ActiveMQDestination : public BaseDataStructure,
                                           public decaf::lang::Comparable<ActiveMQDestination> {
    protected:

        struct DestinationFilter{
            static const std::string ANY_CHILD;
            static const std::string ANY_DESCENDENT;
        };

        /**
         * The default target for ordered destinations
         */
        static const std::string DEFAULT_ORDERED_TARGET;

        static const std::string TEMP_PREFIX;
        static const std::string TEMP_POSTFIX;
        static const std::string COMPOSITE_SEPARATOR;

        static const std::string QUEUE_QUALIFIED_PREFIX;
        static const std::string TOPIC_QUALIFIED_PREFIX;
        static const std::string TEMP_QUEUE_QUALIFED_PREFIX;
        static const std::string TEMP_TOPIC_QUALIFED_PREFIX;

        // Cached transient data
        bool exclusive;
        bool ordered;
        bool advisory;
        mutable decaf::util::ArrayList< Pointer<ActiveMQDestination> > compositeDestinations;
        std::string orderedTarget;

        std::string physicalName;
        util::ActiveMQProperties options;
        int hashCode;

    public:

        const static unsigned char ID_ACTIVEMQDESTINATION = 0;

        static const std::string TEMP_DESTINATION_NAME_PREFIX;

        typedef decaf::lang::PointerComparator<ActiveMQDestination> COMPARATOR;

    private:

        ActiveMQDestination(const ActiveMQDestination&);
        ActiveMQDestination& operator=(const ActiveMQDestination&);

    public:

        ActiveMQDestination();

        ActiveMQDestination(const std::string& physicalName);

        virtual ~ActiveMQDestination() throw();

        virtual ActiveMQDestination* cloneDataStructure() const {
            return NULL;
        }

        virtual void copyDataStructure(const DataStructure* src);

        virtual bool equals(const DataStructure* value) const;

        virtual unsigned char getDataStructureType() const;

        virtual std::string toString() const;

        int getHashCode() const {
            return this->hashCode;
        }

    public:

        /**
         * Fetch this destination's physical name
         * @return const string containing the name
         */
        virtual std::string getPhysicalName() const {
            return this->physicalName;
        }

        /**
         * Set this destination's physical name
         * @return const string containing the name
         */
        virtual void setPhysicalName(const std::string& physicalName);

        /**
         * @return Returns the advisory.
         */
        virtual bool isAdvisory() const {
            return advisory;
        }

        /**
         * @param advisory The advisory to set.
         */
        virtual void setAdvisory(bool advisory) {
            this->advisory = advisory;
        }

        /**
         * @return Returns the exclusive.
         */
        virtual bool isExclusive() const {
            return exclusive;
        }

        /**
         * @param exclusive The exclusive to set.
         */
        virtual void setExclusive( bool exclusive ) {
            this->exclusive = exclusive;
        }

        /**
         * @return Returns the ordered.
         */
        virtual bool isOrdered() const {
            return ordered;
        }

        /**
         * @param ordered The ordered to set.
         */
        virtual void setOrdered(bool ordered) {
            this->ordered = ordered;
        }

        /**
         * @return Returns the orderedTarget.
         */
        virtual std::string getOrderedTarget() const {
            return orderedTarget;
        }

        /**
         * @param orderedTarget The orderedTarget to set.
         */
        virtual void setOrderedTarget(const std::string& orderedTarget) {
            this->orderedTarget = orderedTarget;
        }

        /**
         * Returns the Type of Destination that this object represents
         * @return int type qualifier.
         */
        virtual cms::Destination::DestinationType getDestinationType() const = 0;

        /**
         * Returns the type of Destination that this object represents as a string, the
         * available string values are, "Queue", "Topic", "TempQueue" and "TempTopic".
         *
         * @return The string value that represents the type of this destination.
         */
        std::string getDestinationTypeAsString() const;

        /**
         * Returns true if a temporary Destination
         * @return true/false
         */
        virtual bool isTemporary() const {
            return getDestinationType() == cms::Destination::TEMPORARY_TOPIC ||
                   getDestinationType() == cms::Destination::TEMPORARY_QUEUE;
        }

        /**
         * Returns true if a Topic Destination
         * @return true/false
         */
        virtual bool isTopic() const {
            return getDestinationType() == cms::Destination::TOPIC ||
                   getDestinationType() == cms::Destination::TEMPORARY_TOPIC;
        }

        /**
         * Returns true if a Queue Destination
         * @return true/false
         */
        virtual bool isQueue() const {
            return !isTopic();
        }

        /**
         * Returns true if this destination represents a collection of
         * destinations; allowing a set of destinations to be published to or
         * subscribed from in one CMS operation.
         *
         * @return true if this destination represents a collection of child
         *         destinations.
         */
        virtual bool isComposite() const {
            return physicalName.find_first_of(COMPOSITE_SEPARATOR) != std::string::npos;
        }

        /**
         * Returns an ArrayList containing all the ActiveMQDestinations that comprise this
         * Composite destination, if this destination is composite, otherwise it returns an
         * empty list.
         */
        decaf::util::ArrayList< Pointer<ActiveMQDestination> > getCompositeDestinations() const;

        /**
         * @return true if the destination matches multiple possible destinations
         */
        virtual bool isWildcard() const {
            return physicalName.find_first_of(DestinationFilter::ANY_CHILD) != std::string::npos||
                   physicalName.find_first_of(DestinationFilter::ANY_DESCENDENT) != std::string::npos;
        }

        /**
         * @return a reference (const) to the options properties for this Destination.
         */
        const activemq::util::ActiveMQProperties& getOptions() const {
            return options;
        }

        /**
         * @return the cms::Destination interface pointer that the
         *          objects that derive from this class implement.
         */
        virtual const cms::Destination* getCMSDestination() const {
            return NULL;
        }

        /**
         * Create a new Destination that's of the same type as this one but with
         * the given destination name.
         *
         * @param name
         *      The name
         *
         * @return Pointer to a new ActiveMQDestination.
         */
        Pointer<ActiveMQDestination> createDestination(const std::string& name) const {
            return ActiveMQDestination::createDestination(getDestinationType(), name);
        }

        virtual int compareTo(const ActiveMQDestination& value) const;

        virtual bool equals(const ActiveMQDestination& value) const;

        virtual bool operator==(const ActiveMQDestination& value) const;

        virtual bool operator<(const ActiveMQDestination& value) const;

    public:  // Statics

        /**
         * Create a temporary name from the clientId
         *
         * @param clientId
         * @return
         */
        static std::string createTemporaryName(const std::string& clientId) {
            return TEMP_PREFIX + clientId + TEMP_POSTFIX;
        }

        /**
         * From a temporary destination find the clientId of the Connection that created it
         *
         * @param destination
         * @return the clientId or null if not a temporary destination
         */
        static std::string getClientId(const ActiveMQDestination* destination);

        /**
         * Creates a Destination given the String Name to use and a Type.
         *
         * @param type - The Type of Destination to Create
         * @param name - The Name to use in the creation of the Destination
         *
         * @return Pointer to a new ActiveMQDestination instance.
         */
        static Pointer<ActiveMQDestination> createDestination(int type, const std::string& name);

    };

}}

#endif /*_ACTIVEMQ_COMMANDS_ACTIVEMQDESTINATION_H_*/