/*
 *                    BioJava development code
 *
 * This code may be freely distributed and modified under the
 * terms of the GNU Lesser General Public Licence.  This should
 * be distributed with the code.  If you do not have a copy,
 * see:
 *
 *      http://www.gnu.org/copyleft/lesser.html
 *
 * Copyright for this code is held jointly by the individual
 * authors.  These should be listed in @author doc comments.
 *
 * For more information on the BioJava project and its aims,
 * or to join the biojava-l mailing list, visit the home page
 * at:
 *
 *      http://www.biojava.org/
 *
 */
package org.biojava.nbio.core.sequence.storage;

import org.biojava.nbio.core.exceptions.CompoundNotFoundException;
import org.biojava.nbio.core.sequence.AccessionID;
import org.biojava.nbio.core.sequence.template.*;
import org.biojava.nbio.core.util.Equals;

import java.util.*;

/**
 * This reader actually proxies onto multiple types of sequence in order
 * to allow a number of sequence objects to act as if they are one sequence.
 * The code takes in any number of sequences, records the minimum and maximum
 * bounds each sequence covers with respect to 1 position indexing and then
 * binary searches these when a position is requested. Because of this
 * 0 length Sequences are excluded during construction.
 *
 * Performance is not as good as if you are using a flat sequence however the
 * speed of lookup is more than adaquate for most situations. Using the iterator
 * gives the best performance as this does not rely on the binary search
 * mechanism instead iterating through each sequence in turn.
 *
 * @author ayates
 * @param <C> Tyoe of compound to hold
 */
public class JoiningSequenceReader<C extends Compound> implements ProxySequenceReader<C> {

	/**
	 * Internal implementation flag and controls how we look for the right
	 * sub-sequence
	 */
	private static final boolean BINARY_SEARCH = true;
	private final List<Sequence<C>> sequences;
	private final CompoundSet<C> compoundSet;
	private int[] maxSequenceIndex;
	private int[] minSequenceIndex;

	/**
	 * Allows creation of the store from Vargs Sequence<C> objects. CompoundSet
	 * defaults to the first element of the array (assuming there are elements
	 * available during construction otherwise we will throw an illegal
	 * state exception).
	 */
	public JoiningSequenceReader(Sequence<C>... sequences) {
		this(Arrays.asList(sequences));
	}

	/**
	 * Allows creation of the store from List<Sequence<C>>. CompoundSet
	 * defaults to the first element of the List (assuming there are elements
	 * available during construction otherwise we will throw an illegal
	 * state exception).
	 */
	public JoiningSequenceReader(List<Sequence<C>> sequences) {
		this.sequences = grepSequences(sequences);
		this.compoundSet = grepCompoundSet();
	}

	public JoiningSequenceReader(CompoundSet<C> compoundSet, Sequence<C>... sequences) {
		this(compoundSet, Arrays.asList(sequences));
	}

	public JoiningSequenceReader(CompoundSet<C> compoundSet, List<Sequence<C>> sequences) {
		this.sequences = grepSequences(sequences);
		this.compoundSet = compoundSet;
	}

	private List<Sequence<C>> grepSequences(List<Sequence<C>> sequences) {
		List<Sequence<C>> seqs = new ArrayList<Sequence<C>>();
		for (Sequence<C> s : sequences) {
			if (s.getLength() != 0) {
				seqs.add(s);
			}
		}
		return seqs;
	}

	private CompoundSet<C> grepCompoundSet() {
		if (sequences.isEmpty()) {
			throw new IllegalStateException("Cannot get a CompoundSet because we have no sequences. Set during construction");
		}
		return sequences.get(0).getCompoundSet();
	}


	@Override
	public C getCompoundAt(int position) {
		int sequenceIndex = getSequenceIndex(position);
		Sequence<C> sequence = sequences.get(sequenceIndex);
		int indexInSequence = (position - getMinSequenceIndex()[sequenceIndex]) + 1;
		return sequence.getCompoundAt(indexInSequence);
	}


	@Override
	public CompoundSet<C> getCompoundSet() {
		return compoundSet;
	}


	@Override
	public int getLength() {
		int[] maxSeqIndex = getMaxSequenceIndex();
		if (maxSeqIndex.length == 0) {
			return 0;
		}
		return maxSeqIndex[maxSeqIndex.length - 1];
	}

	/**
	 * Returns which Sequence holds the position queried for
	 */
	private int getSequenceIndex(int position) {
		if (BINARY_SEARCH) {
			return binarySearch(position);
		} else {
			return linearSearch(position);
		}
	}

	private int[] getMinSequenceIndex() {
		if (minSequenceIndex == null) {
			initSeqIndexes();
		}
		return minSequenceIndex;
	}

	private int[] getMaxSequenceIndex() {
		if (maxSequenceIndex == null) {
			initSeqIndexes();
		}
		return maxSequenceIndex;
	}

	private void initSeqIndexes() {
		minSequenceIndex = new int[sequences.size()];
		maxSequenceIndex = new int[sequences.size()];
		int currentMaxIndex = 0;
		int currentMinIndex = 1;
		int lastLength = 0;
		for (int i = 0; i < sequences.size(); i++) {
			currentMinIndex += lastLength;
			currentMaxIndex += sequences.get(i).getLength();
			minSequenceIndex[i] = currentMinIndex;
			maxSequenceIndex[i] = currentMaxIndex;
			lastLength = sequences.get(i).getLength();
		}
	}

