/*******************************************************************************
 * Copyright (c) 2007 Oracle 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:
 *     Oracle Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.pagedesigner.internal.metadata;

import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;

import org.eclipse.emf.ecore.xml.type.SimpleAnyType;
import org.eclipse.emf.ecore.xml.type.XMLTypeFactory;
import org.eclipse.jst.jsf.common.metadata.Entity;
import org.eclipse.jst.jsf.common.metadata.MetadataFactory;
import org.eclipse.jst.jsf.common.metadata.Model;
import org.eclipse.jst.jsf.common.metadata.Trait;
import org.eclipse.jst.jsf.common.metadata.internal.IMetaDataModelMergeAssistant;
import org.eclipse.jst.jsf.common.metadata.internal.IMetaDataSourceModelProvider;
import org.eclipse.jst.jsf.common.metadata.internal.IMetaDataTranslator;
import org.eclipse.jst.jsf.common.metadata.traittypes.traittypes.ListOfValues;
import org.eclipse.jst.jsf.common.metadata.traittypes.traittypes.TraitTypesFactory;
import org.eclipse.jst.pagedesigner.editors.properties.IPropertyPageDescriptor;
import org.eclipse.jst.pagedesigner.meta.IAttributeDescriptor;
import org.eclipse.jst.pagedesigner.meta.IAttributeRuntimeValueType;
import org.eclipse.jst.pagedesigner.meta.IElementDescriptor;
import org.eclipse.jst.pagedesigner.meta.OLDIValueType;
import org.eclipse.jst.pagedesigner.meta.internal.SimpleCMRegistry;

/**
 * Translates Sybase MD into JSF common MD and attribute value type system.
 * 
 * Supplied to ease migration to JSF Common meta data by allowing current MD into JSF common md format.
 * 
 * @deprecated this will be disappearing along with all of the Sybase meta data 
 * and supporting classes before Ganymede release
 *
 */
public class SybaseCMConfigMetaDataTranslator implements IMetaDataTranslator {
	private static final String ATTR_VAL_RUNTIME_TYPE = "attribute-value-runtime-type";
	private IMetaDataModelMergeAssistant _assistant;

	public boolean canTranslate(IMetaDataSourceModelProvider modelProvider) {		
		if (modelProvider.getSourceModel() != null && 
				modelProvider.getSourceModel() instanceof SimpleCMRegistry)
			return true;
		return false;
	}
	
	public void translate(IMetaDataModelMergeAssistant assistant) {
		_assistant = assistant;
		SimpleCMRegistry reg = (SimpleCMRegistry)assistant.getSourceModelProvider().getSourceModel();
		traverseCMRegistryModel(reg);
	}

	private void traverseCMRegistryModel(SimpleCMRegistry reg){
		for (Iterator it=reg.getMap().entrySet().iterator(); it.hasNext();){
		    Map.Entry entry = (Map.Entry)it.next();			
			IElementDescriptor tagElem = (IElementDescriptor)entry.getValue();
			findOrCreateTag(tagElem);
		}
	}
	
	private void findOrCreateTag(IElementDescriptor tagElem) {
		Entity tag =_assistant.getMergedEntity(getMergedModel(), tagElem.getTagName());
		if (tag == null){
			tag = internalCreateTagEntity(tagElem);
			getMergedModel().getChildEntities().add(tag);
		}
		createTagTraits(tag, tagElem);
		createAttributeEntities(tag, tagElem);
	}

	private void createAttributeEntities(Entity tag, IElementDescriptor tagElem) {
		for (IAttributeDescriptor attrDesc : tagElem.getAttributeDescriptors()){
			Entity attr =_assistant.getMergedEntity(tag, attrDesc.getAttributeName());
			if (attr == null) {
				attr = internalCreateAttributeEntity(attrDesc);
				tag.getChildEntities().add(attr);
			}
			createAttributeTraits(attr, attrDesc);
		}
		if (tagElem.getReference() != null) {
			//create attributes from referenced tag
			createAttributeEntities(tag,tagElem.getReference());
		}
	}

	private void createAttributeTraits(Entity attr,
			IAttributeDescriptor attrDesc) {
		
		//convert ValueType to runtime-attrib-values
		convertValueType(attr, attrDesc);

		createTraitAndSimpleAnyTypeValue(attr, "display-label", attrDesc.getLabelString());
		createTraitAndSimpleAnyTypeValue(attr, "description", attrDesc.getDescription());
		createTraitAndSimpleAnyTypeValue(attr, "default-value", attrDesc.getDefaultValue());
		createTraitAndSimpleAnyTypeValue(attr, IPropertyPageDescriptor.PROP_DESC_CATEGORY, attrDesc.getCategory());
		createTraitAndSimpleAnyTypeValue(attr, "required", String.valueOf(attrDesc.isRequired()));
		
		
		
	}

