/*
    * Created on Oct 20, 2004
    */
   package org.extremecomponents.tree.model;
   
   import java.util.ArrayList;
   import java.util.Iterator;
   import java.util.List;
   
  import org.apache.commons.beanutils.BeanUtils;
  import org.apache.commons.beanutils.PropertyUtils;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import org.extremecomponents.table.model.ParameterRegistry;
  
  import org.extremecomponents.tree.bean.TreeNode;
  
  
  /***
   * org.extremecomponents.tree.model.TreeModelUtils.java -
   *
   * @author phorn
   */
  public class TreeModelUtils
  {
  	private static Log logger = LogFactory.getLog(TreeModelUtils.class);
  
  	/***
  	 * Recursively loads the tree structure into the treeList attribute and sets the
  	 * treeList as the collection to use.
  	 * @param model
  	 * @param inputList
  	 * @throws Exception
  	 */
  	public static List loadTreeStructure(TreeModel model, List inputList) throws Exception
  	{
  		List result = new ArrayList();
  
  		List searchList = new ArrayList();
  		searchList.addAll(inputList);
  
  		for (Iterator iter = searchList.iterator(); iter.hasNext();)
  		{
  			Object bean = iter.next();
  
  			if (BeanUtils.getProperty(bean, model.getParentAttribute()) == null)
  			{
  				//Load up the top level parents
  				TreeNode node = new TreeNode(bean, getBeanId(model, bean), 0);
  				result.add(node);
  				iter.remove();
  				loadChildren(model, result, searchList, node, 0);
  			}
  		}
  
  		return result;
  	}
  
  	/***
  	 * @param model
  	 * @param displayList
  	 * @param searchList
  	 * @param node
  	 * @param currentDepth
  	 * @throws Exception
  	 */
  	public static void loadChildren(TreeModel model, List displayList, List searchList, TreeNode node, int currentDepth) throws Exception
  	{
  		currentDepth++;
  
  		List subList = new ArrayList();
  		subList.addAll(searchList);
  
  		Object id = node.getIdentifier();
  		String key = getNodeKey(model, id);
  
  		if (model.getOpenNodes().get(key) != null)
  		{
  			node.setOpen(true);
  		}
  		else
  		{
  			node.setOpen(false);
  		}
  
  		for (Iterator iter = subList.iterator(); iter.hasNext();)
  		{
  			Object bean = iter.next();
  
  			if (nodeIsBeanParent(model, node, bean))
  			{
  				TreeNode childNode = new TreeNode(bean, getBeanId(model, bean), currentDepth);
  				node.addChild(childNode);
  				childNode.setParent(node);
  				iter.remove();
  
  				if (isOpen(model, node, true))
 				{
 					displayList.add(childNode);
 				}
 
 				loadChildren(model, displayList, subList, childNode, currentDepth); //Recurse
 			}
 		}
 	}
 
 	/***
 	 * Used by the filter function to add back the filtered out parents.
 	 * @param model
 	 * @param searchList
 	 * @return
 	 * @throws Exception
 	 */
 	public static List findParents(TreeModel model, List searchList) throws Exception
 	{
 		logger.debug("TreeModel.findParents()");
 
 		List result = new ArrayList();
 
 		for (Iterator iter = searchList.iterator(); iter.hasNext();)
 		{
 			Object bean = iter.next();
 
 			if (!result.contains(bean))
 			{
 				result.add(bean);
 			}
 
 			findBeanParents(model, result, bean);
 		}
 
 		return result;
 	}
 
 	/***
 	 * Recursive call used by the filter function to add back the filtered out parents.
 	 * @param model
 	 * @param parents
 	 * @param bean
 	 * @throws Exception
 	 */
 	public static void findBeanParents(TreeModel model, List parents, Object bean) throws Exception
 	{
 		Object parent = PropertyUtils.getProperty(bean, model.getParentAttribute());
 
 		if (parent == null)
 		{
 			return;
 		}
 		else
 		{
 			if (!parents.contains(parent))
 			{
 				parents.add(parent);
 				findBeanParents(model, parents, parent);
 			}
 		}
 	}
 
 	/***
 	 * Used by the filter function to add back the filtered out children.
 	 * @param model
 	 * @param displayList
 	 * @throws Exception
 	 */
 	public static void addClosedChildren(TreeModel model, List displayList) throws Exception
 	{
 		logger.debug("TreeModel.addClosedChildren()");
 
 		List parents = new ArrayList();
 		parents.addAll(displayList);
 
 		for (Iterator iter = parents.iterator(); iter.hasNext();)
 		{
 			TreeNode node = (TreeNode) iter.next();
 
 			if ((node.getChildren() == null) || (node.getChildren().size() == 0))
 			{
 				addChildren(model, displayList, node);
 			}
 		}
 	}
 
 	/***
 	 * Recursive call used by the filter function to add back the filtered out children
 	 * but keeps them collapsed unless they have been openned manually be the open parameter.
 	 * @param model
 	 * @param displayList
 	 * @param node
 	 * @throws Exception
 	 */
 	public static void addChildren(TreeModel model, List displayList, TreeNode node) throws Exception
 	{
 		for (Iterator iter = model.getTableCollection().iterator(); iter.hasNext();)
 		{
 			Object bean = iter.next();
 
 			if (nodeIsBeanParent(model, node, bean))
 			{
 				TreeNode childNode = new TreeNode(bean, getBeanId(model, bean), node.getDepth() + 1);
 				node.addChild(childNode);
 
 				Object id = node.getIdentifier();
 				String openParam = (String) model.getOpenNodes().get(getNodeKey(model, id));
 
 				if (isOpen(model, node, false) || "true".equals(openParam))
 				{
 					node.setOpen(true);
 
 					int parentPosition = displayList.indexOf(node);
 					displayList.add(parentPosition + 1, childNode);
 				}
 
 				addChildren(model, displayList, childNode);
 			}
 		}
 	}
 
 	/***
 	 * @param model
 	 * @param node
 	 * @param bean
 	 * @return
 	 * @throws Exception
 	 */
 	public static boolean nodeIsBeanParent(TreeModel model, TreeNode node, Object bean) throws Exception
 	{
 		Object parent = PropertyUtils.getProperty(bean, model.getParentAttribute());
 
 		if (parent == null)
 		{
 			return false;
 		}
 
 		Object nodeId = node.getIdentifier();
 		Object parentId = getBeanId(model, parent);
 
 		return (node.getBean().equals(parent) || nodeId.equals(parentId));
 	}
 
 	/***
 	 * @param model
 	 * @param bean
 	 * @return
 	 * @throws Exception
 	 */
 	public static Object getBeanId(TreeModel model, Object bean) throws Exception
 	{
 		return PropertyUtils.getProperty(bean, model.getIdentifier());
 	}
 
 	/***
 	 * Find out if the node and all parents are open.
 	 * @param model
 	 * @param node
 	 * @param filterControlled
 	 * @return
 	 */
 	public static boolean isOpen(TreeModel model, TreeNode node, boolean filterControlled)
 	{
 		if (filterControlled && model.getFilterHandler().doFilter() && !model.getFilterHandler().doClear())
 		{
 			node.setOpen(true);
 
 			return true;
 		}
 
 		if (!node.isOpen())
 		{
 			return false;
 		}
 
 		if (node.getParent() == null)
 		{
 			return true;
 		}
 
 		return isOpen(model, node.getParent(), filterControlled);
 	}
 
 	/***
 	 * @param model
 	 * @param id value of the node.
 	 * @return Returns the parameter key used to indicate this node is open.
 	 */
 	public static String getNodeKey(TreeModel model, Object id)
 	{
 		return model.getTableKey() + ParameterRegistry.OPEN + id;
 	}
 }