package pyUML.views;

import java.util.Arrays;
import java.util.Dictionary;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Vector;

import org.eclipse.emf.ecore.EObject;
import org.eclipse.jface.wizard.WizardPage;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.SelectionEvent;
import org.eclipse.swt.events.SelectionListener;
import org.eclipse.swt.layout.GridData;
import org.eclipse.swt.layout.GridLayout;
import org.eclipse.swt.widgets.Button;
import org.eclipse.swt.widgets.Composite;
import org.eclipse.swt.widgets.Label;
import org.eclipse.swt.widgets.Text;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeItem;
import org.eclipse.uml2.uml.Classifier;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.Interface;
import org.eclipse.uml2.uml.Model;

/**
 * This Wizard page contains a tree view where 
 * the user can select packages/classes used in the view.
 */
public class SelectViewElementsPage extends WizardPage implements SelectionListener{

	private Model model;
	private List<String> usedXmiIds;
	protected Dictionary<Element, TreeItem> nodeCheckboxDict;
	protected Text viewNameField;
	protected Button buttInclSuperClasses;
	protected Button buttInclSubClasses;
	private Map<EObject, String> modelXmiDict;
	private boolean initialIncludeSuperclasses;
	private boolean initialIncludeSubclasses;
	private String initialViewName;
	
	public Text getViewNameField() {
		return viewNameField;
	}

	protected SelectViewElementsPage(String pageName, Model model, List<String> usedXmiIds, 
			Map<EObject, String> modelXmiDict, String initialViewName, 
			boolean initialIncludSuperclasses, boolean initialIncludSubclasses) {
		super(pageName);
		this.setTitle(pageName);
		this.model=model;
		this.nodeCheckboxDict = new Hashtable<Element, TreeItem>();
		this.usedXmiIds = usedXmiIds;
		this.modelXmiDict = modelXmiDict;
		this.initialIncludeSuperclasses = initialIncludSuperclasses;
		this.initialIncludeSubclasses = initialIncludSubclasses;
		this.initialViewName = initialViewName;
	}

	public void createControl(Composite parent) {
		// create the composite to hold the widgets
		GridData gd;
		Composite composite =  new Composite(parent, SWT.NULL);

	    // create the desired layout for this wizard page
		GridLayout gl = new GridLayout();
		int ncol = 1;
		gl.numColumns = ncol;
		gl.makeColumnsEqualWidth=true;
		composite.setLayout(gl);
		
		Composite viewNameComp= new Composite(composite, composite.getStyle());
		GridLayout ViewNameLayout = new GridLayout();
		ViewNameLayout.numColumns=2;
		ViewNameLayout.makeColumnsEqualWidth=false;
		viewNameComp.setLayout(ViewNameLayout);
		
		Label viewNameLabel = new Label(viewNameComp, SWT.HORIZONTAL);
		viewNameLabel.setText("View name: ");
		viewNameField = new Text(viewNameComp, SWT.SINGLE);
		viewNameField.setText(this.initialViewName);
		viewNameField.setSize(200, 25);
		
		Tree tree = new Tree(composite, SWT.CHECK);
		gd = new GridData(GridData.FILL_BOTH);

		tree.setLayoutData(gd);
		
		TreeItem item = new TreeItem(tree, tree.getStyle());
		item.setText(this.model.getName());
		
		nodeCheckboxDict.put(model, item);
		if (usedXmiIds.contains(modelXmiDict.get(model)))
			item.setChecked(true);

		for (Element child : model.getOwnedElements()) {
			recurseModelElements(child, item);
		}
		
		if (usedXmiIds.contains(modelXmiDict.get(model)))
			item.setChecked(true);

		
		this.buttInclSuperClasses = new Button(composite, SWT.CHECK);
		this.buttInclSuperClasses.setText("Include superclasses of selected classes");
		this.buttInclSuperClasses.setSelection(this.initialIncludeSuperclasses);		
		
		this.buttInclSubClasses = new Button(composite, SWT.CHECK);
		this.buttInclSubClasses.setText("Include child classes of selected classes");
		this.buttInclSubClasses.setSelection(this.initialIncludeSubclasses);		

		
	    // set the composite as the control for this page
		setControl(composite);		
		tree.addSelectionListener(this);	

	}
	
