/*

 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

 * All rights reserved.

 * This component and the accompanying materials are made available

 * which accompanies this distribution, and is available

 * 

 * Initial Contributors:

 * Nokia Corporation - Initial contribution

 * 

 * Contributors:

 * 

 * Description: This file is part of com.nokia.tools.variant.confml.core component.

 */

package com.nokia.tools.variant.confml.internal.core.application;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.NullProgressMonitor;

import org.eclipse.core.runtime.OperationCanceledException;

import org.eclipse.core.runtime.SubProgressMonitor;

import org.eclipse.emf.common.util.EList;

import org.eclipse.emf.common.util.TreeIterator;

import org.eclipse.emf.common.util.URI;

import org.eclipse.emf.ecore.EObject;

import org.eclipse.emf.ecore.resource.Resource;

import org.eclipse.emf.ecore.resource.ResourceSet;

import org.eclipse.emf.ecore.resource.impl.ResourceImpl;

import org.eclipse.emf.ecore.util.EcoreUtil;

import com.nokia.tools.variant.common.core.utils.ArrayUtils;

import com.nokia.tools.variant.confml.core.model.application.EAppDataContainer;

import com.nokia.tools.variant.confml.core.model.application.EAppFeature;

import com.nokia.tools.variant.confml.core.model.application.EAppGroup;

import com.nokia.tools.variant.confml.core.model.application.EAppGroupContainer;

import com.nokia.tools.variant.confml.core.model.application.EAppIncludeElement;

import com.nokia.tools.variant.confml.core.model.application.EAppOptionContainer;

import com.nokia.tools.variant.confml.core.model.application.EAppResourceData;

import com.nokia.tools.variant.confml.core.model.application.EAppResourceType;

import com.nokia.tools.variant.confml.core.model.application.EAppRfsInfo;

import com.nokia.tools.variant.confml.core.model.application.EAppSequenceData;

import com.nokia.tools.variant.confml.core.model.application.EAppSequenceDataItem;

import com.nokia.tools.variant.confml.core.model.application.EAppSequenceType;

import com.nokia.tools.variant.confml.core.model.application.EAppSetting;

import com.nokia.tools.variant.confml.core.model.application.EAppSettingData;

import com.nokia.tools.variant.confml.core.model.application.EAppSettingOption;

import com.nokia.tools.variant.confml.core.model.application.EAppSettingRef;

import com.nokia.tools.variant.confml.core.model.application.EAppSettingType;

import com.nokia.tools.variant.confml.core.model.application.EAppSimpleData;

import com.nokia.tools.variant.confml.core.model.application.EAppSimpleType;

import com.nokia.tools.variant.confml.core.model.application.EAppTypeContainer;

import com.nokia.tools.variant.confml.core.model.application.EAppView;

import com.nokia.tools.variant.confml.core.model.application.EApplicationFactory;

import com.nokia.tools.variant.confml.core.model.application.EConfMLLayer;

import com.nokia.tools.variant.confml.core.model.application.EConfigurationProject;

import com.nokia.tools.variant.confml.core.model.application.EStorageClass;

import com.nokia.tools.variant.confml.internal.core.project.ContributorUtils;

import com.nokia.tools.vct.confml.model.confml1.EConfMLDocument;

import com.nokia.tools.vct.confml.model.confml1.EConfigurationElement;

import com.nokia.tools.vct.confml.model.confml1.EFeatureElement;

import com.nokia.tools.vct.confml.model.confml1.ESettingData;

import com.nokia.tools.vct.confml.model.confml1.ESettingElement;

import com.nokia.tools.vct.confml.model.confml1.ESettingRfs;

import com.nokia.tools.vct.confml.model.confml1.EViewElement;

import com.nokia.tools.vct.confml.model.confml1.include.EInclude;

import com.nokia.tools.vct.confml.model.confml2.EConfML2Document;

import com.nokia.tools.vct.confml.model.confml2.EFeatureData;

import com.nokia.tools.vct.confml.model.confml2.EFeatureRfs;

public class AppModelFactory {

	public AppModelFactory() {

	}

