EDIT

/**

 * Copyright (C) 2007 EDIT

 * European Distributed Institute of Taxonomy 

 * http://www.e-taxonomy.eu

 * 

 * The contents of this file are subject to the Mozilla Public License Version 1.1

 * See LICENSE.TXT at the top of this package for the full license terms.

 */

package eu.etaxonomy.taxeditor.propertysheet.namerelations.wizard;

import java.beans.PropertyChangeEvent;

import java.beans.PropertyChangeListener;

import java.util.ArrayList;

import java.util.List;

import org.apache.log4j.Logger;

import org.eclipse.core.databinding.observable.list.WritableList;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.swt.SWT;

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.Button;

import org.eclipse.swt.widgets.Combo;

import org.eclipse.swt.widgets.Composite;

import org.eclipse.swt.widgets.Group;

import org.eclipse.swt.widgets.Label;

import eu.etaxonomy.cdm.model.name.NameRelationship;

import eu.etaxonomy.cdm.model.name.NameRelationshipType;

import eu.etaxonomy.cdm.model.name.TaxonNameBase;

import eu.etaxonomy.cdm.model.name.ZoologicalName;

import eu.etaxonomy.cdm.model.reference.ReferenceBase;

import eu.etaxonomy.taxeditor.editor.name.NameSelectComposite;

import eu.etaxonomy.taxeditor.editor.reference.ReferenceSelectComposite;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.model.NameRelationsUtil;

import eu.etaxonomy.taxeditor.store.model.NameUtil;

/**

 * An all-in-one relation wizard page where the user chooses a related name, a

 * relationship type, and the relation's directionality.

 * 

 * @author p.ciardelli

 * @created 04.06.2008

 * @version 1.0

 */

public class ChooseRelationWizardPage extends WizardPage {

	private static final Logger logger = Logger

			.getLogger(ChooseRelationWizardPage.class);

	private List<NameRelationshipType> relationTypes;

	private Combo typeCombo;

	private Label lblDirection;

	private Button btnFromRelatedToBase;

	private Button btnFromBaseToRelated;

	private boolean typeSelected = false;

	private boolean directionSelected = false;

	private SelectionListener radioSelectionListener = new SelectionAdapter() {

		public void widgetSelected(SelectionEvent e) {

			directionSelected = true;

			if (e.widget.equals(btnFromRelatedToBase)) {

				fromName = relatedName;

				toName = baseName;

			}

			if (e.widget.equals(btnFromBaseToRelated)) {

				fromName = baseName;

				toName = relatedName;

			}

			updatePage();

		}

	};

	private NameSelectComposite nameComposite;

	private boolean nameSelected;

	private TaxonNameBase baseName;

	private TaxonNameBase relatedName; 

	private TaxonNameBase fromName;

	private TaxonNameBase toName;

	private NameRelationshipType type;

	private Label lblType;

	private ReferenceSelectComposite referenceComposite;

	private WritableList nameRelationsList;

	public ChooseRelationWizardPage(TaxonNameBase name, WritableList nameRelationsList) {

		super("");

		this.baseName = name;

		this.nameRelationsList = nameRelationsList;

		setTitle("Create name relationship.");	

		setDescription("Create a relationship for  \""

				+ NameUtil.getDisplayName(baseName) + "\".");

	}

