/**
 * Copyright (C) 2010-2015 The Roslin Institute <contact andy.law@roslin.ed.ac.uk>
 *
 * This file is part of JEnsembl: a Java API to Ensembl data sources developed by the
 * Bioinformatics Group at The Roslin Institute, The Royal (Dick) School of
 * Veterinary Studies, University of Edinburgh.
 *
 * Project hosted at: http://jensembl.sourceforge.net
 *
 * This is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License (version 3) as published by
 * the Free Software Foundation.
 *
 * This software is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * in this software distribution. If not, see: http://opensource.org/licenses/gpl-3.0.html
 */
package uk.ac.roslin.ensembl.dao.database;

import java.util.*;
import uk.ac.roslin.ensembl.config.EnsemblDBType;
import uk.ac.roslin.ensembl.datasourceaware.core.*;
import uk.ac.roslin.ensembl.exception.BacterialCollectionException;
import uk.ac.roslin.ensembl.exception.ConfigurationException;
import uk.ac.roslin.ensembl.exception.DAOException;
import uk.ac.roslin.ensembl.model.core.CollectionSpecies;
import uk.ac.roslin.ensembl.model.database.Database;
import uk.ac.roslin.ensembl.model.database.DatabaseType;


public class DBCollectionSpecies extends DBSpecies implements CollectionSpecies {
  
    private DBCollectionCoreDatabase mostRecentCoreDatabase = null;

    private TreeSet<DBCollectionDatabase> databases = new TreeSet<DBCollectionDatabase>();

    protected TreeMap<String,Integer> versionIDmap = new TreeMap<String,Integer>();

    public DBCollectionSpecies() {
        dbType = EnsemblDBType.collection_core;
    }

    public DBCollectionSpecies(DBCollectionCoreDatabase database) throws ConfigurationException {
        this();
        this.addDatabase(database);
        this.registry =  database.getRegistry();
        this.mostRecentEnsemblSchemaVersion = registry.getMostRecentEnsemblVersion();
     }

    public void setIDForVersion(Integer ID, String version) {
        this.versionIDmap.put(version, ID);
    }
    
    //different logic to DBSpecies
    @Override
    public void setProperty(HashMap row) {
        boolean oldStyleKeys = true;

        String key = (String) row.get("meta_key");
        String value = (String) row.get("meta_value");
        Integer schemaVersion = Integer.parseInt((String) row.get("schemaVersion"));
        String dbVersion = (String) row.get("dbVersion");
        Integer dbV = 0;
        try {
                dbV = Integer.parseInt(dbVersion);
        } catch (Exception e) {}
        
        //making aliases all lower case now
        if (key.startsWith("species.") 
                && ! key.equals("species.division")
                    && ! key.equals("species.stable_id_prefix")) {
            aliases.add(value.toLowerCase());
        }
                
        if (schemaVersion != null && schemaVersion >= 58) {
            oldStyleKeys = false;
        }
        //pre dbVersion 58 the db_name held the binomial
        //and compara_name, file_name and sql_name = the db style name
        //this is a mess

        if (oldStyleKeys) {
            if (key.equals("species.db_name")) {
                this.speciesBinomial = value;

            } else if (key.equals("species.compara_name")) {
                this.databaseStyleSpeciesName = value;
                this.setDatabaseStyleSpeciesName(dbV,value);
                this.comparaNameByVersion.put(dbVersion ,value);
            } 
            //if we dont have a comparaname use the sql name
            else if (key.equals("species.sql_name") 
                    && 
                    (this.databaseStyleSpeciesName==null || this.databaseStyleSpeciesName.isEmpty())) {
                this.databaseStyleSpeciesName = value;
                this.setDatabaseStyleSpeciesName(dbV,value);
                this.comparaNameByVersion.put(dbVersion ,value);
            }
        //from dbVersion 58 the binomial is held in scientific name
        //and compara_name, file_name,db_name, production_name and sql_name
        //all seem to hold the db style name   
                  
        //post schema 67  The following meta keys are retired
        //species.short_name
        //species.ensembl_common_name
        //species.ensembl_alias_name
        //The following meta keys will be added
        //species.url
        //species.display_name
         
        } else {
            
            //in release 24/77 they seemed to drop species.common_name,
            //species.ensembl_alias_name, species.short_name
            
            if (key.equals("species.production_name")) {
                this.databaseStyleSpeciesName = value;
                this.setDatabaseStyleSpeciesName(dbV,value);
                this.comparaNameByVersion.put(dbVersion ,value);

            } else if (key.equals("species.scientific_name")) {
                this.speciesBinomial = value;
            } else if (key.equals("species.short_name")
                    || key.equals("species.display_name")) {
                this.shortName = value;
                if (schemaVersion>76) {
                    this.commonName = value;
                }
            } else if (key.equals("species.division")) {
                this.setComparaDivision(value);
            } else if (key.equals("species.url")) {
                    this.setUrlName(value);
            } else if (key.equals("assembly.accession")) {
                      this.setAssemblyAccession(dbVersion, value);                      
            } else if (key.equals("assembly.name")) {
                     this.setAssemblyName(dbVersion, value);   
            }
        }


        if (key.equals("species.stable_id_prefix")) {
            this.ensemblStablePrefix = value;
        } else if (key.equals("species.common_name")
            || key.equals("species.ensembl_common_name")) {
            this.commonName = value;
        } else if (key.equals("species.taxonomy_id")) {
            this.taxonomyID = value;
        } 

    }


