//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 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.export.services;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.epf.common.utils.FileUtil;
import org.eclipse.epf.library.ILibraryResourceManager;
import org.eclipse.epf.library.util.ResourceHelper;
import org.eclipse.epf.uma.CapabilityPattern;
import org.eclipse.epf.uma.DeliveryProcess;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.util.UmaUtil;


/**
 * Utility class to handle diagram export/import
 * @author Weiping Lu
 * @since 1.2
 *
 */
public class DiagramHandler {
	
	//To do: need to consider element rename issue. 
	//		 -> Resovle the involved file names after all resource names are settled.
	//		 -> Let a sub class to take of it?

	private File sourceLibRoot;
	private File targetLibRoot;
	private Map<String, MapEntryValue> elementMap = new HashMap<String, MapEntryValue>();
	private static boolean debug = false;
		
	/**
	 * Creates a new instance.
	 */	
	public DiagramHandler(File sourceLibRoot, File targetLibRoot) {
		this.sourceLibRoot = sourceLibRoot;
		this.targetLibRoot = targetLibRoot;
	}
	
	protected Map<String, MapEntryValue> getElementMap() {
		return elementMap;
	}
	
	private boolean needToProcess(MethodElement elem) {
		boolean b = elem instanceof CapabilityPattern ||
								elem instanceof DeliveryProcess;
		return b;	
	}
	
	public void registerElement(MethodElement elem) {
		registerElement(elem, false);
	}
	
	public void registerElement(MethodElement elem, boolean processEntry) {
		if (! needToProcess(elem)) {
			return;
		}
		if (elementMap.containsKey(elem.getGuid())) {
			return;
		}
		
		MapEntryValue mapEntryValue = new MapEntryValue();
		mapEntryValue.element = elem;
		elementMap.put(elem.getGuid(), mapEntryValue);		
		
		if (processEntry) {
			processEntry(elem, mapEntryValue);
		}
	}
	
	public void postRegisterElements() {
		for (Iterator<MapEntryValue> it = elementMap.values().iterator(); it.hasNext();) {
			MapEntryValue value = it.next();
			processEntry(value.element, value);
		}	
	}

	private void processEntry(MethodElement elem, MapEntryValue mapEntryValue) {
		File[] files = getFiles(elem);
		File sourceFile = files[0];
		File targetFile = files[1];

		if (sourceFile != null && sourceFile.exists()) {
			mapEntryValue.sourceFile = sourceFile;
		}

		if (targetFile.exists()) {
			if (mapEntryValue.sourceFile == null || needCopy(mapEntryValue.sourceFile, targetFile)) {
				mapEntryValue.targetFile = targetFile;
			}
			mapEntryValue.existing = true;
		} else {
			if (mapEntryValue.sourceFile != null) {
				mapEntryValue.targetFile = targetFile;
			}
		}
		
		if (debug) {
			System.out.println("LD> mapEntryValue: ");					//$NON-NLS-1$
			System.out.println(mapEntryValue.toDebugString("LD> "));	//$NON-NLS-1$
			System.out.println("");										//$NON-NLS-1$
		}
	}
	
	public List getModifiedFiles() {
		List ret = new ArrayList();		
		for (Iterator<MapEntryValue> it = elementMap.values().iterator(); it.hasNext();) {
			MapEntryValue value = it.next();
			if (value.existing && value.targetFile != null) {
				ret.add(value.targetFile.getAbsolutePath());
			}
		}		
		return ret;
	}

	/**
	 * copy all the files to the destination
	 *
	 */
	public void execute() {
		try {
			execute_();
		} catch (Throwable e) {
			if (debug) {
				e.printStackTrace();
			}
		}	
	}
	
