/**
 * 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.datasourceaware.core;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import uk.ac.roslin.ensembl.config.EnsemblComparaDivision;
import uk.ac.roslin.ensembl.config.EnsemblCoreObjectType;
import uk.ac.roslin.ensembl.config.FeatureType;
import uk.ac.roslin.ensembl.dao.compara.HomologyDAO;
import uk.ac.roslin.ensembl.dao.factory.DAOComparaFactory;
import uk.ac.roslin.ensembl.dao.factory.DAOCoreFactory;
import uk.ac.roslin.ensembl.dao.factory.DAOFactory;
import uk.ac.roslin.ensembl.dao.factory.DAOSpeciesFactory;
import uk.ac.roslin.ensembl.datasourceaware.variation.DAVariation;
import uk.ac.roslin.ensembl.exception.DAOException;
import uk.ac.roslin.ensembl.exception.RangeException;
import uk.ac.roslin.ensembl.model.Coordinate.Strand;
import uk.ac.roslin.ensembl.model.*;
import uk.ac.roslin.ensembl.model.core.CollectionSpecies;
import uk.ac.roslin.ensembl.model.core.CoordinateSystem;
import uk.ac.roslin.ensembl.model.core.CoreObject;
import uk.ac.roslin.ensembl.model.core.Species;
import uk.ac.roslin.ensembl.model.database.CollectionCoreDatabase;
import uk.ac.roslin.ensembl.model.database.CollectionDatabase;
import uk.ac.roslin.ensembl.model.database.Registry;
import uk.ac.roslin.ensembl.model.database.SingleSpeciesCoreDatabase;
import uk.ac.roslin.ensembl.model.database.SingleSpeciesDatabase;

/**
 *
 * @author paterson
 */
public class DADNASequence extends org.biojava3.core.sequence.DNASequence implements CoreObject, uk.ac.roslin.ensembl.model.core.DNASequence {

    protected DAOFactory daoFactory = null;
    protected String schemaVersion = null;
    protected String dbVersion = null;
    protected Registry registry = null;
    protected Integer id = null;
    protected Integer seqRegionID = null;
    protected String name = null;
    protected String dbSpeciesName = null;
    protected Species species = null;
    protected Integer DBSeqLength = null;
    protected CoordinateSystem coordSystem = null;
    protected MappingSet mappings = new MappingSet();
    protected HashMap<ObjectType, CoordinateSet> mappedRegions
            = new HashMap<ObjectType, CoordinateSet>();
    protected HashMap<ObjectType, MappingSet> objectTypeMappings
            = new HashMap<ObjectType, MappingSet>();
    protected HashMap<EnsemblComparaDivision, DAOComparaFactory> comparaFactories
            = new HashMap<EnsemblComparaDivision, DAOComparaFactory>();
    
    protected Integer codonTableID = 1; //default universal code
    protected boolean lazyLoaded = false;
    HashMap<String,String> adhocAttributes = new HashMap<String,String>();
    
    //to simplify Mybatis fetching
    protected Integer csID = null;

    public DADNASequence() {
        super();

    }

    public DADNASequence(DAEnsemblDNASequenceReader proxyLoader) {
        super(proxyLoader);
        ((DAEnsemblDNASequenceReader) this.getProxySequenceReader()).setParent(this);
        this.setId(proxyLoader.getSeqRegionID());
        this.setDBSeqLength(proxyLoader.getLengthInteger());
    }

    public DADNASequence(String sequence) {
        super(new DAEnsemblDNASequenceReader());
        ((DAEnsemblDNASequenceReader) this.getProxySequenceReader()).setParent(this);
        ((DAEnsemblDNASequenceReader) this.getProxySequenceReader()).setContents(sequence);
    }

    public DADNASequence(DAOCoreFactory factory) {
        this.setDaoFactory(factory);
    }

    public void setSequenceStorage(DAEnsemblDNASequenceReader proxyLoader) {
        this.setProxySequenceReader(proxyLoader);
        ((DAEnsemblDNASequenceReader) this.getProxySequenceReader()).setParent(this);
    }