    @Override
    public Integer getDBSpeciesID(String version) {
        if (version == null || version.isEmpty()) {
            if (this.highestDBRelease!=null && this.highestDBRelease!=0 ) {
                 version = this.highestDBRelease.toString();  
            } else {
                return null;
            }
        }
        if (!this.highestDBRelease.toString().equals(version)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }        
        return this.versionIDmap.get(version);
    }
    
    
    @Deprecated //for CollectionSpecies
    @Override
    public Integer getDBSpeciesID() {
        return this.versionIDmap.get(this.highestDBRelease.toString());
    }

    @Override
    public int compareTo(Object o) {
        
        //now that this uses databaseStyleSpeciesNamewe want to try and make sure there always is one
        //when we parse the species meta data
        
        //also have a fallback to use the binomial where we have an empty dbstyle name
        
        if (o==null) {
            throw new NullPointerException();
        }
        CollectionSpecies sp = (CollectionSpecies) o;
        
        if (this.databaseStyleSpeciesName!=null && !this.databaseStyleSpeciesName.isEmpty()
                && sp.getDatabaseStyleName()!=null && !sp.getDatabaseStyleName().isEmpty()) {
            return this.databaseStyleSpeciesName.compareTo(sp.getDatabaseStyleName());
        } else {
            return this.getSpeciesBinomial().compareTo(sp.getSpeciesBinomial());
        }

    }

    @Override
    public int hashCode() {
        int hash = 7;
        hash = 79 * hash + ( (this.databaseStyleSpeciesName != null && !this.databaseStyleSpeciesName.isEmpty())
                ? this.databaseStyleSpeciesName.hashCode() :                
                (this.toString()!=null) ? this.toString().hashCode() : 0);
        return hash;
    }

    
    @Override
    public boolean equals(Object o) {
        return ( o != null && getClass() == o.getClass() && this.compareTo(o)==0 );
    }

    @Override
    public DBCollectionCoreDatabase getMostRecentCoreDatabase() {
        return (DBCollectionCoreDatabase) this.mostRecentCoreDatabase;
    }

    public void setMostRecentCoreDatabase(DBCollectionCoreDatabase currentCoreDatabase) {
        this.mostRecentCoreDatabase = currentCoreDatabase;
    }

    @Override
    public TreeSet<DBCollectionDatabase> getDatabases() {
        return this.databases;
    }

    @Override
    public void addDatabases(TreeSet<? extends Database> databases) {
        for (Database d : databases) {
                this.addDatabase( d);
        }
    }

    @Override
    public void addDatabase(Database database) {
            try {
                this.databases.add((DBCollectionDatabase) database);
                if( database.getType().equals(dbType)) {
                    this.dbVersions.add(database.getDBVersion());
                    this.schemaVersions.add(database.getSchemaVersion());
                   //check that we are not adding a more recent release than we know about
                    if ( database.getIntDBVersion() > this.highestDBRelease ) {
                        this.highestDBRelease = database.getIntDBVersion(); 
                        this.mostRecentCoreDatabase = (DBCollectionCoreDatabase) database;
                    }
                }
        } catch (Exception e) {
        }
    }

    @Override
    public TreeSet<DBCollectionDatabase> getDatabasesByType(DatabaseType type) {
        TreeSet<DBCollectionDatabase> out = new TreeSet<DBCollectionDatabase>();
        for (DBCollectionDatabase d : databases) {
            if (d.getType()==type) {
                out.add(d);
            }
        }
        return out;
    }

    @Override
    public TreeSet<DBCollectionDatabase> getDatabasesByVersion(String version) {       
        if (!this.highestDBRelease.toString().equals(version)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }
        TreeSet<DBCollectionDatabase> out = new TreeSet<DBCollectionDatabase>();
        for (DBCollectionDatabase d : databases) {
            if (d.getDBVersion().equals(version)) {
                out.add(d);
            }
        }
        return out;
    }

