/*******************************************************************************
 * Copyright (c) 2005, 2009 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.authoring.ui.views;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.eclipse.core.runtime.ListenerList;
import org.eclipse.core.runtime.SafeRunner;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.edit.ui.provider.AdapterFactoryContentProvider;
import org.eclipse.epf.authoring.ui.providers.ConfigPackageContentProvider;
import org.eclipse.epf.library.configuration.ConfigurationData;
import org.eclipse.epf.library.edit.navigator.ConfigContentPackageItemProvider.LeafElementsItemProvider;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.ContentPackage;
import org.eclipse.epf.uma.CustomCategory;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodPackage;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.jface.util.SafeRunnable;
import org.eclipse.jface.viewers.CheckStateChangedEvent;
import org.eclipse.jface.viewers.CheckboxTreeViewer;
import org.eclipse.jface.viewers.ICheckStateListener;
import org.eclipse.jface.viewers.ITreeViewerListener;
import org.eclipse.jface.viewers.TreeExpansionEvent;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Control;
import org.eclipse.swt.widgets.Item;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.ui.dialogs.ContainerCheckedTreeViewer;

/**
 * ContainerCheckedTreeViewer class that supports MethodElements.
 * Specifically, has changes to support FeatureValueWrapperItemProviders.
 * 
 * Also, expands the tree for checked items when they are set via
 * setCheckedElements(..) iff expandWhenChecking is true.
 * @author Jeff Hardy
 * @author Phong Nguyen Le
 */
