package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl;

import java.util.Iterator;

import fj.F;
import fj.data.List;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;

public class DefaultNodePath implements NodePath
{
	private final List<Integer> path;
	
	public static void main(String args[])
	{
		DefaultNodePath p = new DefaultNodePath();
		p = p.add(1).add(2).add(3).add(4);
		System.out.println(p.toString());
	}
	
	public DefaultNodePath()
	{
		path = List.list(-1);
	}
	
	private DefaultNodePath(List<Integer> path)
	{
		this.path = path;
	}

	@Override
	public Iterator<Integer> iterator()
	{
		return path.iterator();
	}

	@Override
	public DefaultNodePath add(int pos)
	{
		List<Integer> newPath = path.snoc(pos);
		return new DefaultNodePath(newPath);
	}

	@Override
	public Pair<Integer, NodePath> pop()
	{
		Integer head = path.head();
		List<Integer> tail = path.tail();
		
		return new Pair<Integer,NodePath>(head,new DefaultNodePath(tail));
	}

	@Override
	public Pair<Integer,NodePath> last(){
		Integer last = path.last();
		List<Integer> list = path.reverse().tail().reverse();
		return new Pair<Integer,NodePath>(last,new DefaultNodePath(list));
	}
	
	@Override
	public String toString()
	{
		return path.toString();
	}
	
	@Override
	public int size()
	{
		return path.length();
	}
	
	public List<DefaultNodePath> inits()
	{
		List<List<Integer>> inits = path.inits();
		inits = inits.filter(new F<List<Integer>,Boolean>(){
			@Override
			public Boolean f(List<Integer> init){
				return init.length() != 0;
			}
		});
		
		return inits.map(new F<List<Integer>,DefaultNodePath>(){
			@Override
			public DefaultNodePath f(List<Integer> path){
				return new DefaultNodePath(path);
			}
		});
	}


	@Override
	public NodePath tail() {
		List<Integer> tail = path.reverse();
		tail = tail.tail().reverse();
		return new DefaultNodePath(tail);
	}

	@Override
	public boolean compare(NodePath targetPath) {
		
		if (targetPath.size() < path.length())
			return false;
		
		for (Integer currentNum : path) {
			Pair<Integer, NodePath> currentTargetPathNumPair = targetPath.pop();
			targetPath = currentTargetPathNumPair.right();
			if (currentNum != currentTargetPathNumPair.left()) 
				return false;
		}
		return true;
	}
}