/*******************************************************************************
 * Copyright (c) 2002, 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Jens Lukowski/Innoopract - initial renaming/restructuring
 *     
 *******************************************************************************/
package org.eclipse.wst.xml.core.internal.contentmodel.util;

import java.util.Hashtable;
import java.util.List;
import java.util.Stack;
import java.util.Vector;

import org.eclipse.wst.xml.core.internal.contentmodel.CMAnyElement;
import org.eclipse.wst.xml.core.internal.contentmodel.CMAttributeDeclaration;
import org.eclipse.wst.xml.core.internal.contentmodel.CMContent;
import org.eclipse.wst.xml.core.internal.contentmodel.CMDataType;
import org.eclipse.wst.xml.core.internal.contentmodel.CMDocument;
import org.eclipse.wst.xml.core.internal.contentmodel.CMElementDeclaration;
import org.eclipse.wst.xml.core.internal.contentmodel.CMGroup;
import org.eclipse.wst.xml.core.internal.contentmodel.CMNamedNodeMap;
import org.eclipse.wst.xml.core.internal.contentmodel.CMNode;
import org.eclipse.wst.xml.core.internal.contentmodel.CMNodeList;
import org.eclipse.wst.xml.core.internal.contentmodel.ContentModelManager;
import org.eclipse.wst.xml.core.internal.contentmodel.internal.util.CMDataTypeValueHelper;
import org.w3c.dom.Attr;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.DocumentType;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.ProcessingInstruction;
import org.w3c.dom.Text;


/**
 * todo... common up this code with 'ContentBuilder'
 */
public class DOMContentBuilderImpl extends CMVisitor implements DOMContentBuilder {
	protected int buildPolicy = BUILD_ALL_CONTENT;
	protected Hashtable propertyTable = new Hashtable();

	protected boolean alwaysVisit = false;
	protected List resultList;
	protected Document document;
	protected Node currentParent;
	protected Node topParent;
	protected Vector visitedCMElementDeclarationList = new Vector();
	protected boolean attachNodesToParent = true;
	protected NamespaceTable namespaceTable;

	protected List namespaceInfoList;
	protected Element rootElement; // this is used only teporarily via
									// createDefaultRootContent
	protected ExternalCMDocumentSupport externalCMDocumentSupport;

	public boolean supressCreationOfDoctypeAndXMLDeclaration;

	protected CMDataTypeValueHelper valueHelper = new CMDataTypeValueHelper();

	protected int numOfRepeatableElements = 1;
	protected Stack cmGroupStack = new Stack();
	protected int depthLimit = -1;

	protected int domLevel;
	private int originalBuildPolicy;
	
	public interface ExternalCMDocumentSupport {
		public CMDocument getCMDocument(Element element, String uri);
	}

	public void setExternalCMDocumentSupport(ExternalCMDocumentSupport externalCMDocumentSupport) {
		this.externalCMDocumentSupport = externalCMDocumentSupport;
	}

	public DOMContentBuilderImpl(Document document) {
		this.document = document;
		namespaceTable = new NamespaceTable(document);
	}

	public void setBuildPolicy(int buildPolicy) {
		this.buildPolicy = buildPolicy;
	}

	public int getBuildPolicy() {
		return buildPolicy;
	}

	protected boolean buildAllContent(int policy) {
		return (policy & BUILD_ALL_CONTENT) == BUILD_ALL_CONTENT;
	}

	protected boolean buildOptionalElements(int policy) {
		return (policy & BUILD_OPTIONAL_ELEMENTS) == BUILD_OPTIONAL_ELEMENTS;
	}

	protected boolean buildOptionalAttributes(int policy) {
		return (policy & BUILD_OPTIONAL_ATTRIBUTES) == BUILD_OPTIONAL_ATTRIBUTES;
	}

	protected boolean buildFirstChoice(int policy) {
		return (policy & BUILD_FIRST_CHOICE) == BUILD_FIRST_CHOICE;
	}

	protected boolean buildTextNodes(int policy) {
		return (policy & BUILD_TEXT_NODES) == BUILD_TEXT_NODES;
	}

	protected boolean buildFirstSubstitution(int policy) {
		return (policy & BUILD_FIRST_SUBSTITUTION) == BUILD_FIRST_SUBSTITUTION;
	}

	public List getResult() {
		return resultList;
	}

	public void setProperty(String propertyName, Object value) {
		propertyTable.put(propertyName, value);
	}

	public Object getProperty(String propertyName) {
		return propertyTable.get(propertyName);
	}