	private void createTraitAndSimpleAnyTypeValue(Entity attr, String traitKey,
			String traitValue) {
		
		if (traitValue != null && traitValue.trim().length() > 0) {
			Trait trait = createTrait(attr, traitKey);
			setTraitValueUsingSimpleAnyType(trait, traitValue);	
			attr.getTraits().add(trait);
		}
	}

	private void convertValueType(Entity attr, IAttributeDescriptor attrDesc) {
		if (hasTrait(attr, ATTR_VAL_RUNTIME_TYPE)){
			return;
		}
		String rtType = null;
		String valType = attrDesc.getValueType();
		Trait trait = createTrait(attr, ATTR_VAL_RUNTIME_TYPE);
		if (OLDIValueType.ENUMERATED.equals(valType)){
			if ("lang".equalsIgnoreCase(attrDesc.getAttributeName()))
				rtType = IAttributeRuntimeValueType.LANGUAGECODE;
//			else if ()
			else {
				rtType = IAttributeRuntimeValueType.STRING;
				createPossibleValuesAndValidValueTraits(attr, attrDesc);
			}
		}
		else if (OLDIValueType.BOOLEAN.equals(valType)) {
			rtType = IAttributeRuntimeValueType.BOOLEAN;
		}
		else if (OLDIValueType.CLASSNAME.equals(valType)) {
			rtType = IAttributeRuntimeValueType.JAVACLASS;
			//"superType=I:javax.faces.event.ActionListener" 
			int colonIndex = attrDesc.getTypeParameter().lastIndexOf(":");
			String superTypeValue= attrDesc.getTypeParameter().substring(colonIndex+1);
			String superTypeType= attrDesc.getTypeParameter().substring(colonIndex-1,colonIndex);
			if (superTypeType.equalsIgnoreCase("I"))
				createTraitAndSimpleAnyTypeValue(attr, "valid-interfaces", superTypeValue);
			else
				createTraitAndSimpleAnyTypeValue(attr, "valid-superclass", superTypeValue);
		}
		else if (OLDIValueType.CLASSPATH_RESOURCE.equals(valType)) {
			rtType = IAttributeRuntimeValueType.RESOURCEBUNDLE;
		}
		else if (OLDIValueType.COLOR.equals(valType)) {
			rtType = IAttributeRuntimeValueType.COLOR;
		}
		else if (OLDIValueType.CSSCLASS.equals(valType)) {
			rtType = IAttributeRuntimeValueType.CSSCLASS;
		}
		else if (OLDIValueType.CSSID.equals(valType)) {
			rtType = IAttributeRuntimeValueType.CSSID;
		}
		else if (OLDIValueType.CSSSTYLE.equals(valType)) {
			rtType = IAttributeRuntimeValueType.CSSSTYLE;
		}
		else if (OLDIValueType.CURRENCYCODE.equals(valType)) {
			rtType = IAttributeRuntimeValueType.CURRENCYCODE;
		}
		else if (OLDIValueType.JAVASCRIPT.equals(valType)) {
			rtType = IAttributeRuntimeValueType.SCRIPT;
		}
		else if (OLDIValueType.LINK.equals(valType)) {
			rtType = IAttributeRuntimeValueType.LINK;
		}
		else if (OLDIValueType.LOCALE.equals(valType)) {
			rtType = IAttributeRuntimeValueType.LOCALE;
		}
		else if (OLDIValueType.METHODBINDING.equals(valType)) {
			rtType = IAttributeRuntimeValueType.METHODBINDING;
			if (attr.getId().equals("validator"))			
				createValidatorParams(attr);
			else if (attr.getId().equals("actionListener")){
				Trait t = createTrait(attr, "runtime-param-types");
				t.setValue(createAndSetSimpleAnyTypeValue("javax.faces.event.ActionEvent"));
				attr.getTraits().add(t);
			}
			else if (attr.getId().equals("valueChangeListener")){
				Trait t = createTrait(attr, "runtime-param-types");
				t.setValue(createAndSetSimpleAnyTypeValue("javax.faces.event.ValueChangeEvent"));
				attr.getTraits().add(t);
			}
			Trait t2 = createTrait(attr, "runtime-return-type");
			t2.setValue(createAndSetSimpleAnyTypeValue("void"));	
			attr.getTraits().add(t2);
		}
		else if (OLDIValueType.MULTICHOICE.equals(valType)) {
			rtType = IAttributeRuntimeValueType.STRING;
		}
		else if (OLDIValueType.NAMED_BOOLEAN.equals(valType)) {
			rtType = IAttributeRuntimeValueType.BOOLEAN;
		}
		else if (OLDIValueType.PROPERTYBINDING.equals(valType)) {
			rtType = IAttributeRuntimeValueType.VALUEBINDING;
		}
		else if (OLDIValueType.RELATIVEPATH.equals(valType)) {
			rtType = IAttributeRuntimeValueType.RELATIVEPATH;
		}
		else if (OLDIValueType.TIMEZONE.equals(valType)) {
			rtType = IAttributeRuntimeValueType.TIMEZONE;
		}
		else if (OLDIValueType.WEBPATH.equals(valType)) {
			rtType = IAttributeRuntimeValueType.WEBPATH;
//			createWebPathValidExtensionsTrait(attr, attrDesc);
		}
		else
			rtType = IAttributeRuntimeValueType.STRING;
		
		setTraitValueUsingSimpleAnyType(trait, rtType.toString());		
		setTypeParamsIfAny(attr, attrDesc);
		attr.getTraits().add(trait);
	}

