/*******************************************************************************
 * Copyright (c) 2007, 2008 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
 *******************************************************************************/
package org.eclipse.wst.xml.ui.internal.correction;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.eclipse.jface.text.ITextViewer;
import org.eclipse.jface.text.contentassist.ICompletionProposal;
import org.eclipse.jface.text.quickassist.IQuickAssistInvocationContext;
import org.eclipse.jface.text.quickassist.IQuickAssistProcessor;
import org.eclipse.jface.text.source.Annotation;
import org.eclipse.jface.text.source.ISourceViewer;
import org.eclipse.wst.sse.core.StructuredModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IModelManager;
import org.eclipse.wst.sse.core.internal.provisional.IStructuredModel;
import org.eclipse.wst.sse.core.internal.provisional.IndexedRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.IStructuredDocumentRegion;
import org.eclipse.wst.sse.core.internal.provisional.text.ITextRegion;
import org.eclipse.wst.xml.core.internal.contentmodel.CMAttributeDeclaration;
import org.eclipse.wst.xml.core.internal.contentmodel.CMElementDeclaration;
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.basic.CMNamedNodeMapImpl;
import org.eclipse.wst.xml.core.internal.contentmodel.modelquery.ModelQuery;
import org.eclipse.wst.xml.core.internal.modelquery.ModelQueryUtil;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;
import org.eclipse.wst.xml.core.internal.regions.DOMRegionContext;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;

public class XMLQuickAssistProcessor implements IQuickAssistProcessor {

	public boolean canAssist(IQuickAssistInvocationContext invocationContext) {
		return true;
	}

	public boolean canFix(Annotation annotation) {
		return false;
	}

	public ICompletionProposal[] computeQuickAssistProposals(IQuickAssistInvocationContext invocationContext) {
		List proposals = new ArrayList();

		getLocalRenameQuickAssistProposal(proposals, invocationContext.getSourceViewer(), invocationContext.getOffset());
		getSurroundWithNewElementQuickAssistProposal(proposals, invocationContext.getSourceViewer(), invocationContext.getOffset());
		getInsertRequiredAttrs(proposals, invocationContext.getSourceViewer(), invocationContext.getOffset());

		return (ICompletionProposal[]) proposals.toArray(new ICompletionProposal[proposals.size()]);
	}

	public String getErrorMessage() {
		return null;
	}

	private void getInsertRequiredAttrs(List proposals, ISourceViewer viewer, int offset) {
		IDOMNode node = (IDOMNode) getNodeAt(viewer, offset);
		if ((node != null) && (node.getNodeType() == Node.ELEMENT_NODE)) {
			IStructuredDocumentRegion startStructuredDocumentRegion = node.getStartStructuredDocumentRegion();
			if ((startStructuredDocumentRegion != null) && startStructuredDocumentRegion.containsOffset(offset)) {
				IDOMNode cursorNode = (IDOMNode) getNodeAt(viewer, offset);
				List requiredAttrs = getRequiredAttrs(cursorNode);
				if (requiredAttrs.size() > 0) {
					NamedNodeMap currentAttrs = node.getAttributes();
					List insertAttrs = new ArrayList();
					if (currentAttrs.getLength() == 0) {
						insertAttrs.addAll(requiredAttrs);
					}
					else {
						for (int i = 0; i < requiredAttrs.size(); i++) {
							String requiredAttrName = ((CMAttributeDeclaration) requiredAttrs.get(i)).getAttrName();
							boolean found = false;
							for (int j = 0; j < currentAttrs.getLength(); j++) {
								String currentAttrName = currentAttrs.item(j).getNodeName();
								if (requiredAttrName.compareToIgnoreCase(currentAttrName) == 0) {
									found = true;
									break;
								}
							}
							if (!found) {
								insertAttrs.add(requiredAttrs.get(i));
							}
						}
					}
					if (insertAttrs.size() > 0) {
						proposals.add(new InsertRequiredAttrsQuickAssistProposal(insertAttrs));
					}
				}
			}
		}
	}

