EDIT

import java.util.Collection;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import eu.etaxonomy.cdm.model.location.NamedArea;

    protected boolean replaceCommonAreaLabelStart;

    //for future use in combined DistributionComposer

    private boolean sortByStatus;

    /**

     * @param langs

     * @param area

     * @return

     */

    protected String makeAreaLabel(List<Language> langs, NamedArea area) {

        String result = area.getIdInVocabulary() != null ? area.getIdInVocabulary() :area.getPreferredRepresentation(langs).getAbbreviatedLabel();

        return areaPreTag + result + areaPostTag;

    }

    /**

     * Searches for the parent are of the area given as parameter in

     * the Collection of areas.

     *

     * @parent area

     *      The area whose parent area is to be searched

     * @param collection

     *      The areas to search in.

     *

     * @return

     *      Either the parent if it has been found or null.

     */

    protected NamedArea findParentIn(NamedArea area, Collection<NamedArea> areas) {

        NamedArea parent = area.getPartOf();

        if(parent != null && areas.contains(parent)){

            return parent;

        }

        return null;

    }

    protected class AreaNode {

        protected final NamedArea area;

        protected AreaNode parent = null;

        protected final Set<AreaNode> subAreas = new HashSet<AreaNode>();

        /**

         * @param area

         */

        public AreaNode(NamedArea area) {

            this.area = area;

        }

        public void addSubArea(AreaNode subArea) {

            subAreas.add(subArea);

            subArea.parent = this;

        }

        public AreaNode getParent() {

            return parent;

        }

        public boolean hasParent() {

            return getParent() != null;

        }

        public Collection<NamedArea> getSubareas() {

            Collection<NamedArea> areas = new HashSet<NamedArea>();

            for(AreaNode node : subAreas) {

                areas.add(node.area);

            }

            return areas;

        }

        @Override

        public String toString() {

            return "AreaNode [area=" + area + "]";

        }

    }

    //Keep here only in case new version does creates problems in E+M

    //can be deleted if no problem occurs

        //1. group by PresenceAbsenceTerms

        Map<PresenceAbsenceTerm, Collection<NamedArea>> areasByStatus = new HashMap<PresenceAbsenceTerm, Collection<NamedArea>>();

            if(!areasByStatus.containsKey(status)) {

                areasByStatus.put(status, new HashSet<NamedArea>());

            areasByStatus.get(status).add(d.getArea());

        for(PresenceAbsenceTerm status : areasByStatus.keySet()) {

            for(NamedArea area : areasByStatus.get(status)) {

                NamedArea parent = findParentIn(area, areasByStatus.get(status));

            for(AreaNode topLevelNode : hierarchy) {

                String areaLabel = topLevelNode.area.getPreferredRepresentation(langs).getAbbreviatedLabel();

                if(!topLevelNode.subAreas.isEmpty()) {

                    subAreaLabels(langs, topLevelNode.subAreas, areaStatusString, statusSymbol, areaLabel);

            if (replaceCommonAreaLabelStart){

                String cleanSubAreaLabel = StringUtils.replaceEach(areaLabel, new String[] {parentLabel, "(", ")"}, new String[] {"", "", ""});

                subAreaString.append(cleanSubAreaLabel);

            }else{

                subAreaString.append(areaLabel);

            }

import java.util.Collections;

import java.util.Comparator;

import java.util.Map;

//    private static Set<UUID> foreignStatusUuids;

    //preliminary for Cuba, needs to be parameterized

//    // these status uuids are special for EuroPlusMed and might also be used

//    private final static UUID REPORTED_IN_ERROR_UUID =  UUID.fromString("38604788-cf05-4607-b155-86db456f7680");

// ***************************** GETTER/SETTER ***********************************/

    public String getInternalAreaSeparator() {

        return internalAreaSeparator;

    }

    public void setInternalAreaSeparator(String internalAreaSeparator) {

        this.internalAreaSeparator = internalAreaSeparator;

    }

// ***********************************************************************

            List<Language> languages) {

        CondensedDistribution result = new CondensedDistribution();

//        Collection<NamedArea> allAreas = new HashSet<NamedArea>();

        //we expect every area only to have 1 status  (multiple status should have been filtered beforehand)

        Map<NamedArea, PresenceAbsenceTerm> areaToStatusMap = new HashMap<>();

        //1. compute all areas and their status

        for(Distribution d : filteredDistributions) {

            PresenceAbsenceTerm status = d.getStatus();

            //TODO needed? Do we only want to have areas with status?

            if(status == null) {

                continue;

            }

            NamedArea area = d.getArea();

            areaToStatusMap.put(area, status);

        //2. build the area hierarchy

        Map<NamedArea, AreaNode> areaNodeMap = new HashMap<>();

        for(NamedArea area : areaToStatusMap.keySet()) {

            AreaNode node;

            if(!areaNodeMap.containsKey(area)) {

                // putting area into hierarchy as node

                node = new AreaNode(area);

                areaNodeMap.put(area, node);

            } else {

                //  is parent of another and thus already has a node

                node = areaNodeMap.get(area);

            NamedArea parent = findParentIn(area, areaToStatusMap.keySet());

            if(parent != null) {

                AreaNode parentNode;

                if(!areaNodeMap.containsKey(parent)) {

                    parentNode = new AreaNode(parent);

                    areaNodeMap.put(parent, parentNode);

                } else {

                    parentNode = areaNodeMap.get(parent);

                }

                parentNode.addSubArea(node);

            }

        }

        //3. find root nodes

        List<AreaNode>topLevelNodes = new ArrayList<AreaNode>();

        for(AreaNode node : areaNodeMap.values()) {

            if(!node.hasParent() && ! topLevelNodes.contains(node)) {

                topLevelNodes.add(node);

            }

        }

        //4. replace the area by the abbreviated representation and add symbols

        boolean isFirstAfterAreaOfScope = false;

        AreaNodeComparator areaNodeComparator = new AreaNodeComparator();

        Collections.sort(topLevelNodes, areaNodeComparator);

        for(AreaNode topLevelNode : topLevelNodes) {

            StringBuilder areaStatusString = new StringBuilder();

            NamedArea area = topLevelNode.area;

                isFirstAfterAreaOfScope = true;

            }else if(isFirstAfterAreaOfScope && !area.getUuid().equals(uuidInternalArea)){

                isFirstAfterAreaOfScope = false;

            PresenceAbsenceTerm status = areaToStatusMap.get(area);

            String statusSymbol = statusSymbol(areaToStatusMap.get(area));

            String areaLabel = makeAreaLabel(languages, area);

            if(!topLevelNode.subAreas.isEmpty()) {

                areaStatusString.append('(');

                subAreaLabels(languages, topLevelNode.subAreas, areaStatusString, statusSymbol,

                        areaLabel, areaToStatusMap, areaNodeComparator);

                areaStatusString.append(')');

                result.addIndigenousDistributionItem(status, areaStatusString.toString(), areaLabel);

        return result;

     * Recursive call to create sub area label strings

     * @param areaNodeComparator

    private void subAreaLabels(List<Language> languages, Collection<AreaNode> nodes, StringBuilder totalStringBuilder,

            String parentStatusSymbol, String parentLabel,

            Map<NamedArea, PresenceAbsenceTerm> areaToStatusMap, AreaNodeComparator areaNodeComparator) {

        List<AreaNode> areaNodes = new ArrayList<>(nodes);

        Collections.sort(areaNodes, areaNodeComparator);

        for(AreaNode node : areaNodes) {

            NamedArea area = node.area;

            PresenceAbsenceTerm status = areaToStatusMap.get(area);

            if (subAreaStatusSymbol != null && !subAreaStatusSymbol.equals(parentStatusSymbol)){

            String areaLabel = makeAreaLabel(languages, area);

            if(replaceCommonAreaLabelStart){

                String cleanSubAreaLabel = StringUtils.replaceEach(areaLabel, new String[] {parentLabel, "(", ")"}, new String[] {"", "", ""});

                subAreaString.append(cleanSubAreaLabel);

            }else{

                subAreaString.append(areaLabel);

            }

            if(!node.subAreas.isEmpty()) {

                subAreaString.append('(');

                subAreaLabels(languages, node.subAreas, subAreaString, subAreaStatusSymbol, areaLabel,

                        areaToStatusMap, areaNodeComparator);

                subAreaString.append(')');

//        Collections.sort(subAreaLabels);

        totalStringBuilder.append(StringUtils.join(subAreaLabels, " "));

    private class AreaNodeComparator implements Comparator<AreaNode>{

        @Override

        public int compare(AreaNode areaNode1, AreaNode areaNode2) {

            NamedArea area1 = areaNode1.area;

            NamedArea area2 = areaNode2.area;

            if (area1 == null && area2 == null){

                return 0;

            }else if (area1 == null){

                return -1;

            }else if (area2 == null){

                return 1;

            }else{

                //- due to wrong ordering behavior in DefinedTerms

                return - area1.compareTo(area2);

    }

// $Id$

/**

* Copyright (C) 2015 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.cdm.ext.geo;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.api.service.dto.CondensedDistribution;

import eu.etaxonomy.cdm.common.UTF8;

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.location.NamedArea;

/**

 * @author a.mueller

 * @date Apr 05, 2016

 *

 */

public class FloraCubaCondensedDistributionComposerOld extends CondensedDistributionComposerBase {

    @SuppressWarnings("unused")

    private static final Logger logger = Logger.getLogger(FloraCubaCondensedDistributionComposerOld.class);

//    private static Set<UUID> foreignStatusUuids;

    private UUID uuidInternalArea = UUID.fromString("d0144a6e-0e17-4a1d-bce5-d464a2aa7229");  //Cuba

    private String internalAreaSeparator = UTF8.EN_DASH.toString() + " ";

//    // these status uuids are special for EuroPlusMed and might also be used

//    private final static UUID REPORTED_IN_ERROR_UUID =  UUID.fromString("38604788-cf05-4607-b155-86db456f7680");

    static {

        // ==================================================

        // Mapping as defined in ticket http://dev.e-taxonomy.eu/trac/ticket/5682

        // ==================================================

       statusSymbols = new HashMap<UUID, String> ();

       //no entries as we handle symbols now on model level

    }

    /**

     * {@inheritDoc}

     * @return

     */

    @Override

    public CondensedDistribution createCondensedDistribution(Collection<Distribution> filteredDistributions,

            List<Language> languages) {

        CondensedDistribution condensedDistribution = new CondensedDistribution();

        //empty

        if (filteredDistributions == null || filteredDistributions.isEmpty()){

            return condensedDistribution;

        }

        OrderedTermVocabulary<NamedArea> areaVocabulary = CdmBase.deproxy(filteredDistributions.iterator().next().getArea().getVocabulary(), OrderedTermVocabulary.class);

        //deproxy and reverse order

        List<NamedArea> areaList = new ArrayList<NamedArea>();

        for (DefinedTermBase<NamedArea> dtb : areaVocabulary.getOrderedTerms()){

            areaList.add(0, (NamedArea)CdmBase.deproxy(dtb));

        }

        boolean isFirstAfterInternalArea = false;

        for (NamedArea area : areaList){

            if (area.getPartOf() != null){

                continue;  //subarea are handled later

            }

            StringBuilder areaStatusString = new StringBuilder();

            Distribution distribution = getDistribution(area, filteredDistributions);

            if (distribution == null){

                continue;

            }

            if (area.getUuid().equals(uuidInternalArea)){

                isFirstAfterInternalArea = true;

            }else if(isFirstAfterInternalArea && !area.getUuid().equals(uuidInternalArea)){

                areaStatusString.append(internalAreaSeparator);

                isFirstAfterInternalArea = false;

            }

            PresenceAbsenceTerm status = distribution.getStatus();

            String statusSymbol = statusSymbol(status);

            areaStatusString.append(statusSymbol);

            String areaLabel = makeAreaLabel(languages, area);

            areaStatusString.append(areaLabel);

            if(!area.getIncludes().isEmpty()) {

//                areaStatusString.append('(');

                subAreaLabels(languages, area.getIncludes(), areaStatusString, statusSymbol, areaLabel, filteredDistributions);

//                areaStatusString.append(')');

            }

//            if(isForeignStatus(status)) {

//                condensedDistribution.addForeignDistributionItem(status, areaStatusString.toString(), areaLabel);

//            } else {

                condensedDistribution.addIndigenousDistributionItem(status, areaStatusString.toString(), areaLabel);

//            }

        }

//        }

//        //5. order the condensedDistributions alphabetically

//        // FIXME

//        condensedDistribution.sortForeign();

//        condensedDistribution.sortIndigenous();

        return condensedDistribution;

    }

    /**

     * @param area

     * @param filteredDistributions

     * @return

     */

    private Distribution getDistribution(NamedArea area, Collection<Distribution> filteredDistributions) {

        for (Distribution dist : filteredDistributions){

            if (dist.getArea() != null && dist.getArea().equals(area)){

                return dist;

            }

        }

        return null;

    }

//    private boolean isForeignStatus(PresenceAbsenceTerm status) {

//        return foreignStatusUuids.contains(status.getUuid());

//    }

    /**

     * @param langs

     * @param node

     * @param areaString

     * @param statusSymbol

     */

    private void subAreaLabels(List<Language> langs, Collection<NamedArea> subAreas, StringBuilder areaString,

            String statusSymbol, String parentLabel,

            Collection<Distribution> filteredDistributions) {

        //TODO very redundant with main method

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

        //deproxy and reverse order

        List<NamedArea> areaList = new ArrayList<NamedArea>();

        for (DefinedTermBase<NamedArea> dtb : subAreas){

            areaList.add(0, (NamedArea)CdmBase.deproxy(dtb));

        }

//        Collections.sort(areaList);

        for(NamedArea area : areaList) {

            StringBuilder subAreaString = new StringBuilder();

            Distribution distribution = getDistribution(area, filteredDistributions);

            if (distribution == null){

                continue;

            }

            PresenceAbsenceTerm status = distribution.getStatus();

            String subAreaStatusSymbol = statusSymbol(status);

            if (subAreaStatusSymbol != null && !subAreaStatusSymbol.equals(statusSymbol)){

                subAreaString.append(subAreaStatusSymbol);

            }

            String areaLabel = makeAreaLabel(langs, area);

//            String cleanSubAreaLabel = StringUtils.replaceEach(areaLabel, new String[] {parentLabel, "(", ")"}, new String[] {"", "", ""});

            String cleanSubAreaLabel = areaLabel;

            subAreaString.append(cleanSubAreaLabel);

            if(!area.getIncludes().isEmpty()) {

//                subAreaString.append('(');

                subAreaLabels(langs, area.getIncludes(), subAreaString, subAreaStatusSymbol, areaLabel, filteredDistributions);

//                subAreaString.append(')');

            }

            subAreaLabels.add(subAreaString.toString());

        }

//      Collections.sort(subAreaLabels);

        if (!subAreaLabels.isEmpty()){

            areaString.append("(" + StringUtils.join(subAreaLabels, " ") + ")");

        }

    }

    public String getInternalAreaSeparator() {

        return internalAreaSeparator;

    }

    public void setInternalAreaSeparator(String internalAreaSeparator) {

        this.internalAreaSeparator = internalAreaSeparator;

    }

}

 * Tests for {@link FloraCubaCondensedDistributionComposerOld}

     * Test method for {@link eu.etaxonomy.cdm.ext.geo.FloraCubaCondensedDistributionComposerOld#createCondensedDistribution(java.util.Collection, java.util.List)}.

        composer.setAreaPreTag("<b>");

        composer.setAreaPostTag("</b>");

        filteredDistributions.add(Distribution.NewInstance(westernCuba, statusVoc.findTermByUuid(uuidStatusDoubtfullyNativeError)));

        Assert.assertEquals("Condensed string for Cuba differs", "n<b>Cu</b>(-d<b>CuW</b>(-c<b>PR*</b>) (c)<b>CuE</b>(n<b>Ho</b>)) " + composer.getInternalAreaSeparator() + "<b>Bah</b> ?<b>VM</b> ", condensedString);

//        cuba.addIncludes(westernCuba);

        cuba.addIncludes(westernCuba);