	public EConfigurationProject populateProject(ResourceSet resourceSet,

			URI projectRootURI, Collection<URI> resources) {

		try {

			return populateProject(new NullProgressMonitor(), resourceSet,

					projectRootURI, resources);

		} catch (InterruptedException e) {

			throw new OperationCanceledException();

		}

	}

	public EConfigurationProject populateProject(IProgressMonitor monitor,

			ResourceSet resourceSet, URI projectRootURI,

			Collection<URI> resources) throws InterruptedException {

		monitor.beginTask("Creating project", 100);

		if (monitor.isCanceled()) {

			throw new InterruptedException();

		}

		EConfigurationProject configurationProject = EApplicationFactory.eINSTANCE

				.createEConfigurationProject();

		configurationProject.setStorage(EStorageClass.PROJECT);

		configurationProject.setRootConfml(projectRootURI);

		Resource resource = null;

		// map for collecting of an information about view name 2 Resource in

		// which is that view located

		Map<String, Resource> viewName2ResourceMapForAllLayers = new HashMap<String, Resource>();

		try {

			monitor.subTask("Parsing root file");

			resource = resourceSet.getResource(projectRootURI, true);

			if (resource != null) {

				EObject root = resource.getContents().get(0);

				EList<EInclude> includes = null;

				if (root instanceof EConfMLDocument) {

					EConfMLDocument document = (EConfMLDocument) root;

					EConfigurationElement configuration = document

							.getConfiguration();

					configurationProject.setName(configuration.getName());

					configurationProject.setConfVersion(configuration

							.getVersion());

					ContributorUtils.adaptMetadata(configuration,

							configurationProject);

					includes = configuration.getIncludes();

				} else if (root instanceof EConfML2Document) {

					EConfML2Document document = (EConfML2Document) root;

					com.nokia.tools.vct.confml.model.confml2.EConfigurationElement configuration = document

							.getConfiguration();

					configurationProject.setName(configuration.getName());

					configurationProject.setConfVersion(configuration

							.getVersion());

					ContributorUtils.adaptMetadata(configuration,

							configurationProject);

					includes = configuration.getIncludes();

				}

				monitor.worked(5);

				if (monitor.isCanceled()) {

					throw new InterruptedException();

				}

				SubProgressMonitor monitor2 = new SubProgressMonitor(monitor,

						95);

				monitor2.beginTask("Generating layer", includes.size());

				EConfMLLayer lastLayer = null;

				for (EInclude include : includes) {

					monitor.subTask("Processing " + include.getHref());

					try {

						URI includeURI = URI.createURI(include.getHref());

						includeURI = includeURI.resolve(projectRootURI);

						URI layerURI = discoverLayerUri(includeURI, resources);

						EConfMLLayer layer = populateConfMLLayer(resourceSet,

								layerURI, includeURI, resources, lastLayer,

								viewName2ResourceMapForAllLayers);

						configurationProject.getLayers().add(layer);

						lastLayer = layer;

					} catch (Exception ex) {

						ex.printStackTrace();

					}

					monitor2.worked(1);

					if (monitor.isCanceled()) {

						throw new InterruptedException();

					}

				}

				monitor2.done();

			}

		} catch (Exception ex) {

			// ex.printStackTrace();

		}

		monitor.done();

		return configurationProject;

	}

	protected URI discoverLayerUri(URI includeURI, Collection<URI> resources) {

		OUTER: for (URI ptr : resources) {

			if (ptr.segmentCount() > includeURI.segmentCount()) {

				for (int i = 0; i < includeURI.segmentCount() - 1; i++) {

					if (!ptr.segment(i).equals(includeURI.segment(i))) {

						continue OUTER;

					}

				}

				if ("confml".equals(ptr.segment(includeURI.segmentCount() - 1))) {

					return includeURI.trimSegments(1).appendSegment("");

				}

			}

		}

		int count = includeURI.segmentCount();

		for (int i = count - 1; i > 0; i--) {

			if ("confml".equals(includeURI.segment(i))) {

				return includeURI.trimSegments(count - i).appendSegment("");

			}

		}

		return includeURI.trimSegments(1).appendSegment("");

	}