	private void setTypeParamsIfAny(Entity attr, IAttributeDescriptor attrDesc) {
		//this method is relying on the fact that only one typeParam is being set.   this is all that was ever done by the Sybase config
		if (attrDesc.getTypeParameter()!= null){
			String typeParam = attrDesc.getTypeParameter(); 
			if (typeParam.indexOf(IAttributeDescriptor.PARAMETER_SUFFIX) > -1){
				int i = typeParam.indexOf(IAttributeDescriptor.PARAMETER_SUFFIX);
				String suffixes = typeParam.substring(i+IAttributeDescriptor.PARAMETER_SUFFIX.length()+1);
				Trait trait = createTrait(attr, "file-extensions");
				StringTokenizer st = new StringTokenizer(suffixes, ";");
				ListOfValues exts = TraitTypesFactory.eINSTANCE.createListOfValues();
				while (st.hasMoreElements()){
					String ext = st.nextToken();
					exts.getEntries().add(createAndSetSimpleAnyTypeValue(ext));
				}
				trait.setValue(exts);
				attr.getTraits().add(trait);
			}
			else if (typeParam.indexOf(IAttributeDescriptor.PARAMETER_DEFAULT) > -1){
				int i = typeParam.indexOf(IAttributeDescriptor.PARAMETER_DEFAULT);
				String defaultVal = typeParam.substring(i+IAttributeDescriptor.PARAMETER_DEFAULT.length()+1);
				createTraitAndSimpleAnyTypeValue(attr, "default-value", defaultVal);
			}
			else if (typeParam.indexOf(IAttributeDescriptor.PARAMETER_SEPARATOR) > -1){
				int i = typeParam.indexOf(IAttributeDescriptor.PARAMETER_SEPARATOR);
				String sep = typeParam.substring(i+IAttributeDescriptor.PARAMETER_SEPARATOR.length()+1);
				createTraitAndSimpleAnyTypeValue(attr, "multi-choice-seperator", sep);
			}
			else if (typeParam.indexOf(IAttributeDescriptor.PARAMETER_STYLE) > -1){
				int i = typeParam.indexOf(IAttributeDescriptor.PARAMETER_STYLE);
				String style = typeParam.substring(i+IAttributeDescriptor.PARAMETER_STYLE.length()+1);
				createTraitAndSimpleAnyTypeValue(attr, "style", style);
			}
			else if (typeParam.indexOf(IAttributeDescriptor.PARAMETER_SUPER_TYPE) > -1){
				//do nothing; handled by JavaClassType translation
			}
			else if (typeParam.length() > 0){
				//what to do?  CSSClass seems to require 'empty' type param
				System.out.println(typeParam);
			}
		}
	}

//	private void createWebPathValidExtensionsTrait(Entity attr, IAttributeDescriptor attrDesc) {
//		List<String> exts = new ArrayList<String>();
//		if (attrDesc.getTypeParameter().indexOf("=") > 0){
//			String extS = attrDesc.getTypeParameter().substring(attrDesc.getTypeParameter().indexOf("=")+1);//remove "suffix="
//			StringTokenizer st = new StringTokenizer(extS, ";");
//			while (st.hasMoreElements()){
//				exts.add((String)st.nextElement());
//			}
//			Trait trait = createTrait(attr, "file-extension-filters");
//			ListOfValues list =  TraitTypesFactory.eINSTANCE.createListOfValues();
//			for (String ext : exts){
//				list.getEntries().add(createAndSetSimpleAnyTypeValue(ext));
//			}
//			trait.setValue(list);
//			attr.getTraits().add(trait);
//		}
//	}

