EDIT

/**

* Copyright (C) 2007 EDIT

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.io.berlinModel.in;

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 java.util.UUID;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.database.update.DatabaseTypeNotSupportedException;

import eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer;

import eu.etaxonomy.cdm.io.berlinModel.in.validation.BerlinModelTaxonNameImportValidator;

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

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

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

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

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

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.Team;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

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

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

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

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

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

import eu.etaxonomy.cdm.model.reference.Reference;

import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;

/**

 * @author a.mueller

@Component

public class BerlinModelTaxonNameImport extends BerlinModelImportBase {

    private static final boolean BLANK_TO_NULL = true;

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

	public static final String NAMESPACE = "TaxonName";

	private static final String pluralString = "TaxonNames";

	private static final String dbTableName = "Name";

	public BerlinModelTaxonNameImport(){

		super(dbTableName, pluralString);

	}

	@Override

	protected String getIdQuery(BerlinModelImportState state) {

		if (state.getConfig().getNameIdTable()==null ){

			return super.getIdQuery(state);

		}else{

	}

	protected String getRecordQuery(BerlinModelImportConfigurator config) {

		Source source = config.getSource();

			String strFacTable = "RefDetail";

			String strFacColumn = "IdInSource";

			String strColAlias = null;

			if (checkSqlServerColumnExists(source, strFacTable, strFacColumn)){

				facultativCols +=  ", " + strFacTable + "." + strFacColumn ;

				if (! CdmUtils.Nz(strColAlias).equals("") ){

					facultativCols += " AS " + strColAlias;

				}

			}

                      		facultativCols +

                    " FROM Name LEFT OUTER JOIN RefDetail ON Name.NomRefDetailFk = RefDetail.RefDetailId AND  " +

                    	" Name.NomRefFk = RefDetail.RefFk " +

					//strQuery += " AND RefDetail.PreliminaryFlag = 1 ";

					//strQuery += " AND Name.Created_When > '03.03.2004' ";

		return strRecordQuery +  "";

	}

	@Override

	protected void doInvoke(BerlinModelImportState state) {

		//update rank labels if necessary

		String strAbbrev = state.getConfig().getInfrGenericRankAbbrev();

		Rank rank = Rank.INFRAGENERICTAXON();

		testRankAbbrev(strAbbrev, rank);

		rank = Rank.INFRASPECIFICTAXON();

		testRankAbbrev(strAbbrev, rank);

	}

	private void testRankAbbrev(String strAbbrev, Rank rank) {

		if (strAbbrev != null){

			Representation rep = rank.getRepresentation(Language.ENGLISH());

			rep.setAbbreviatedLabel(strAbbrev);

			getTermService().saveOrUpdate(rank);

		}

	}

		String dbAttrName;

		String cdmAttrName;

		boolean success = true ;

		BerlinModelImportConfigurator config = state.getConfig();

			int i = 0;

			//for each reference

			while (rs.next()){

				int nameId = rs.getInt("nameId");

				Object authorFk = rs.getObject("AuthorTeamFk");

				Object exAuthorFk = rs.getObject("ExAuthorTeamFk");

				Object basAuthorFk = rs.getObject("BasAuthorTeamFk");

				Object exBasAuthorFk = rs.getObject("ExBasAuthorTeamFk");

				String strCultivarGroupName = rs.getString("CultivarGroupName");

				String strCultivarName = rs.getString("CultivarName");

				String nameCache = rs.getString("NameCache");

				String fullNameCache = rs.getString("FullNameCache");

				if (resultSetHasColumn(rs,"UUID")){

					uuid = rs.getString("UUID");

				}

					boolean useUnknownRank = true;

					Rank rank = BerlinModelTransformer.rankId2Rank(rs, useUnknownRank, config.isSwitchSpeciesGroup());

					if (rank == null || rank.equals(Rank.UNKNOWN_RANK()) || (rank.equals(Rank.INFRASPECIFICTAXON()) && ! allowInfraSpecTaxonRank)){

						rank = handleProlesAndRaceSublusus(state, rs, rank);

					}

						getTermService().save(rank);

						logger.warn("Rank did not yet exist: " +  rank.getTitleCache());

					}

						}

					}else{

						//TODO rank should never be null or a more sophisticated algorithm has to be implemented for genus/supraGenericName

					}

					if (rank != null && rank.isSupraGeneric()){

						dbAttrName = "supraGenericName";

					}else{

						dbAttrName = "genus";

					}

					cdmAttrName = "genusOrUninomial";

					cdmAttrName = "infraGenericEpithet";

					cdmAttrName = "specificEpithet";

					cdmAttrName = "infraSpecificEpithet";

					cdmAttrName = "appendedPhrase";

					dbAttrName = "details";

					cdmAttrName = "nomenclaturalMicroReference";

					boolean colExists = true;

					try {

						colExists = state.getConfig().getSource().checkColumnExists("Name", "Source_Acc");

					} catch (DatabaseTypeNotSupportedException e) {

						logger.debug("Source does not support 'checkColumnExists'");

					}

					if (colExists){

						String sourceAcc = rs.getString("Source_Acc");

					}

					boolean excludeUpdated = true;

					success &= doIdCreatedUpdatedNotes(state, taxonName, rs, nameId, NAMESPACE, excludeUpdated, excludeNotes);

					handleNameNotes(state, taxonName, rs, nameId);

						INonViralName nonViralName = taxonName;

						if (teamMap != null ){

							nonViralName.setExCombinationAuthorship(getAuthorTeam(teamMap, exAuthorFk, nameId, config));

							nonViralName.setBasionymAuthorship(getAuthorTeam(teamMap, basAuthorFk, nameId, config));

							nonViralName.setExBasionymAuthorship(getAuthorTeam(teamMap, exBasAuthorFk, nameId, config));

							logger.warn("TeamMap is null");

							success = false;

						}

					}//nonviralName

						IZoologicalName zooName = taxonName;

					}

						IBotanicalName botName = taxonName;

					Boolean preliminaryFlag = rs.getBoolean("PreliminaryFlag");

					Boolean hybridFormulaFlag = rs.getBoolean("HybridFormulaFlag");  //hybrid flag does not lead to cache update in Berlin Model

					if (preliminaryFlag == true || hybridFormulaFlag == true){

						taxonName.setFullTitleCache(taxonName.getFullTitleCache(), true);

						if (taxonName.isNonViral()){

							INonViralName nvn = taxonName;

							nvn.setAuthorshipCache(nvn.getAuthorshipCache(), true);

						}

					}

				catch (UnknownCdmTypeException e) {

					logger.warn("Name with id " + nameId + " has unknown rankId " + " and could not be saved.");

		} catch (SQLException e) {

			logger.error("SQLException:" +  e);

			return false;

		}

		getNameService().save(namesToSave);

		return success;

	}

     * @param state

     * @param taxonName

     * @param rs

     * @param nameId

	 * @throws SQLException

     */

    private void handleNameNotes(BerlinModelImportState state, TaxonName taxonName, ResultSet rs, int nameId) throws SQLException {

        String notesOrig = rs.getString("notes");

        String notes = filterNotes(notesOrig, nameId);

        if (isNotBlank(notes) && taxonName != null ){

            String notesString = String.valueOf(notes);

            if (notesString.length() > 65530 ){

                notesString = notesString.substring(0, 65530) + "...";

                logger.warn("Notes string is longer than 65530 and was truncated: " + taxonName);

            }

            Annotation notesAnnotation = Annotation.NewInstance(notesString, Language.DEFAULT());

            //notesAnnotation.setAnnotationType(AnnotationType.EDITORIAL());

            //notes.setCommentator(bmiConfig.getCommentator());

            taxonName.addAnnotation(notesAnnotation);

        }

    }

    private static final String MCL = "MCL\\s?[0-9]{1,3}(\\-[0-9]{1,4}(\\-[0-9]{1,4}(\\-[0-9]{1,4}(\\-[0-9]{1,3})?)?)?)?";

    /**

     * @param notes

     */

    private String filterNotes(String notes, int nameId) {

        String result;

        if (isBlank(notes)){

            result = null;

        }else if (notes.matches("Acc:.*")){

            if (notes.matches("Acc: .*\\$$") || (notes.matches("Acc: .*"+MCL))){

                result = null;

            }else if (notes.matches("Acc: .*(\\$|"+MCL+")\\s*\\{.*\\}")){

                notes = notes.substring(notes.indexOf("{")+1, notes.length()-1);

                result = notes;

            }else if (notes.matches("Acc: .*(\\$|"+MCL+")\\s*\\[.*\\]")){

                notes = notes.substring(notes.indexOf("[")+1, notes.length()-1);

                result = notes;

            }else{

                logger.warn("Name id: " + nameId + ". Namenote: " + notes);

                result = notes;

            }

        }else if (notes.matches("Syn:.*")){

            if (notes.matches("Syn: .*\\$$") || (notes.matches("Syn: .*"+MCL))){

                result = null;

            }else if (notes.matches("Syn: .*(\\$|"+MCL+")\\s*\\{.*\\}")){

                notes = notes.substring(notes.indexOf("{")+1, notes.length()-1);

                result = notes;

            }else if (notes.matches("Syn: .*(\\$|"+MCL+")\\s*\\[.*\\]")){

                notes = notes.substring(notes.indexOf("[")+1, notes.length()-1);

                result = notes;

            }else{

                logger.warn("Name id: " + nameId + ". Namenote: " + notes);

                result = notes;

            }

        }else{

            result = notes;

        }

        return result;

    }

    private Rank handleProlesAndRaceSublusus(BerlinModelImportState state, ResultSet rs, Rank rank) throws SQLException {

		String rankAbbrev = rs.getString("RankAbbrev");

//		String rankStr = rs.getString("Rank");

		if (CdmUtils.nullSafeEqual(rankAbbrev, "prol.") ){

			result = Rank.PROLES();

		}else if(CdmUtils.nullSafeEqual(rankAbbrev, "race")){

			result = Rank.RACE();

		}else if(CdmUtils.nullSafeEqual(rankAbbrev, "sublusus")){

			result = Rank.SUBLUSUS();

		}else{

			result = rank;

			logger.warn("Unhandled rank: " + rankAbbrev);

		}

		return result;

	}

	public Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForPartition(ResultSet rs, BerlinModelImportState state) {

			Set<String> teamIdSet = new HashSet<String>();

			Set<String> referenceIdSet = new HashSet<String>();

			Set<String> refDetailIdSet = new HashSet<String>();

			while (rs.next()){

				handleForeignKey(rs, teamIdSet, "AuthorTeamFk");

				handleForeignKey(rs, teamIdSet, "ExAuthorTeamFk");

				handleForeignKey(rs, teamIdSet, "BasAuthorTeamFk");

				handleForeignKey(rs, teamIdSet, "ExBasAuthorTeamFk");

				handleForeignKey(rs, referenceIdSet, "nomRefFk");

				handleForeignKey(rs, refDetailIdSet, "nomRefDetailFk");

			}

			nameSpace = BerlinModelAuthorTeamImport.NAMESPACE;

			cdmClass = Team.class;

			idSet = teamIdSet;

			Map<String, Person> teamMap = (Map<String, Person>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);

			result.put(nameSpace, teamMap);

			//reference map

			nameSpace = BerlinModelReferenceImport.REFERENCE_NAMESPACE;

			cdmClass = Reference.class;

			idSet = referenceIdSet;

			Map<String, Reference> referenceMap = (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);

			result.put(nameSpace, referenceMap);

			nameSpace = BerlinModelRefDetailImport.REFDETAIL_NAMESPACE;

			cdmClass = Reference.class;

			idSet = refDetailIdSet;

			Map<String, Reference> refDetailMap= (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);

			result.put(nameSpace, refDetailMap);

			throw new RuntimeException(e);

		}

		return result;

	}

		boolean success = true;

		//publicationYear

		String authorTeamYear = rs.getString("authorTeamYear");

		try {

			if (! "".equals(CdmUtils.Nz(authorTeamYear).trim())){

				Integer publicationYear  = Integer.valueOf(authorTeamYear.trim());

				zooName.setPublicationYear(publicationYear);

			}

		} catch (NumberFormatException e) {

			logger.warn("authorTeamYear could not be parsed for taxonName: "+ nameId);

		}

		//original publication year

		String basAuthorTeamYear = rs.getString("basAuthorTeamYear");

		try {

			if (! "".equals(CdmUtils.Nz(basAuthorTeamYear).trim())){

				Integer OriginalPublicationYear  = Integer.valueOf(basAuthorTeamYear.trim());

				zooName.setOriginalPublicationYear(OriginalPublicationYear);

			}

		} catch (NumberFormatException e) {

			logger.warn("basAuthorTeamYear could not be parsed for taxonName: "+ nameId);

		}

		return success;

	}

		String dbAttrName;

		String cdmAttrName;

		cdmAttrName = "isHybridFormula";

		success &= ImportHelper.addBooleanValue(rs, botanicalName, dbAttrName, cdmAttrName);

		dbAttrName = "MonomHybFlag";

		cdmAttrName = "isMonomHybrid";

		success &= ImportHelper.addBooleanValue(rs, botanicalName, dbAttrName, cdmAttrName);

		dbAttrName = "BinomHybFlag";

		cdmAttrName = "isBinomHybrid";

		success &= ImportHelper.addBooleanValue(rs, botanicalName, dbAttrName, cdmAttrName);

		dbAttrName = "TrinomHybFlag";

		cdmAttrName = "isTrinomHybrid";

		success &= ImportHelper.addBooleanValue(rs, botanicalName, dbAttrName, cdmAttrName);

		try {

			String strCultivarGroupName = rs.getString("CultivarGroupName");

			String strCultivarName = rs.getString("CultivarName");

				ICultivarPlantName cultivarName = (ICultivarPlantName)botanicalName;

				}

				cultivarName.setCultivarName(strCultivarGroupName);

			}

		} catch (SQLException e) {

			throw e;

		}

		return success;

	}

		Map<String, Reference> refMap = partitioner.getObjectMap(BerlinModelReferenceImport.REFERENCE_NAMESPACE);

		Map<String, Reference> refDetailMap = partitioner.getObjectMap(BerlinModelRefDetailImport.REFDETAIL_NAMESPACE);

		Object nomRefDetailFkObj = rs.getObject("NomRefDetailFk");

		boolean refDetailPrelim = rs.getBoolean("RefDetailPrelim");

		//nomenclatural Reference

		if (refMap != null){

			if (nomRefFkObj != null){

				String nomRefFk = String.valueOf(nomRefFkObj);

				String nomRefDetailFk = String.valueOf(nomRefDetailFkObj);

				//get nomRef

				if (nomReference == null ){

					//TODO

					if (! config.isIgnoreNull()){

						logger.warn("Nomenclatural reference (nomRefFk = " + nomRefFk + ") for TaxonName (nameId = " + nameId + ")"+

							" was not found in reference store. Nomenclatural reference was not set!!");

					}

				}else{

					if (! INomenclaturalReference.class.isAssignableFrom(nomReference.getClass())){

						logger.warn("Nomenclatural reference (nomRefFk = " + nomRefFk + ") for TaxonName (nameId = " + nameId + ")"+

								" is not assignable from INomenclaturalReference. (Class = " + nomReference.getClass()+ ")");

					}

					nomReference.setNomenclaturallyRelevant(true);

					taxonNameBase.setNomenclaturalReference(nomReference);

				}

			}

		}

		return success;

	}

		if (teamIdObject == null){

			return null;

		}else {

			String teamId = String.valueOf(teamIdObject);

			TeamOrPersonBase author = teamMap.get(teamId);

			if (author == null){

				//TODO

				" was not found in authorTeam store. Relation was not set!!");}

				return null;

			}else{

				return author;

			}

		}

	}

	protected boolean doCheck(BerlinModelImportState state){

		IOValidator<BerlinModelImportState> validator = new BerlinModelTaxonNameImportValidator();

		return validator.validate(state);

	}

	@Override

    protected boolean isIgnore(BerlinModelImportState state){

	}

