/*******************************************************************************
 * Copyright (c) 2006 Sybase, Inc. 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:
 *     Sybase, Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.pagedesigner.properties.internal;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.jst.jsf.common.metadata.Entity;
import org.eclipse.jst.jsf.common.metadata.query.TaglibDomainMetaDataQueryHelper;
import org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogField;
import org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogFieldGroup;
import org.eclipse.jst.jsf.common.ui.internal.dialogfield.IDialogFieldApplyListener;
import org.eclipse.jst.jsf.common.ui.internal.dialogfield.IDialogFieldChangeListener;
import org.eclipse.jst.jsf.common.ui.internal.dialogfield.ISupportTextValue;
import org.eclipse.jst.jsf.context.resolver.structureddocument.IStructuredDocumentContextResolverFactory;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContext;
import org.eclipse.jst.jsf.context.structureddocument.IStructuredDocumentContextFactory;
import org.eclipse.jst.jsf.metadataprocessors.MetaDataEnabledProcessingFactory;
import org.eclipse.jst.pagedesigner.editors.HTMLEditor;
import org.eclipse.jst.pagedesigner.editors.properties.IPropertyPageDescriptor;
import org.eclipse.jst.pagedesigner.properties.attrgroup.IElementContextable;
import org.eclipse.swt.SWT;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMElement;
import org.eclipse.wst.xml.core.internal.provisional.document.IDOMNode;

/**
 * @author mengbo
 * @version 1.5
 * 
 * TODO: cleanup up constructors
 */
public class AttributeGroup extends DialogFieldGroup {
	private static final Object KEY_ATTR = "KEY_ATTR"; //$NON-NLS-1$

//	private String _helpContextId;

	private List<DialogField> _dialogFields = null;  //consider using Map
	private IDOMElement _ownerElement;
	private Entity _tagEntity;
	private List<String> _attrNames;
	private List<IPropertyPageDescriptor> _attrPDs;
	private IStructuredDocumentContext _sdContext;

	private String _uri;
	private String _tagName;
	
	/**
	 * Constructor
	 * @param tagEntity - may not be null
	 * @param attrNames - may not be null.  Attribute names must be valid for the tag, and have attribute-value-runtime-type trait info
	 */
	public AttributeGroup(Entity tagEntity, List<String> attrNames) {
		_tagEntity = tagEntity;
		_attrNames = attrNames;		
	}
	
	/**
	 * Constructor where tagEntity is determined later or set later
	 * @param uri - may be null
	 * @param tagName - may be null
	 * @param attributeNames - may not be null.  Attribute names must be valid for the tag, and have attribute-value-runtime-type trait info
	 */
	public AttributeGroup(String uri,
			String tagName, String[] attributeNames) {
		_uri = uri;
		_tagName = tagName;
		if (attributeNames != null)
			_attrNames = Arrays.asList(attributeNames);
		else 
			_attrNames = new ArrayList();
	}
	
	private List<IPropertyPageDescriptor> prepareDescriptors(Entity tagEntity,
			List<String> names) {
		
		List pds = new ArrayList();
		for (String attrName : names) {
			IPropertyPageDescriptor pd = getPD(tagEntity, attrName);
			if (pd != null)
				pds.add(pd);
		}
		return pds;
	}

	private IPropertyPageDescriptor getPD(Entity tagEntity, String attrName) {		
		IPropertyPageDescriptor pd = null;
		Entity attrEntity = TaglibDomainMetaDataQueryHelper.getEntity(tagEntity, attrName);
		if (attrEntity != null){
			List pds = MetaDataEnabledProcessingFactory.getInstance().getAttributeValueRuntimeTypeFeatureProcessors(
							IPropertyPageDescriptor.class, getStructuredDocumentContext(), attrEntity);					
			if (pds != null && !pds.isEmpty())
				pd = (IPropertyPageDescriptor)pds.get(0);
			else 
				pd = new DefaultPropertyPageDescriptor(tagEntity, attrEntity);
		}
		return pd;
	}


	private void resetStructuredDocumentContext() {
		_sdContext = null;
		getStructuredDocumentContext();		
	}

	private IStructuredDocumentContext getStructuredDocumentContext() {
		if (_sdContext == null) {
			if (_ownerElement != null) {
				_sdContext = IStructuredDocumentContextFactory.INSTANCE.getContext(_ownerElement.getStructuredDocument(), _ownerElement);				
				
			} else {
				IEditorPart edPart = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage().getActiveEditor();
				if (edPart != null && edPart instanceof HTMLEditor) {//edPart will always be the WPE, but checking just to be safe
					_sdContext = IStructuredDocumentContextFactory.INSTANCE.getContext(((HTMLEditor)edPart).getDocument(), 0);
				}
			} 
		}
		return _sdContext;
	}

