/**
 * 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.lang.ref.SoftReference;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import org.biojava3.core.exceptions.CompoundNotFoundError;
import org.biojava3.core.sequence.AccessionID;
import org.biojava3.core.sequence.DNASequence;
import org.biojava3.core.sequence.Strand;
import org.biojava3.core.sequence.compound.NucleotideCompound;
import org.biojava3.core.sequence.storage.ArrayListSequenceReader;
import org.biojava3.core.sequence.template.CompoundSet;
import org.biojava3.core.sequence.template.SequenceMixin;
import org.biojava3.core.sequence.template.SequenceProxyView;
import org.biojava3.core.sequence.template.SequenceReader;
import org.biojava3.core.sequence.template.SequenceView;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import uk.ac.roslin.ensembl.biojava3.EnsemblDNACompoundSet;
import uk.ac.roslin.ensembl.biojava3.EnsemblDNASequenceReader;
import uk.ac.roslin.ensembl.dao.factory.DAOCoreFactory;
import uk.ac.roslin.ensembl.exception.DAOException;

/**
 *
 * @author paterson
 */
public class DAEnsemblDNASequenceReader implements EnsemblDNASequenceReader {

    protected String sequence;
    protected EnsemblDNACompoundSet compoundSet;
    protected DADNASequence dASequence;
    protected Integer coordSystemID;

    protected Integer seqRegionID;
    protected Integer length;
    protected String name;

    protected DAOCoreFactory factory;
    protected DADNASequence parent;



    private LinkedHashMap<SoftReference<Integer>, SoftReference<DNASequence>> cache;
//    private SoftReference<Map<Integer,SoftReference<DNASequence>>> cacheMap;
//    private Map<Integer,SoftReference<DNASequence>> cache;
    private Integer chunkSize = 250000;
    private boolean usesCache = false;
    private boolean nonCacheLazyLoaded = false;
    private Integer chunks = 0;


    private SequenceReader<NucleotideCompound> sequenceReader;
    
    final static Logger LOGGER = LoggerFactory.getLogger(DAEnsemblDNASequenceReader.class);

    public DAEnsemblDNASequenceReader(){
        this.setCompoundSet(EnsemblDNACompoundSet.getDNACompoundSet());
    }

    public DAEnsemblDNASequenceReader(Integer coordSystemID, Integer seqRegionID, Integer length, String name, DAOCoreFactory factory){
        this.setCompoundSet(EnsemblDNACompoundSet.getDNACompoundSet());
        this.setCoordSystemID(coordSystemID);
        this.setLength(length);
        if (this.getLengthInteger()>2*chunkSize) {
            usesCache=true;
            chunks = (this.getLengthInteger()/chunkSize) -1;
            cache  = new LinkedHashMap<SoftReference<Integer> ,SoftReference<DNASequence>>();
        }
        this.setSeqRegionID(seqRegionID);
        this.setName(name);
        this.setFactory(factory);
    }

    private void initCache() {

    }

    private void lazyLoadNonCache() throws DAOException, CompoundNotFoundError {

        String out = null;
        if (this.getFactory()!=null
                && this.getFactory().getSequenceDAO()!=null) {
            out = this.getFactory().getSequenceDAO().getFullSequence(this);
            setNonCacheLazyLoaded(true);
        }
        if (out!=null) {
            this.setContents(out);
        }
        
    }

    public DADNASequence getParent() {
        return parent;
    }

    public void setParent(DADNASequence parent) {
        this.parent = parent;
        if (parent!=null) {
            this.setFactory(parent.getDaoFactory());
        }
    }

    //*************************************



    public DAOCoreFactory getFactory() {
        if (factory == null) {
            if (this.getParent() != null) {
                factory = this.getParent().getDaoFactory();
            }
        }
        return factory;
    }

    public void setFactory(DAOCoreFactory factory) {
        this.factory = factory;
    }

    public String getName() {
        return name;
    }

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

    public Integer getCoordSystemID() {
        return coordSystemID;
    }

    public void setCoordSystemID(Integer coordSystemID) {
        this.coordSystemID = coordSystemID;
    }

    public int getLength() {
       return (length!=null)?length:0;
    }

    public Integer getLengthInteger() {
        return length;
    }

    public void setLength(Integer length) {
        this.length = length;
    }