    public DAOCoreFactory getDaoFactory() {
        return (DAOCoreFactory) daoFactory;
    }

    public void setDaoFactory(DAOFactory daoFactory) {
        this.daoFactory = daoFactory;
        if (this.daoFactory!= null) {
            this.setSchemaVersion(daoFactory.getEnsemblSchemaVersion());
            this.setDBVersion(daoFactory.getDBVersion());
            this.setRegistry((Registry) daoFactory.getRegistry());
        }
    }

    @Override
    public String getSchemaVersion() {
            return schemaVersion;
    }

    private void setSchemaVersion(String schemaVersion) {
        this.schemaVersion = schemaVersion;
    }

    @Override
    public String getDBVersion() {
            return dbVersion;
    }

    private void setDBVersion(String dbversion) {
        this.dbVersion = dbversion;
    }

    public Registry getRegistry() {
            return registry;
    }

    public void setRegistry(Registry datasource) {
        this.registry = datasource;
    }

    @Override
    public Integer getId() {
        return id;
    }

    @Override
    public void setId(Integer id) {
        this.id = id;
    }

    public String getDBName() {
        return (daoFactory!= null)?daoFactory.getDatabaseName():null;
    }

    @Override
    public Species getSpecies() {
        if (species == null && this.daoFactory != null && this.daoFactory instanceof DAOSpeciesFactory) {
            species = ((DAOSpeciesFactory) this.daoFactory).getSpecies();
        }
        return species;
    }

    @Override
    public void setSpecies(Species species) {
        this.species = species;
    }

    @Override
    public ObjectType getType() {
        //forces a lazy load so make sure we get CS for all retrieved sequenceIDS in the first query!
        if (this.getCoordSystem() != null) {
            return this.getCoordSystem().getType();
        } else {
            return EnsemblCoreObjectType.DNASequence;
        }
    }

    @Override
    public Integer getDBSeqLength() {
        if (DBSeqLength == null) {
            this.lazyLoad();
        }
        if (DBSeqLength != null) {
            return DBSeqLength;
        } else { return 0;}
    }

    @Override
    public void setDBSeqLength(Integer seqLength) {
        this.DBSeqLength = seqLength;
        this.setBioEnd(seqLength);
    }

    @Override
    public Integer getBioEnd() {

        try {
            return (super.getBioEnd() != null) ? super.getBioEnd() : this.getDBSeqLength();
        } catch (NullPointerException e) {
            return this.getDBSeqLength();
        }
    }

    @Override
    public int getLength() {

        try {
            return super.getLength();
        } catch (NullPointerException e) {
            return this.getDBSeqLength();
        }
    }

    @Override
    public String getName() {
        if (name == null) {
            this.lazyLoad();
        }
        return name;
    }

    @Override
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public CoordinateSystem getCoordSystem() {

        if (coordSystem == null) {
            this.lazyLoad();
        }

        return coordSystem;
    }

    @Override
    public void setCoordSystem(CoordinateSystem coordSystem) {
        this.coordSystem = coordSystem;
    }

    @Override
    public MappingSet getLoadedMappings() {
        return this.mappings;
    }

    //Should Be Private??
    @Override
    public MappingSet getLoadedMappings(ObjectType targetType) {

        //need to add lazy load here?

        if (!this.objectTypeMappings.containsKey(targetType)) {
            return new MappingSet();
        } else {
            return this.objectTypeMappings.get(targetType);
        }
    }

    @Override
    public Boolean addMapping(Mapping mapping) {

//        //check we haven't already added a mapping for an object with this id!
//        if (mapping.getTarget() != null) {
//
//            for (Mapping m : this.mappings) {
//                if (m.getTarget() != null && m.getTarget().getId().equals(mapping.getTarget().getId())) {
//                    return;
//                }
//            }
//        }

        //if we fail to add the mapping this will be false
        if (this.mappings.add((Mapping) mapping)) {

            ObjectType t = mapping.getTargetType();

            if (t != null) {
                if (!this.objectTypeMappings.containsKey(t)) {
                    this.objectTypeMappings.put(t, new MappingSet());
                }

                this.objectTypeMappings.get(t).add((Mapping) mapping);
            }
            return true;
        }
        return false;
    }

