EDIT

/**

* Copyright (C) 2011 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.store;

import java.net.URISyntaxException;

import org.eclipse.core.runtime.IProgressMonitor;

import org.eclipse.core.runtime.NullProgressMonitor;

import eu.etaxonomy.cdm.common.URI;

import eu.etaxonomy.cdm.api.conversation.ConversationHolder;

import eu.etaxonomy.cdm.api.service.ITermService;

import eu.etaxonomy.cdm.api.service.IVocabularyService;

import eu.etaxonomy.cdm.model.common.MarkerType;

import eu.etaxonomy.cdm.model.description.Feature;

import eu.etaxonomy.cdm.model.description.State;

import eu.etaxonomy.cdm.model.term.DefinedTerm;

import eu.etaxonomy.cdm.model.term.TermType;

import eu.etaxonomy.cdm.model.term.TermVocabulary;

/**

 * A store to handle all terms and vocabulary required for

 * the UseObjects view and components.

 * Whenever one of the terms is requested, all required terms are generated

 * in the database as we consider the requests as an indicator that

 * someone wants to use the terms.

 * This

 * @author a.theys

 * @author a.mueller

 * @created mar 13, 2012

 */

public class UseObjectStore {

	private static boolean isInitialized;

	private static MarkerType useMarkerType;

	private static Feature useSummaryFeature;

	private static Feature useRecordFeature;

	public static void reset() {

		isInitialized = false;

		useMarkerType = null;

		useSummaryFeature = null;

		useRecordFeature = null;

	}

	public static MarkerType getUseMarkerType() {

		initialize();

		return useMarkerType;

	}

	public static Feature getUseSummaryFeature() {

		initialize();

		return useSummaryFeature;

	}

	public static Feature getUseRecordFeature() {

		initialize();

		return useRecordFeature;

	}

	private static void initialize(){

		setupNecessaryItems(null);

		isInitialized = true;

	}

	private static void setupNecessaryItems( IProgressMonitor monitor ) {

		if (isInitialized){

			return;

		}

		if (monitor == null){

			//TODO can we use a better one?

			monitor = new NullProgressMonitor();

		}

		ConversationHolder conversation = CdmStore.createConversation();

		//retrieve terms and vocabularies from db

		useRecordFeature = (Feature) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseRecordFeature);

