#ifndef PSEARCH_NODE_H_
#define PSEARCH_NODE_H_

#include "psearch_core.h"


namespace psearch {
    
    /////////////////////////////////////////////////////////////////////////////////////////
    // class Node
    //
    //  The set of patterns attribute to Node correspond to the patterns for which
    //  this node is included in their neccessairy and sufficient criteria (nsc.)
    /////////////////////////////////////////////////////////////////////////////////////////
    class Node: public PSBase
    {
        public:
        inline Node(PSearchDB * db_p, index_type index):
                PSBase(db_p, index),
                m_rules(),
                m_patterns(),
                m_skip_pattern_activation(false)
        {};
        
        
        inline node_index_type
        get_node_index()const
        {
            return this;
        };
        
        
        //////////////////////////////////////////////////////////////////////////////////////
        // relationship with Rule
        /////////////////////////////////////////////////////////////////////////////////////
        
        
        // returns true if this node is included in the pattern's c1 set.
        inline bool 
        is_c1_to_rule(rule_index_type pindex)const
        {
            return m_rules.find(pindex) != m_rules.end();
        };
        
        
        inline rule_const_iterator_type
        get_rules_begin()const
        {
            return m_rules.begin();
        };
        
        
        inline rule_const_iterator_type
        get_rules_end()const
        {
            return m_rules.end();
        };
        
        
        inline rule_set_const_iterator
        get_rules_iterator()const
        {
            return rule_set_const_iterator(get_rules_begin(), get_rules_end());
        };
        
        
        inline size_t 
        get_nbr_rules()const
        {
            return m_rules.size();
        };
        
        
        //////////////////////////////////////////////////////////////////////////////////////
        // relationship with Pattern
        /////////////////////////////////////////////////////////////////////////////////////
        
        inline bool 
        is_skip_pattern_activation() const
        {
            return m_skip_pattern_activation;
        };
        
        
        // returns true if this node is included in the pattern's c1 set.
        inline bool 
        is_c1_to_pattern(pattern_index_type pindex)const
        {
            return m_patterns.find(pindex) != m_patterns.end();
        };
        
        
        inline pattern_const_iterator_type
        get_patterns_begin()const
        {
            return m_patterns.begin();
        };
        
        
        inline pattern_const_iterator_type
        get_patterns_end()const
        {
            return m_patterns.end();
        };
        
        
        inline pattern_set_const_iterator
        get_patterns_iterator()const
        {
            return pattern_set_const_iterator(get_patterns_begin(), get_patterns_end());
        };
        
        
        inline size_t 
        get_nbr_patterns()const
        {
            return m_patterns.size();
        };
        
        
        ///////////////////////////////////////////////////////////////////////////////////////
        // relationship to Category
        //////////////////////////////////////////////////////////////////////////////////////
        
        inline bool 
        has_category(category_index_type category_index)const
        {
            return m_categories.find(category_index) != m_categories.end();
        };
        
        
        inline category_const_iterator_type
        get_categories_begin()const
        {
            return m_categories.begin();
        };
        
        
        inline category_const_iterator_type
        get_categories_end()const
        {
            return m_categories.end();
        };
        
        
        inline category_set_const_iterator
        get_categories_iterator()const
        {
            return category_set_const_iterator(get_categories_begin(), get_categories_end());
        };
        
        
        inline size_t 
        get_nbr_categories()const
        {
            return m_categories.size();
        };
        
        
        protected:
        
        
        inline void 
        set_skip_pattern_activation(bool b)
        {
            m_skip_pattern_activation = b;
        };
        
        
        //////////////////////////////////////////////////////////////
        // rule
        //////////////////////////////////////////////////////////////
        
        inline void 
        add_rule(rule_index_type rule_index)
        {
            if(!rule_index) return;
            m_rules.insert(rule_index);
        };
        
        
        inline void
        remove_rule(rule_index_type rule_index)
        {
            m_rules.erase(rule_index);
        };
        
        
        inline void
        remove_all_rules()
        {
            m_rules.clear();
        };
        
        
        //////////////////////////////////////////////////////////////
        // pattern
        //////////////////////////////////////////////////////////////
        
        
        inline void 
        add_pattern(pattern_index_type pattern_index)
        {
            if(!pattern_index) return;
            m_patterns.insert(pattern_index);
        };
        
        
        inline void
        remove_pattern(pattern_index_type pattern_index)
        {
            m_patterns.erase(pattern_index);
        };
        
        
        inline void
        remove_all_patterns()
        {
            m_patterns.clear();
        };
        
        
        inline void 
        add_category(category_index_type category_index)
        {
            if(!category_index) return;
            m_categories.insert(category_index);
        };
        
        
        inline void
        remove_category(category_index_type category_index)
        {
            m_categories.erase(category_index);
        };
        
        
        inline void
        remove_all_categories()
        {
            m_categories.clear();
        };
        
        private:
        friend class PSearchDB;
        friend class Rule;
        friend std::ostream& operator<<(std::ostream& out, Node const& node);
        friend std::ostream& operator<<(std::ostream& out, node_index_type node_index);
        rule_set_type           m_rules;
        pattern_set_type        m_patterns;
        category_set_type       m_categories;
        bool                    m_skip_pattern_activation;
    };
    
    
    inline std::ostream& operator<<(std::ostream& out, node_index_type node_index)
    {
        out << *node_index;
        return out;
    };
    
    
};  /* psearch namespace */

#endif /*PSEARCH_NODE_H_*/