SeqIO

import org.biojava3.core.sequence.DNASequence;
import org.biojava3.core.sequence.ProteinSequence;
import org.biojava3.core.sequence.io.FastaReaderHelper;
import org.biojava3.core.sequence.template.Sequence;
import org.biojava3.sequencing.io.fastq.*;

import java.io.InputStream;
import java.util.Iterator;

public class SeqIO {
    public static final Class<DNASequence> DNA = DNASequence.class;
    public static final Class<ProteinSequence> PROTEIN = ProteinSequence.class;

    public static final int FASTA = 0;
    public static final int FASTQ_SANGER = 1;
    public static final int FASTQ_SOLEXA = 2;


    public static <S extends Sequence> Iterable<S> parse(InputStream is, int fileFormat, Class<S> seqType) throws Exception {
        switch (fileFormat) {
            case FASTA:
                if (seqType == DNA) {
                    return (Iterable<S>) FastaReaderHelper.readFastaDNASequence(is);
                } else if (seqType == PROTEIN) {
                    return (Iterable<S>) FastaReaderHelper.readFastaProteinSequence(is);
                } else {
                    throw new IllegalArgumentException("Unsupported sequence type");
                }
            case FASTQ_SANGER:
                if (seqType == DNA) {
                    Iterable<Fastq> iter = new SangerFastqReader().read(is);
                    return (Iterable<S>) new MappedIterable<Fastq, DNASequence>(iter.iterator()) {
                        DNASequence mappingFunction(Fastq fq) {
                            return FastqTools.createDNASequenceWithQualityScoresAndErrorProbabilities(fq);
                        }
                    };
                } else {
                    throw new IllegalArgumentException("Unsupported sequence type");
                }
            case FASTQ_SOLEXA:
                if (seqType == DNA) {
                    Iterable<Fastq> iter = new SolexaFastqReader().read(is);
                    return (Iterable<S>) new MappedIterable<Fastq, DNASequence>(iter.iterator()) {
                        DNASequence mappingFunction(Fastq fq) {
                            return FastqTools.createDNASequenceWithQualityScoresAndErrorProbabilities(fq);
                        }
                    };
                }
             default:
                 throw new IllegalArgumentException("Unsupported file format");
        }
    }

    // A wrapper for Iterable that maps a function over the wrapped iterable before returning results
    private static abstract class MappedIterable<A,B> implements Iterable<B> {
        private final Iterator<A> origIter;
        abstract B mappingFunction(A a);

        MappedIterable(Iterator<A> originalIterator) {
            origIter = originalIterator;
        }

        public Iterator<B> iterator() {
            return new Iterator<B>() {
                @Override
                public boolean hasNext() {
                    return origIter.hasNext();
                }

                @Override
                public B next() {
                    return mappingFunction(origIter.next());
                }

                @Override
                public void remove() {
                    origIter.remove();
                }
            };
        }
    }

}