	public void build(Node parent, CMNode child) {
		resultList = new Vector();
		topParent = parent;
		currentParent = parent;
		if (parent instanceof Element) {
			namespaceTable.addElementLineage((Element) parent);
		}
		attachNodesToParent = false;
		alwaysVisit = true;
		visitCMNode(child);
	}

	public void createDefaultRootContent(CMDocument cmDocument, CMElementDeclaration rootCMElementDeclaration, List namespaceInfoList) throws Exception {
		this.namespaceInfoList = namespaceInfoList;
		createDefaultRootContent(cmDocument, rootCMElementDeclaration);
	}

	public void createDefaultRootContent(CMDocument cmDocument, CMElementDeclaration rootCMElementDeclaration) throws Exception {
		String grammarFileName = cmDocument.getNodeName();
		if (!supressCreationOfDoctypeAndXMLDeclaration) {
			// TODO cs... investigate to see if this code path is ever used,
			// doesn't seem to be
			// for now I'm setting the encoding to UTF-8 just incase this code
			// path is used somewhere
			//
			String piValue = "version=\"1.0\""; //$NON-NLS-1$
			String encoding = "UTF-8"; //$NON-NLS-1$
			piValue += " encoding=\"" + encoding + "\""; //$NON-NLS-1$ //$NON-NLS-2$      
			ProcessingInstruction pi = document.createProcessingInstruction("xml", piValue); //$NON-NLS-1$
			document.appendChild(pi);

			// if we have a 'dtd' then add a DOCTYPE tag
			//
			if (grammarFileName != null && grammarFileName.endsWith("dtd")) //$NON-NLS-1$
			{
				DOMImplementation domImpl = document.getImplementation();
				DocumentType documentType = domImpl.createDocumentType(rootCMElementDeclaration.getElementName(), grammarFileName, grammarFileName);
				document.appendChild(documentType);
			}
		}

		// if we have a schema add an xsi:schemaLocation attribute
		//
		if (grammarFileName != null && grammarFileName.endsWith("xsd") && namespaceInfoList != null) //$NON-NLS-1$
		{
			DOMNamespaceInfoManager manager = new DOMNamespaceInfoManager();
			String name = rootCMElementDeclaration.getNodeName();
			if (namespaceInfoList.size() > 0) {
				NamespaceInfo info = (NamespaceInfo) namespaceInfoList.get(0);
				if (info.prefix != null && info.prefix.length() > 0) {
					name = info.prefix + ":" + name; //$NON-NLS-1$
				}
			}
			rootElement = createElement(rootCMElementDeclaration, name, document);
			manager.addNamespaceInfo(rootElement, namespaceInfoList, true);
		}
		createDefaultContent(document, rootCMElementDeclaration);
	}

	public void createDefaultContent(Node parent, CMElementDeclaration ed) {
		currentParent = parent;
		alwaysVisit = true;
		originalBuildPolicy = buildPolicy;
		visitCMElementDeclaration(ed);
	}

	public String computeName(CMNode cmNode, Node parent) {
		String prefix = null;
		return DOMNamespaceHelper.computeName(cmNode, parent, prefix, namespaceTable);
	}

	// overide the following 'create' methods to control how nodes are created
	//
	protected Element createElement(CMElementDeclaration ed, String name, Node parent) {
		return document.createElement(name);
	}

	protected Attr createAttribute(CMAttributeDeclaration ad, String name, Node parent) {
		return document.createAttribute(name);
	}

	protected Text createTextNode(CMDataType dataType, String value, Node parent) {
		return document.createTextNode(value);
	}

	protected void handlePushParent(Element parent, CMElementDeclaration ed) {
	  domLevel++;
	}

	protected void handlePopParent(Element element, CMElementDeclaration ed) {
      domLevel--;
	}

	// The range must be between 1 and 99.
	public void setNumOfRepeatableElements(int i) {
		numOfRepeatableElements = i;
	}

	protected int getNumOfRepeatableElements() {
		return numOfRepeatableElements;
	}

