/*******************************************************************************
 * Copyright (c) 2006 Sybase, Inc. 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:
 *     Sybase, Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.pagedesigner.editors.palette.impl;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.locks.ReentrantLock;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.Status;
import org.eclipse.core.runtime.content.IContentType;
import org.eclipse.core.runtime.content.IContentTypeManager;
import org.eclipse.gef.palette.PaletteDrawer;
import org.eclipse.gef.palette.PaletteEntry;
import org.eclipse.jst.jsf.common.internal.JSPUtil;
import org.eclipse.jst.jsf.common.runtime.internal.view.model.common.Namespace;
import org.eclipse.jst.jsf.core.internal.CompositeTagRegistryFactory;
import org.eclipse.jst.jsf.core.internal.CompositeTagRegistryFactory.TagRegistryIdentifier;
import org.eclipse.jst.jsf.designtime.internal.view.model.ITagRegistry;
import org.eclipse.jst.jsf.designtime.internal.view.model.ITagRegistry.ITagRegistryListener;
import org.eclipse.jst.jsf.designtime.internal.view.model.ITagRegistry.TagRegistryChangeEvent;
import org.eclipse.jst.jsf.designtime.internal.view.model.ITagRegistry.TagRegistryChangeEvent.EventType;
import org.eclipse.jst.pagedesigner.PDPlugin;
import org.eclipse.jst.pagedesigner.editors.palette.DesignerPaletteCustomizationsHelper;
import org.eclipse.jst.pagedesigner.editors.palette.IEntryChangeListener;
import org.eclipse.jst.pagedesigner.editors.palette.IPaletteConstants;
import org.eclipse.jst.pagedesigner.editors.palette.IPaletteContext;
import org.eclipse.jst.pagedesigner.editors.palette.IPaletteItemManager;
import org.eclipse.wst.html.core.internal.contentmodel.HTMLCMDocumentFactory;
import org.eclipse.wst.xml.core.internal.contentmodel.CMDocument;
import org.eclipse.wst.xml.core.internal.provisional.contentmodel.CMDocType;

/**
 *  Manages tag library palette by palette context.   Capable of handling JSP and XHTML content types.
 *  
 *  Callers must use getInstance(IPaletteContext), and when done, call release(IFile).   
 *  
 * @author mengbo and others
 */
