EDIT

/**

* Copyright (C) 2009 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.editor.definedterm.input;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.stream.Collectors;

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

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

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

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

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

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

import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

import eu.etaxonomy.taxeditor.store.TermStore;

/**

 * @author n.hoffmann

 * @date Jan 24, 2012

 *

 */

public class TermEditorInput extends AbstractDefinedTermEditorInput<DefinedTerm> {

	private TermType termType;

	private Set<TermVocabularyDto> vocabularies;

	// FIXME: the default feature should be move to CdmApplicationState

	//        where it is a singleton instance variable

	private static TermTree defaultFeatureTree = null;

	private static TermTree defaultNameFeatureTree = null;

	private List<String> termClasses = Arrays.asList(new String[]{

			DefinedTerm.class.getName()

	});

	public TermEditorInput(TermType termType) {

		this.termType = termType;

		vocabularies = new HashSet<TermVocabularyDto>();

		initialiseVocabularies();

	}

	public String getName() {

		return termType.getMessage();

	}

	@Override

	public List<String> getTermClasses() {

		return termClasses;

	}

	public TermType getTermType() {

		return termType;

	}

	public void initialiseVocabularies() {

		if(vocabularies != null) {

			vocabularies.clear();

		}

		List<TermVocabularyDto> vocs = CdmStore.getService(IVocabularyService.class).findVocabularyDtoByTermType(termType, false);

		vocabularies.addAll(vocs);

	}

	public Set<TermVocabularyDto> getVocabularies() {

		return vocabularies;

	}

	public void updateDefaultFeatureTree() {

	    for(TermVocabularyDto vocab : getVocabularies()) {

	        if(vocab != null && TermType.Feature.equals(vocab.getTermType())) {

	            defaultFeatureTree = null;

	            return;

	        }

	    }

	}

	@Override

    public Set<TermVocabularyDto>  getRootEntities() {

        return getVocabularies();

    }

	@Override

    public void merge() {

	    List<TermVocabulary> vocabularies = new ArrayList<>();

	    getRootEntities().forEach(vocDto->vocabularies.add(CdmStore.getService(IVocabularyService.class).load(vocDto.getUuid())));

        CdmStore.getService(IVocabularyService.class).merge(vocabularies, true);

        updateDefaultFeatureTree();

    }

    public static TermTree getDefaultFeatureTree() {

        if(defaultFeatureTree == null) {

            List<Feature> features = TermStore.getTerms(Feature.class);

//            TermVocabulary voc = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid());

//            List<Feature> nameFeatures = new ArrayList(voc.getTerms());

            List<Feature> taxonFeatures = features.stream().filter(f -> f.isAvailableForTaxon())

                    .collect(Collectors.toList());

//            for (Feature feature: copy){

//                if (nameFeatures.contains(feature)){

//                    features.remove(feature);

//                }

//            }

            defaultFeatureTree = TermTree.NewInstance(taxonFeatures);

        }

        return defaultFeatureTree;

    }

    public static void resetDefaultFeatureTree(){

        defaultFeatureTree = null;

    }

    public static TermTree getDefaultNameFeatureTree() {

        if(defaultNameFeatureTree == null) {

//            List<TermVocabularyDto> vocs = new ArrayList<>();

//            Set<CdmClass> availableFor = new HashSet<>();

//            availableFor.add(CdmClass.TAXON_NAME);

//            vocs = CdmStore.getService(IVocabularyService.class).findFeatureVocabularyDtoByTermTypes(availableFor);

//            TermVocabulary voc = CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid());

//            List<Feature> nameFeatures = new ArrayList(voc.getTerms());

//            nameFeatures.remove(Feature.PROTOLOGUE());

//            PreferencesUtil.createPreferredFeatureTreeForNameDescription();

            defaultNameFeatureTree = PreferencesUtil.getPreferredFeatureTreeForNameDescription(true);

          //List<Feature> nameFeatures = CdmStore.getTermManager().getPreferredTerms(CdmStore.getService(IVocabularyService.class).load(VocabularyEnum.NameFeature.getUuid()), null);

//            defaultNameFeatureTree = TermTree.NewInstance(nameFeatures);

        }

        return defaultNameFeatureTree;

    }

    public static void resetDefaultNameFeatureTree(){

        defaultNameFeatureTree = null;

    }

    /**

     * @return

     */

    public static TermTree<?> getPreferredNameFeatureTree(boolean createNew) {

        return PreferencesUtil.getPreferredFeatureTreeForNameDescription(createNew);

    }

    public static TermTree<?> getPreferredTaxonFeatureTree(boolean createNew) {

        return PreferencesUtil.getPreferredFeatureTreeForTaxonDescription(createNew);

    }

}