/*
    * Created on May 6, 2005. Copyright 1999-2006 Faculty of Mathematics, Physics
    * and Informatics, Comenius University, Bratislava. This file is protected by
    * the Mozilla Public License version 1.1 (the "License"); you may not use this
    * file except in compliance with the License. You may obtain a copy of the
    * License at http://euromath2.sourceforge.net/license.html Unless required by
    * applicable law or agreed to in writing, software distributed under the
    * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
    * OF ANY KIND, either express or implied. See the License for the specific
   * language governing permissions and limitations under the License.
   */
  package sk.uniba.euromath.editor.widgets;
  import java.io.ByteArrayOutputStream;
  import java.io.IOException;
  import java.io.PrintStream;
  import java.util.EnumSet;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.IdentityHashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import org.apache.commons.lang.StringUtils;
  import org.eclipse.jface.dialogs.MessageDialog;
  import org.eclipse.swt.SWT;
  import org.eclipse.swt.events.DisposeEvent;
  import org.eclipse.swt.events.DisposeListener;
  import org.eclipse.swt.events.ModifyEvent;
  import org.eclipse.swt.events.ModifyListener;
  import org.eclipse.swt.events.SelectionAdapter;
  import org.eclipse.swt.events.SelectionEvent;
  import org.eclipse.swt.layout.GridData;
  import org.eclipse.swt.layout.GridLayout;
  import org.eclipse.swt.widgets.Button;
  import org.eclipse.swt.widgets.Combo;
  import org.eclipse.swt.widgets.Composite;
  import org.eclipse.swt.widgets.Label;
  import sk.baka.ikslibs.ResultEnum;
  import sk.baka.xml.gene.CoordinatorInfo;
  import sk.baka.xml.gene.ExportException;
  import sk.baka.xml.gene.exportgraph.ExportGraph;
  import sk.baka.xml.gene.exportgraph.ExportGraphBuilder;
  import sk.baka.xml.gene.exportgraph.GraphNode;
  import sk.baka.xml.gene.exportgraph.IGraphEdgeSelector;
  import sk.baka.xml.gene.exportgraph.TransformGraph;
  import sk.baka.xml.gene.exportgraph.TransformNode;
  import sk.uniba.euromath.config.EuromathConfig;
  import sk.uniba.euromath.config.bind.NamespaceType;
  import sk.uniba.euromath.editor.lang.Messages;
  /***
   * <p>
   * Allows user to select choices in an export graph. Able to convert list of
   * graph nodes to a list of {@link TransformNode} instances.
   * </p>
   * @author Martin Vysny
   */
  public class GraphSelectorWidget extends AbstractUserInputWidget {
  	/***
  	 * Here all controls will be placed.
  	 */
  	protected final Composite composite;
  	/***
  	 * Constructor.
  	 * @param parent the parent widget
  	 * @param editableChoices all choice nodes. May be empty or
  	 * <code>null</code>.
  	 * @param graph offer this graph to user. Must not be empty.
  	 * @throws IllegalArgumentException if graphList or editableChoices is
  	 * empty, or editableChoices refers to non-choosable nodes.
  	 */
  	public GraphSelectorWidget(final Composite parent,
  			final Map<GraphNode, Set<String>> editableChoices,
  			final ExportGraph graph) {
  		super();
  		if ((graph == null) || graph.isEmpty())
  			throw new IllegalArgumentException("Graph is empty or null"); //$NON-NLS-1$
  		// create controls
  		composite = new Composite(parent, SWT.NONE);
  		final GridLayout l = new GridLayout(2, false);
  		composite.setLayout(l);
  		// create controls
  		if ((editableChoices != null) && !editableChoices.isEmpty()) {
  			createChoiceNodeControls(editableChoices);
  		}
  		createNamespaceOptionsControls(graph);
  		this.graph = graph;
  		// create button that displays the graph
  		final Button showGraphButton = new Button(composite, SWT.PUSH);
  		showGraphButton.setText(Messages.getString("SHOW_EXPORT_GRAPH_REP")); //$NON-NLS-1$
  		showGraphButton.addSelectionListener(new SelectionAdapter() {
  			/*
  			 * (non-Javadoc)
  			 * @see org.eclipse.swt.events.SelectionAdapter#widgetSelected(org.eclipse.swt.events.SelectionEvent)
  			 */
  			@Override
  			public void widgetSelected(SelectionEvent e) {
  				// compute the string representation of graph
  				final ByteArrayOutputStream bos = new ByteArrayOutputStream();
  				final PrintStream out = new PrintStream(bos);
 				ExportGraphBuilder.printGraph(GraphSelectorWidget.this.graph,
 						out);
 				out.close();
 				final String graphRep = new String(bos.toByteArray());
 				MessageDialog.openInformation(parent.getShell(),
 						Messages.getString("EXPORT_GRAPH_REPRESENTATION"), graphRep); //$NON-NLS-1$
 			}
 		});
 	}
 	/***
 	 * Creates controls allowing you to choose one of the choice nodes options.
 	 * @param editableChoices all choice nodes. Must not be <code>null</code>.
 	 */
 	private void createChoiceNodeControls(
 			final Map<GraphNode, Set<String>> editableChoices) {
 		for (final GraphNode graph : editableChoices.keySet()) {
 			for (final String target : editableChoices.get(graph)) {
 				final List<GraphNode> children = graph.getTargets(target);
 				if (children.size() < 2)
 					throw new IllegalArgumentException(graph + ":" + target //$NON-NLS-1$
 							+ " is not choice node"); //$NON-NLS-1$
 				// create controls for each namespace that has multiple
 				// exporters connected.
 				new Label(composite, SWT.NONE).setText(Messages
 						.getString("SOURCE_NAMESPACE")); //$NON-NLS-1$
 				final Label ns = new Label(composite, SWT.NONE);
 				ns.setText(StringUtils.defaultString(target));
 				final NamespaceType nsType = EuromathConfig
 						.getNamespace(target);
 				if ((nsType != null) && (nsType.getDesc() != null)) {
 					ns.setToolTipText(nsType.getDesc());
 				}
 				new Label(composite, SWT.NONE).setText(Messages
 						.getString("EXPORTERS")); //$NON-NLS-1$
 				final ComboAndValue combo = new ComboAndValue(children);
 				// register the combobox
 				Map<String, ComboAndValue> map = graphChoices.get(graph);
 				if (map == null) {
 					map = new HashMap<String, ComboAndValue>();
 					graphChoices.put(graph, map);
 				}
 				map.put(StringUtils.defaultString(target), combo);
 			}
 		}
 	}
 	/***
 	 * Creates controls for source document namespace processing tuning.
 	 * @param graph offer this graph to user. Must not be empty.
 	 */
 	private void createNamespaceOptionsControls(final ExportGraph graph) {
 		for (final GraphNode node : graph.getAllNodes()) {
 			if (node.info != null)
 				throw new IllegalArgumentException("Node " + node //$NON-NLS-1$
 						+ " does not represent source document node"); //$NON-NLS-1$
 			new Label(composite, SWT.NONE).setText(Messages
 					.getString("DOCUMENT_NAMESPACE")); //$NON-NLS-1$
 			final Label ns = new Label(composite, SWT.NONE);
 			ns.setText(StringUtils.defaultString(node.targetNamespace));
 			final NamespaceType nsType = EuromathConfig
 					.getNamespace(node.targetNamespace);
 			if ((nsType != null) && (nsType.getDesc() != null)) {
 				ns.setToolTipText(nsType.getDesc());
 			}
 			final CheckboxAndValue cb = new CheckboxAndValue(composite, !graph
 					.isRegular(node), node.targetNamespace);
 			wildcardCheckboxes.put(StringUtils
 					.defaultString(node.targetNamespace), cb);
 		}
 	}
 	/***
 	 * Computes and returns all choice nodes that the user can edit using this
 	 * widget.
 	 * @param graph the export graph. Should be able to transform whole
 	 * document.
 	 * @return never <code>null</code>. A map of choice nodes. If empty then
 	 * there are no choice points.
 	 */
 	public static Map<GraphNode, Set<String>> getEditableChoices(
 			final ExportGraph graph) {
 		Map<GraphNode, Set<String>> result = new HashMap<GraphNode, Set<String>>();
 		for (final GraphNode node : graph.getRegularNodes()) {
 			scanGraph(node, result);
 		}
 		return result;
 	}
 	/***
 	 * Scans the graph for a choice node. If such node is found then it is
 	 * registered into the {@link #graphChoices} map and the scan continues.
 	 * Descendants of the choice node are not searched for the choice nodes.
 	 * @param graph graph to analyze.
 	 * @param editableChoices put all choice nodes here.
 	 */
 	protected static void scanGraph(final GraphNode graph,
 			final Map<GraphNode, Set<String>> editableChoices) {
 		for (final String target : graph.getResultNamespaces()) {
 			final List<GraphNode> children = graph.getTargets(target);
 			if ((children == null) || (children.isEmpty())) {
 				// this node emits this output to the controller. ignore.
 			} else if (children.size() > 1) {
 				// we have found a choice node. register it into editableChoices
 				Set<String> targets = editableChoices.get(graph);
 				if (targets == null) {
 					targets = new HashSet<String>();
 					editableChoices.put(graph, targets);
 				}
 				targets.add(StringUtils.defaultString(target));
 				// do not walk through children
 			} else if (children.size() == 1) {
 				// not a choice node. try its children.
 				final GraphNode child = children.get(0);
 				scanGraph(child, editableChoices);
 			}
 		}
 	}
 	/***
 	 * Graph provided to the constructor.
 	 */
 	protected final ExportGraph graph;
 	/***
 	 * Contains choices in graphs. Maps graph node instance and a namespace
 	 * string to a combobox instance. Combo allows to select one of the graph
 	 * node children.
 	 */
 	protected final IdentityHashMap<GraphNode, Map<String, ComboAndValue>> graphChoices = new IdentityHashMap<GraphNode, Map<String, ComboAndValue>>();
 	/***
 	 * Contains all wildcard checkboxes. If this checkbox is checked then the
 	 * namespace is transmitted to receiver as a tree representation, it is not
 	 * exported normally.
 	 */
 	protected final Map<String, CheckboxAndValue> wildcardCheckboxes = new HashMap<String, CheckboxAndValue>();
 	/***
 	 * Maintains combobox selection index even when combobox is disposed.
 	 * @author Martin Vysny
 	 */
 	private final class ComboAndValue {
 		/***
 		 * Combobox instance.
 		 */
 		public final Combo combo;
 		/***
 		 * Selection.
 		 */
 		private int selection = 0;
 		/***
 		 * Constructor.
 		 * @param children we may choose from these child nodes.
 		 */
 		public ComboAndValue(List<GraphNode> children) {
 			super();
 			combo = new Combo(composite, SWT.DROP_DOWN | SWT.READ_ONLY);
 			final GridData data = new GridData(SWT.CENTER, SWT.LEFT, false,
 					true);
 			combo.setLayoutData(data);
 			// fill the combobox with all exporters
 			final String[] comboItems = new String[children.size()];
 			for (int i = 0; i < children.size(); i++) {
 				comboItems[i] = children.get(i).info.displayableName;
 			}
 			combo.setItems(comboItems);
 			combo.select(0);
 			combo.addDisposeListener(new DisposeListener() {
 				/*
 				 * (non-Javadoc)
 				 * @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent)
 				 */
 				public void widgetDisposed(DisposeEvent e) {
 					selection = combo.getSelectionIndex();
 				}
 			});
 			combo.addModifyListener(new ModifyListener() {
 				/*
 				 * (non-Javadoc)
 				 * @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent)
 				 */
 				public void modifyText(ModifyEvent e) {
 					fireDataModified();
 				}
 			});
 		}
 		/***
 		 * Returns combobox selection index.
 		 * @return the selection index.
 		 */
 		public int getSelectionIndex() {
 			if (!combo.isDisposed())
 				return combo.getSelectionIndex();
 			return selection;
 		}
 	}
 	/***
 	 * Maintains wildcard selection checkbox and its value even when the
 	 * checkbox is disposed.
 	 * @author Martin Vysny
 	 */
 	private final class CheckboxAndValue {
 		/***
 		 * The checkbox.
 		 */
 		public final Button checkbox;
 		/***
 		 * Checkbox value.
 		 */
 		private boolean checked;
 		/***
 		 * Constructor.
 		 * @param composite where the checkbox is placed.
 		 * @param alwaysChecked if true then checkbox is disabled and always
 		 * checked.
 		 * @param namespace the namespace. Set as data property of the checkbox.
 		 */
 		public CheckboxAndValue(final Composite composite,
 				final boolean alwaysChecked, final String namespace) {
 			super();
 			checkbox = new Button(composite, SWT.CHECK);
 			checkbox.setText(Messages.getString("USE_TREE_REPRESENTATION")); //$NON-NLS-1$
 			checkbox.setLayoutData(new GridData(SWT.BEGINNING, SWT.CENTER,
 					true, false, 2, 1));
 			checkbox.setData(namespace);
 			if (alwaysChecked) {
 				checkbox.setSelection(true);
 				checkbox.setEnabled(false);
 			}
 			checkbox.addSelectionListener(new SelectionAdapter() {
 				/*
 				 * (non-Javadoc)
 				 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
 				 */
 				@Override
 				public void widgetSelected(SelectionEvent e) {
 					enableChoiceSelectors();
 					fireDataModified();
 				}
 			});
 			checkbox.addDisposeListener(new DisposeListener() {
 				/*
 				 * (non-Javadoc)
 				 * @see org.eclipse.swt.events.DisposeListener#widgetDisposed(org.eclipse.swt.events.DisposeEvent)
 				 */
 				public void widgetDisposed(DisposeEvent e) {
 					checked = checkbox.getSelection();
 				}
 			});
 		}
 		/***
 		 * Tests if checkbox is checked.
 		 * @return <code>true</code> if checkbox is checked.
 		 */
 		public boolean isChecked() {
 			if (!checkbox.isDisposed())
 				return checkbox.getSelection();
 			return checked;
 		}
 		/***
 		 * Enables or disables comboboxes selecting choice nodes, that would
 		 * actually get replaced by a wildcard exporter when this checkbox is
 		 * checked.
 		 */
 		private void enableChoiceSelectors() {
 			final String namespace = StringUtils
 					.defaultString((String) checkbox.getData());
 			final boolean checked = isChecked();
 			// enable/disable all choice nodes that are descendants of node
 			// reading from 'namespace'
 			final GraphNode node = graph.getAllNodesAsMap().get(namespace);
 			assert node != null;
 			for (final GraphNode choiceNode : graphChoices.keySet()) {
 				if (choiceNode.equals(node) || node.isAscendantOf(choiceNode)) {
 					// enable/disable it.
 					for (final ComboAndValue combo : graphChoices.get(
 							choiceNode).values()) {
 						combo.combo.setEnabled(!checked);
 					}
 				}
 			}
 		}
 	}
 	/***
 	 * <p>
 	 * Processes actual selection and returns exact transformation tree. Each
 	 * transformation info is produced from appropriate graph node: i-th info is
 	 * produced from i-th graphlist item.
 	 * </p>
 	 * <p>
 	 * Not all choice nodes are made selectable; if a choice node is not
 	 * selectable then simply the first exporter is selected.
 	 * </p>
 	 * @param info the coordinator info object.
 	 * @return list of transformation infos.
 	 * @throws ExportException if exporter fails to initialize.
 	 * @throws IOException if i/o error occurs.
 	 */
 	public TransformGraph getTransformationInfo(final CoordinatorInfo info)
 			throws ExportException, IOException {
 		final IGraphEdgeSelector userSelector = new ComboGraphEdgeSelector();
 		final ExportGraphBuilder builder = new ExportGraphBuilder();
 		final List<GraphNode> allNodes = graph.getAllNodes();
 		final TransformGraph result = new TransformGraph();
 		// convert all graph nodes to transformation info instance.
 		for (GraphNode node : allNodes) {
 			// if user wishes to export the namespace using wildcard exporter,
 			// then replace this node with a wildcard node. This is needed only
 			// when this node is a regular node.
 			final String ns = StringUtils.defaultString(node.targetNamespace);
 			if (graph.isRegular(node) && wildcardCheckboxes.get(ns).isChecked()) {
 				node = builder.newWildcardGraphNode(node.targetNamespace,
 						EnumSet.of(ResultEnum.DOM), info);
 			}
 			final TransformNode ti = builder.toTransformationInfo(node, info,
 					userSelector);
 			if (ti == null)
 				result.addDirectPipe(ns, true);
 			else
 				result.add(ti, true);
 		}
 		return result;
 	}
 	/***
 	 * Selects the outgoing edge depending on the value of the combobox, if
 	 * registered.
 	 * @author Martin Vysny
 	 */
 	private final class ComboGraphEdgeSelector implements IGraphEdgeSelector {
 		/*
 		 * (non-Javadoc)
 		 * @see sk.uniba.euromath.api.export.graph.IGraphEdgeSelector#getChildNode(sk.uniba.euromath.api.export.graph.GraphNode,
 		 * java.lang.String)
 		 */
 		public int getChildNode(GraphNode node, String namespace) {
 			final Map<String, ComboAndValue> map = graphChoices.get(node);
 			if (map == null)
 				return 0;
 			final ComboAndValue combo = map.get(namespace);
 			if (combo == null)
 				return 0;
 			return combo.getSelectionIndex();
 		}
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.widgets.IUserInputWidget#getComposite()
 	 */
 	public Composite getComposite() {
 		return composite;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.widgets.IUserInputWidget#getLastError()
 	 */
 	public ValidityMessages getMessages() {
 		// component is always valid
 		return null;
 	}
 	/***
 	 * The state of the widget.
 	 * @author Martin Vysny
 	 */
 	public class State {
 		/***
 		 * Selects correct nodes when a choice of nodes is available.
 		 */
 		public final IGraphEdgeSelector nodeSelector;
 		/***
 		 * List of namespaces explicitly selected as wildcards.
 		 */
 		public final Set<String> wildcards = new HashSet<String>();
 		private State() {
 			super();
 			nodeSelector = new ComboGraphEdgeSelector();
 			final List<GraphNode> allNodes = graph.getAllNodes();
 			for (final GraphNode node : allNodes) {
 				final String ns = StringUtils
 						.defaultString(node.targetNamespace);
 				if (wildcardCheckboxes.get(ns).isChecked())
 					wildcards.add(ns);
 			}
 		}
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.widgets.IUserInputWidget#getState()
 	 */
 	public Object getState() {
 		return new State();
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.widgets.IUserInputWidget#getStateClass()
 	 */
 	public Class< ? > getStateClass() {
 		return State.class;
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.widgets.IUserInputWidget#setState(java.lang.Object)
 	 */
 	public void setState(Object state) {
 		throw new UnsupportedOperationException();
 	}
 }