/**
 * 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.EnsemblComparaDivision;
import uk.ac.roslin.ensembl.config.EnsemblDBType;
import uk.ac.roslin.ensembl.datasourceaware.core.*;
import uk.ac.roslin.ensembl.exception.DAOException;
import uk.ac.roslin.ensembl.model.core.Species;
import uk.ac.roslin.ensembl.model.database.*;

public class DBSpecies implements Species {

    protected String databaseStyleSpeciesName = "";
    // note this could now be a trinomial from Ensembl 66
    protected String speciesBinomial = "";
    protected String commonName = "";
//    protected String comparaName = "";
    protected String shortName = "";
    protected String urlName = "";
    //these are both taken from the config file
    protected String mostRecentEnsemblSchemaVersion = "";
//    protected String mostRecentDBRelease = "";
    //this is determined from parsing the databases found
    protected Integer highestDBRelease = 0;
    protected String taxonomyID = "";
    protected String ensemblStablePrefix = "";
    protected TreeSet<String> aliases = new TreeSet<String>();
    protected Registry registry = null;
    private TreeSet<DBSingleSpeciesDatabase> databases = new TreeSet<DBSingleSpeciesDatabase>();
    private DBSingleSpeciesCoreDatabase mostRecentCoreDatabase;
    private final Integer dBSpeciesID = 1;
    //this acts as the chromosome cache, hashed by version then by name
    protected TreeMap<String, TreeMap<String, DAChromosome>> chromosomes =
            new TreeMap<String, TreeMap<String, DAChromosome>>(); 
    protected TreeSet<String> allChromosomesRetrieved = new TreeSet<String>();
    //this acts as the fragment cache for species without chromosomes (i.e. top level assembled sequences), 
    //hashed by version then by name
    protected TreeMap<String, TreeMap<String, DAAssembledDNASequence>> fragments =
            new TreeMap<String, TreeMap<String, DAAssembledDNASequence>>();
    protected TreeSet<String> allFragmentsRetrieved = new TreeSet<String>();
    protected TreeSet<String> dbVersions = new TreeSet<String>();
    protected TreeSet<String> schemaVersions = new TreeSet<String>();
    EnsemblDBType dbType;
    //default value
    EnsemblComparaDivision comparaDivision = EnsemblComparaDivision.MULTI;
    
//    HashMap<String, HashMap<DAChromosome,MappingSet>> assemblyExceptions = 
//            new HashMap<String, HashMap<DAChromosome,MappingSet>>();
    
    protected HashMap<String, String> assemblyAccessionsByVersion = new HashMap<String, String>();
    protected HashMap<String, String> assemblyNamesByVersion = new HashMap<String, String>();
    protected HashMap<String, String> comparaNameByVersion = new HashMap<String, String>();
    protected HashMap<Integer, String> dbStyleNameByVersion = new HashMap<Integer, String>();
    

    public DBSpecies() {
        dbType = EnsemblDBType.core;
    }

    public DBSpecies(DBSingleSpeciesCoreDatabase database) {
        this();
        this.registry = database.getRegistry();
        mostRecentEnsemblSchemaVersion = registry.getMostRecentEnsemblVersion();
        
        this.addDatabase(database);

//        //from dbVersion 59 releases, the meta table holds the species.production_name,
//        //species.short_name and species.scientific_name meta_keys
//        //making this obsolete - but we will need to perform it in DBDatabaseDAO if
//        //it is a pre59 release
//        databaseStyleSpeciesName=this.currentCoreDatabase.getDbSpeciesName();
//        speciesBinomial = databaseStyleSpeciesName.replaceFirst( databaseStyleSpeciesName.substring(0, 1), (databaseStyleSpeciesName.substring(0,1)).toUpperCase() ).replace("_"," ");
//        aliases.add(speciesBinomial);

    }

    @Override
    public TreeSet<String> getAliases() {
        return aliases;
    }

    //will be overridden in DBCollectionSpecies
    @Override
    public void setProperty(HashMap row) {

        String key = (String) row.get("key");
        String value = (String) row.get("value");

        //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 (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.short_name")
                || key.equals("species.display_name")) {
            this.shortName = value;
        } else if (key.equals("species.scientific_name")) {
            this.speciesBinomial = value;
        } else if (key.equals("species.production_name")) {
            this.databaseStyleSpeciesName = value;
        } else if (key.equals("species.taxonomy_id")) {
            this.taxonomyID = value;
        } else if (key.equals("species.url")) {
            this.urlName = value;
        } 
    }

    @Override
    public CoreDatabase getMostRecentCoreDatabase() {
        return mostRecentCoreDatabase;
    }

    @Override
    public String getCommonName() {
        return commonName;
    }

    @Override
    public String getShortName() {
        return shortName;
    }
    
    @Override
    public String getDisplayName() {
        return shortName;
    }

    public void setShortName(String name) {
        shortName = name;
    }

    @Override
    public String getDatabaseStyleName() {
        return databaseStyleSpeciesName;
    }

    @Override
    public TreeSet<? extends DBDatabase> getDatabases() {
        return 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((DBSingleSpeciesDatabase) 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 = (DBSingleSpeciesCoreDatabase) database;
                }               
            }
        } catch (Exception e) {
        }

    }

    @Override
    public String getEnsemblStablePrefix() {
        return ensemblStablePrefix;
    }

    @Override
    public String getSpeciesBinomial() {
        return speciesBinomial;
    }

    @Override
    public String getTaxonomyID() {
        return taxonomyID;
    }

    @Override
    public TreeSet<? extends DBDatabase> getDatabasesByType(DatabaseType type) {
        TreeSet<DBSingleSpeciesDatabase> out = new TreeSet<DBSingleSpeciesDatabase>();
        for (DBDatabase d : databases) {
            if (d instanceof DBSingleSpeciesDatabase && d.getType() == type) {
                out.add((DBSingleSpeciesDatabase) d);
            }
        }
        return out;
    }

    @Override
    public TreeSet<? extends DBDatabase> getDatabasesByVersion(String version) {
        TreeSet<DBSingleSpeciesDatabase> out = new TreeSet<DBSingleSpeciesDatabase>();
        for (DBDatabase d : databases) {
            if (d instanceof DBSingleSpeciesDatabase && d.getDBVersion().equals(version)) {
                out.add((DBSingleSpeciesDatabase) d);
            }
        }
        return out;
    }

    @Override
    public DBDatabase getDatabaseByTypeAndVersion(DatabaseType type, String version) {

        for (DBDatabase d : databases) {
            if (d.getDBVersion().equalsIgnoreCase(version) && d.getType() == type) {
                return d;
            }
        }
        return null;
    }

    public void setCommonName(String commonName) {
        this.commonName = commonName;
    }

    public void setEnsemblStablePrefix(String ensemblStablePrefix) {
        this.ensemblStablePrefix = ensemblStablePrefix;
    }

    public void setSpeciesBinomial(String speciesBinomial) {
        this.speciesBinomial = speciesBinomial;
    }

    public void setTaxonomyID(String taxonomyID) {
        this.taxonomyID = taxonomyID;
    }

    @Override
    public Integer getDBSpeciesID(String version) {
        return this.dBSpeciesID;
    }

    public Integer getDBSpeciesID() {
        return this.dBSpeciesID;
    }

    @Override
    public String getComparaName(String version) {
        // only the current most recent database species has this parsed and set on registry init()
        //all other dbVersions need a lazy load of metadata
       if (this.comparaNameByVersion.get(version) == null 
               && this.getDatabaseByTypeAndVersion(EnsemblDBType.core, version) != null ) {
           //trigger lazyload of metadata
           this.setComparaName(version, ((SingleSpeciesCoreDatabase)this.getDatabaseByTypeAndVersion(dbType, version)).getComparaName());
       }
       return   (this.comparaNameByVersion.get(version)==null)?"":this.comparaNameByVersion.get(version);
    }
   
    public void setComparaName(String version, String comparaName) {
        this.comparaNameByVersion.put(version, comparaName);
    }

    @Override
    public TreeMap<String, DAChromosome> getChromosomes() throws DAOException {
        return getChromosomes(null);
    }

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

        if (dbVersion == null || dbVersion.isEmpty()) {
            dbVersion = highestDBRelease.toString();
        }

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

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

        List<DAChromosome> chrs = null;

        chrs = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(EnsemblDBType.core, dbVersion)).getChromosomes();
        this.allChromosomesRetrieved.add(dbVersion);
        this.cacheChromosomes(dbVersion, chrs);

        return this.chromosomes.get(dbVersion);
    }
    
    @Override
    public TreeMap<String, DAAssembledDNASequence> getFragments() throws DAOException {
        return getFragments(null);
    }    
    
    @Override
    public TreeMap<String, DAAssembledDNASequence> getFragments(String dbVersion) throws DAOException {

//        TreeMap<String, DAAssembledDNASequence> out = new TreeMap<String, DAAssembledDNASequence>();
//        //note we are not caching these like we do for the chromosomes...
        
        if (dbVersion == null || dbVersion.isEmpty()) {
            dbVersion = highestDBRelease.toString();
        }

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

        if (this.allFragmentsRetrieved.contains(dbVersion)) {
            return this.fragments.get(dbVersion);
        }
        
        List<DAAssembledDNASequence> ass = null;

        ass = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(EnsemblDBType.core, dbVersion)).getFragments();

        this.allFragmentsRetrieved.add(dbVersion);
        
        this.cacheFragments(dbVersion, ass);

        return this.fragments.get(dbVersion);
    }

    private void cacheChromosomes(String dbVersion, Collection<DAChromosome> chrs) {

        if (dbVersion != null && !dbVersion.isEmpty()) {
            if (!this.chromosomes.containsKey(dbVersion)) {
                this.chromosomes.put(dbVersion, new TreeMap<String, DAChromosome>());
            }
            if (chrs != null) {
                for (DAChromosome c : chrs) {
                    if (!chromosomes.get(dbVersion).containsKey(c.getChromosomeName())) {
                        chromosomes.get(dbVersion).put(c.getChromosomeName(), c);
                    }
                }
            }
        }
    }
    
    private void cacheFragments(String dbVersion, Collection<DAAssembledDNASequence> ass) {

        if (dbVersion != null && !dbVersion.isEmpty()) {
            if (!this.fragments.containsKey(dbVersion)) {
                this.fragments.put(dbVersion, new TreeMap<String, DAAssembledDNASequence>());
            }
            if (ass != null) {
                for (DAAssembledDNASequence a : ass) {
                    if (!fragments.get(dbVersion).containsKey(a.getName())) {
                        fragments.get(dbVersion).put(a.getName(), a);
                    }
                }
            }
        }
    }
       
    private void cacheChromosome(String dbVersion, DAChromosome chr) {

        if (dbVersion != null && !dbVersion.isEmpty() && chr != null) {
            if (!this.chromosomes.containsKey(dbVersion)) {
                this.chromosomes.put(dbVersion, new TreeMap<String, DAChromosome>());
            }
            if (!chromosomes.get(dbVersion).containsKey(chr.getChromosomeName())) {
                chromosomes.get(dbVersion).put(chr.getChromosomeName(), chr);
            }
        }
    }
    
    private void cacheFragment(String dbVersion, DAAssembledDNASequence ass) {

        if (dbVersion != null && !dbVersion.isEmpty() && ass != null) {
            if (!this.fragments.containsKey(dbVersion)) {
                this.fragments.put(dbVersion, new TreeMap<String, DAAssembledDNASequence>());
            }
            if (!fragments.get(dbVersion).containsKey(ass.getName())) {
                fragments.get(dbVersion).put(ass.getName(), ass);
            }
        }
    }

    @Override
    public DAChromosome getChromosomeByName(String name) throws DAOException {
        return this.getChromosomeByName(name, null);
    }
    
    @Override
    public DAAssembledDNASequence getFragmentByName(String name) throws DAOException {
        return this.getFragmentByName(name, null);
    }

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

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

        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return null;
            }
        }

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

        if (this.chromosomes.containsKey(dbVersion) && this.chromosomes.get(dbVersion).containsKey(name)) {
            return this.chromosomes.get(dbVersion).get(name);
        } else  if (this.allChromosomesRetrieved.contains(dbVersion)){
            return null;
        } else {
            chr = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(EnsemblDBType.core, dbVersion)).getChromosomeByName(name);
            this.cacheChromosome(dbVersion, chr);
            return chr;
        }
    }
    
    @Override
    public DAAssembledDNASequence getFragmentByName(String name, String dbVersion) throws DAOException {
        DAAssembledDNASequence ass = null;
        
        if (name==null || name.isEmpty()) {
            return null;
        }

        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return null;
            }
        }

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

        if (this.fragments.containsKey(dbVersion) && this.fragments.get(dbVersion).containsKey(name)) {
            return this.fragments.get(dbVersion).get(name);
        } else  if (this.allFragmentsRetrieved.contains(dbVersion)){
            return null;
        } else {
            ass = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(EnsemblDBType.core, dbVersion)).getFragmentByName(name);
            this.cacheFragment(dbVersion, ass);
            return ass;
        }
    }

    
     /**
     * 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
     * 
     * @throws DAOException 
     */
    @Override
    public List<DATranscript> getTranscriptsForVegaID(String vegaID) throws DAOException {
        return this.getTranscriptsForVegaID(vegaID, null);
    }
    
    /**
     * 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 && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return transcripts;
            }
        }

        try {
            transcripts = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(
                    EnsemblDBType.core, dbVersion)).getCoreFactory().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 Transcripts that have been mapped to the given CCDS Identifier 
     * (This may be the CCDS accession or the CCDS accession.version).
     * 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
     * 
     * @throws DAOException 
     */    
    @Override
    public List<DATranscript> getTranscriptsForCcdsID(String ccdsID) throws DAOException {
        return this.getTranscriptsForCcdsID(ccdsID, null);
    }
    
    /**
     * 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.version).
     * 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 && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return transcripts;
            }
        }

        try {
            transcripts = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(
                    EnsemblDBType.core, dbVersion)).getCoreFactory().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 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

     * 
     * @throws DAOException 
     */
    @Override
    public List<DATranslation> getTranslationsForVegaID(String vegaID) throws DAOException {
        return this.getTranslationsForVegaID(vegaID, null);
    }
    
    /**
     * 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 && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return translations;
            }
        }

        try {
            translations = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(
                    EnsemblDBType.core, dbVersion)).getCoreFactory().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).
     * 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

     * 
     * @throws DAOException 
     */
    @Override
    public List<DAGene> getGenesForVegaID(String vegaID) throws DAOException {
        return this.getGenesForVegaID(vegaID, null);
    }
    
    /**
     * 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 && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return genes;
            }
        }

        try {
            genes = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(
                    EnsemblDBType.core, dbVersion)).getCoreFactory().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) throws DAOException {
        return this.getGeneByStableID(stableID, null);
    }

    @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 && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return null;
            }
        }

        try {
            gene = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(
                    EnsemblDBType.core, dbVersion)).getCoreFactory().getGeneDAO().getGeneByStableID(stableID.trim());
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException(e);
            }
        }

        return gene;
    }
    
    @Override
    public List<DAGene> getGenesForExactName(String name) throws DAOException {
         return this.getGenesForExactName(name, null);
    }
    
    @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;
            }
        }
        
        try {
            out = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(
                    EnsemblDBType.core, dbVersion)).getCoreFactory().getGeneDAO().getGenesByExactName(name.trim());
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException(e);
            }
        }
        
        return out;
    }
    
    @Override
    public List<DAGene> getGenesForNameBeginning(String name) throws DAOException {
        if (name==null) {
            return new ArrayList<DAGene>();
        }        
         return this.getGenesForExactName(name.trim()+"%", null);
    }
    
    @Override
    public List<DAGene> getGenesForNameBeginning(String name, String dbVersion) throws DAOException {
        if (name==null) {
            return new ArrayList<DAGene>();
        }
         return this.getGenesForExactName(name.trim()+"%", dbVersion);
    }
    
    @Override
    public DATranscript getTranscriptByStableID(String stableID) throws DAOException {
        return this.getTranscriptByStableID(stableID, null);
    }

    @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 && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return null;
            }
        }

        try {
            transcript = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(
                    EnsemblDBType.core, dbVersion)).getCoreFactory().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) throws DAOException {
        return this.getTranslationByStableID(stableID, null);
    }

    @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 && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return null;
            }
        }

        try {
            translation = ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(
                    EnsemblDBType.core, dbVersion)).getCoreFactory().getTranslationDAO().getTranslationByStableID(stableID.trim());
        } catch (Exception e) {
            if (e instanceof DAOException) {
                throw (DAOException) e;
            } else {
                throw new DAOException("Error retrieving translation by StableID.", e);
            }
        }

        return translation;
    }

    @Override
    public TreeSet<String> getSchemaVersions() {
        return this.schemaVersions;
    }

    @Override
    public TreeSet<String> getDBVersions() {
        return this.dbVersions;
    }

    public void setDatabaseStyleSpeciesName(String dbSpeciesName) {
        this.databaseStyleSpeciesName = dbSpeciesName;
    }
    
    public void setDatabaseStyleSpeciesName(Integer version, String dbSpeciesName) {
        this.dbStyleNameByVersion.put(version, dbSpeciesName);
    }
    
    public String getDatabaseStyleSpeciesName(Integer version) {
        return this.dbStyleNameByVersion.get(version);
    }

    @Override
    public String toString() {
        return ((this.commonName != null && !this.commonName.isEmpty()) ? this.commonName : this.shortName)
                + " (" + this.speciesBinomial + ")  ";
    }

    public DAChromosome getCachedChromosome(DAChromosome chr_in) {

        if (chr_in == null) {
            return null;
        }

        //test we have enough details on this chromosome to use the cache
        if (chr_in.getChromosomeName() == null
                || chr_in.getChromosomeName().isEmpty()
                || chr_in.getDaoFactory() == null
                || chr_in.getDaoFactory().getDBVersion() == null
                || chr_in.getDaoFactory().getDBVersion().isEmpty()) {
            return chr_in;
        }

        //if the cach has this db version
        if (chromosomes.containsKey(chr_in.getDaoFactory().getDBVersion())) {

            //if the version hash has a chr of this name return the cached one
            if (chromosomes.get(chr_in.getDaoFactory().getDBVersion()).containsKey(chr_in.getChromosomeName())) {

                DAChromosome c = chromosomes.get(chr_in.getDaoFactory().getDBVersion()).get(chr_in.getChromosomeName());
                c.setAttributes(chr_in.getAttributes());
                return c;
            } //otherwise add this chr to the cache and return it
            else {
                chromosomes.get(chr_in.getDaoFactory().getDBVersion()).put(chr_in.getChromosomeName(), chr_in);
                return chr_in;
            }

        } //put create a hash for this version, and add this named chromosome to it, before returning it
        else {
            chromosomes.put(chr_in.getDaoFactory().getDBVersion(), new TreeMap<String, DAChromosome>());
            chromosomes.get(chr_in.getDaoFactory().getDBVersion()).put(chr_in.getChromosomeName(), chr_in);
            return chr_in;
        }
    }
    
    public DAAssembledDNASequence getCachedFragment(DAAssembledDNASequence frag_in) {

        if (frag_in == null) {
            return null;
        }

        //test we have enough details on this chromosome to use the cache
        if (frag_in.getName() == null
                || frag_in.getName().isEmpty()
                || frag_in.getDaoFactory() == null
                || frag_in.getDaoFactory().getDBVersion() == null
                || frag_in.getDaoFactory().getDBVersion().isEmpty()) {
            return frag_in;
        }

        //if the cache has this db version
        if (fragments.containsKey(frag_in.getDaoFactory().getDBVersion())) {

            //if the version hash has a frag of this name return the cached one
            if (fragments.get(frag_in.getDaoFactory().getDBVersion()).containsKey(frag_in.getName())) {

                DAAssembledDNASequence c = fragments.get(frag_in.getDaoFactory().getDBVersion()).get(frag_in.getName());
                c.setAttributes(frag_in.getAttributes());
                return c;
            } //otherwise add this frag to the cache and return it
            else {
                fragments.get(frag_in.getDaoFactory().getDBVersion()).put(frag_in.getName(), frag_in);
                return frag_in;
            }

        } //put create a hash for this version, and add this named fragment to it, before returning it
        else {
            fragments.put(frag_in.getDaoFactory().getDBVersion(), new TreeMap<String, DAAssembledDNASequence>());
            fragments.get(frag_in.getDaoFactory().getDBVersion()).put(frag_in.getName(), frag_in);
            return frag_in;
        }
    }

    @Override
    public EnsemblComparaDivision getComparaDivision() {
        //the default value is MULTI - used for ensembl.org
        return comparaDivision;
    }

    public void setComparaDivision(String speciesDivision) {
        //sets group for ensemblgenomes.org
        this.comparaDivision = EnsemblComparaDivision.getEnsemblComparaDivisionByMetaValue(speciesDivision);
    }
    
    public void setComparaDivision(EnsemblComparaDivision speciesDivision) {
        this.comparaDivision = speciesDivision;
    }

    @Override
    public String getAssemblyName(String dbVersion) {

        String out = "";
        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return out;
            }
        }

        if (this.assemblyNamesByVersion.get(dbVersion) == null) {
            if (this.getDatabaseByTypeAndVersion(EnsemblDBType.core, dbVersion) != null) {
                //the lazyload will be called here if required
                out = ((SingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(EnsemblDBType.core, dbVersion)).getAssemblyName();
            }
            this.assemblyNamesByVersion.put(dbVersion, out);
        }

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

    //non lazyload direct setter
    public void setAssemblyAccession(String version, String value) {
        this.assemblyAccessionsByVersion.put(version, value);
    }
    //non lazyload direct setter

    public void setAssemblyName(String version, String value) {
        this.assemblyNamesByVersion.put(version, value);
    }

    @Override
    public String getAssemblyAccession(String dbVersion) {
        String out = "";
        if (dbVersion == null || dbVersion.isEmpty()) {
            if (this.highestDBRelease!=null && this.highestDBRelease!=0) {
                 dbVersion = this.highestDBRelease.toString();  
            } else {
                return out;
            }
        }

        if (this.assemblyAccessionsByVersion.get(dbVersion) == null) {
            if (this.getDatabaseByTypeAndVersion(EnsemblDBType.core, dbVersion) != null) {
                //the lazyload will be called here if required
                out = ((SingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(EnsemblDBType.core, dbVersion)).getAssemblyAccession();
            }
            this.assemblyAccessionsByVersion.put(dbVersion, out);
        }

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

    @Override
    public Integer getHighestDBRelease() {
        return this.highestDBRelease;
    }
    
    @Override
    public void setAssemblyExceptions(String version) throws DAOException {
        
        //HashMap<DAChromosome, MappingSet> results = new HashMap<DAChromosome, MappingSet>();
        TreeMap<String, DAChromosome> chrs = this.getChromosomes(version);
        
        if (chrs != null && !chrs.isEmpty()) {

            try {
                ((DBSingleSpeciesCoreDatabase) this.getDatabaseByTypeAndVersion(
                        EnsemblDBType.core, version)).getCoreFactory().getChromosomeDAO().setAssemblyExceptions(chrs);
            } catch (Exception e) {
                if (e instanceof DAOException) {
                    throw (DAOException) e;
                } else {
                    throw new DAOException(e);
                }
            }

        }
        
        //this.assemblyExceptions.put(version, results);
    }

    @Override
    public String getAssemblyAccessionStem() {
        return this.getAssemblyAccession(null).split("\\.")[0];
    }
    
    @Override
    public String getAssemblyAccessionStem(String dbVersion) {
        return this.getAssemblyAccession(dbVersion).split("\\.")[0];
    }

    public String getUrlName() {
        return urlName;
    }

    public void setUrlName(String urlName) {
        this.urlName = urlName;
    }

    @Override
    public boolean isInPanCompara(String dbVersion) {
        if (registry==null
                || !this.getDBVersions().contains(dbVersion)) {
            
            return false;
        } 
        return this.registry.isSpeciesInPanHomology(this, dbVersion);
    }
}