/*

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

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

package com.nokia.carbide.cpp.internal.project.ui.views;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Set;

import org.eclipse.cdt.core.model.CModelException;

import org.eclipse.cdt.core.model.CoreModel;

import org.eclipse.cdt.core.model.CoreModelUtil;

import org.eclipse.cdt.core.model.ElementChangedEvent;

import org.eclipse.cdt.core.model.ICElement;

import org.eclipse.cdt.core.model.ICElementDelta;

import org.eclipse.cdt.core.model.ICProject;

import org.eclipse.cdt.core.model.IElementChangedListener;

import org.eclipse.cdt.core.model.ITranslationUnit;

import org.eclipse.cdt.internal.core.model.ExternalTranslationUnit;

import org.eclipse.cdt.ui.CElementGrouping;

import org.eclipse.cdt.ui.CElementSorter;

import org.eclipse.core.filesystem.URIUtil;

import org.eclipse.core.resources.IFile;

import org.eclipse.core.resources.IFolder;

import org.eclipse.core.resources.IProject;

import org.eclipse.core.resources.IResource;

import org.eclipse.core.resources.IWorkspaceRoot;

import org.eclipse.core.resources.ResourcesPlugin;

import org.eclipse.core.runtime.CoreException;

import org.eclipse.core.runtime.IAdaptable;

import org.eclipse.core.runtime.IAdapterFactory;

import org.eclipse.core.runtime.IAdapterManager;

import org.eclipse.core.runtime.IPath;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.IStatus;

import org.eclipse.core.runtime.Path;

import org.eclipse.core.runtime.Platform;

import org.eclipse.core.runtime.Status;

import org.eclipse.core.runtime.jobs.Job;

import org.eclipse.jface.resource.ImageDescriptor;

import org.eclipse.jface.viewers.IStructuredSelection;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.jface.viewers.Viewer;

import org.eclipse.jface.viewers.ViewerSorter;

import org.eclipse.swt.widgets.Display;

import org.eclipse.swt.widgets.TreeItem;

import org.eclipse.ui.IMemento;

import org.eclipse.ui.ISharedImages;

import org.eclipse.ui.IViewSite;

import org.eclipse.ui.PlatformUI;

import org.eclipse.ui.model.BaseWorkbenchContentProvider;

import org.eclipse.ui.model.IWorkbenchAdapter;

import com.nokia.carbide.cdt.builder.BldInfViewPathHelper;

import com.nokia.carbide.cdt.builder.CarbideBuilderPlugin;

import com.nokia.carbide.cdt.builder.DefaultImageMakefileViewConfiguration;

import com.nokia.carbide.cdt.builder.DefaultMMPViewConfiguration;

import com.nokia.carbide.cdt.builder.DefaultViewConfiguration;

import com.nokia.carbide.cdt.builder.EMMPPathContext;

import com.nokia.carbide.cdt.builder.EpocEnginePathHelper;

import com.nokia.carbide.cdt.builder.ImageMakefileViewPathHelper;

import com.nokia.carbide.cdt.builder.MMPViewPathHelper;

import com.nokia.carbide.cdt.builder.project.ICarbideBuildConfiguration;

import com.nokia.carbide.cdt.builder.project.ICarbideConfigurationChangedListener;

import com.nokia.carbide.cdt.builder.project.ICarbideProjectInfo;

import com.nokia.carbide.cdt.builder.project.ICarbideProjectPropertyChangedListener;

import com.nokia.carbide.cdt.builder.project.ISISBuilderInfo;

import com.nokia.carbide.cpp.epoc.engine.BldInfDataRunnableAdapter;

import com.nokia.carbide.cpp.epoc.engine.EpocEnginePlugin;

import com.nokia.carbide.cpp.epoc.engine.ImageMakefileDataRunnableAdapter;

import com.nokia.carbide.cpp.epoc.engine.MMPDataRunnableAdapter;

import com.nokia.carbide.cpp.epoc.engine.image.IBitmapSource;

import com.nokia.carbide.cpp.epoc.engine.image.IBitmapSourceReference;

import com.nokia.carbide.cpp.epoc.engine.image.IImageSource;

import com.nokia.carbide.cpp.epoc.engine.image.IMultiImageSource;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IBldInfData;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IExtension;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IMMPReference;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IMakMakeReference;

import com.nokia.carbide.cpp.epoc.engine.model.bldinf.IMakefileReference;

import com.nokia.carbide.cpp.epoc.engine.model.makefile.image.IImageMakefileData;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPAIFInfo;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPData;

import com.nokia.carbide.cpp.epoc.engine.model.mmp.IMMPResource;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.AcceptedNodesViewFilter;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.DefaultModelDocumentProvider;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.DefaultTranslationUnitProvider;

import com.nokia.carbide.cpp.epoc.engine.preprocessor.IIncludeFileLocator;

import com.nokia.carbide.cpp.internal.project.ui.ProjectUIPlugin;

import com.nokia.carbide.cpp.sdk.core.ISymbianBuildContext;

import com.nokia.carbide.cpp.sdk.core.ISymbianSDK;

import com.nokia.carbide.cpp.ui.CarbideUIPlugin;

import com.nokia.carbide.cpp.ui.ICarbideSharedImages;

import com.nokia.carbide.internal.api.cpp.epoc.engine.preprocessor.DependencyScanner;

/**

 * Content provider for the SymbianProjectNavigatorView

 * 

 */