	/**
	 * @return tag entity for this attribute group
	 */
	protected Entity getTagEntity() {
		if (_tagEntity == null) {
			if (_ownerElement != null){
				IStructuredDocumentContext context = IStructuredDocumentContextFactory.INSTANCE.getContext(_ownerElement.getStructuredDocument(), 0);
				if (context != null){
					String uri = _uri != null ? _uri : IStructuredDocumentContextResolverFactory.INSTANCE.getDOMContextResolver(context).getNode().getBaseURI();
					String tagName = _tagName != null ? _tagName :  IStructuredDocumentContextResolverFactory.INSTANCE.getDOMContextResolver(context).getNode().getNodeName();
					if (uri != null){
						IProject project = IStructuredDocumentContextResolverFactory.INSTANCE.getWorkspaceContextResolver(context).getProject();
						_tagEntity = TaglibDomainMetaDataQueryHelper.getEntity(TaglibDomainMetaDataQueryHelper.createMetaDataModelContext(project, uri), tagName);
					}
				}
			}
		}
		return _tagEntity;
	}
	/**
	 * @return tag name
	 */
	public String getTagName() {
		if (getTagEntity() == null)
			return _tagName;
		return getTagEntity().getId();
	}

	/**
	 * @return tag URI
	 */
	public String getURI() {
		if (getTagEntity() == null)
			return _uri;
		return getTagEntity().getModel().getCurrentModelContext().getUri();
	}


	/**
	 * Empty implementation. Subclasses should override to override default dialogField creation
	 * @param ppd
	 * @return DialogField
	 */
	protected DialogField createDialogField(IPropertyPageDescriptor ppd) {
		return null;
	}
	
//	protected DialogField createDialogField(String uri, String tag,
//			String attr) {
//		
//		return null;
//	}
	
	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogFieldGroup#initialize()
	 */
	public void initialize() {
		if (_dialogFields == null) {
			_dialogFields = new ArrayList();

			for (IPropertyPageDescriptor pd : getAttributePDs()) {
				DialogField field;			
				field = createDialogField(pd);
				
				if (field == null) {
					field = pd.getDialogFieldEditor();
				}

				field.putAttachedData(KEY_ATTR, pd);//descriptors[i]);

				IDialogFieldApplyListener applyListener = getDialogFieldApplyListener(pd);
//						getURI(), getTagName(), pd.getAttributeName());//descriptors[i]);
				if (applyListener == null) {
					applyListener = getDefaultApplyListener();
				}
				field.setDialogFieldApplyListener(applyListener);

				IDialogFieldChangeListener changeListener = getDialogFieldChangeListener(pd);
//						getURI(), getTagName(), pd.getAttributeName());//descriptors[i]);
				if (changeListener == null) {
					changeListener = getDefaultChangeListener();
				}
				field.setDialogFieldChangeListener(changeListener);
				_dialogFields.add(field);
			}
		}
	}

	private List<IPropertyPageDescriptor> getAttributePDs() {
		if (_attrPDs == null){
			_attrPDs = prepareDescriptors(getTagEntity(), _attrNames);
		}
		return _attrPDs;
	}

	/**
	 * Child class can override the method to provide listener implementation
	 * 
	 * @param ppd
	 * @return IDialogFieldApplyListener
	 */
	protected IDialogFieldApplyListener getDialogFieldApplyListener(IPropertyPageDescriptor ppd) {
		return null;
	}