	private void execute_() {
		
		for (Iterator<MapEntryValue> it = elementMap.values().iterator(); it.hasNext(); ) {
			MapEntryValue value = it.next();
			if (value.targetFile == null) {
				continue;
			} else if (value.sourceFile != null) {
				File parentFile = value.targetFile.getParentFile();
				FileUtil.copyFile(value.sourceFile, value.targetFile);
				if (debug) {
					System.out.println("LD: File copied: " + value.sourceFile);	//$NON-NLS-1$
				}
			} else {
				value.targetFile.delete();
			}
		}	
	}
		
	/**
	 * Checks to see if the copy action is needed.
	 */
	public static boolean needCopy(File source, File dest) {
		boolean ret = true;
		if (dest.exists()) {
			ret = (dest.lastModified() != source.lastModified())
					|| (dest.length() != source.length());
		}
		return ret;
	}
	
	protected static class MapEntryValue {

		public MethodElement element;
		public File sourceFile;
		public File targetFile;
		public boolean existing = false;		
		
		public String toDebugString(String prompt) {
			String str = prompt + "element: " + element.getName();		//$NON-NLS-1$
			str += "\n" + prompt + "sourceFile: " + sourceFile;		//$NON-NLS-1$ //$NON-NLS-2$
			str += "\n" + prompt + "targetFile: " + targetFile;		//$NON-NLS-1$ 	//$NON-NLS-2$
			str += "\n" + prompt + "existing: " + existing;			//$NON-NLS-1$ 	//$NON-NLS-2$			
			return str;
		}
		
	}

	protected File[] getFiles(MethodElement elem) {
		return getFiles(elem, true);
	}
	
	//[0]: sourceFile
	//[1]: targetFile
	protected File[] getFiles(MethodElement elem, boolean export) {
		File[] files = new File[2];
		
		String elementPath = ResourceHelper.getElementPath(elem);
		if (debug) {
			System.out.println("LD> elementPath: " + elementPath); //$NON-NLS-1$
		}
		if (elementPath == null || elementPath.length() == 0) {
			if (debug) {
				System.out.println("LD> elementPath is null or empty!"); //$NON-NLS-1$
			}
			return files;
		}

		String diagramPath = elementPath + elem.getName() + File.separator + 
								"diagram.xmi";				//$NON-NLS-1$
		
		if (debug) {
			System.out.println("LD> diagramPath 0: " + diagramPath); //$NON-NLS-1$
		}

		File srcRoot = sourceLibRoot;
		File tgtRoot = targetLibRoot;
		
		
		if (export) {
			srcRoot =  getRoot(elem);
		} else {
			tgtRoot =  getRoot(elem);
		}
		
		if (export) {
			Resource res = elem.eResource();
			if (res != null) {
				File modelFile = new File(res.getURI().toFileString());
				File folder = modelFile.getParentFile();
				String folderPath = folder.getAbsolutePath();

				int ix = srcRoot.getAbsolutePath().length();
				if (folderPath.length() > ix
						&& folderPath.substring(0, ix).equalsIgnoreCase(
								srcRoot.getAbsolutePath())) {
					diagramPath = folderPath.substring(ix + 1) + File.separator
							+ "diagram.xmi"; //$NON-NLS-1$
				}
			}
		} else {
			ProcessComponent pc = UmaUtil.getProcessComponent(elem);
			if (pc != null && ! pc.getName().equals(elem.getName())) {
				diagramPath = elementPath + pc.getName() + File.separator
						+ "diagram.xmi"; //$NON-NLS-1$
			}
		}
		
		files[0] = new File(srcRoot, diagramPath);
		files[1] = new File(tgtRoot, diagramPath);		

		return files;
	}
	
	public void visitElementMap(int passId) {
	}

	public File getSourceLibRoot() {
		return sourceLibRoot;
	}
	
	protected File getRoot(MethodElement elem) {
		ILibraryResourceManager libResMgr = ResourceHelper.getResourceMgr(elem);
		String pluginPath = libResMgr.getPhysicalPluginPath(elem);
		File root = (new File(pluginPath)).getParentFile();
		return root;
	}

	public File getTargetLibRoot() {
		return targetLibRoot;
	}
	
}