    @Override
    public DBCollectionDatabase getDatabaseByTypeAndVersion(DatabaseType type, String version) {
        if (!this.highestDBRelease.toString().equals(version)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }
         for (DBCollectionDatabase d : databases) {
            if (d.getDBVersion().equalsIgnoreCase(version) && d.getType()== type) {
               return d;
            }
        }
        return null;
    }


    @Override
    public DAChromosome getChromosomeByName(String name, String dbVersion) throws DAOException {
     
        DAChromosome chr = null;

        if (dbVersion == null || dbVersion.isEmpty()) {
            dbVersion = this.highestDBRelease.toString();
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }
        if (!this.versionIDmap.containsKey(dbVersion)) {
            throw new DAOException("No version "+dbVersion+" for "+this.toString());
        }


        if (!chromosomes.containsKey(dbVersion)) {
            chromosomes.put(dbVersion, new TreeMap<String, DAChromosome>());
        }

        if (chromosomes.get(dbVersion).containsKey(name)) {
            return chromosomes.get(dbVersion).get(name);
        } else {

            chr = ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion
                (EnsemblDBType.collection_core, dbVersion) )
                    .getChromosomeByName(this, name);
        }

        if (chr != null) {
            //make sure we use the actual CHromosome Name - not the search Name
            chromosomes.get(dbVersion).put(chr.getChromosomeName(), chr);
        }

