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

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

import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.InternalEObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.epf.library.LibraryService;
import org.eclipse.epf.library.edit.util.ModelStructure;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.persistence.ILibraryResourceSet;
import org.eclipse.epf.persistence.MultiFileSaveUtil;
import org.eclipse.epf.uma.ContentPackage;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.ProcessPackage;
import org.eclipse.epf.uma.UmaFactory;
import org.eclipse.epf.uma.util.UmaUtil;


/**
 * @author Phong Nguyen Le
 * @since 1.0
 */
public final class ModelStorage {
	
	/**
	 * return the MethodPlugins in the current MethodLibrary
	 * @return List
	 */
	public static List<MethodPlugin> getBaseModels() {
		MethodLibrary lib = LibraryService.getInstance().getCurrentMethodLibrary();
		if (lib != null)
			return new ArrayList<MethodPlugin>(lib.getMethodPlugins());
		return Collections.emptyList();
	}

	/**
	 * create a new MethodLibrary and return the associated Resource
	 * 
	 * @param resourceSet MultiFileResourceSetImpl
	 * @param name String
	 * @param dir String
	 * @param bMultiple boolean
	 * @return Resource
	 * @throws Exception
	 */
	public static Resource newLibrary(ILibraryResourceSet resourceSet,
			String name, String dir, boolean bMultiple) throws Exception {
		String lib_filename = null;
		// Map options = new
		// HashMap(MultiFileResourceSetImpl.DEFAULT_SAVE_OPTIONS);
		if (bMultiple) {
			lib_filename = MultiFileSaveUtil.DEFAULT_LIBRARY_MODEL_FILENAME;
			// options.put(MultiFileXMISaveImpl.MULTI_FILE, Boolean.TRUE);
		} else {
			lib_filename = name;
		}
		resourceSet.unload();
		Resource res = resourceSet.createResource(URI.createFileURI(dir
				+ File.separator + lib_filename));
		MethodLibrary lib = UmaFactory.eINSTANCE.createMethodLibrary();
		lib.setName(name);
		res.getContents().add(lib);
		resourceSet.save(null);
		return res;
	}
	
	/**
	 * initialize a new method plugin
	 * @param emptyModel MethodPlugin
	 * @return MethodPlugin
	 */
	public static MethodPlugin initialize(MethodPlugin emptyModel) {
		emptyModel.setUserChangeable(Boolean.TRUE);

		createContentPackages(emptyModel, ModelStructure.DEFAULT_DOMAIN_PATH);
		createContentPackages(emptyModel,
				ModelStructure.DEFAULT.disciplineDefinitionPath);
		createContentPackages(emptyModel, ModelStructure.DEFAULT.roleSetPath);
		createContentPackages(emptyModel,
				ModelStructure.DEFAULT.coreContentPath);
		createContentPackages(emptyModel,
				ModelStructure.DEFAULT.workProductTypePath);
		createContentPackages(emptyModel, ModelStructure.DEFAULT.toolPath);
		createContentPackages(emptyModel,
				ModelStructure.DEFAULT.standardCategoryPath);

		ContentPackage contentPkg = createContentPackages(emptyModel,
				ModelStructure.DEFAULT.customCategoryPath);
		TngUtil.createRootCustomCategory(contentPkg);

		// create DeliveryProcesses process package
		//
		ProcessPackage pkg = UmaFactory.eINSTANCE.createProcessPackage();
		pkg.setName(ModelStructure.DEFAULT.deliveryProcessPath[0]);
		emptyModel.getMethodPackages().add(pkg);

		// create ProcessContributions process package
		//
		ModelStructure.createProcessContributionPackage(emptyModel);

		// create CapabilityPatterns process package
		//
		pkg = UmaFactory.eINSTANCE.createProcessPackage();
		int len = ModelStructure.DEFAULT.capabilityPatternPath.length - 1;
		pkg.setName(ModelStructure.DEFAULT.capabilityPatternPath[len]);
		String[] path = new String[len];
		System.arraycopy(ModelStructure.DEFAULT.capabilityPatternPath, 0, path,
				0, len);
		ContentPackage contPkg = UmaUtil.findContentPackage(emptyModel, path);
		contPkg.getChildPackages().add(pkg);

		// // create inherited domains
		// //
		// List allBase = Misc.getAllBase(emptyModel);
		// // System.out.println("ModelStorage.initialize(): allBase="+allBase);
		// for(Iterator iter = allBase.iterator(); iter.hasNext();) {
		// MethodPlugin basePlugin = (MethodPlugin) iter.next();
		// ContentPackage baseDomainPkg = UmaUtil.findContentPackage(basePlugin,
		// ModelStructure.DEFAULT_DOMAIN_PATH);
		// InheritedCategoryPackageListener listener = new
		// InheritedDomainPackageListener(domainPkg);
		// baseDomainPkg.eAdapters().add(listener);
		// for (Iterator iterator =
		// baseDomainPkg.getContentElements().iterator(); iterator.hasNext();) {
		// Object element = (Object) iterator.next();
		// if(element instanceof Domain) {
		// ContentCategory category = (ContentCategory) element;
		// if(category.getVariabilityBasedOnElement() == null) {
		// // this category is not a inherited one, can be added.
		// //
		// domainPkg.getContentElements().add(listener.createInherited((ContentCategory)
		// element));
		// }
		// }
		// }
		// }

		// TODO: test on-fly creation of category contributor
		// MethodPluginItemProvider itemProvider = (MethodPluginItemProvider)
		// TngAdapterFactory.INSTANCE.getNavigatorView_ComposedAdapterFactory().adapt(emptyModel,
		// ITreeItemContentProvider.class);
		// itemProvider.addInheritedCategories();

		return emptyModel;
	}

