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.ui.section.reference;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import org.eclipse.swt.SWT;

import org.joda.time.DateTime;

import eu.etaxonomy.cdm.model.agent.Institution;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

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

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

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

import eu.etaxonomy.taxeditor.store.StoreUtil;

import eu.etaxonomy.taxeditor.ui.combo.EnumComboElement;

import eu.etaxonomy.taxeditor.ui.element.CdmFormFactory;

import eu.etaxonomy.taxeditor.ui.element.CdmPropertyChangeEvent;

import eu.etaxonomy.taxeditor.ui.element.DoiWithLabelElement;

import eu.etaxonomy.taxeditor.ui.element.ICdmFormElement;

import eu.etaxonomy.taxeditor.ui.element.IErrorIntolerableElement;

import eu.etaxonomy.taxeditor.ui.element.IExceptionHandler;

import eu.etaxonomy.taxeditor.ui.element.LsidWithExceptionLabelElement;

import eu.etaxonomy.taxeditor.ui.element.TextWithLabelElement;

import eu.etaxonomy.taxeditor.ui.element.ToggleableTextElement;

import eu.etaxonomy.taxeditor.ui.element.UriWithLabelElement;

import eu.etaxonomy.taxeditor.ui.element.VerbatimTimePeriodElement;

import eu.etaxonomy.taxeditor.ui.mvc.element.DateElement;

import eu.etaxonomy.taxeditor.ui.section.AbstractIdentifiableEntityDetailElement;

import eu.etaxonomy.taxeditor.ui.selection.EntitySelectionElement;

/**

 * ReferenceBaseDetailElement class.

 *

 * @author n.hoffmann

 * @created Mar 2, 2010

 */