public class SPNViewContentProvider extends BaseWorkbenchContentProvider 

									implements ICarbideConfigurationChangedListener, ICarbideProjectPropertyChangedListener, IAdapterFactory, IElementChangedListener {

	private TreeViewer viewer;

	private boolean filteringEnabled = true;

	private boolean displaySourcePaths = true;

	// these are used to save/restore view state

	private static final String TAG_SELECTION = "selection"; //$NON-NLS-1$

	private static final String TAG_EXPANDED = "expanded"; //$NON-NLS-1$

	private static final String TAG_IPROJECT = "iproject"; //$NON-NLS-1$

	private static final String TAG_IFILE = "ifile"; //$NON-NLS-1$

	private static final String TAG_ITRANSLATIONUNIT = "itranslationunit"; //$NON-NLS-1$

	private static final String TAG_CONTAINER = "spn_container"; //$NON-NLS-1$

	private static final String TAG_PATH = "path"; //$NON-NLS-1$

	private static final String TAG_CONTAINER_SEPARATOR = "#"; //$NON-NLS-1$

	private static final String TAG_FILTERING_ENABLED = "filtering"; //$NON-NLS-1$

	private static final String TAG_DISPLAYSOURCEPATHS_ENABLED = "display_sourcepaths"; //$NON-NLS-1$

	private static final String TAG_SORTING_ENABLED = "sorting"; //$NON-NLS-1$

	private SPNContainerFactory containerFactory = new SPNContainerFactory();

	private class SPNViewSorter extends CElementSorter {

		public SPNViewSorter() {

			super();

		}

		@Override

		public int compare(Viewer viewer, Object e1, Object e2) {

			// use the CDT sorter for CDT objects

			if (e1 instanceof ICElement || e1 instanceof CElementGrouping ||

					e2 instanceof ICElement || e2 instanceof CElementGrouping) {

				return super.compare(viewer, e1, e2);

			}

			// sort mmp objects if necessary

			if (sortMMPsAplhabetically) {

				if (e1 instanceof SPNMMPContainer && e2 instanceof SPNMMPContainer) {

					return (((SPNMMPContainer)e1).getLabel(null).compareToIgnoreCase(((SPNMMPContainer)e2).getLabel(null)));

				}

			}

			// leave them in current order

			return 0;

		}

	}

	private SPNViewSorter viewSorter = new SPNViewSorter();

	private boolean sortMMPsAplhabetically = false;

	public SPNViewContentProvider () {

		super();

		this.viewer = null;

	}

	SPNViewContentProvider(TreeViewer viewer) {

		super();

		this.viewer = viewer;

		CarbideBuilderPlugin.addBuildConfigChangedListener(this);

		CarbideBuilderPlugin.addProjectPropertyChangedListener(this);

        CoreModel.getDefault().addElementChangedListener(this);

		IAdapterManager manager = Platform.getAdapterManager();

		manager.registerAdapters(this, IResource.class);

	}

	@Override

	public void dispose() {

		super.dispose();

		CarbideBuilderPlugin.removeBuildConfigChangedListener(this);

		CarbideBuilderPlugin.removeProjectPropertyChangedListener(this);

        CoreModel.getDefault().removeElementChangedListener(this);

		IAdapterManager manager = Platform.getAdapterManager();

		manager.unregisterAdapters(this);

	}

	public ViewerSorter getViewSorter() {

		return viewSorter;

	}

	/**

	 * Factory used to create and keep track of container instances.  In order to restore selection and

	 * expansion of container elements in the tree we have use the same instance of a container (Object.equals

	 * is not enough!).  

	 */

	private class SPNContainerFactory {

		// maps to keep track of existing containers so we don't create more than one instance

		private HashMap<IFile, SPNBldInfContainer> bldInfContainerMap = new LinkedHashMap<IFile, SPNBldInfContainer>();

		private HashMap<IFile, SPNBldInfIncludesContainer> bldinfIncludesContainerMap = new LinkedHashMap<IFile, SPNBldInfIncludesContainer>();

		private HashMap<IFile, SPNMMPContainer> mmpContainerMap = new LinkedHashMap<IFile, SPNMMPContainer>();

		private HashMap<IFile, SPNImageMakefileContainer> imageMakefileContainerMap = new LinkedHashMap<IFile, SPNImageMakefileContainer>();

		private HashMap<IFile, SPNUIDesignsContainer> uiDesignsContainerMap = new LinkedHashMap<IFile, SPNUIDesignsContainer>();

		private HashMap<IFile, SPNSourcesContainer> sourcesContainerMap = new LinkedHashMap<IFile, SPNSourcesContainer>();

		private HashMap<IFile, SPNSourcePathsContainer> sourcePathsContainerMap = new LinkedHashMap<IFile, SPNSourcePathsContainer>();

		private HashMap<IFile, SPNResourcesContainer> resourcesContainerMap = new LinkedHashMap<IFile, SPNResourcesContainer>();

		private HashMap<IFile, SPNIncludesContainer> includesContainerMap = new LinkedHashMap<IFile, SPNIncludesContainer>();

		private HashMap<IFile, SPNImagesContainer> imagesContainerMap = new LinkedHashMap<IFile, SPNImagesContainer>();

		private HashMap<IFile, SPNDocumentsContainer> documentsContainerMap = new LinkedHashMap<IFile, SPNDocumentsContainer>();

		private HashMap<IFile, SPNDefContainer> defContainerMap = new LinkedHashMap<IFile, SPNDefContainer>();

		private HashMap<IFile, SPNAIFContainer> aifContainerMap = new LinkedHashMap<IFile, SPNAIFContainer>();

		private HashMap<IPath, SPNMIFContainer> makefileImageContainerMap = new LinkedHashMap<IPath, SPNMIFContainer>();

		SPNBldInfContainer getBldInfContainer(IFile bldInfFile, boolean create) {

			if (create && !bldInfContainerMap.containsKey(bldInfFile)) {

				bldInfContainerMap.put(bldInfFile, new SPNBldInfContainer(bldInfFile));

			}

			return bldInfContainerMap.get(bldInfFile);

		}

		SPNBldInfIncludesContainer getInfIncludesContainer(IFile infFile) {

			if (!bldinfIncludesContainerMap.containsKey(infFile)) {

				bldinfIncludesContainerMap.put(infFile, new SPNBldInfIncludesContainer(infFile));

			}

			return bldinfIncludesContainerMap.get(infFile);

		}

		SPNMMPContainer getMMPContainer(IFile mmpFile, boolean create) {

			if (create && !mmpContainerMap.containsKey(mmpFile)) {

				mmpContainerMap.put(mmpFile, new SPNMMPContainer(mmpFile));

			}

			return mmpContainerMap.get(mmpFile);

		}

		SPNImageMakefileContainer getImageMakefileContainer(IFile makeFile, boolean create) {

			if (create && !imageMakefileContainerMap.containsKey(makeFile)) {

				imageMakefileContainerMap.put(makeFile, new SPNImageMakefileContainer(makeFile));

			}

			return imageMakefileContainerMap.get(makeFile);

		}

		SPNUIDesignsContainer getUIDesignsContainer(IFile bldInfFile) {

			if (!uiDesignsContainerMap.containsKey(bldInfFile)) {

				uiDesignsContainerMap.put(bldInfFile, new SPNUIDesignsContainer(bldInfFile));

			}

			return uiDesignsContainerMap.get(bldInfFile);

		}

		SPNSourcesContainer getSourcesContainer(IFile mmpFile) {

			if (!sourcesContainerMap.containsKey(mmpFile)) {

				sourcesContainerMap.put(mmpFile, new SPNSourcesContainer(mmpFile));

			}

			return sourcesContainerMap.get(mmpFile);

		}

		SPNSourcePathsContainer getSourcePathsContainer(IFile mmpFile) {

			if (!sourcePathsContainerMap.containsKey(mmpFile)) {

				sourcePathsContainerMap.put(mmpFile, new SPNSourcePathsContainer(mmpFile));

			}

			return sourcePathsContainerMap.get(mmpFile);

		}

		SPNResourcesContainer getResourcesContainer(IFile mmpFile) {

			if (!resourcesContainerMap.containsKey(mmpFile)) {

				resourcesContainerMap.put(mmpFile, new SPNResourcesContainer(mmpFile));

			}

			return resourcesContainerMap.get(mmpFile);

		}

		SPNIncludesContainer getIncludesContainer(IFile mmpFile) {

			if (!includesContainerMap.containsKey(mmpFile)) {

				includesContainerMap.put(mmpFile, new SPNIncludesContainer(mmpFile));

			}

			return includesContainerMap.get(mmpFile);

		}

		SPNImagesContainer getImagesContainer(IFile mmpFile) {

			if (!imagesContainerMap.containsKey(mmpFile)) {

				imagesContainerMap.put(mmpFile, new SPNImagesContainer(mmpFile));

			}

			return imagesContainerMap.get(mmpFile);

		}

		SPNDocumentsContainer getDocumentsContainer(IFile mmpFile) {

			if (!documentsContainerMap.containsKey(mmpFile)) {

				documentsContainerMap.put(mmpFile, new SPNDocumentsContainer(mmpFile));

			}

			return documentsContainerMap.get(mmpFile);

		}

		SPNDefContainer getDefContainer(IFile mmpFile) {

			if (!defContainerMap.containsKey(mmpFile)) {

				defContainerMap.put(mmpFile, new SPNDefContainer(mmpFile));

			}

			return defContainerMap.get(mmpFile);

		}

		SPNAIFContainer getAIFContainer(IFile mmpFile) {

			if (!aifContainerMap.containsKey(mmpFile)) {

				aifContainerMap.put(mmpFile, new SPNAIFContainer(mmpFile));

			}

			return aifContainerMap.get(mmpFile);

		}

		SPNMBMContainer getMBMContainer(IFile mmpFile, IPath mbmPath) {

			SPNImagesContainer container = getImagesContainer(mmpFile);

			if (container != null) {

				return container.getMBMContainer(mbmPath);

			}

			return null;

		}

		SPNMIFContainer getMIFContainer(IFile makeFile, IPath mifPath) {

			if (!makefileImageContainerMap.containsKey(mifPath)) {

				makefileImageContainerMap.put(mifPath, new SPNMIFContainer(makeFile, mifPath));

			}

			return makefileImageContainerMap.get(mifPath);

		}

		public void projectDeleted(IProject project) {

			// mark the containers are needing reparsing - easier than removing entries

			// from all container maps.

			for (IFile file : bldInfContainerMap.keySet()) {

				if (file != null) {

					IProject parentProject = file.getProject();

					if (parentProject != null && parentProject.equals(project)) {

						SPNBldInfContainer container = bldInfContainerMap.get(file);

						container.setNeedsReparse(true);

						break;

					}

				}

			}

		}

	}

	/**

	 * Abstract class which represents an object that acts as a container, e.g. has children

	 *

	 */

	private abstract class SPNContainer implements IWorkbenchAdapter, IAdaptable, ISPNStatusLineDecorator, ISPNViewRefreshable {

		protected boolean needsReparse = true;

		private String typeString;

		protected List<Object> children = new ArrayList<Object>(0);

		SPNContainer(String typeString) {

			this.typeString = typeString;

		}

		public Object[] getChildren(Object o) {

			if (needsReparse) {

				synchronized(children) {

					children.clear();

					children.addAll(getChildren());

				}

				needsReparse = false;

			}

			return children.toArray();

		}

		protected void setChildren(List<Object> newChildren) {

			synchronized(children) {

				children.clear();

				children.addAll(newChildren);

			}

		}

		protected abstract List<Object> getChildren();

		protected abstract String getTagString();

		public void setNeedsReparse(boolean recurse) {

			if (recurse) {

				// call setNeedsReparse on children, iff it has children.

				if (children.size() > 0) {

					for (Object o : getChildren(null)) {

						if (o instanceof SPNContainer) {

							((SPNContainer)o).setNeedsReparse(recurse);

						}

					}

				}

			}

			needsReparse = true;			

		}

		public String getTypeString() {

			return typeString;

		}

		public Object getParent(Object o) {

			return null;

		}

		public Object getAdapter(Class adapter) {

			if (IWorkbenchAdapter.class.equals(adapter)) {

				return this;

			}

			return null;

		}

		public void refresh() {

			setNeedsReparse(true);

		}

	}

	/**

	 * Abstract class which represents an IFile that acts as a container, e.g. has children

	 *

	 */

	private abstract class SPNFileContainer extends SPNContainer {

		protected static final String BLD_INF_CONTAINER_TYPE = "BLD_INF_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String MMP_CONTAINER_TYPE = "MMP_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String IMAGE_MAKEFILE_CONTAINER_TYPE = "IMAGE_MAKEFILE_CONTAINER_TYPE"; //$NON-NLS-1$

		protected IFile file;

		/**

		 * Constructor.

		 * 

		 * @param file the file acting as a container (bld.inf, mmp or make file)

		 * @param typeString the type string defining what type of file container this is

		 * 			 see {@link #BLD_INF_CONTAINER_TYPE}, {@link #MMP_CONTAINER_TYPE}, {@link #IMAGE_MAKEFILE_CONTAINER_TYPE}

		 */

		SPNFileContainer(IFile file, String typeString) {

			super(typeString);

			this.file = file;

		}

		public ImageDescriptor getImageDescriptor(Object object) {

			Object o = file.getAdapter(IWorkbenchAdapter.class);

			if (o != null) {

				return ((IWorkbenchAdapter)o).getImageDescriptor(file);

			}

			return PlatformUI.getWorkbench().getSharedImages().getImageDescriptor(ISharedImages.IMG_OBJ_FILE);

		}

		public String getLabel(Object o) {

			return file.getName();

		}

		public Object getAdapter(Class adapter) {

			if (IResource.class.equals(adapter) || IFile.class.equals(adapter)) {

				return file;

			} else if (IProject.class.equals(adapter)) {

				return file.getProject();

			}

			return super.getAdapter(adapter);

		}

		@Override

		public String toString() {

			if (file != null) {

				return file.getFullPath().toOSString();

			}

			return super.toString();

		}

		public String getStatusLineText() {

			return file.getFullPath().toOSString();

		}

		@Override

		public void refresh() {

			super.refresh();

			// checks for file system changes

			if (file != null) {

				IProject project = file.getProject();

				if (project != null) {

					try {

						project.refreshLocal(IResource.DEPTH_INFINITE, null);

					} catch (CoreException e) {

						e.printStackTrace();

					}

				}

			}

		}

	}

	/**

	 * Abstract class which represents an IFolder that acts as a container, e.g. has children

	 *

	 */

	private abstract class SPNFolderContainer extends SPNContainer {

		protected static final String UIDESIGNS_CONTAINER_TYPE = "UIDESIGNS_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String SOURCES_CONTAINER_TYPE = "SOURCES_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String SOURCEPATHS_CONTAINER_TYPE = "SOURCEPATHS_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String RESOURCES_CONTAINER_TYPE = "RESOURCES_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String INCLUDES_CONTAINER_TYPE = "INCLUDES_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String IMAGES_CONTAINER_TYPE = "IMAGES_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String DOCUMENTS_CONTAINER_TYPE = "DOCUMENTS_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String DEF_CONTAINER_TYPE = "DEF_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String MBM_CONTAINER_TYPE = "MBM_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String MIF_CONTAINER_TYPE = "MAKEFILE_IMAGE_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String AIF_CONTAINER_TYPE = "AIF_CONTAINER_TYPE"; //$NON-NLS-1$

		protected static final String BLD_INF_INCLUDES_CONTAINER_TYPE = "BLD_INF_INCLUDES_CONTAINER_TYPE"; //$NON-NLS-1$

		protected IFile parentFile;