package com.nailabs.abac.process;

import com.nailabs.abac.trust.*;
import com.nailabs.abac.test.*;
import com.nailabs.abac.credential.*;
import edu.stanford.peer.rbtm.credential.*;
import edu.stanford.peer.rbtm.engine.*;

import edu.stanford.rt.credential.CredentialDomain;
import edu.stanford.rt.credential.CredentialStore;
import edu.stanford.rt.credential.RTContext;
import edu.stanford.rt.parser.RTParser;
import java.io.ByteArrayInputStream;
import java.io.InputStream;
import java.util.*;

/**
 * A trust target graph (TTG) is used to represent the state of a trust
 * negotiation in process (one per graph). 
 * @version	$Id: TTG.java,v 1.50 2003/02/26 00:45:11 jjacobs Exp $	

 */
public class TTG extends Observable implements Observer { 
    /** The top-level trust target the system is trying to solve. */
    protected TargetNode root;

    /** An index of TTGNodes based on their trust targets */
    protected Hashtable indexByTT = new Hashtable();

    /** The old change list for this graph */
    protected Message oldDelta =  new Message();

    /** The current change list for this graph */
    protected Message newDelta = new Message();

    /** A set of all previoussent credentials */
    protected HashSet outCache = new HashSet();

    /** A graph engine for storing remotely held credential */
    protected GraphEngine oppoCreds = null;

    /** An RTML parser for de-serializing RTML evidence */
    protected RTParser parser = null;
    
    /** An RTML context for incoming opponent's credentials */
    protected RTContext rtc = null;

    /** A context for a single trust negotiation */
    protected NegotiationContext context;

    /** Create a trust target graph for a specific negotiation */
    public TTG(NegotiationContext context){
	this.context = context;
	if(context.getFrontier() instanceof RtmlFrontier) {
	    try {
		parser = new RTParser();
		rtc = new RTContext(parser);
		oppoCreds = new RtmlEngine(new CredentialStore(parser));
	    }
	    catch(Exception ex) {
		debug("rtml", ex.getMessage());
	    }
	} else {
	    oppoCreds = new GraphEngine();
	}
    }

    /** Propagates node state change information to a graph observer */
    public void update(Observable o, Object arg) {
	//if(o instanceof TTGNode) {
	setChanged();
	notifyObservers(arg);
	//}
	//else {
	//debug("update", "received unexpected observation from " + arg);
	//}
    }

    /**
     * This returns an internal list of all node in the trust target graph.
     * WARNING: this should be a privileged function for production use. Also,
     * any changes to the TTG will invalidate this iterator!
     */
    public Iterator getNodes() {
        return indexByTT.values().iterator();
    }

    public TTGNode getNode(Goal key) {
	TTGNode node = getNodeByHash(key);
	if(node == null) {
	    node = TTGNode.createNode(key);
	    putNodeByHash(node);
	    debug("node", "initialized node for " + key);
	}
	else {
	    debug("node", "found node for " + key);

	}
	return node;
    }

    /** Access a trust target node by the goal it represents */
    public TTGNode getNodeByHash(Goal key) {
	return (TTGNode)indexByTT.get(key.toString());
    }

    /** Entry point for global or local changes. */
    public void putNodeByHash(TTGNode node) {
	indexByTT.put(node.getGoal().toString(), node);
	debug("node", "putting " + node.getGoal());
	node.init(context);
	context.getStrategy().addToWorklist(node);
	context.getStrategy().addNewNode(node);
	setChanged();
	notifyObservers((Object)node);
    
    }

    public void putRoot(TargetNode node) {
	debug("root", "putting root" + node);
	root = node;
	setChanged();
	notifyObservers((Object)node);
    }

    /** A method to reset the change list at the end of a processing cycle */
    public void reset() { 
        //consolidate credentials 
        Iterator i = newDelta.getEvidence();
        while(i.hasNext()) {
            Object potential = i.next();
            if(outCache.contains(potential)) {
                i.remove();
            } else {
                outCache.add(potential);
            }
        }
        oldDelta = newDelta;    // swap out the deltas 
        newDelta = new Message();     
        setChanged();           // notify observers of the changed message
        notifyObservers((Object)oldDelta);
    }

    /** Accessor method for the change list on the graph and resets the list */
    public Message getChanges() {
	return newDelta;
    }
    
    public boolean verifyEvidence(Operation op) {
        Entity self = context.getSelf();
        if(op instanceof LinkingImplicationEdge) {
            return false;
        }
        if((op instanceof ImplicationEdge)) { 
            Goal g = ((EdgeOperation)op).getParent();
            debug("message", "verifying operation " + op);
            return(self.equals(g.getVerifier()));
        }
        debug("message", "not verifying operation " + op);
        return false;
    }