	private void createValidatorParams(Entity attr) {
		Trait t = createTrait(attr, "runtime-param-types");
		ListOfValues list =  TraitTypesFactory.eINSTANCE.createListOfValues();
		list.getEntries().add(createAndSetSimpleAnyTypeValue("javax.faces.context.FacesContext"));
		list.getEntries().add(createAndSetSimpleAnyTypeValue("javax.faces.component.UIComponent"));
		list.getEntries().add(createAndSetSimpleAnyTypeValue("java.lang.Object"));
	
		t.setValue(list);
		attr.getTraits().add(t);
	}
	
	private SimpleAnyType createAndSetSimpleAnyTypeValue(String rawVal){
		SimpleAnyType item = XMLTypeFactory.eINSTANCE.createSimpleAnyType();
		item.setRawValue(rawVal);
		return item;
	}

	private void createPossibleValuesAndValidValueTraits(Entity attr,
			IAttributeDescriptor attrDesc) {
		if (attrDesc.getOptions() != null){
			Trait validVals = MetadataFactory.eINSTANCE.createTrait();
			validVals.setId("valid-values");
			validVals.setSourceModelProvider(_assistant.getSourceModelProvider());
			
			Trait displayVals = MetadataFactory.eINSTANCE.createTrait();
			displayVals.setId("displayed-values");
			displayVals.setSourceModelProvider(_assistant.getSourceModelProvider());
			
			Map options = attrDesc.getOptions();
			ListOfValues validVs = TraitTypesFactory.eINSTANCE.createListOfValues();
			ListOfValues displayVs = TraitTypesFactory.eINSTANCE.createListOfValues();
			for (Iterator it=options.entrySet().iterator();it.hasNext();){
				Map.Entry entry = (Map.Entry)it.next();
				validVs.getEntries().add(createAndSetSimpleAnyTypeValue((String)entry.getKey()));
				displayVs.getEntries().add(createAndSetSimpleAnyTypeValue((String)entry.getValue()));
			}
			if (validVs.getEntries().size() > 0) {
				validVals.setValue(validVs);
				displayVals.setValue(displayVs);
				attr.getTraits().add(validVals);
				attr.getTraits().add(displayVals);
			}
		}		
	}

	private void setTraitValueUsingSimpleAnyType(Trait trait, String type) {
		SimpleAnyType value = XMLTypeFactory.eINSTANCE.createSimpleAnyType();
		value.setRawValue(type);
		trait.setValue(value);
	}
	
	private Trait createTrait(Entity entity, String id){
		Trait trait = MetadataFactory.eINSTANCE.createTrait();
		trait.setId(id);
		trait.setSourceModelProvider(_assistant.getSourceModelProvider());
		return trait;
	}
	
	private boolean hasTrait(Entity attr, String traitKey) {
		
		return false;
	}

	private void createTagTraits(Entity tag, IElementDescriptor tagElem) {
		if (tagElem.getHelpContextID() != null && !tagElem.getHelpContextID().equals("")){
			//create help-topic-id trait...
			//not bothering at the moment as we are not providing tooling at the moment
		}
	}

	private Entity internalCreateTagEntity(IElementDescriptor tagElem) {
		Entity tag = MetadataFactory.eINSTANCE.createEntity();
		tag.setId(tagElem.getTagName());
		return tag;
	}
	
	private Entity internalCreateAttributeEntity(IAttributeDescriptor attrDesc) {
		Entity attr = MetadataFactory.eINSTANCE.createEntity();
		attr.setId(attrDesc.getAttributeName());
		return attr;
	}

	private Model getMergedModel(){
		if ((Model)_assistant.getMergedModel().getRoot() != null)
			return (Model)_assistant.getMergedModel().getRoot();
		
		Model model = MetadataFactory.eINSTANCE.createModel();
		model.setId(_assistant.getMergedModel().getModelKey().getUri());
		model.setSourceModelProvider(_assistant.getSourceModelProvider());
		_assistant.getMergedModel().setRoot(model);
		return model;
		
	}
}