package treecms.memory;

import java.nio.ByteBuffer;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import treecms.api.Forest;
import treecms.api.MonotonicTreeNode;
import treecms.api.Node;
import treecms.api.NodeID;
import treecms.api.TreeNode;

/**
 * SingleLinkedなNodeをラップしたDoubleLinkedなNodeの実装です．
 * @author shoshi
 */
public class OnMemoryMonotonicTreeNode implements MonotonicTreeNode
{
	private OnMemoryMonotonicTree m_tree;
	private OnMemoryNode m_node;
	private OnMemoryMonotonicTreeNode m_parent;
	
	/**
	 * コンストラクタです．
	 * @param _target 対象となるSingleLinked Node
	 * @param _parent このDoubleLinked Nodeの親，RootNodeならnull
	 * @param _tree このNodeがRootNodeなら，nullではいけない．
	 */
	public OnMemoryMonotonicTreeNode(OnMemoryNode _target,OnMemoryMonotonicTreeNode _parent,OnMemoryMonotonicTree _tree)
	{
		if(_target == null){
			throw new NullPointerException("_target must not be null.");
		}
		
		if(_parent == null && _tree == null){
			throw new NullPointerException("_parent or _tree must not be null.");
		}
		
		m_node  = _target;
		m_parent = _parent;
		m_tree = _tree;
	}
	
	/*
	 * 親関連のメソッド
	 */
	
	@Override
	public NodeID getID()
	{
		return m_node.getID();
	}

	@Override
	public Forest getForest()
	{
		return m_node.getForest();
	}

	@Override
	public MonotonicTreeNode getParent()
	{
		return m_parent;
	}

	@Override
	public Node getNode()
	{
		return m_node;
	}
	
	/*
	 * 属性関連のメソッド
	 */
	
	@Override
	public ByteBuffer get(ByteBuffer _key)
	{
		return m_node.get(_key);
	}

	@Override
	public Map<ByteBuffer, ByteBuffer> getAll()
	{
		return m_node.getAll();
	}

	@Override
	public void put(ByteBuffer _key, ByteBuffer _value)
	{
		m_node.put(_key,_value);
	}

	@Override
	public void putAll(Map<ByteBuffer, ByteBuffer> _map)
	{
		m_node.putAll(_map);
	}

	@Override
	public void remove(ByteBuffer _key)
	{
		m_node.remove(_key);
	}

	@Override
	public void removeAll(Set<ByteBuffer> _keys)
	{
		m_node.removeAll(_keys);
	}

	@Override
	public void clear()
	{
		m_node.clear();
	}
	
	/**
	 * このMonotonicNodeに変更が加えられたら，こちらのメソッドが呼び出されます．
	 * 非破壊的に変更するために，SingleLinkedNodeのクローンを作成し，親にも複製を依頼します．
	 * 
	 * RootNodeまで伝搬すると親のNodeはnullとなる．親Nodeは担当するMonotonicTreeのオブジェクトを保持しており，そこにRootNodeが変更されたことを通知する．
	 * 通知が終わり，処理が戻ってきた時に自身のOnMemoryNodeをクローンした新しいものに書き換えます．
	 * 
	 * _fromがnullの場合は，自身が編集元であることを示します．
	 * @param _from 編集元のOnMemoryMonotonicTreeNode
	 */
	public void transmit(OnMemoryNode _orig,OnMemoryNode _edit)
	{
		Node clone = m_node.cloneNode(null);
		clone.replaceChild(_orig,_edit);
		
		if(m_parent != null){
			m_parent.transmit(m_node,(OnMemoryNode)clone);
			return;
		}
		
		//なにかしたい
	}
	
	/*
	 * 子供関連のメソッド
	 */

	@Override
	public Iterator<MonotonicTreeNode> getChildren()
	{
		//NodeのリストよりMonotonicTreeNodeのリストを作成する．
		LinkedList<MonotonicTreeNode> res = new LinkedList<MonotonicTreeNode>();
		for(Iterator<Node> it = m_node.getChildren();it.hasNext();){
			OnMemoryNode n = (OnMemoryNode)it.next();
			res.add(new OnMemoryMonotonicTreeNode(n,this,null));
		}
		
		return res.iterator();
	}

	@Override
	public void addChild(MonotonicTreeNode _n)
	{
		m_node.addChild(_n.getNode());
	}

	@Override
	public void addChildren(List<MonotonicTreeNode> _list)
	{
		//MotonicTreeNodeのリストからNodeのリストを作成する．
		LinkedList<Node> res = new LinkedList<Node>();
		for(Iterator<MonotonicTreeNode> it = _list.iterator();it.hasNext();){
			MonotonicTreeNode mono = (MonotonicTreeNode)it.next();
			res.add(mono.getNode());
		}
		
		m_node.addChildren(res);
	}

	@Override
	public void removeChild(MonotonicTreeNode _n)
	{
		m_node.removeChild(_n.getNode());
	}

	@Override
	public void removeChildren(List<MonotonicTreeNode> _list)
	{
		//MonotonicTreeNodeのリスト
		LinkedList<Node> res = new LinkedList<Node>();
		for(Iterator<MonotonicTreeNode> it = _list.iterator();it.hasNext();){
			MonotonicTreeNode mono = it.next();
			res.add(mono.getNode());
		}
		
		m_node.removeChildren(res);
	}

	@Override
	public void clearChildren()
	{
		m_node.clearChildren();
	}

}