EDIT

import java.util.HashMap;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Map;

import java.util.Set;

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

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

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

import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;

import eu.etaxonomy.cdm.common.monitor.NullProgressMonitor;

import eu.etaxonomy.cdm.common.monitor.SubProgressMonitor;

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

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

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

/**

 *

@Service

public class TransmissionEngineDistribution { //TODO extends IoBase?

    public static final String EXTENSION_VALUE_PREFIX = "transmissionEngineDistribution.priority:";

    public static final Logger logger = Logger.getLogger(TransmissionEngineDistribution.class);

    private final Map<NamedArea, Set<NamedArea>> subAreaMap = new HashMap<NamedArea, Set<NamedArea>>();

    int byRankTicks = 300;

    int byAreasTicks = 100;

    /**

     * byAreaIgnoreStatusList contains by default:

     *  <ul>

     *            should be reported and that the operation cannot be cancelled.

     */

    public void accumulate(AggregationMode mode, List<NamedArea> superAreas, Rank lowerRank, Rank upperRank,

        if (monitor == null) {

            monitor = new NullProgressMonitor();

        }

        // only for debugging:

        //logger.setLevel(Level.TRACE); // TRACE will slow down a lot since it forces loading all term representations

        //Logger.getLogger("org.hibernate.SQL").setLevel(Level.DEBUG);

     * @param superAreas

     *      the areas to which the subordinate areas should be projected

     * @param classificationLookupDao

     *

     */

        TransactionStatus txStatus = startTransaction(false);

        subMonitor.beginTask("Accumulating by area ",  classificationLookupDao.getTaxonIds().size());

        Iterator<Integer> taxonIdIterator = classificationLookupDao.getTaxonIds().iterator();

            if(txStatus == null) {

                // transaction has been comitted at the end of this batch, start a new one

            List<NamedArea> superAreaList = (List)termService.find(superAreaUuids);

            // load taxa for this batch

//            logger.debug("accumulateByArea() - taxon " + taxonPager.getFirstRecord() + " to " + taxonPager.getLastRecord() + " of " + taxonPager.getCount() + "]");

            // iterate over the taxa and accumulate areas

            for(TaxonBase taxonBase : taxa) {

                if(logger.isDebugEnabled()){

                    logger.debug("accumulateByArea() - taxon :" + taxonToString(taxonBase));

                }

                Taxon taxon = (Taxon)taxonBase;

                TaxonDescription description = findComputedDescription(taxon, doClearDescriptions);

                List<Distribution> distributions = distributionsFor(taxon);

                descriptionService.saveOrUpdate(description);

                taxonService.saveOrUpdate(taxon);

                subMonitor.worked(1);

            } // next taxon

    *  <li>the source reference of the accumulated distributions are also accumulated into the new distribution,

    *    this has been especially implemented for the EuroMed Checklist Vol2 and might not be a general requirement</li>

    *</ul>

    */

        int ticksPerRank = 100;

        TransactionStatus txStatus = startTransaction(false);

            Iterator<Integer> taxonIdIterator = taxonIdsPerRank.iterator();

                if(txStatus == null) {

                    // transaction has been committed at the end of this batch, start a new one

                }

                // load taxa for this batch

                taxa = taxonService.loadByIds(taxonIds, null);

                for(TaxonBase taxonBase : taxa) {

                    Taxon taxon = (Taxon)taxonBase;

                    if (taxaProcessedIds.contains(taxon.getId())) {

                        if(logger.isDebugEnabled()){

                    }

                    if(!childTaxonIds.isEmpty()) {

                        childTaxa = taxonService.loadByIds(childTaxonIds, TAXONDESCRIPTION_INIT_STRATEGY);

                            Taxon childTaxon = (Taxon) childTaxonBase;

                            getSession().setReadOnly(childTaxon, true);

                                StatusAndSources subStatusAndSources = new StatusAndSources(status, distribution.getSources());

                                accumulatedStatusMap.put(area, choosePreferred(accumulatedStatusMap.get(area), subStatusAndSources, null));

                             }

                        }

                        if(accumulatedStatusMap.size() > 0) {

                    }

                    taxonSubMonitor.worked(1); // one taxon worked

                } // next taxon ....

                commitTransaction(txStatus);

                txStatus = null;

                if(ONLY_FISRT_BATCH) {

                    break;

                }

    /**

     *

     */

        getSession().flush();

        try {

            Search.getFullTextSession(getSession()).flushToIndexes();

        } catch (HibernateException e) {

            /* IGNORE - Hibernate Search Event listeners not configured ... */

                throw e;

            }

        }

    }

    // TODO merge with CdmApplicationDefaultConfiguration#startTransaction() into common base class

    public TransactionStatus startTransaction(Boolean readOnly) {

        // find existing one

        for (TaxonDescription description : taxon.getDescriptions()) {

            if (description.hasMarker(MarkerType.COMPUTED(), true)) {

                if (doClear) {

                    int deleteCount = 0;

                    Set<DescriptionElementBase> deleteCandidates = new HashSet<DescriptionElementBase>();

    private List<Distribution> distributionsFor(Taxon taxon) {

        List<Distribution> distributions = new ArrayList<Distribution>();

        for(TaxonDescription description: taxon.getDescriptions()) {

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

                if(deb instanceof Distribution) {

                    distributions.add((Distribution)deb);

                }

            }