	/**
	 * Child class can override the method to provide listener implementation
	 * 
	 * @param ppd
	 * @return IDialogFieldChangeListener
	 */
	protected IDialogFieldChangeListener getDialogFieldChangeListener(IPropertyPageDescriptor ppd){
			return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jst.jsf.common.ui.internal.dialogfield.DialogFieldGroup#refreshData()
	 */
	public void refreshData() {
		if (_ownerElement == null) {
			return;
		}
		initialize();
		for (int i = 0, size = _dialogFields.size(); i < size; i++) {
			DialogField field = _dialogFields.get(i);

			ISupportTextValue textValue = (ISupportTextValue) field;
			IPropertyPageDescriptor attr = (IPropertyPageDescriptor) field
					.getAttachedData(KEY_ATTR);
			String attrName = attr.getAttributeName();
			String attrValue = _ownerElement.getAttribute(attrName);
			textValue.setTextWithoutUpdate(attrValue);
		}
	}

	/**
	 * @return IDOMElement
	 */
	public IDOMElement getElement() {
		return _ownerElement;
	}

	/**
	 * Sets the context in each of the dialogFields in the Group
	 * @param context
	 * @param owner
	 */
	public void setElementContext(IDOMNode context, IDOMElement owner) {
		this._ownerElement = owner;
		resetStructuredDocumentContext();
		initialize();
		if (context != null) {
			for (int i = 0, size = _dialogFields.size(); i < size; i++) {
				DialogField field = _dialogFields.get(i);
				if (field instanceof IElementContextable) {
					((IElementContextable) field).setElementContext(context,
							owner);
				}
			}
		}
		refreshData();
	}

	public void layoutDialogFields(FormToolkit toolkit, Composite parent) {
		Composite top;
		if (toolkit == null) {//when being displayed by DialogFieldGroupPage  (wizard)
			top = new Composite(parent, SWT.NONE);
			FillLayout fillLayout = new FillLayout(SWT.VERTICAL);
			parent.setLayout(fillLayout);
		} else {
			top = toolkit.createComposite(parent, SWT.NONE);
		}
//		FillLayout fillLayout = new FillLayout(SWT.VERTICAL);
//		parent.setLayout(fillLayout);

//		if (this._helpContextId != null && this._helpContextId.length() > 0) {
//			PlatformUI.getWorkbench().getHelpSystem().setHelp(top,
//					_helpContextId);
//		}

		GridLayout layout = new GridLayout();
		int numColumns = getNumColumns();
		layout.numColumns = numColumns;
		top.setLayout(layout);
//		top.setLayoutData(new RowData());
		
		initialize();
		for (int i = 0, size = _dialogFields.size(); i < size; i++) {
			DialogField field = _dialogFields.get(i);
			field.doFillIntoGrid(toolkit, top, numColumns);
		}

		DialogField maxColumnField = null;
		int maxColumn = 0;
		for (int i = 0, size = _dialogFields.size(); i < size; i++) {
			DialogField field = _dialogFields.get(i);
			int c = field.getNumberOfControls();
			if (c > maxColumn) {
				maxColumn = c;
				maxColumnField = field;
			}
		}
		if (maxColumnField != null) {
			maxColumnField.handleGrabHorizontal();
		}
	}

	/**
	 * @return number of columns in for composite grid layout
	 */
	public int getNumColumns() {
		int columns = 1;
		initialize();
		for (int i = 0, size = _dialogFields.size(); i < size; i++) {
			DialogField field = _dialogFields.get(i);
			columns = Math.max(columns, field.getNumberOfControls());
		}
		return columns;
	}
	
	@Override
	public IStatus[] validateDialogFields() {
		return null;
	}

	/**
	 * @return DialogField[]
	 */
	public DialogField[] getDialogFields() {
		initialize();
		DialogField[] ret = new DialogField[_dialogFields.size()];
		_dialogFields.toArray(ret);
		return ret;
	}

	/**
	 * get the dialogfield for the corresponding attribute.
	 * 
	 * @param attrName
	 *            case sensitive attribute name.
	 * @return null if fail to find.
	 */
	public DialogField getDialogField(String attrName) {
		initialize();
		for (int i = 0, size = _dialogFields.size(); i < size; i++) {
			DialogField field = _dialogFields.get(i);
			IPropertyPageDescriptor attr = this.getPropertyDescriptor(field);
			if (attr != null && attr.getAttributeName().equals(attrName)) {
				return field;
			}
		}
		return null;
	}
	
	/**
	 * @param field
	 * @return IPropertyPageDescriptor
	 */
	public IPropertyPageDescriptor getPropertyDescriptor(DialogField field) {
		Object obj = field.getAttachedData(KEY_ATTR);
		if (obj instanceof IPropertyPageDescriptor) {
			return (IPropertyPageDescriptor) obj;
		}
	    return null;
	}
	
	@Override
	public void reset(){
		if (_dialogFields != null){
			for (DialogField field : _dialogFields){
				field.setDialogFieldApplyListener(null);
				field.setDialogFieldChangeListener(null);
			}
			_dialogFields = null;
		}
	}

	/**
	 * Set the tag entity
	 * @param tagEntity
	 */
	/*package*/ void setTagEntity(Entity tagEntity) {
		_tagEntity = tagEntity;		
	}

	public String toString(){
		StringBuffer buf = new StringBuffer("AttributeGroup: uri="); //$NON-NLS-1$
		buf.append("\r\r").append(getURI()).append("\r\rtag=").append(getTagName()); //$NON-NLS-1$ //$NON-NLS-2$
		buf.append("\r\rAttrs: "); //$NON-NLS-1$
		for (int i=0;i<_attrNames.size();i++) {
			String attr = _attrNames.get(i);
			buf.append(attr);
			if (i<_attrNames.size())
				buf.append(", "); //$NON-NLS-1$
		}
		return buf.toString();
	}
	

}