EDIT

// $Id$

/**

* 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.editor.workingSet.matrix;

import java.util.Comparator;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import ca.odell.glazedlists.TreeList;

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

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

/**

 * @author pplitzner

 * @date 23.01.2018

 *

 */

/*

 * Using a String directly as the tree item has the possible disadvantage of

 * haven non-unique items in the tree within subtrees.

 */

 public class DescriptionTreeFormat implements TreeList.Format<Object> {

     private Map parentMapping = new HashMap<>();

     /**

      * Populate path with a list describing the path from a root node to

      * this element. Upon returning, the list must have size >= 1, where the

      * provided element identical to the list's last element. This

      * implementation will use the first object found for a last name as

      * root node by storing it within a map. If there is already an object

      * stored for the lastname of the given element, it will be used as root

      * for the path.

      */

     @Override

     public void getPath(List path, Object element) {

         if(element instanceof RowWrapper){

             //TODO: check for multiple taxon nodes in multiple classifications

             Taxon taxon = (Taxon) ((RowWrapper) element).getAssociatedTaxa().iterator().next();

             Set<TaxonNode> taxonNodes = taxon.getTaxonNodes();

             if(taxonNodes!=null){

                 TaxonNode node = taxonNodes.iterator().next();

                 addPathRecursive(path, node);

//                 Object rowWrapperParentNode = parentMapping.get(node);

//                 if(rowWrapperParentNode!=null){

//                     path.add(rowWrapperParentNode);

//                 }

//                 else{

//                     TaxonNode parentNode = HibernateProxyHelper.deproxy(node.getParent(), TaxonNode.class);

//                     while(parentNode!=null){

//                         path.add(parentNode);

//                         parentMapping.put(node, parentNode);

//                         if(parentNode instanceof TaxonNode){

//                             if(parentMapping.get(parentNode)!=null){

//                                 path.add(parentMapping).get(parentNode);

//                             }

//                             else{

//                                 parentNode = HibernateProxyHelper.deproxy(parentNode.getParent(), TaxonNode.class);

//                             }

//                         }

//                     }

//                 }

             }

         }

         path.add(element);

     }

     private void addPathRecursive(List path, TaxonNode node){

         if(node.getParent()!=null){

             addPathRecursive(path, node.getParent());

             path.add(node);

         }

     }

     /**

      * Simply always return true.

      *

      * @return true if this element can have child elements, or

      *         false if it is always a leaf node.

      */

     @Override

     public boolean allowsChildren(Object element) {

         return true;

     }

     /**

      * Returns the comparator used to order path elements of the specified

      * depth. If enforcing order at this level is not intended, this method

      * should return null. We do a simple sorting of the last

      * names of the persons to show so the tree nodes are sorted in

      * alphabetical order.

      */

     @Override

     public Comparator<Object> getComparator(int depth) {

         return new Comparator<Object>() {

             @Override

             public int compare(Object o1, Object o2) {

//                 if(o1 instanceof RowWrapper && o2 instanceof RowWrapper){

//                     return ((RowWrapper) o1).getSpecimenDescription().getId()-(((RowWrapper) o2).getSpecimenDescription().getId());

//                 }

//                 else

                     if(o1 instanceof TaxonNode && o2 instanceof TaxonNode){

                     return ((TaxonNode) o1).getTaxon().getName().getNameCache().compareTo(((TaxonNode) o2).getTaxon().getName().getNameCache());

                 }

                 return 0;

             }

         };

     }

 }