package edu.stanford.peer.rbtm.engine;

import java.util.*;

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

/**
 * A graph engine is a proof graph which may optionally contain a predicate
 * function. This implementation is a tightly coupled directed credential
 * graph and credential index. 
 *
 * @deprecated 
 */
public class CredentialManager 
    implements java.io.Serializable, ProofGraph, RBTMConstants
{
    static final public Iterator emptyIt = new ArrayList(1).iterator();
    static final public Collection emptyCollection = new ArrayList(1);

    /** stores all the credentials */
    private HashSet credentials = new HashSet();

    /** an index from issuers to credential collections */
    private HashMap indexByIssuer = new HashMap();

    /** an index from roles to credential collections */
    private HashMap indexByRole = new HashMap();

    /** an index from subjects to collections of credentials */
    private HashMap indexBySubject = new HashMap();

    /** predicate function which could be null */
    private Predicate pred = null;

	private int track;

	private SolutionFilter solutionFilter;

	// a proof queue
	transient private ProofQueue proofQueue = new SimpleProofQueue();

	transient private HashMap    nodeTable = new HashMap();

	public CredentialManager(Set credSet, int trackType, 
							 SolutionFilter solFilter) 
	{
		this(trackType, solFilter);
		addCredentials(credentials);
	}

	public CredentialManager(int trackType, SolutionFilter solFilter) {
		track = trackType;
		solutionFilter = solFilter;
	}

	public CredentialManager() {
		this(TRACK_NONE, new DefaultSolutionFilter());
	}

	public void reinit() {
		proofQueue = new SimpleProofQueue();
		nodeTable = new HashMap();
	}

	synchronized public void addCredentials(Collection credentials) {
		reinit();
		Iterator credIt = credentials.iterator();
		while (credIt.hasNext()) {
			addCredential((StaticCredential)credIt.next());
		}
	}

	synchronized public void removeCredentials(Collection credentials) {
		reinit();
		Iterator credIt = credentials.iterator();
		while (credIt.hasNext()) {
			removeCredential((StaticCredential)credIt.next());
		}
	}

    synchronized public boolean addCredential(StaticCredential cred) {
        // Make sure that no duplicate Credential exists
        if (credentials.contains(cred)) {
	        Debug.debugInfo("trying to add existing credential: " + cred);
            return false;
        }
        Debug.debugInfo("adding credential: " + cred);
        credentials.add(cred);
		addIndexFor(cred);
		ProofNode node = getNode(cred.getDefinedRole());
		if (node != null) {
			node.invalidateBackward();
		}
		node = getNode(cred.getSubject());
		if (node != null) {
			node.invalidateForward();
		}
	    return true;
    }

	synchronized public void removeCredential(StaticCredential cred) {
		if (credentials.contains(cred)) {
			Debug.debugInfo("removing credential: " + cred);
			reinit();
			credentials.remove(cred);
			removeIndexFor(cred);
		} else {
			Debug.debugInfo("trying to remove nonexistent credential: " + cred);
			//// throw Exception
		}
	}

	private void addIndexFor(StaticCredential cred) 
	{
		Entity e = cred.getIssuer();
		ArrayList credList = (ArrayList)indexByIssuer.get(e);
		if (credList == null) {
			credList = new ArrayList(40);
			indexByIssuer.put(e, credList);
		}
		credList.add(cred);

        // Code to deal with indexByRole
        Role r = cred.getDefinedRole();
        credList = (ArrayList) indexByRole.get(r);
        if (credList == null) {
            credList = new ArrayList(10);
            indexByRole.put(r, credList);
        }
        credList.add(cred);

        EntityExpression subject = cred.getSubject();
		  if(subject instanceof Intersection) {
				Iterator parts = ((Intersection)subject).getParts();
				while(parts.hasNext()) {
					 EntityExpression partialSolution = 
						  (EntityExpression)parts.next();
					 credList = (ArrayList) indexBySubject.get(subject);
					 if (credList == null) {
						  credList = new ArrayList(10);
						  indexBySubject.put(partialSolution, credList);
					 }
					 credList.add(cred);
				}
		  } else {
				credList = (ArrayList) indexBySubject.get(subject);
				if (credList == null) {
					 credList = new ArrayList(10);
					 indexBySubject.put(subject, credList);
				}
				credList.add(cred);
		  }
	}

	private void removeIndexFor(StaticCredential cred) 
	{
		((ArrayList)indexByIssuer.get(cred.getIssuer())).remove(cred);
		((ArrayList)indexByRole.get(cred.getDefinedRole())).remove(cred);
		((ArrayList)indexBySubject.get(cred.getSubject())).remove(cred);
	}

	/*
	public void addRole(Role role) {
		if (! indexByRole.containsKey(role)) {
			indexByRole.put(role, new ArrayList());
		}
	}
	*/

    synchronized public Collection getCredentialsIssuedBy(Entity e) {
    	Collection credentials = (Collection)indexByIssuer.get(e);
		if (credentials == null) {
			return emptyCollection;
		} else {
    		return credentials;
		}
    }

    synchronized public Iterator findCredentialsDefiningRole(Role r) 
    {
        ArrayList credList = (ArrayList) indexByRole.get(r);
        if (credList == null) {
            return emptyIt;
        } else {
            return credList.iterator();
        }
    }

    synchronized public Iterator findCredentialsBySubject(EntityExpression subject)
    {
        ArrayList credList = (ArrayList) indexBySubject.get(subject);
        if (credList == null) {
            return emptyIt;
        } else {
            return credList.iterator();
        }
    }

	 synchronized public Iterator findCredentialsByPartialSubject(EntityExpression subject) 
	 {
		  // Using a vector copies the arraylist so we don't remove from it
        ArrayList credList = (ArrayList)indexBySubject.get(subject);
        if (credList == null) {
            return emptyIt;
        }
		  credList = (ArrayList)credList.clone();
		  Iterator i = credList.iterator(); 
		  while(i.hasNext()) {	// remove credential which aren't intersections
				StaticCredential cred = (StaticCredential)i.next();
				if(!(cred.getSubject() instanceof Intersection)) {
					 i.remove();
				}
		  }
		  return credList.iterator();
	 }

	/*    
    boolean hasCredentialsForSubject(EntityExpression re) {
        return findCredentialsBySubject(re).hasNext();
    }
	*/

    // Find out all Roles that roleExp belongs to
    synchronized public ResultEvidenceMap forwardSearch(EntityExpression roleExp) {
        ProofNode goalNode = addForwardNode(roleExp);
        while (proofQueue.hasUnexploredForwardNodes()) {
            proofQueue.nextUnexploredForwardNode().forwardProcess();
        }
        return goalNode.getForwardSolutions();
    }

    // Find out all members of roleExp
    synchronized public ResultEvidenceMap backwardSearch(EntityExpression roleExp) {
        ProofNode goalNode = addBackwardNode(roleExp);
        while (proofQueue.hasUnexploredBackwardNodes()) {
            proofQueue.nextUnexploredBackwardNode().backwardProcess();
        }
        return goalNode.getBackwardSolutions();
    }

    public ProofNode addForwardNode(EntityExpression roleExp) {
        ProofNode node = addNode(roleExp);
        proofQueue.addForwardNode(node);
        return node;
    }

    public ProofNode addBackwardNode (EntityExpression roleExp) {
        ProofNode node = addNode(roleExp);
        proofQueue.addBackwardNode(node);
        return node;
    }

    /**
     * Add a node corresponding to a role expression, make sure that the 
     * node is not added twice.
     */
    private ProofNode addNode (EntityExpression roleExp) {
        ProofNode node = (ProofNode)nodeTable.get(roleExp);
        if (node == null) {
            node = createProofNode(roleExp);
            nodeTable.put(roleExp, node);
        }
        return node;
    }

	private ProofNode getNode(EntityExpression roleExp) {
        return (ProofNode)nodeTable.get(roleExp);
    }

    private ProofNode createProofNode (EntityExpression roleExp) {
        if (roleExp instanceof Role) {
            return new RoleProofNode(this, (Role)roleExp, track);
        } else if (roleExp instanceof LinkedRole) {
            return new LinkedRoleProofNode(this, (LinkedRole)roleExp, track);
        } else if (roleExp instanceof Intersection) {
            return new IntersectionProofNode(this,(Intersection)roleExp,track);
        } else {
            return new EntityProofNode(this, (Entity)roleExp, track);
        }
    }

    public ForwardSolution getForwardSolution(EntityExpression re) {
		return solutionFilter.getForwardSolution(re);
    }

    public BackwardSolution getBackwardSolution(EntityExpression re) {
	    return solutionFilter.getBackwardSolution(re);
    }

    public String toString() {
        return "credentials=" + credentials.toString() + "\n" +
			   "indexByIssuer=" + indexByIssuer.toString() + "\n" +
               "indexByRole=" + indexByRole.toString() + "\n" +
    		   "indexBySubject=" + indexBySubject.toString();
    }
	
	private String getSubjectIndexs()
	{
		StringBuffer outBuf = new StringBuffer();
		Iterator keyIt = indexBySubject.keySet().iterator();
		while (keyIt.hasNext()) {
			Object o = keyIt.next();
			if (o instanceof Role) {
				outBuf.append("Role ").append(o.toString()).append("\n");
				Role r = (Role) o;
				outBuf.append("Base is ").append(r.getBase().getClass()).append("\n");
				outBuf.append("RoleName is ").append(r.getName().getClass()).append("\n");
			}
		}
		return outBuf.toString();
	}

    public HashSet getChain(EntityExpression source, EntityExpression target) {
        return new HashSet();
    }
    
    public Predicate getPredicate() { return pred; }
}