//FOR FUTURE USE , DONT DELETE

//	new CdmStringMapper("rankFk", "rankFk"),

//	new CdmStringMapper("nameCache", "nameCache"),

//	new CdmStringMapper("unnamedNamePhrase", "unnamedNamePhrase"),

//	new CdmStringMapper("fullNameCache", "fullNameCache"),

//	new CdmStringMapper("preliminaryFlag", "preliminaryFlag"),

//	new CdmStringMapper("supragenericName", "supragenericName"),

//	new CdmStringMapper("genus", "genus"),

//	new CdmStringMapper("genusSubdivisionEpi", "genusSubdivisionEpi"),

//	new CdmStringMapper("speciesEpi", "speciesEpi"),

//	new CdmStringMapper("infraSpeciesEpi", "infraSpeciesEpi"),

//	new CdmStringMapper("authorTeamFk", "authorTeamFk"),

//	new CdmStringMapper("exAuthorTeamFk", "exAuthorTeamFk"),

//	new CdmStringMapper("basAuthorTeamFk", "basAuthorTeamFk"),

//	new CdmStringMapper("exBasAuthorTeamFk", "exBasAuthorTeamFk"),

//	new CdmStringMapper("hybridFormulaFlag", "hybridFormulaFlag"),

//	new CdmStringMapper("monomHybFlag", "monomHybFlag"),

//	new CdmStringMapper("binomHybFlag", "binomHybFlag"),

//	new CdmStringMapper("trinomHybFlag", "trinomHybFlag"),

//	new CdmStringMapper("cultivarGroupName", "cultivarGroupName"),

//	new CdmStringMapper("cultivarName", "cultivarName"),

//	new CdmStringMapper("nomRefFk", "nomRefFk"),

//	new CdmStringMapper("nomRefDetailFk", "nomRefDetailFk"),

//	new CdmStringMapper("nameSourceRefFk", "nameSourceRefFk"),

//	new CdmStringMapper("source_Acc", "source_Acc"),

//	new CdmStringMapper("created_When", "created_When"),

//	new CdmStringMapper("created_Who", "created_Who"),

//	new CdmStringMapper("notes", "notes"),

//	new CdmStringMapper("parsingComments", "parsingComments"),

//	new CdmStringMapper("oldNomRefFk", "oldNomRefFk"),

//	new CdmStringMapper("oldNomRefDetailFk", "oldNomRefDetailFk"),

//	new CdmStringMapper("updated_Who", "updated_Who"),

//	new CdmStringMapper("orthoProjection", "orthoProjection"),