    /** boolean query to determine whether the sepcified goal needs evidence */
    public boolean provideEvidence(Operation edge) {
        Goal g = ((EdgeOperation)edge).getParent();
        Entity self = context.getSelf();
        return (!self.equals(g.getVerifier()));
    }

    /** Update this graph with changes contained in the specified message */
    public void update(Message msg) throws Exception {
	setChanged();
	//notifyObservers("<Update location=\"remote\">\n");
	notifyObservers("location = remote");
	Iterator ev = msg.getEvidence();
	while(ev.hasNext()) {
	    Object eObj = ev.next();
	    if(eObj instanceof String) {
		String xml = (String) eObj;
		InputStream in = new ByteArrayInputStream(xml.getBytes());
		CredentialDomain domain = 
		    parser.parseCredentialDomain(in, rtc);
		((RtmlEngine)oppoCreds).addDomain(domain);
		debug("message", "received evidence = " + domain);
	    }
	    else {
		StaticCredential credential = (StaticCredential)eObj;
		Debug.rbtmStart();
		oppoCreds.addCredential(credential);        
		Debug.rbtmStop();
		debug("message", "received evidence = " + credential);
	    }
	}
	Iterator operations = msg.getOperations();
	while(operations.hasNext()) {
	    Operation op = (Operation)operations.next();
	    debug("message", "performing op " + op);
	    if(verifyEvidence(op)) {
		EdgeOperation edgeOp = (EdgeOperation)op;
		TrustTarget parent = (TrustTarget)edgeOp.getParent();
		TrustTarget child = (TrustTarget)edgeOp.getChild();
		HashSet evidence = null;
		
		//try {
                EntityExpression parentRole = parent.getTargetRole();
                EntityExpression childRole = child.getTargetRole();
                debug("message", "chain search from " + 
                      parentRole + " to " + childRole);
                Debug.rbtmStart();                
                oppoCreds.backwardSearch(parentRole);
                if(parentRole.equals(childRole)) {
                    debug("message", "roles are equal bailing out now!");
                } else {
                    evidence = oppoCreds.getChain(parentRole, childRole);
                    // }
		    Debug.rbtmStop();
		    //} catch(Exception ex) {
		    //ex.printStackTrace();
		    //throw(new java.rmi.RemoteException("Unjustified implication!!"));
		}
		edgeOp.setEvidence(evidence);
		debug("message", "evidence = " + evidence);
	    }
	    setChanged();
	    notifyObservers((Object)op);
	    op.perform(this);
	} 
	setChanged();
	//notifyObservers("</Update>\n");
    }


    /** 
     * Accessor method for of root of graph. This is necessary to traverse
     * the graph. 
     * @returns the root node which may be any TTGNode descendent.
     */
    public TargetNode getRoot() {
	return root;
    }


    // Methods in this section are recorded in the delta list

    /** 
     * Insert a new root node for this graph. 
     * <I>This is a global operation</I>
     */
    public void setRoot(TrustTarget target) {
	debug("root", "setting root = " + target);
	NodeOperation op = new NodeOperation
	    (target, target.getInitialProcessingState(context), true);
	setChanged();
	notifyObservers(op);
	op.perform(this);
	newDelta.addOperation(op);
    }
    
    /**
     * Mark a node in the graph as opponent processed.
     */
    public void setOpponentProcessed(Goal id) {
	//TTGNode node = getNode(id);
	//ProcessingState state = node.getProcessingState();
	//state.opponentProcess(state);
	setNode(id, new ProcessingState(false, true));
    }

    /**
     * Mark a node in the graph as verifier processed.
     */
    public void setVerifierProcessed(Goal id) {
	//TTGNode node = getNode(id);
	//ProcessingState state = node.getProcessingState();
	//state.verifierProcess();
	setNode(id, new ProcessingState(true, false));
    }


    /**
     * Add a root or modify a node to this TTG and replicate the changes on 
     * the opponent's TTG.
     * <I>This is a global operation</I>
     */
    public void setNode(Goal id, ProcessingState state)
    {
        ProcessingState copy = new ProcessingState();
        copy.update(state);
        NodeOperation nodeOp = new NodeOperation(id, copy); 
        context.getStrategy().scheduleOperation(nodeOp);
    }

