package jp.ac.u_ryukyu.cr.ie.tatsuki.bbs;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.JungleTree;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NodePath;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser.InterfaceTraverser;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Either;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Error;
import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.util.Pair;

public class JuGrix {
	
	JungleTree personTree;
	JungleTree organizationTree;
	JungleTree roleTree;
	public JuGrix(){
		try{
			loadXml reader = new loadXml();
			personTree = reader.loadTestData("Person.xml");
			organizationTree = reader.loadTestData("Organization.xml");
			roleTree = reader.loadTestData("Role.xml");
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public boolean isActive(String id){
		
		InterfaceTraverser ifTraverser = personTree.getTraverser();
		Iterator<Pair<TreeNode,NodePath>> pairIterator = ifTraverser.find(
				(TreeNode node) -> {
					String personId = node.getAttributes().getString("id");
					if (personId == null)
						return false;
					if (personId.equals(id)) 
						return true;
					return false;
				}
				,"id",id);

		if (pairIterator.hasNext())
			return true;
		return false;
		
	}
	
	public Iterator<String> personIds(String orgId, LinkedList<String> roleIds){
		
		LinkedList<String> names = personIdsSearch(orgId, roleIds);
		return names.iterator();
	}
	
	public Iterator<String> personIds(LinkedList<String> orgIds ,LinkedList<String> roleIds){
		
		LinkedList<String> personIds = new LinkedList<String>();

		for (String orgId : orgIds) {
			personIds.addAll(personIdsSearch(orgId, roleIds));
		}
		return personIds.iterator();
	}
	
	private LinkedList<String> personIdsSearch(String id, LinkedList<String> roleIds) {
		
		if (!filter(id, roleIds))
			return new LinkedList<String>();
			
		InterfaceTraverser personTraverser = personTree.getTraverser();
		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = personTraverser.find(
				(TreeNode node) -> {
					String personId = node.getAttributes().getString("element");
					if (personId == null)
						return false;
					if (personId.equals("Person")) 
						return true;
					return false;
				}
				,"element","Person");
		
		LinkedList<String> names = new LinkedList<String>();
		
		for (;pairPersonIterator.hasNext();) {
			
			Pair<TreeNode, NodePath> pairPerson = pairPersonIterator.next();
			Iterator<Pair<TreeNode,NodePath>> pairIdIterator = personTraverser.find(
					(TreeNode node) -> {
						String personId = node.getAttributes().getString("text");
						if (personId == null)
							return false;
						if (personId.equals(id)) 
							return true;
						return false;
					}
					,pairPerson.left(),"text",id);
			
			if (pairIdIterator.hasNext()) {
					String name = pairPerson.left().getAttributes().getString("id");
					names.add(name);
			}
		}
		return names;
	}


	public boolean filter(String orgId, LinkedList<String> roleIds) {
		if (roleIds == null)
			return true;
		 
		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
		
		Iterator<Pair<TreeNode,NodePath>> orgNodeIterator = orgTraverser.find(
				(TreeNode node) -> {
					String personId = node.getAttributes().getString("element");
					if (personId == null)
						return false;
					if (!personId.equals("Organization")) 
						return false;
					 String compareOrgId = node.getAttributes().getString("id");
					if (orgId == null)
						return false;
					if (compareOrgId.equals(orgId))
						return true;
					return false;
				}
				,"element","orgId");
		
		if (!orgNodeIterator.hasNext())
			return false;
		
		TreeNode searchNode = orgNodeIterator.next().left();
		
		for (String id : roleIds) {
			Pattern personPattern = Pattern.compile("r:");
			Matcher personMacher = personPattern.matcher(id);
			if (personMacher.find()) {
				if (!roleFilter(id , searchNode))
					return false;
			}
			
			Pattern organizationPattern = Pattern.compile("rde:");
			Matcher organizationMacher = organizationPattern.matcher(id);
			if (organizationMacher.find()) {
				if (!rdeFilter(id,searchNode))
					return false;
			}
		}
		return true;
	}

	private boolean rdeFilter(String id, TreeNode targetNode) {
		
		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
		Iterator<Pair<TreeNode,NodePath>> pairIdIterator = orgTraverser.find(
				(TreeNode node) -> {
					String element = node.getAttributes().getString("element");
					if (element == null)
						return false;
					if (!element.equals("roleRefId")) 
						return false;
					String roleId = node.getAttributes().getString("text");
					if (roleId != null)
						return true;
					return false;
				}
				,targetNode,"element","roleRefId");
		
		TreeMap<String, String> idMap = TreeMap.empty(Ord.stringOrd);
		for (; pairIdIterator.hasNext();) {
			String roleId = pairIdIterator.next().left().getAttributes().getString("text");
			idMap = idMap.set(roleId,roleId);
		}
		
		Iterator<P2<String, String>> ids = idMap.iterator();
		InterfaceTraverser roleTraverser = roleTree.getTraverser();
		
		for (;ids.hasNext();) {
			String roleId = ids.next()._1();
			Iterator<Pair<TreeNode,NodePath>> roleNodeIterator = roleTraverser.find(
					(TreeNode node) -> {
						String element = node.getAttributes().getString("element");
						if (element == null)
							return false;
						if (!element.equals("Role")) 
							return false;
						String compareRoleId = node.getAttributes().getString("id");
						if (compareRoleId == null)
							return false;
						if (compareRoleId.equals(roleId))
							return true;
						return false;
					}
					,"id",roleId);
			
			for (;roleNodeIterator.hasNext();) {
				TreeNode roleNode = roleNodeIterator.next().left();
				Iterator<Pair<TreeNode,NodePath>> rdeNodeIterator = roleTraverser.find(
						(TreeNode node) -> {
							String elementName = node.getAttributes().getString("element");
							if (elementName == null)
								return false;
							if (!elementName.equals("roleDescriptionElementRefIds")) 
								return false;
							String rdeId = node.getAttributes().getString("text");
							if (rdeId == null)
								return false;
							Pattern personPattern = Pattern.compile(id);
							Matcher personMacher = personPattern.matcher(rdeId);
							if (personMacher.find())
								return true;
							return false;
						}
						,roleNode,"text",id);
					
				if (!rdeNodeIterator.hasNext())
					return false;
			}
			
		}
		return true;
	}

	public boolean roleFilter(String id, TreeNode orgNode) {
		
		InterfaceTraverser orgTraverser = organizationTree.getTraverser();
		
		Iterator<Pair<TreeNode,NodePath>> pairIdIterator = orgTraverser.find(
				(TreeNode node) -> {
					String elementName = node.getAttributes().getString("element");
					if (elementName == null)
						return false;
					if (!elementName.equals("roleRefId")) 
						return false;
					String roleId = node.getAttributes().getString("text");
					if (roleId == null)
						return false;
					if (roleId.equals(id))
						return true;
					return false;
				}
				,orgNode,"text",id);
		
		if (pairIdIterator.hasNext()){
			System.out.println(pairIdIterator.next().left().getAttributes().getString("text"));
			return true;
		}
		return false;
	}

	public Iterator<String> roleIds(String id) {
		Pattern personPattern = Pattern.compile("p:");
		Matcher personMacher = personPattern.matcher(id);
		if (personMacher.find()) {
			return searchRoleIds(personTree, id, "Person");
		}
		
		Pattern organizationPattern = Pattern.compile("o:");
		Matcher organizationMacher = organizationPattern.matcher(id);
		if (organizationMacher.find()) {
			return searchRoleIds(organizationTree, id, "Organization");
		}
		
		return null;
	}
	
	public Iterator<String> searchRoleIds(JungleTree tree, String id, String element){
		
		InterfaceTraverser ifTraverser = tree.getTraverser();
		Iterator<Pair<TreeNode,NodePath>> searchTargetIterator = ifTraverser.find(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals(element)) 
						return false;
					String nodeId = node.getAttributes().getString("id");
					if (nodeId == null)
						return false;
					if (nodeId.equals(id)) 
						return true;
					return false;
				}
				,"id",id);
		
		LinkedList<String> ids = new LinkedList<String>();
		
		for (;searchTargetIterator.hasNext();) {
			
			Pair<TreeNode, NodePath> searchTargetPair = searchTargetIterator.next();
			Iterator<Pair<TreeNode,NodePath>> pairIdIterator = ifTraverser.find(
					(TreeNode node) -> {
						String nodeElement = node.getAttributes().getString("element");
						if (nodeElement == null)
							return false;
						if (!nodeElement.equals("roleRefId")) 
							return false;
						String nodeId = node.getAttributes().getString("text");
						if (nodeId != null)
							return true;
						return false;
					}
					,searchTargetPair.left());
			

			for (;pairIdIterator.hasNext();){
				Pair<TreeNode, NodePath> idNodePath = pairIdIterator.next();
				String attribute = idNodePath.left().getAttributes().getString("text");
				
				Iterator<String> checkList = ids.iterator();
				for (;checkList.hasNext();) {
					if(checkList.next().equals(attribute))
						attribute = null;
				}
				
				if (attribute != null) {
					ids.add(attribute);
					System.out.println("-------------------------" + attribute + "-------------------------");
				}
			}
		}
		return ids.iterator();
	}
	
	
	public Iterator<String> competentRoleId(String personId) {
		
		InterfaceTraverser ifTraverser = personTree.getTraverser();
		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(personId, ifTraverser);
		
		if (!pairPersonIterator.hasNext()) 
			return new NullIterator();
		TreeNode person = pairPersonIterator.next().left();
		
		Iterator<Pair<TreeNode,NodePath>> targetPairIterator = ifTraverser.find(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals("priority")) 
						return false;
					String priority = node.getAttributes().getString("text");
					if (priority == null)
						return false;
					if (priority.equals("0"))
						return true;
					return false;
				}
				,person);
		
		
		LinkedList<String> idList = new LinkedList<String>();
		for (;targetPairIterator.hasNext();) {
			NodePath searchPath = targetPairIterator.next().right();
			Pair<Integer, NodePath> searchPair = searchPath.last();
			NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
			TreeNode targetNode = getTarget(person, targetPath);
			String id = targetNode.getAttributes().getString("text");
			idList.add(id);
		}
		
		return idList.iterator();
	}

	
	public Iterator<String> concurrentRoleIds(String personId) {
		
		InterfaceTraverser ifTraverser = personTree.getTraverser();
		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchPerson(
				personId, ifTraverser);
		
		if (!pairPersonIterator.hasNext()) 
			return new NullIterator();
		TreeNode person = pairPersonIterator.next().left();
		
		Iterator<Pair<TreeNode,NodePath>> targetPairIterator = ifTraverser.find(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals("priority")) 
						return false;
					String priority = node.getAttributes().getString("text");
					if (priority == null)
						return false;
					if (!priority.equals("0"))
						return true;
					return false;
				}
				,person);
		
		
		LinkedList<String> idList = new LinkedList<String>();
		for (;targetPairIterator.hasNext();) {
			NodePath searchPath = targetPairIterator.next().right();
			Pair<Integer, NodePath> searchPair = searchPath.last();
			NodePath targetPath = searchPair.right().add(searchPair.left() + 1);
			TreeNode targetNode = getTarget(person, targetPath);
			String id = targetNode.getAttributes().getString("text");
			idList.add(id);
		}
		
		return idList.iterator();
	}
	private Iterator<Pair<TreeNode, NodePath>> searchPerson(String personId,
			InterfaceTraverser ifTraverser) {
		Iterator<Pair<TreeNode,NodePath>> pairPersonIterator = ifTraverser.find(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals("Person")) 
						return false;
					String nodeId = node.getAttributes().getString("id");
					if (nodeId == null)
						return false;
					if (nodeId.equals(personId)) 
						return true;
					return false;
				}
				,"element","Person");
		return pairPersonIterator;
	}
	

	public Iterator<String> childOrganizationIds(String orgId) {
		InterfaceTraverser ifTraverser = organizationTree.getTraverser();
		Iterator<Pair<TreeNode, NodePath>> pairPersonIterator = searchOrganization(orgId, ifTraverser);
		
		if (!pairPersonIterator.hasNext()) 
			return new NullIterator();
		TreeNode person = pairPersonIterator.next().left();
		
		Iterator<Pair<TreeNode,NodePath>> chilrenOrgIdsIterator = ifTraverser.find(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (nodeElement.equals("childOrganizations")) 
						return true;
					return false;
				}
				,person);
		
		if (!chilrenOrgIdsIterator.hasNext()) 
			return new NullIterator();
		
		TreeNode chilerenOrgIds = chilrenOrgIdsIterator.next().left();
		
		Iterator<Pair<TreeNode,NodePath>> chilrenOrgIdIterator = ifTraverser.find(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals("organizationRefIds")) 
						return false;
					nodeElement = node.getAttributes().getString("text");
					if (nodeElement != null)
						return true;
					return false;
				}
				,person);
		
		LinkedList<String> ids = new LinkedList<String>();
		
		for (;chilrenOrgIdIterator.hasNext();) {
			ids.add(chilrenOrgIdIterator.next().left().getAttributes().getString("text"));
		}
		
		return ids.iterator();
	}
	
	
	private Iterator<Pair<TreeNode, NodePath>> searchOrganization(String orgId,
			InterfaceTraverser ifTraverser) {
		Iterator<Pair<TreeNode,NodePath>> pairPersonIterator = ifTraverser.find(
				(TreeNode node) -> {
					String nodeElement = node.getAttributes().getString("element");
					if (nodeElement == null)
						return false;
					if (!nodeElement.equals("Organization")) 
						return false;
					String nodeId = node.getAttributes().getString("id");
					if (nodeId == null)
						return false;
					if (nodeId.equals(orgId)) 
						return true;
					return false;
				}
				,"element","Organization");
		return pairPersonIterator;
	}
	
	public TreeNode getTarget(TreeNode node , NodePath path){
		TreeNode target;
		Pair<Integer, NodePath> pathNode = path.pop();
		int num = pathNode.left();
		NodePath newPath = pathNode.right();
		if (num == -1 && newPath.size() != 0)
			return getTarget(node, newPath);
			
		Either<Error, TreeNode> either = node.getChildren().at(num);
		if (either.isA())
			return node;
		
		TreeNode child = either.b();
		if (pathNode.right().size() == 0)
			return child;
		
		target = getTarget(child,pathNode.right());
		return target;
	}
	
	class NullIterator implements Iterator<String>{

		@Override
		public boolean hasNext() {
			return false;
		}

		@Override
		public String next() {
			return null;
		}
		
	}


}