	/**
	 * This adds all sub-elements of checked packages
	 * to the list of used XMI-IDs. This is needed for a non-interactive
	 * View update to ensure all newly created sub-classes/-packages 
	 * are added to a checked package.
	 */
	public void addPackagedXmiIds() {
		this.recurseModelElements(this.model, null);
	}

	/**
	 * Initialize the TreeView by iterationg the Model
	 * -> Package and class nodes are created in the tree
	 * @param node
	 * @param parentItem if null, the XMI-ID will be added to used IDs
	 *        insead of checking the box (used non-interactive mode)
	 */
	protected void recurseModelElements(Element node, TreeItem parentItem) {
		if (node instanceof org.eclipse.uml2.uml.Package) {
			org.eclipse.uml2.uml.Package pack = (org.eclipse.uml2.uml.Package) node;
			if (parentItem == null) {
				if (this.usedXmiIds.contains(this.modelXmiDict.get(pack)))
					for (Element childNode : pack.getOwnedElements()) {
						this.usedXmiIds.add(this.modelXmiDict.get(childNode));
						recurseModelElements(childNode, null);
				}
			} else {
				TreeItem item = new TreeItem(parentItem, parentItem.getStyle());
				item.setText("Package " + pack.getName());
				nodeCheckboxDict.put(pack, item);
				
				for (Element childNode : pack.getOwnedElements())
					recurseModelElements(childNode, item);
				
				if(this.usedXmiIds.contains(this.modelXmiDict.get(pack)))
					setWidgetChecked(item, true);
			}
			return;
		}
		if (node instanceof Classifier && parentItem != null) {
			Classifier cl = (Classifier) node;
			TreeItem item = new TreeItem(parentItem, parentItem.getStyle());
			if (cl instanceof org.eclipse.uml2.uml.Class)
				item.setText("Class " + cl.getName());
			else if (cl instanceof Interface)
				item.setText("Interface " + cl.getName());
			else
				item.setText("Element " + cl.getName());

			nodeCheckboxDict.put(cl, item);
			if(this.usedXmiIds.contains(this.modelXmiDict.get(cl)))
				item.setChecked(true);
			
			for (Element childNode : cl.getOwnedElements())
				recurseModelElements(childNode, item);
			return;
		}
	}
	
	public void widgetDefaultSelected(SelectionEvent e) {
	}

	/**
	 * Check/uncheck a Class/Package in the Tree View
	 * and *all* subpackages/classes of a view
	 * This can be called by the listener or
	 * automatically when updating a view
	 * -> all new Child-Elements of a selected package
	 * should be automatically added to a view.
	 * @param item
	 * @param checked
	 */
	public void setWidgetChecked(TreeItem item, boolean checked) {
		item.setChecked(checked);
		List<TreeItem> children = new Vector<TreeItem>();
		children.addAll(Arrays.asList(item.getItems()));
		while(! children.isEmpty()) {
			TreeItem child = children.get(0);
			children.remove(child);
			children.addAll(Arrays.asList(child.getItems()));
			child.setChecked(checked);
		}			
	}
	
	public void widgetSelected(SelectionEvent e) {
		// mark or unmark all children check boxes
		// of a marked/unmarked box
		if (e.item instanceof TreeItem) {
			TreeItem item = (TreeItem) e.item;
			boolean checked = item.getChecked();
			this.setWidgetChecked(item, checked);
		}
	}

	public Dictionary<Element, TreeItem> getNodeCheckboxDict() {
		return nodeCheckboxDict;
	}

	public Button getButtInclSuperClasses() {
		return buttInclSuperClasses;
	}

	public boolean isInitialIncludeSuperclasses() {
		return initialIncludeSuperclasses;
	}

	public void setInitialIncludeSuperclasses(boolean initialIncludeSuperclasses) {
		this.initialIncludeSuperclasses = initialIncludeSuperclasses;
	}

	public Button getButtInclSubClasses() {
		return buttInclSubClasses;
	}
}