//------------------------------------------------------------------------------
// Copyright (c) 2005, 2006 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 implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.library.tester.impl.testcommands;

import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.emf.ecore.EAttribute;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.EStructuralFeature;
import org.eclipse.emf.ecore.sdo.EProperty;
import org.eclipse.epf.common.utils.XMLUtil;
import org.eclipse.epf.library.tester.TesterOutputUtil;
import org.eclipse.epf.library.tester.iface.TCExeReply;
import org.eclipse.epf.library.tester.impl.TestCommandImpl;
import org.eclipse.epf.library.tester.impl.TestCommandMgr;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPlugin;
import org.w3c.dom.Document;
import org.w3c.dom.Element;

/**
 * A test command class
 * 
 * @author Weiping Lu
 * @since 1.0
 * 
 */
public class TCOutputMethodElement extends TestCommandImpl {

	//May want to use feature classes directly instead of names later
	private static String[] excludedFeatures = {
		//"guid",
		//"gUIDs"
	};
	
	private static Set excludedFeatureSet = new HashSet();
	
	static {
		for (int i=0; i<excludedFeatures.length; i++) {
			excludedFeatureSet.add(excludedFeatures[i]);
		}
	}
	
	private static boolean localDebug = false;
	String path;
	private Document doc;
	private Map systemPkgMap = new HashMap();
	private Element root;
	private boolean recursive = true;
	private String tagName;
	
	public void parse(Element element) {
		super.parse(element);
		doc = getOwner().getOutputDocument();
		//String tagName = tagName(); need to fix tagName() mehtod
		tagName = element.getTagName();
		
		setAttribute(AT_Path, element.getAttribute(AT_Path));
		setAttribute(AT_Recursive, element.getAttribute(AT_Recursive));
		setAttribute(AT_OutputFileName, element.getAttribute(AT_OutputFileName));	
	}		
	
	public TCExeReply execute() {	
		path = getAttribute(AT_Path);
		recursive = parseBoolean(AT_Recursive, recursive);
		
		MethodLibrary lib = getOwner().getCurrentBaseLib();
		root = doc.getDocumentElement();
				
		if (tagName.equals(TestCommandMgr.TCOutputLibrary)) {
			outputMethodElement(lib, root);
		} else if (tagName.equals(TestCommandMgr.TCOutputPlugin)) {
			MethodPlugin plugin = TesterOutputUtil.getMethodPlugin(lib, path);
			outputMethodElement(plugin, root);
		} else if (tagName.equals(TestCommandMgr.TCOutputConfiguration)) {
			MethodConfiguration config = TesterOutputUtil.getMethodConfiguration(lib, path);
			outputMethodElement(config, root);
		} else if (tagName.equals(TestCommandMgr.TCOutputMethodElement)) {
			MethodElement me = TesterOutputUtil.getMethodElement(lib, path);
			outputMethodElement(me, root);
		} else {
			throw new UnsupportedOperationException();
		}

		outputToFile();		
		
		return null;
	}

	private void outputToFile() {
		String outputFileName = getAttribute(AT_OutputFileName);
		if (outputFileName == null || outputFileName.length() == 0) {
			return;
		}
		String outputPath = getOwner().getOutputPath();
		File file = new File(outputPath).getParentFile();
		outputPath = file.getAbsolutePath() + File.separator + outputFileName;
		
		Document outputDocument = getOwner().getOutputDocument();
		try {
			XMLUtil.saveDocument(outputDocument, outputPath);
		} catch (Exception e){
			e.printStackTrace();
		}
	}
	
	private void outputMethodElement(MethodElement element, Element parentNode) {	
		Element node = doc.createElement(getType(element));		
		parentNode.appendChild(node);
		if (parentNode == root) {
			node.setAttribute("path", path);
		}
		outputFeatures(element, node);
	}
	
	private void outputReference(EReference feature, MethodElement element, Element parentNode) {
		Element node = doc.createElement(feature.getName());
		parentNode.appendChild(node);
		node.setAttribute("path", TesterOutputUtil.getOutputPath(element));
	}
	
	private void outputFeatures(MethodElement element, Element node) {
		List properties = element.getInstanceProperties();		
		for (int i = 0; i < properties.size(); i++) {
			EProperty ep = (EProperty) properties.get(i);
			EStructuralFeature feature = ep.getEStructuralFeature();
			if (excludedFeatureSet.contains(feature.getName())) {
				continue;
			}
			Object value = element.eGet(feature);
			if (value == null) {
				continue;
			}
			if (feature instanceof EReference) {
				if (! recursive && node.getParentNode() != root) {
					continue;
				}
				EReference refFeature = (EReference) feature;
				if (value instanceof List) {
					outputListFeature(refFeature, (List) value, node);
				} else if (value instanceof MethodElement) {
					if (refFeature.isContainment()) {
						outputMethodElement((MethodElement) value, node);
					} else {
						outputReference(refFeature, (MethodElement) value, node);
					}
				} else if (localDebug){
					getOwner().trace("Warning> value is of non-output type: " + value.getClass().getName());
				}
			} else if (feature instanceof EAttribute) {
				node.setAttribute(feature.getName(), value.toString());
			} else {
				throw new UnsupportedOperationException();
			}
			
		}			
	}
	
	private void outputListFeature(EReference feature, List list, Element parentNode) {
		int sz = list == null ? 0 : list.size();
		if (sz == 0) {
			return;
		}
		if (! (list.get(0) instanceof MethodElement)) {
			getOwner().trace("Warning> list.get(0) is of type: " + list.get(0).getClass().getName());
			return;
		}
		boolean containment = feature.isContainment();
		for (int i=0; i<sz; i++) {
			MethodElement element = (MethodElement) list.get(i);
			if (element == null) {
				continue;
			}
			if (containment) {
				outputMethodElement(element, parentNode);
			} else {
				outputReference(feature, element, parentNode);
			}
		}
	}	
	
	private String getType(Object obj) {
		String clsName = obj.getClass().getName();
		int ix = clsName.lastIndexOf(".") + 1;
		String type = clsName.substring(ix);
		ix = type.lastIndexOf("Impl");
		if (obj instanceof MethodElement && ix + 4 ==  type.length()) {
			type = type.substring(0, ix);
		}
		return type;
	}	
	
	
	
}