        return chr;
    }

    @Override
    public TreeMap<String, DAChromosome> getChromosomes(String dbVersion) throws DAOException {

        if (dbVersion == null || dbVersion.isEmpty()) {
            dbVersion = this.highestDBRelease.toString();
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }        

        if (!this.versionIDmap.containsKey(dbVersion)) {
            throw new DAOException("No version "+dbVersion+" for "+this.toString());
        }

        if (this.allChromosomesRetrieved.contains(dbVersion)) {
            return this.chromosomes.get(dbVersion);
        }

        List<DAChromosome> chrs = null;

        if (!this.chromosomes.containsKey(dbVersion)) {
            this.chromosomes.put(dbVersion, new TreeMap<String, DAChromosome>());
        }

        chrs = ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion(EnsemblDBType.collection_core, dbVersion)).getChromosomes(this);

        this.allChromosomesRetrieved.add(dbVersion);

        if (chrs != null) {
            for (DAChromosome c : chrs) {
                if (!chromosomes.get(dbVersion).containsKey(c.getChromosomeName())) {
                    chromosomes.get(dbVersion).put(c.getChromosomeName(), c);
                }
            }
        }

        return this.chromosomes.get(dbVersion);
    }

    @Override
    public DAAssembledDNASequence getFragmentByName(String name, String dbVersion) throws DAOException {
        DAAssembledDNASequence ass = null;

        if (dbVersion == null || dbVersion.isEmpty()) {
            dbVersion = this.highestDBRelease.toString();
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }
        if (!this.versionIDmap.containsKey(dbVersion)) {
            throw new DAOException("No version "+dbVersion+" for "+this.toString());
        }


        if (!fragments.containsKey(dbVersion)) {
            fragments.put(dbVersion, new TreeMap<String, DAAssembledDNASequence>());
        }

        if (fragments.get(dbVersion).containsKey(name)) {
            return fragments.get(dbVersion).get(name);
        } else {

            ass = ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion
                (EnsemblDBType.collection_core, dbVersion) )
                    .getFragmentByName(this, name);
        }

        if (ass != null) {
            //make sure we use the actual CHromosome Name - not the search Name
            fragments.get(dbVersion).put(ass.getName(), ass);
        }

        return ass;
    }

    @Override
    public TreeMap<String, DAAssembledDNASequence> getFragments(String dbVersion) throws DAOException {
        if (dbVersion == null || dbVersion.isEmpty()) {
            dbVersion = this.highestDBRelease.toString();
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }
        if (!this.versionIDmap.containsKey(dbVersion)) {
            throw new DAOException("No version "+dbVersion+" for "+this.toString());
        }

        if (this.allFragmentsRetrieved.contains(dbVersion)) {
            return this.fragments.get(dbVersion);
        }

        List<DAAssembledDNASequence> ass = null;

        if (!this.fragments.containsKey(dbVersion)) {
            this.fragments.put(dbVersion, new TreeMap<String, DAAssembledDNASequence>());
        }

        ass = ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion(EnsemblDBType.collection_core, dbVersion)).getFragments(this);

        this.allFragmentsRetrieved.add(dbVersion);

        if (ass != null) {
            for (DAAssembledDNASequence a : ass) {
                if (!fragments.get(dbVersion).containsKey(a.getName())) {
                    fragments.get(dbVersion).put(a.getName(), a);
                }
            }
        }

        return this.fragments.get(dbVersion);
    }
    
    /**
     * Method returns a List of Transcripts that have been mapped to the given CCDS Identifier 
     * (This may be the CCDS accession or the CCDS accession.schemaVersion).
     * There may be  more than one Ensembl Transcript returned.
     * CCDS currently curates consensus canonical transcripts for human and mouse. Calling this method
     * on EnsemblGenomes (invertebrate) species will return an empty list by default
     * via the wrapped TranscriptDAO method). 
     * @param ccdsID
     * @param dbVersion
     * 
     * @throws DAOException 
     */
    @Override
    public List<DATranscript> getTranscriptsForCcdsID(String ccdsID, String dbVersion) throws DAOException {
        List<DATranscript> transcripts = new ArrayList<DATranscript>();

        if (ccdsID==null || ccdsID.isEmpty()) {
            return transcripts;
        }

        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return transcripts;
            }
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }        

        try {
            transcripts = (List<DATranscript>) ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion(
                EnsemblDBType.collection_core, dbVersion)).getCoreFactory(this).getTranscriptDAO().getTranscriptsForCcdsID(ccdsID.trim());
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException(e);
            }
        }

        return transcripts;
    }
    
    /**
     * Method returns a List of Transcripts that have been mapped to the given Vega Identifier.
     * (there may be  more than one Ensembl Transcript).
     * Vega currently curates gene, transcript and protein annotations for a human 
     * and and a few key regions of other vertebrate species. Calling this method
     * on EnsemblGenomes (invertebrate) species will return an empty list by default
     * Via the wrapped TranscriptDAO method). 
     * @param vegaID
     * @param dbVersion
     * 
     * @throws DAOException 
     */
    @Override
    public List<DATranscript> getTranscriptsForVegaID(String vegaID, String dbVersion) throws DAOException {
        List<DATranscript> transcripts = new ArrayList<DATranscript>();

        if (vegaID==null || vegaID.isEmpty()) {
            return transcripts;
        }

        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return transcripts;
            }
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }          

        try {
            transcripts = (List<DATranscript>) ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion(
                EnsemblDBType.collection_core, dbVersion)).getCoreFactory(this).getTranscriptDAO().getTranscriptsForVegaID(vegaID.trim());
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException(e);
            }
        }

        return transcripts;
    }
       
    /**
     * Method returns a List of Translations that have been mapped to the given Vega Identifier.
     * (there may be  more than one Ensembl Translation).
     * Vega currently curates gene, transcript and protein annotations for a human 
     * and and a few key regions of other vertebrate species. Calling this method
     * on EnsemblGenomes (invertebrate) species will return an empty list by default
     * Via the wrapped TranslationDAO method). 
     * @param vegaID
     * @param dbVersion
     * 
     * @throws DAOException 
     */
    @Override
    public List<DATranslation> getTranslationsForVegaID(String vegaID, String dbVersion) throws DAOException {
        List<DATranslation> translations = new ArrayList<DATranslation>();
        if (vegaID==null || vegaID.isEmpty()) {
            return translations;
        }

        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return translations;
            }
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }  

        try {
            translations = (List<DATranslation>) ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion(
                EnsemblDBType.collection_core, dbVersion)).getCoreFactory(this).getTranslationDAO().getTranslationsForVegaID(vegaID.trim());
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException(e);
            }
        }

        return translations;
    }
       
    /**
     * Method returns a List of Genes that have been mapped to the given Vega Identifier.
     * (there may be  more than one Ensembl Gene).
     * Vega currently curates gene, transcript and protein annotations for a human 
     * and and a few key regions of other vertebrate species. Calling this method
     * on EnsemblGenomes (invertebrate) species will return an empty list by default
     * Via the wrapped GeneDAO method). 
     * @param vegaID
     * @param dbVersion
     * 
     * @throws DAOException 
     */
    @Override
    public List<DAGene> getGenesForVegaID(String vegaID, String dbVersion) throws DAOException {
        List<DAGene> genes = new ArrayList<DAGene>();

        if (vegaID==null || vegaID.isEmpty()) {
            return genes;
        }

        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return genes;
            }
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }  
        try {
            genes = (List<DAGene>) ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion(
                EnsemblDBType.collection_core, dbVersion)).getCoreFactory(this).getGeneDAO().getGenesForVegaID(vegaID.trim());
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException(e);
            }
        }

        return genes;
    }

    @Override
    public DAGene getGeneByStableID(String stableID, String dbVersion) throws DAOException {

        DAGene gene = null;

        if (stableID==null || stableID.isEmpty()) {
            return null;
        }

        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return null;
            }
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }          

        try {
        gene = (DAGene)
                ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion(
                EnsemblDBType.collection_core, dbVersion)).getCoreFactory(this).getGeneDAO().getGeneByStableID(stableID.trim());
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException(e);
            }
        }
        return gene;
    }
    
    @Override
    public DATranscript getTranscriptByStableID(String stableID, String dbVersion) throws DAOException {

        DATranscript transcript = null;

        if (stableID==null || stableID.isEmpty()) {
            return null;
        }

        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return null;
            }
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }  
        try {
        transcript = (DATranscript)
                ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion(
                EnsemblDBType.collection_core, dbVersion)).getCoreFactory(this).getTranscriptDAO().getTranscriptByStableID(stableID.trim());
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException(e);
            }
        }
        return transcript;
    }

    @Override
    public DATranslation getTranslationByStableID(String stableID, String dbVersion) throws DAOException {

        DATranslation translation = null;

        if (stableID==null || stableID.isEmpty()) {
            return null;
        }

        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return null;
            }
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }  
        try {
            translation = (DATranslation)
                    ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion(
                    EnsemblDBType.collection_core, dbVersion)).getCoreFactory(this).getTranslationDAO().getTranslationByStableID(stableID.trim());
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException(e);
            }
        }

        return translation;
    }
            
    @Override
    public String getAssemblyName(String dbVersion) {

        String out = "";
        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && highestDBRelease!=0 ) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return out;
            }
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }          
       //we no longer have a lazy load for AssemblyName  - cos this should be filled in on initialisation
