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.NodeAttributes;
import treecms.api.NodeChildren;
import treecms.api.NodeID;
import treecms.api.SingleNode;
import treecms.api.TreeNode;
import treecms.tree.util.NodeChildrenImpl;

/**
 * SingleLinkedなNodeをラップしたDoubleLinkedなNodeの実装です．
 * @author shoshi
 */
public class OnMemoryMonotonicTreeNode implements MonotonicTreeNode
{
	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)
	{
		if(_target == null){
			throw new NullPointerException("_target must not be null.");
		}
		
		m_node  = _target;
		m_parent = _parent;
	}
	
	/*
	 * 親関連のメソッド
	 */
	
	@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 SingleNode getNode()
	{
		return m_node;
	}
	
	/*
	 * 属性関連のメソッド
	 */
	
	@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)
	{
		m_node.put(_key,_value);
	}

	@Override
	public void putAll(NodeAttributes _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 clearAttributes()
	{
		m_node.clearAttributes();
	}
	
	/**
	 * このMonotonicNodeに変更が加えられたら，こちらのメソッドが呼び出されます．
	 * 非破壊的に変更するために，SingleLinkedNodeのクローンを作成し，親にも複製を依頼します．
	 * 
	 * RootNodeまで伝搬すると親のNodeはnullとなる．親Nodeは担当するMonotonicTreeのオブジェクトを保持しており，そこにRootNodeが変更されたことを通知する．
	 * 通知が終わり，処理が戻ってきた時に自身のOnMemoryNodeをクローンした新しいものに書き換えます．
	 * 
	 * _fromがnullの場合は，自身が編集元であることを示します．
	 * @param _from 編集元のOnMemoryMonotonicTreeNode
	 */
	public void transmit(OnMemoryNode _orig,OnMemoryNode _edit)
	{
		OnMemoryForest f = (OnMemoryForest)m_node.getForest();
		OnMemoryNode clone = f.createNode(m_node.getID(),null);
		clone.replaceChild(_orig,_edit);
		
		if(m_parent != null){
			m_parent.transmit(m_node,(OnMemoryNode)clone);
			return;
		}
		
		//なにかしたい
	}
	
	/*
	 * 子供関連のメソッド
	 */
	@Override
	public List<MonotonicTreeNode> getList()
	{
		//NodeのリストよりMonotonicTreeNodeのリストを作成する．
		NodeChildren<MonotonicTreeNode> res = new NodeChildrenImpl<MonotonicTreeNode>();
		for(Iterator<SingleNode> it = m_node.getList().iterator();it.hasNext();){
			OnMemoryNode n = (OnMemoryNode)it.next();
			res.add(new OnMemoryMonotonicTreeNode(n,this));
		}
		
		return res.getList();
	}

	@Override
	public boolean add(MonotonicTreeNode _n)
	{
		return m_node.add(_n.getNode());
	}

	@Override
	public boolean addAll(NodeChildren<MonotonicTreeNode> _list)
	{
		//MotonicTreeNodeのリストからNodeのリストを作成する．
		NodeChildren<SingleNode> res = new NodeChildrenImpl<SingleNode>();
		for(Iterator<MonotonicTreeNode> it = _list.getList().iterator();it.hasNext();){
			MonotonicTreeNode mono = (MonotonicTreeNode)it.next();
			res.add(mono.getNode());
		}
		
		return m_node.addAll(res);
	}

	@Override
	public MonotonicTreeNode remove(String _uuid)
	{
		SingleNode n = m_node.remove(_uuid);
		return new OnMemoryMonotonicTreeNode((OnMemoryNode)n,this);
	}

	@Override
	public MonotonicTreeNode remove(int _index)
	{
		SingleNode n = m_node.remove(_index);
		return new OnMemoryMonotonicTreeNode((OnMemoryNode)n,null);
	}

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