package treecms.tree.memory;

import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import treecms.api.Node;
import treecms.api.NodeID;

public class OnMemoryNode implements Node
{
	NodeID m_id;
	OnMemoryTree m_tree;
	
	HashSet<Node> m_children;
	HashMap<String,byte[]> m_attrs;
	
	public OnMemoryNode(NodeID _id,OnMemoryTree _tree)
	{
		m_id = _id;
		m_tree = _tree;
		m_children = new HashSet<Node>();
		m_attrs = new HashMap<String,byte[]>();
	}

	@Override
	public Node createNode()
	{
		OnMemoryNode child = m_tree.createNode(null);
		return child;
	}

	@Override
	public NodeID getID()
	{
		return m_id;
	}

	@Override
	public Iterator<Node> iterator()
	{
		return Collections.unmodifiableSet(m_children).iterator();
	}

	@Override
	public Node addChild(Node _child)
	{
		OnMemoryTree.NodeData data = m_tree.extractData(this);
		data.m_children.add(_child);
		OnMemoryNode newNode = m_tree.clonetree(this,data);
		if(newNode == null){
			m_children.add(_child);
			return this;
		}
		return newNode;
	}

	@Override
	public Node addChildren(Set<Node> _children)
	{
		OnMemoryTree.NodeData data = m_tree.extractData(this);
		data.m_children.addAll(_children);
		OnMemoryNode newNode = m_tree.clonetree(this,data);
		if(newNode == null){
			m_children.addAll(_children);
			return this;
		}
		return newNode;
	}

	@Override
	public Node clearChildren()
	{
		OnMemoryTree.NodeData data = m_tree.extractData(this);
		data.m_children.clear();
		OnMemoryNode newNode = m_tree.clonetree(this,data);
		if(newNode == null){
			m_children.clear();
			return this;
		}
		return newNode;
	}
	
	@Override
	public Node removeChild(Node _child)
	{
		OnMemoryTree.NodeData data = m_tree.extractData(this);
		data.m_children.remove(_child);
		OnMemoryNode newNode = m_tree.clonetree(this,data);
		if(newNode == null){
			m_children.remove(_child);
			return this;
		}
		return newNode;
	}
	
	@Override
	public Node setAttribute(String _attr,byte[] _value)
	{
		OnMemoryTree.NodeData data = m_tree.extractData(this);
		data.m_attrs.put(_attr,_value);
		OnMemoryNode newNode = m_tree.clonetree(this,data);
		if(newNode == null){
			m_attrs.put(_attr,_value);
			return this;
		}
		return newNode;
	}
	
	@Override
	public Node setAttributeMap(Map<String,byte[]> _map)
	{
		OnMemoryTree.NodeData data = m_tree.extractData(this);
		data.m_attrs.putAll(_map);
		OnMemoryNode newNode = m_tree.clonetree(this,data);
		if(newNode == null){
			m_attrs.putAll(_map);
			return this;
		}
		return newNode;
	}

	@Override
	public byte[] getAttribute(String _attr)
	{
		return m_attrs.get(_attr);
	}

	@Override
	public Set<String> getAttributeKeys()
	{
		return m_attrs.keySet();
	}

	@Override
	public Map<String, byte[]> getAttributeMap()
	{
		return Collections.unmodifiableMap(m_attrs);
	}

	@Override
	public Set<Node> getChildren()
	{
		return Collections.unmodifiableSet(m_children);
	}
	
	@Override
	public String toString()
	{
		return m_id.toString();
	}

	@Override
	public boolean isChild(Node _child)
	{
		return m_children.contains(_child);
	}

	@Override
	public Node useContents()
	{
		return m_tree.useContents();
	}
}