/**
 * 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.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;
import org.biojava3.core.sequence.RNASequence;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import uk.ac.roslin.ensembl.config.EnsemblCoordSystemType;
import uk.ac.roslin.ensembl.config.EnsemblDBType;
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.NonUniqueException;
import uk.ac.roslin.ensembl.exception.RangeException;
import uk.ac.roslin.ensembl.model.Coordinate;
import uk.ac.roslin.ensembl.model.Coordinate.Strand;
import uk.ac.roslin.ensembl.model.Mapping;
import uk.ac.roslin.ensembl.model.MappingSet;
import uk.ac.roslin.ensembl.model.ObjectType;
import uk.ac.roslin.ensembl.model.core.Chromosome;
import uk.ac.roslin.ensembl.model.core.CoordinateSystem;
import uk.ac.roslin.ensembl.model.core.Feature;
import uk.ac.roslin.ensembl.model.database.CollectionCoreDatabase;
import uk.ac.roslin.ensembl.model.database.SingleSpeciesCoreDatabase;

/**
 *
 * @author tpaterso
 */
public abstract class DAFeature extends DACoreObject implements Feature {

    protected MappingSet mappings = new MappingSet();
    protected HashMap<ObjectType, MappingSet> objectTypeMappings = new HashMap<ObjectType, MappingSet>();
    protected Set<ObjectType> mappedObjectTypes = new HashSet<ObjectType>();
    protected String description = null;
    protected DAXRef displayXRef = null;
    //protected List<DAXRef> xrefs = new ArrayList<DAXRef>();
    protected String displayName = null;
    protected Status status = Status.UNKNOWN;
    protected Boolean current = null;
    
    Coordinate topLevelTargetCoordinates = null;
    DADNASequence topLevelTargetSequence = null;
    protected DADNASequence thisSequence = null;
    CoordinateSystem topLevelCS = null;
        
    final static Logger LOGGER = LoggerFactory.getLogger(DAFeature.class);
    protected Integer length;
    protected boolean initialized = false;


    public DAFeature() {
        super();
    }

    public DAFeature(DAOCoreFactory factory) {
        super(factory);
    }

    @Override
    public MappingSet getLoadedMappings() {
        //we haven't got the lazy load working here yet
        return this.mappings;
    }

    //Should Be Private?? and call by named object type methods ??
    @Override
    public MappingSet getLoadedMappings(ObjectType targetType) {

        if (this.objectTypeMappings.containsKey(targetType)) {
            return this.objectTypeMappings.get(targetType);
        } else if (this.isObjectTypeMapped(targetType)) {
            this.objectTypeMappings.put(targetType, new MappingSet());
            return this.objectTypeMappings.get(targetType);
        } else {
            //we haven't got the lazy load working here yet
            //so far implemented the reinitialize method in: DATranscript, DAGene, DAExon
            this.reinitialize();
            return this.objectTypeMappings.get(targetType);
        }
    }

    @Override
    public Boolean addMapping(Mapping mapping) {

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

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

            ObjectType t = mapping.getTargetType();

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

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

        return false;

    }

    @Override
    public void addMappedObjectType(ObjectType mappedType) {
        mappedObjectTypes.add(mappedType);
    }

    @Override
    public Boolean isObjectTypeMapped(ObjectType mappedType) {
        return mappedObjectTypes.contains(mappedType);
    }

