/*
    * Created on Aug 26, 2004
    */
   package DTDDoc;
   
   import java.io.PrintWriter;
   import java.text.Collator;
   import java.util.*;
   
  import com.wutka.dtd.*;
  
  /**
   * Used to build the HTML/Javascript code necessary to set up the d-tree.
   *
   * <p>
   * Please note we used d-tree code as a <em>basis</em> for our. d-tree was not
   * our original work. Nothing on the original copyright notice stated that we
   * can't use it the way we do. We contacted the author about that but had no
   * answer so far. Therefore, we conclude that we can use his code (and the
   * JavaScript library as well). If some disagree, we'll be able to explain and,
   * if needed, comply...
   * </p>
   *
   * <p>
   * This class traverses a tree defined as follows:
   * <ul>
   * <li>The root is a DTD file.
   * <li>The children of the root are all the elements in the file.
   * <li>The children of each element are the content model and attribute list
   * for that tree.
   * </ul>
   * Emits a tree node for each node in this tree.
   * </p>
   *
   * @author Michael Koehrsen
   * @author Stefan Champailler
   */
  public class ElementTreeBuilder {
  	/**
  	 * ATTENTION ! Not used right now. Was prototyped in the hope to clean the
  	 * code some more
  	 */
  
  	private static class TreeRunState {
  		/** Maps DTDelement to their numerical Id. */
  		private final Map elementNodeIds = new HashMap();
  
  		/** The Id that the next element (in the map) will get. */
  		private int nextNodeId = 0;
  
  		/**
  		 * Allocates an id for an element of the tree. Please note that id
  		 * allocated this way will not be tied to a particular DTDElement. So
  		 * please use this function for things that are not DTDElement.
  		 *
  		 * @return A new id.
  		 */
  		int allocateIdGeneric() {
  			int nid = nextNodeId;
  			nextNodeId++;
  			return nid;
  
  		}
  
  		/**
  		 * Adds a element to the mapping. If the element is already in the
  		 * mapping, doesn't do anything.
  		 *
  		 * @param element
  		 *            Element to add.
  		 * @return The id associted to the node.
  		 */
  
  		int addIdElement(DTDElement element) throws Exception {
  			String key = element.getName();
  
  			if (!isNodeVisited(element)) {
  				int nid = allocateIdGeneric();
  				elementNodeIds.put(key, new Integer(nid));
  				return nid;
  			} else
  				return getElementId(element);
  		}
  
  		boolean isNodeVisited(DTDElement element) {
  			return elementNodeIds.containsKey(element.getName());
  		}
  
  		int getElementId(DTDElement element) throws Exception {
  			String key = element.getName();
  
  			if (isNodeVisited(element))
  				return ((Integer) elementNodeIds.get(key)).intValue();
  			else
  				throw new Exception("Requested the id of " + key + ", which"
  						+ " doesn't exist !");
  
  		}
  	}
 
 	private Logger log;
 	
 	// modifier bitmasks:
 	private static final int UNMODIFIED = 0;
 
 	private static final int BOLD = 1;
 
 	private static final int ITALIC = 2;
 
 	private static final int ALWAYS_OPEN = 4;
 
 	private static final int INITIALLY_OPEN = 8;
 
 	private final PrintWriter out;
 
 	private final DTDCommenter commenter;
 
 	private final Set dtds;
 
 	private ExtendedDTD currentDTD;
 
 	private int nextNodeId = 0;
 
 	private Map elementNodeIds = new HashMap(); // Maps element names to node
 												// ids for currentDTD
 
 	public ElementTreeBuilder(PrintWriter out, DTDCommenter commenter,
 			Set dtds, Logger log) {
 		this.log = log;
 		this.out = out;
 		this.commenter = commenter;
 		this.dtds = dtds;
 	}
 
 	/**
 	 * Builds the HTML/Javascript code necessary to the invocation of d-tree.
 	 */
 
 	public void generateTree() {
 		out.println("<div class='dtree'>");
 		out.println("<script type='text/javascript'>");
 		out.println("//<!--"); // comment script body
 
 		out.println("eltTree = new CCTree('detail');");
 
 		// The nodes will be identified according to the following ID.
 		// therefore, we make sure it is suitable before going any further.
 		nextNodeId = 0;
 
 		// Note that the top node as a parent with id of -1.
 		//addTreeNode(-1, "Files", null,ALWAYS_OPEN);
 		
 		SortedMap dtdsByTitle = new TreeMap(Collator.getInstance());
 
 		for (Iterator iter = dtds.iterator(); iter.hasNext(); ) {
 			ExtendedDTD dtd = (ExtendedDTD)iter.next();
 			dtdsByTitle.put(dtd.getTitle(), dtd);
 		}
 
 		for (Iterator iter = dtdsByTitle.entrySet().iterator(); iter.hasNext(); ) {
 			Map.Entry entry = (Map.Entry)iter.next();
 			ExtendedDTD dtd = (ExtendedDTD)entry.getValue();
 			visitCurrentDTD(dtd);
 		}
 
 		out.println("document.write(eltTree);");
 		out.println("//-->");
 		out.println("</script>");
 		out.println("</div>");
 	}
 
 	private void visitCurrentDTD(ExtendedDTD dtd) {
 		// Some initialisations...
 		currentDTD = dtd;
 		elementNodeIds = new HashMap();
 
 		// The DTD's name is a root node.
 		int nodeId = generateTreeNode(-1, dtd.getTitle(), commenter
 				.getDTDBaseURI(dtd), UNMODIFIED);
 
 		// The first level of this DTD children is populated with
 		// the elements definitions. We sort them to make the read
 		// easier.
 
 		Collection c = Tools.sort(dtd.getElementsCollection(),
 				new Comparator() {
 					public int compare(Object oa, Object ob) {
 						DTDElement a = (DTDElement) oa;
 						DTDElement b = (DTDElement) ob;
 						return a.getName().compareToIgnoreCase(b.getName());
 					}
 				});
 
 		// Build the tree.
 
 		for (Iterator i = c.iterator(); i.hasNext();)
 			visitElement(nodeId, (DTDElement) i.next(), null, true);
 	}
 
 	/**
 	 * Visit an element and generate the Javascript d-tree code.
 	 *
 	 * @param parentNodeId
 	 *            Id of the parent of the element
 	 * @param dtdElement
 	 *            The element
 	 * @param cardinality
 	 *            The cardinality <em>applied</em> to the element (this is
 	 *            obviously given in the parent definition).
 	 * @throws Exception
 	 */
 	private void visitElement(int parentNodeId, DTDElement dtdElement,
 			DTDCardinal cardinality, boolean firstLevel) {
 		// We check if we have already visited the element. This avoids
 		// all sorts of infinite loop.
 
 		if (elementNodeIds.containsKey(dtdElement)) {
 			// Since it's the case, we don't need to generate the full
 			// node again. A simple link-node will suffice.
 
 			generateTreeLink(parentNodeId, ((Integer) elementNodeIds
 					.get(dtdElement)).intValue(), dtdElement.getName()
 					+ getCardinalitySymbol(cardinality),
 					getCardinalityModifier(cardinality));
 			return;
 		}
 
 		// It's the first time we visit the element. Therefore, a corresponding
 		// node must be created in the tree.
 
 		String name = dtdElement.getName();
 
 		// Make empty element clear.
 		if (dtdElement.getContent() instanceof DTDEmpty)
 			name = "&lt;" + name + "/&gt;";
 		else if (dtdElement.getContent() instanceof DTDAny)
 			name = name + " (any)";
 
 		int typefaceModifier = getCardinalityModifier(cardinality);
 
 		// Make the root appear clearly. Root is emphasized only when
 		// displayed on the first level of children of the DTD node.
 
 		if (currentDTD.isRoot(dtdElement) && firstLevel) {
 			name = name + " (root)";
 			typefaceModifier |= BOLD;
 		}
 
 		int nodeId = generateTreeNode(parentNodeId, name
 				+ getCardinalitySymbol(cardinality), commenter.newURITo(
 				currentDTD, dtdElement).toString(), typefaceModifier);
 
 		// Remeber that we visited the current element.
 		elementNodeIds.put(dtdElement, new Integer(nodeId));
 
 		// Show attributes, if any
 		generateAttributesNodes(nodeId, dtdElement);
 
 		// Now we look for recursion ddeper in the tree
 
 		if (dtdElement.getContent() instanceof DTDContainer)
 
 			visitContainer(nodeId, (DTDContainer) dtdElement.getContent());
 
 		else if (dtdElement.getContent() instanceof DTDAny) {
 
 			// See section 3 of the XML spec for info about this ANY thing.
 
 			Iterator i = currentDTD.getElementsCollection().iterator();
 			while (i.hasNext())
 				// This won't loop infitenly because we shortcut
 				// it at the beginning of this method.
 				visitElement(nodeId, (DTDElement) i.next(), null, true);
 		}
 
 		// FIXME what about DTDName,
 		// DTDPCData : must appear in parenthieseis, that is, in a container.
 	}
 
 	/**
 	 * Visit a container and generate the Javascript d-tree code. The children
 	 * of the container are visited (recursively) as well.
 	 *
 	 * @param parentId
 	 *            The parent id of the parent of the container (-1 if none).
 	 * @param container
 	 *            The container to visit.
 	 * @throws Exception
 	 *             If anything goes wrong.
 	 */
 
 	public void visitContainer(final int parentId, DTDContainer container) {
 		// We simplify the display of elements defined like this :
 		// <!ELEMENT alpha (#PCDATA)>
 		// is shown as a simple element (i.e. containing just text
 		// with no apparent structure, although it's a container).
 
 		if (container instanceof DTDMixed && container.getItems() != null
 				&& container.getItems().length == 1
 				&& container.getItems()[0] instanceof DTDPCData)
 			return;
 
 		int newNodeId = parentId;
 
 		// A sequence without cardinality (for example
 		// <!ELEMENT alpha (beta,gamma,etha)>) is not shown
 		// explicitely, to ease reading.
 
 		if (!(container instanceof DTDSequence && container.getCardinal() == DTDCardinal.NONE))
 			newNodeId = generateContainerNode(container, parentId);
 
 		// Now we recurse...
 
 		//DTDItem[] childItems = container.getItems();
 		Iterator i = container.getItemsVec().iterator();
 
 		while (i.hasNext()) {
 			DTDItem childItem = (DTDItem) i.next();
 
 			if (childItem instanceof DTDName) {
 
 				DTDElement childElement = (DTDElement) currentDTD
 						.getElementByName((DTDName) childItem);
 
 				if (childElement != null)
 					visitElement(newNodeId, childElement, childItem
 							.getCardinal(), true);
                                 // SC 3/8/2006 Removed this log 'cos too verbose
 				//else
 				//	log.warn("Malformed DTD ! Unknown element: "
 				//			+ ((DTDName) childItem).getValue() + " in "
 				//			+ currentDTD.getSystemPath());
 			} else if (childItem instanceof DTDContainer)
 				visitContainer(newNodeId, (DTDContainer) childItem);
 
 			// Note : EMPTY and ANY can't appear here because we're inside
 			// a container
 		}
 	}
 
 	/**
 	 * Generate the d-tree code for a container node. Does not recurse over the
 	 * children of the container.
 	 *
 	 * @param container
 	 *            The container node.
 	 * @param parentId
 	 *            The id of the parent of the container (-1 if none).
 	 * @return The id associated to the container node.
 	 */
 
 	private int generateContainerNode(DTDContainer container, int parentId) {
 
 		String s = null;
 
 		if (container instanceof DTDMixed)
 			s = "mixed";
 		else if (container instanceof DTDChoice)
 			s = "choice";
 		else if (container instanceof DTDSequence)
 			s = "sequence";
 		else
 			log.error("Unsupported type of container: " + container.getClass());
 
 		return generateTreeNode(parentId, "&lt;" + s + "&gt;"
 				+ getCardinalitySymbol(container.getCardinal()), null, ITALIC
 				| getCardinalityModifier(container.getCardinal()) | ALWAYS_OPEN);
 	}
 
 	private String getCardinalitySymbol(DTDCardinal card) {
 		if (card == DTDCardinal.OPTIONAL)
 			return "?";
 		if (card == DTDCardinal.ZEROMANY)
 			return "*";
 		if (card == DTDCardinal.ONEMANY)
 			return "+";
 		return "";
 	}
 
 	private int getCardinalityModifier(DTDCardinal card) {
 		if ((card == DTDCardinal.NONE) || (card == DTDCardinal.ONEMANY))
 			return BOLD;
 		else
 			return UNMODIFIED;
 	}
 
 	/**
 	 * Generates the Javascript code for representing the attributes of a given
 	 * element. Once displayed in the tree, the attributes will be sorted
 	 * according to the natural order of their names (e.g. alphabetical).
 	 *
 	 * @param parentNodeId
 	 *            Parent id of the element.
 	 * @param dtdElement
 	 *            Element to get the attributes from.
 	 * @throws Exception
 	 */
 
 	private void generateAttributesNodes(int parentNodeId, DTDElement dtdElement) {
 		// Make sure there's actually something to show
 		if (dtdElement.attributes == null || dtdElement.attributes.size() <= 0)
 			return;
 
 		SortedMap sortedAttributes = new TreeMap(dtdElement.attributes);
 
 		// Build the Javascript code for each attribute
 
 		for (Iterator iter = sortedAttributes.entrySet().iterator(); iter.hasNext(); ) {
 			Map.Entry entry = (Map.Entry)iter.next();
 			DTDAttribute attr = (DTDAttribute) entry.getValue();
 			int modifier = UNMODIFIED;
 			if (attr.decl == DTDDecl.REQUIRED)
 				modifier = BOLD;
 
 			generateTreeNode(parentNodeId, "@" + attr.getName(),
 					commenter.newURITo(currentDTD, dtdElement, attr).toString(),
 					modifier);
 		}
 	}
 
 	/**
 	 * Generates the Javascript code for one node of the d-tree.
 	 *
 	 * @param parentNodeId
 	 *            The id of the parent node. If the node is the root node, then
 	 *            this must be -1.
 	 * @param label
 	 *            The label that will represent the node.
 	 * @param url
 	 *            The URL that will be attached to the node.
 	 * @param modifiers
 	 *            Modifiers to change the presentation of the node. Accepted
 	 *            values are ITALIC, BOLD, ALWAYS_OPEN, INITIALLY_OPEN.
 	 *
 	 * @return the nodeId that was allocated to the added node.
 	 */
 	private int generateTreeNode(int parentNodeId, String label, String url,
 			int modifiers) {
 		int nodeId = nextNodeId++;
 		label = Tools.escapeHTMLUnicode(label, true);
 
 		if ((modifiers & ITALIC) == ITALIC)
 			label = "<i>" + label + "</i>";
 		if ((modifiers & BOLD) == BOLD)
 			label = "<b>" + label + "</b>";
 
 		// FIXME url should be in the class URL, not a string !
 
 		if (url != null)
 			url = "'" + url + "'";
 		else
 			url = "null";
 
 		boolean alwaysOpen = (modifiers & ALWAYS_OPEN) == ALWAYS_OPEN;
 		boolean initiallyOpen = (modifiers & INITIALLY_OPEN) == INITIALLY_OPEN;
 
 		String addNodeFunc = (parentNodeId >= 0 ? "addNode" : "addRootNode");
 
 		out.println("eltTree." + addNodeFunc + "('" + nodeId + "','" + label
 				+ "'," + url + "," + alwaysOpen + "," + initiallyOpen + ")");
 
 		if (parentNodeId >= 0)
 			out.println("eltTree.linkNodes('" + parentNodeId + "','" + nodeId
 					+ "')");
 
 		return nodeId;
 	}
 
 	/**
 	 * Generates the Javascript code for one link-node of the d-tree. A link is
 	 * a node of the tree that represents another node (non-link) of the tree.
 	 *
 	 * @param parentNodeId
 	 *            Id of the parent node of the link-node.
 	 * @param nodeId
 	 *            Id of the node the link refers to.
 	 * @param label
 	 *            Label to be displayed for the link.
 	 * @param modifiers
 	 *            Modifiers to change the presentation of the node. Accepted
 	 *            values are ITALIC, BOLD, ALWAYS_OPEN, INITIALLY_OPEN.
 	 */
 
 	private void generateTreeLink(int parentNodeId, int nodeId, String label,
 			int modifiers) {
 		if ((modifiers & ITALIC) == ITALIC)
 			label = "<i>" + label + "</i>";
 		if ((modifiers & BOLD) == BOLD)
 			label = "<b>" + label + "</b>";
 
 		out.println("eltTree.linkNodes('" + parentNodeId + "','" + nodeId
 				+ "','" + label + "')");
 	}
 
 	/**
 	 * Generates preliminary Javascript code needed to load the d-tree library.
 	 *
 	 * @param out
 	 *            Where to generate the code.
 	 */
 
 	public static void generateJavascriptSetup(PrintWriter out) {
 		out.println("<script type='text/javascript' src='cctree.js'></script>");
 	}
 
 }