EDIT

/**

 * 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.cdm.io.redlist.gefaesspflanzen;

import java.sql.ResultSet;

import java.sql.SQLException;

import java.util.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.io.common.IPartitionedIO;

import eu.etaxonomy.cdm.io.common.ImportHelper;

import eu.etaxonomy.cdm.io.common.ResultSetPartitioner;

import eu.etaxonomy.cdm.io.common.mapping.UndefinedTransformerMethodException;

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

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

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

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

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

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

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

/**

 * @author pplitzner

 * @date Mar 1, 2016

 *

@Component

@SuppressWarnings("serial")

public class RedListGefaesspflanzenImportNames extends DbImportBase<RedListGefaesspflanzenImportState, RedListGefaesspflanzenImportConfigurator> {

    private static final String tableName = "Rote Liste Gefäßpflanzen";

    private static final String pluralString = "names";

    public RedListGefaesspflanzenImportNames() {

        super(tableName, pluralString);

    }

    @Override

    protected String getIdQuery(RedListGefaesspflanzenImportState state) {

        return "SELECT NAMNR "

                + "FROM V_TAXATLAS_D20_EXPORT t "

                + " ORDER BY NAMNR";

    }

    @Override

    protected String getRecordQuery(RedListGefaesspflanzenImportConfigurator config) {

        String result = " SELECT * "

                + " FROM V_TAXATLAS_D20_EXPORT t "

                + " WHERE t.NAMNR IN (@IDSET)";

        result = result.replace("@IDSET", IPartitionedIO.ID_LIST_TOKEN);

        return result;

    }

    @Override

    protected void doInvoke(RedListGefaesspflanzenImportState state) {

        super.doInvoke(state);

    }

    @Override

    public boolean doPartition(ResultSetPartitioner partitioner, RedListGefaesspflanzenImportState state) {

        ResultSet rs = partitioner.getResultSet();

        Set<TaxonBase<?>> taxaToSave = new HashSet<TaxonBase<?>>();

            while (rs.next()){

            }

        } catch (SQLException e) {

            e.printStackTrace();

        }

        getTaxonService().saveOrUpdate((TaxonBase) taxaToSave);

    }

        String relationE = rs.getString(RedListUtil.E);

        String relationW = rs.getString(RedListUtil.W);

        String relationK = rs.getString(RedListUtil.K);

        String relationAW = rs.getString(RedListUtil.AW);

        String relationAO = rs.getString(RedListUtil.AO);

        String relationR = rs.getString(RedListUtil.R);

        String relationO = rs.getString(RedListUtil.O);

        String relationS = rs.getString(RedListUtil.S);

        //---TAXON---

            RedListUtil.logMessage(id, "Taxon for name "+name+" could not be created.", logger);

            return;

        /*check if taxon/synonym also exists in other classification

         * 1. create new taxon with the same name (in that classification)

         * 2. create concept relationship between both

        addConceptRelation(relationE, RedListUtil.CLASSIFICATION_NAMESPACE_E, taxonBase, name, taxaToSave, id, state);

        addConceptRelation(relationW, RedListUtil.CLASSIFICATION_NAMESPACE_W, taxonBase, name, taxaToSave, id, state);

        addConceptRelation(relationK, RedListUtil.CLASSIFICATION_NAMESPACE_K, taxonBase, name, taxaToSave, id, state);

        addConceptRelation(relationAW, RedListUtil.CLASSIFICATION_NAMESPACE_AW, taxonBase, name, taxaToSave, id, state);

        addConceptRelation(relationAO, RedListUtil.CLASSIFICATION_NAMESPACE_AO, taxonBase, name, taxaToSave, id, state);

        addConceptRelation(relationR, RedListUtil.CLASSIFICATION_NAMESPACE_R, taxonBase, name, taxaToSave, id, state);

        addConceptRelation(relationO, RedListUtil.CLASSIFICATION_NAMESPACE_O, taxonBase, name, taxaToSave, id, state);

        addConceptRelation(relationS, RedListUtil.CLASSIFICATION_NAMESPACE_S, taxonBase, name, taxaToSave, id, state);

        //NOTE: the source has to be added after cloning or otherwise the clone would also get the source

        ImportHelper.setOriginalSource(taxonBase, state.getTransactionalSourceReference(), id, RedListUtil.TAXON_GESAMTLISTE_NAMESPACE);

        taxaToSave.add(taxonBase);

    }

            TaxonRelationshipType taxonRelationshipTypeByKey = new RedListGefaesspflanzenTransformer().getTaxonRelationshipTypeByKey(substring);

            }

            //there is no type "included in" so we have to reverse the direction

            if(substring.equals("<")){

                cloneTaxon(taxonBase, name, taxonRelationshipTypeByKey, taxaToSave, id, classificationNamespace, true, false, state);

            }

            else{

                cloneTaxon(taxonBase, name, taxonRelationshipTypeByKey, taxaToSave, id, classificationNamespace, false, false, state);

        }

    }

     * <b>NOTE:</b> the {@link TaxonRelationshipType} passed as parameter is

     * This can be changed with parameter <i>reverseRelation</i>

        TaxonBase<?> clone = (TaxonBase<?>) taxonBase.clone();

        if(taxonBase.isInstanceOf(Taxon.class)){

            TaxonRelationship taxonRelation;

            if(reverseRelation){

                taxonRelation = ((Taxon) taxonBase).addTaxonRelation((Taxon) clone, relationFromCloneToTaxon, null, null);

                taxonRelation = ((Taxon) clone).addTaxonRelation((Taxon) taxonBase, relationFromCloneToTaxon, null, null);

            }

            taxonRelation.setDoubtful(doubtful);

        }

        ImportHelper.setOriginalSource(clone, state.getTransactionalSourceReference(), id, sourceNameSpace);

        taxaToSave.add(clone);

        long id = rs.getLong(RedListUtil.NAMNR);

        String taxNameString = rs.getString(RedListUtil.TAXNAME);

        String gueltString = rs.getString(RedListUtil.GUELT);

        String trivialString = rs.getString(RedListUtil.TRIVIAL);

        String authorBasiString = rs.getString(RedListUtil.AUTOR_BASI);

        String hybString = rs.getString(RedListUtil.HYB);

        TaxonBase<?> taxonBase = null;

            taxonBase = Taxon.NewInstance(name, null);

            taxonBase.setAppendedPhrase(RedListUtil.AUCT);

            taxonBase = Taxon.NewInstance(name, null);

            taxonBase = Synonym.NewInstance(name, null);

            return null;

        if(taxonBase.isInstanceOf(Taxon.class) && trivialString!=null){

            Taxon taxon = HibernateProxyHelper.deproxy(taxonBase, Taxon.class);

            TaxonDescription description = TaxonDescription.NewInstance(taxon);

            description.addElement(CommonTaxonName.NewInstance(trivialString, Language.getDefaultLanguage()));

        }

        checkTaxonNameConsistency(id, taxNameString, hybString, taxonBase);

        return taxonBase;

    }

        long id = rs.getLong(RedListUtil.NAMNR);

        String nomZusatzString = rs.getString(RedListUtil.NOM_ZUSATZ);

        String taxZusatzString = rs.getString(RedListUtil.TAX_ZUSATZ);

        String zusatzString = rs.getString(RedListUtil.ZUSATZ);

        String authorKombString = rs.getString(RedListUtil.AUTOR_KOMB);

        String authorBasiString = rs.getString(RedListUtil.AUTOR_BASI);

                if(i==0){

                    //first author is ex author

                }

                else{

                }

            }

        }

        }

        //basionym author

            String[] basiSplit = authorBasiString.split(RedListUtil.EX);

                        name.setExCombinationAuthorship(authorBasi);

                    }

                    else{

                        name.setExBasionymAuthorship(authorBasi);

                    }

                else{

                        name.setCombinationAuthorship(authorBasi);

                    }

                    else{

                        name.setBasionymAuthorship(authorBasi);

                    }

            }

        }

                name.setCombinationAuthorship(authorBasi);

            }

            else{

                name.setBasionymAuthorship(authorBasi);

            }

        //check authorship consistency

    }

        long id = rs.getLong(RedListUtil.NAMNR);

        String taxNameString = rs.getString(RedListUtil.TAXNAME);

        String rangString = rs.getString(RedListUtil.RANG);

        String ep1String = rs.getString(RedListUtil.EPI1);

        String ep2String = rs.getString(RedListUtil.EPI2);

        String ep3String = rs.getString(RedListUtil.EPI3);

        String nomZusatzString = rs.getString(RedListUtil.NOM_ZUSATZ);

        String hybString = rs.getString(RedListUtil.HYB);

            RedListUtil.logMessage(id, "No name found!", logger);

        }

        Rank rank = makeRank(id, state, rangString);

        //ep1 should always be present

        if(CdmUtils.isBlank(ep1String)){

            RedListUtil.logMessage(id, RedListUtil.EPI1+" is empty!", logger);

        }

        name.setGenusOrUninomial(ep1String);

        if(CdmUtils.isNotBlank(ep2String)){

            name.setSpecificEpithet(ep2String);

        }

        if(CdmUtils.isNotBlank(ep3String)){

        //nomenclatural status

        if(CdmUtils.isNotBlank(nomZusatzString)){

            NomenclaturalStatusType status = makeNomenclaturalStatus(id, state, nomZusatzString);

            if(status!=null){

                name.addStatus(NomenclaturalStatus.NewInstance(status));

            }

        }

        //hybrid

            if(hybString.equals(RedListUtil.HYB_X)){

                name.setBinomHybrid(true);

            }

                name.setMonomHybrid(true);

            }

                name.setHybridFormula(true);

                if(ep1String.contains(RedListUtil.HYB_SIGN)){

                    RedListUtil.logMessage(id, "EPI1 has hybrid signs but with flag: "+RedListUtil.HYB_XF, logger);

                }

                else if(ep2String.contains(RedListUtil.HYB_SIGN)){

                    String[] split = ep2String.split(RedListUtil.HYB_SIGN);

                    if(split.length!=2){

                        RedListUtil.logMessage(id, "Multiple hybrid signs found in "+ep2String, logger);

                    }

                    String hybridFormula1 = ep1String+" "+split[0].trim();

                    String hybridFormula2 = ep1String+" "+split[1].trim();

                    if(CdmUtils.isNotBlank(ep3String)){

                        hybridFormula1 += " "+ep3String;

                        hybridFormula2 += " "+ep3String;

                    }

                    String fullFormula = hybridFormula1+" "+RedListUtil.HYB_SIGN+" "+hybridFormula2;

                    name = NonViralNameParserImpl.NewInstance().parseFullName(fullFormula);

                }

                else if(ep3String.contains(RedListUtil.HYB_SIGN)){

                    String[] split = ep3String.split(RedListUtil.HYB_SIGN);

                    if(split.length!=2){

                        RedListUtil.logMessage(id, "Multiple hybrid signs found in "+ep3String, logger);

                    }

                    String hybridFormula1 = ep1String+" "+ep2String+" "+split[0];

                    String hybridFormula2 = ep1String+" "+ep2String+" "+split[1];

                    String fullFormula = hybridFormula1+" "+RedListUtil.HYB_SIGN+" "+hybridFormula2;

                    name = NonViralNameParserImpl.NewInstance().parseFullName(fullFormula);

                }

            }

                name = NonViralNameParserImpl.NewInstance().parseFullName(ep1String+" "+ep2String+" nothosubsp. "+ep3String);

            }

            else if(hybString.equals(RedListUtil.HYB_GF)){

                if(ep1String.contains(RedListUtil.HYB_SIGN)){

                    name = NonViralNameParserImpl.NewInstance().parseFullName(ep1String);

                }

                else{

                    RedListUtil.logMessage(id, "HYB is "+hybString+" but "+RedListUtil.HYB+" does not contain "+RedListUtil.HYB_SIGN, logger);

                }

            }

            else{

                logger.error("HYB value "+hybString+" not yet handled");

            }

        //add source

        ImportHelper.setOriginalSource(name, state.getTransactionalSourceReference(), id, RedListUtil.NAME_NAMESPACE);

        return name;

    }

    private void checkAuthorShipConsistency(long id, String nomZusatzString, String taxZusatzString,

            String zusatzString, String authorString, String authorshipCache) {

        }

            authorString = authorString.replace(", "+nomZusatzString, "");

        }

        if(CdmUtils.isNotBlank(taxZusatzString)){

            authorString = authorString.replace(", "+taxZusatzString, "");

        }

        }

            if(HibernateProxyHelper.deproxy(taxonBase.getName(),NonViralName.class).getHybridChildRelations().isEmpty()){

                RedListUtil.logMessage(id, "Hybrid name but no hybrid child relations", logger);

                return;

            }

            return;

        }

        String nameCache = HibernateProxyHelper.deproxy(taxonBase.getName(), NonViralName.class).getNameCache().trim();

            taxNameString = taxNameString.replace("agg.", "aggr.");

        }

            taxNameString.replaceAll("- Gruppe", "species group");

        }

        if(taxNameString.endsWith("- group")){

            taxNameString.replaceAll("- group", "species group");

            RedListUtil.logMessage(id, "Taxon name inconsistent! taxon.titleCache <-> Column "+RedListUtil.TAXNAME+": "+nameCache+" <-> "+taxNameString, logger);

        }

        try {

            rank = state.getTransformer().getRankByKey(rankStr);

        } catch (UndefinedTransformerMethodException e) {

            e.printStackTrace();

        }

    }

        NomenclaturalStatusType status = null;

        try {

            status = state.getTransformer().getNomenclaturalStatusByKey(nomZusatzString);

        } catch (UndefinedTransformerMethodException e) {

            e.printStackTrace();

        }

        if(status==null){

            RedListUtil.logMessage(id, nomZusatzString+" could not be associated to a known nomenclatural status.", logger);

        }

        return status;

    }

    @Override

    public Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForPartition(ResultSet rs,

            RedListGefaesspflanzenImportState state) {

        Map<Object, Map<String, ? extends CdmBase>> result = new HashMap<>();

        try {

            while (rs.next()){

                    String[] kombSplit = authorKombString.split(RedListUtil.EX);

                        if(!authorMap.containsKey(kombSplit[i])){

                            authorMap.put(kombSplit[i], getAgentService().load(state.getAuthorMap().get(kombSplit[i])));

                        }

                    }

                }

                }

                    String[] basiSplit = authorBasiString.split(RedListUtil.EX);

                        if(!authorMap.containsKey(basiSplit[i])){

                            authorMap.put(basiSplit[i], getAgentService().load(state.getAuthorMap().get(basiSplit[i])));

                        }

                    }

                }

                }

            }

        } catch (SQLException e) {

            e.printStackTrace();

        }

        return result;

    }

    @Override

    protected boolean doCheck(RedListGefaesspflanzenImportState state) {

        return false;

    }

    @Override

    protected boolean isIgnore(RedListGefaesspflanzenImportState state) {

        return false;

    }

}