/**
 * 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.RNASequence;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import uk.ac.roslin.ensembl.config.DBConnection;
import uk.ac.roslin.ensembl.config.ExternalDBType;
import uk.ac.roslin.ensembl.config.FeatureType;
import uk.ac.roslin.ensembl.dao.factory.DAOCoreFactory;
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.Exon;
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 DATranscript extends DAAnalyzedFeature implements Transcript, VegaFeature, XRefed {

    Integer canonicalTranslationID = null;
    DATranslation canonicalTranslation = null;
    private TreeMap<Integer, DATranslation> translationHash = null;
    private String biotype = null;
    private DAGene gene = null;
    private boolean canonical = false;
    private Integer geneID = null;
    private TreeMap<Integer, DAExon> exonHash = null;
    MappingSet primaryTranscriptExonMappings = null;
    MappingSet processedTranscriptExonMappings = null;
    Integer processedTranscriptLength = null;
    private DADNASequence processedTranscript = null;
    final static Logger LOGGER = LoggerFactory.getLogger(DATranscript.class);

    private TreeSet<String> synonyms = null;
    protected  Set<DAXRef> xrefs = new HashSet<DAXRef>();
    protected HashMap<ExternalDBType, Set<DAXRef>> typedXRefs = new HashMap<ExternalDBType, Set<DAXRef>>();
    boolean xrefsInitialized = false;        
    private String vegaTranscriptID = null;
    private String ccdsID =null;

    public DATranscript() {
        super();
    }

    /**
     * 
     * @param daoFactory 
     */
    public DATranscript(DAOCoreFactory daoFactory) {
        super(daoFactory);
    }

    @Override
    public ObjectType getType() {
        return FeatureType.transcript;
    }

    /**
     * Returns all of the Translation objects associated with this Transcript 
     * (typically there will only be one, the canonical translation, there may 
     * also be no translation for a transcript). If
     * the 'translationHash' object has not yet been instantiated, a lazy load 
     * by the TranslationDAO object returned by the DAOFactory is triggered.
     * @return Collection of Translation objects.
     * 
     */
    @Override
    public Collection<? extends Translation> getTranslations() {

        List<? extends Translation> out = null;       
        if (this.translationHash != null) {
            return this.translationHash.values();
        }
        this.reinitialize(); // we need an ID for this method
        //this clears any existing translations
        this.translationHash = new TreeMap<Integer, DATranslation>();
        
        try {
             out = this.getDaoFactory().getTranslationDAO().getTranslationsForTranscript(this);

        } catch (Exception e) {
            LOGGER.info("failed to get Translations", e);
        }

        return out;
    }

    /**
     * Returns the canonical Translation for this Transcript (if there is one).
     * If not set, a lazy load using 'getTranslations()' is triggered. 
     */
    @Override
    public DATranslation getCanonicalTranslation() {

        if (canonicalTranslation != null) {
            return this.canonicalTranslation;
        } else {
            
            if (this.getDaoFactory()==null || this.getStableID()==null || this.getStableID().isEmpty()) {
                return null;
            }
            this.reinitialize(); // need canonicalTranslationID 
            //prior to version 57 there was no concept of a canonicalTranslation storedin the transcript table
            if (this.getSchemaVersion()!=null && Integer.parseInt(this.getSchemaVersion())>56 
                    &&   (this.canonicalTranslationID == null || this.canonicalTranslationID.equals(0)) ) {
                return null;
            }

            //get all of the transcripts not just the canonical one!
            this.getTranslations();
            return this.canonicalTranslation;
        }
    }

    /**
     * Utility method to reset or initialize the important fields of this Transcript 
     * (which must have a 'stableID' set).
     * @throws DAOException 
     */
    @Override
    void reinitialize()  { 
        if (!this.isLazyloadAllowed() || this.isInitialized()) {
            return;
        }
        try {
            //nb getDaoFActory() will try and make a factory if we have at least species and ensembl version
            this.getDaoFactory().getTranscriptDAO().reInitialize(this);
        } catch (Exception ex) {
            LOGGER.info("Failed to reinitialize the Transcript from the Database (using its stableID: "
                    +this.stableID+").", ex);
        } finally {
            //always set this so dont try again
            this.setInitialized(true);
        }
    }

    public String getBiotype() {
        this.reinitialize();
        return this.biotype;
    }

    public void setBiotype(String biotype) {
        this.biotype = biotype;
    }

    /**
     * Gets the Gene associated with this transcript, using the stableID for the 
     * gene set on Transcript initialization.
     */
    @Override
    public DAGene getGene() {
        this.reinitialize(); // need the geneID
        if (gene == null && geneID != null) {
            try {
                gene = (DAGene) this.getDaoFactory().getGeneDAO().getGeneByID(this.geneID);
            } catch (Exception e) {
                LOGGER.info("Error thrown whilst trying to retrieve Gene for a Transcript", e);
            }
        }

        return gene;
    }

    public void setGene(DAGene gene) {
        this.gene = gene;
    }

    public Integer getGeneID() {
        this.reinitialize();
        return geneID;
    }

    public void setGeneID(Integer geneID) {
        this.geneID = geneID;
    }

    /**
     * Returns true if this Transcript has been annotated by Ensembl as 'Canonical', 
     * according to the following rules:
     * A 'Canonical' Transcript is the longest CCDS model in a gene.
     * If none is available then the longest coding Ensembl-Havana merged transcript 
     * is chosen. If no merged  transcript is present, the longest coding transcript
     * is used, regardless of their source; this can be either an Ensembl or a 
     * Havana transcript. Finally, if there are no coding transcripts in the gene, 
     * the longest non-coding transcript is selected.
     */
    public boolean isCanonical() {
        this.reinitialize();
        return canonical;
    }

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

    @Override
    public String getDisplayName() {
        this.reinitialize();        
        return (displayName != null) ? displayName : stableID;
    }

    /**
     * Returns a Collection of Exons for this Transcript. These are returned in 
     * (Ranked) order from the exonHash of this Transcript, which will be initialized 
     * by lazy loading. The ordered exons are used to make the 'processedTranscript' 
     * object for this Transcript (the full length transcript being considered
     * the 'pimaryTranscript'
     */
    @Override
    public Collection<DAExon> getExons() {
        this.reinitialize(); //needs transcript id
        if (exonHash == null) {
            exonHash = new TreeMap<Integer, DAExon>();
            try {
                Collection<DAExon> out =  (Collection<DAExon>) this.getDaoFactory().getExonDAO().getExonsForTranscript(this);
                // don't use this - use the values ordered in the exonHash
                //return out;
            } catch (Exception e) {
                LOGGER.info("Threw DAOException on trying to populate exons for a transcript", e);
            }

        }
        return this.exonHash.values();
    }

    /**
     * Method used by the ExonDAO to add an Exon to the 'exonHash', hashed on the 
     * 'Rank' integer held by the Exon.
     * @param exon 
     */
    public void addExon(Exon exon) {
        if (exonHash == null) {
            exonHash = new TreeMap<Integer, DAExon>();
        }
        try {
            DAExon e = (DAExon) exon;
            this.exonHash.put(e.getRank(), e);
        } catch (Exception ex) {
            LOGGER.info("failed to add an exon to the transcript ", ex);
        }
    }

    /**
     * Returns the internal database ID for the Translation object marked as 'Canonical'.
     * (Prior to Ensembl57 there was a single translation object for each transcript, 
     * considered as canonical.)
     */
    public Integer getCanonicalTranslationID() {
        reinitialize();
        return canonicalTranslationID;
    }

    public void setCanonicalTranslationID(Integer canonicalTranslationID) {
        this.canonicalTranslationID = canonicalTranslationID;
    }

    /**
     * Package method to add a Translation to the 'translationHash', 
     * hashed on the internal database ID of the Translation, and to set the 
     * canonicalTranlation/ID where applicable.
     * @param trl 
     */
    protected void addTranslation(DATranslation trl) {
        if (trl != null && trl.getId() != null) {
            
            if (this.translationHash==null) {
                this.translationHash = new TreeMap<Integer, DATranslation>();
            }
            
            trl.setTranscript(this);
            this.translationHash.put(trl.getId(), trl);
            
            if(this.getSchemaVersion()!= null && Integer.parseInt(this.getSchemaVersion())<57 ){
                trl.setCanonical(true);
                this.canonicalTranslation = trl;
                this.canonicalTranslationID = trl.getId();
            } else if (trl.getId().equals(this.getCanonicalTranslationID())) {
                trl.setCanonical(true);
                this.canonicalTranslation = trl;
            }
        }
    }

    /**
     * Method used by the TranslationDAO to add Translations to the 'translationHash', 
     * hashed on the internal database ID of the Translation. 
     * @param trls Collection&lt;DATranslation&gt;
     */
    public void addTranslations(Collection<DATranslation> trls) {

        if (trls != null) {
            for (DATranslation trl : trls) {
                this.addTranslation(trl);
            }
        }
    }

    /**
     * Returns whether this Transcript has (at least one, canonical) Translation.
     */
    @Override
    public boolean isTranslated() {
        
         if (this.getDaoFactory()==null) {
                return false;
         }
                 
         if  (this.getStableID()==null || this.getStableID().isEmpty()) {
                return false;
         }
        this.reinitialize();
        //prior to version 57 there was no concept of a canonicalTranslation storedin the transcript table
        if (this.getSchemaVersion()!=null && Integer.parseInt(this.getSchemaVersion())>56 ) {
           return (this.canonicalTranslationID != null && !this.canonicalTranslationID.equals(0)) ;
        } else {
            return (this.getTranslations()!= null && !this.getTranslations().isEmpty());
        }
    }
    
    /**
     * Private method to initialize both MappingSets 'primaryTranscriptExonMappings'
     * and 'processedTranscriptExonMappings' which hold the (ordered) Mappings of 
     * Coordinates on the primary or processed Transcript against the Exons. 
     * @throws DAOException 
     */
    private void stitchExons() throws DAOException {

        super.inititializeTopLevel();
        
        primaryTranscriptExonMappings = new MappingSet();
        processedTranscriptExonMappings = new MappingSet();
        
        boolean intranslated = false;
        String seq = "";

        Collection<DAExon> exons = this.getExons();
        if (exons == null || exons.isEmpty() || this.topLevelTargetCoordinates==null ||
                this.topLevelTargetCoordinates.getStart()==null ||
                this.topLevelTargetCoordinates.getEnd()==null) {
            return;
        }
        
        //@TODO makesafe
        //@TODO make get from best top level mapping
        Integer transcriptChrStart = this.topLevelTargetCoordinates.getStart();
        Integer transcriptChrEnd = this.topLevelTargetCoordinates.getEnd();
        Strand strand = this.topLevelTargetCoordinates.getStrand();
        
        int length = 0;
        int primaryPosition = 1;
        int processedPosition = 1;
        
        for (DAExon ex : exons) {
            Coordinate exonCoord = ex.getTopLevelMappings().first().getTargetCoordinates();
            Coordinate primaryTranscriptCoord = null;
            Coordinate processedTranscriptCoord = null;
            if (Strand.REVERSE_STRAND.equals(strand)) {
                primaryPosition = transcriptChrEnd - exonCoord.getEnd() +1;
                primaryTranscriptCoord = new Coordinate(primaryPosition, primaryPosition+exonCoord.getLength()-1, strand);     
                processedTranscriptCoord = new Coordinate(processedPosition , processedPosition+exonCoord.getLength()-1 , strand);
                processedPosition += exonCoord.getLength();            
            } else {
                primaryPosition = exonCoord.getStart() - transcriptChrStart + 1;
                primaryTranscriptCoord = new Coordinate(primaryPosition, primaryPosition+exonCoord.getLength()-1, strand);
                processedTranscriptCoord = new Coordinate(processedPosition, processedPosition+exonCoord.getLength()-1, strand);  
                processedPosition += exonCoord.getLength();
            }
           
            
            Mapping primaryTMappings = new Mapping();
            primaryTMappings.setSource(this);
            primaryTMappings.setTarget(ex);
            primaryTMappings.setSourceCoordinates(primaryTranscriptCoord);
            //this is actually the coordinates on the chromosome not the coordinates of the exon ;)
            //primaryTMappings.setTargetCoordinates(exonCoord);
            primaryTranscriptExonMappings.add(primaryTMappings);  
            
            Mapping processedTMappings = new Mapping();
            processedTMappings.setSource(this);
            processedTMappings.setTarget(ex);
            processedTMappings.setSourceCoordinates(processedTranscriptCoord);
            //processedTMappings.setTargetCoordinates(exonCoord);
            processedTranscriptExonMappings.add(processedTMappings);  
            
            
            length += exonCoord.getLength();
        }
       
        this.processedTranscriptLength = length;
    }

    /**
     * Returns the mapped relative primaryTranscript position for a given Chromosome 
     * (or other Toplevel genomic) position. Wraps the DAFeature 'convertChromosomePositionToFeature'
     * method.  The TopLevel Target should only have  a 
     * positive coordinate system. If the TopLevel Target coordinates are found to extend below 1, 
     * a range exception is thrown rather than try to handle this.
     * @param chromosomePosition
     */
    public Integer convertChromosomeToPrimaryTranscriptPosition(Integer chromosomePosition) {
        return super.convertChromosomePositionToFeature(chromosomePosition);
    }
    
    /**
     * Returns the mapped Chromosomal position for a given 
     * primaryTranscript position. Wraps the DAFeature 'convertToTargetPosition'
     * method.  Whilst the TopLevel Target should only have  a 
     * positive coordinate system (and if not a RangeException will be thrown here), 
     * the query Integer is allowed to be outwith the bounds of the Feature,
     * and may possibly return a value outwith the bounds of the Chromosome.
     * @param primaryTranscriptPosition
     */
    public Integer convertPrimaryTranscriptPositionToChromosome(Integer primaryTranscriptPosition) {
        return super.convertToTargetPosition(primaryTranscriptPosition);
    }
    
     /**
     * Converts an Integer position on the processed (spliced) transcript  
     * to the position on the TopLevel-annotated Target (typically the Chromosome). 
     * The TopLevel Target should only have  a 
     * positive coordinate system. However negative values will be returned here 
     * if appropriate.
     * @param processedTranscriptPosition Integer
     * @return Integer
     */  
    public Integer convertProcessedTranscriptPositionToChromosome(Integer processedTranscriptPosition) throws DAOException {
        
        if (processedTranscriptPosition==null || processedTranscriptPosition == 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.");
        } 
        
        Integer result = null;
        
        super.inititializeTopLevel();
        
        if (this.topLevelTargetCoordinates==null ||
                this.topLevelTargetCoordinates.getStart()==null ||
                this.topLevelTargetCoordinates.getEnd()==null) {
            return null;
        }
        
        
        Coordinate primaryTranscCoords = this.topLevelTargetCoordinates;
        
   
  
                
        if (processedTranscriptPosition<0) {
            if (Strand.REVERSE_STRAND.equals(primaryTranscCoords.getStrand())) {
                result = primaryTranscCoords.getEnd()-processedTranscriptPosition;
                //if move from negative to positive
                if (primaryTranscCoords.getEnd()<0 && result>0) {
                    result++;
                }                
            } else {
                result = primaryTranscCoords.getStart()+processedTranscriptPosition;             
                //if move from positive to negative
                if (primaryTranscCoords.getStart()>0 && result<1) {
                    result--;
                }
            }
            return result;
        }

        if ( processedTranscriptExonMappings==null ) {
            this.stitchExons();
        }  
        
        if (processedTranscriptExonMappings==null || processedTranscriptExonMappings.isEmpty()) {
            return null;
        }
        
        if ( processedTranscriptPosition>this.getProcessedTranscriptLength()) {
            
            if (Strand.REVERSE_STRAND.equals(primaryTranscCoords.getStrand())) {
                result = primaryTranscCoords.getStart() - (+processedTranscriptPosition-this.getProcessedTranscriptLength());
                if (primaryTranscCoords.getStart()>0 && result<1) {
                    result--;
                }
                
            } else {            
                result = primaryTranscCoords.getEnd()+processedTranscriptPosition-this.getProcessedTranscriptLength();
                if(primaryTranscCoords.getEnd()<1 && result>0) {
                    result++;
                }
            }
            return result;
        }
        
        
        for (Mapping m: this.processedTranscriptExonMappings) {
            DAExon ex = (DAExon) m.getTarget();
            Coordinate sourceCoordinates = m.getSourceCoordinates();
            if (sourceCoordinates.containsPoint(processedTranscriptPosition)) {
                Coordinate exonCoordinates = ex.getTopLevelMappings().first().getTargetCoordinates();
                
                if (Strand.REVERSE_STRAND.equals(exonCoordinates.getStrand())) {
                    result =  exonCoordinates.getEnd() - (processedTranscriptPosition- sourceCoordinates.getStart() );
                    //if move from positive to negative
                    if (exonCoordinates.getEnd()>0 && result<1) {
                        result--;
                    }
                    
                } else {
                    result = exonCoordinates.getStart() + (processedTranscriptPosition -sourceCoordinates.getStart() );
                    //if move from negative to positive
                    if ( exonCoordinates.getStart()<0 && result>0) {
                        result++;
                    }
                    
                    break;
                }               
            }
        }
        return result;
    }
    
    /**
     * Converts an Integer position on the TopLevel-annotated Target (typically the Chromosome) 
     * to the position on the processed (spliced) Transcript. The TopLevel Target should only have  a 
     * positive coordinate system. If the TopLevel Target position is less than 1, 
     * a range exception is thrown rather than try to handle this.
     * Although the  chromosomePosition parameter may not be  less than 1, the method does cope with 
     * negative coordinate transcript/exon  mappings on the chromosome.
     * @param chromosomePosition Integer
     * @return Integer
     */      
    public Integer convertChromosomeToProcessedTranscriptPosition(Integer chromosomePosition) throws DAOException {
        
        if (chromosomePosition==null|| chromosomePosition==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 (chromosomePosition<0) {
            throw new RangeException("A chromosome has no coordinates lower than 0.");            
        }

        Integer result = null;            
        Integer processedLength = null;
        
        //calling 'getProcessedTranscriptLength()' forces intialization of the top level mappings and 
        //top level mappings and the stitching together of exons
        processedLength = this.getProcessedTranscriptLength();

        
        if (processedLength==null 
            || processedLength==0 
            || this.topLevelTargetCoordinates==null 
            || this.topLevelTargetCoordinates.getStart()==null 
            || this.topLevelTargetCoordinates.getEnd()==null) {
            return null;
        }     
        
        Coordinate primaryTranscTargetCoords = this.topLevelTargetCoordinates;

        if (Strand.REVERSE_STRAND.equals(primaryTranscTargetCoords.getStrand()) ) {
            
            //before transcript start
            if (chromosomePosition > primaryTranscTargetCoords.getEnd()) {
                    //result = this.getProcessedTranscriptLength() + (chromosomePosition- primaryTranscTargetCoords.getEnd() );
                    result =  - (chromosomePosition -primaryTranscTargetCoords.getEnd());
                    //if going from -ive to positive, we will have gone back  one too many
                    if (chromosomePosition>0 && primaryTranscTargetCoords.getEnd()<1 ) {
                        result++;
                    }
                    return result;
                }
            
            if (chromosomePosition.equals( primaryTranscTargetCoords.getEnd())) {
                return 1;
            }
                
            //beyond transcript end
            if (chromosomePosition < primaryTranscTargetCoords.getStart()) {
                    //result =  - (primaryTranscTargetCoords.getStart() - chromosomePosition);
                    result = processedLength + (primaryTranscTargetCoords.getStart()-chromosomePosition );
//                    //if going from positive to negative, we will have gone forward one too many
//                    if (chromosomePosition<0 && primaryTranscTargetCoords.getStart()>0) {
//                        result--;
//                    }                
                    return result;    
                }  
                
                
        } else {
             
            //before transcript start
            if (chromosomePosition<primaryTranscTargetCoords.getStart()) {
                    result =  - (primaryTranscTargetCoords.getStart() - chromosomePosition);
//                    //if move from positive to negative
//                    if (chromosomePosition<0 && primaryTranscTargetCoords.getStart()>0) {
//                        result++;
//                    }
                    return result;
             }
            
             if (chromosomePosition.equals(primaryTranscTargetCoords.getStart())) {
                 return 1;
             }
             
            //beyond transcript end
            if (chromosomePosition > primaryTranscTargetCoords.getEnd()) {
                 result = processedLength + (chromosomePosition - primaryTranscTargetCoords.getEnd());
                 //if move from negative to positive
                 if (chromosomePosition>0 && primaryTranscTargetCoords.getEnd() <1) {
                        result--;
                 }
                 return result;
             }             
        }
        
        if ( processedTranscriptExonMappings==null) {
            this.stitchExons();
        }     
        
        for (Mapping m: this.processedTranscriptExonMappings) {
            DAExon ex = (DAExon) m.getTarget();
            Coordinate exonCoordinates = ex.getTopLevelMappings().first().getTargetCoordinates();
            if (exonCoordinates.containsPoint(chromosomePosition)) {
                Coordinate sourceCoordinates = m.getSourceCoordinates();
                
                if (Strand.REVERSE_STRAND.equals(exonCoordinates.getStrand())) {
                    result = sourceCoordinates.getStart() + (exonCoordinates.getEnd()-chromosomePosition );
                } else {
                    result = sourceCoordinates.getStart() + (chromosomePosition-exonCoordinates.getStart() );
                    if (chromosomePosition>0 && exonCoordinates.getStart()<1) {
                        result--;
                    }
                }     
                break;
            }
        }

        return result;
    }    
    
    /**
     * Returns the mapped position on the Primary transcript equivalent to the given 
     * position on the processed transcript
     * @param processedTranscriptPosition
     * 
     * @throws DAOException 
     */
    public Integer convertProcessedToPrimaryTranscriptPosition(Integer processedTranscriptPosition) throws DAOException {
                       
        if (processedTranscriptPosition==null|| processedTranscriptPosition==0 ) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world.");
        }          
        
        if (processedTranscriptPosition<0) {
            return processedTranscriptPosition;
        }
        
        Integer chr = this.convertProcessedTranscriptPositionToChromosome(processedTranscriptPosition);
        
        if (chr==null) {
            return null;
        } else {
            return this.convertChromosomeToPrimaryTranscriptPosition(chr);
        }
    }
    
    /**
     * Returns the mapped position on the Processed transcript equivalent to the given 
     * position on the Primary (unprocessed) transcript
     * @param primaryTranscriptPosition
     * 
     * @throws DAOException 
     */
    public Integer convertPrimaryToProcessedTranscriptPosition(Integer primaryTranscriptPosition) throws DAOException {
        
        if (primaryTranscriptPosition==null|| primaryTranscriptPosition==0 ) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world.");
        }  
        
        if (primaryTranscriptPosition<0) {
            return primaryTranscriptPosition;
        }        
        
        Integer chr = this.convertPrimaryTranscriptPositionToChromosome(primaryTranscriptPosition);
        
        if (chr==null) {
            return null;
        } else {
            return this.convertChromosomeToProcessedTranscriptPosition(chr);
        }
    }
    
    
    /**
     * Returns a DADNASequence object representing the processed (spliced exons)
     * version of this Transcript.
     * 
     * @throws DAOException 
     */
    public DADNASequence getProcessedTranscript() throws DAOException  {
        
        if (processedTranscript != null ) {
            return processedTranscript;
        }
        
        String seq = "";
               
        if ( processedTranscriptExonMappings==null) {
                this.stitchExons();
        }  
        
        for (Mapping m:processedTranscriptExonMappings ) {          
            seq = seq.concat(super.getSequenceAsString(m.getSourceCoordinates().getStart(),m.getSourceCoordinates().getEnd()));
        }
        
        if (seq!= null && !seq.isEmpty()) {
            processedTranscript =  new DADNASequence(seq);
        }
        return processedTranscript;
    }

    /**
     * Returns the length of the processed (spliced exons)
     * version of this Transcript.
     * 
     * @throws DAOException 
     */
    public Integer getProcessedTranscriptLength() throws DAOException {
        if (processedTranscriptLength==null) {
            this.stitchExons();
        }
        return processedTranscriptLength;
    }
    
    
    /**
     * Returns the length of the unprocessed (primary)
     * version of this Transcript. (Wraps the DAFeature method 'getLength()').
     * 
     * @throws DAOException 
     */
    public Integer getPrimaryTranscriptLength()  { 
        return super.getLength();
    }
    
    /**
     * Returns a DADNASequence object representing the unprocessed primary Transcript.
     * (Wraps the DAFeature 'getSequence()' method.)
     * 
     */
    public DADNASequence getPrimaryTranscript() {
        return super.getSequence();
    }
    
    /**
     * Use of this deprecated method is equivalent to the preferred method 'getPrimaryTranscripRNASequence'.
     * 
     * @deprecated
     */
    @Deprecated
    @Override
    public RNASequence getRNASequence() {
        return super.getRNASequence();
    }
    
    /**
     * Preferred method to explicitly get the RNASequence object representing the 
     * PrimaryTranscript. Wraps DAFeature getRNASequence().
     * 
     */
    public RNASequence getPrimaryTranscriptRNASequence() {
        return super.getRNASequence();
    }
    
    /**
     * Use of this deprecated method is equivalent to the preferred method 'getPrimaryTranscripRNASequenceAsString'.
     * 
     * @deprecated
     */    
    @Deprecated
    @Override
    public String getRNASequenceAsString() {
        return super.getRNASequenceAsString();
    }

    /**
     * Preferred method to explicitly get a String representing the RNA sequence 
     * of the  PrimaryTranscript. Wraps DAFeature getRNASequenceAsString().
     * 
     */    
    public String getPrimaryTranscriptRNASequenceAsString() {
        return super.getRNASequenceAsString();
    }
    
    /**
     * Use of this deprecated method is equivalent to the preferred method 
     * 'getPrimaryTranscripRNASequenceAsString(int,int)'.
     * 
     * @deprecated
     */    
    @Deprecated
    @Override
    public String getRNASequenceAsString(Integer start, Integer stop) throws RangeException  {
        return super.getRNASequenceAsString(start, stop);
    }

    /**
     * Preferred method to explicitly get a String representing the RNA sequence 
     * of the  PrimaryTranscript, for the given range. 
     * Wraps DAFeature getRNASequenceAsString(int,int).
     * 
     */ 
    public String getPrimaryTranscriptRNASequenceAsString(Integer start, Integer stop) throws RangeException  {
        return super.getRNASequenceAsString(start, stop);
    }
    
    /**
     * Returns an RNASequence object representing the 
     * Processed (RNA spliced) Transcript. 
     * 
     */
    public RNASequence getProcessedTranscriptRNASequence() throws DAOException {
        
        if (this.getProcessedTranscript()==null || topLevelTargetSequence==null ) {
            return null;
        } else {
           Integer id = topLevelTargetSequence.getCodonTableID();
           return this.getProcessedTranscript().getRNASequence(this.getRegistry().getTranscriptionEngine(id));
        }        

    }    
    
    /**
     * Returns a String representing the RNA sequence 
     * of the  Processed (RNA spliced) Transcript. 
     * 
     */ 
    public String getProcessedTranscriptRNASequenceAsString() throws DAOException  {
        
          if (this.getProcessedTranscript()==null || topLevelTargetSequence==null) {
            return "";
          }
        
        return this.getProcessedTranscriptRNASequence().getSequenceAsString();
    }
    
    /**
     * Returns a String representing the RNA sequence 
     * of the  Processed (RNA spliced) Transcript, for the given range. 
     * 
     */ 
    public String getProcessedTranscriptRNASequenceAsString(Integer start, Integer stop) throws RangeException, DAOException  {
        
          if (this.getProcessedTranscript()==null || topLevelTargetSequence==null) {
            return "";
          }
        
        return this.getProcessedTranscriptRNASequence().getSequenceAsString(start,stop, org.biojava3.core.sequence.Strand.POSITIVE);
    }
    
    /**
     * Beware: this method does not trigger lazyloading of typed XRefs. 
     * @param type
     */
    protected Set<DAXRef> getXRefs(ExternalDBType type) {
        return typedXRefs.get(type);
    }
    
    /** 
     * Triggers lazyload if Transcript is not initialized.
     */
    @Override
    public DAXRef getDisplayXRef() {
        this.reinitialize();
        return displayXRef;
    }

    public void setDisplayXRef(DAXRef xref) {
        this.displayXRef = xref;
        if (xref!=null) {
            this.xrefs.add(xref);
            Set s = new HashSet<DAXRef>();
            s.add(xref);
            this.typedXRefs.put(ExternalDBType.DisplayID, s);            
        }
    }    

    /**
     * Returns any curated VegaID for the Transcript, 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.vegaTranscriptID!=null) {
            return this.vegaTranscriptID;
        }
        
        List<DAXRef> outList = new ArrayList<DAXRef>();
        
        if (this.getDaoFactory()!= null 
                && !this.getDaoFactory().getRegistry().getDatasourceType().equals(DBConnection.DataSource.ENSEMBLDB)) {
            this.vegaTranscriptID="";
            this.addTypedXRefs(ExternalDBType.VegaTranscript, outList);
            return this.vegaTranscriptID ;
        }
              
        this.reinitialize();
        
        if (this.vegaTranscriptID==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.VegaTranscript.toString())
                                    ||
                                    dax.getDB().getDBName().contains("Vega_transcript") 
                                    ||
                                    dax.getDB().getDBName().contains("vega_transcript") )
                                ) {
                            outList.add(dax);
                            }
                  }
                
                if (outList.isEmpty()) {
                    this.vegaTranscriptID = "";
                    this.addTypedXRefs(ExternalDBType.VegaTranscript, outList);
                    return this.vegaTranscriptID;
                } 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.VegaTranscript, outList);
                }

                if (outList.size()==1) {
                    this.vegaTranscriptID = outList.get(0).getPrimaryAccession().trim();
                    return this.vegaTranscriptID;
                } 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) {
                        vegaTranscriptID=out;
                    } else {
                        out = out.trim().concat("}");
                        vegaTranscriptID = pre.concat(out);
                    }
                    return this.vegaTranscriptID;
                }
            }          
        }
        return this.vegaTranscriptID;
    }

    @Override
    public Set<DAXRef> getVegaXRefs() {
        this.getVegaID();
        return this.getXRefs(ExternalDBType.VegaTranscript);
    }
    
    @Override 
    public Set<DAXRef> getCCDSXRefs() {
        this.getCcdsID();
        return this.getXRefs(ExternalDBType.CCDS);
    }

    @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 Feature: " + 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;
    }
    
    @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();
    }       
        
    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);
    }
    
    /**
     * Returns any curated CCDS for this transcript. 
     * The Consensus CDS (CCDS) project is a collaborative effort to identify a 
     * core set of human and mouse protein coding regions that are consistently 
     * annotated and of high quality. The long term goal is to support convergence 
     * towards a standard set of gene annotations.  
     */
    @Override
    public String getCcdsID() {
        if (ccdsID==null) {
           setCcdsXRef();
        }
        return ccdsID;
    }
    
    /*
     * Private setter routine for the CCDS ID. Restricted to  ENSEMBL database.
     * Calls the getTypedXRefs() method for ExternalDBType.CCDS and stores the 
     * typed XRef results.
     */
    private void setCcdsXRef() {
        
        //return immediately if we have already set the list of CCDS XRefs
        if (this.getXRefs(ExternalDBType.CCDS)!= null) {
            return;
        }
        
        List<DAXRef> out = new ArrayList<DAXRef>();  
        
        
        if (this.getDaoFactory()!= null 
                && !this.getDaoFactory().getRegistry().getDatasourceType().equals(DBConnection.DataSource.ENSEMBLDB)) {
            this.ccdsID="";
            this.addTypedXRefs(ExternalDBType.CCDS, out);
            return;
        }
        this.reinitialize();
        
        if (this.getDaoFactory()!= null && this.getId()!=null) {                

            for (DAXRef dax : this.getAllXRefs()) {
                if (dax.getDB()!= null  && dax.getDB().getDBName().equals(ExternalDBType.CCDS.toString())) {
                    out.add(dax);
                }
            }

                if ( out.isEmpty() ) {
                    this.ccdsID = "";
                    this.addTypedXRefs(ExternalDBType.CCDS, out);
                    return;
                } else {
                    
                    //add the factory to the xref - although we shouldn't need to use it as it is fully initialized
                    for (DAXRef xr: out) {
                        xr.setDaoFactory(this.getDaoFactory());
                    }
                    
                    this.addTypedXRefs(ExternalDBType.CCDS, out);
                }

                if (out.size()==1) {
                    //use the DisplayID in preference to the accession - because this has the version appended
                    this.ccdsID = out.get(0).getDisplayID().trim();
                } else {
                    //hopefully there wil be a single, or at least unique ID - but may not be able to guarantee this!
                    String pre = "Multiple CCDS IDs: {";
                    boolean multiple = false;
                    String o = null;
                    String firstID = "";
                    
                    for (XRef x: out) {
                        if (o==null) {
                            //use the DisplayID in preference to the accession - because this has the version appended
                            o = x.getDisplayID().trim();
                            firstID = x.getDisplayID().trim(); 
                        } else if (!firstID.equals(x.getDisplayID().trim())) {                        
                            o = o.concat(", ").concat(x.getDisplayID().trim());
                            multiple  = true;
                        }
                    }
                    o = o.trim().concat("}");
                    if (multiple) {                        
                        ccdsID = pre.concat(o);
                    }
                }

            } else {
            this.ccdsID= "";
            }        
    }    
    
}