/**
 * 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 __ZK_TREE_UTIL_H__
#define __ZK_TREE_UTIL_H__

#include <libxml/parser.h>
#include <libxml/tree.h>
#include "SimpleTree.h"
#include "ZkAdaptor.h"

namespace zktreeutil
{

#define ZKTREEUTIL_INF 1000000000
    /**
     * \brief A structure containing ZK node data.
     */
    struct ZkNodeData
    {
        /**
         * \brief The value string of the ZK node.
         */
        string value;

        /**
         * \brief The flag indicating whether children of the
         * \brief node shduld be ignored during create/diff/update
         */
        bool ignoreUpdate;

        /**
         * \brief Constructor.
         *
         * @param val the value string
         * @param ignore the flag indicating ignore any update/diff
         */
        ZkNodeData (const string& val, bool ignore=false)
            : value (val), ignoreUpdate (ignore) {}

        /**
         * \brief Constructor.
         *
         * @param ignore the flag indicating ignore any update/diff
         */
        ZkNodeData (bool ignore=false)
            : ignoreUpdate (ignore) {}
    };

    /**
     * \brief The type representing a ZK Treenode
     */
    typedef SimpleTreeNode< string, ZkNodeData > ZkTreeNode;

    /**
     * \brief The type representing a ZK Treenode smart-pointer
     */
    typedef boost::shared_ptr< ZkTreeNode > ZkTreeNodeSptr;

    /**
     * \brief The type representing a ZK Adapter smart-pointer
     */
    typedef boost::shared_ptr< ZooKeeperAdapter > ZooKeeperAdapterSptr;

    /**
     * \brief A structure defining a particular action on ZK node;
     * \brief the action can be any of -
     * \brief        CREAT- <zknode>                : creates <zknode> recussively
     * \brief        DELET- <zknode>              : deletes <zknode> recursively
     * \brief        VALUE- <zknode> <value>     : sets <value> to <zknode>
     */
    struct ZkAction
    {
        /**
         * \brief The action type; any of create/delete/setvalue.
         */
        enum ZkActionType
        {
            NONE,
            CREATE,
            DELETE,
            VALUE,
        };

        /**
         * \brief action of this instance
         */
        ZkActionType action;

        /**
         * \brief ZK node key
         */
        string key;

        /**
         * \brief value to be set, if action is setvalue
         */
        string newval;

        /**
         * \brief existing value of the ZK node key
         */
        string oldval;

        /**
         * \brief Constructor.
         */
        ZkAction ()
            : action (ZkAction::NONE) {}

        /**
         * \brief Constructor.
         *
         * @param act the action to be taken
         * @param k the key on which action to be taken
         */
        ZkAction (ZkActionType act, const string& k)
            : action(act),
            key(k) {}

        /**
         * \brief Constructor.
         *
         * @param act the action to be taken
         * @param k the key on which action to be taken
         * @param v the value of the ZK node key
         */
        ZkAction (ZkActionType act, const string& k, const string& v)
            : action(act),
            key(k),
            newval(v) {}

        /**
         * \brief Constructor.
         *
         * @param act the action to be taken
         * @param k the key on which action to be taken
         * @param nv the new value of the ZK node key
         * @param ov the old value of the ZK node key
         */
        ZkAction (ZkActionType act, const string& k, const string& nv, const string& ov)
            : action (act),
            key(k),
            newval(nv),
            oldval(ov) {}
    };

    /**
     * \brief The ZK tree utility class; supports loading ZK tree from ZK server OR
     * \brief from saved XML file, saving ZK tree into XML file, dumping the ZK tree
     * \brief on standard output, creting a diff between saved ZK tree and live ZK
     * \brief tree and incremental update of the live ZK tree.
     */
    class ZkTreeUtil
    {
        public:
            /**
             * \brief Execution flag on ZkAction
             */
            enum ZkActionExecuteFlag
            {
                NONE = 0,
                PRINT = 1,
                EXECUTE = 2,
                INTERACTIVE = 5,
            };

        public:
            /**
             * \brief Connects to zookeeper and returns a valid ZK handle
             *
             * @param zkHosts comma separated list of host:port forming ZK quorum
             * @param a valid ZK handle
             */
            static ZooKeeperAdapterSptr get_zkHandle (const string& zkHosts);


        public:
            /**
             * \brief Constructor.
             */
            ZkTreeUtil () : loaded_(false) {}

            /**
             * \brief loads the ZK tree from ZK server into memory
             *
             * @param zkHosts comma separated list of host:port forming ZK quorum
             * @param path path to the subtree to be loaded into memory
             * @param force forces reloading in case tree already loaded into memory
             */
            void loadZkTree (const string& zkHosts, const string& path="/", bool force=false);

            /**
             * \brief loads the ZK tree from XML file into memory
             *
             * @param zkXmlConfig ZK tree XML file
             * @param force forces reloading in case tree already loaded into memory
             */
            void loadZkTreeXml (const string& zkXmlConfig, bool force=false);

            /**
             * \brief writes the in-memory ZK tree on to ZK server
             *
             * @param zkHosts comma separated list of host:port forming ZK quorum
             * @param path path to the subtree to be written to ZK tree
             * @param force forces cleanup of the ZK tree on the ZK server before writing
             */
            void writeZkTree (const string& zkHosts, const string& path="/", bool force=false) const;

            /**
             * \brief dupms the in-memory ZK tree on the standard output device;
             *
             * @param xml flag indicates whether tree should be dumped in XML format
             * @param depth the depth of the tree to be dumped for non-xml dump
             */
            void dumpZkTree (bool xml=false, int depth=ZKTREEUTIL_INF) const;

            /** 
             * \brief returns a list of actions after taking a diff of in-memory
             * \brief ZK tree and live ZK tree.
             *
             * @param zkHosts comma separated list of host:port forming ZK quorum
             * @param path path to the subtree in consideration while taking diff with ZK tree
             * @return a list of ZKAction instances to be performed on live ZK tree
             */
            vector< ZkAction > diffZkTree (const string& zkHosts, const string& path="/") const;

            /**
             * \brief performs create/delete/setvalue by executing a set of
             * ZkActions on a live ZK tree.
             *
             * @param zkHosts comma separated list of host:port forming ZK quorum
             * @param zkActions set of ZkActions
             * @param execFlags flags indicating print/execute/interactive etc
             */
            void executeZkActions (const string& zkHosts,
                    const vector< ZkAction >& zkActions,
                    int execFlags) const;

        private:

            ZkTreeNodeSptr zkRootSptr_;     // ZK tree root node
            bool loaded_;                        // Falg indicating whether ZK tree loaded into memory
    };
}

#endif // __ZK_TREE_UTIL_H__