    /**
     * Returns a List of Genes on the specified Coordinate region. 
     * @param coord
     * 
     * @throws DAOException 
     */
    @Override
    public List<DAGene> getGenesOnRegion(Coordinate coord) throws DAOException {

        List<DAGene> out = new ArrayList<DAGene>();

        List<? extends Mapping> mappings = null;

        //test if we already have got the genes for this coordinate region
        if (this.mappedRegions.containsKey(FeatureType.gene)
                && this.mappedRegions.get(FeatureType.gene).containsCoordinateWithoutGaps(coord)) {

            //we need a temporary pointer here so we can match the signatures
            ArrayList<Mapping> theseMappings = new ArrayList<Mapping>();

            //find and return genes in this region
            for (Mapping m : this.getLoadedMappings(FeatureType.gene)) {
                Coordinate c = m.getSourceCoordinates();
                if (c.overlaps(coord)) {
                    theseMappings.add(m);
                }
            }
            mappings = theseMappings;

            if (mappings == null || mappings.isEmpty()) {
                return out;
            } else {
                //these mappings are seq -> gene

                if (coord.getStrand() == null) {
                    for (Mapping m : mappings) {
                        out.add((DAGene) m.getTarget());
                        //already done in the DAO
                        //this.addMapping(m);

                    }
                } else {
                    for (Mapping m : mappings) {
                        if (m.getSourceCoordinates().getStrand().equals(coord.getStrand())) {
                            out.add((DAGene) m.getTarget());
                        }
                        //already done in the DAO
                        //this.addMapping(m);
                    }
                }
            }
            return out;

        } else {

            if (this.getDaoFactory() != null && this.getDaoFactory().getGeneDAO() != null) {

                mappings = this.getDaoFactory().getGeneDAO().getGeneMappingsOnRegion(this, coord);
            }

            if (mappings == null || mappings.isEmpty()) {
                return out;
            } else {
                //these mappings ade gene->seq
                if (coord.getStrand() == null) {
                    for (Mapping m : mappings) {
                        out.add((DAGene) m.getSource());
                        //already done in the DAO
                        //this.addMapping(m);

                    }
                } else {
                    for (Mapping m : mappings) {
                        if (m.getTargetCoordinates().getStrand().equals(coord.getStrand())) {
                            out.add((DAGene) m.getSource());
                        }
                        //already done in the DAO
                        //this.addMapping(m);
                    }
                }
            }

            //put this region in the sore of mapped regions
            if (!mappedRegions.containsKey(FeatureType.gene)) {
                mappedRegions.put(FeatureType.gene, new CoordinateSet());
            }
            this.mappedRegions.get(FeatureType.gene).add(coord);
            return out;
        }
    }

    /**
     * Returns a List of Genes on the specified Region. Start/Stop locations must be 
     * both Non-Null and Non-ZERO or a Runtime IllegalArgumentException will be thrown. 
     * @param start
     * @param stop
     * @param strand
     * 
     * @throws DAOException 
     */
    @Override
    public List<DAGene> getGenesOnRegion(Integer start, Integer stop, Strand strand) throws DAOException {
        Coordinate coord = new Coordinate(start, stop, strand);
        return this.getGenesOnRegion(coord);
    }

    /**
     * Returns a List of Genes on the specified Region. Start/Stop locations must be 
     * both Non-Null and Non-ZERO or a Runtime IllegalArgumentException will be thrown. 
     * @param start
     * @param stop
     * 
     * @throws DAOException 
     */
    @Override
    public List<DAGene> getGenesOnRegion(Integer start, Integer stop) throws DAOException {

        return this.getGenesOnRegion(start, stop, null);
    }