	public void visitCMElementDeclaration(CMElementDeclaration ed) {
		int forcedMin = (buildOptionalElements(buildPolicy) || alwaysVisit) ? 1 : 0;
		int min = Math.max(ed.getMinOccur(), forcedMin);

		// Correct the min value if the element is contained in
		// a group.
		if (!cmGroupStack.isEmpty()) {
			CMGroup group = (CMGroup) cmGroupStack.peek();
			int gmin = group.getMinOccur();
			if (gmin == 0)
				if (buildOptionalElements(buildPolicy)) { 
					/* do nothing: min = min */
				}
				else {
					min = min * gmin; // min = 0
				}
			else {
				min = min * gmin;
			}
		}

		int max = Math.min(ed.getMaxOccur(), getNumOfRepeatableElements());
		if (max < min)
			max = min;

		alwaysVisit = false;

		// Note - ed may not be abstract but has substitutionGroups
		// involved.
		if (buildFirstSubstitution(buildPolicy) || isAbstract(ed)) // leave
																	// this
																	// for
																	// backward
																	// compatibility
																	// for now
		{
			// Note - To change so that if ed is optional, we do not
			// generate anything here.
			ed = getSubstitution(ed);

			// Note - the returned ed may be an abstract element in
			// which case the xml will be invalid.
		}

		if (min > 0 && !visitedCMElementDeclarationList.contains(ed)) {
			visitedCMElementDeclarationList.add(ed);
			for (int i = 1; i <= max; i++) {
				// create an Element for each
				Element element = null;
				if (rootElement != null) {
					element = rootElement;
					rootElement = null;
				}
				else {
					element = createElement(ed, computeName(ed, currentParent), currentParent);
				}

				// visit the children of the GrammarElement
				Node oldParent = currentParent;
				currentParent = element;
				handlePushParent(element, ed);

				namespaceTable.addElement(element);

				boolean oldAttachNodesToParent = attachNodesToParent;
				attachNodesToParent = true;

				// instead of calling super.visitCMElementDeclaration()
				// we duplicate the code with some minor modifications
				CMNamedNodeMap nodeMap = ed.getAttributes();
				int size = nodeMap.getLength();
				for (int j = 0; j < size; j++) {
					visitCMNode(nodeMap.item(j));
				}

				CMContent content = ed.getContent();
				if (content != null) {
					visitCMNode(content);
				}

				if (ed.getContentType() == CMElementDeclaration.PCDATA) {
					CMDataType dataType = ed.getDataType();
					if (dataType != null) {
						visitCMDataType(dataType);
					}
				}
				// end duplication
				attachNodesToParent = oldAttachNodesToParent;
				handlePopParent(element, ed);
				currentParent = oldParent;
				linkNode(element);
			}
			int size = visitedCMElementDeclarationList.size();
			visitedCMElementDeclarationList.remove(size - 1);
		}
	}


	public void visitCMDataType(CMDataType dataType) {
		Text text = null;
		String value = null;

		// For backward compatibility:
		// Previous code uses a property value but new one uses
		// buildPolicy.
		if (getProperty(PROPERTY_BUILD_BLANK_TEXT_NODES) != null && getProperty(PROPERTY_BUILD_BLANK_TEXT_NODES).equals("true")) //$NON-NLS-1$
			buildPolicy = buildPolicy ^ BUILD_TEXT_NODES;

		if (buildTextNodes(buildPolicy)) {
			value = valueHelper.getValue(dataType);
			if (value == null) {
				if (currentParent != null && currentParent.getNodeType() == Node.ELEMENT_NODE) {
					value = currentParent.getNodeName();
				}
				else {
					value = "pcdata"; //$NON-NLS-1$
				}
			}
		}
		else {
			value = ""; //$NON-NLS-1$
		}
		text = createTextNode(dataType, value, currentParent);
		linkNode(text);
	}

	public void visitCMNode(CMNode node) {
		if (depthLimit != -1) {
			if (domLevel > depthLimit) {
				buildPolicy = buildPolicy &= ~BUILD_OPTIONAL_ELEMENTS;
			} else {
				buildPolicy = originalBuildPolicy;
			}
		}
		super.visitCMNode(node);
	}