public class MethodContainerCheckedTreeViewer extends
		ContainerCheckedTreeViewer {
	
	protected boolean expandWhenChecking = false;
	protected boolean initializingTreeCheckState = false;
	private ConfigurationData configData;
	private boolean disableHandleLeafCrayChecks = false;

	protected ListenerList childrenCheckStateListeners = new ListenerList();

    /**
     * Constructor for MethodContainerCheckedTreeViewer.
     * @see CheckboxTreeViewer#CheckboxTreeViewer(Composite)
     */
    public MethodContainerCheckedTreeViewer(Composite parent) {
        super(parent);
        initViewer();
    }

    /**
     * Constructor for MethodContainerCheckedTreeViewer.
     * @see CheckboxTreeViewer#CheckboxTreeViewer(Composite,int)
     */
    public MethodContainerCheckedTreeViewer(Composite parent, int style) {
        super(parent, style);
        initViewer();
    }

    /**
     * Constructor for MethodContainerCheckedTreeViewer.
     * @see CheckboxTreeViewer#CheckboxTreeViewer(Tree)
     */
    public MethodContainerCheckedTreeViewer(Tree tree) {
        super(tree);
        initViewer();
    }
    
    protected void initViewer() {
        setUseHashlookup(true);
        addCheckStateListener(new ICheckStateListener() {
            public void checkStateChanged(CheckStateChangedEvent event) {
				updateWrappers(event.getElement());
				doCheckStateChanged(event.getElement());
//	not ready to call the following line yet				
//				handleLeafCrayChecks(element);	
			}
        });
        addTreeListener(new ITreeViewerListener() {
            public void treeCollapsed(TreeExpansionEvent event) {
            }

            public void treeExpanded(TreeExpansionEvent event) {
                Widget item = findItem(event.getElement());
                if (item instanceof TreeItem) {
                    initializeItem((TreeItem) item);
                }
            }
        });
    }
    
    /**
     * The item has expanded. Updates the checked state of its children. 
     */
    protected void initializeItem(TreeItem item) {
        if (item.getChecked() && !item.getGrayed()) {
            updateChildrenItems(item);
        }
    }
    
    /**
     * Updates the check state of all created children
     */
    protected void updateChildrenItems(TreeItem parent) {
        Item[] children = getChildren(parent);
        boolean state = parent.getChecked();
        for (int i = 0; i < children.length; i++) {
            TreeItem curr = (TreeItem) children[i];
            if (curr.getData() != null
                    && ((curr.getChecked() != state) || curr.getGrayed())) {
                curr.setChecked(state);
                curr.setGrayed(false);
                notifyChildrenCheckStateListeners(new CheckStateChangedEvent(this, curr.getData(),
                		state));                
                updateChildrenItems(curr);
            }
        }
    }
    
    @Override
    protected void doCheckStateChanged(Object element) {
    	if (initializingTreeCheckState) {
    		// when initializing, don't update children:
    		// parent may have been gray-checked and we don't
    		// want to white-check all children
    		// children will be checked because setCheckedElements(..)
    		// typically receives list of all checked elements
			Widget item = findItem(element);
			if (item instanceof TreeItem) {
				TreeItem treeItem = (TreeItem) item;
				treeItem.setGrayed(false);
				updateParentItems(treeItem.getParentItem());
			}
		} else {
			super.doCheckStateChanged(element);		
		}
    }
    
    private void handleLeafCrayChecks(Object element) {
    	if (getConfigData() == null || disableHandleLeafCrayChecks) {
    		return;
    	}
        Widget item = findItem(element);
        TreeItem treeItem = item instanceof TreeItem ? (TreeItem) item : null;
        if (treeItem == null) {
        	return;
        }
        
        Set<LeafElementsItemProvider> uncheckedLeafs = new HashSet<LeafElementsItemProvider>();        	
        collectUncheckedLeafs(treeItem, uncheckedLeafs);
        handleLeafCrayChecks(uncheckedLeafs);
    }
    
    private void collectUncheckedLeafs(TreeItem treeItem, Set<LeafElementsItemProvider> uncheckedLeafs) {
        if (treeItem.getData() instanceof LeafElementsItemProvider) {
        	if (! treeItem.getChecked()) {
        		uncheckedLeafs.add((LeafElementsItemProvider) treeItem.getData());
        	}
        	return;
        }
        Item[] children = getChildren(treeItem);
        for (int i = 0; i < children.length; i++) {
            TreeItem curr = (TreeItem) children[i];
            collectUncheckedLeafs(curr, uncheckedLeafs);
        }
    }
    
	public void handleLeafCrayChecks(
			Collection<LeafElementsItemProvider> uncheckedLeafs) {
		if (uncheckedLeafs == null || uncheckedLeafs.isEmpty()) {
			return;
		}
		Set<TreeItem> grayCheckedSet = new HashSet<TreeItem>();

		for (LeafElementsItemProvider leaf : uncheckedLeafs) {
			MethodPackage leafParent = leaf.getParentPackage();
			if (!getConfigData().hasAddedElements(leafParent)) {
				continue;
			}

			Widget item = findItem(leaf);
			if (item instanceof TreeItem) {
				TreeItem treeItem = (TreeItem) item;
				while (treeItem != null) {
					if (!grayCheckedSet.contains(treeItem)) {
						treeItem.setChecked(true);
						treeItem.setGrayed(true);
						grayCheckedSet.add(treeItem);
					}
					treeItem = treeItem.getParentItem();
				}
			}
		}
	}   
        
    public void updateParents(Object element) {
        Widget item = findItem(element);
        if (item instanceof TreeItem) {
            TreeItem treeItem = (TreeItem) item;
            updateParentItems(treeItem.getParentItem());
        }
    }

    /**
     * Updates the check / gray state of all parent items
     */
    protected void updateParentItems(TreeItem item) {
        if (item != null) {
            Item[] children = getChildren(item);
            boolean containsChecked = false;
            boolean containsUnchecked = false;
            for (int i = 0; i < children.length; i++) {
                TreeItem curr = (TreeItem) children[i];
                containsChecked |= curr.getChecked();
                containsUnchecked |= (!curr.getChecked() || curr.getGrayed());
            }
            item.setChecked(containsChecked);
            item.setGrayed(containsChecked && containsUnchecked);
            if (expandWhenChecking && item.getChecked()) {
            	item.setExpanded(true);
            }
            updateParentItems(item.getParentItem());
        }
    }
    
    private void updateWrappers(Object object) {
    	boolean state = getChecked(object);
    	Object element = TngUtil.unwrap(object);
    	if(object != element) {
    		setChecked(element, state);
    	}
		AdapterFactory adapterFactory = null;
		if (getContentProvider() instanceof AdapterFactoryContentProvider) {
			adapterFactory = ((AdapterFactoryContentProvider) getContentProvider())
					.getAdapterFactory();
		}
		if (adapterFactory != null) {
			Collection<?> wrappers = TngUtil.getWrappers(adapterFactory,
					element);
			if (!wrappers.isEmpty()) {
				for (Object wrapper : wrappers) {
					setChecked(wrapper, state);
				}
			}
		}
	}
    
    /*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jface.viewers.CheckboxTreeViewer#setCheckedElements(java.lang.Object[])
	 */
    public void setCheckedElements(Object[] elements) {
    	// fix elements list to use EPF's wrappers
    	List<Object> treeElements = new ArrayList<Object>();
    	AdapterFactory adapterFactory = null;
    	if (getContentProvider() instanceof AdapterFactoryContentProvider) {
    		adapterFactory = ((AdapterFactoryContentProvider)getContentProvider()).getAdapterFactory();
    	}
		for (int i = 0; i < elements.length; i++) {
			Object element = elements[i];
			if (adapterFactory != null) {
				treeElements.addAll(TngUtil.getWrappers(adapterFactory, element));
			}
			if(!(element instanceof CustomCategory)) {
				treeElements.add(element);
			}
		}
    	initializingTreeCheckState = true;
        super.setCheckedElements(treeElements.toArray());
    	initializingTreeCheckState = false;
    }
    
    /**
     * Returns a list of top-most checked elements in this viewer's tree, 
     * including currently hidden ones that are marked as
     * checked but are under a collapsed ancestor.
     *
     * Only returns white-checked items, not grayed items
     *
     * @return the array of checked elements
     *
     * @see #setCheckedElements
     */
    public Object[] getTopCheckedElements() {
        ArrayList v = new ArrayList();
        Control tree = getControl();
        internalCollectTopChecked(v, tree);
        return v.toArray();
    }
    
    
    /**
     * Gathers the top-most checked states of the given widget and its
     * descendents, following a pre-order traversal of the tree.
     *
     * @param result a writable list of elements (element type: <code>Object</code>)
     * @param widget the widget
     */
    private void internalCollectTopChecked(List result, Widget widget) {
        Item[] items = getChildren(widget);
        for (int i = 0; i < items.length; i++) {
            Item item = items[i];
            if (item instanceof TreeItem && ((TreeItem) item).getChecked() && !((TreeItem) item).getGrayed()) {
                Object data = item.getData();
                if (data != null) {
					result.add(data);
				}
            }
            if (item instanceof TreeItem && (!((TreeItem) item).getChecked() || ((TreeItem) item).getGrayed())) {
            	internalCollectTopChecked(result, item);
            }
        }
    }


	public boolean isExpandWhenChecking() {
		return expandWhenChecking;
	}

	public void setExpandWhenChecking(boolean expandWhenChecking) {
		this.expandWhenChecking = expandWhenChecking;
	}
	
	/**
	 * notified when children checkstate is changed (by checking a parent)
	 * @param listener
	 */
	public void addChildrenCheckStateListener(ICheckStateListener listener) {
		childrenCheckStateListeners.add(listener);
	}
	
	public void removeChildrenCheckStateListener(ICheckStateListener listener) {
		childrenCheckStateListeners.remove(listener);
	}
	
	protected void notifyChildrenCheckStateListeners(final CheckStateChangedEvent event) {
		for (final Object listener : childrenCheckStateListeners.getListeners()) {
            SafeRunner.run(new SafeRunnable() {
                public void run() {
                	((ICheckStateListener)listener).checkStateChanged(event);
                }
            });
		}
	}
		
    public Set<MethodPackage> getElementsUnslectedPkgs(Collection<MethodPackage> pkgsInConfig, ConfigPackageContentProvider provider) {
    	Set<MethodPackage> elementsUnslectedPkgs = new HashSet<MethodPackage>();
    	for (MethodPackage pkg : pkgsInConfig) {
    		if (pkg instanceof ContentPackage) {
    			Object leaf = provider.getLeafElementsNode(pkg);
            Widget item = findItem(leaf);            
				if (item instanceof TreeItem) {
					TreeItem treeItem = (TreeItem) item;
					if (! treeItem.getChecked() || treeItem.getGrayed()) {
						elementsUnslectedPkgs.add((ContentPackage) pkg);
					}
				}
    		}
        }
        return elementsUnslectedPkgs;
    }
    
    public void debugDump(Collection items, String msg) {
    	System.out.println("LD> msg : " + msg);						//$NON-NLS-1$	
    	for (Object item : items) {
    		System.out.println("LD> item : " + item);				//$NON-NLS-1$	
    		System.out.println("LD> found: " + findItem(item));		//$NON-NLS-1$	
    	}
		System.out.println("");	 //$NON-NLS-1$
    }
    
	public ConfigurationData getConfigData() {
		return configData;
	}

	public void setConfigData(ConfigurationData configData) {
		this.configData = configData;
	}

	@Override
    public boolean setChecked(Object element, boolean state) {
		try {
			disableHandleLeafCrayChecks = true;
			return super.setChecked(element, state);
		} finally {
			disableHandleLeafCrayChecks = false;
		}
    }
	
	public void debugTree() {
		Object root = getRoot();
		Tree tree = (Tree) this.findItem(root);
		debugItem(tree.getItem(0), "LD>"); //$NON-NLS-1$
	}

	private void debugItem(Object objItem, String indent) {
		if (objItem instanceof TreeItem) {
			TreeItem item = (TreeItem) objItem;
			System.out.println(indent + "item : " + item + ", hash: " //$NON-NLS-1$ //$NON-NLS-2$
					+ item.hashCode());
			System.out.println(indent + "data : " + item.getData()); //$NON-NLS-1$
			System.out.println(""); //$NON-NLS-1$
			for (TreeItem cItem : item.getItems()) {
				debugItem(cItem, indent + "     "); //$NON-NLS-1$
			}
		} else {
			System.out.println(indent + "objItem : " + objItem); //$NON-NLS-1$
			System.out.println(""); //$NON-NLS-1$
		}

	} 
	
}