    /** actually performs the node operation on this graph */
    public void performNode(NodeOperation nodeOp) {
        // This is slightly different than perform edge although they
        // could possibly be merged into a single performOperation method
        nodeOp.perform(this);
        newDelta.addOperation((Operation)nodeOp);
        setChanged();
        notifyObservers((Object)nodeOp);
    }

    /** actually performs a previously scheduled edge operation */
    public void performEdge(EdgeOperation edgeOp) 
    {
        if(edgeOp instanceof LinkingImplicationEdge) {
            setChanged();
            notifyObservers("location = async");
        }
        setChanged();
        notifyObservers((Object)edgeOp);
        edgeOp.perform(this);
        if(edgeOp instanceof ImplicationEdge && provideEvidence(edgeOp)) {
            debug("message", " %%%% adding evidence for " + edgeOp.toString());
            newDelta.addOperation((Operation)edgeOp);
        } else {
            debug("message", " %%%% not adding evidence for" + 
                  edgeOp.toString());
            newDelta.addOperationWithoutEvidence((Operation)edgeOp);
        }
        if(edgeOp instanceof LinkingImplicationEdge) {
            setChanged();
            notifyObservers("location = sync");
        }
    }

    /**
     * Add a new control edge to this TTG and replicate the changes on the 
     * opponent's TTG.
     * <I>This is a global operation</I>
     */
    public void addControlEdge(Goal parent, Goal child)
    {
        TTGNode cnode = getNodeByHash(child);
        ProcessingState state =  (cnode == null)? 
            child.getInitialProcessingState(context): null;
        EdgeOperation edgeOp = new ControlEdge(parent, child, state);
        context.getStrategy().scheduleOperation(edgeOp);
    }

    /**
     * Add a new implication edge to this TTG and replicate the changes on the 
     * opponent's TTG.
     * <I>This is a global operation</I>
     */
    public void addImplicationEdge(Goal parent, Goal child, HashSet creds) {
        TTGNode cnode = getNodeByHash(child);
        //debug("node", "implication cnode = " + cnode); 
        ProcessingState state = (cnode == null)? 
            child.getInitialProcessingState(context): null;
        ImplicationEdge edgeOp = 
            new ImplicationEdge(parent, child,  state, creds);
        context.getStrategy().scheduleOperation(edgeOp);
    }

    /**
     * Add a new intersection edge to this TTG and replicate the edge on the
     * opponent's TTG. <i>This is a global operation</i>
     */
    public void addIntersectionEdge(TrustTarget parent, TrustTarget child) {
        TargetNode cnode = (TargetNode)getNodeByHash(child);
        debug("node", "implication cnode = " + cnode); 
        ProcessingState state = (cnode == null)? 
            child.getInitialProcessingState(context): null;
        IntersectionEdge edgeOp = new IntersectionEdge(parent, child,  state);
        context.getStrategy().scheduleOperation(edgeOp);        
    }

    public void addLinkingMonitorEdge(TrustTarget parent, LinkingGoal child) {
        TTGNode cnode = getNodeByHash(child);
        ProcessingState state =  (cnode == null)? 
            child.getInitialProcessingState(context): null;
        EdgeOperation edgeOp = new LinkingMonitorEdge(parent, child, state);
        context.getStrategy().scheduleOperation(edgeOp);
    }

    public void addLinkingSolutionEdge(LinkingGoal monitor, TrustTarget soln) {
        TTGNode cnode = getNodeByHash(soln);
        ProcessingState state =  (cnode == null)? 
            soln.getInitialProcessingState(context): null;
        EdgeOperation edgeOp = new LinkingSolutionEdge(monitor, soln, state);
        context.getStrategy().scheduleOperation(edgeOp);
    }

    public void addLinkingImplicationEdge(TrustTarget parent, TrustTarget child)
    {
        TTGNode cnode = getNodeByHash(child);
        ProcessingState state =  (cnode == null)? 
            child.getInitialProcessingState(context): null;
        EdgeOperation edgeOp = 
            new LinkingImplicationEdge(parent, child, state);
        context.getStrategy().scheduleOperation(edgeOp);
    }

    /** Friendly debugging convenience method */
    protected void debug(String level, String message) {
	StringBuffer buff = new StringBuffer("TTG[");
	buff.append(context.getSelf()).append("]: ").append(message);
	Debug.debug(level, buff.toString());
    }


    public String toString() {
	StringBuffer buff = new StringBuffer("[TTG EntityID=");
	buff.append(context.getSelf().toString()).append("\n");
	Iterator i = indexByTT.keySet().iterator();
	while(i.hasNext()) {
	    buff.append("\t").append(i.next()).append("\n");
	}
	buff.append("]");
	return buff.toString();
    }

}