	public void visitCMGroup(CMGroup e) {
		cmGroupStack.push(e);

		int forcedMin = (buildOptionalElements(buildPolicy) || alwaysVisit) ? 1 : 0;
		int min = Math.max(e.getMinOccur(), forcedMin);

		int max = 0;
		if (e.getMaxOccur() == -1) // unbounded
			max = getNumOfRepeatableElements();
		else
			max = Math.min(e.getMaxOccur(), getNumOfRepeatableElements());

		if (max < min)
			max = min;

		alwaysVisit = false;

		for (int i = 1; i <= max; i++) {
			if (e.getOperator() == CMGroup.CHOICE && buildFirstChoice(buildPolicy)) {
				CMNode hintNode = null;

				// todo... the CMGroup should specify the hint... but it seems
				// as though
				// the Yamato guys are making the CMElement specify the hint.
				// I do it that way for now until... we should fix this post
				// GA
				//    
				int listSize = visitedCMElementDeclarationList.size();
				if (listSize > 0) {
					CMElementDeclaration ed = (CMElementDeclaration) visitedCMElementDeclarationList.get(listSize - 1);
					Object contentHint = ed.getProperty("contentHint"); //$NON-NLS-1$
					if (contentHint instanceof CMNode) {
						hintNode = (CMNode) contentHint;
					}
				}

				// see if this hint corresponds to a valid choice
				//
				CMNode cmNode = null;

				if (hintNode != null) {
					CMNodeList nodeList = e.getChildNodes();
					int nodeListLength = nodeList.getLength();
					for (int j = 0; j < nodeListLength; j++) {
						if (hintNode == nodeList.item(j)) {
							cmNode = hintNode;
						}
					}
				}

				// if no cmNode has been determined from the hint, just use
				// the first choice
				//
				if (cmNode == null) {
					CMNodeList nodeList = e.getChildNodes();
					if (nodeList.getLength() > 0) {
						cmNode = nodeList.item(0);
					}
				}

				if (cmNode != null) {
					// Bug 330260
					// Problem - Add child element also adds optional grand-child elements
					// This assumes 'e' is a model group choice, case 1. However 'e' could be a model group definition, case 2, where the
					// first child is a model group. In the first case (choice), the first child is an
					// element. Upon visiting the element (visitCMElementDeclaration), the minOccurs of the
					// choice is ALSO considered. If its minOccurs is 0, then the first element is not added as a child.
					// However, in the second case (model group definition), the first child is a choice, but the multiplicity is [1,1],
					// meaning, it is required. So the first element is then added as child, even though
					// the model group definition reference is optional. (minOccurs is not checked in this method, visitCMGroup)
					// Visit the node only if it is not a GROUP (model group). If it is an element, then visit it.
					if (!(cmNode.getNodeType() == CMNode.GROUP && min > 0)) {
						visitCMNode(cmNode);
					}
				}
			}
			else if (e.getOperator() == CMGroup.ALL // ALL
						|| e.getOperator() == CMGroup.SEQUENCE) // SEQUENCE
			{
				// visit all of the content
				super.visitCMGroup(e);
			}
		}

		cmGroupStack.pop();
	}

	static int count = 0;

	public void visitCMAttributeDeclaration(CMAttributeDeclaration ad) {
		if (alwaysVisit || buildOptionalAttributes(buildPolicy) || ad.getUsage() == CMAttributeDeclaration.REQUIRED) {
			alwaysVisit = false;
			String name = computeName(ad, currentParent);
			String value = valueHelper.getValue(ad, namespaceTable);
			Attr attr = createAttribute(ad, name, currentParent);
			attr.setValue(value != null ? value : ""); //$NON-NLS-1$
			linkNode(attr);
		}
	}

	protected boolean isAbstract(CMNode ed) {
		boolean result = false;
		if (ed != null) {
			Object value = ed.getProperty("Abstract"); //$NON-NLS-1$
			result = (value == Boolean.TRUE);
		}
		return result;
	}

	protected CMElementDeclaration getSubstitution(CMElementDeclaration ed) {
		CMElementDeclaration result = ed;
		CMNodeList l = (CMNodeList) ed.getProperty("SubstitutionGroup"); //$NON-NLS-1$
		if (l != null) {
			for (int i = 0; i < l.getLength(); i++) {
				CMNode candidate = l.item(i);
				if (!isAbstract(candidate) && (candidate instanceof CMElementDeclaration)) {
					result = (CMElementDeclaration) candidate;
					break;
				}
			}
		}
		return result;
	}

	protected CMElementDeclaration getParentCMElementDeclaration() {
		CMElementDeclaration ed = null;
		int listSize = visitedCMElementDeclarationList.size();
		if (listSize > 0) {
			ed = (CMElementDeclaration) visitedCMElementDeclarationList.get(listSize - 1);
		}
		return ed;
	}