    // can there be more than one of these?
    public MappingSet getTopLevelMappings() throws DAOException {
        
        if (this.topLevelCS!=null) {
            return this.getLoadedMappings(topLevelCS.getType());
        } else {
            this.inititializeTopLevel();
        }

        MappingSet out = new MappingSet();

        if (this.getDaoFactory()==null) {
            throw new DAOException("No DAOFactory Set on this DAFeature");
        }

        try {
                if (this.getDaoFactory().getDBType().equals(EnsemblDBType.core)) {

                    this.topLevelCS = ((SingleSpeciesCoreDatabase) this.getDaoFactory().getDatabase()).getTopLevelCoordSystem();

                } else if (this.getDaoFactory().getDBType().equals(EnsemblDBType.collection_core)) {
                    this.topLevelCS = ((CollectionCoreDatabase) this.getDaoFactory().getDatabase()).getTopLevelCS(this.getSpecies());

                }
            } catch (DAOException dex) {
                LOGGER.warn("Failed to get the top level coordinate System for a Feature "
                        +this.getClass().getSimpleName()+ " "+this.getId(), dex);
                throw dex;
            } catch (Exception ex) {
                LOGGER.warn("Failed to get the top level coordinate System for a Feature "
                        +this.getClass().getSimpleName()+ " "+this.getId(), ex);
                throw new DAOException("Failed to retrieve top level CoordinateSystem for this CoreDatabase", ex);
            }

        if (this.topLevelCS != null) {

            out = this.getLoadedMappings(this.topLevelCS.getType());
            this.addMappedObjectType(this.topLevelCS.getType());
        } else {
            return null;
        } 


            return out;
    }

    /**
     * Utility method to pull back a single mapping of this Feature on a Given chromosome.
     * This should be the mapping stored at initialisation.
     * If the Feature has implemented a reinitialize method this may be called.
     * @param chr
     * @return a single Mapping
     * @throws NonUniqueException if more than one mapping for the chromosome
     */
    @Override
    public Mapping getChromosomeMapping(Chromosome chr) throws NonUniqueException{
        
        if (chr==null) {
            return null;
        }
        
        Mapping uniqueMapping = null;
        
        MappingSet s = this.getLoadedMappings(EnsemblCoordSystemType.chromosome);
        
        if (s==null || s.isEmpty()) {
            return null;
        }
        
        boolean found = false;
        
        for (Mapping m : s) {
            if (m.getTarget()==chr) {
                if (found) {
                    throw new NonUniqueException();
                }
                uniqueMapping = m;
                found = true;
            }
        }
        return uniqueMapping;
    }
    
    /**
     * Utility method to pull back a unique chromosomal mapping of this Feature.
     * This should be the mapping stored at initialisation.
     * If the Feature has implemented a reinitialize method this may be called.
     * @return a single Mapping
     * @throws NonUniqueException if more than one mapping for the chromosome
     */
    @Override
    public Mapping getChromosomeMapping() throws NonUniqueException{
        
        Mapping uniqueMapping = null;
        MappingSet s = this.getLoadedMappings(EnsemblCoordSystemType.chromosome);
        
        if (s==null || s.isEmpty()) {
            return null;
        }
        
        if (s.size()>1) {
          throw new NonUniqueException();
        }
        
        return s.first();
    }
    
    /**
     * Method to return all chromosomal mappings for this feature.
     * In most circumstances there should be only one mapping.
     * If the Feature has implemented a re-initialize method this may be called.
     * @return MappingSet ordered set of chromosomal mappings
     */
    @Override
    public MappingSet getChromosomeMappings() {
        
        return this.getLoadedMappings(EnsemblCoordSystemType.chromosome);
    }
    
    public MappingSet getAnnotationLevelMappings() throws DAOException  {
        
        if (this.getDaoFactory()==null) {
            throw new DAOException("No DAOFactory Set on this DAFeature");
        }

        Set<? extends CoordinateSystem> annotCS = null;

        try {
            if (this.getDaoFactory().getDBType().equals(EnsemblDBType.core)) {

                annotCS = ((SingleSpeciesCoreDatabase) this.getDaoFactory().getDatabase()).getCSForFeature(this.getType());

            } else if (this.getDaoFactory().getDBType().equals(EnsemblDBType.collection_core)) {
                annotCS = ((CollectionCoreDatabase) this.getDaoFactory().getDatabase())
                        .getCSForFeature(this.getSpecies(),this.getType());
            }
        } catch (DAOException dex) {
                LOGGER.warn("Failed to get the annotation level coordinate System for a Feature "
                        +this.getClass().getSimpleName()+ " "+this.getId(), dex);
                throw dex;
            } catch (Exception ex) {
                LOGGER.warn("Failed to get the annotation level coordinate System for a Feature "
                        +this.getClass().getSimpleName()+ " "+this.getId(), ex);
                throw new DAOException("Failed to retrieve annotation level CoordinateSystem for this CoreDatabase", ex);
            }

        if (annotCS==null || annotCS.isEmpty()) {
            LOGGER.warn("Failed to get the annotation level coordinate System for a Feature "
                    +this.getClass().getSimpleName()+ " "+this.getId());
            return null;
        }

        MappingSet out = new MappingSet();

        for (CoordinateSystem cs : annotCS ) {

            MappingSet t = this.getLoadedMappings(cs.getType());
            this.addMappedObjectType(cs.getType());
            if (t != null) {
               out.addAll(t);
            }

        }

        return out;
    }