//        if (this.assemblyNamesByVersion.get(dbVersion) == null) {
//            if (this.getDatabaseByTypeAndVersion(EnsemblDBType.collection_core, dbVersion) != null) {
//                out = ((CollectionCoreDatabase) this.getDatabaseByTypeAndVersion(EnsemblDBType.collection_core, dbVersion)).getAssemblyName(this);
//            }
//            this.assemblyNamesByVersion.put(dbVersion, out);
//        }

        out = this.assemblyNamesByVersion.get(dbVersion);
        return out == null ? "" : out;
    }

    @Override
    public String getAssemblyAccession(String dbVersion) {
            
        String out = "";

        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return out;
            }
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }  
        //we no longer have a lazy load for AssemblyAccesion  - cos this should be filled in on initialisation
//        if (this.assemblyAccessionsByVersion.get(dbVersion) == null) {
//            if (this.getDatabaseByTypeAndVersion(EnsemblDBType.collection_core, dbVersion) != null) {
//                out = ((CollectionCoreDatabase) this.getDatabaseByTypeAndVersion(EnsemblDBType.collection_core, dbVersion)).getAssemblyAccession(this);
//            }
//            this.assemblyAccessionsByVersion.put(dbVersion, out);
//        }

        out = this.assemblyAccessionsByVersion.get(dbVersion);
        return out == null ? "" : out;
    }
    
    @Override
    public void setAssemblyExceptions(String version) throws DAOException {
         //not implemented yet
    }     
    
    
    @Override
    public List<DAGene> getGenesForExactName(String name, String dbVersion) throws DAOException {
        //return an empty list rather than null
        List<DAGene> out = new ArrayList<DAGene>();        
        if (name==null || name.isEmpty() || name.startsWith("%")) {
            return out;
        }
        
        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return out;
            }
        }
        if (!this.highestDBRelease.toString().equals(dbVersion)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }          
        try {
            out = ((DBCollectionCoreDatabase) this.getDatabaseByTypeAndVersion(
                EnsemblDBType.collection_core, dbVersion)).getCoreFactory(this).getGeneDAO().getGenesByExactName(name.trim()); 
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException(e);
            }
        }
        
        return out;
    }
           
    @Override
    public String getComparaName(String version) {
        // unlike the case for DBSpecies, all versions of the species are parsed on Registry init()
        // so there is no lazy load required
        if (version == null || version.isEmpty()) {
            if (this.highestDBRelease!=null && this.highestDBRelease!=0) {
                 version = this.highestDBRelease.toString();  
            } else {
                return "";
            }
        }
        if (!this.highestDBRelease.toString().equals(version)) {
            throw new BacterialCollectionException(
                    "The Bacterial Registry can now only handle a single database release. "
                    +"This registry is configured with release:"+this.highestDBRelease);
        }          
        return (this.comparaNameByVersion.get(version)==null)?"":this.comparaNameByVersion.get(version);
    }
}