EDIT

/**

* Copyright (C) 2018 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.preference.wizard;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.eclipse.jface.layout.GridLayoutFactory;

import org.eclipse.jface.viewers.CheckboxTreeViewer;

import org.eclipse.jface.wizard.WizardPage;

import org.eclipse.swt.SWT;

import org.eclipse.swt.layout.GridLayout;

import org.eclipse.swt.widgets.Composite;

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

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

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

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

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

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

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

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

import eu.etaxonomy.taxeditor.editor.definedterm.DefinedTermSorter;

import eu.etaxonomy.taxeditor.editor.definedterm.TermDtoContentProvider;

import eu.etaxonomy.taxeditor.editor.definedterm.TermDtoLabelProvider;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 * @author k.luther

 * @since 04.06.2018

 *

 */

public abstract class AbstractTermSelectionWizardPage extends WizardPage {

    protected CheckBoxTreeComposite treeComposite;

    private List<TermVocabularyDto> vocabularies = new ArrayList<>();

    boolean localPref;

    List<AbstractTermDto> listCheckedTerms = new ArrayList<>();

    List<AbstractTermDto> listGrayedTerms = new ArrayList<>();

    TermType type;

    /**

     * @param pageName

     */

    protected AbstractTermSelectionWizardPage(String pageName, TermType type) {

        super(pageName);

        // TODO check if configuration exists

        CdmStore.getCurrentSessionManager().bindNullSession();

        this.type = type;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void createControl(Composite parent){

        parent.setLayout(new GridLayout());

        treeComposite = new CheckBoxTreeComposite(parent, new TermDtoContentProvider(), new TermDtoLabelProvider(), SWT.NONE);

        treeComposite.getViewer().setComparator(new DefinedTermSorter());

        rememberCheckedValues(getCheckedValuesFromPreferences(), getGrayedValuesFromPreferences());

        GridLayoutFactory.fillDefaults().applyTo(treeComposite);

        setControl(treeComposite);

    }

    protected abstract String getCheckedValuesFromPreferences();

    protected abstract String getGrayedValuesFromPreferences();

    protected CheckboxTreeViewer getViewer(){

        return treeComposite.getViewer();

    }

    public List<TermVocabularyDto> getVocabularies() {

        return vocabularies;

    }

    public void addVocabularies(TermVocabularyDto vocabulary) {

        this.vocabularies.add(vocabulary);

    }

    /**

     * @param vocs

     */

    protected void setVocabularies(List<TermVocabularyDto> vocs) {

        vocabularies = vocs;

    }

    public List<AbstractTermDto> getListCheckedTerms() {

        return listCheckedTerms;

    }

    public List<AbstractTermDto> getListGrayedTerms() {

        return listGrayedTerms;

    }

    protected void rememberCheckedValues(String checkedValues, String grayedValues) {

        initialiseVocabularies();

        treeComposite.getViewer().setInput(getVocabularies());

        if (grayedValues != null && grayedValues != "") { //$NON-NLS-1$

            String[] arrayGrayed = grayedValues.split(";"); //$NON-NLS-1$

            List<String> listGrayed = Arrays.asList(arrayGrayed);

            listGrayedTerms = getTermsFromStringValues(listGrayed);

        }

        if (checkedValues != null && checkedValues != "") { //$NON-NLS-1$

            String[] listChecked = checkedValues.split(";"); //$NON-NLS-1$

            String[] listCheckedComma = checkedValues.split(","); //$NON-NLS-1$

            List<String> checked = new ArrayList<>();

            if (listChecked != null ){

                checked = Arrays.asList(listChecked);

            }

            if (listCheckedComma != null && checkedValues.contains(",")){ //$NON-NLS-1$

                checked = Arrays.asList(listCheckedComma);

            }

            listCheckedTerms = getTermsFromStringValues(checked);

        }

//        treeComposite.getViewer().setParentsGrayed(element, state)

        treeComposite.setCheckedElements(listCheckedTerms.toArray());

    }

    /**

     * @param split

     * @param termlist

     */

    private List<AbstractTermDto> getTermsFromStringValues(List<String> listValue) {

        List<AbstractTermDto> termlist = new ArrayList<>();

        for (String s : listValue) {

            if (!StringUtils.isBlank(s)){

                UUID uuid = UUID.fromString(s);

                ITermService termService = CdmStore.getService(ITermService.class);

                DefinedTermBase definedTermBase = termService.load(uuid);

                if(definedTermBase != null){

                    termlist.add(TermDto.fromTerm(definedTermBase, true));

                }else{

                    IVocabularyService vocabularyService = CdmStore.getService(IVocabularyService.class);

                    TermVocabulary termVocabulary = vocabularyService.load(uuid);

                    termlist.add(new TermVocabularyDto(uuid, termVocabulary.getRepresentations()));

                }

            }

        }

        return termlist;

    }

    protected void initialiseVocabularies() {

        if (getVocabularies() != null) {

            getVocabularies().clear();

        }

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

        if (localPref){

            vocs = getVocabulariesFromPreference();

        }else{

            vocs = CdmStore.getService(IVocabularyService.class).findVocabularyDtoByTermType(type);

        }

        setVocabularies(vocs);

    }

    protected abstract List<TermVocabularyDto> getVocabulariesFromPreference();

}