package treecms.memory;

import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import treecms.api.MonotonicTreeNode;
import treecms.api.Node;
import treecms.api.NodeAttributes;
import treecms.api.NodeID;
import treecms.tree.util.NodeData;

public class OnMemoryMonotonicTreeNode implements MonotonicTreeNode
{
	private final OnMemoryMonotonicTreeNode m_parent;
	private volatile OnMemoryNode m_node;
	
	public OnMemoryMonotonicTreeNode(OnMemoryNode _node,OnMemoryMonotonicTreeNode _parent)
	{
		m_node = _node;
		m_parent = _parent;
	}
	
	@Override
	public NodeID getID()
	{
		return m_node.getID();
	}

	@Override
	public MonotonicTreeNode getParent()
	{
		return m_parent;
	}
	
	@Override
	public ByteBuffer get(ByteBuffer _key)
	{
		return m_node.get(_key);
	}

	@Override
	public NodeAttributes getAll()
	{
		return m_node.getAll();
	}

	@Override
	public void put(ByteBuffer _key, ByteBuffer _value)
	{
		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
		d.put(_key,_value);
		
		cloneAndTransmit(d);
	}

	@Override
	public void putAll(NodeAttributes _map)
	{
		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
		d.putAll(_map);
		
		cloneAndTransmit(d);
	}

	@Override
	public void remove(ByteBuffer _key)
	{
		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
		d.remove(_key);
		
		cloneAndTransmit(d);
	}

	@Override
	public void removeAll(Set<ByteBuffer> _keys)
	{
		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
		d.removeAll(_keys);
		
		cloneAndTransmit(d);
	}

	@Override
	public void clearAttributes()
	{
		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
		d.clearAttributes();
		
		cloneAndTransmit(d);
	}
	
	public void cloneAndTransmit(NodeData<Node> _d)
	{
		NodeID newID = m_node.getID().update();
		OnMemoryNode clone = new OnMemoryNode(newID,_d);
		
		OnMemoryMonotonicTreeNode parent = (OnMemoryMonotonicTreeNode)getParent();
		if(parent != null){ 
			parent.transmit(m_node,clone);
		}
		
		m_node = clone;
	}
	
	public boolean transmit(Node _orig,Node _edit)
	{
		NodeData<Node> d = new NodeData<Node>(m_node,m_node);
		d.replace(_edit);
		NodeID newID = m_node.getID().update();
		OnMemoryNode clone = new OnMemoryNode(newID,d);
		
		m_node = clone;
		OnMemoryMonotonicTreeNode parent = (OnMemoryMonotonicTreeNode)getParent();
		if(parent != null){
			return m_parent.transmit(m_node,clone);
		}else{
			
		}
		
		return true;
	}
	
	@Override
	public Node getNode()
	{
		return m_node;
	}
	
	@Override
	public List<MonotonicTreeNode> getList()
	{
		//NodeのリストよりMonotonicTreeNodeのリストを作成する．
		OnMemoryNode node = (OnMemoryNode)getNode();
		int size = node.getList().size();
		ArrayList<MonotonicTreeNode> list = new ArrayList<MonotonicTreeNode>(size);
		for(Iterator<Node> it = node.getList().iterator();it.hasNext();){
			OnMemoryNode n = (OnMemoryNode)it.next();
			OnMemoryMonotonicTreeNode tn = new OnMemoryMonotonicTreeNode(n,this);
			list.add(tn);
		}
		
		return Collections.unmodifiableList(list);
	}
	
	@Override
	public MonotonicTreeNode remove(int _index)
	{
		OnMemoryNode n = (OnMemoryNode)getNode();
		NodeData<Node> d = new NodeData<Node>(n,n);
		OnMemoryNode deleted = (OnMemoryNode)d.remove(_index);
		
		if(deleted != null){
			cloneAndTransmit(d);
			
			OnMemoryMonotonicTreeNode tn = new OnMemoryMonotonicTreeNode(deleted,null);
			return tn;
		}
		
		return null;
	}
	
	@Override
	public void clearChildren()
	{
		OnMemoryNode node = (OnMemoryNode)getNode();
		if(node.getList().size() == 0){
			return;
		}
		
		NodeData<Node> d = new NodeData<Node>(node,node);
		d.clearChildren();
		
		cloneAndTransmit(d);
	}

	@Override
	public Map<ByteBuffer, ByteBuffer> asMap()
	{
		OnMemoryNode node = (OnMemoryNode)getNode();
		return node.asMap();
	}

	@Override
	public Set<ByteBuffer> getKeySet()
	{
		OnMemoryNode node = (OnMemoryNode)getNode();
		return node.getKeySet();
	}

	@Override
	public MonotonicTreeNode get(int _index)
	{
		OnMemoryNode node = (OnMemoryNode)getNode();
		OnMemoryMonotonicTreeNode tn = new OnMemoryMonotonicTreeNode(node,this);
		return tn;
	}

	@Override
	public boolean contains(NodeID _id)
	{
		OnMemoryNode node = (OnMemoryNode)getNode();
		return node.contains(_id);
	}

	@Override
	public boolean swap(String _fid1,String _fid2)
	{
		OnMemoryNode node = (OnMemoryNode)getNode();
		NodeData<Node> d = new NodeData<Node>(node,node);
		
		if(d.swap(_fid1,_fid2)){
			cloneAndTransmit(d);
			
			return true;
		}
		
		return false;
	}

	@Override
	public Set<String> getFamilyIDSet()
	{
		Set<String> fids = m_node.getFamilyIDSet();
		return fids;
	}

	@Override
	public MonotonicTreeNode get(String _fid)
	{
		OnMemoryNode node = (OnMemoryNode)m_node.get(_fid);
		OnMemoryMonotonicTreeNode mono = new OnMemoryMonotonicTreeNode(node,this);
		return mono;
	}

	@Override
	public MonotonicTreeNode remove(String _fid)
	{
		OnMemoryNode node = (OnMemoryNode)getNode();
		
		NodeData<Node> d = new NodeData<Node>(node,node);
		OnMemoryNode deleted = (OnMemoryNode)d.remove(_fid);
		
		cloneAndTransmit(d);
		return new OnMemoryMonotonicTreeNode(deleted,null);
	}

	@Override
	public MonotonicTreeNode create(NodeAttributes _attr)
	{
		NodeID newID = getNode().getID().create();
		OnMemoryNode newNode = new OnMemoryNode(newID,new NodeData<Node>(null,_attr));
		
		OnMemoryNode thisNode = (OnMemoryNode)getNode();
		NodeData<Node> d = new NodeData<Node>(thisNode,thisNode);
		d.add(newNode);
		cloneAndTransmit(d);
		
		OnMemoryMonotonicTreeNode tn = new OnMemoryMonotonicTreeNode(newNode,this);
		return tn;
	}
	
	@Override
	public String toString()
	{
		return m_node.toString();
	}
}