public class PaletteItemManager implements IPaletteItemManager,
		IPaletteConstants, ITagRegistryListener {
	
	private static final boolean DEBUG = false;

	
	private static Map<TagRegistryIdentifier, PaletteItemManager> _managers = new HashMap<TagRegistryIdentifier, PaletteItemManager>();
	private static ReentrantLock MANAGER_LOCK = new ReentrantLock();
	private static long MANAGER_LOCK_TIMEOUT = 120;
	
	private Set<IFile> _files = new HashSet<IFile>();
	private TagRegistryIdentifier _tagRegId;
	private List<PaletteDrawer> _paletteCategories = new ArrayList<PaletteDrawer>();
	private CopyOnWriteArrayList<IEntryChangeListener> _listeners = new CopyOnWriteArrayList<IEntryChangeListener>();
	private AtomicBoolean IS_DISPOSED = new AtomicBoolean();

	private PaletteHelper _paletteHelper;

	private ITagRegistry _tagRegistry;


	/**
	 * Return singleton paletteItemManager for a given project.  Will only work for JSPs.
	 * @param project
	 * @return PaletteItemManager
	 * @deprecated - use getInstance(paletteContext)
	 */
	public static PaletteItemManager getInstance(final IProject project) {
		if (project == null) {
			// sometimes when the editor is editing a file in jar file, may not
			// be able to
			// get the project.
			return getInstance(createPaletteContext(null));
		}		
		//relies on JSP file extension for content type
		return getInstance(createPaletteContext(project.getFile("dummy.jsp")));  //$NON-NLS-1$
	}
	
	/**
	 * @param paletteContext
	 * @return PaletteItemManager instance shared with all files with same palette context in a project
	 * 				May return null if locking issue 
	 */
	public static PaletteItemManager getInstance(final IPaletteContext paletteContext) {	
		boolean hasLock = false;
		try {
			if (MANAGER_LOCK.tryLock(MANAGER_LOCK_TIMEOUT, TimeUnit.SECONDS)){
				hasLock = true;
				final TagRegistryIdentifier regId = getTagRegistryIdentifier(paletteContext);
				if (regId == null) {
					PDPlugin.log(new Status(IStatus.ERROR, PDPlugin.getPluginId(), "Unable to display palette for "+paletteContext.getFile().getName()+".  Unknown content type for file."));  //$NON-NLS-1$//$NON-NLS-2$
					return null;
				}
				PaletteItemManager manager = _managers.get(regId);
				if (manager == null) {
					 manager = new PaletteItemManager(regId);
					_managers.put(regId, manager);
					manager.init();
				} 
				manager.addFile(paletteContext.getFile());
				return manager;
				
			}
			//if we get here then the lock has timed out
			PDPlugin.log(new Status(Status.ERROR, PDPlugin.getPluginId(), "(getInstance()) Failed to get managers lock for" + paletteContext.getFile().toString())); //$NON-NLS-1$
			
		} catch (InterruptedException e) {
			PDPlugin.log("Failed in PaletteItemManager.getInstance(PaletteContext", e); //$NON-NLS-1$
		} finally {
			if (hasLock)
				MANAGER_LOCK.unlock();
		}
		return null;
	}
	
	private static TagRegistryIdentifier getTagRegistryIdentifier(
			final IPaletteContext paletteContext) {

		final IFile file = paletteContext.getFile();
		if (file != null) {
	        final IContentTypeManager typeManager = Platform.getContentTypeManager();
	        final IContentType contentType = 
	            typeManager.findContentTypeFor(file.getName());
	        
	        if (contentType != null)
	        {
	            return new TagRegistryIdentifier(file.getProject(), contentType);
	        }
	        return null;
		}
		//to support legacy null projects.   Allows HTML and JSP tag libs to be displayed.
	    return new TagRegistryIdentifier(null, org.eclipse.jst.pagedesigner.utils.JSPUtil.JSP_CONTENTTYPE);

	}

	/**
	 * @param file
	 * @return IPaletteContext
	 */
	public static IPaletteContext createPaletteContext(final IFile file) {
		return new IPaletteContext() {
			public IFile getFile() {
				return file;
			}

			public Object getAdapter(Class adapter) {				
				return null;
			}
		};
	}
	private void addFile(final IFile file) {
		synchronized (_files) {
			_files.add(file);
		}
		
	}
	
	/**
	 * Indicates that the file no longer needs the paletteItemManager, freeing the manager to be released after last reference
	 * @param paletteContext
	 */
	public void release(final IPaletteContext paletteContext) { 
		final IFile file = paletteContext.getFile();
		boolean isEmpty = false;
		synchronized (_files) {
			if (_files.contains(file)) {
				_files.remove(file);
				if (_files.isEmpty())
					isEmpty = true;
			}
		}

		if (isEmpty && IS_DISPOSED.compareAndSet(false, true)) {
			removeTagRegistryListeners(this);
			boolean hasLock = false;
			try {
				if (MANAGER_LOCK.tryLock(MANAGER_LOCK_TIMEOUT, TimeUnit.SECONDS)) {
					hasLock = true;
					_managers.remove(_tagRegId);
				}
				else {
					PDPlugin.log(new Status(Status.ERROR, PDPlugin.getPluginId(), "(Release) Failed to get managers lock for" + paletteContext.getFile().toString())); //$NON-NLS-1$
				}
			} catch (InterruptedException e) {
				PDPlugin.log("Failed to release paletteItemManager for" + paletteContext.getFile().toString(), e); //$NON-NLS-1$
			} finally {
				if (hasLock)
					MANAGER_LOCK.unlock();
			}
		}
	}

	private static void removeTagRegistryListeners(final PaletteItemManager manager) {
		if (manager.getTagRegistry() != null)
			manager.getTagRegistry().removeListener(manager);
	}

	private ITagRegistry getTagRegistry() {		
		return _tagRegistry;
	}

	/**
	 * For JUnit testing purposes only
	 */
	public static void clearPaletteItemManager() {
		
		boolean hasLock = false;
		try {
			if (MANAGER_LOCK.tryLock(MANAGER_LOCK_TIMEOUT, TimeUnit.SECONDS)){
				hasLock = true;
				if (_managers == null)
					return;

				for (final PaletteItemManager manager : _managers.values()) {
					PaletteItemManager.removeTagRegistryListeners(manager);		
					manager._files.clear();
				}							
				_managers.clear();
			} else {
				//if we get here then the lock has timed out
				PDPlugin.log(new Status(Status.ERROR, PDPlugin.getPluginId(), "(clear) Failed to get managers lock")); //$NON-NLS-1$
			}
			
		} catch (InterruptedException e) {
			PDPlugin.log("Failed in clearPaletteItemManager", e); //$NON-NLS-1$
		} finally {
			if (hasLock)
				MANAGER_LOCK.unlock();
		}

	}
	
	private PaletteItemManager(final TagRegistryIdentifier regId) {
		_paletteHelper = new PaletteHelper(this);
		if (regId != null) {
			_tagRegId = regId;
//			init();
		}		
	}
	

	public List getAllCategories() {	
		synchronized (_paletteCategories) {
			final List<PaletteDrawer> readOnlyCategories = new ArrayList<PaletteDrawer>(_paletteCategories);			
			return Collections.unmodifiableList(readOnlyCategories);
		}		
	}

	/**
	 * Initializes the palette items for the current project
	 */
	protected synchronized void init() {
		synchronized (_paletteCategories) {
			_paletteCategories.clear();
		}
		
		initTagRegistry();

		DesignerPaletteCustomizationsHelper.loadUserCustomizations(this);
		
		sortCategories();
	}

	/**
	 * Sort palette categories
	 */
	protected void sortCategories() {
		//note that once we store ordering customizations, we will need to do something different
		synchronized(_paletteCategories) {
			Collections.sort(_paletteCategories, new Comparator(){
	
				public int compare(Object o1, Object o2) {
					String label1 = ((PaletteEntry)o1).getLabel();
					String label2 = ((PaletteEntry)o2).getLabel();
					
					return label1.compareTo(label2);
				}
				
			});
		}
	}

	/**
	 * Reinitializes the palatteItemManager and informs all palette roots that use the manager to refresh
	 */
	public void reset() {
		init();
		fireModelChanged(null, null);
	}
	
	private void initTagRegistry() {
		registerHTMLCategory();
		if (isJSP(_tagRegId))
			registerJSPCategory();			
		
		registerTagsFromTagRegistry();	
	}

	private boolean isJSP(final TagRegistryIdentifier tagRegistryId) {
		final IContentType ct = tagRegistryId.getContentType();
		if (JSPUtil.isJSPContentType(ct.getId()))
			return true;
		return false;
	}

	private void registerTagsFromTagRegistry() {
		_tagRegistry = getTagRegistry(_tagRegId);
		if (_tagRegistry != null) {
			for (final Namespace ns : _tagRegistry.getAllTagLibraries()) {							
				_paletteHelper.configPaletteItemsByNamespace(this, ns);			
			}
		}
	}

	private ITagRegistry getTagRegistry(final TagRegistryIdentifier regId) {
		ITagRegistry reg = null;
		if (regId.getProject() != null) {
			reg = CompositeTagRegistryFactory.getInstance().getRegistry(regId);
			if (reg != null) {
				reg.addListener(this);
			}
		}
		return reg;
	}

	private void registerHTMLCategory() {
		final CMDocument doc = HTMLCMDocumentFactory.getCMDocument(CMDocType.HTML_DOC_TYPE);
		_paletteHelper.getOrCreateTaglibPaletteDrawer(this, doc, CMDocType.HTML_DOC_TYPE);
	}

	private void registerJSPCategory() {
		final CMDocument doc = HTMLCMDocumentFactory.getCMDocument(CMDocType.JSP11_DOC_TYPE);
		_paletteHelper.getOrCreateTaglibPaletteDrawer(this, doc, CMDocType.JSP11_DOC_TYPE);
	}

//	/**
//	 * Search Classpath entry list to find if the entry is jar library and the
//	 * library have the tld descriptor, if have ,build a palette category mapping
//	 * the tld descriptor.
//	 * 
//	 * @param project
//	 */
//	private void registerTldFromClasspath(final IProject project) {
//		if (project != null) {
//			ITaglibRecord[] tldrecs = TaglibIndex.getAvailableTaglibRecords(project.getFullPath());
//			for (int i=0;i<tldrecs.length;i++){				
//				_paletteHelper.configPaletteItemsByTLD(this, getCurProject(), tldrecs[i]);			
//			}
//		}			
//	}

	/**
	 * @param id (most likely the uri)
	 * @param label 
	 * @return TaglibPaletteDrawer
	 */
	public TaglibPaletteDrawer findOrCreateCategory(final String id, final String label) {
		TaglibPaletteDrawer category = getTaglibPalletteDrawer(id);
		if (category == null)
			category = createTaglibPaletteDrawer(id, label);
		return category;
	}

	/**
	 * @param uri
	 * @return TaglibPaletteDrawer
	 */
	public TaglibPaletteDrawer findCategoryByURI(final String uri) {
		TaglibPaletteDrawer category;
		for (final Iterator iter = getAllCategories().iterator(); iter.hasNext();) {
			category = (TaglibPaletteDrawer) iter.next();
			if (uri.equals(category.getURI())) {
				return category;
			}
		}
		return null;
	}

	public TaglibPaletteDrawer createTaglibPaletteDrawer(final String uri, final String label) {
		final TaglibPaletteDrawer r = new TaglibPaletteDrawer(uri, label);
		synchronized(_paletteCategories) {
			_paletteCategories.add(r);
		}
		return r;
	}

	public TaglibPaletteDrawer getTaglibPalletteDrawer(final String uri) {
		for (final Iterator iter = getAllCategories().iterator(); iter.hasNext();) {
			final TaglibPaletteDrawer cat = (TaglibPaletteDrawer) iter.next();
			if (uri.equalsIgnoreCase(cat.getId())) {
				return cat;
			}
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.sybase.stf.jmt.pagedesigner.editors.palette.IPaletteItemManager#addEntryChangeListener(com.sybase.stf.jmt.pagedesigner.editors.palette.IEntryChangeListener)
	 */
	public void addEntryChangeListener(final IEntryChangeListener listener) {
		_listeners.addIfAbsent(listener);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see com.sybase.stf.jmt.pagedesigner.editors.palette.IPaletteItemManager#removeEntryChangeListener(com.sybase.stf.jmt.pagedesigner.editors.palette.IEntryChangeListener)
	 */
	public void removeEntryChangeListener(final IEntryChangeListener listener) {		
		_listeners.remove(listener);
	}

	/**
	 * Notify model change event
	 * 
	 * @param oldDefinitions
	 * @param newDefinitions
	 */
	private void fireModelChanged(final List oldDefinitions, final List newDefinitions) {
		if (_listeners == null) {
			return;
		}
		for (final Iterator<IEntryChangeListener> it= _listeners.iterator();it.hasNext();){
			final IEntryChangeListener listener = it.next();
			listener.modelChanged(oldDefinitions, newDefinitions);
		}	
	}
	
	/**
	 * Informs all paletteItemManagers, except the notifying paletteManager, of updates to the customizations
	 * All palette viewer roots will be notifed of possible updates
	 * @param notifyingManager 
	 */
	public static void notifyPaletteItemManagersOfCustomizationsUpdate(final IPaletteItemManager notifyingManager){
		boolean hasLock = false;
		try {
			if (MANAGER_LOCK.tryLock(MANAGER_LOCK_TIMEOUT, TimeUnit.SECONDS)){
				hasLock = true;
				for (Iterator it=_managers.values().iterator();it.hasNext();){
					final PaletteItemManager mgr = (PaletteItemManager)it.next();
					if (mgr != null && notifyingManager != mgr)
						mgr.reset();
				}
			} 
			else {
				//if we get here then the lock has timed out
				PDPlugin.log(new Status(Status.ERROR, PDPlugin.getPluginId(), "Failed to get managers lock in notifyPaletteItemManagersOfCustomizationsUpdate")); //$NON-NLS-1$
			}
			
		} catch (InterruptedException e) {
			PDPlugin.log("Failed in notifyPaletteItemManagersOfCustomizationsUpdate", e); //$NON-NLS-1$
		} finally {
			if (hasLock)
				MANAGER_LOCK.unlock();
		}

	}

	public void registryChanged(final TagRegistryChangeEvent event) {
		final EventType eventType = event.getType();
		switch (eventType) {
			case ADDED_NAMESPACE:
				addNamespaces(event.getAffectedObjects());
				break;
			case REMOVED_NAMESPACE:
				removeNamespaces(event.getAffectedObjects());
				break;
			case CHANGED_NAMESPACE:
				changeNamespaces(event.getAffectedObjects());
				break;
			case REGISTRY_DISPOSED:
				break;
	
			default:
				break;
		}
		
		DesignerPaletteCustomizationsHelper.loadUserCustomizations(this);
		sortCategories();
		
		fireModelChanged(null, null);
	}


	private void addNamespaces(final List<? extends Namespace> affectedObjects) {
		synchronized (_paletteCategories) {
			for (final Namespace ns : affectedObjects) {
				if (DEBUG)
					System.out.println("Add NS: "+ns.getNSUri()+"["+System.currentTimeMillis()+"]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
				_paletteHelper.configPaletteItemsByNamespace(this, ns);
			}
		}
	}
	
	private void removeNamespaces(final List<? extends Namespace> affectedObjects) {
		final List<Integer> drawersToRemove = new ArrayList<Integer>();
		synchronized (_paletteCategories) {
			for (final Namespace ns : affectedObjects) {
				for (int i=_paletteCategories.size() - 1; i >= 0; i--) {//gather in reverse order
					final PaletteDrawer drawer = _paletteCategories.get(i);
					if (drawer.getId().equals(ns.getNSUri())) {
						if (DEBUG)
							System.out.println("Remove NS: "+drawer.getId() +"["+System.currentTimeMillis()+"]"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
						drawersToRemove.add(new Integer(i));	
					}
				}
			}	
			if (! drawersToRemove.isEmpty()) {
				Collections.sort(drawersToRemove, new Comparator<Integer>() {//reverse order sort

					public int compare(Integer o1, Integer o2) {
						if (o1.intValue() > o2.intValue())
							return -1;
						else if (o1.intValue() < o2.intValue())
							return 1;
							
						return 0;
					}
				});
				for (Integer index : drawersToRemove) {
					_paletteCategories.remove(index.intValue());				
				}
			}
		}
	}

	private void changeNamespaces(final List<? extends Namespace> affectedObjects) {
		//for now, remove then add
		removeNamespaces(affectedObjects);
		addNamespaces(affectedObjects);		
	}

	public TagRegistryIdentifier getTagRegistryIdentifier() {		
		return _tagRegId;
	}

	/**
	 * @return helper
	 */
	public PaletteHelper getPaletteHelper() {
		return _paletteHelper;
	}

}