EDIT

// $Id$

/**

 * 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.editor.view.checklist;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.SortedSet;

import java.util.TreeSet;

import java.util.UUID;

import org.eclipse.jface.preference.IPreferenceStore;

import org.eclipse.jface.viewers.ITableLabelProvider;

import org.eclipse.jface.viewers.LabelProvider;

import org.eclipse.jface.viewers.TableViewer;

import org.eclipse.swt.graphics.Image;

import org.eclipse.swt.widgets.TableColumn;

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

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

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.taxeditor.preference.PreferencesUtil;

import eu.etaxonomy.taxeditor.store.CdmStore;

/**

 *

 * @author a.oppermann

 * @created 30.04.2014

 * @version 1.0

 */

public class ChecklistLabelProvider extends LabelProvider implements ITableLabelProvider {

    public static final String DEFAULT_ENTRY = "";

    private IDescriptionService descriptionService;

    private final SortedSet<DefinedTermBase> namedAreas;

    TableViewer viewer = null;

    /**

     *

     */

    public ChecklistLabelProvider() {

        namedAreas = loadNamedAreas();

    }

    public ChecklistLabelProvider(TableViewer viewer) {

        namedAreas = loadNamedAreas();

        this.viewer = viewer;

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * org.eclipse.jface.viewers.ITableLabelProvider#getColumnImage(java.lang

     * .Object, int)

     */

    /** {@inheritDoc} */

    @Override

    public Image getColumnImage(Object element, int columnIndex) {

        // TODO

        return null;

    }

    /*

     * (non-Javadoc)

     *

     * @see

     * org.eclipse.jface.viewers.ITableLabelProvider#getColumnText(java.lang

     * .Object, int)

     */

    /** {@inheritDoc} */

	@Override

    public String getColumnText(Object element, int columnIndex) {

        descriptionService = CdmStore.getService(IDescriptionService.class);

        Taxon taxon = (Taxon) element;

        //TODO load areas by this list

        List<TaxonDescription> listTaxonDescriptions = descriptionService.listTaxonDescriptions(taxon, null, null, null, null, null, DESC_INIT_STRATEGY);;

        NonViralName<?> nonViralName = HibernateProxyHelper.deproxy(taxon.getName(), NonViralName.class);

        switch (columnIndex) {

        case 0:

            String taxonName = null;

            taxonName = (nonViralName != null) ? nonViralName.getNameCache() : null;

            return (taxonName != null) ? taxonName : DEFAULT_ENTRY;

        case 1:

            String authorship = null;

            authorship = (nonViralName != null) ? nonViralName.getAuthorshipCache() : null;

            return (authorship != null) ? authorship : DEFAULT_ENTRY;

//        case 2:

//            String ref = null;

//            if (taxon.getName() != null) {

//                INomenclaturalReference nomenclaturalReference = HibernateProxyHelper.deproxy(

//                        nonVirlaName.getNomenclaturalReference(), Reference.class);

//                ref = (nomenclaturalReference != null) ? nomenclaturalReference.getAbbrevTitleCache() : null;

//            }

//            return (ref != null) ? ref : DEFAULT_ENTRY;

        case 2:

            String rank = null;

            if (taxon.getName().getRank() != null) {

                rank = taxon.getName().getRank().toString();

            }

            return (rank != null) ? rank : DEFAULT_ENTRY;

        }

        if(columnIndex >2){

            for (TaxonDescription td : listTaxonDescriptions) {

                for (DescriptionElementBase deb : td.getElements()) {

                    if (deb instanceof Distribution) {

                        Distribution distribution = HibernateProxyHelper.deproxy(deb, Distribution.class);

                        String area = null;

                        if (distribution.getArea() != null ){

                            if (PreferencesUtil.isShowIdInVocabularyInChecklistEditor()){

                                area = distribution.getArea().getIdInVocabulary();

                            }else{

                                area = distribution.getArea().getTitleCache();

                            }

                        }else{

                            continue;

                        }

                        if(viewer != null){

                        	TableColumn column = viewer.getTable().getColumn(columnIndex);

                        	if (area.equalsIgnoreCase(column.getText())) {

                        	    return (distribution.getStatus().getTitleCache() != null)?distribution.getStatus().getTitleCache():DEFAULT_ENTRY;

                            }

                        }

                    }

                }

            }

        }

        return DEFAULT_ENTRY;

    }

    private static final List<String> DESC_INIT_STRATEGY = Arrays.asList(new String[] { "descriptions",

            "descriptions.*", "description.state" });

    private SortedSet<DefinedTermBase> loadNamedAreas() {

        IPreferenceStore preferenceStore = PreferencesUtil.getPreferenceStore();

        String values = preferenceStore.getString(PreferencesUtil.DISTRIBUTION_AREA_OCCURENCE_STATUS);

        if (values != null && values != "") {

            String[] split = values.split(",");

            List<String> listValue = Arrays.asList(split);

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

           Set<UUID> uuidList = new HashSet<UUID>();

           UUID uuid;

            for(String s : listValue){

                uuid = UUID.fromString(s);

                uuidList.add(uuid);

            }

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

            termlist = service.find(uuidList);

            return getTermsOrderedByIdInVocabulary(termlist);

        }

        return null;

    }

    public SortedSet<?> getTermsOrderedByLabels(List<DefinedTermBase<?>> listTerm,Language language){

        TermLanguageComparator comp = new TermLanguageComparator();

        comp.setCompareLanguage(language);

        SortedSet result = new TreeSet(comp);

        if(listTerm != null){

            result.addAll(listTerm);

        }

        return result;

    }

    /**

     * @return the namedAreas

     */

    public SortedSet<DefinedTermBase> getNamedAreas() {

        return namedAreas;

    }

    /**

     * @param namedAreas

     * @param defaultLanguage

     * @return

     */

    public SortedSet<DefinedTermBase> getTermsOrderedByIdInVocabulary(List<DefinedTermBase> namedAreas) {

        TermIdInVocabularyComparator comp = new TermIdInVocabularyComparator();

        SortedSet result = new TreeSet(comp);

        if(namedAreas != null){

            result.addAll(namedAreas);

        }

        return result;

    }

}