/**
 * 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.*;
import org.biojava3.core.sequence.DNASequence;
import org.biojava3.core.sequence.ProteinSequence;
import org.biojava3.core.sequence.RNASequence;
import org.biojava3.core.sequence.transcription.TranscriptionEngine;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import uk.ac.roslin.ensembl.config.DBConnection;
import uk.ac.roslin.ensembl.config.EnsemblCoreObjectType;
import uk.ac.roslin.ensembl.config.ExternalDBType;
import uk.ac.roslin.ensembl.datasourceaware.DAXRef;
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.ProteinFeature;
import uk.ac.roslin.ensembl.model.core.Transcript;
import uk.ac.roslin.ensembl.model.core.Translation;
import uk.ac.roslin.ensembl.model.core.VegaFeature;

public class DATranslation extends DACoreObject implements Translation, XRefed, VegaFeature {

    DATranscript transcript = null;
    List<? extends ProteinFeature> proteinFeatures = null;
    private boolean canonical = false;
    private DAExon firstExon = null;
    private Integer firstExonID = null;
    private DAExon lastExon = null;
    private Integer lastExonID = null;
    private Integer firstExonStart = null;
    private Integer lastExonEnd = null;
    private Integer transcriptID = null;
    private DNASequence translatedSequence = null;
    /**
     * Each Mapping in this TreeSet has  
     * source: null (implicitly the translated sequence) 
     * sourceCoordinates: the coordinate on the translated sequence - including 
     * any 1 or 2 residue shift due to Exon1 phase issues. 
     * target: the (unprocessed) primaryTranscript specifying this Translation
     * targetCoordinates: the coordinates on the (unprocessed) pimaryTranscript
     */
    MappingSet translationMappings = null;
    final static Logger LOGGER = LoggerFactory.getLogger(DATranslation.class);
    private String vegaProteinID = null;
    protected  Set<DAXRef> xrefs = new HashSet<DAXRef>();
    protected HashMap<ExternalDBType, Set<DAXRef>> typedXRefs = new HashMap<ExternalDBType, Set<DAXRef>>();
    boolean xrefsInitialized = false;
    private boolean initialized;
    private TreeSet<String> synonyms = null;
  
    /*
     * Temporarily just a demo function... 
     */
    @Override
    public List<? extends ProteinFeature> getProteinFeatures() {
        if (proteinFeatures == null) {

            if (this.getId() == null) {
                return null;
            }

            try {
                proteinFeatures = this.getDaoFactory().getProteinFeatureDAO().getProteinFeaturesByTranslationID(this.id);
            } catch (DAOException dex) {
                LOGGER.info("failed to get Protein Features", dex);
            } catch (Exception ex) {
                LOGGER.info("failed to get Protein Features", ex);
            }

        }
        return proteinFeatures;
    }

    @Override
    public DATranscript getTranscript() {
        //v1.15 previously Translations were only instantiated by the MyBatis/DAO mapping
        //TranslationDAO.getTranslationsForTranscript(Transcript transcript)
        //and therefor the transcript were set on all translations
        //now we have the ability to retrieve a transaltion by stableID from a species
        //so we need to be able to load the transcript for this
        
        if (transcript!=null) {
            return transcript;
        }
        this.reinitialize();
        if (this.transcriptID!=null && this.getDaoFactory()!= null) {
            try {
                transcript = (DATranscript) this.getDaoFactory().getTranscriptDAO().getTranscriptByID(this.transcriptID);
            } catch (DAOException ex) {
                    LOGGER.info("Threw DAOException on trying to get Transcript: "+this.transcriptID, ex);
                }
        }
        
        return transcript;
    }
    
    public boolean isInitialized() {
        return initialized;
    }
    
    public void setInitialized(boolean init) {
        this.initialized = init;
    }

    void reinitialize()  { 
        if (this.isInitialized()) {
            return;
        }
        try {
            //nb getDaoFactory() will try and make a factory if we have at least species and ensembl version
            this.getDaoFactory().getTranslationDAO().reInitialize(this);
                       
        } catch (Exception ex) {
            LOGGER.info("Failed to reinitialize the Gene from the Database (using its stableID: "
                    +this.stableID+").", ex);
        } finally {
            //always set this so dont try again
            this.setInitialized(true);
        }
    }
    
    @Override
    public void setTranscript(Transcript transcript) {
        this.transcript = (DATranscript) transcript;
    }

    @Override
    public ObjectType getType() {
        return EnsemblCoreObjectType.translation;
    }

    /**
     * Returns whether this Translation is marked as the Canonical Translation for 
     * its transcript. (Prior to Ensembl57 there was a single translation object 
     * for each transcript, which is considered as canonical.)
     */
    public boolean isCanonical() {
        return canonical;
    }

    public void setCanonical(boolean canonical) {
        this.canonical = canonical;
    }

    /**
     * Returns the internal database ID of the first Exon for this translation.
     */
    public Integer getFirstExonID() {
        return firstExonID;
    }
    
    public void setFirstExonID(Integer firstExonID) {
        this.firstExonID = firstExonID;
    }

    /**
     * Returns the (relative) position of the translational start in the first exon of this Translation.
     */
    public Integer getFirstExonStart() {
        return firstExonStart;
    }

    public void setFirstExonStart(Integer firstExonStart) {
        this.firstExonStart = firstExonStart;
    }

    /**
     * Returns the internal database ID of the last Exon for this translation.
     */
    public Integer getLastExonID() {
        return lastExonID;
    }

    public void setLastExonID(Integer lastExonID) {
        this.lastExonID = lastExonID;
    }

    @Override
    public String getStableID() {
        return stableID;
    }

    @Override
    public void setStableID(String stableID) {
        this.stableID = stableID;
    }

    /**
     * Returns the first Exon of this Translation.
     */
    public DAExon getFirstExon() {
        if (this.firstExon != null) {
            return this.firstExon;
        }

        for (DAExon e : this.getTranscript().getExons()) {
            if (e.getId().equals(this.getFirstExonID())) {
                this.firstExon = e;
            }
            if (e.getId().equals(this.getLastExonID())) {
                this.lastExon = e;
            }
        }
        return firstExon;
    }

    /**
     * Gets the Gene associated with this Translation via the associated Transcript.
     */
    public DAGene getGene() {
        if (this.getTranscript() != null) {
            return this.getTranscript().getGene();
        } else {
            return null;
        }
    }

    /**
     * Returns the last Exon of this Translation.
     */
    public DAExon getLastExon() {

        if (this.lastExon != null) {
            return this.lastExon;
        }

        for (DAExon e : this.getTranscript().getExons()) {
            if (e.getId().equals(this.getFirstExonID())) {
                this.firstExon = e;
            }
            if (e.getId().equals(this.getLastExonID())) {
                this.lastExon = e;
            }
        }
        return lastExon;

    }

    
    /**
     * Returns the (relative) position of the translational end in the last exon 
     * of this Translation. This is inclusive of the stop codon.
     */    
    public Integer getLastExonEnd() {
        return lastExonEnd;
    }

    public void setLastExonEnd(Integer lastExonEnd) {
        this.lastExonEnd = lastExonEnd;
    }

    /**
     * Returns a (BioJava) ProteinSequence for this Translation using the specified 
     * Codon Table ID to retrieve the appropriate  (BioJava)  TranscriptionEngine.
     */
    public ProteinSequence getProteinSequence(Integer codonTable) {
        /*
         * By default BioJava uses  a Transcription engine singleton that uses 
         * the universal codon table, we can create alternative codon usage 
         * engines from the common IDed tables
         * 1 - UNIVERSAL
         * 2 - VERTEBRATE_MITOCHONDRIAL
         * 3 - YEAST_MITOCHONDRIAL
         * 4 - MOLD_MITOCHONDRIAL
         * 5 - INVERTEBRATE_MITOCHONDRIAL
         * 6 - CILIATE_NUCLEAR
         * 9 - ECHINODERM_MITOCHONDRIAL
         * 10 - EUPLOTID_NUCLEAR
         * 11 - BACTERIAL
         * 12 - ALTERNATIVE_YEAST_NUCLEAR
         * 13 - ASCIDIAN_MITOCHONDRIAL
         * 14 - FLATWORM_MITOCHONDRIAL
         * 15 - BLEPHARISMA_MACRONUCLEAR
         * 16 - 2CHLOROPHYCEAN_MITOCHONDRIAL
         * 21 - TREMATODE_MITOCHONDRIAL
         * 23 - SCENEDESMUS_MITOCHONDRIAL 
         */
        return this.getProteinSequence(this.getRegistry().getTranscriptionEngine(codonTable));
    }

    /**
     * Returns a (BioJava) ProteinSequence for this Translation using the specified (BioJava) 
     * TranscriptionEngine.
     *  
     */
    public ProteinSequence getProteinSequence(TranscriptionEngine trancriptionEngine) {

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

        if (this.translatedSequence == null) {
            this.translate();
        }

        if (this.translatedSequence != null
                && this.translatedSequence.getLength() > 2) {
            //vanilla BioJava Translation
            //a bug in BioJava-core 3.0 which fails to translate some codons with N in, needs shift up to v3.0.3
            return  this.translatedSequence.getRNASequence(trancriptionEngine).getProteinSequence(trancriptionEngine);
            
        } else {
            return null;
        }
    }

    /**
     * Returns a (BioJava) ProteinSequence for this Translation. IF possible it will use a 
     * TranscriptionEngine configured to use the Codon table specified by the annotated Chromosome.
     * Otherwise it will use the default Universal codon table.
     *  
     */
    @Override
    public ProteinSequence getProteinSequence() {

        Integer codonTable = 1;

        if (this.getTranscript() != null) {

            try {
                codonTable = this.getTranscript().getTargetSequence().getCodonTableID();
            } catch (Exception ex) {
            }
        }
        //if no codon_table attribute has been set for the DNASequence we just use the defualt
        return this.getProteinSequence(this.getRegistry().getTranscriptionEngine(codonTable));
    }

   /**
    * Convenience method to get the Amino Acid sequence of the protein product of
    * this translation. Wraps BioJava ProteinSequence functionality. Note that no 
    * terminator (*) is appended. 
    *  
    */
    public String getProteinSequenceAsString() {
        return this.getProteinSequence().getSequenceAsString();
    }
    
    /**
     * Convenience method to get the Amino Acid sequence of the protein product of
     * this translation. Wraps BioJava ProteinSequence functionality, using the specified 
     * Codon Table ID to retrieve the appropriate  (BioJava)  TranscriptionEngine.
     * Note that no terminator (*) is appended. 
     * @param codonTable 
     *  
     */
    public String getProteinSequenceAsString(Integer codonTable) {
        return this.getProteinSequence(codonTable).getSequenceAsString();
    }
    
    /**
     * Convenience method to get the Amino Acid sequence of the protein product of
     * this translation. Wraps BioJava ProteinSequence functionality, using the specified 
     * (BioJava)  TranscriptionEngine. Note that no terminator (*) is appended. 
     * @param trancriptionEngine
     *  
     */
    public String getProteinSequenceAsString(TranscriptionEngine trancriptionEngine) {
        return this.getProteinSequence(trancriptionEngine).getSequenceAsString();
    }
    
    /**
     * Convenience method to get the Amino Acid sequence of the given range of the 
     * protein product of this translation. Wraps BioJava ProteinSequence functionality.
     * Note that terminators (*) will be appended for positions beyond the end of the peptide,
     * but within the translation (i.e. stop codons). 
     * @param start
     * @param end
     * @throws RangeException if position does not lie within the peptide and stop codons.  
     *  
     */
    public String getProteinSequenceAsString(Integer start, Integer end) {
        
        org.biojava3.core.sequence.Strand strand = org.biojava3.core.sequence.Strand.POSITIVE;       
        if (start!=null && end !=null && start>end) {
             //Integers are assigned by value not as pointers
             Integer temp = end;
             end = start;
             start = temp;
             strand = org.biojava3.core.sequence.Strand.NEGATIVE;
        }
        
         if (start==null || start<1 
                 || end == null || end < 1 || 3*end > this.getLength()) {
            throw new RangeException("An amino acid position must lie between 1 and the length of the peptide. ");
        }       
         
        String stop = "";
         
        if (start > this.getProteinSequence().getLength() ) {
            return GapSequence.getGapString((end-start)+1, '*');
        } 
         
         
        for (int i=0; i<end-this.getProteinSequence().getLength();i++) {
            stop += "*";
        } 
        end -= stop.length();
        if (org.biojava3.core.sequence.Strand.NEGATIVE.equals(strand)) {
            return stop+this.getProteinSequence().getSequenceAsString(start,end,strand);
        }
        return this.getProteinSequence().getSequenceAsString(start,end,org.biojava3.core.sequence.Strand.POSITIVE)+stop;        
    }
    
    /**
     * Convenience method to get the Amino Acid sequence of the given range of the 
     * protein product of this translation. 
     * Wraps BioJava ProteinSequence functionality, using the specified 
     * Codon Table ID to retrieve the appropriate  (BioJava)  TranscriptionEngine.
     * For 'start'>'end' the amino acid sequence will be written in reverse.
     * Note that terminators (*) will be appended for positions beyond the end of the peptide,
     * but within the translation (i.e. stop codons). 
     * @param start
     * @param end
     * @throws RangeException if position does not lie within the peptide 
     *  
     */
    public String getProteinSequenceAsString(Integer codonTable, Integer start, Integer end) {
        
        org.biojava3.core.sequence.Strand strand = org.biojava3.core.sequence.Strand.POSITIVE;       
        if (start!=null && end !=null && start>end) {
             //Integers are assigned by value not as pointers
             Integer temp = end;
             end = start;
             start = temp;
             strand = org.biojava3.core.sequence.Strand.NEGATIVE;
        }
        
        if (start==null || start<1 
                 || end == null || end < 1 || 3*end > this.getLength()) {
            throw new RangeException("An amino acid position must lie between 1 and the length of the peptide. ");
        }
         
        if (start > this.getProteinSequence(codonTable).getLength() ) {
            return GapSequence.getGapString((end-start)+1, '*');
        }  
        String stop = "";
        for (int i=0; i<end-this.getProteinSequence(codonTable).getLength();i++) {
            stop += "*";
        } 
        end -= stop.length();         

        if (org.biojava3.core.sequence.Strand.NEGATIVE.equals(strand)) {
            return stop+this.getProteinSequence(codonTable).getSequenceAsString(start,end,strand);
        }
        return this.getProteinSequence(codonTable).getSequenceAsString(start,end,org.biojava3.core.sequence.Strand.POSITIVE)+stop;        
        
    }
    
    /**
     * Convenience method to get the Amino Acid sequence of the given range of the 
     * protein product of this translation. 
     * Wraps BioJava ProteinSequence functionality, using the specified 
     * (BioJava)  TranscriptionEngine.
     * For 'start'>'end' the amino acid sequence will be written in reverse.
     * Note that terminators (*) will be appended for positions beyond the end of the peptide,
     * but within the translation (i.e. stop codons). 
     * @param start
     * @param end
     * @throws RangeException if position does not lie within the peptide 
     *  
     */    
    public String getProteinSequenceAsString(TranscriptionEngine trancriptionEngine, Integer start, Integer end) {
        
        org.biojava3.core.sequence.Strand strand = org.biojava3.core.sequence.Strand.POSITIVE;       
        if (start!=null && end !=null && start>end) {
             //Integers are assigned by value not as pointers
             Integer temp = end;
             end = start;
             start = temp;
             strand = org.biojava3.core.sequence.Strand.NEGATIVE;
        }
        
        if (start==null || start<1  
                || end == null || end < 1 || 3*end > this.getLength()) {
            throw new RangeException("An amino acid position must lie between 1 and the length of the peptide. ");
        }
        
        if (start > this.getProteinSequence(trancriptionEngine).getLength() ) {
            return GapSequence.getGapString((end-start)+1, '*');
        } 
        
        String stop = "";
        for (int i=0; i<end-this.getProteinSequence(trancriptionEngine).getLength();i++) {
            stop += "*";
        } 
        end -= stop.length();  
        
        if (org.biojava3.core.sequence.Strand.NEGATIVE.equals(strand)) {
            return stop+this.getProteinSequence(trancriptionEngine).getSequenceAsString(start,end,strand);
        }
        
        return this.getProteinSequence(trancriptionEngine).getSequenceAsString(start,end,org.biojava3.core.sequence.Strand.POSITIVE)+stop;
    }

    /**
     * Returns a String representation of this Translation ( i.e. the DNA Sequence...).
     *  
     */
    public String getTranslatedSequenceAsString() {

        if (translatedSequence == null) {
            this.translate();
        }

        if (translatedSequence != null) {
           return  translatedSequence.getSequenceAsString();
        } else {
            return "";
        }
    }
    
    /**
     * Returns a String representation of this Translation for the given range 
     * (i.e. the DNA Sequence...).
     * @param start
     * @param stop
     * 
     * @throws RangeException
     * @throws IllegalArgumentException 
     */
    public String getTranslatedSequenceAsString(Integer start, Integer stop) throws RangeException, IllegalArgumentException {
        
        if (start == null || start==  0 ) {
            throw new IllegalArgumentException("Translated sequence begins at +1.");
        }
        
        if (translatedSequence == null) {
            this.translate();
        }

        if (translatedSequence != null) {
            if ( stop > translatedSequence.getLength()) {
                throw new RangeException("Specified end is beyond ends of translation.");
            }
            //the translated sequence object is a BioJava DNASequence object so we call its methods directly
            return  translatedSequence.getSequenceAsString(start,stop,org.biojava3.core.sequence.Strand.POSITIVE);
        } else {
            return "";
        }
    }
        
    /**
     * Returns the mapped position of a translation (nucleotide) position on the unprocessed
     * primary transcript that provides this translation.
     * @param translationBase a nucleotide position on the translated sequence 
     *  
     */
    public Integer getPrimaryTranscriptPositionFromBASE(Integer translationBase) {
        
        Integer result = null;
        if (translationMappings == null) {
            this.translate();
        }
                        
        if (translationMappings != null && !translationMappings.isEmpty()) {
            
            if (translationBase<1) {
                result = translationMappings.first().getTargetCoordinates().getStart()+translationBase;
                if (result<1 && translationMappings.first().getTargetCoordinates().getStart()>0 ) {
                    result--;
                }
                return result;
            }            
            if (translationBase > translationMappings.last().getSourceCoordinates().getEnd()) {
                result = translationMappings.last().getTargetCoordinates().getEnd()+
                        translationBase - translationMappings.last().getSourceCoordinates().getEnd();
                return result;
            }            
            
            for (Mapping m : translationMappings) {
                if (m.getSourceCoordinates().containsPoint(translationBase)) {
                    Integer offset = translationBase-m.getSourceCoordinates().getStart();
                    return m.getTargetCoordinates().getStart()+offset;
                }
            }           
        }
        return result;
    }
    
    /**
     * Returns the mapped position of a translation (nucleotide) position on the (spliced) processed
     * transcript that provides this translation. Querying for upstream or downstream positions 
     * is unreliable, and may return null if falling within an intron.
     * @param translationBase a nucleotide position on the translated sequence
     *  
     */
    public Integer getProcessedTranscriptPositionFromBASE(Integer translationBase) throws DAOException {
        
        Integer result = null;
        Integer primaryT = this.getPrimaryTranscriptPositionFromBASE(translationBase);
       
        if (primaryT != null && this.getTranscript()!=null) {
                result = this.getTranscript().convertPrimaryToProcessedTranscriptPosition(primaryT);
        }       
        
        return result;
    }
    
    /**
     * Returns the mapped chromosomal position of a translation (nucleotide) position.
     * @param translationBase a nucleotide position on the translated sequence
     * 
     * @throws DAOException 
     */
    public Integer getChromosomePositionFromBASE(Integer translationBase) throws DAOException {
        
        Integer result = null;
        Integer primaryT = this.getPrimaryTranscriptPositionFromBASE(translationBase);
       
        if (primaryT != null) {
                result = this.getTranscript().convertPrimaryTranscriptPositionToChromosome(primaryT);
        }       
        
        return result;
    }
    
    /**
     * Returns the mapped coordinates of an amino acid  position on the unprocessed
     * primary transcript that provides this translation. 
     * @param aminoAcidPosition
     *  
     * @throws RangeException if position does not lie within the peptide 
     */
    public Coordinate getPrimaryTranscriptPositionFromAA(Integer aminoAcidPosition) throws RangeException {
        
        if (aminoAcidPosition==null || aminoAcidPosition<1 || 3*aminoAcidPosition>this.getLength()) {
            throw new RangeException("An amino acid position must lie between 1 and the length of the peptide. ");
        }
        
        Strand strand = null;
        try {
            strand = this.getTranscript().getTopLevelTargetCoordinates().getStrand();
        } catch (Exception ex) {

        }
        
        Integer start = getPrimaryTranscriptPositionFromBASE(3*aminoAcidPosition-2);
        Integer end = getPrimaryTranscriptPositionFromBASE(3*aminoAcidPosition);
        if (end ==null || start ==null ) {
            return null;
        }
        return new Coordinate(start,end,strand);        
    }
    
    /**
     * Returns the mapped coordinates of an amino acid position on the (spliced) processed
     * transcript that provides this translation. Querying for upstream or downstream positions 
     * is unreliable, and may return null if falling within an intron.
     * @param aminoAcidPosition
     *  
     * @throws RangeException if position does not lie within the peptide 
     */
    public Coordinate getProcessedTranscriptPositionFromAA(Integer aminoAcidPosition) throws DAOException,RangeException {
        if (aminoAcidPosition==null || aminoAcidPosition<1 || aminoAcidPosition>3*this.getLength()) {
            throw new RangeException("An amino acid position must lie between 1 and the length of the peptide. ");
        }
        Strand strand = null;
        try {
            strand = this.getTranscript().getTopLevelTargetCoordinates().getStrand();
        } catch (Exception ex) {

        }     
        Integer start = getProcessedTranscriptPositionFromBASE(3*aminoAcidPosition-2);
        Integer end = getProcessedTranscriptPositionFromBASE(3*aminoAcidPosition);
        if (end ==null || start ==null ) {
            return null;
        }
        return new Coordinate(start,end,strand);     
    }
    
    /**
     * Returns the mapped chromosomal coordinates of an amino acid position.
     * @param aminoAcidPosition
     * 
     * @throws DAOException 
     * @throws RangeException if position does not lie within the peptide 
     */
    public Coordinate getChromosomePositionFromAA(Integer aminoAcidPosition) throws DAOException,RangeException {
        if (aminoAcidPosition==null || aminoAcidPosition<1 || 3*aminoAcidPosition>this.getLength()) {
            throw new RangeException("An amino acid position must lie between 1 and the length of the peptide. ");
        }
        Strand strand = null;
        try {
            strand = this.getTranscript().getTopLevelTargetCoordinates().getStrand();
        } catch (Exception ex) {

        }    
        Integer start = getChromosomePositionFromBASE(3*aminoAcidPosition-2);
        Integer end = getChromosomePositionFromBASE(3*aminoAcidPosition);
        if (end ==null || start ==null ) {
            return null;
        }
        return new Coordinate(start,end,strand);  
    }

    /**
     * Returns the nucleotide position on this translation sequence for a given 
     * Chromosomal Position
     * @param chromosomePosition
     *  
     */
    public Integer getBasePositionFromChromosome(Integer chromosomePosition) {
       
        DATranscript primTranscript = this.getTranscript();
        
        if (primTranscript == null) {
            return null;
        }
        
        if (this.translationMappings == null) {
            this.translate();
        }

        if (this.translatedSequence == null
                || this.translatedSequence.getLength() <1 || translationMappings==null) {
            return null;
        }
        
        Integer primTPos = primTranscript.convertChromosomeToPrimaryTranscriptPosition(chromosomePosition);
        
        if (primTPos<1 || primTPos>primTranscript.getLength()) {
            return null;
        }
        return getBasePositionFromPrimaryTranscript(primTPos);
    }
    
    /**
     * Returns the nucleotide position on this translation sequence for a given 
     * primary Transcript position
     * @param primaryTranscriptPosition
     *  
     */
    public Integer getBasePositionFromPrimaryTranscript(Integer primaryTranscriptPosition) {
        
        if (primaryTranscriptPosition==null || primaryTranscriptPosition==0) {
            throw new IllegalArgumentException("Zero is not a valid position.");
        }
               
        if (this.getTranscript() == null) {
            return null;
        }
        
        if (this.translationMappings == null) {
            this.translate();
        }

        if (this.translatedSequence == null
                || this.translatedSequence.getLength() <1 || translationMappings==null ) {
            return null;
        }
        
        for (Mapping m: translationMappings) {
            if (m.getTargetCoordinates().containsPoint(primaryTranscriptPosition)) {
                Integer offset = primaryTranscriptPosition-m.getTargetCoordinates().getStart();
                return m.getSourceCoordinates().getStart()+offset;
            }
        }
        
        return null;
    }
    
    /**
     * Returns the nucleotide position on this translation sequence for a given 
     * processed (spliced) transcript position.
     * @param processedTranscriptPosition
     *  
     */
    public Integer getBasePositionFromProcessedTranscript(Integer processedTranscriptPosition) {

        DATranscript primTranscript = this.getTranscript();
        
        if (primTranscript == null) {
            return null;
        }
        
        if (this.translationMappings == null) {
            this.translate();
        }

        if (this.translatedSequence == null
                || this.translatedSequence.getLength() <1 || translationMappings==null) {
            return null;
        }
        Integer primTPos  = null;
        
        try {
            primTPos = primTranscript.convertProcessedToPrimaryTranscriptPosition(processedTranscriptPosition);
        } catch (DAOException ex) {
            return null;
        }
        
        if (primTPos ==null || primTPos<1 || primTPos>primTranscript.getLength()) {
            return null;
        }
        
        return getBasePositionFromPrimaryTranscript(primTPos);
    }
    
    /**
     * Returns the amino acid position on this translation for a given
     * Chromosomal Position
     * @param chromosomePosition
     *  
     */
    public Integer getAAPositionFromChromosome(Integer chromosomePosition) {
        
        Integer transPosition = this.getBasePositionFromChromosome(chromosomePosition);
        
        if (transPosition==null || transPosition <1 || transPosition> this.getLength()) {
            return null;
        }
        
        Integer two = 2;
        Integer three = 3;
        return (transPosition+two)/three;
    }
    
    /**
     * Returns the amino acid position on this translation for a given
     * Primary Transcript Position
     * @param primaryTranscriptPosition
     *  
     */    
    public Integer getAAPositionFromPrimaryTranscript(Integer primaryTranscriptPosition) {
        Integer transPosition = this.getBasePositionFromPrimaryTranscript(primaryTranscriptPosition);
        
        if (transPosition==null || transPosition <1 || transPosition> this.getLength()) {
            return null;
        }
        
        Integer two = 2;
        Integer three = 3;
        return (transPosition+two)/three;
    }
    
    /**
     * Returns the amino acid position on this translation for a given
     * Processed Transcript Position
     * @param processedTranscriptPosition
     *  
     */     
    public Integer getAAPositionFromProcessedTranscript(Integer processedTranscriptPosition) {
        Integer transPosition = this.getBasePositionFromProcessedTranscript(processedTranscriptPosition);
        
        if (transPosition==null || transPosition <1 || transPosition> this.getLength()) {
            return null;
        }
        
        Integer two = 2;
        Integer three = 3;
        return (transPosition+two)/three;
    }
    
    
    /**
     * Private method that stitches together the ORF coordinates into a map of 
     * Translation/ORF Coordinate to (unprocessed) primaryTranscript Coordinate, and initializes 
     * a DNASequence object representing this translated sequence. 
     */
    private void translate() {
        
        //note it was easier to stitch together the processedTranscript-->translation map
        //however this 'lacks' any notion of the introns - so is no good for mapping
        //back from translation to primaryTranscript

        translationMappings = new MappingSet();
        boolean intranslated = false;
        String seq = "";
        
        //If something is wrong and the DNASequence for the Exons cannot be retrieved
        //the seq is set to GapSequences of lengths based on the exon lengths.        
        
        if (this.getTranscript() == null) {
            return;
        }
        Collection<DAExon> exons = this.getTranscript().getExons();
        if (exons == null || exons.isEmpty()) {
            return;
        }
        
        Coordinate topLevelTargetCoordinates = null;
        try {
            topLevelTargetCoordinates = this.getTranscript().getTopLevelTargetCoordinates();
        } catch (DAOException ex) {
            translatedSequence = new DNASequence(seq);
            return;
        }
        
        if (topLevelTargetCoordinates==null || topLevelTargetCoordinates.getEnd()==null
                || topLevelTargetCoordinates.getStart()==null) {
            translatedSequence = new DNASequence(seq);
            return;
        }
        
        Strand strand = topLevelTargetCoordinates.getStrand();

        Integer chromosomalStart;
        if (Strand.REVERSE_STRAND.equals(strand)) {
            chromosomalStart = topLevelTargetCoordinates.getEnd(); 
        } else {
            chromosomalStart = topLevelTargetCoordinates.getStart();
        }
        
        Integer transcriptPosition=0;
        
        for (DAExon ex : exons) {
            
            if (Strand.REVERSE_STRAND.equals(strand)) {
                transcriptPosition = chromosomalStart - ex.convertToTargetPosition(1) + 1;
            } else {
                transcriptPosition = ex.convertToTargetPosition(1) - chromosomalStart + 1;
            }
            
            
            if (!intranslated && ex.getId().equals(this.getFirstExonID())) {

                Coordinate transcript ;
                Coordinate translation ;
                
                
                intranslated = true;

                //case of a single exon translation
                if (ex.getId().equals(this.getLastExonID())) {
                    try {                       
//                        if (Strand.REVERSE_STRAND.equals(strand)) {
//                            seq = ex.getSequence().getReverseComplementSequenceAsString( ex.getLength() - this.getLastExonEnd() + 1, ex.getLength()-this.getFirstExonStart() + 1);
//                        } else {
//                            seq = ex.getSequence().getSequenceAsString(this.getFirstExonStart(), this.getLastExonEnd());
//                        }
                        seq = ex.getSequenceAsString(this.getFirstExonStart(), this.getLastExonEnd());
                    } catch (Exception e) {
                        seq = GapSequence.getGapString( this.getLastExonEnd()-  this.getFirstExonStart()+1);
                    }
                    Mapping m = new Mapping();
                    m.setTarget(this.getTranscript());
                    
                    //case where we are missing one or two 5'bases for the correct phase
                    if (ex.getPhase() == 1) {
                        seq = "N" + seq;
                        translation = new Coordinate(1+ex.getPhase(), seq.length()+ex.getPhase());
                    } else if (ex.getPhase() == 2) {
                        seq = "NN" + seq;
                        translation = new Coordinate(1+ex.getPhase(), seq.length()+ex.getPhase());
                    } else {
                        translation = new Coordinate(1, seq.length());
                    }
                    transcript = new Coordinate(transcriptPosition+this.getFirstExonStart()-1,transcriptPosition+this.getLastExonEnd()-1); 
                    m.setSourceCoordinates(translation);
                    m.setTargetCoordinates(transcript);
                    translationMappings.add(m);                    
                    
                    break;
                }
                try {                   
//                      if (Strand.REVERSE_STRAND.equals(strand)) {
//                          
//                          System.out.println("ex.getSequenceAsString(1,30): "+ex.getSequenceAsString(1,30));
//                          System.out.println("ex.getSequence().getSequenceAsString(1,30): "+ex.getSequence().getSequenceAsString(1,30));
//                          System.out.println("ex.getSequence().getReverseComplementSequenceAsString(1,30): "+ex.getSequence().getReverseComplementSequenceAsString(1,30));
//                          
//                            seq = ex.getSequence().getReverseComplementSequenceAsString(1, ex.getLength() - this.getFirstExonStart() + 1);
//                        } else {
//                            seq = ex.getSequence().getSequenceAsString(this.getFirstExonStart(), ex.getSequence().getLength());
//                        }
                          seq = ex.getSequenceAsString(this.getFirstExonStart(), ex.getLength());
                } catch (Exception e) {
                    seq = GapSequence.getGapString( ex.getLength() -  this.getFirstExonStart()+1);
                }   
                Mapping m = new Mapping();
                m.setTarget(this.getTranscript());
                
                //case where we are missing one or two 5'bases for the correct phase
                if (ex.getPhase() == 1) {
                    seq = "N" + seq;
                    //correct the mapping coordinate...by adding the shift
                    translation = new Coordinate(1+ex.getPhase(),seq.length()+ex.getPhase());
                } else if (ex.getPhase() == 2) {
                    seq = "NN" + seq;
                    translation = new Coordinate(1+ex.getPhase(),seq.length()+ex.getPhase());
                } else {
                    translation = new Coordinate(1,seq.length());
                }

                transcript = new Coordinate(transcriptPosition+this.getFirstExonStart()-1,transcriptPosition+ex.getLength()-1); 
                //transcriptPosition =transcriptPosition+ ex.getLength()-1;
                m.setSourceCoordinates(translation);
                m.setTargetCoordinates(transcript);
                translationMappings.add(m);
                
                continue;
            } 
//            else if (!intranslated && !ex.getId().equals(this.getFirstExonID())) {
//                
//                
//                continue;
//            }
            
            else if (intranslated && !ex.getId().equals(this.getLastExonID())) {
                Integer start = seq.length()+1;
                try {
//                       if (Strand.REVERSE_STRAND.equals(strand)) {
//                            seq = seq.concat(ex.getSequence().getReverseComplementSequenceAsString());
//                        } else {
//                            seq = seq.concat(ex.getSequence().getSequenceAsString());
//                        }
                    seq = seq.concat(ex.getSequenceAsString());
                } catch (Exception e) {
                    seq = seq.concat(GapSequence.getGapString( ex.getLength()));
                }   
                Mapping m = new Mapping();
                m.setTarget(this.getTranscript());
             
                Coordinate translation = new Coordinate(start,seq.length());
                Coordinate transcript = new Coordinate(transcriptPosition,transcriptPosition+ex.getLength()-1); 
                m.setSourceCoordinates(translation);
                m.setTargetCoordinates(transcript);
                //transcriptPosition=transcriptPosition+ex.getLength()-1;
                translationMappings.add(m);
                continue;
            }
            else if (intranslated && ex.getId().equals(this.getLastExonID())) {
                Integer start = seq.length()+1;
                try {
//                     if (Strand.REVERSE_STRAND.equals(strand)) {
//                            seq = seq.concat(ex.getSequence().getReverseComplementSequenceAsString(ex.getLength()- this.getLastExonEnd() +1 , ex.getLength()));
//                        } else {
//                            seq = seq.concat(ex.getSequence().getSequenceAsString(1,this.getLastExonEnd()));
//                     }
                    seq = seq.concat(ex.getSequenceAsString(1,this.getLastExonEnd()));
                } catch (Exception e) {
                    seq = seq.concat(GapSequence.getGapString( this.getLastExonEnd()));
                }   
                Mapping m = new Mapping();
                m.setTarget(this.getTranscript());
              
                Coordinate translation = new Coordinate(start,seq.length());
                Coordinate transcript = new Coordinate(transcriptPosition,transcriptPosition+this.getLastExonEnd()-1); 
                m.setSourceCoordinates(translation);
                m.setTargetCoordinates(transcript);
                translationMappings.add(m);          
                break;
            }
            else {
                //this must be a 5'UTR
                //transcriptPosition += ex.getLength()-1;
            }
        } 
        translatedSequence = new DNASequence(seq);
    }

    /**
     * Returns the length of the translated nucleotide sequence, i.e. from first 
     * nucleotide of the start codon to end of the stop codon. 
     *  
     */
    public int getLength() {
        if (translatedSequence==null) {
            this.translate();
        }
        if (translatedSequence!= null) {
            return translatedSequence.getLength();
        }
        return 0;
    }
    
    /**
     * Returns a DNASequence object representing the translation.
     *  
     */
    public DNASequence getTranslatedSequence() {
        if (this.translationMappings==null) {
            this.translate();
        } 
        return translatedSequence;
    }
    
    /**
     * Returns the Set of Mappings between coordinates on this Translation and 
     * the Primary transcript.
     *  
     */
    public MappingSet getTranslationMappings() {
        if (this.translationMappings==null) {
            this.translate();
        } 
        return this.translationMappings;
    }

    /**
     * Returns a (BioJava) RNASequence for this Translation using the default (BioJava) 
     * TranscriptionEngine or one assigned to this Gene/Organism.
     *  
     */
    public RNASequence getRNASequence() {
        
        Integer codonTable = 1;

        if (this.getTranscript() != null) {

            try {
               codonTable = this.getTranscript().getTargetSequence().getCodonTableID();
            } catch (Exception ex) {
            }
        }
        if (this.getRegistry()!=null) {
            return this.getRNASequence(this.getRegistry().getTranscriptionEngine(codonTable));
        }
        //if no Registry we just use BioJava's fallback default engine
        return this.getRNASequence(null);
    }
    
    /**
     * Returns a (BioJava) RNASequence for this Translation using the specified (BioJava) 
     * TranscriptionEngine or one assigned to this Gene/Organism.
     *  
     */
    public RNASequence getRNASequence(TranscriptionEngine engine) {
        if (this.translatedSequence == null) {
            this.translate();
        }
        if (this.translatedSequence == null) {
            return null;
        }
        if (engine!=null) {
            return this.translatedSequence.getRNASequence(engine);
        }
        //Fallback on BioJava's default
        return this.translatedSequence.getRNASequence();
    }
    
    public String getRNASequenceAsString() {
        RNASequence rnaSequence = this.getRNASequence();
        if (rnaSequence!=null) {
            return rnaSequence.getSequenceAsString();
        } return "";
    }
    
    public String getRNASequenceAsString(TranscriptionEngine engine) {
        RNASequence rnaSequence = this.getRNASequence(engine);
        if (rnaSequence!=null) {
            return rnaSequence.getSequenceAsString();
        } return "";
    }
    
    public String getRNASequenceAsString(Integer start, Integer stop) {
        if (start==null || start<1 || stop==null || stop<1 || stop>this.getLength()) {
            throw new RangeException("The specified position must lie between 1 and the length of the translation. ");
        }
        RNASequence rnaSequence = this.getRNASequence();
        if (rnaSequence!=null) {
            return rnaSequence.getSequenceAsString(start,stop,org.biojava3.core.sequence.Strand.POSITIVE);
        } return "";       

    }
    
    public String getRNASequenceAsString(TranscriptionEngine engine, Integer start, Integer stop) {
        if (start==null || start<1 || stop==null || stop<1 || stop>this.getLength()) {
            throw new RangeException("The specified position must lie between 1 and the length of the translation. ");
        }        
        RNASequence rnaSequence = this.getRNASequence(engine);
        if (rnaSequence!=null) {
            return rnaSequence.getSequenceAsString(start,stop,org.biojava3.core.sequence.Strand.POSITIVE);
        } return "";
    }
    
    /**
     * Returns any curated VegaID for the Translation, forcing lazy load if not set, and defaulting 
     * to an empty string if absent (e.g. for all the invertebrate species in EnsemblGenomes).
     *  
     */
    @Override
    public String getVegaID() {       
        if (this.vegaProteinID!=null) {
            return this.vegaProteinID;
        }
        List<DAXRef> outList = new ArrayList<DAXRef>();
        
        if (this.getDaoFactory()!= null 
                && !this.getDaoFactory().getRegistry().getDatasourceType().equals(DBConnection.DataSource.ENSEMBLDB)) {
            this.vegaProteinID="";
            this.addTypedXRefs(ExternalDBType.VegaProtein, outList);
            return this.vegaProteinID;
        }
                      
        //??
        this.reinitialize();
               
        if (this.vegaProteinID==null ) {
            
            if (this.getDaoFactory()!= null ) {

                  for (DAXRef dax : this.getAllXRefs()) {
                        if (dax.getPrimaryAccession()!=null
                                && dax.getPrimaryAccession().startsWith("OTT")
                                && dax.getDB()!= null  
                                && (dax.getDB().getDBName().equals(ExternalDBType.VegaProtein.toString())
                                    ||
                                    dax.getDB().getDBName().contains("Vega_translation") 
                                    ||
                                    dax.getDB().getDBName().contains("vega_translation") )
                                ) {
                            outList.add(dax);
                            }
                  }
                
                if (outList.isEmpty()) {
                    this.vegaProteinID = "";
                    this.addTypedXRefs(ExternalDBType.VegaProtein, outList);                    
                    return this.vegaProteinID;
                } else {
                    //add the factory to the xref - although we shouldn't need to use it as it is fully initialized
                    for (DAXRef xr: outList) {
                        xr.setDaoFactory(this.getDaoFactory());
                    }
                    this.addTypedXRefs(ExternalDBType.VegaProtein, outList);
                }
                
                 if (outList.size()==1) {
                    this.vegaProteinID = outList.get(0).getPrimaryAccession().trim();
                    return this.vegaProteinID;
                } else {
                    //hopefully all the IDs will be the same - but can't guarantee this!
                    String pre = "Multiple Vega IDs: {";
                    boolean multiple = false;
                    String out = null;
                    String firstID = "";
                    
                    for (XRef x: outList) {
                        if (out==null) {
                            out = x.getPrimaryAccession().trim();
                            firstID = x.getPrimaryAccession().trim(); 
                        } else if (!firstID.equals(x.getPrimaryAccession().trim())) {                        
                            out = out.concat(", ").concat(x.getPrimaryAccession().trim());
                            multiple  = true;
                        }
                    }
                    if (!multiple) {
                        vegaProteinID=out;
                    } else {
                        out = out.trim().concat("}");
                        vegaProteinID = pre.concat(out);
                    }
                    return this.vegaProteinID;
                }
            }
        }
        return this.vegaProteinID;
    }

    @Override
    public Set<DAXRef> getVegaXRefs() {
        this.getVegaID();
        return this.getXRefs(ExternalDBType.VegaProtein);
    }  
    
    /**
     * Returns preloaded XRefs of given type: Note - does not lazy load these.
     * @param type
     *  
     */    
    protected Set<DAXRef> getXRefs(ExternalDBType type) {
        return typedXRefs.get(type);
    }
    
    @Override
    public Set<DAXRef> getAllXRefs() {
        if (this.xrefsInitialized) {
            return xrefs;
        }

        this.reinitialize();

        if (this.getDaoFactory() != null && this.getId() != null) {
            List<DAXRef> result = null;
            try {
                result = (List<DAXRef>) this.getDaoFactory().getXRefDAO().getAllXRefs(this);

            } catch (DAOException ex) {
                LOGGER.info("Threw DAOException on trying to get Vega ID for Translation: " + this.getStableID(), ex);
            } finally {
                this.xrefsInitialized = true;
            }

            if (result == null || result.isEmpty()) {
                return xrefs;
            } else {
                
                for (DAXRef xr : result) {
                    //add the factory to the xref - although we shouldn't need to use it as it is fully initialized
                    xr.setDaoFactory(this.getDaoFactory());
                    /* shouldn't be necessary now */  
                    //check that we are not creating duplicate External DBs...
//                    ExternalDB db = xr.getDB();
//                    int originalHashCode = db.originalHashCode();
//                    db  = this.getDaoFactory().getDatabase().validateExternalDB(db);
//                    int checkedHashCode = db.originalHashCode();
//                    if (originalHashCode-checkedHashCode !=0) {
//                        System.out.println("*** FAILED TO REUSE EXTERNALDB");
//                    } else {
//                        System.out.println("*** successfully reused externaldb");
//                    }
//                    xr.setDB(db);
                    xrefs.add(xr);
                    }
                }
        }
        return xrefs;
    }

    protected void addTypedXRefs(ExternalDBType type, Collection<? extends XRef> xrefs) {
        if ( this.typedXRefs.get(type)==null) {
            this.typedXRefs.put(type, new HashSet<DAXRef>());
        }
        this.typedXRefs.get(type).addAll((Collection<DAXRef>)xrefs);
    }

    public Integer getTranscriptID() {
        return transcriptID;
    }

    public void setTranscriptID(Integer transcriptID) {
        this.transcriptID = transcriptID;
    }

    public void setVegaProteinID(String vegaProteinID) {
        this.vegaProteinID = vegaProteinID;
    }    
    
    @Override
    public Integer getId() {
        if (id==null || id == 0) {
            this.reinitialize();
        }
        return id;
    }
    
    @Override
    public Integer getVersion() {
        if (version==null) {
            this.reinitialize();
        }
        return version;
    }
    
    @Override
    public Date getModificationDate() {
        if (modificationDate==null) {
            this.reinitialize();
        }
        return modificationDate;
    }
    
    @Override
    public Date getCreationDate() {
        if (creationDate==null) {
            this.reinitialize();
        }
        return creationDate;
    }

    @Override
    public TreeSet<String> getAllSynonyms() {
        if (synonyms!=null) {
            return synonyms;
        }
        this.reinitialize();
        try {
            synonyms = this.getDaoFactory().getXRefDAO().getAllSynonyms(this);
        } catch (DAOException ex) {
            LOGGER.debug("Failed to getAllSynonyms for DAFeature", ex);
        }
        if (synonyms==null) {
            synonyms = new TreeSet<String>();
        }
        return synonyms;
    }

    @Override
    public TreeSet<String> getSynonyms(XRef xref) {
        return xref.getSynonyms();
    }

}