    /**
     * Private lazyLoad method for validation of essential properties of this object. 
     * Refetchs the DNASequence by ID, and fills in Name,Length, CoordSystem, Attributes. 
     */
    private void lazyLoad() {

        if (!this.lazyLoaded && this.id != null && this.getDaoFactory() != null) {
            try {
                DADNASequence fetchedSeq = (DADNASequence) this.getDaoFactory().getSequenceDAO().getSequenceByID(id);
                this.setName(fetchedSeq.getName());
                this.setDBSeqLength(fetchedSeq.getDBSeqLength());
                this.setCoordSystem(fetchedSeq.getCoordSystem());
                this.setAttributes(fetchedSeq.getAttributes());
                this.lazyLoaded = true;
                
            } catch (Exception ex) {
            }
        }
    }
    
    /**
     * Method to get a string representation of the sequence for the given range. 
     * Arguments outwith the extent of the sequence (i.e. greater than its length, or less than the start site of +1) 
     * will throw a RangeException.   
     * @param begin
     * @param end
     * @throws RangeException
     */
    @Override
    public String getSequenceAsString(Integer begin, Integer end) throws RangeException {
        if (begin==null || begin==0 || end==null || end==0) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }        
        if (this.getLength()==0) {
            return "";
        }
        if (begin>end) {
            int temp = begin;
            begin = end;
            end = temp;
        }
        if (begin < this.getBioBegin() || end>this.getLength()) {
            throw new RangeException("Requested Sequence is outwith the extent of the Sequence (from +1 to 'length')."
                    +" Try using 'getPaddedSequenceAsString(int, int)' method.");
        }
        