	private void getLocalRenameQuickAssistProposal(List proposals, ISourceViewer viewer, int offset) {
		IDOMNode node = (IDOMNode) getNodeAt(viewer, offset);
		IStructuredDocumentRegion startStructuredDocumentRegion = node == null ? null : node.getStartStructuredDocumentRegion();
		IStructuredDocumentRegion endStructuredDocumentRegion = node == null ? null : node.getEndStructuredDocumentRegion();

		ITextRegion region = null;
		int regionTextEndOffset = 0;
		if ((startStructuredDocumentRegion != null) && startStructuredDocumentRegion.containsOffset(offset)) {
			region = startStructuredDocumentRegion.getRegionAtCharacterOffset(offset);
			regionTextEndOffset = startStructuredDocumentRegion.getTextEndOffset(region);
		}
		else if ((endStructuredDocumentRegion != null) && endStructuredDocumentRegion.containsOffset(offset)) {
			region = endStructuredDocumentRegion.getRegionAtCharacterOffset(offset);
			regionTextEndOffset = endStructuredDocumentRegion.getTextEndOffset(region);
		}

		if ((region != null) && ((region.getType() == DOMRegionContext.XML_TAG_NAME) || (region.getType() == DOMRegionContext.XML_TAG_ATTRIBUTE_NAME)) && (offset <= regionTextEndOffset)) {
			proposals.add(new RenameInFileQuickAssistProposal());
		}
	}

	private ModelQuery getModelQuery(Node node) {
		if (node.getNodeType() == Node.DOCUMENT_NODE) {
			return ModelQueryUtil.getModelQuery((Document) node);
		}
		else {
			return ModelQueryUtil.getModelQuery(node.getOwnerDocument());
		}
	}

	private List getRequiredAttrs(Node node) {
		List result = new ArrayList();

		ModelQuery modelQuery = getModelQuery(node);
		if (modelQuery != null) {
			CMElementDeclaration elementDecl = modelQuery.getCMElementDeclaration((Element) node);
			if (elementDecl != null) {
				CMNamedNodeMap attrMap = elementDecl.getAttributes();

				CMNamedNodeMapImpl allAttributes = new CMNamedNodeMapImpl(attrMap);
				List nodes = ModelQueryUtil.getModelQuery(node.getOwnerDocument()).getAvailableContent((Element) node, elementDecl, ModelQuery.INCLUDE_ATTRIBUTES);
				for (int k = 0; k < nodes.size(); k++) {
					CMNode cmnode = (CMNode) nodes.get(k);
					if (cmnode.getNodeType() == CMNode.ATTRIBUTE_DECLARATION) {
						allAttributes.put(cmnode);
					}
				}
				attrMap = allAttributes;
				
				Iterator it = attrMap.iterator();
				CMAttributeDeclaration attr = null;
				while (it.hasNext()) {
					attr = (CMAttributeDeclaration) it.next();
					if (attr.getUsage() == CMAttributeDeclaration.REQUIRED) {
						result.add(attr);
					}
				}
			}
		}

		return result;
	}

	private void getSurroundWithNewElementQuickAssistProposal(List proposals, ISourceViewer viewer, int offset) {
		IDOMNode node = (IDOMNode) getNodeAt(viewer, offset);
		if (node != null) {
			proposals.add(new SurroundWithNewElementQuickAssistProposal());
		}
	}

	/**
	 * Returns the closest IndexedRegion for the offset and viewer allowing
	 * for differences between viewer offsets and model positions. note: this
	 * method returns an IndexedRegion for read only
	 * 
	 * @param viewer
	 *            the viewer whose document is used to compute the proposals
	 * @param documentOffset
	 *            an offset within the document for which completions should
	 *            be computed
	 * @return an IndexedRegion
	 */
	private IndexedRegion getNodeAt(ITextViewer viewer, int documentOffset) {
		// copied from ContentAssistUtils.getNodeAt()
		if (viewer == null)
			return null;

		IndexedRegion node = null;
		IModelManager mm = StructuredModelManager.getModelManager();
		IStructuredModel model = null;
		if (mm != null)
			model = mm.getExistingModelForRead(viewer.getDocument());
		try {
			if (model != null) {
				int lastOffset = documentOffset;
				node = model.getIndexedRegion(documentOffset);
				while (node == null && lastOffset >= 0) {
					lastOffset--;
					node = model.getIndexedRegion(lastOffset);
				}
			}
		}
		finally {
			if (model != null)
				model.releaseFromRead();
		}
		return node;
	}
}