    public MappingSet getBuildLevelMappings() throws DAOException{

        if (this.getDaoFactory()==null) {
            throw new DAOException("No DAOFactory Set on this DAFeature");
        }

        MappingSet out = new MappingSet();
        CoordinateSystem buildCS = null;
        
        try {
            if (this.getDaoFactory().getDBType().equals(EnsemblDBType.core)) {

                buildCS = ((SingleSpeciesCoreDatabase) this.getDaoFactory().getDatabase()).getBuildCoordSystem(this.getType().toString());

            } else if (this.getDaoFactory().getDBType().equals(EnsemblDBType.collection_core)) {
                buildCS = ((CollectionCoreDatabase) this.getDaoFactory().getDatabase()).getBuildCoordSystem(this.getSpecies(),this.getType().toString() );

            }
        } catch (DAOException dex) {
                LOGGER.warn("Failed to get the build level coordinate system for this database "
                        +this.getClass().getSimpleName()+ " "+this.getId(), dex);
                throw dex;
            } catch (Exception ex) {
                LOGGER.warn("Failed to get the build level coordinate system for this database "
                        +this.getClass().getSimpleName()+ " "+this.getId(), ex);
                throw new DAOException("Failed to retrieve build level CoordinateSystem for this CoreDatabase", ex);
            }

        if (buildCS != null) {

            out = this.getLoadedMappings(buildCS.getType());
            this.addMappedObjectType(buildCS.getType());
        } else {
            return null;
        }

        return out;
    }

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

