/*
    * Copyright (c) 2005 Regents of the University of California (Regents). Created
    * by TELS, Graduate School of Education, University of California at Berkeley.
    *
    * This software is distributed under the GNU Lesser General Public License, v2.
    *
    * Permission is hereby granted, without written agreement and without license
    * or royalty fees, to use, copy, modify, and distribute this software and its
    * documentation for any purpose, provided that the above copyright notice and
   * the following two paragraphs appear in all copies of this software.
   *
   * REGENTS SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
   * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   * PURPOSE. THE SOFTWAREAND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED
   * HEREUNDER IS PROVIDED "AS IS". REGENTS HAS NO OBLIGATION TO PROVIDE
   * MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
   *
   * IN NO EVENT SHALL REGENTS BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
   * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
   * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF
   * REGENTS HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  package net.sf.sail.common.persistance.memory;
  
  import java.io.PrintStream;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.logging.Logger;
  
  import javax.xml.parsers.DocumentBuilder;
  import javax.xml.parsers.DocumentBuilderFactory;
  import javax.xml.transform.OutputKeys;
  import javax.xml.transform.Result;
  import javax.xml.transform.Source;
  import javax.xml.transform.Transformer;
  import javax.xml.transform.TransformerException;
  import javax.xml.transform.TransformerFactory;
  import javax.xml.transform.dom.DOMSource;
  import javax.xml.transform.stream.StreamResult;
  
  import net.sf.sail.core.beans.Pod;
  import net.sf.sail.core.beans.SessionContext;
  import net.sf.sail.core.beans.UnknownPodException;
  import net.sf.sail.core.beans.service.AgentService;
  import net.sf.sail.core.curnit.Curnit;
  import net.sf.sail.core.entity.AgentSet;
  import net.sf.sail.core.entity.IAgent;
  import net.sf.sail.core.entity.ISock;
  import net.sf.sail.core.entity.Rim;
  import net.sf.sail.core.entity.Role;
  import net.sf.sail.core.entity.UnsupportedRimShapeException;
  import net.sf.sail.core.entity.User;
  import net.sf.sail.core.uuid.UserUuid;
  
  import org.w3c.dom.CDATASection;
  import org.w3c.dom.Document;
  import org.w3c.dom.Element;
  
  public class MemoryPersistenceImpl 
  	implements AgentService {
  	/**
  	 * Logger for this class
  	 */
  	private static final Logger logger = Logger
  			.getLogger(MemoryPersistenceImpl.class.getName());
  
  	Map<Role,AgentSet> rolesToAgents = new HashMap<Role,AgentSet>();
  
  	Map<SockKey,ISock<Object>> socks = new HashMap<SockKey,ISock<Object>>();
  
  	Map<UserUuid,AgentSet> usersToAgents = new HashMap<UserUuid,AgentSet>();
  
  	Map<Rim<Object>, AgentSet> rimsToAgents = new HashMap<Rim<Object>, AgentSet>();
  
  	/**
  	 * Just a plain old list of agents nothing fancy like the maps above
  	 */
  	List<IAgent> agents = new ArrayList<IAgent>();
  	
  	/**
  	 * A sock is specified by an MemoryAgent,Rim tuple
  	 * 
  	 * @author turadg
  	 */
  	static class SockKey<T> {
  		IAgent agent;
  
  		Rim<T> rim;
  
  		SockKey(Rim<T> rim, IAgent agent) {
  			if (rim == null)
  				throw new IllegalArgumentException("rim is null");
  			if (agent == null)
 				throw new IllegalArgumentException("agent is null");
 			this.rim = rim;
 			this.agent = agent;
 		}
 
 		@Override
 		public int hashCode() {
 			return agent.hashCode() * 43 + rim.hashCode();
 		}
 
 		@SuppressWarnings("unchecked")
 		@Override
 		public boolean equals(Object obj) {
 			if (!(obj instanceof SockKey))
 				return false;
 			SockKey sk = (SockKey) obj;
 			return this.rim == sk.rim && this.agent == sk.agent;
 		}
 
 		@Override
 		public String toString() {
 			return "SockKey[" + rim + "," + agent + "]";
 		}
 	}
 
 	public AgentSet getAgentsInRole(Role role) {
 		AgentSet agentSet = rolesToAgents.get(role);
 		if (agentSet == null)
 			agentSet = new AgentSet();
 		return agentSet;
 	}
 
 	@SuppressWarnings("unchecked")
 	public <T> ISock<T> getSock(Rim<T> rim, IAgent agent) throws UnsupportedRimShapeException {
 		if (rim == null)
 			throw new IllegalArgumentException("getSock() received null rim");
 		if (agent == null)
 			throw new IllegalArgumentException("getSock() received null agent");
 
 		SockKey<T> key = new SockKey<T>(rim, agent);
 		ISock sock = socks.get(key);
 		if (sock == null) {
 			Class<?> shape = rim.getShape();
 			if (shape == String.class) {
 				sock = new MemorySock<T>(rim);
 			} else
 				throw new UnsupportedRimShapeException(rim);
 			socks.put(key, sock);
 			registerRimUse(rim, agent);
 		}
 		return sock;
 	}
 
 	/**
 	 * @param rim
 	 * @param agent
 	 */
 	@SuppressWarnings("unchecked")
 	private void registerRimUse(Rim rim, IAgent agent) {
 		AgentSet agents = rimsToAgents.get(rim);
 		if (agents == null) {
 			agents = new AgentSet();
 			rimsToAgents.put(rim, agents);
 		}
 		agents.add(agent);
 	}
 
 	/**
 	 * @param agent
 	 */
 	protected void addAgent(MemoryAgent agent) {
 		AgentSet agentSet = rolesToAgents.get(agent.getRole());
 		if (agentSet == null) {
 			agentSet = new AgentSet();
 			rolesToAgents.put(agent.getRole(), agentSet);
 		}
 		agentSet.add(agent);
 
 		UserUuid[] users = agent.getUserArray();
 		for (UserUuid element : users) {
 			recordUserMembership(element, agent);
 		}
 		
 		agents.add(agent);
 	}
 
 	private void recordUserMembership(UserUuid user, IAgent agent) {
 		AgentSet existingAgents = usersToAgents.get(user);
 		if (existingAgents == null) {
 			existingAgents = new AgentSet();
 			usersToAgents.put(user, existingAgents);
 		}
 		if (!existingAgents.contains(agent))
 			existingAgents.add(agent);
 	}
 
 	String[] getKnownRoles() {
 		Set<Role> roleSet = rolesToAgents.keySet();
 		String[] roleArray = new String[roleSet.size()];
 		roleSet.toArray(roleArray);
 		return roleArray;
 	}
 
 	public AgentSet getAgentsOfUser(User user) {
 		AgentSet agentSet = new AgentSet();
 		for (IAgent agent : agents) {
 			UserUuid userIds[] = agent.getUserArray();
 			for (UserUuid userId : userIds) {
 				if(user.getUserUUID().equals(userId) &&
 						!agentSet.contains(agent)){
 					agentSet.add(agent);
 				}
 			}
 		}
 		
 		return agentSet;
 	}
 
 	/**
 	 * Dump to out in SSDIF representation.
 	 */
 	public void dump(SessionContext session, PrintStream out) {
 		Document document;
 		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 		DocumentBuilder builder = null;
 		try {
 			builder = factory.newDocumentBuilder();
 		} catch (Exception e) {
 			// how can this fail?
 			logger.severe("SessionContext, PrintStream -  : exception: " + e); //$NON-NLS-1$
 		}
 
 		document = builder.newDocument();
 		Element root = document.createElement("ssdif");
 		document.appendChild(root);
 
 		Element authorData = buildAuthorDataElement(session, document);
 		root.appendChild(authorData);
 
 		Element sessionElement = buildSessionElement(session, document);
 		root.appendChild(sessionElement);
 
 		try {
 			writeDocument(document, out);
 		} catch (TransformerException e) {
 			// TODO Auto-generated catch block
 			logger.severe("SessionContext, PrintStream -  : exception: " + e); //$NON-NLS-1$
 		}
 	}
 
 	/**
 	 * @param doc
 	 * @return
 	 */
 	private Element buildSessionElement(SessionContext session, Document doc) {
 		Element sessionElement = doc.createElement("session");
 
 		sessionElement.setAttribute("sessionId", session.getSessionId()
 				.toString());
 
 		Date startTime = session.getStartTime();
 		if (startTime != null)
 			sessionElement.setAttribute("startTime", startTime.toGMTString());
 		Date stopTime = session.getStopTime();
 		if (stopTime != null)
 			sessionElement.setAttribute("stopTime", stopTime.toGMTString());
 
 		Element ofrun = doc.createElement("of-run");
 		ofrun.setAttribute("idref", "run1");
 		sessionElement.appendChild(ofrun);
 
 		Element rimsElement = doc.createElement("rims");
 
 		// for each used Rim
 		for (Rim<Object> rim : rimsToAgents.keySet()) {
 			Element rimElement = doc.createElement("rim");
 			String rimName = rim.getName();
 			if (rimName == null)
 				throw new NullPointerException("null rimName during dump");
 			rimElement.setAttribute("id", rimName);
 			// FIX how to find the Pod for a given Rim?
 			rimElement.setAttribute("pod", "not implemented");
 			AgentSet agents = rimsToAgents.get(rim);
 			for (Iterator<?> iter2 = agents.iterator(); iter2.hasNext();) {
 				MemoryAgent agent = (MemoryAgent) iter2.next();
 				Element sockElement = doc.createElement("sock");
 				// FIX agent local id?
 				sockElement.setAttribute("agent", agent.toString());
 				SockKey<Object> sockKey = new SockKey<Object>(rim, agent);
 				ISock<Object> sock = socks.get(sockKey);
 				for (Object value : sock) {
 					Element entry = doc.createElement("entry");
 					// FIX record time of each sock entry
 					entry.setAttribute("time", "not implemented");
 					// FIX serialize objects a more reliable way
 					CDATASection section = doc.createCDATASection(value
 							.toString());
 					entry.appendChild(section);
 					sockElement.appendChild(entry);
 				}
 				rimElement.appendChild(sockElement);
 			}
 			rimsElement.appendChild(rimElement);
 		}
 		sessionElement.appendChild(rimsElement);
 
 		return sessionElement;
 	}
 
 	/**
 	 * @param document
 	 * @param out
 	 * @throws TransformerException
 	 */
 	private void writeDocument(Document document, PrintStream out)
 			throws TransformerException {
 		TransformerFactory xformFactory = TransformerFactory.newInstance();
 		Transformer idTransform = xformFactory.newTransformer();
 		idTransform.setOutputProperty(
 				"{http://xml.apache.org/xslt}indent-amount", "4");
 		idTransform.setOutputProperty(OutputKeys.INDENT, "yes");
 		Source input = new DOMSource(document);
 		Result output = new StreamResult(out);
 		idTransform.transform(input, output);
 	}
 
 	/**
 	 * @param doc
 	 * @return
 	 * @throws UnknownPodException 
 	 */
 	private Element buildAuthorDataElement(SessionContext session, Document doc) {
 		Element authorData = doc.createElement("author-data");
 
 		// This persistanceImpl will only work with original curnit implementation.
 		Curnit curnit = (Curnit) session.getOffering().getCurnit();
 		int curnit_index = indexOf(curnit);
 		Element curnitRef = doc.createElement("curnitRef");
 		curnitRef.setAttribute("id", "curnit" + curnit_index);
 		curnitRef.setAttribute("uuid", curnit.getCurnitId().toString());
 		authorData.appendChild(curnitRef);
 
 		Collection<?> referencedPods = curnit.getReferencedPods();
 		for (Object name : referencedPods) {
 			Pod pod = (Pod) name;
 			Element podRef = doc.createElement("podRef");
 			int pod_index = indexOf(pod);
 			podRef.setAttribute("id", "pod" + pod_index);
 			podRef.setAttribute("uuid", pod.getPodId().toString());
 			authorData.appendChild(podRef);
 		}
 
 		return authorData;
 	}
 
 	/**
 	 * @param podId
 	 * @return
 	 */
 	private int indexOf(Pod pod) {
 		int index = pods.indexOf(pod);
 		if (index == -1) {
 			// add it
 			index = pods.size();
 			pods.add(pod);
 		}
 		return index;
 	}
 
 	/**
 	 * @param curnit
 	 * @return
 	 */
 	private int indexOf(Curnit curnit) {
 		int index = curnits.indexOf(curnit);
 		if (index == -1) {
 			// add it
 			index = curnits.size();
 			curnits.add(curnit);
 		}
 		return index;
 	}
 
 	static List<Curnit> curnits = new ArrayList<Curnit>();
 
 	static List<Pod> pods = new ArrayList<Pod>();
 
 	/* (non-Javadoc)
 	 * @see net.sf.sail.core.entity.AgentFactory#createAgent(net.sf.sail.core.entity.Role)
 	 */
 	public IAgent createAgent(Role role) {
 		MemoryAgent agent = new MemoryAgent(role);
 		addAgent(agent);
 		return agent;
 	};
 
 }