/***
    *  The contents of this file are subject to the Mozilla Public
    *  License Version 1.1 (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.mozilla.org/MPL/
    *
    *  Software distributed under the License is distributed on an "AS
    *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
    *  implied. See the License for the specific language governing
   *  rights and limitations under the License.
   *
   *  The Original Code is pow2toolkit library.
   *
   *  The Initial Owner of the Original Code is
   *  Power Of Two S.R.L. (www.pow2.com)
   *
   *  Portions created by Power Of Two S.R.L. are
   *  Copyright (C) Power Of Two S.R.L.
   *  All Rights Reserved.
   *
   * Contributor(s):
   */
  
  package com.pow2.structures.tree;
  
  
  import java.util.HashMap;
  
  
  /***
   *  ItemsTree class.
   *
   * @author  Luca Fossato
   */
  public abstract class ItemTree extends BinaryTree
  {
    /***
     *  Node hashMap.
     *  <br>
     *  Every map entry references a tree node.
     */
    protected HashMap map;
  
    /***
     * set to true to navigate all the nodes; to false to
     * navigate only the open nodes;
     */
    protected boolean traverseAllNodes;
  
  
    /***
     *  Constructor for the ItemsTree object
     */
    public ItemTree()
    {
      super();
      map              = new HashMap();
      traverseAllNodes = false;
    }
  
  
    /***
     *  Sets the traverseAllNodes attribute of the ItemTree object
     *
     * @param  traverseAllNodes The new traverseAllNodes value
     */
    public void setTraverseAllNodes(boolean traverseAllNodes)
    {
      this.traverseAllNodes = traverseAllNodes;
    }
  
  
    /***
     *  Gets the traverseAllNodes attribute of the ItemTree object
     *
     * @return  The traverseAllNodes value
     */
    public boolean isTraverseAllNodes()
    {
      return traverseAllNodes;
    }
  
  
    /***
     *  Move the <code>c</code> node identified by the input <code>pId</code>
     *  indentifier over the new parent <code>p</code> node.
     *
     * @param  pId the identifier of the parent <code>c</code> node
     * @param  id the identifier of the <code>c</code> node to move
     * @param  left true   if the <code>c</code> node must be inserted
     *                      as left node of <code>p</code>;
     *               false  if <code>c</code> must be inserted as right
     *                      node of <code>p</code>
     */
    public void move(String pId, String id, boolean left)
    {
      Node p  = getNode(pId);
      Node c  = getNode(id);
  
     move(p, c, left);
   }
 
 
   /***
    *  Remove the input node from the tree, rearranging
    *  the parent and the child nodes references.
    *
    * @param  n the node to remove.
    */
   protected void remove(Node n)
   {
     synchronized (map)
     {
       map.remove(n.getId());
     }
 
     super.remove(n);
   }
 
 
   /***
    *  Get the node referenced by the input id.
    *
    * @param  id the node id
    * @return  the node referenced by the input id, or null
    *             if that id doesn't match any node stored into
    *             the node map
    */
   public Node getNode(String id)
   {
     return (map.containsKey(id)) ? (Node) map.get(id) : null;
   }
 
 
   /***
    *  Traverse the tree, using pre-order algorithm,
    *  starting from the input node; visit only open nodes.
    *  <br>
    *  pre-order traversal: first looks at the data,
    *  then the left nodes, and then the right nodes.
    *
    * @param      p the node where to start the tree traversing
    * @exception  Exception if any error occurs
    */
   protected void pretrav(Node p) throws Exception
   {
     if (p == null) return;
 
     visit(p);                      // show data;
     Node l = p.getLeft();
 
     // left node must be open;
     if (traverseAllNodes || p.isOpen())
       pretrav(l);
 
     pretrav(p.getRight());         // show right nodes;
   }
 
 
   /***
    *  Insert a new left node into the tree.
    *
    * @param  p the parent node where to insert the new left node
    * @param  c the new left node to add to the parent node
    * @return  true  if the insertion is successfull;
    *            false otherwise
    */
   public boolean insertLeft(Node p, Node c)
   {
     boolean  inserted  = false;
 
     if ((inserted = super.insertLeft(p, c)))
       map.put(c.getId(), c);
 
     return inserted;
   }
 
 
   /***
    *  Insert a new right node into the tree.
    *
    * @param  p the parent node where to insert the new right node
    * @param  c the new right node to add to the parent node
    * @return  true  if the insertion is successfull;
    *            false otherwise
    */
   public boolean insertRight(Node p, Node c)
   {
     boolean  inserted  = false;
 
     if ((inserted = super.insertRight(p, c)))
       map.put(c.getId(), c);
 
     return inserted;
   }
 
 
   /***
    *  Add a new left node to the parent node left node list.
    *
    * @param  p the parent node
    * @param  c the left node to add to the parent node left node list
    * @return  true  if the addition is successfull;
    *            false otherwise
    */
   public boolean addLeft(Node p, Node c)
   {
     boolean added  = false;
 
     if ((added = super.addLeft(p, c)))
       map.put(c.getId(), c);
 
     return added;
   }
 
 
   /***
    *   Add a new right node to the parent node right node list.
    *
    * @param  p the parent node
    * @param  c the right node to add to the parent node right node list
    * @return  true  if the addition is successfull;
    *           false otherwise
    */
   public boolean addRight(Node p, Node c)
   {
     boolean added = false;
 
     if ((added = super.addRight(p, c)))
       map.put(c.getId(), c);
 
     return added;
   }
 
 
 //   /***
 //    *  Collapse the tree.
 //    *
 //    *  Use this method to set
 //    */
 //   public void collapse()
 //   {
 //     collapse((Node)root);
 //   }
 
 
 //   /***
 //    *  Collapse the tree.
 //    *
 //    *  @param n the input itemNode.
 //    */
 //   private void collapse(ItemNode n)
 //   {
 //     if (n == null) return;
 
 //     n.setOpening(false);
 //     collapse((Node)n.getLeft());
 //     collapse((Node)n.getRight());
 //   }
 }