	public EConfMLLayer populateConfMLLayer(ResourceSet resourceSet,

			URI layerURI, URI rootConfmlURI, Collection<URI> resources,

			EConfMLLayer parent,

			Map<String, Resource> viewName2ResourceMapForAllLayers) {

		Resource layerResource = new ResourceImpl(layerURI);

		EConfMLLayer layer = EApplicationFactory.eINSTANCE.createEConfMLLayer();

		layer.setRootConfml(rootConfmlURI);

		layerResource.getContents().add(layer);

		resourceSet.getResources().add(layerResource);

		layer.setLayerURI(layerURI);

		layer.setParent(parent);

		for (URI uri : resources) {

			if (isBaseURI(layerURI, uri)) {

				layer.getLayerFiles().add(uri);

			}

		}

		if (parent != null) {

			for (Map.Entry<URI, URI> entry : parent.getDocumentMap()) {

				layer.getDocumentMap().put(entry.getKey(), entry.getValue());

			}

			for (Map.Entry<URI, URI> entry : parent.getResourceMap()) {

				layer.getResourceMap().put(entry.getKey(), entry.getValue());

			}

			for (Map.Entry<URI, URI> entry : parent.getImplMap()) {

				layer.getImplMap().put(entry.getKey(), entry.getValue());

			}

			Collection<Map.Entry<String, EAppView>> viewCopy = EcoreUtil

					.copyAll(parent.getViews());

			layer.getViews().addAll(viewCopy);

			Collection<Map.Entry<String, EAppFeature>> featureCopy = EcoreUtil

					.copyAll(parent.getFeatures());

			layer.getFeatures().addAll(featureCopy);

		}

		URI contentURI = ConfMLConstants.URI_CONTENT.resolve(layerURI);

		URI docURI = ConfMLConstants.URI_DOC.resolve(layerURI);

		URI implURI = ConfMLConstants.URI_IMPLML.resolve(layerURI);

		// URI confmlURI = URI_CONFML.resolve(layerURI);

		for (URI uri : resources) {

			if (isBaseURI(contentURI, uri)) {

				URI relative = relativize(contentURI, uri);

				layer.getResourceMap().put(relative, uri);

			} else if (isBaseURI(docURI, uri)) {

				URI relative = relativize(docURI, uri);

				layer.getDocumentMap().put(relative, uri);

			} else if (isBaseURI(implURI, uri)) {

				URI relative = relativize(implURI, uri);

				layer.getImplMap().put(relative, uri);

			} else {

				// other content - ignore

			}

		}

		Resource resource;

		try {

			resource = resourceSet.getResource(rootConfmlURI, true);

		} catch (Exception ex) {

			return layer;

		}

		TreeIterator<Object> it = EcoreUtil.getAllContents(resource, false);

		while (it.hasNext()) {

			Object o = it.next();

			if (o instanceof EConfigurationElement) {

				EConfigurationElement ce = (EConfigurationElement) o;

				layer.setName(ce.getName());

				ContributorUtils.adaptMetadata(ce, layer);

				break;

			}

			if (o instanceof com.nokia.tools.vct.confml.model.confml2.EConfigurationElement) {

				com.nokia.tools.vct.confml.model.confml2.EConfigurationElement ce = (com.nokia.tools.vct.confml.model.confml2.EConfigurationElement) o;

				layer.setName(ce.getName());

				ContributorUtils.adaptMetadata(ce, layer);

				break;

			}

		}

		Map<String, EObject> views = new LinkedHashMap<String, EObject>(); // String->

		// EViewElement

		Map<String, List<EObject>> types = new HashMap<String, List<EObject>>(); // String

		// -

		// >

		// EFeatureElement

		Map<String, Map<String, List<EObject>>> data = new HashMap<String, Map<String, List<EObject>>>(); // ESettingData

		Map<String, Map<String, EObject>> rfs = new HashMap<String, Map<String, EObject>>(); // ESettingRfs

		Set<URI> visitedLayers = new HashSet<URI>();

		List<EAppIncludeElement> includeChain = new ArrayList<EAppIncludeElement>();

		populateMaps(resourceSet, rootConfmlURI, visitedLayers, views, types,

				data, rfs, includeChain);

		layer.getIncludes().addAll(includeChain);

		populateResourceData(layer, views, types, data, rfs);

		return layer;

	}