	public void visitCMAnyElement(CMAnyElement anyElement) {
		// ingnore buildPolicy for ANY elements... only create elements if
		// absolutely needed
		//
		int forcedMin = alwaysVisit ? 1 : 0;
		int min = Math.max(anyElement.getMinOccur(), forcedMin);
		alwaysVisit = false;

		String uri = anyElement.getNamespaceURI();
		String targetNSProperty = "http://org.eclipse.wst/cm/properties/targetNamespaceURI"; //$NON-NLS-1$
		CMDocument parentCMDocument = (CMDocument) anyElement.getProperty("CMDocument"); //$NON-NLS-1$
		CMElementDeclaration ed = null;

		// System.out.println("parentCMDocument = " + parentCMDocument);
		// //$NON-NLS-1$
		if (parentCMDocument != null) {
			if (uri == null || uri.startsWith("##") || uri.equals(parentCMDocument.getProperty(targetNSProperty))) //$NON-NLS-1$
			{
				ed = getSuitableElement(getParentCMElementDeclaration(), parentCMDocument);
			}
		}


		if (ed == null && externalCMDocumentSupport != null && uri != null && !uri.startsWith("##") && currentParent instanceof Element) //$NON-NLS-1$
		{
			CMDocument externalCMDocument = externalCMDocumentSupport.getCMDocument((Element) currentParent, uri);
			if (externalCMDocument != null) {
				ed = getSuitableElement(null, externalCMDocument);
			}
		}

		for (int i = 1; i <= min; i++) {
			if (ed != null) {
				visitCMElementDeclaration(ed);
			}
			else {
				Element element = document.createElement("ANY-ELEMENT"); //$NON-NLS-1$
				linkNode(element);
			}
		}
	}

	protected CMElementDeclaration getSuitableElement(CMNamedNodeMap nameNodeMap) {
		CMElementDeclaration result = null;
		int size = nameNodeMap.getLength();
		for (int i = 0; i < size; i++) {
			CMElementDeclaration candidate = (CMElementDeclaration) nameNodeMap.item(i);
			if (!visitedCMElementDeclarationList.contains(candidate)) {
				result = candidate;
				break;
			}
		}
		return result;
	}

	protected CMElementDeclaration getSuitableElement(CMElementDeclaration ed, CMDocument cmDocument) {
		CMElementDeclaration result = null;

		if (ed != null) {
			result = getSuitableElement(ed.getLocalElements());
		}

		if (result == null && cmDocument != null) {
			result = getSuitableElement(cmDocument.getElements());
		}

		return result;
	}


	public void linkNode(Node node) {
		if (attachNodesToParent && currentParent != null) {
			if (node.getNodeType() == Node.ATTRIBUTE_NODE) {
				((Element) currentParent).setAttributeNode((Attr) node);
			}
			else {
				currentParent.appendChild(node);
			}
		}
		else if (resultList != null) {
			resultList.add(node);
		}
	}

	public static void testPopulateDocumentFromGrammarFile(Document document, String grammarFileName, String rootElementName, boolean hack) {
		try {
			CMDocument cmDocument = ContentModelManager.getInstance().createCMDocument(grammarFileName, null);
			CMNamedNodeMap elementMap = cmDocument.getElements();
			CMElementDeclaration element = (CMElementDeclaration) elementMap.getNamedItem(rootElementName);

			DOMContentBuilderImpl contentBuilder = new DOMContentBuilderImpl(document);
			contentBuilder.supressCreationOfDoctypeAndXMLDeclaration = hack;
			contentBuilder.createDefaultRootContent(cmDocument, element);

			System.out.println();
			System.out.println("-----------------------------"); //$NON-NLS-1$
			DOMWriter writer = new DOMWriter();
			if (hack) {
				writer.print(document, grammarFileName);
			}
			else {
				writer.print(document);
			}
			System.out.println("-----------------------------"); //$NON-NLS-1$
		}
		catch (Exception e) {
			System.out.println("Error: " + e); //$NON-NLS-1$
			e.printStackTrace();
		}
	}
	
	public void setOptionalElementDepthLimit(int depth) {
		depthLimit = depth;
	}
	

	// test
	//
	/*
	 * public static void main(String arg[]) { if (arg.length >= 2) { try {
	 * CMDocumentFactoryRegistry.getInstance().registerCMDocumentBuilderWithClassName("org.eclipse.wst.xml.core.internal.contentmodel.mofimpl.CMDocumentBuilderImpl");
	 * 
	 * String grammarFileName = arg[0]; String rootElementName = arg[1];
	 * 
	 * Document document =
	 * (Document)Class.forName("org.apache.xerces.dom.DocumentImpl").newInstance();
	 * testPopulateDocumentFromGrammarFile(document, grammarFileName,
	 * rootElementName, true); } catch (Exception e) {
	 * System.out.println("DOMContentBuilderImpl error"); e.printStackTrace(); } }
	 * else { System.out.println("Usage : java
	 * org.eclipse.wst.xml.util.DOMContentBuildingCMVisitor grammarFileName
	 * rootElementName"); } }
	 */
}