	/**
	 * @param path
	 * @param emptyModel
	 */
	private static ContentPackage createContentPackages(MethodPlugin model,
			String[] path) {
		List list = model.getMethodPackages();
		ContentPackage pkg = UmaUtil.findContentPackage(list, path[0]);
		if (pkg == null) {
			pkg = UmaFactory.eINSTANCE.createContentPackage();
			pkg.setName(path[0]);
			list.add(pkg);
		}
		for (int i = 1; i < path.length; i++) {
			list = pkg.getChildPackages();
			pkg = UmaUtil.findContentPackage(list, path[i]);
			if (pkg == null) {
				pkg = UmaFactory.eINSTANCE.createContentPackage();
				pkg.setName(path[i]);
				list.add(pkg);
			}
		}
		return pkg;
	}

	/**
	 * load the containment proxies for the object
	 * @param obj EObject
	 */
	public static void loadContainmentProxies(EObject obj) {
		// for(TreeIterator iter = obj.eAllContents(); iter.hasNext();) {
		List list = obj.eContents();
		for (int i = 0; i < list.size(); i++) {
			InternalEObject o = (InternalEObject) list.get(i);
			// InternalEObject o = (InternalEObject)iter.next();
			if (o.eProxyURI() != null) {
				System.out.println("proxy URI = " + o.eProxyURI()); //$NON-NLS-1$
				ResourceSet resourceSet = o.eResource().getResourceSet();
				Resource res = resourceSet.getResource(o.eProxyURI(), true);
				InternalEObject resolvedObj = null;
				try {
					resolvedObj = (InternalEObject) res.getContents().get(0);
				} catch (Exception e) {
					e.printStackTrace();
				}
				System.out.println("resolvedObj = " + resolvedObj); //$NON-NLS-1$
				System.out.println("-----------------------------------"); //$NON-NLS-1$
				if (resolvedObj != null) {
					EcoreUtil.replace(o, resolvedObj);
					((BasicEList) res.getContents()).setData(1,
							new Object[] { resolvedObj });         
					o = resolvedObj;
				}
			}
			loadContainmentProxies(o);
		}
	}

	/**
	 * load all proxies for the object
	 * @param obj EObject
	 */
	public static void loadAllProxies(EObject obj) {
		for (Iterator iter = obj.eAllContents(); iter.hasNext();) {
			EObject element = (EObject) iter.next();
			for (Iterator iterator = element.eCrossReferences().iterator(); iterator
					.hasNext();) {
				iterator.next();
			}
		}

		// loadContainmentProxies(obj);
		// loadCrossReferenceProxies(obj);
	}

	/**
	 * load all cross reference proxies for the object
	 * @param obj EObject
	 */
	public static void loadCrossReferenceProxies(EObject obj) {
		List list = obj.eCrossReferences();
		int size = list.size();
		for (int i = 0; i < size; i++) {
			EObject o = (EObject) list.get(i);
			loadCrossReferenceProxies(o);
		}
	}

	/**
	 * find a MethodElement with the given element name in the element list
	 * @param methodElements The element list
	 * @param name String
	 * @return MethodElement
	 */
	public static MethodElement findMethodElement(List methodElements,
			String name) {
		int size = methodElements.size();
		for (int i = 0; i < size; i++) {
			MethodElement element = (MethodElement) methodElements.get(i);
			if (name.equals(element.getName()))
				return element;
		}
		return null;
	}

	/**
	 * get of index int he list location for the element with the given name.
	 * @param methodElements List
	 * @param name String
	 * @return int
	 */
	public static int indexOf(List methodElements, String name) {
		int size = methodElements.size();
		for (int i = 0; i < size; i++) {
			MethodElement element = (MethodElement) methodElements.get(i);
			if (name.equals(element.getName()))
				return i;
		}
		return -1;
	}

}