    public String getDescription()  {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    abstract void reinitialize() ; //throws DAOException ;

    public boolean isInitialized() {
        return initialized;
    }
    
    public void setInitialized(boolean init) {
        this.initialized = init;
    }
    
    public static enum Status {
        KNOWN,
        NOVEL,
        PUTATIVE,
        PREDICTED,
        KNOWN_BY_PROJECTION,
        UNKNOWN;
    }

    public String getStatus() {
        return this.status.toString();
    }

    public void setStatus(String status) {
        try {
            this.status = Status.valueOf(status);
        } catch (IllegalArgumentException e) {
            this.status = Status.UNKNOWN;
        }
    }

    public String getDisplayName() {
        return displayName ;
    }

    public void setDisplayName(String displayName) {
        this.displayName = displayName;
    }

    @Override
    public Boolean isCurrent() {
        return current;
    }

    public void setCurrent(Boolean current) {
        this.current = current;
    }
    
    /**
     * This method is used to initialize  the 'topLevelCS', 
     * the 'topLevelTargetCoordinates' and the 'topLevelTargetSequence' fields.
     * @throws DAOException 
     */
    protected void inititializeTopLevel() throws DAOException {
        
        //make sure the gene is intialized
        reinitialize();

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

        if (this.getDaoFactory() == null) {
            throw new DAOException("No DAOFactory Set on this DAFeature");
        }

        try {
            if (this.getDaoFactory().getDBType().equals(EnsemblDBType.core)) {

                this.topLevelCS = ((SingleSpeciesCoreDatabase) this.getDaoFactory().getDatabase()).getTopLevelCoordSystem();

            } else if (this.getDaoFactory().getDBType().equals(EnsemblDBType.collection_core)) {
                this.topLevelCS = ((CollectionCoreDatabase) this.getDaoFactory().getDatabase()).getTopLevelCS(this.getSpecies());

            }
        } catch (DAOException dex) {
            LOGGER.warn("Failed to get the top level coordinate System for a Feature "
                    + this.getClass().getSimpleName() + " " + this.getId(), dex);
            throw dex;
        } catch (Exception ex) {
            LOGGER.warn("Failed to get the top level coordinate System for a Feature "
                    + this.getClass().getSimpleName() + " " + this.getId(), ex);
            throw new DAOException("Failed to retrieve top level CoordinateSystem for this CoreDatabase", ex);
        }

        if (this.topLevelCS != null) {

            this.addMappedObjectType(this.topLevelCS.getType());
            Mapping m = null;
            
            
            if (this.getLoadedMappings(this.topLevelCS.getType())!=null && 
                    !this.getLoadedMappings(this.topLevelCS.getType()).isEmpty()) {
                m= this.getLoadedMappings(this.topLevelCS.getType()).first() ;
            }

            if (m == null) {
                return;
            }

            topLevelTargetCoordinates = m.getTargetCoordinates();
            if (topLevelTargetCoordinates == null || topLevelTargetCoordinates.getStart() == null
                    || topLevelTargetCoordinates.getEnd() == null) {
                return;
            }

            topLevelTargetSequence = (DADNASequence) m.getTarget();
        }
    }

    /**
     * Returns the sequence covered by this feature (i.e. a new DADNASequence
     * object representing this region of the genome, it might be a GAPSequence
     * if no sequence info is available).
     * @return DADNASequence
     */
    public DADNASequence getSequence()  {

        if (thisSequence != null) {
            return thisSequence;
        }

        try {
            this.inititializeTopLevel();
        } catch (DAOException dAOException) {
        }
               
        if (topLevelTargetCoordinates == null || topLevelTargetCoordinates.getStart() == null 
                || topLevelTargetCoordinates.getEnd() == null) {
            return null;
        }
       
        // according to the ensembl api we should catch null sequences here and 
        //convert them to the length of the exon - however, i think this is more
        //to catch empty sequences
        if (topLevelTargetSequence == null) {
            Integer length = topLevelTargetCoordinates.getLength();
            thisSequence = GapSequence.makeGap(length);
        } else if (Strand.REVERSE_STRAND.equals(topLevelTargetCoordinates.getStrand())) {
            thisSequence = new DADNASequence(topLevelTargetSequence.getReverseComplementSequenceAsString(topLevelTargetCoordinates.getStart(), topLevelTargetCoordinates.getEnd()));
        } else {
            thisSequence = new DADNASequence(topLevelTargetSequence.getSequenceAsString(topLevelTargetCoordinates.getStart(), topLevelTargetCoordinates.getEnd()));
        }

        return thisSequence;
    }

    /**
     * Returns the (genomic) sequence that this feature is annotated upon (at
     * 'top level').
     *
     * @return DADNASequence
     */
    public DADNASequence getTargetSequence() {
        try {
            this.inititializeTopLevel();
        } catch (DAOException dAOException) {
        }
        return topLevelTargetSequence;
    }

    /**
     * Retrieves the String representation of the target (genomic) sequence that
     * this feature is annotated upon, for the given range. The range arguments
     * are relative to the start of the annotation, and therefore can be used to
     * get Flanking Sequences etc. The range arguments are transparently
     * converted to coordinates on the target sequence.      
     * Arguments outwith the extent of the annotation (i.e greater than its length, or less than the start site of 1) 
     * will throw a (Runtime) RangeException.
     * @param start Integer
     * @param stop Integer
     * @return String
     * @throws RangeException
     */
    public String getFlankingTargetSequenceAsString(Integer start, Integer stop) throws RangeException {
        try {
            this.inititializeTopLevel();
        } catch (DAOException dAOException) {
        }
               
        if (topLevelTargetCoordinates == null || topLevelTargetCoordinates.getStart() == null 
                || topLevelTargetCoordinates.getEnd() == null || topLevelTargetSequence == null) {
            return "";
        }
        
        //any illegal arguments are thrown as runtime exceptions by the method
        Coordinate targetCoordinate = this.convertToTargetCoordinate(start, stop);

        if (Strand.REVERSE_STRAND.equals(targetCoordinate.getStrand())) {
            //any illegal arguments are thrown as runtime exceptions by the  method
            return topLevelTargetSequence.getReverseComplementSequenceAsString(targetCoordinate.getStart(), targetCoordinate.getEnd());
        } else {
            //any illegal arguments are thrown as runtime exceptions by  the method
            return topLevelTargetSequence.getSequenceAsString(targetCoordinate.getStart(), targetCoordinate.getEnd());
        }
    }
    
    /**
     * Retrieves the String representation of the target (genomic) sequence that
     * this feature is annotated upon, for the given range. The range arguments
     * are relative to the start of the annotation, and therefore can be used to
     * get Flanking Sequences etc. The range arguments are transparently
     * converted to coordinates on the target sequence.
     * Arguments outwith the extent of the target sequence (i.e greater than its length, or less than the start site of 1) 
     * will cause the returned sequence to be padded appropriately.     
     * @param start Integer
     * @param stop Integer
     * @return String
     */
    public String getPaddedFlankingTargetSequenceAsString(Integer start, Integer stop) {
        try {
            this.inititializeTopLevel();
        } catch (DAOException dAOException) {
        }
               
        if (topLevelTargetCoordinates == null || topLevelTargetCoordinates.getStart() == null 
                || topLevelTargetCoordinates.getEnd() == null || topLevelTargetSequence == null) {
            return "";
        }
        //any illegal arguments are thrown as runtime exceptions by the wrapped method
        Coordinate targetCoordinate = this.convertToTargetCoordinate(start, stop);

        if (Strand.REVERSE_STRAND.equals(targetCoordinate.getStrand())) {
            return topLevelTargetSequence.getPaddedReverseComplementSequenceAsString(targetCoordinate.getStart(), targetCoordinate.getEnd());
        } else {
            return topLevelTargetSequence.getPaddedSequenceAsString(targetCoordinate.getStart(), targetCoordinate.getEnd());
        }
    }

    /**
     * Returns the string representation of the (genomic) sequence that this
     * feature is annotated upon (at 'top level').
     *
     * @return String
     */
    public String getSequenceAsString() {
        
       //original method caused a sequence object to be created..
       // return this.getSequence() != null ? this.getSequence().getSequenceAsString() : "";
        
        if (thisSequence != null) {
            return thisSequence.getSequenceAsString();
        }
        
        try {
            this.inititializeTopLevel();
        } catch (DAOException dAOException) {
        }
               
        if (topLevelTargetCoordinates == null || topLevelTargetCoordinates.getStart() == null 
                || topLevelTargetCoordinates.getEnd() == null) {
            return "";
        }
       
        // according to the ensembl api we should catch null sequences here and 
        //convert them to the length of the exon - however, i think this is more
        //to catch empty sequences
        Integer length = topLevelTargetCoordinates.getLength();
        if (topLevelTargetSequence == null) {
            return  GapSequence.getGapString(length);
        } else {
            return getFlankingTargetSequenceAsString(1,length);
        }

    }

    /**
     * Returns the string representation of the (genomic) sequence that this
     * feature is annotated upon (at 'top level'), for the specified range. The
     * range arguments are relative to the start of the annotation, i.e. on the correct strand, from '1' to 'length of annotation'.
     * Arguments outwith the extent of the annotation (i.e greater than its length, or less than the start site of 1) 
     * will throw a (Runtime) RangeException. There is no Padding function available on Features.
     * @param start Integer
     * @param stop Integer
     * @return String
     */
    public String getSequenceAsString(Integer start, Integer stop) throws RangeException {
        //any illegal arguments are thrown as runtime exceptions by the wrapped method

        //original method caused a sequence object to be created..
        //return this.getSequence() != null ? ((DADNASequence) this.getSequence()).getSequenceAsString(start, stop) : "";
        
        if (thisSequence != null) {
            return thisSequence.getSequenceAsString(start, stop);
        }
        
        try {
            this.inititializeTopLevel();
        } catch (DAOException dAOException) {
        }
               
        if (topLevelTargetCoordinates == null || topLevelTargetCoordinates.getStart() == null 
                || topLevelTargetCoordinates.getEnd() == null) {
            return "";
        }
       
        // according to the ensembl api we should catch null sequences here and 
        //convert them to the length of the exon - however, i think this is more
        //to catch empty sequences

        if (topLevelTargetSequence == null) {
            Coordinate c = new Coordinate(start,stop);
            return  GapSequence.getGapString(c.getLength());
        } else  {
            return getFlankingTargetSequenceAsString(start,stop);
        }
        
    }
      
    /**
     * Converts an Integer position on the TopLevel-annotated Target (typically the Chromosome) 
     * to the position on this feature. 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.
     * @TODO maybe rename 'convertTopLevelPositionToFeature'
     * @param chromosomePosition Integer
     * @return Integer
     */    
    public Integer convertChromosomePositionToFeature(Integer chromosomePosition) {
        
        Integer result = null;
        
        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.");            
        }
        
        try {
            this.inititializeTopLevel();
        } catch (DAOException dAOException) {
        } 
        
        if (topLevelTargetCoordinates == null || topLevelTargetCoordinates.getStart() == null 
                || topLevelTargetCoordinates.getEnd() == null) {
            return null;
        }       
        
        //these coordinates should be positive, with End>Start
        Integer featureChrStart = topLevelTargetCoordinates.getStart();
        Integer featureChrEnd = topLevelTargetCoordinates.getEnd();
        
        if (featureChrStart<1 || featureChrEnd<1) {
            throw new RangeException("Bad (negative) chromosome coordinates for this Feature");
        }
        
        if ( Strand.REVERSE_STRAND.equals(topLevelTargetCoordinates.getStrand())) {
            result = 1 + (featureChrEnd-chromosomePosition);
            //if we have gone over 'ZERO' we need a correction
            if (result<1 ){
                result--;
            }
            
            
        } else {
            result =  chromosomePosition-featureChrStart+1;
            //if we have gone over 'ZERO' we need a correction
            if (result<1)
                {
                    result--;
                }
        }

        return result;
    }
    