		useSummaryFeature = (Feature) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseSummaryFeature);

		//create use marker type if not exists

		createUseMarkerType(conversation);

		//create state vocabulary if not exists

		createStateVocabulary(monitor, conversation);

		//create state vocabulary if not exists

		createCountryVocabulary(monitor, conversation);

		//create plant part vocabulary

		createPlantVocabulary(monitor, conversation);

		//create human group vocabulary

		createHumanGroupVocabulary(monitor, conversation);

		if(useRecordFeature == null || useSummaryFeature == null) {

			TermVocabulary<Feature> featureVocabulary = CdmStore.getService(IVocabularyService.class).find((UsageTermCollection.uuidFeatureVocabulary));

//			FeatureTree palmWebFeatureTree = CdmStore.getService(ITermTreeService.class).find(UsageTermCollection.uuidPalmWebFeatureTree);

			if (useRecordFeature == null ) {

				useRecordFeature = Feature.NewInstance(UsageTermCollection.useRecordFeatureLabel, UsageTermCollection.useRecordFeatureLabel, null);

				useRecordFeature.setUuid(UsageTermCollection.uuidUseRecordFeature);

				useRecordFeature.setSupportsCategoricalData(true);

				featureVocabulary.addTerm(useRecordFeature);

//				if (palmWebFeatureTree != null){

//					FeatureNode useRecFeatureNode = FeatureNode.NewInstance(featureUseRecord);

//					palmWebFeatureTree.getRoot().addChild(useRecFeatureNode);

//				}else{

//					StoreUtil.warn(getClass(), "No current feature tree available to add useRecord feature");

//				}

			}

			if (useSummaryFeature == null) {

				useSummaryFeature = Feature.NewInstance(UsageTermCollection.useSummaryFeatureLabel, UsageTermCollection.useSummaryFeatureLabel, null);

				useSummaryFeature.setUuid(UsageTermCollection.uuidUseSummaryFeature);

				useSummaryFeature.setSupportsTextData(true);

				featureVocabulary.addTerm(useSummaryFeature);

//				if (palmWebFeatureTree != null){

//					FeatureNode useSumFeatureNode = FeatureNode.NewInstance(featureUseSummary);

//					palmWebFeatureTree.getRoot().addChild(useSumFeatureNode);

//				}else{

//					StoreUtil.warn(getClass(), "No current feature tree available to add use summary feature");

//				}

			}

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(featureVocabulary);

//			if (palmWebFeatureTree != null){

//				CdmStore.getService(ITermTreeService.class).saveOrUpdate(palmWebFeatureTree);

//			}

			conversation.commit(true);

		}

		conversation.close();

	}

	private static void createHumanGroupVocabulary(IProgressMonitor monitor,ConversationHolder conversation) {

		TermVocabulary<DefinedTerm> humanGroupVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidHumanGroupVocabulary);

		if (humanGroupVocabulary == null){

			monitor.subTask("create human group vocabulary");

			URI termSourceUri = null;

			try {

				termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");

			} catch (URISyntaxException e) {

				e.printStackTrace();

			}

			humanGroupVocabulary = TermVocabulary.NewInstance(TermType.Modifier, UsageTermCollection.humanGroupLabel, UsageTermCollection.humanGroupLabel, null, termSourceUri);

			humanGroupVocabulary.setUuid(UsageTermCollection.uuidHumanGroupVocabulary);

			DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newDummyModifier.setUuid(UsageTermCollection.uuidHumanGroupDummy);

			DefinedTerm newSubDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newSubDummyModifier.setUuid(UsageTermCollection.uuidEthnicGroupDummy);

			newDummyModifier.addIncludes(newSubDummyModifier);

			humanGroupVocabulary.addTerm(newDummyModifier);

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(humanGroupVocabulary);

			conversation.commit(true);

		}

	}

	private static void createPlantVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {

		TermVocabulary<DefinedTerm> plantPartVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidPlantPartVocabulary);

		if (plantPartVocabulary == null){

			monitor.subTask("create plant part vocabulary");

			URI termSourceUri = null;

			try {

				termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");

			} catch (URISyntaxException e) {

				e.printStackTrace();

			}

			plantPartVocabulary = TermVocabulary.NewInstance(TermType.Modifier, UsageTermCollection.plantPartLabel, UsageTermCollection.plantPartLabel, null, termSourceUri);

			plantPartVocabulary.setUuid(UsageTermCollection.uuidPlantPartVocabulary);

			DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newDummyModifier.setUuid(UsageTermCollection.uuidPlantPartDummy);

			plantPartVocabulary.addTerm(newDummyModifier);

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(plantPartVocabulary);

			conversation.commit(true);

		}

	}

	private static void createCountryVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {

		TermVocabulary<DefinedTerm> countryVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidCountryVocabulary);

		if (countryVocabulary == null){

			monitor.subTask("create country vocabulary");

			URI termSourceUri = null;

			try {

				termSourceUri = new URI("eu.etaxonomy.cdm.model.description.DefinedTerm");

			} catch (URISyntaxException e) {

				e.printStackTrace();

			}

			countryVocabulary = TermVocabulary.NewInstance(TermType.Modifier, UsageTermCollection.countryLabel, UsageTermCollection.countryLabel, null, termSourceUri);

			countryVocabulary.setUuid(UsageTermCollection.uuidCountryVocabulary);

			DefinedTerm newDummyModifier = DefinedTerm.NewInstance(TermType.Modifier, UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newDummyModifier.setUuid(UsageTermCollection.uuidCountryDummy);

			countryVocabulary.addTerm(newDummyModifier);

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(countryVocabulary);

			conversation.commit(true);

		}

	}

	private static void createStateVocabulary(IProgressMonitor monitor, ConversationHolder conversation) {

		TermVocabulary<State> stateVocabulary =  CdmStore.getService(IVocabularyService.class).find(UsageTermCollection.uuidUseCategoryVocabulary);

		if (stateVocabulary == null){

			monitor.subTask("create state vocabulary");

			URI termSourceUri = null;

			try {

				termSourceUri = new URI("eu.etaxonomy.cdm.model.description.State");

			} catch (URISyntaxException e) {

				e.printStackTrace();

			}

			stateVocabulary = TermVocabulary.NewInstance(TermType.State, UsageTermCollection.useCategoryVocabularyLabel, UsageTermCollection.useCategoryVocabularyLabel, null, termSourceUri);

			stateVocabulary.setUuid(UsageTermCollection.uuidUseCategoryVocabulary);

			State newDummyState = State.NewInstance(UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newDummyState.setUuid(UsageTermCollection.uuidUseCategoryDummy);

			State newDummySubCat = State.NewInstance(UsageTermCollection.notAvailableLabel, UsageTermCollection.notAvailableLabel, null);

			newDummySubCat.setUuid(UsageTermCollection.uuidUseSubCategoryDummy);

			newDummyState.addIncludes(newDummySubCat);

			stateVocabulary.addTerm(newDummyState);

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(stateVocabulary);

			conversation.commit(true);

		}

	}

	private static void createUseMarkerType(ConversationHolder conversation) {

		useMarkerType = (MarkerType) CdmStore.getService(ITermService.class).find(UsageTermCollection.uuidUseMarkerType);

		if (useMarkerType == null){

			useMarkerType = MarkerType.NewInstance(UsageTermCollection.useMakerLabel, UsageTermCollection.useMakerLabel, null);

			useMarkerType.setUuid( UsageTermCollection.uuidUseMarkerType);

			TermVocabulary<MarkerType> markerTypeVocabulary = CdmStore.getService(IVocabularyService.class).find((UsageTermCollection.uuidMarkersVocabulary));

			markerTypeVocabulary.addTerm(useMarkerType);

			CdmStore.getService(IVocabularyService.class).saveOrUpdate(markerTypeVocabulary);

			conversation.commit(true);

		}

	}

}