EDIT

/**

* Copyright (C) 2007 EDIT

* 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.

*/

 * @created 20.02.2010

 */

@Component

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

	private int modCount = 10000;

	private static final String pluralString = "taxa";

	private static final String dbTableName = "specTax";

	private static final Class<?> cdmTargetClass = Reference.class;

	private static UUID uuidCitedTypeLocality = UUID.fromString("ca431e0a-84ec-4828-935f-df4c8f5cf880");

	private static UUID uuidCitedTypeMaterial = UUID.fromString("8395021a-e596-4a55-9794-8c03aaad9e16");

	@Override

	protected String getIdQuery() {

	}

	@Override

	protected String getRecordQuery(GlobisImportConfigurator config) {

			" SELECT t.*, t.DateCreated as Created_When, t.CreatedBy as Created_Who," +

			" FROM " + getTableName() + " t " +

			" WHERE ( t.specTaxId IN (" + ID_LIST_TOKEN + ") )";

		return strRecordQuery;

	}

	@Override

	public boolean doPartition(ResultSetPartitioner partitioner, GlobisImportState state) {

		boolean success = true;

		Set<TaxonBase> objectsToSave = new HashSet<TaxonBase>();

		Set<TaxonNameBase> namesToSave = new HashSet<TaxonNameBase>();

		ResultSet rs = partitioner.getResultSet();

		try {

			int i = 0;

			//for each reference

            while (rs.next()){

        		if ((i++ % modCount) == 0 && i!= 1 ){ logger.info(pluralString + " handled: " + (i-1));}

        		Integer specTaxId = rs.getInt("SpecTaxId");

        		Integer acceptedTaxonId = nullSafeInt(rs, "SpecCurrspecID");

        		String specSystaxRank = rs.getString("SpecSystaxRank");

        		//        SpecDescriptionImageFile, all *Valid*

				try {

					//source ref

					Taxon acceptedTaxon =  taxonMap.get(String.valueOf(acceptedTaxonId));

					TaxonBase<?> thisTaxon = null;

					ZoologicalName name = null;

					if (isBlank(specSystaxRank) ){

						name = makeName(state, rs, specTaxId);

						logger.warn(String.format("Unhandled specSystaxRank %s in specTaxId %d", specSystaxRank, specTaxId));

						name = makeName(state, rs, specTaxId);

					}

					if (thisTaxon != null){

						name = CdmBase.deproxy(thisTaxon.getName(), ZoologicalName.class);

					}else{

						if (name == null){

							name = makeName(state, rs, specTaxId);

						}

						thisTaxon = Taxon.NewInstance(name, sourceRef);

						objectsToSave.add(thisTaxon);

					}

					if (name == null){

						throw new RuntimeException("Name is still null");

					}

					handleNomRef(state, referenceMap, rs, name, specTaxId);

					handleTypeInformation(state,rs, name, specTaxId);

//					this.doIdCreatedUpdatedNotes(state, ref, rs, refId, REFERENCE_NAMESPACE);

					if (acceptedTaxon != null){

					}

					//makeMarker1(state, rs, name);   //ignore!

					//make not available

					makeNotAvailable(state, rs, name, specTaxId);

					//maken invalid

					//SpecCitedTypeLocality

					String citedTypeLocality = rs.getString("SpecCitedTypeLocality");

					if (isNotBlank(citedTypeLocality)){

					}

					name.addSource(OriginalSourceType.Import, String.valueOf(specTaxId), SPEC_TAX_NAMESPACE, state.getTransactionalSourceReference(), null);

					namesToSave.add(name);

				} catch (Exception e) {

					logger.warn("Exception in specTax: SpecTaxId " + specTaxId + ". " + e.getMessage());

					e.printStackTrace();

            }

			logger.warn(pluralString + " to save: " + objectsToSave.size());

			getNameService().save(namesToSave);

			return success;

		} catch (Exception e) {

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

	private void makeNotAvailable(GlobisImportState state, ResultSet rs, ZoologicalName name, int id) throws SQLException {

		String notAvailableStr = rs.getString("SpecNotAvailable");

		String notAvailableReason = rs.getString("SpecNotAvailableReason");

		if (isNotBlank(notAvailableStr) && notAvailableStr.contains("not available")){

			if (isBlank(notAvailableReason)){

				logger.warn("Blank notAvailableReason has available: " + id);

		//OLD

//					UUID uuidNotAvailableMarkerType = state.getTransformer().getMarkerTypeUuid("not available");

//					MarkerType markerType = getMarkerType(state, uuidNotAvailableMarkerType, "not available", "not available", null);

//					name.addMarker(Marker.NewInstance(markerType, true));

//				}

//				name.addExtension(notAvailableReason, notAvailableReasonExtType);

//			} catch (UndefinedTransformerMethodException e) {

//				e.printStackTrace();

//		}

	}

	private NomenclaturalStatus getNomStatus(GlobisImportState state, String notAvailableReason, int id) {

		NomenclaturalStatus status = NomenclaturalStatus.NewInstance(NomenclaturalStatusType.ZOO_NOT_AVAILABLE());

		status.setRuleConsidered(notAvailableReason);

				if (marker1Str.contains("checked") || marker1Str.contains("berpr") ){ //überprüft

					UUID uuidCheckedMarkerType;

						uuidCheckedMarkerType = state.getTransformer().getMarkerTypeUuid("checked");

					MarkerType markerType = getMarkerType(state, uuidCheckedMarkerType, "checked", "checked", null);

					name.addMarker(Marker.NewInstance(markerType, true));

				}

		} catch (UndefinedTransformerMethodException e) {

			e.printStackTrace();

		}

	}

			String citedTypeLocality, String featureLabel) {

		Feature feature = getFeature(state, featureUuid,featureLabel,featureLabel, null, null);

		getTaxonNameDescription(name, false, true);

	}

	private Pattern patternAll = Pattern.compile("(.+,\\s.+)(\\(.+\\))");

	private void handleTypeInformation(GlobisImportState state, ResultSet rs, ZoologicalName name, Integer specTaxId) throws SQLException {

		if (! hasTypeInformation(rs)){

			return;

		}

		FieldUnit fieldObservation = makeTypeFieldObservation(state, rs);

		//typeDepository

		String specTypeDepositoriesStr = rs.getString("SpecTypeDepository");

		if (isNotBlank(specTypeDepositoriesStr) ){

			specTypeDepositories = specTypeDepositoriesStr.trim().split(";");

		}else{

			specTypeDepositories = new String[0];

		}

		//TODO several issues

		if (specTypeDepositories.length == 0){

			DerivedUnit specimen = makeSingleTypeSpecimen(fieldObservation);

		}else{

			for (String specTypeDepositoryStr : specTypeDepositories){

				specTypeDepositoryStr = specTypeDepositoryStr.trim();

				//Specimen

				DerivedUnit specimen = makeSingleTypeSpecimen(fieldObservation);

				if (specTypeDepositoryStr.equals("??")){

					//unknown

					//TODO marker unknown ?

				}else{

					specTypeDepositoryStr = makeAdditionalSpecimenInformation(

							specTypeDepositoryStr, specimen, specTaxId);

					Collection collection = makeCollection(state, specTypeDepositoryStr, specimen, specTaxId);

					String collectionCode = collection.getCode();

					if (isBlank(collectionCode)){

					if (isBlank(collectionCode)){

						logger.warn("Collection has empty representation: " + specTypeDepositoryStr + ", specTaxId" +  specTaxId);

					}

				}

				//type Designation

				makeTypeDesignation(name, rs, specimen, specTaxId);

			}

		}

	}

	/**

	 * @param specTypeDepositoryStr

	 * @param specimen

	 */

	protected Collection makeCollection(GlobisImportState state, String specTypeDepositoryStr, DerivedUnit specimen, Integer specTaxId) {

		//Collection

		specTypeDepositoryStr = specTypeDepositoryStr.replace("Washington, D.C.", "Washington@ D.C.")

				.replace("St.-Raymond, Quebec", "St.-Raymond@ Quebec")

				.replace("St.Petersburg", "St. Petersburg");

		Collection collection = handleSpecialCase(specTypeDepositoryStr, state, specimen);

		if (collection == null){

			String[] split = specTypeDepositoryStr.split(",");

					collection.setCode("??");

					//TODO deduplicate ??

				}

			}else{

				String collectionStr = split[0];

				String location = split[1].replace("@", ",").trim();

				collection = state.getRelatedObject(COLLECTION_NAMESPACE, collectionStr, Collection.class);

				if (collection == null){

					collection = Collection.NewInstance();

					}

					collection.setTownOrLocation(location);

					state.addRelatedObject(COLLECTION_NAMESPACE, collection.getCode(), collection);

				}else if (! CdmUtils.nullSafeEqual(location, collection.getTownOrLocation())){

					if (! normalizeTownOrLocation(location, collection)){

						String message = "Location (%s) is not equal to location (%s) of existing collection, specTaxId: " + specTaxId;

						logger.warn(String.format(message, location, collection.getTownOrLocation(), collection.getCode()));

					}

				}

				specimen.setCollection(collection);

			}

		}

				return true;

			} else if ("coll. Dantchenko".equals(collection.getName())){

				if (! "Moscow".equals(collection.getTownOrLocation())){

					getCollectionService().saveOrUpdate(collection);

				}

				return true;

			} else if ("coll. S. Nakano".equals(collection.getName())){

				if (! "Tokyo".equals(collection.getTownOrLocation())){

					getCollectionService().saveOrUpdate(collection);

				}

				return true;

			} else if ("coll. A. Yagishita".equals(collection.getName())){

				if (! "Toride Ibaraki".equals(collection.getTownOrLocation())){

					getCollectionService().saveOrUpdate(collection);

				}

				return true;

			} else if ("coll. H. Sugiyama".equals(collection.getName())){

				if (! "Gifu".equals(collection.getTownOrLocation())){

					getCollectionService().saveOrUpdate(collection);

				}

				return true;

			} else if ("MDMO".equals(collection.getCode())){

				if (! "Moscow".equals(collection.getTownOrLocation())){

					getCollectionService().saveOrUpdate(collection);

				}

				return true;

			} else if ("coll. W. Eckweiler".equals(collection.getName())){

				if (! "Frankfurt am Main".equals(collection.getTownOrLocation())){

					getCollectionService().saveOrUpdate(collection);

				}

				return true;

			} else if ("coll. T. Frankenbach".equals(collection.getName())){

				if (! "Wangen".equals(collection.getTownOrLocation())){

					getCollectionService().saveOrUpdate(collection);

				}

				return true;

			}

		}

		return result;

	}

				state.addRelatedObject(COLLECTION_NAMESPACE, collection.getName(), collection);

			}

			specimen.setCollection(collection);

		}else if (specTypeDepositoryStr.equals("coll. L. V. Kaabak, A .V. Sotshivko & V. V. Titov, Moscow")){

			String colName = "coll. L. V. Kaabak, A .V. Sotshivko & V. V. Titov";

			collection = state.getRelatedObject(COLLECTION_NAMESPACE, colName, Collection.class);

		}else{

			collection = null;

		}

		return collection;

	}

	 * @param specTypeDepositoriesStr

	 * @param specTypeDepositoryStr

	 * @param specimen

	 * @return

	 */

	protected String makeAdditionalSpecimenInformation( String specTypeDepositoryStr, DerivedUnit specimen, Integer specTaxId) {

			Marker.NewInstance(specimen, true, MarkerType.IS_DOUBTFUL());

			specTypeDepositoryStr = specTypeDepositoryStr.substring(0, specTypeDepositoryStr.length() -1).trim();

		}

		//brackets

		Matcher matcher = patternAll.matcher(specTypeDepositoryStr);

		if (matcher.find()){

			//has brackets

			String brackets = matcher.group(2);

			brackets = brackets.substring(1, brackets.length()-1);

			//TODO this is unwanted according to Alexander

			brackets = brackets.replace("[mm]", "\u2642\u2642");

			brackets = brackets.replace("[m]", "\u2642");

			brackets = brackets.replace("[ff]", "\u2640\u2640");

			brackets = brackets.replace("[f]", "\u2640");

			brackets = brackets.replace("[m/f]", "\u26a5");

			if (brackets.contains("[") || brackets.contains("]")){

				logger.warn ("There are still '[', ']' in the bracket part: " + brackets + "; specTaxId: " + specTaxId);

			}

			specimen.setTitleCache(brackets, true);

			specTypeDepositoryStr = matcher.group(1).trim();

		}

	 * @return

	 * @throws SQLException

	 */

			ResultSet rs) throws SQLException {

		String countryString = rs.getString("SpecTypeCountry");

		SpecimenOrObservationType unitType = SpecimenOrObservationType.PreservedSpecimen;

		DerivedUnitFacade facade = DerivedUnitFacade.NewInstance(unitType);

		NamedArea typeCountry = getCountry(state, countryString);

		facade.setCountry(typeCountry);

		FieldUnit fieldObservation = facade.innerFieldUnit();

	/**

	 * @param name

	 * @param status

	 * @param specimen

	 */

	protected void makeTypeDesignation(ZoologicalName name, ResultSet rs, DerivedUnit specimen, Integer specTaxId) throws SQLException {

		//type

		SpecimenTypeDesignation typeDesignation = SpecimenTypeDesignation.NewInstance();

		typeDesignation.setTypeStatus(status);

		typeDesignation.setTypeSpecimen(specimen);

		name.addTypeDesignation(typeDesignation, true);

	}

	 * @param referenceMap

	 * @param rs

	 * @param name

	 * @return

	 * @throws SQLException

	 */

			ZoologicalName name, Integer specTaxId) throws SQLException {

		//ref

		Integer refId = nullSafeInt(rs, "fiSpecRefID");

		if (refId != null){

			nomRef = referenceMap.get(String.valueOf(refId));

			if (nomRef == null && state.getConfig().getDoReferences().equals(state.getConfig().getDoReferences().ALL)){

				name.setNomenclaturalReference(nomRef);

			}

		}

		//refDetail

		String refDetail = rs.getString("SpecPage");

		if (isNotBlank(refDetail)){

	private void validateAcceptedTaxon(Taxon acceptedTaxon, ResultSet rs, Integer specTaxId, Integer acceptedTaxonId) throws SQLException {

		if (acceptedTaxon == null){

			logger.warn("Accepted taxon is null for taxon taxon to validate. SpecTaxId " + specTaxId + ", accTaxonId: " + acceptedTaxonId);

			return;

		}

		ZoologicalName name = CdmBase.deproxy(acceptedTaxon.getName(), ZoologicalName.class);

		String specName = rs.getString("SpecName");

		if (! name.getSpecificEpithet().equals(specName)){

			logger.warn(String.format("Species epithet is not equal for accepted taxon: %s - %s. SpecTaxId: %d", name.getSpecificEpithet(), specName, specTaxId));

	private Synonym getSynonym(GlobisImportState state, ResultSet rs, Integer specTaxId) throws SQLException {

		ZoologicalName name = makeName(state, rs, specTaxId);

		Synonym synonym = Synonym.NewInstance(name, state.getTransactionalSourceReference());

		return synonym;

	}

	/**

	 * @param state

	 * @param rs

	 * @return

	 * @throws SQLException

	 */

				e.printStackTrace();

			}

		}

		//name

		ZoologicalName name = ZoologicalName.NewInstance(rank);

		makeNamePartsAndCache(state, rs, rankStr, name);

//		name.setGenusOrUninomial(genusOrUninomial);

		String authorStr = rs.getString("SpecAuthor");

		String yearStr = rs.getString("SpecYear");

		String authorAndYearStr = CdmUtils.concat(", ", authorStr, yearStr);

		handleAuthorAndYear(authorAndYearStr, name, specTaxId, state);

		return name;

	}

		String citedSpecies = rs.getString("SpecCitedSpecies");

		String citedSubspecies = rs.getString("SpecCitedSubspecies");

		String lastEpithet = rs.getString("SpecName");

		String cache = CdmUtils.concat(" ", new String[]{citedFamily, citedGenus, citedSpecies, citedSubspecies, rank, lastEpithet});

		name.setGenusOrUninomial(citedGenus);

		//TODO separate authors

				name.setInfraSpecificEpithet(lastEpithet);

			}

		}

		//TODO check if cache needs protection

		name.setNameCache(cache, true);

	}

		String nameSpace;

		Class<?> cdmClass;

		Set<String> idSet;

		Set<AgentBase> agents = state.getAgents();

		getAgentService().saveOrUpdate(agents);

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

		try{

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

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

			while (rs.next()){

				handleForeignKey(rs, taxonIdSet, "SpecCurrspecID");

				handleForeignKey(rs, referenceIdSet, "fiSpecRefID");

			}

			//taxon map

			nameSpace = TAXON_NAMESPACE;

			cdmClass = Taxon.class;

			idSet = referenceIdSet;

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

			result.put(nameSpace, referenceMap);

			//collection map

			nameSpace = COLLECTION_NAMESPACE;

			List<Collection> listCollection = getCollectionService().list(Collection.class, null, null, null, null);

				}

			}

			result.put(nameSpace, collectionMap);

		} catch (SQLException e) {

			throw new RuntimeException(e);

		}

		return result;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doCheck(eu.etaxonomy.cdm.io.common.IImportConfigurator)

	 */

		IOValidator<GlobisImportState> validator = new GlobisSpecTaxaImportValidator();

		return validator.validate(state);

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.CdmIoBase#isIgnore(eu.etaxonomy.cdm.io.common.IImportConfigurator)

	 */

		return ! state.getConfig().isDoSpecTaxa();

	}

	@Override

			throws SQLException {

		// not needed

		return null;