package edu.stanford.peer.rbtm.engine;

import java.util.*;

import edu.stanford.peer.rbtm.credential.*;
import edu.stanford.peer.rbtm.util.*;

/**
 * A proof node which represents a role in the credential graph.
 */
public class RoleProofNode extends AbstractProofNode
{
	/**
	 * A map for managing all the partial solutions per intersection that arrive
	 */
   static protected PartialSolutionMap partialSolutions = 
		 new PartialSolutionMap();

   /** A forwarlinking monitor which handles linking goals */
	private ForwardLinkingMonitor monitor;

    protected RoleProofNode(ProofGraph graph, Role re, int trackType) {
    	super(graph, re, trackType);
    }

    public HashSet getChain(int size, EntityExpression target) {
	if(target.equals(getRoleExp())) {
	    System.out.println("\n@@@@@ creating set of size " + size);
	    return new HashSet(size);
	}
	System.out.println("\n@@@@@ this = " + getRoleExp());	
	ResultEvidenceMap solutions = getBackwardSolutions();
	//ProofNode nextNode =(ProofNode)solutions.getResultEvidence(target);
	HashSet soln = (HashSet)solutions.getResultEvidence(target);
	System.out.println("solutions = " + solutions);
	System.out.println("soln = " + soln);
	//In the end, there can be only ONE . . . 
	ProofNode nextNode =(ProofNode)soln.iterator().next();
	System.out.println("\n@@@@@ next = " + nextNode.getRoleExp() );
	size++;
	HashSet set = nextNode.getChain(size, target);
	System.out.println("\n@@@@@ children  = " + nextNode.getChildren());
        HashSet results = 
	    (HashSet)nextNode.getChildren().getResultEvidence(getRoleExp());
	Iterator evidence = results.iterator();
	while(evidence.hasNext()) {
	    set.add((Credential)evidence.next());
	}
	return set;
    }

    public void additionalBackwardProcess() {
        Iterator  credIt = getGraph().findCredentialsDefiningRole((Role)getRoleExp());
        while (credIt.hasNext()) {
            StaticCredential credential = (StaticCredential) credIt.next();
            ProofNode node = getGraph().addBackwardNode(credential.getSubject());
	    node.addChild(this, credential);
	    //if(addRole)backwardSolutionAdded(this, getRoleExp());
        }
    }

    public void additionalForwardProcess() {
		Role thisRole = (Role)getRoleExp();
		// Make itself a forward solution to itself
		forwardSolutionAdded(this, thisRole);
		
		if (monitor == null) {
	        ProofNode node = getGraph().addForwardNode(thisRole.getBase());
			monitor = new ForwardLinkingMonitor();
	        node.addForwardListener(monitor);
		}
    }
	 /**
	  * Adds a forward solution but propagating the solution backwards along
	  * the credential chain. If s is a partial solution and all k pieces have
	  * arrived, then add edge from this node to the intersection.
	  */
	 public void forwardSolutionAdded(ProofNode s, ForwardSolution r) {
		  EntityExpression expr = s.getRoleExp();
		  Iterator iCreds = getGraph().findCredentialsByPartialSubject(expr);
		  
		  super.forwardSolutionAdded(s, r);
		  if(iCreds.hasNext()) {  // if s is partial solution of intersection(s)
				StaticCredential credential = (StaticCredential) iCreds.next();
				Intersection i = (Intersection)credential.getSubject();				
				if(partialSolutions.addPartialSolution(i, expr)) {
					 ProofNode node = getGraph().addForwardNode(i);
					 node.addParent(node, r);
				}
		  } 
	 }

    class ForwardLinkingMonitor implements ForwardSolutionListener {
        public void forwardSolutionAdded(ProofNode s,  ForwardSolution sol) {
			if (sol instanceof Role) {
				Role  role = (Role)sol;
				if (role.getName() instanceof RPermission) {
					return;
				}
				LinkedRole linkedRole = 
					 new LinkedRole(role, ((Role)getRoleExp()).getName());
				//if (getGraph().hasCredentialsForSubject(linkedRole)) {
				ProofNode node = getGraph().addForwardNode(linkedRole);
				node.addParent(RoleProofNode.this, s);
				// addProofEdge(this, node, s);
			}
        }

	    public String toString() {
	    	return "Monitor " + getRoleExp();
	    }
    }
	
	
} // End of class RoleProofNode