//------------------------------------------------------------------------------
// 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.xmi;

import java.io.File;
import java.util.Iterator;
import java.util.List;

import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.epf.library.ILibraryResourceManager;
import org.eclipse.epf.library.LibraryServiceUtil;
import org.eclipse.epf.library.util.LibraryUtil;
import org.eclipse.epf.persistence.MethodLibraryPersister;
import org.eclipse.epf.services.IFileBasedLibraryPersister;
import org.eclipse.epf.services.ILibraryPersister;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.util.UmaUtil;


/**
 * XMI library resource mamager
 * 
 * @author Jinhua Xi
 * @since 1.0
 *
 */
public class XMILibraryResourceManager implements ILibraryResourceManager {

	public XMILibraryResourceManager() {
	}

	
	/**
	 * get the logical path of the element in the library,
	 * the path should start with the plugin name. 
	 * i.e. <plugin name>/path/to/element
	 * 
	 * The implementation class should encapsulate the physical storage 
	 * of the resource and return the path of the element start with it's plugin name
	 * 
	 * @param element MethodElement
	 * @return String
	 */
	public String getLogicalPath(MethodElement element) {
		try {
			String path = MethodLibraryPersister.INSTANCE.getElementVirtualPath(element);
			if (path == null || path.equals("")) //$NON-NLS-1$
			{
				System.out
						.println("Warning! No Path for Element [" + element.getType().getName() + ": " + element.getName() + "]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
				return ""; //$NON-NLS-1$
			}
			return fixPath(path);
		} catch (RuntimeException e) {
			e.printStackTrace();
		}

		return ""; //$NON-NLS-1$
	}
	
	/**
	 * get the element's back path of the element based on the logical path, for example,
	 * "OpenUP\guidance\concept\c1.xml", the back path is "./../../../"
	 * 
	 * @param element MethodElement
	 * @return String
	 */
	public String getBackPath(MethodElement element) {
		// Linux: Browsing and preview shows only plain text.
		// There are no images/sections
		// element path should check File.separatorChar instead of "\"
		String backPath = ""; //$NON-NLS-1$
		String path = getLogicalPath(element);
		if (path != null && path.length() > 0) {
			backPath = path.replace(File.separatorChar, '/').replaceAll(
					".*?/", "\\.\\./"); //$NON-NLS-1$ //$NON-NLS-2$
		}
		return "./" + backPath; //$NON-NLS-1$
	}
	
	/**
	 * fix the path by appending a File.seperator to the end of it
	 * @param path String
	 * @return String
	 */
	private String fixPath(String path) {
		if (path == null || path.equals("")) //$NON-NLS-1$
		{
			return ""; //$NON-NLS-1$
		} else if (!path.endsWith(File.separator)) {
			return path + File.separator;
		} else {
			return path;
		}
	}

	/**
	 * get the logical resource path of the element in the
	 * library. the path should start with the plugin name. 
	 * i.e. <plugin name>/path/to/element/resources
	 * 
	 * @param element MethodElement
	 * @return String
	 */
	public String getLogicalResourcePath(MethodElement element) {
		String path = MethodLibraryPersister.INSTANCE.geResourceVirtualPath(element);
		return fixPath(path);
	}
	
	/**
	 * Gets the physical path of a method element
	 * 
	 * @param element
	 * @return the physical path of the element
	 */
	public String getPhysicalPath(MethodElement element) {
		if ( element == null ) {
			return null;
		}
		
		IFileBasedLibraryPersister persister = getFileBasedLibraryPersister(element);
		return persister != null ? fixPath(persister.getFolderAbsolutePath(element)) : null;
	}
	
	/**
	 * Gets the absolute path of the resource folder of the element in the library.
	 * 
	 * @param e
	 * @return the physical resource path of the element
	 */
	public String getPhysicalResourcePath(MethodElement element) {
		IFileBasedLibraryPersister persister = getFileBasedLibraryPersister(element);
		return persister != null ? fixPath(persister.getResourceFolderPath(element)) : null;
	}
	
	private IFileBasedLibraryPersister getFileBasedLibraryPersister(MethodElement element) {
		Resource resource = element.eResource();
		if(resource != null) {
			ILibraryPersister persister = LibraryServiceUtil.getPersisterFor(resource);
			if(persister instanceof IFileBasedLibraryPersister) {
				return ((IFileBasedLibraryPersister)persister);
			}
		}
		return null;
	}
	
	/**
	 * get the logical path of the plugin 
	 * 
	 * @param element
	 * @return String
	 */
	public String getLogicalPluginPath(MethodElement element) {
		MethodPlugin plugin = UmaUtil.getMethodPlugin(element);
		if (plugin != null) {
			return plugin.getName() + File.separator;
		} 
		
		return ""; //$NON-NLS-1$
	}
	
	/**
	 * get the physical path of the plugin associated with the element
	 * 
	 * @param element
	 * @return String
	 */
	public String getPhysicalPluginPath(MethodElement element) {
		MethodPlugin plugin = UmaUtil.getMethodPlugin(element);
		if (plugin != null) {
			return getPhysicalPath(plugin);
		} 
		
		return null;
	}

	
	/**
	 * get the physical path associated with the given logical path
	 * 
	 * @param element MethodElement an element in the library to access the library resource
	 * usually this is the owner element that references the logicalPath
	 * @param logicalPath String
	 * @return String the physical path resolved from the logical path
	 *
	 * for example, element task1, logical path is "plugin 1/tasks/task1.html"
	 * the returned physical path is <plugin location>/path/to/element
	 * 
	 * @param element 
	 * @param logicalPath the logical path of the element
	 * @return String
	 */
	public String resolve(MethodElement element, String logicalPath) {

		// use the plugin name in the logical path
		// find the MethodPlugin object
		// find the pluginPath
				
		// strip off the first folder in the relpath since this is the plugin name
		logicalPath = logicalPath.replace('/', File.separatorChar);
		int i = logicalPath.indexOf(File.separatorChar);
		if ( i > 0 ) {
			String pluginName = logicalPath.substring(0, i);
			String pluginPath = null; 

			MethodLibrary lib = UmaUtil.getMethodLibrary(element);
			List plugins = LibraryUtil.getMethodPlugins(lib);
			
			for (Iterator it = plugins.iterator(); it.hasNext(); ) {
				MethodPlugin plugin = (MethodPlugin)it.next();
				if ( plugin.getName().equals(pluginName) ) {
					pluginPath = getPhysicalPluginPath(plugin);
					break;
				}
			}
			
			if ( pluginPath != null ) {
				return pluginPath + logicalPath.substring(i+1);
			}
		}
		
		return null;
		
	}
	
}