	/**
	 * Scans through the sequence index arrays in linear time. Not the best
	 * performance but easier to code
	 */
	private int linearSearch(int position) {
		int[] minSeqIndex = getMinSequenceIndex();
		int[] maxSeqIndex = getMaxSequenceIndex();
		int length = minSeqIndex.length;
		for (int i = 0; i < length; i++) {
			if (position >= minSeqIndex[i] && position <= maxSeqIndex[i]) {
				return i;
			}
		}
		throw new IndexOutOfBoundsException("Given position " + position + " does not map into this Sequence");
	}

	/**
	 * Scans through the sequence index arrays using binary search
	 */
	private int binarySearch(int position) {
		int[] minSeqIndex = getMinSequenceIndex();
		int[] maxSeqIndex = getMaxSequenceIndex();

		int low = 0;
		int high = minSeqIndex.length - 1;
		while (low <= high) {
			//Go to the mid point in the array
			int mid = (low + high) >>> 1;

			//Get the max position represented by this Sequence
			int midMinPosition = minSeqIndex[mid];
			int midMaxPosition = maxSeqIndex[mid];

			//if current position is greater than the current bounds then
			//increase search space
			if (midMinPosition < position && midMaxPosition < position) {
				low = mid + 1;
			} //if current position is less than current bounds then decrease
			//search space
			else if (midMinPosition > position && midMaxPosition > position) {
				high = mid - 1;
			} else {
				return mid;
			}
		}
		throw new IndexOutOfBoundsException("Given position " + position + " does not map into this Sequence");
	}

	/**
	 * Iterator implementation which attempts to move through the 2D structure
	 * attempting to skip onto the next sequence as & when it is asked to
	 */

	@Override
	public Iterator<C> iterator() {
		final List<Sequence<C>> localSequences = sequences;
		return new Iterator<C>() {

			private Iterator<C> currentSequenceIterator = null;
			private int currentPosition = 0;


			@Override
			public boolean hasNext() {
				//If the current iterator is null then see if the Sequences object has anything
				if (currentSequenceIterator == null) {
					return !localSequences.isEmpty();
				}

				//See if we had any compounds
				boolean hasNext = currentSequenceIterator.hasNext();
				if (!hasNext) {
					hasNext = currentPosition < sequences.size();
				}
				return hasNext;
			}


			@Override
			public C next() {
				if (currentSequenceIterator == null) {
					if (localSequences.isEmpty()) {
						throw new NoSuchElementException("No sequences to iterate over; make sure you call hasNext() before next()");
					}
					currentSequenceIterator = localSequences.get(currentPosition).iterator();
					currentPosition++;
				}
				if (!currentSequenceIterator.hasNext()) {
					currentSequenceIterator = localSequences.get(currentPosition).iterator();
					currentPosition++;
				}
				return currentSequenceIterator.next();
			}


			@Override
			public void remove() throws UnsupportedOperationException {
				throw new UnsupportedOperationException("Cannot remove from this Sequence");
			}
		};
	}


	@Override
	public void setCompoundSet(CompoundSet<C> compoundSet) {
		throw new UnsupportedOperationException();
	}


	@Override
	public void setContents(String sequence) throws CompoundNotFoundException {
		throw new UnsupportedOperationException();
	}


	@Override
	public int countCompounds(C... compounds) {
		return SequenceMixin.countCompounds(this, compounds);
	}


	@Override
	public AccessionID getAccession() throws UnsupportedOperationException {
		throw new UnsupportedOperationException();
	}


	@Override
	public List<C> getAsList() {
		return SequenceMixin.toList(this);
	}

	@Override
	public boolean equals(Object o) {

		if(! Equals.classEqual(this, o)) {
			return false;
		}

		Sequence<C> other = (Sequence<C>)o;
		if ( other.getCompoundSet() != getCompoundSet())
			return false;

		List<C> rawCompounds = getAsList();
		List<C> otherCompounds = other.getAsList();

		if ( rawCompounds.size() != otherCompounds.size())
			return false;

		for (int i = 0 ; i < rawCompounds.size() ; i++){
			Compound myCompound = rawCompounds.get(i);
			Compound otherCompound = otherCompounds.get(i);
			if ( ! myCompound.equalsIgnoreCase(otherCompound))
				return false;
		}
		return true;
	}

	@Override
	public int hashCode(){
		String s = getSequenceAsString();
		return s.hashCode();
	}

	@Override
	public int getIndexOf(C compound) {
		return SequenceMixin.indexOf(this, compound);
	}


	@Override
	public int getLastIndexOf(C compound) {
		return SequenceMixin.lastIndexOf(this, compound);
	}


	@Override
	public String getSequenceAsString() {
		return SequenceMixin.toStringBuilder(this).toString();
	}


	@Override
	public SequenceView<C> getSubSequence(Integer start, Integer end) {
		return SequenceMixin.createSubSequence(this, start, end);
	}

	@Override
	public SequenceView<C> getInverse() {
		return SequenceMixin.inverse(this);
	}
}