    /**
     * Converts an Integer relative to the annotation start site to the position on the 
     * annotated TopLevel target (genomic) sequence. 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 query Integer
     * @return Integer
     */
    public Integer convertToTargetPosition (Integer query) {
        
        //there is no zero in Ensembl
        //if we are asked for 0 we could perhaps return the mapping for 1 rater than a runtime exception
        //if we are asked for negative (upstream) positions, we need a +1 correction
        
        if (query ==null || query==0) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }
        
        try {
            this.inititializeTopLevel();
        } catch (DAOException dAOException) {
        }
             
        if (topLevelTargetCoordinates == null || topLevelTargetCoordinates.getStart() == null 
                || topLevelTargetCoordinates.getEnd() == null) {
            return null;
        }
        
        //these coordinates should be positive, with End>Start
        Integer featureChrStart = topLevelTargetCoordinates.getStart();
        Integer featureChrEnd = topLevelTargetCoordinates.getEnd();
        
        if (featureChrStart<1 || featureChrEnd<1) {
            throw new RangeException("Bad (negative) chromosome coordinates for this Feature");
        }
        
        
        Integer temp = null;
        
        if (Strand.REVERSE_STRAND.equals(topLevelTargetCoordinates.getStrand())) {          
            if (query<0) {
                temp =  featureChrEnd-query;              
            } else {
                temp =  featureChrEnd-query+1;
                //if moved from positive to negative, subtract one
                if (temp<1){
                    temp--;
                }
            }
            
        } else {
            if (query>0) {
                temp =  featureChrStart+query-1;           
            } else {
                temp = featureChrStart+query;
                //if moved from positive to negative, subtract one
                if (temp<1){
                    temp--;
                }
            }
        }
     