public class ReferenceDetailElement extends AbstractIdentifiableEntityDetailElement<Reference>

		implements IErrorIntolerableElement, IExceptionHandler {

    private ToggleableTextElement toggleableAbbrevCache;

	private TextWithLabelElement text_edition;

	private TextWithLabelElement text_editor;

	private TextWithLabelElement text_isbn;

	private TextWithLabelElement text_issn;

	private TextWithLabelElement text_organisation;

	private TextWithLabelElement text_pages;

	private TextWithLabelElement text_placePublished;

	private TextWithLabelElement text_publisher;

	private TextWithLabelElement text_referenceAbstract;

	private TextWithLabelElement text_series;

//	private TextWithLabelElement text_seriesPart;

	private TextWithLabelElement text_volume;

	private TextWithLabelElement text_abbrevTitle;

	private TextWithLabelElement text_title;

	private DoiWithLabelElement text_doi;

	private UriWithLabelElement text_uri;

	private LsidWithExceptionLabelElement text_lsid;

	private DateElement text_accessed;

	private EntitySelectionElement<TeamOrPersonBase> selection_authorTeam;

	private VerbatimTimePeriodElement element_timePeriod;

	private EntitySelectionElement<Reference> selection_inReference;

	private EntitySelectionElement<Institution> selection_institution;

	private EnumComboElement<ReferenceType> combo_referenceType;

	private EntitySelectionElement<Reference> selection_inSeries;

	private boolean isWizard;

	/**

	 * Constructor for ReferenceBaseDetailElement.

	 */

	public ReferenceDetailElement(CdmFormFactory cdmFormFactory,

			ICdmFormElement formElement, int style) {

		super(cdmFormFactory, formElement);

	}

	@Override

	protected void createControls(ICdmFormElement formElement,

			Reference entity, int style) {

		setWarnForReferencingObjects(formElement);

		toggleable_cache = formFactory.createToggleableTextField(formElement,

				"Reference Cache", entity.getTitleCache(),

				entity.isProtectedTitleCache(), style);

		toggleableAbbrevCache = formFactory.createToggleableTextField(formElement,

		        "Nomencl. Cache", entity.getAbbrevTitleCache(),

		        entity.isProtectedAbbrevTitleCache(), style);

		combo_referenceType = formFactory.createEnumComboElement(ReferenceType.class,

						formElement, style);

		combo_referenceType.setSelection(entity.getType());

		// title

		text_title = formFactory.createMultiLineTextWithLabel(formElement,

				"Title",  60, style);

		text_title.setText(entity.getTitle());

		// abbreviated title

		text_abbrevTitle = formFactory.createTextWithLabelElement(formElement,

		        "Nomencl. Title", entity.getAbbrevTitle(), style);

		ReferenceType referenceType = entity.getType();

		// author team

		if(referenceType != null && !referenceType.equals(ReferenceType.Journal) && !referenceType.equals(ReferenceType.PrintSeries) ) {

            selection_authorTeam = formFactory

            		.createSelectionElement(TeamOrPersonBase.class,

            		        formElement, "Author",

            				entity.getAuthorship(),

            				EntitySelectionElement.ALL, style);

        }

		if (referenceType != null) {

			createInReferenceByType(this, referenceType, entity, SWT.NULL);

			if (referenceType.equals(ReferenceType.Generic)) {

				createGenericControls(this, entity, SWT.NULL);

				createPublicationControls(this, referenceType, entity, SWT.NULL);

			} else {

				if (referenceType.isPrintedUnit()) {

					createPrintedUnitControls(this, referenceType, entity,

							SWT.NULL);

				}

//				if (referenceType.equals(ReferenceType.Proceedings)) {

//				    text_isbn = formFactory.createTextWithLabelElement(this, "ISBN",

//		                    entity.getIsbn(), style);

//              }

				if (referenceType.isPublication()) {

					createPublicationControls(this, referenceType, entity,

							SWT.NULL);

				}

				if (referenceType.isVolumeReference()) {

					createVolumeControls(this, entity, SWT.NULL);

				}

				if (referenceType.isSection()) {

					createSectionControls(this, entity, SWT.NULL);

				}

			}

		}

		// date published

		if(referenceType != null && !referenceType.equals(ReferenceType.Journal) && !referenceType.equals(ReferenceType.PrintSeries)){

		    element_timePeriod = formFactory.createVerbatimTimePeriodElement(formElement,

		            "Date Published", entity.getDatePublished(), style);

		}

		createUri(this, entity, SWT.NULL);

		if(referenceType != null && (!referenceType.equals(ReferenceType.Journal) && !referenceType.equals(ReferenceType.PrintSeries) && !referenceType.equals(ReferenceType.PersonalCommunication))) {

            text_doi = formFactory.createDoiWithLabelElement(formElement, "DOI", entity.getDoi(), style);

        }

		createLsid(this, entity, SWT.NULL);

		createAbstract(this, entity, SWT.NULL);

		handleToggleableAbbrevTitleField();

		handleToggleableCacheField();

	}

    private void createWebPageControls(ReferenceDetailElement referenceDetailElement, Reference reference, int style) {

		DateTime accessed = reference.getAccessed();

		text_accessed = formFactory.createDateElement(referenceDetailElement, "Accessed", accessed, style, false);

	}

	@Override

	protected void updateContent() {

		if (getEntity() == null) {

			setEntity(ReferenceFactory.newGeneric());

		}

		super.updateContent();

		// enable elements according to state of cache protection

		// setEnabled(getEntity().isProtectedTitleCache(), Arrays.asList(new

		// Object[]{text_cache}));

		toggleable_cache.setEnabled(getEntity().isProtectedTitleCache());

		toggleableAbbrevCache.setEnabled(getEntity().isProtectedAbbrevTitleCache());

		setIrrelevantReferenceDetail(false);

		setIrrelevantReferenceDetail(true);

	}

	/**

	 * Creates an in reference for reference types that do hav this.

	 */

	private void createInReferenceByType(ICdmFormElement element,

			ReferenceType referenceType, Reference reference, int style) {

		boolean createInReferenceWidget = true;

		String label = "In Reference";

		switch (referenceType) {

		case Generic:

			break;

		case Section:

		    break;

		case BookSection:

			label = "Book";

			break;

		case InProceedings:

			label = "Proceedings";

			break;

		case Article:

			label = "Journal";

			break;

		case WebPage:

			break;

		default:

			createInReferenceWidget = false;

		}

		if (createInReferenceWidget) {

			selection_inReference = formFactory

					.createSelectionElement(Reference.class,

					        element, label,

							reference.getInReference(),

							EntitySelectionElement.ALL, style);

		}

	}

	/**

	 * Creates additional controls to edit a generic reference

	 */

	private void createGenericControls(ICdmFormElement element,

			Reference reference, int style) {

		// editor

		text_editor = formFactory.createTextWithLabelElement(element, "Editor",

				reference.getEditor(), style);

		// series

		text_series = formFactory.createTextWithLabelElement(element, "Series",

				reference.getSeriesPart(), style);

		// volume

		text_volume = formFactory.createTextWithLabelElement(element, "Volume",

				reference.getVolume(), style);

		// pages

		text_pages = formFactory.createTextWithLabelElement(element, "Pages",

				reference.getPages(), style);

	}

	/**

	 * Creates additional controls to edit a publication

	 */

	private void createPublicationControls(ICdmFormElement element,

			ReferenceType referenceType, Reference reference, int style) {

		// placePublished

		text_placePublished = formFactory.createTextWithLabelElement(element,

				"Place Published", reference.getPlacePublished(), style);

		// publisher

		text_publisher = formFactory.createTextWithLabelElement(element,

				"Publisher", reference.getPublisher(), style);

		if (referenceType.equals(ReferenceType.Journal)) {

			// issn

			text_issn = formFactory.createTextWithLabelElement(element, "ISSN",

					reference.getIssn(), style);

		}

		if (referenceType.equals(ReferenceType.Report)) {

			// institution

			selection_institution = formFactory

					.createSelectionElement(Institution.class,//getConversationHolder(),

					        element, "Institution",

							reference.getInstitution(),

							EntitySelectionElement.ALL, style);

		}

		if (referenceType.equals(ReferenceType.Thesis)) {

			// school

			selection_institution = formFactory

					.createSelectionElement(Institution.class,//getConversationHolder(),

					        element, "School",

							reference.getSchool(),

							EntitySelectionElement.ALL, style);

		}

		if (referenceType.equals(ReferenceType.Proceedings)) {

			// organization

			text_organisation = formFactory.createTextWithLabelElement(element,

					"Organisation", reference.getOrganization(), style);

		}

	}

	/**

	 * Creates additional controls to edit a section

	 */

	private void createSectionControls(ICdmFormElement element,

			Reference reference, int style) {

		// pages

		text_pages = formFactory.createTextWithLabelElement(element, "Pages",

				reference.getPages(), style);

	}

	/**

	 * Creates additional controls to edit a volume

	 */

	private void createVolumeControls(ICdmFormElement element,

			Reference reference, int style) {

		text_volume = formFactory.createTextWithLabelElement(element, "Volume",

				reference.getVolume(), style);

		text_series = formFactory.createTextWithLabelElement(element, "Series",

				reference.getSeriesPart(), style);

	}

	private void createPrintedUnitControls(ICdmFormElement element,

			ReferenceType referenceType, Reference reference, int style) {

		// in series

		selection_inSeries = formFactory

				.createSelectionElement(Reference.class,//getConversationHolder(),

				        element, "In Series",

						(Reference) reference.getInSeries(),

						EntitySelectionElement.ALL, style);

		// editor

		text_editor = formFactory.createTextWithLabelElement(element, "Editor",

				reference.getEditor(), style);

		/* series part

		text_seriesPart = formFactory.createTextWithLabelElement(element,

				"Series", reference.getSeriesPart(), style);

*/

		if (referenceType.equals(ReferenceType.Book)) {

			// edition

			text_edition = formFactory.createTextWithLabelElement(element,

					"Edition", reference.getEdition(), style);

		}

		// isbn

        text_isbn = formFactory.createTextWithLabelElement(element, "ISBN",

                reference.getIsbn(), style);

	}

	private void createAbstract(ICdmFormElement element,

			Reference reference, int style) {

		text_referenceAbstract = formFactory.createMultiLineTextWithLabel(

				element, "Reference Abstract", 100, style);

		text_referenceAbstract.setText(reference.getReferenceAbstract());

	}

	private void createLsid(ICdmFormElement element,

            Reference reference, int style) {

        text_lsid = formFactory.createLsidWithExceptionLabelElement(element, "LSID",

                reference.getLsid(), style);

    }

	private void createUri(ICdmFormElement element,

            Reference reference, int style) {

        text_uri = formFactory.createUriWithLabelElement(element, "URI",

                reference.getUri(), style);

        if (reference.getType().equals(ReferenceType.WebPage)){

            createWebPageControls(this, reference, style);

        }

    }

	@Override

	public void handleEvent(Object eventSource) {

		if (eventSource == combo_referenceType) {

			getEntity().setType(combo_referenceType.getSelection());

			updateContent();

	        //this is needed for the "new" wizards in order to redraw correctly

			StoreUtil.reflowParentScrolledForm(getLayoutComposite(), true);

		} else if (eventSource == element_timePeriod) {

			getEntity().setDatePublished(element_timePeriod.getTimePeriod());

			clearException();

		}

		// selections

		else if (eventSource == selection_authorTeam) {

			getEntity().setAuthorship(

					selection_authorTeam.getEntity());

		} else if (eventSource == selection_inReference) {

			getEntity().setInReference(selection_inReference.getSelection());

		} else if (eventSource == selection_inSeries) {

			getEntity().setInReference(selection_inSeries.getSelection());

		} else if (eventSource == selection_institution) {

			getEntity().setInstitution(selection_institution.getSelection());

		}

		// textfields

		else if (eventSource == toggleable_cache) {

			handleToggleableCacheField();

		}

		else if (eventSource == toggleableAbbrevCache) {

		    handleToggleableAbbrevTitleField();

		} else if (eventSource == text_edition) {

			getEntity().setEdition(text_edition.getText());

		} else if (eventSource == text_editor) {

			getEntity().setEditor(text_editor.getText());

		} else if (eventSource == text_isbn) {

			getEntity().setIsbn(text_isbn.getText());

		} else if (eventSource == text_issn) {

			getEntity().setIssn(text_issn.getText());

		} else if (eventSource == text_organisation) {

			getEntity().setOrganization(text_organisation.getText());

		} else if (eventSource == text_pages) {

			getEntity().setPages(text_pages.getText());

		} else if (eventSource == text_placePublished) {

			getEntity().setPlacePublished(text_placePublished.getText());

		} else if (eventSource == text_publisher) {

			getEntity().setPublisher(text_publisher.getText());

		} else if (eventSource == text_referenceAbstract) {

			getEntity().setReferenceAbstract(text_referenceAbstract.getText());

		} else if (eventSource == text_series) {

			getEntity().setSeriesPart(text_series.getText());

		} else if (eventSource == text_title ) {

			getEntity().setTitle(text_title.getText());

			if (!toggleable_cache.isEnabled()){

			    toggleable_cache.setText(getEntity().generateTitle());

			}

		} else if (eventSource == text_abbrevTitle ) {

		    getEntity().setAbbrevTitle(text_abbrevTitle.getText());

		    if (!toggleableAbbrevCache.isEnabled()){

		        toggleableAbbrevCache.setText(getEntity().generateAbbrevTitle());

		    }

		} else if (eventSource == text_uri) {

			getEntity().setUri(text_uri.parseText());

		} else if (eventSource == text_lsid) {

            getEntity().setLsid(text_lsid.parseText());

        } else if (eventSource == text_volume) {

			getEntity().setVolume(text_volume.getText());

		}else if (eventSource == text_doi) {

            getEntity().setDoi(text_doi.parseText());

        }else if (eventSource == text_accessed.getController()) {

            getEntity().setAccessed(text_accessed.getController().getDateTime());

        }

		if (eventSource != text_title && eventSource != text_abbrevTitle) {

		    // set abbrev title cache to null to force new generation

		    // for the standard title cache this is done by a PropertyChangeListener registered

		    // in IdentifiableEntity.initListeners()

		    if(!getEntity().isProtectedAbbrevTitleCache()){

		        getEntity().setAbbrevTitleCache(null, getEntity().isProtectedAbbrevTitleCache());

		    }

		    if(!getEntity().isProtectedTitleCache()){

                getEntity().setTitleCache(null, getEntity().isProtectedTitleCache());

            }

			toggleable_cache.setText(getEntity().getTitleCache());

			toggleableAbbrevCache.setText(getEntity().getAbbrevTitleCache());

		}

		firePropertyChangeEvent(new CdmPropertyChangeEvent(this, null));

	}

    @Override

    public void updateToggleableCacheField() {

        if (!getEntity().isProtectedTitleCache()) {

            toggleable_cache.setText(getEntity().generateTitle());

        }

        if (!getEntity().isProtectedAbbrevTitleCache()) {

            toggleableAbbrevCache.setText(getEntity().generateAbbrevTitle());

        }

    }

    protected void handleToggleableAbbrevTitleField() {

        boolean pushedAbbrevState = toggleableAbbrevCache.getState();

        getEntity().setAbbrevTitleCache(toggleableAbbrevCache.getText(), pushedAbbrevState);

        setIrrelevantReferenceDetail(true);

        updateToggleableCacheField();

    }

	@Override

	public void handleException(CdmPropertyChangeEvent event) {

		exceptionOccurred(event);

	}

	@Override

	public void clearException() {

		exceptionOccurred(null);

	}

	private final List<IExceptionHandler> exceptionHandlers = new ArrayList<>();

	@Override

	public void addExceptionHandler(IExceptionHandler handler) {

		exceptionHandlers.add(handler);

	}

	@Override

	public void removeExceptionHandler(IExceptionHandler handler) {

		exceptionHandlers.remove(handler);

	}

	@Override

	public void exceptionOccurred(CdmPropertyChangeEvent event) {

		for (IExceptionHandler handler : exceptionHandlers) {

			if (event == null) {

				handler.clearException();

			} else {

				handler.handleException(event);

			}

		}

	}

	@Override

	protected void handleToggleableCacheField() {

		boolean pushedState = toggleable_cache.getState();

        getEntity().setTitleCache(toggleable_cache.getText(), pushedState);

        setIrrelevantReferenceDetail(false);

        updateToggleableCacheField();

    }

	protected void setIrrelevantReferenceDetail(boolean abbrev){

		List<Object> except = new ArrayList<>();

	    except.addAll( Arrays.asList(new Object[] { toggleable_cache, toggleableAbbrevCache, text_editor, text_isbn, text_issn, text_organisation, text_pages, text_placePublished, text_publisher, text_referenceAbstract,  text_uri, selection_institution}));

	    if (abbrev){

	      except.add(text_title);

	    } else{

	      except.add(text_abbrevTitle);

	    }

	    switch( getEntity().getType()){

	    case Journal:

	    	except.add(element_timePeriod);

	    	break;

	    case Book:

	    	except.remove(text_series);

	    	except.remove(text_edition);

	    	break;

	    default:

	    	break;

	    }

	    boolean pushedState = toggleableAbbrevCache.getState() || toggleable_cache.getState();

	    setIrrelevant(pushedState, except);

	    text_title.setIrrelevant(toggleable_cache.getState());

	    text_abbrevTitle.setIrrelevant(toggleableAbbrevCache.getState());

	}

}