/*
    * Created on Mar 11, 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.util.ArrayList;
  import java.util.Collections;
  import java.util.List;
  import java.util.Set;
  import javax.xml.namespace.QName;
  import org.apache.commons.lang.StringUtils;
  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.events.SelectionListener;
  import org.eclipse.swt.layout.GridData;
  import org.eclipse.swt.layout.GridLayout;
  import org.eclipse.swt.widgets.Combo;
  import org.eclipse.swt.widgets.Composite;
  import org.eclipse.swt.widgets.Label;
  import org.eclipse.swt.widgets.TabFolder;
  import org.eclipse.swt.widgets.TabItem;
  import org.eclipse.swt.widgets.Text;
  import sk.uniba.euromath.document.NamespaceManager;
  import sk.uniba.euromath.document.XMLAccess;
  import sk.uniba.euromath.document.schema.AttributeListRule;
  import sk.uniba.euromath.document.schema.AttributeRule;
  import sk.uniba.euromath.document.schema.INameList;
  import sk.uniba.euromath.editor.lang.Messages;
  import sk.uniba.euromath.editor.widgets.namelist.DisplayableNameItemTypeEnum;
  import sk.uniba.euromath.editor.widgets.namelist.DisplayableNameListImpl;
  /***
   * Manages the process of creating new attributes into newly created element.
   * Attributes themselves are not created, their names and values are returned
   * instead.
   * @author Martin Vysny
   */
  public class CreateAttributeList extends AbstractUserInputWidget {
  	/***
  	 * All controls are placed here.
  	 */
  	protected final Composite composite;
  	/***
  	 * Document instance.
  	 */
  	public final XMLAccess xmlAccess;
  	/***
  	 * Namespace manager.
  	 */
  	public final NamespaceManager currentManager;
  	/***
  	 * Name of parent element; used only to display the name on the shell.
  	 */
  	public final String parentName;
  	/***
  	 * Constructs the instance of the window.
  	 * @param parent the parent composite.
  	 * @param listRules the list of lists of attribute. Exactly one list will be
  	 * chosen.
  	 * @param parentName the name of the parent element. Used only to display
  	 * the name on the shell.
  	 * @param xmlAccess the xml document instance.
  	 * @param currentManager the current manager.
  	 */
  	public CreateAttributeList(Composite parent,
  			List<AttributeListRule> listRules, String parentName,
  			XMLAccess xmlAccess, NamespaceManager currentManager) {
  		super();
  		if (listRules.size() == 0)
  			throw new IllegalArgumentException(
  					"The listRules array must contain at least one item."); //$NON-NLS-1$
  		this.xmlAccess = xmlAccess;
  		this.currentManager = currentManager;
  		this.parentName = parentName;
  		// create the composite
  		composite = new Composite(parent, SWT.NONE);
  		composite.setLayout(new GridLayout(1, false));
  		composite.setLayoutData(new GridData(SWT.FILL, SWT.FILL, false, false));
  		new Label(composite, SWT.NONE).setText(Messages.getString(
  				"SELECT_LIST_OF_ATTRIBUTES", parentName)); //$NON-NLS-1$
  		tabFolder = new TabFolder(composite, SWT.TOP);
  		// create the controls
  		nameControls = new ArrayList<List<NameControls>>(listRules.size());
  		int tabOrder = 0;
  		for (final AttributeListRule listRule : listRules) {
  			final TabItem item = new TabItem(tabFolder, SWT.NONE);
  			// all controls in one tab shall be placed onto this panel
  			final Composite panel = new Composite(tabFolder, SWT.NONE);
 			panel.setLayout(new GridLayout(2, false));
 			item.setControl(panel);
 			item
 					.setText(Messages.getString("SET") + Integer.toString(++tabOrder)); //$NON-NLS-1$
 			// create the controls and place them on 'panel'
 			final List<INameList<AttributeRule>> nameLists = listRule.getList();
 			final List<NameControls> oneTabControls = new ArrayList<NameControls>(
 					nameLists.size());
 			for (INameList<AttributeRule> nameList : nameLists) {
 				// small panel containing controls for one attribute
 				new Label(panel, SWT.NONE).setText(Messages
 						.getString("NAME_MARK")); //$NON-NLS-1$
 				final Combo comboName = new Combo(panel, SWT.READ_ONLY);
 				comboName.setLayoutData(new GridData(SWT.FILL, SWT.CENTER,
 						true, false));
 				comboName.addSelectionListener(selectionListener);
 				new Label(panel, SWT.NONE).setText(Messages
 						.getString("VALUE_MARK")); //$NON-NLS-1$
 				final Text value = new Text(panel, SWT.SINGLE | SWT.BORDER);
 				value.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true,
 						false));
 				value.setEnabled(false);
 				value.addModifyListener(modifyListener);
 				final Label l = new Label(panel, SWT.NONE);
 				l.setText(Messages.getString("VALUE_TYPE_MARK")); //$NON-NLS-1$
 				l.setLayoutData(new GridData(SWT.BEGINNING, SWT.BEGINNING,
 						false, false));
 				final Label valueType = new Label(panel, SWT.WRAP);
 				final GridData valueTypeGD = new GridData(SWT.FILL, SWT.FILL,
 						true, true);
 				valueTypeGD.widthHint = 300;
 				valueTypeGD.heightHint = 50;
 				valueType.setLayoutData(valueTypeGD);
 				valueType.setText(Messages.getString("NON_APPLICABLE")); //$NON-NLS-1$
 				final NameControls nc = new NameControls(comboName, value,
 						valueType, nameList);
 				comboName.setItems(nc.dnl.getStrings());
 				oneTabControls.add(nc);
 				comboName.setData(nc);
 				comboName.addModifyListener(cnmInstance);
 			}
 			nameControls.add(oneTabControls);
 		}
 		tabFolder.addSelectionListener(selectionListener);
 		fillData();
 	}
 	/***
 	 * Captures component changes events.
 	 */
 	private final ModifyListener modifyListener = new ModifyListener() {
 		/*
 		 * (non-Javadoc)
 		 * @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent)
 		 */
 		public void modifyText(ModifyEvent e) {
 			fillData();
 			fireDataModified();
 		}
 	};
 	/***
 	 * Captures component changes events.
 	 */
 	private final SelectionListener selectionListener = new SelectionAdapter() {
 		/*
 		 * (non-Javadoc)
 		 * @see org.eclipse.swt.events.SelectionListener#widgetSelected(org.eclipse.swt.events.SelectionEvent)
 		 */
 		@Override
 		public void widgetSelected(SelectionEvent e) {
 			fillData();
 			fireDataModified();
 		}
 	};
 	/***
 	 * Contains links to controls. First index is the index to
 	 * <code>listRules</code>, second points to appropriate
 	 * <code>AttributeListRule</code>.
 	 */
 	private List<List<NameControls>> nameControls;
 	/***
 	 * Contains links to controls. Grabs the values from controls when control
 	 * is disposed.
 	 * @author Martin Vysny
 	 */
 	private class NameControls {
 		/***
 		 * Attribute name selector.
 		 */
 		private final Combo comboName;
 		/***
 		 * Attribute value text box.
 		 */
 		private final Text value;
 		/***
 		 * Prints the datatype of allowed contents of attribute value.
 		 */
 		private final Label valueType;
 		/***
 		 * Namelist; datasource for the name selector combobox.
 		 */
 		final DisplayableNameListImpl<AttributeRule> dnl;
 		/***
 		 * Constructs the instance.
 		 * @param comboName attribute name selector.
 		 * @param value attribute value text box.
 		 * @param valueType prints the datatype of allowed contents of attribute
 		 * value.
 		 * @param nameList namelist; datasource for the name selector combobox.
 		 */
 		private NameControls(Combo comboName, Text value, Label valueType,
 				INameList<AttributeRule> nameList) {
 			super();
 			this.comboName = comboName;
 			this.value = value;
 			this.valueType = valueType;
 			this.dnl = new DisplayableNameListImpl<AttributeRule>(nameList,
 					xmlAccess, currentManager, false);
 			comboName.addDisposeListener(new DisposeListener() {
 				public void widgetDisposed(DisposeEvent e) {
 					_attributeNameIndex = NameControls.this.comboName
 							.getSelectionIndex();
 				}
 			});
 			value.addDisposeListener(new DisposeListener() {
 				public void widgetDisposed(DisposeEvent e) {
 					_value = NameControls.this.value.getText();
 				}
 			});
 		}
 		/***
 		 * Returns the attribute name index.
 		 * @return selected attribute name.
 		 */
 		private int getAttributeNameIndex() {
 			if (comboName.isDisposed())
 				return _attributeNameIndex;
 			return comboName.getSelectionIndex();
 		}
 		/***
 		 * Valid when combobox is disposed.
 		 */
 		private int _attributeNameIndex;
 		/***
 		 * Returns the attribute value.
 		 * @return the attribute value.
 		 */
 		private String getValue() {
 			if (value.isDisposed())
 				return _value;
 			return value.getText();
 		}
 		/***
 		 * Valid when the textbox is disposed.
 		 */
 		private String _value;
 	}
 	/***
 	 * The tab folder, where all attribute-related controls are stored.
 	 */
 	protected TabFolder tabFolder;
 	/***
 	 * Change listener, listens to the attribute name selector combobox. On
 	 * change updates the datatype name of selected attribute, and loads schema
 	 * if namespace is selected.
 	 * @author Martin Vysny
 	 */
 	private class ComboNameModified implements ModifyListener {
 		/*
 		 * (non-Javadoc)
 		 * @see org.eclipse.swt.events.ModifyListener#modifyText(org.eclipse.swt.events.ModifyEvent)
 		 */
 		public void modifyText(ModifyEvent e) {
 			// identify the controls involved.
 			Combo sender = (Combo) e.widget;
 			NameControls nc = (NameControls) e.widget.getData();
 			int sel = sender.getSelectionIndex();
 			if (sel < 0) {
 				nc.value.setEnabled(false);
 				nc.valueType.setText(Messages.getString("NON_APPLICABLE")); //$NON-NLS-1$
 				return;
 			}
 			DisplayableNameItemTypeEnum type = nc.dnl.getType(sel);
 			nc.value
 					.setEnabled((type == DisplayableNameItemTypeEnum.ITEM_LOCAL)
 							|| (type == DisplayableNameItemTypeEnum.ITEM_FOREIGN));
 			if (type != DisplayableNameItemTypeEnum.ITEM_NAMESPACE) {
 				// ordinary qname was chosen, process it normally
 				AttributeRule rule = nc.dnl.getRule(sel);
 				nc.valueType.setText(rule.getDatatypeName());
 				fireDataModified();
 				return;
 			}
 			// a namespace was selected for which the schema is not yet loaded.
 			String ns = nc.dnl.getNamespace(sel);
 			nc.valueType.setText(Messages.getString("NON_APPLICABLE")); //$NON-NLS-1$
 			if (!Tools.loadSchema(sender.getShell(), xmlAccess.getSchema()
 					.getRefs(), ns))
 				return;
 			// Recreate all namelists, update all combos
 			update();
 			fireDataModified();
 		}
 	}
 	/***
 	 * Single instance of the listener.
 	 */
 	private final ComboNameModified cnmInstance = new ComboNameModified();
 	/***
 	 * Recreates all namelists and updates all combo boxes.
 	 */
 	protected void update() {
 		// update all combos
 		for (final List<NameControls> tabControls : nameControls) {
 			for (final NameControls nc : tabControls) {
 				int item = nc.comboName.getSelectionIndex();
 				if ((item >= 0)
 						&& (item < nc.dnl.getLength())
 						&& (nc.dnl.getType(item) == DisplayableNameItemTypeEnum.ITEM_LOCAL)) {
 					// ok, combobox is scrolled on local name, leave it be
 				} else {
 					// combobox points onto item that is likely to be moved,
 					// reset it
 					item = -1;
 				}
 				nc.dnl.refresh();
 				nc.comboName.setItems(nc.dnl.getStrings());
 				nc.comboName.select(item);
 			}
 		}
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.widgets.IEncapsulatesComposite#getComposite()
 	 */
 	public Composite getComposite() {
 		return composite;
 	}
 	/***
 	 * List of chosen attribute names.
 	 */
 	protected List<QName> _names = null;
 	/***
 	 * List of chosen attribute values.
 	 */
 	protected List<String> _values = null;
 	/***
 	 * Returns names of actually selected attributes. On error, function sets
 	 * error message and returns <code>null</code>.
 	 * @return list of names, or <code>null</code> if {@link #fillData()}
 	 * fails.
 	 */
 	public List<QName> getNames() {
 		if (_names == null)
 			return null;
 		return Collections.unmodifiableList(_names);
 	}
 	/***
 	 * Returns text values of attributes. On error, function sets error message
 	 * and returns <code>null</code>.
 	 * @return list containing text values of attributes. <code>null</code> if
 	 * {@link #fillData()} fails.
 	 */
 	public List<String> getValues() {
 		if (_values == null)
 			return null;
 		return Collections.unmodifiableList(_values);
 	}
 	/***
 	 * Errors that occured during last <code>fillData()</code> call.
 	 */
 	protected ValidityMessages lastMessages = null;
 	/***
 	 * <p>
 	 * Fills the <code>_names</code>, <code>_values</code> lists and the
 	 * <code>_namespaces</code> set. The tab control must not yet be disposed.
 	 * </p>
 	 * <p>
 	 * If any combobox does not have name selected then function fails - it sets
 	 * both lists to <code>null</code> and exits, returning non-<code>null</code>
 	 * error message. If any attribute has illegal value, then function sets
 	 * error message and fails.
 	 * </p>
 	 */
 	protected void fillData() {
 		lastMessages = null;
 		int listRuleIndex = tabFolder.getSelectionIndex();
 		List<NameControls> controls = nameControls.get(listRuleIndex);
 		_names = new ArrayList<QName>(controls.size());
 		_values = new ArrayList<String>(controls.size());
 		// get all data. Ignore custom prefix entering for now; they can be
 		// changed using other wizard page.
 		for (NameControls nc : controls) {
 			// get the chosen index
 			int nameIndex = nc.getAttributeNameIndex();
 			if (nameIndex < 0) {
 				_names = null;
 				_values = null;
 				lastMessages = new ValidityMessages(Messages
 						.getString("SELECT_ALL_NAMES")); //$NON-NLS-1$
 				return;
 			}
 			assert nc.dnl.hasRule(nameIndex);
 			// verify if the textual value obeys the rule
 			AttributeRule rule = nc.dnl.getRule(nameIndex);
 			if (!rule.acceptsValue(nc.getValue())) {
 				_names = null;
 				_values = null;
 				String errorMsg = rule.getErrorMessage(nc.value.getText());
 				errorMsg = Messages.getString("INVALID_ATTRIBUTE_VALUE_NAME", //$NON-NLS-1$
 						nc.dnl.getStrings()[nameIndex])
 						+ (StringUtils.isEmpty(errorMsg) ? "" : " " //$NON-NLS-1$ //$NON-NLS-2$
 								+ errorMsg);
 				lastMessages = new ValidityMessages(errorMsg);
 				return;
 			}
 			// everything ok, append attribute information to the lists
 			_values.add(nc.getValue());
 			String prefix = currentManager.getPrefix(nc.dnl
 					.getDomNamespaceUri(nameIndex));
 			_names.add(nc.dnl.getDomQName(nameIndex, prefix));
 		}
 		// exit succesfully
 	}
 	/*
 	 * (non-Javadoc)
 	 * @see sk.uniba.euromath.editor.widgets.IUserInputWidget#getLastError()
 	 */
 	public ValidityMessages getMessages() {
 		return lastMessages;
 	}
 	/***
 	 * Retrieves all namespaces of currently selected attributes.
 	 * @return all namespaces of the attributes. If there are errors on the
 	 * page, the function may return <code>null</code> or incomplete set.
 	 */
 	public Set<String> getAllNamespaces() {
 		List<QName> qnames = getNames();
 		if (qnames == null)
 			return null;
 		return NewPrefixesQuery.getNamespaces(qnames);
 	}
 	/***
 	 * Current state of the widget.
 	 * @author Martin Vysny
 	 */
 	public class State {
 		/***
 		 * Text values of attributes. May be <code>null</code> if there are
 		 * validity errors on the widget.
 		 */
 		public final List<String> values;
 		/***
 		 * Names of currently selected attributes. May be <code>null</code> if
 		 * there are validity errors on the widget.
 		 */
 		public final List<QName> names;
 		/***
 		 * Constructs new state.
 		 */
 		State() {
 			super();
 			values = getValues();
 			names = getNames();
 		}
 	}
 	/*
 	 * (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();
 	}
 }