        //allow this now and deal with it higher up - as we may allow padding if the extent is not covered
//        if (temp>this.topLevelTargetSequence.getLength() || temp<1) {
//            throw new IllegalArgumentException("Coordinates fall outside the extent of the DNA molecule");
//        }

        return temp;
        
        
    }

    /**
     * Converts a given range (relative to the annotation start site) to the Coordinates on the 
     * annotated target TopLevel (genomic) sequence. The TopLevel Target should only have  a 
     * positive coordinate system (and if not a RangeException will be thrown here, 
     * originating in the call to 'convertToTargetPosition').
     * The returned Coordinate is given  on the same strand as the feature.
     * @param start Integer
     * @param stop Integer
     * @return Coordinate
     */
    public Coordinate convertToTargetCoordinate (Integer start, Integer stop)  {
        if (start==null || start==0 || stop==null || stop==0) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }
        
        try {
            this.inititializeTopLevel();
        } catch (DAOException dAOException) {}
        
        if (topLevelTargetCoordinates == null || topLevelTargetCoordinates.getStart() == null 
                || topLevelTargetCoordinates.getEnd() == null) {
            return null;
        }
        
        
        if (stop<start) {
               Integer temp = start;
               start = stop;
               stop = temp;
        } 
        
        if (Strand.REVERSE_STRAND.equals(topLevelTargetCoordinates.getStrand())) {
            return new Coordinate(convertToTargetPosition(stop), convertToTargetPosition(start), 
                   Strand.REVERSE_STRAND) ;
        } else {
            return new Coordinate(convertToTargetPosition(start), convertToTargetPosition(stop),
                    Strand.FORWARD_STRAND);
        }
        
    }    

    /**
     * Returns an RNASequence object trancribed from the DNASequence representing 
     * the extent of this annotation. The TranscriptionEngine used is as specified by
     * the genomic target (annotated) sequence.
     * @return RNASequence
     */
    public RNASequence getRNASequence() {
        if (this.getSequence()==null || topLevelTargetSequence==null) {
            return null;
        } else {
           Integer id = topLevelTargetSequence.getCodonTableID();
           return thisSequence.getRNASequence(this.getRegistry().getTranscriptionEngine(id));
        }

    }
    
    /**
     * Returns a string representation of the RNASequence object trancribed from the DNASequence representing 
     * the extent of this annotation. The TranscriptionEngine used is as specified by
     * the genomic target (annotated) sequence.
     * @return String
     */    
    public String getRNASequenceAsString() {
        if (this.getRNASequence()==null) {
            return "";
        } else {
           return this.getRNASequence().getSequenceAsString();
        }
    }
    
    /**
     * Returns a string representation for the given range of the RNASequence object 
     * trancribed from the DNASequence representing  the extent of this annotation. 
     * The TranscriptionEngine used is as specified by the genomic target (annotated) sequence.
     * Arguments outwith the extent of the annotation (i.e greater than its length, or less than the start site of 1) 
     * will throw a (Runtime) RangeException.
     * @param start
     * @param stop
     * @return String
     * @throws RangeException 
     */
    public String getRNASequenceAsString(Integer start, Integer stop) throws RangeException {
        if (this.getRNASequence()==null) {
            return "";
        } else {   
           if (stop<start) {
               Integer temp = start;
               start = stop;
               stop = temp;
           } 
           if (start<1 ) {
               throw new RangeException("An RNA start position of less than 1 is not allowed");
           }
           if (stop>this.getRNASequence().getLength() ) {
               throw new RangeException("An RNA cannot be longer than its length");
           }               
           return this.getRNASequence().getSequenceAsString(start, stop, null);
        }
    }
    
    /**
     * Returns the length of this feature, as calculated from its mapped 
     * coordinates on the top level annotated sequence (typically the chromosome).
     */
    public Integer getLength() {

        if (this.length!=null) {
            return this.length;
        }
        
        try {
            this.inititializeTopLevel();
        } catch (DAOException dAOException) {
        }
               
        if (topLevelTargetCoordinates == null || topLevelTargetCoordinates.getStart() == null 
                || topLevelTargetCoordinates.getEnd() == null) {
            return null;
        }
        
        this.length = topLevelTargetCoordinates.getLength();
        
        return this.length;
    }
    
    public void setLength(Integer length) {
        this.length = length;
    }

    public Coordinate getTopLevelTargetCoordinates() throws DAOException {
        if (topLevelTargetCoordinates!=null) {
            return topLevelTargetCoordinates;
        }    
        this.inititializeTopLevel();
        return topLevelTargetCoordinates;
    }

    public DADNASequence getTopLevelTargetSequence() throws DAOException {
        if (topLevelTargetSequence!=null) {
            return topLevelTargetSequence;
        } 
        this.inititializeTopLevel();
        return topLevelTargetSequence;
    }

    @Override
    public Integer getId() {
        if (this.id==null||this.id==0) {
            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;
    }


}