	public void createControl(Composite parent) {

		Composite container = new Composite(parent, SWT.NULL);

		container.setLayout(new GridLayout());

		setControl(container);

		// Create name input composite

		nameComposite = new NameSelectComposite(container);

		nameComposite.addPropertyChangeListener(new PropertyChangeListener() {

			public void propertyChange(PropertyChangeEvent evt) {

				setName();

			}

		});

		// Init relation type array

		relationTypes = new ArrayList<NameRelationshipType>();

		//

		lblType = new Label(container, SWT.NONE);

		lblType.setText("Choose relationship type:");

		// Create relation type dropdown 

		typeCombo = new Combo(container, SWT.BORDER);

		typeCombo.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

		for (NameRelationshipType relationType : 

				CdmStore.getDefault().getNameRelationshipTypes()) {

			relationTypes.add(relationType);

			boolean isZoological = baseName instanceof ZoologicalName;

			String label = NameRelationsUtil.getNameRelationTypeLabel(relationType, isZoological);

			typeCombo.add(label);

		}

		typeCombo.setVisibleItemCount(relationTypes.size());

		typeCombo.addSelectionListener(new SelectionAdapter() {

			@Override

			public void widgetSelected(SelectionEvent e) {

				setType();

			}

		});

		typeCombo.setEnabled(false);

		final Group group = new Group(container, SWT.NONE);

		group.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

		final GridLayout gridLayout = new GridLayout();

		group.setLayout(gridLayout);

		lblDirection = new Label(group, SWT.NONE);

		final GridData gd_lblDirection = new GridData(SWT.FILL, SWT.CENTER, true, false);

		gd_lblDirection.heightHint = 32;

		gd_lblDirection.minimumHeight = 40;

		lblDirection

				.setLayoutData(gd_lblDirection);

		lblDirection.setEnabled(false);

		lblDirection.setText("Choose relationship direction:");

		btnFromRelatedToBase = new Button(group, SWT.RADIO);

		btnFromRelatedToBase

				.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

		btnFromRelatedToBase.setVisible(false);

		btnFromRelatedToBase.addSelectionListener(radioSelectionListener);

		btnFromBaseToRelated = new Button(group, SWT.RADIO);

		btnFromBaseToRelated

				.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false));

		btnFromBaseToRelated.setVisible(false);

		btnFromBaseToRelated.addSelectionListener(radioSelectionListener);

		new Label(group, SWT.NONE);

		// Create reference input composite

		referenceComposite = new ReferenceSelectComposite(container);

	}

	/**

	 */

	private void setName() {

		nameSelected = nameComposite.getName() == null ? false : true;

		if (nameSelected) {

			this.relatedName = nameComposite.getName();

		} else {

			this.relatedName = null;

		}

		updatePage();

	}

	/**

	 * 

	 */

	private void setType() {

		int typeIndex = typeCombo.getSelectionIndex();

		type = relationTypes.get(typeIndex);

		typeSelected = true;

		updatePage();

	}

	private void setDirectionLabels() {

		String strDirection1 = "\"" + NameUtil.getDisplayName(relatedName) + "\" "

				+ "is " + typeCombo.getText() + " " + "\""

				+ NameUtil.getDisplayName(baseName) + "\"";

		String strDirection2 = "\"" + NameUtil.getDisplayName(baseName) + "\" "

				+ "is " + typeCombo.getText() + " " + "\""

				+ NameUtil.getDisplayName(relatedName) + "\"";

		btnFromRelatedToBase.setText(strDirection1);

		btnFromBaseToRelated.setText(strDirection2);		

	}

	@Override

	public boolean canFlipToNextPage() {

		return isPageComplete();

	}

    public boolean isPageComplete() {

        return (nameSelected && typeSelected && directionSelected);

    }

	private void updatePage() {

		if (nameSelected) {

			enableType(true);

			if (typeSelected) {

				enableDirection(true);

			} else {

				enableDirection(false);

			}

		} else {

			enableType(false);

			enableDirection(false);

		}

		getWizard().getContainer().updateButtons();

	}

	private void enableType(boolean enabled) {

		lblType.setEnabled(enabled);

		typeCombo.setEnabled(enabled);

	}

	private void enableDirection(boolean enabled) {

		if (enabled) {

			setDirectionLabels();

		} else {

//			directionSelected = false;

		}

		lblDirection.setEnabled(enabled);

		btnFromRelatedToBase.setEnabled(enabled);

		btnFromBaseToRelated.setEnabled(enabled);

		btnFromRelatedToBase.setVisible(enabled);

		btnFromBaseToRelated.setVisible(enabled);

	}

	/* (non-Javadoc)

	 * @see org.eclipse.jface.wizard.WizardPage#setPageComplete(boolean)

	 */

	public void setPageComplete(boolean complete) {

        super.setPageComplete(complete);

        // Add a new relation to the list

        if (complete) {

        	NameRelationship relation = new TemporaryNameRelationship(

        			toName, fromName, type, referenceComposite.getReference(), 

        			referenceComposite.getMicroReference(), null);

        	nameRelationsList.add(relation);

        }

	}

	public class TemporaryNameRelationship extends NameRelationship {

		private TaxonNameBase tempToName;

		private TaxonNameBase tempFromName;

		private NameRelationshipType tempType;

		private ReferenceBase tempCitation;

		private String tempCitationMicroReference;

		private String tempRuleConsidered;

		/**

		 * @param toName

		 * @param fromName

		 * @param type

		 * @param citation

		 * @param citationMicroReference

		 * @param ruleConsidered

		 */

		protected TemporaryNameRelationship(TaxonNameBase toName,

				TaxonNameBase fromName, NameRelationshipType type,

				ReferenceBase citation, String citationMicroReference,

				String ruleConsidered) {

			super(toName, fromName, type, citation, citationMicroReference, ruleConsidered);

//			super(null, null, null, null, null, null);

//			

//			this.tempToName = toName;

//			this.tempFromName = fromName;

//			this.tempType = type;

//			this.tempCitation = citation;

//			this.tempCitationMicroReference = citationMicroReference;

//			this.tempRuleConsidered = ruleConsidered;

		}

//		public TaxonNameBase getToName(){

//			return tempToName;

//		}

//		

//		public TaxonNameBase getFromName(){

//			return tempFromName;

//		}

//		

//		public String getRuleConsidered(){

//			return tempRuleConsidered;

//		}

	}

}