package jas2.util.tree;
import java.util.*;

/**
 * An OrderedNode is a node which may order its children by something
 * other than natural order, using a Comparator. An OrderedNode uses the
 * same ordering as its parent, unless it has an explicit comparator set. 
 */
public class OrderedNode extends SimpleNode
{
	public OrderedNode()
	{
		super();
	}
	public OrderedNode(String name, String type, int flags, Object object)
	{
		super(name,type,flags,object);
	}
	public OrderedNode(SimpleNode parent, String name, String type, int flags, Object object)
	{
		super(parent,name,type,flags,object);
	}
	protected SimpleNode createNode(SimpleNode parent, String name, String type, int flags, Object object)
	{
		return new OrderedNode(parent,name,type,flags,object);
	}
	protected void addChild(SimpleNode child)
	{
		if (getEffectiveOrder() != null) 
		{
			if (orderedList == null) orderedList = createOrderedList(Collections.singleton(child));
			else
			{
				int ip = Collections.binarySearch(orderedList,child,getEffectiveOrder());
				System.out.println("ip="+ip);
				if (ip < 0) ip = -ip - 1;
				orderedList.add(ip,child);
			}
		}
		// Must go after orderedList is updated, since may trigger tree redraw
		super.addChild(child);
	}
	protected void removeChild(SimpleNode child)
	{
		super.removeChild(child);
		if (orderedList != null) orderedList.remove(child);
	}
	public SimpleNode getChild(int index)
	{
		if (orderedList != null) return (SimpleNode) orderedList.get(index);
		return super.getChild(index);
	}
	public int getIndexOfChild(Object child)
	{
		if (orderedList != null) return Collections.binarySearch(orderedList,child,getEffectiveOrder());
		return super.getIndexOfChild(child);
	}
	public int getNaturalIndex()
	{
		return getParent().children.indexOf(this);
	}
	/**
	 * Override to use a different List implementation for the ordered list
	 */
	protected List createOrderedList(Collection c)
	{
		return new ArrayList(c);
	}
	/**
	 * Set a specific ordering, or null to use the parents ordering, or
	 * DEFAULT_ORDER to use the default ordering.
	 */
	public void setOrder(Comparator comp)
	{
		if (this.comp != comp) 
		{
			this.comp = comp;
			notifyOrderChanged();
		}
	}
	public void clearOrder()
	{
		setOrder(null);
	}
	private void notifyOrderChanged()
	{
		orderChanged();
		treeChanged(SimpleNodeListener.STRUCTURE_CHANGED);
	}
	private void orderChanged()
	{
		Comparator comp = getEffectiveOrder();
		if (comp == null) orderedList = null;
		else 
		{
			orderedList = createOrderedList(children == null ? Collections.EMPTY_LIST : children.elements());
			Collections.sort(orderedList,comp);
		}
		// Tell any children that are OrderedNodes and which dont have their own explicit
		// ordering that the order has changed
		if (children != null)
		{
			Iterator iter = children.elements().iterator();
			while (iter.hasNext())
			{
				Object o = iter.next();
				if (o instanceof OrderedNode)
				{
					OrderedNode on = (OrderedNode) o;
					if (on.comp == null) on.orderChanged();
				}
			}
		}
	}
	public Comparator getOrder()
	{
		return comp;
	}
	private Comparator getEffectiveOrder()
	{
		if (comp != null) return comp;
		if (comp == DEFAULT_ORDER) return null;
		SimpleNode parent = getParent();
		if (parent instanceof OrderedNode) return ((OrderedNode) parent).getEffectiveOrder();
		return null;
	}
	private List orderedList;	
	private Comparator comp;
	public static final Comparator DEFAULT_ORDER = new Comparator()
		{
			public boolean equals() { return false; }
			public int compare(Object o1, Object o2) { return 0; }
		};
}