        return super.getSequenceAsString(begin, end, org.biojava3.core.sequence.Strand.POSITIVE);
    }
    
    /**
     * Method to get a string representation of the sequence for the given range. 
     * If the requested range is outwith the sequence extent, 
     * the upstream and or downstream will be padded with N's.
     * @param begin
     * @param end
     */
    @Override
    public String getPaddedSequenceAsString(Integer begin, Integer end) {
        if (begin==null || begin==0 || end==null || end==0) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }        
        if (this.getLength()==0) {
            return "";
        }
        
        if (begin>end) {
            int temp = begin;
            begin = end;
            end = temp;
        }
        
        int up = 0, down = 0;
        if (begin < this.getBioBegin()) {
            if (begin<0) {
               up = this.getBioBegin()-(begin+1);
            } else {
               up = this.getBioBegin()-begin; 
            }
            
            begin = this.getBioBegin();
        }
        if (end>this.getLength()) {
            down = end - this.getLength();
            end = this.getLength();
        }
        
        return pad(super.getSequenceAsString(begin, end, org.biojava3.core.sequence.Strand.POSITIVE), up, down);
    }

    /**
     * Private method to pad a string representation of a sequence with given
     * numbers of upstream and downstream unknown bases.
     * @param seq String: the sequence top be padded.
     * @param upstream int: the number of upstream unknown bases to be prepended.
     * @param downstream int: the number of downstream unknown bases to be appended.
     */
    private String pad(String seq, int upstream, int downstream) {
       return  GapSequence.getGapString(upstream).concat(seq).concat(GapSequence.getGapString(downstream));
    }

    /**
     * Don't use Strands for getting sequence strings - always use getSequenceAsString
     * or getReverseComplementSequenceAsString to guarantee polarity.
     */    
    @Deprecated
    @Override
    public String getSequenceAsString(Integer bioStart, Integer bioEnd, org.biojava3.core.sequence.Strand strand) {
         if (bioStart==null || bioStart==0 || bioEnd==null || bioEnd==0) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }
        
        try {
            if (strand != null && strand == org.biojava3.core.sequence.Strand.NEGATIVE) {
                return getReverseComplementSequenceAsString(bioStart, bioEnd);
            } else {
                return getSequenceAsString(bioStart, bioEnd);
            }
        } catch (RangeException rangeException) {
            throw new RuntimeException("Deprecated method caught a RangeException.", rangeException);
        }
    }
    
    /**
     * Method to get a string representation of the reverse complement of the
     * sequence for the given range.
     * Arguments outwith the extent of the sequence (i.e. greater than its length, or less than the start site of +1) 
     * will throw a RangeException.      
     * @param begin
     * @param end
     * @return String
     * @throws RangeException 
     */
    @Override
    public String getReverseComplementSequenceAsString(Integer begin, Integer end) throws RangeException {
        if (begin==null || begin==0 || end==null || end==0) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }
        if (this.getLength()==0) {
            return "";
        }
        if (begin>end) {
            int temp = begin;
            begin = end;
            end = temp;
        }
        if (begin < this.getBioBegin() || end>this.getLength()) {
            throw new RangeException("Requested Sequence is outwith the extent of the Sequence (from +1 to 'length')"
                    +" Try using 'getPaddedSequenceAsString(int, int)' method.");
        }
        DAEnsemblDNASequenceReader ss = (DAEnsemblDNASequenceReader) getProxySequenceReader();
        return ss.getReverseComplementSequenceAsString(begin, end);
    }
    
    /**
     * Method to get a string representation of the reverse complement of the
     * sequence for the given range. If the requested range is outwith the sequence extent, 
     * the upstream and or downstream will be padded with N's.
     * @param begin
     * @param end
     */
    @Override
    public String getPaddedReverseComplementSequenceAsString(Integer begin, Integer end) {
        if (begin ==null || begin==0 || end==null|| end ==0 ) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }
        
        if (this.getLength()==0) {
            return "";
        }
        
        if (begin>end) {
            int temp = begin;
            begin = end;
            end = temp;
        }
        
        int up = 0, down = 0;
        
        if (begin < this.getBioBegin()) {
            
            if (begin<0) {
               up = this.getBioBegin()-(begin+1);
            } else {
               up = this.getBioBegin()-begin; 
            }
            
            begin = this.getBioBegin();
        }
        if (end>this.getLength()) {
            down = end - this.getLength();
            end = this.getLength();
        }
        
        
        DAEnsemblDNASequenceReader ss = (DAEnsemblDNASequenceReader) getProxySequenceReader();
        //note we switch the up/down cos on complement
        return pad(ss.getReverseComplementSequenceAsString(begin, end),down,up);
    }

    /**
     * Method to get a string representation of the reverse complement of the
     * sequence.
     */
    @Override
    public String getReverseComplementSequenceAsString() {
        if (this.getLength()==0) {
            return "";
        }      
        DAEnsemblDNASequenceReader ss = (DAEnsemblDNASequenceReader) getProxySequenceReader();
        return ss.getReverseComplementSequenceAsString(this.getBioBegin(), this.getBioEnd());        
    }

    @Override
    public HashMap<ObjectType, MappingSet> getObjectTypeMappings() {
        return objectTypeMappings;
    }

    @Override
    public HashMap<ObjectType, CoordinateSet> getMappedRegions() {
        return mappedRegions;
    }

    @Override
    public String getHashID() {
        return
                ((this.getDaoFactory()!=null) ? this.getDaoFactory().getDatabaseName() : "NODATABASE")

                +"_"

                +((this.getType()!=null) ? this.getType().toString() : "NOTYPE")

                +"_"

                +((this.getId()!=null) ? this.getId().toString() : "NOID");
    }

    @Override
    public String toString() {
        return ((this.getName()!=null) ? this.getName().toString() : ((this.getId()!=null) ? this.getId().toString() : "NOID"));
    }

    @Override
    public void clearAllMappings() {
            mappings.clear();
            mappedRegions.clear();
            objectTypeMappings.clear();
    }

    /**
     * Note the special case for Bacteria in collections in DB >16
     * @return 
     */
    public EnsemblComparaDivision getComparaDivision() {
        
       if (this.getSpecies() != null && this.getSpecies() instanceof CollectionSpecies
                && Integer.parseInt(this.getDBVersion())>16) {
            return EnsemblComparaDivision.PAN_HOMOLOGY;
       } else if (this.getSpecies() != null) {
            return this.getSpecies().getComparaDivision();
       }  
       return null;
    }

   public DAOComparaFactory getComparaFactory(EnsemblComparaDivision comparaDivision) {

        if (comparaFactories.containsKey(comparaDivision)) {
            return comparaFactories.get(comparaDivision);
        } else if (this.getDaoFactory() != null) {
            DAOComparaFactory f = this.getDaoFactory().getComparaFactory(comparaDivision);
            comparaFactories.put(comparaDivision, f);
            return f;
        }
        return null;
    }

    public DAOComparaFactory getComparaFactory() {

        EnsemblComparaDivision comparaDivision = this.getComparaDivision();

        if (comparaFactories.containsKey(comparaDivision)) {
            return comparaFactories.get(comparaDivision);
        } else if (this.getDaoFactory() != null) {
            DAOComparaFactory f = this.getDaoFactory().getComparaFactory(comparaDivision);
            comparaFactories.put(comparaDivision, f);
            return f;
        }
        return null;
    }
    
    /**
     * Specifies method to retrieve all potential regions of conserved synteny 
     * (i.e. multiple chromosome regions) in the specified target Species 
     * @param range
     * @param target
     * @return a HashMap of each DNASequence discovered against the MappingSet of Homologous genes
     * @throws DAOException 
     */    
    @Override
    public HashMap<DADNASequence, MappingSet> getRegionsOfConservedSynteny(Coordinate range,
            Species target) throws DAOException {
        return this.getRegionsOfConservedSynteny(range, target, null);
    }
    
    /**
     * Method to retrieve a single potential region of conserved synteny 
     * for the named chromosome in the specified target Species. In effect a filter 
     * on the full query, for efficiency where the target chromosome is already known.  
     * @param range
     * @param target
     * @param chrName
     * @return a HashMap of each DNASequence discovered against the MappingSet of Homologous genes
     * @throws DAOException 
     */     
    @Override
    public HashMap<DADNASequence, MappingSet> getRegionsOfConservedSynteny(Coordinate range,
            Species target, String chrName) throws DAOException {

        HashMap<DADNASequence, MappingSet> syntenies = new HashMap<DADNASequence, MappingSet>();
        
        if (target == null) {
            throw new DAOException("No target Species specified for getRegionsOfConservedSynteny");
        }
        if (this.getSpecies() == null || this.getComparaDivision() == null) {
            throw new DAOException("This Sequence does not seem to belong to a species present in comparison databases.");
        }
        
        //for bacterial species from v17 we need to check both of the species are in
        //pan compara database
        
        if (  this.getSpecies() instanceof CollectionSpecies  ) {
            
            if (this.getComparaDivision().equals(EnsemblComparaDivision.PAN_HOMOLOGY)
                    && (!this.getSpecies().isInPanCompara(this.getDBVersion())
                    || !target.isInPanCompara(this.getDBVersion()))) {
                return syntenies;
            }

        }
        

        try {
            

            HomologyDAO dao =
                    this.getComparaFactory().getHomologyDAO();

            syntenies = (HashMap<DADNASequence, MappingSet>) dao.getRegionsOfConservedSynteny(this, range, target, chrName);

            return syntenies;
        } catch (DAOException dex) {
            if (dex.getMessage().endsWith("target Species not identified in Compara source")) {
                return syntenies;
            }
            throw new DAOException("Failed to access Compara to get Regions of Conserved Synteny",dex);
        }
    }

    @Override
    public String getAssembly() {

        if (this.getSpecies() == null || this.getDaoFactory() == null
                || this.getDaoFactory().getDatabase() == null) {
            return null;
        }

        try {

            if (this.getSpecies() instanceof CollectionSpecies) {
                return ((CollectionCoreDatabase) this.getDaoFactory().getDatabase()).getAssemblyName(
                        (CollectionSpecies) this.getSpecies());

            } else {
                return ((SingleSpeciesCoreDatabase) this.getDaoFactory().getDatabase()).getAssemblyName();

            }
        } catch (Exception e) {
            return null;
        }

    }

    /**
     * Returns list of Variations on specified Coordinate Region. Compare to 
     * {@link getVariationMappingsOnRegion(Coordinate coord)} methods.
     * @param coord
     * 
     * @throws DAOException 
     */
    @Override
    public List<DAVariation> getVariationsOnRegion(Coordinate coord) throws DAOException {
        
        //so far i am not adding the variations to the chromosome
        
        if (this.getDaoFactory()==null || this.getDaoFactory().getVariationFactory()==null) {
            return null;
        }
        
        return (List<DAVariation>) this.getDaoFactory().getVariationFactory().getVariationDAO().getVariationsOnRegion(this, coord);
    }


    /**
     * Returns list of Variations on specified Region.  Compare to 
     * {@link getVariationMappingsOnRegion(Integer start, Integer stop)} methods. Start/Stop locations must be 
     * both Non-Null and Non-ZERO or a Runtime IllegalArgumentException will be thrown. 
     * @param start
     * @param stop
     * 
     * @throws DAOException 
     */
     @Override
    public List<DAVariation> getVariationsOnRegion(Integer start, Integer stop) throws DAOException {
        return this.getVariationsOnRegion(new Coordinate(start,stop));
    }
    
    
    /**
     * Returns List of Mappings of Variations on specified Coordinate Region. Compare to 
     * {@link getVariationsOnRegion(Coordinate coord)} methods.
     * @param coord
     * 
     * @throws DAOException 
     */
     @Override
    public List<? extends Mapping> getVariationMappingsOnRegion(Coordinate coord) throws DAOException {
        
        //so far i am not adding the variations to the chromosome
        
        if (this.getDaoFactory()==null || this.getDaoFactory().getVariationFactory()==null) {
            return null;
        }
        
        return this.getDaoFactory().getVariationFactory().getVariationDAO().getVariationMappingsOnRegion(this, coord);
    }

    /**
     * Returns List of Mappings of Variations on specified Coordinate Region. Compare to 
     * {@link getVariationsOnRegion(Integer start, Integer stop)} methods. Start/Stop locations must be 
     * both Non-Null and Non-ZERO or a Runtime IllegalArgumentException will be thrown.
     * @param start
     * @param stop
     * 
     * @throws DAOException 
     */
     @Override
    public List<? extends Mapping> getVariationMappingsOnRegion(Integer start, Integer stop) throws DAOException {
        return this.getVariationMappingsOnRegion(new Coordinate(start,stop));
    }

    @Override
    public Integer getCodonTableID() {
        this.lazyLoad();
        return this.codonTableID;
    }
    
    public void setCodonTableID(Integer id) {
        this.codonTableID=id;
    }

//    public void fetchAttributes() {
//        
//        if (this.lazyLoaded ) {
//            return;
//        }
//        
//        if(this.getId() != null ) {
//            try {
//                this.getDaoFactory().getSequenceDAO().getValidatedSequence(this);
//            } catch (DAOException ex) {
//            }
//        }
//        
//        this.lazyLoaded = true;
//    }

    public void addAttribute(String key, String value) {
        this.adhocAttributes.put(key, value);
        updateCodonTableID();
    }
    
    public String getAttribute(String key) {
        return this.adhocAttributes.get(key);
    }
    
    public void setAttributes(HashMap<String,String> attribs) {
        this.adhocAttributes = attribs;
        updateCodonTableID();
    }
    
    public HashMap<String,String>  getAttributes() {
        return this.adhocAttributes;
    }
    
    private void updateCodonTableID() {
        if (this.adhocAttributes.containsKey("codon_table")) {
            this.setCodonTableID(Integer.parseInt(this.adhocAttributes.get("codon_table")));
        }
    }

    public void setLazyLoaded(boolean b) {
        this.lazyLoaded = b;
    }

    public Integer getCsID() {
        return csID;
    }

    public void setCsID(Integer csID) {
        this.csID = csID;
    }
    
}