	private void populateResourceData(EConfMLLayer layer,

			Map<String, EObject> views, Map<String, List<EObject>> types,

			Map<String, Map<String, List<EObject>>> data,

			Map<String, Map<String, EObject>> rfs) {

		EApplicationFactory appFactory = EApplicationFactory.eINSTANCE;

		for (Map.Entry<String, List<EObject>> entry : types.entrySet()) {

			String featureId = entry.getKey();

			EAppFeature feature = layer.getFeatures().get(featureId);

			if (feature == null) {

				// create and populate feature properties only if it is not

				// redefined.

				feature = appFactory.createEAppFeature();

				layer.getFeatures().put(featureId, feature);

				EObject ptr = entry.getValue().get(0);

				if (ptr instanceof EFeatureElement) {

					EFeatureElement first = (EFeatureElement) ptr;

					feature.setName(first.getName());

					ConfML1Helper.adaptDescription(first, feature);

					ConfML1Helper.adaptIcon(first, feature);

					feature.setRelevant(ConfML1Helper.buildAppExpression(first

							.getRelevant()));

				} else if (ptr instanceof com.nokia.tools.vct.confml.model.confml2.EFeatureElement) {

					com.nokia.tools.vct.confml.model.confml2.EFeatureElement first = (com.nokia.tools.vct.confml.model.confml2.EFeatureElement) ptr;

					feature.setName(first.getName());

					ConfML2Helper.adaptDescription(first, feature);

					ConfML2Helper.adaptIcon(first, feature);

					feature.setRelevant(ConfML2Helper.buildAppExpression(first

							.getRelevant()));

				}

			}

			// feature.setIconDescriptor(buildIconDescriptor(first));

			for (EObject featureTypeObject : entry.getValue()) {

				if (featureTypeObject instanceof EFeatureElement) {

					for (ESettingElement settingType : ((EFeatureElement) featureTypeObject)

							.getSettings()) {

						String settingId = settingType.getRef();

						EAppSetting setting = feature.getSettings().get(

								settingId);

						if (setting == null) {

							setting = appFactory.createEAppSetting();

							feature.getSettings().put(settingId, setting);

							try {

								ConfML1Helper.populateAppSetting(setting,

										settingType);

							} catch (Exception ex) {

								ex.printStackTrace();

							}

						}

					}

				} else if (featureTypeObject instanceof com.nokia.tools.vct.confml.model.confml2.EFeatureElement) {

					for (com.nokia.tools.vct.confml.model.confml2.ESettingElement settingType : ((com.nokia.tools.vct.confml.model.confml2.EFeatureElement) featureTypeObject)

							.getSettings()) {

						String settingId = settingType.getRef();

						EAppSetting setting = feature.getSettings().get(

								settingId);

						if (setting == null) {

							setting = appFactory.createEAppSetting();

							feature.getSettings().put(settingId, setting);

							try {

								ConfML2Helper.populateAppSetting(setting,

										settingType);

							} catch (Exception ex) {

								ex.printStackTrace();

							}

						}

					}

				}

			}

		}

		for (Map.Entry<String, Map<String, List<EObject>>> entry : data

				.entrySet()) {

			String featureId = entry.getKey();

			EAppFeature feature = layer.getFeatures().get(featureId);

			if (feature == null) {

				continue;

			}

			for (Map.Entry<String, List<EObject>> entry2 : entry.getValue()

					.entrySet()) {

				String settingId = entry2.getKey();

				EAppSetting appSetting = feature.getSettings().get(settingId);

				if (appSetting != null) {

					List<EObject> settingData = entry2.getValue();

					EAppSettingData appData = createSettingData(appSetting

							.getTypeInfo(), appSetting.getValueInfo(),

							settingData);

					appSetting.setValueInfo(appData);

				}

			}

		}

		for (Map.Entry<String, Map<String, EObject>> entry : rfs.entrySet()) {

			String featureId = entry.getKey();

			EAppFeature feature = layer.getFeatures().get(featureId);

			if (feature == null) {

				continue;

			}

			for (Map.Entry<String, EObject> entry2 : entry.getValue()

					.entrySet()) {

				String settingId = entry2.getKey();

				EAppSetting appSetting = feature.getSettings().get(settingId);

				if (appSetting != null) {

					populateSettingRfs(appSetting, appSetting.getRef(), entry

							.getValue());

				}

			}

		}

		Map<String, EObject> noRFS = Collections.emptyMap();

		List<EObject> noData = Collections.emptyList();

		for (Map.Entry<String, EAppFeature> entry : layer.getFeatures()) {

			for (Map.Entry<String, EAppSetting> entry2 : entry.getValue()

					.getSettings()) {

				EAppSetting appSetting = entry2.getValue();

				if (appSetting.getRfsInfo() == null) {

					populateSettingRfs(appSetting, appSetting.getRef(), noRFS);

				}

				if (appSetting.getValueInfo() == null) {

					EAppSettingData appData = createSettingData(appSetting

							.getTypeInfo(), null, noData);

					appSetting.setValueInfo(appData);

				}

			}

		}

		Set<String> updatedViews = views.keySet();

		for (Map.Entry<String, EAppView> appViewEntry : layer.getViews()) {

			if (!updatedViews.contains(appViewEntry.getKey())) {

				fixUpViewTargets(layer, appViewEntry.getValue());

			}

		}

		for (Map.Entry<String, EObject> viewEntry : views.entrySet()) {

			String viewName = viewEntry.getKey();

			EObject viewObject = viewEntry.getValue();

			layer.getViews().removeKey(viewName);

			EAppView appView = appFactory.createEAppView();

			appView.setName(viewName);

			layer.getViews().put(viewName, appView);

			URI uri = EcoreUtil.getURI(viewObject);

			appView.getUri().add(uri);

			if (viewObject instanceof EViewElement) {

				ConfML1Helper

						.populateAppGroups(appFactory, layer.getFeatures(),

								appView, (EViewElement) viewObject);

			} else if (viewObject instanceof com.nokia.tools.vct.confml.model.confml2.EViewElement) {

				ConfML2Helper

						.populateAppGroups(

								appFactory,

								layer.getFeatures(),

								appView,

								(com.nokia.tools.vct.confml.model.confml2.EViewElement) viewObject);

			}

		}

	}