    public Integer getSeqRegionID() {
        return seqRegionID;
    }

    public void setSeqRegionID(Integer seqRegionID) {
        this.seqRegionID = seqRegionID;
    }

    //*****************************

    public void setCompoundSet(CompoundSet compoundSet) {
        this.compoundSet = (EnsemblDNACompoundSet) compoundSet;
    }

    public void setContents(String sequence) {
        sequenceReader = new ArrayListSequenceReader<NucleotideCompound>(sequence, getCompoundSet());
        setNonCacheLazyLoaded(true);
        length = sequenceReader.getLength();
    }

    //******************************

    public NucleotideCompound getCompoundAt(int position) {
        triggerLoad();
        if (this.getLength()==0 || sequenceReader == null ) {
            return null;
        }
        return sequenceReader.getCompoundAt(position);
     }

    public int getIndexOf(NucleotideCompound compound) {
        triggerLoad();
        if (this.getLength()==0) {
            return 0;
        }
        return SequenceMixin.indexOf(this, compound);
    }

    public int getLastIndexOf(NucleotideCompound compound) {
        triggerLoad();
        if (this.getLength()==0) {
            return 0;
        }
        return SequenceMixin.lastIndexOf(this, compound);
     }

     public String getSequenceAsString() {
        triggerLoad();
        if (this.getLength()==0) {
            return "";
        }
        return SequenceMixin.toString(this);
     }

     public String getSequenceAsString(Integer start, Integer end, Strand strand) {
        triggerLoad();
        if (this.getLength()==0) {
            return "";
        }
        if(Strand.NEGATIVE.equals(strand)) {
            return getSubSequence(start, end).getInverse().getSequenceAsString();
         }
        else {
            return getSubSequence(start, end).getSequenceAsString();
        }
    }

    private void triggerLoad() {
        if (usesCache) {
            //TODO Need to support caching version
        }
        else {
            if(! nonCacheLazyLoaded) {
                 try {
                     //initialize the sequence
                     this.lazyLoadNonCache();
                 } catch (DAOException ex) {
                     LOGGER.info("Error in loading data from remote source:\n" + ex.getMessage());

                 } catch (CompoundNotFoundError ex) {
                     LOGGER.info("Error parsing sequence:\n" + ex.getMessage());

                 }
             }
         }

     }

     public String getReverseComplementSequenceAsString(Integer start, Integer end) {
        triggerLoad();
        if (this.getLength()==0) {
            return "";
        }
        return getSubSequence(start, end).getInverse().getSequenceAsString();
     }

    public List<NucleotideCompound> getAsList() {
        triggerLoad();
        if (this.getLength()==0) {
            return new ArrayList<NucleotideCompound>();
        }
        return SequenceMixin.toList(this);
     }

    public SequenceView<NucleotideCompound> getSubSequence(Integer start, Integer end) {
        triggerLoad();
        if (this.getLength()==0) {
            return null;
        }
        return new SequenceProxyView<NucleotideCompound>(this, start, end);
     }

    public CompoundSet<NucleotideCompound> getCompoundSet() {
        return compoundSet;
    }

    public AccessionID getAccession() {
        throw new UnsupportedOperationException("Not supported yet.");
    }

    public int countCompounds(NucleotideCompound... compounds) {
        triggerLoad();
        if (this.getLength()==0) {
            return 0;
        }
        return SequenceMixin.countCompounds(this, compounds);
    }

    public Iterator<NucleotideCompound> iterator() {
        triggerLoad();
        return (sequenceReader!= null) ?  SequenceMixin.createIterator(sequenceReader):
            new EmptyIterator();
     }

    public SequenceView<NucleotideCompound> getInverse() {
        triggerLoad();
        if (this.getLength()==0) {
            return null;
        }
        return SequenceMixin.inverse(this);
    }


    private void setNonCacheLazyLoaded(boolean nonCacheLazyLoaded) {
        this.nonCacheLazyLoaded = nonCacheLazyLoaded;
    }

    public static class EmptyIterator<NucleotideCompound> implements
            Iterator<NucleotideCompound> {

        public EmptyIterator() {

        }

        public boolean hasNext() {
            return false;
        }

        public NucleotideCompound next() {
            return null;
        }

        public void remove() {

        }

    }
  
}