	private void fixUpViewTargets(EConfMLLayer layer,

			EAppGroupContainer container) {

		for (EAppGroup group : container.getGroups()) {

			fixUpViewTargets(layer, group);

		}

		if (container instanceof EAppGroup) {

			for (EAppSettingRef ref : ((EAppGroup) container).getSettings()) {

				EAppSetting old = ref.getResolved();

				if (old != null) {

					String settingRef = old.getRef();

					String featureRef = ((EAppFeature) old.eContainer()

							.eContainer()).getRef();

					EAppFeature newFeature = layer.getFeatures()

							.get(featureRef);

					EAppSetting newSetting = newFeature.getSettings().get(

							settingRef);

					ref.setResolved(newSetting);

				}

			}

		}

	}

	private EAppSettingData createSettingData(EAppSettingType settingType,

			EAppSettingData oldData, List<EObject> settingData) {

		if (settingData == null) {

			settingData = Collections.emptyList();

		}

		if (settingType instanceof EAppSimpleType) {

			EAppSimpleData data = EApplicationFactory.eINSTANCE

					.createEAppSimpleData();

			data.setTypeInfo(settingType);

			if (settingData.size() > 0) {

				EObject obj = ArrayUtils.getLast(settingData);

				if (obj instanceof ESettingData) {

					ESettingData first = (ESettingData) obj;

					if (first.getSettings().isEmpty()) {

						String text = first.getText();

						if (isConfML1Ref(settingType, text)) {

							data.setMap(text);

							data.setValue(null);

						} else {

							data.setMap(null);

							data.setValue(text);

						}

					}

				} else if (obj instanceof com.nokia.tools.vct.confml.model.confml2.ESettingData) {

					com.nokia.tools.vct.confml.model.confml2.ESettingData first = (com.nokia.tools.vct.confml.model.confml2.ESettingData) obj;

					if (first.getSettings().isEmpty()) {

						if (first.getMap() != null) {

							data.setMap(first.getMap());

							data.setValue(null);

							data.setValue(first.getText());

						} else {

							data.setMap(null);

							data.setValue(first.getText());

						}