/*
 *                    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/
 *
 * Created on 01-21-2010
 */
package org.biojava.nbio.core.sequence.location;

import org.biojava.nbio.core.exceptions.ParserException;
import org.biojava.nbio.core.sequence.AccessionID;
import org.biojava.nbio.core.sequence.Strand;
import org.biojava.nbio.core.sequence.location.template.Location;
import org.biojava.nbio.core.sequence.location.template.Point;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * Helper methods for use with the Location classes. Taking its
 * inspiration from the RichSequence.Tools class from the old BioJava
 */
public class LocationHelper {

        /**
         * Used as a thin wrapper to the {@link #location(java.util.List, java.lang.String) }
         * method to bring the given location list together as a join (the default
         * type)
         */
        public static Location location(List<Location> subLocations) {
                return location(subLocations, "join");
        }

        /**
         * Builds a location from a List of locations; this can be circular or
         * linear joins. The code expects that these locations are in
         * a sensible format.
         *
         * @param subLocations The list of locations to use to build the location.
         * If given a list of size 1 we will return that location.
         * @param type The type of join for this location; defaults to join
         * @return
         */
        public static Location location(List<Location> subLocations, String type) {
                if (subLocations.size() == 1) {
                        return subLocations.get(0);
                }

                boolean circular = detectCicular(subLocations);
                Strand strand = detectStrand(subLocations);
                Point start = detectStart(subLocations);
                Point end = detectEnd(subLocations, circular);
                Location l;
                if ("join".equals(type)) {
                        l = new SimpleLocation(start, end, strand, circular, subLocations);
                }
                else if ("order".equals(type)) {
                        l = new InsdcLocations.OrderLocation(start, end, strand, circular, subLocations);
                }
                else if ("one-of".equals(type)) {
                        l = new InsdcLocations.OneOfLocation(subLocations);
                }
                else if ("group".equals(type)) {
                        l = new InsdcLocations.GroupLocation(start, end, strand, circular, subLocations);
                }
                else if ("bond".equals(type)) {
                        l = new InsdcLocations.BondLocation(subLocations);
                }
                else {
                        throw new ParserException("Unknown join type " + type);
                }

                return l;
        }

        /**
         * Returns a location object which unlike the location constructors
         * allows you to input reverse coordinates and will convert
         * these into the right location on the positive strand.
         */
        public static Location location(int start, int end, Strand strand, int length) {
                int min = Math.min(start, end);
                //if this is true then we have a coord on the +ve strand even though Strand could be negative
                boolean isReverse = (min != start);
                if (isReverse) {
                        return new SimpleLocation(
                                        new SimplePoint(start).reverse(length),
                                        new SimplePoint(end).reverse(length),
                                        strand);
                }
                return new SimpleLocation(start, end, strand);
        }

        /**
         * Converts a location which defines the outer bounds of a circular
         * location and splits it into the required portions. Unlike any
         * other location builder this allows you to express your input
         * location on the reverse strand
         *
         * @param location The location which currently expresses the outer
         * bounds of a circular location.
         * @param length The length of the circular genomic unit
         * @return The circular location; can optionally return a normal non
         * circular location if the one you give is within the bounds of
         * the length
         */
        public static Location circularLocation(int start, int end, Strand strand, int length) {

                int min = Math.min(start, end);
                int max = Math.max(start, end);
                //Tells us we're dealing with something that's not _right_
                boolean isReverse = (min != start);

                if (min > length) {
                        throw new IllegalArgumentException("Cannot process a "
                                        + "location whose lowest coordinate is less than "
                                        + "the given length " + length);
                }

                //If max positon was less than length the return a normal location
                if (max <= length) {
                        return location(start, end, strand, length);
                }

                //Fine for forward coords (i..e start < end)
                int modStart = modulateCircularIndex(start, length);
                int modEnd = modulateCircularIndex(end, length);
                int numberOfPasses = completeCircularPasses(Math.max(start, end), length);

                if (isReverse) {
                        int reversedModStart = new SimplePoint(modStart).reverse(length).getPosition();
                        int reversedModEnd = new SimplePoint(modEnd).reverse(length).getPosition();
                        modStart = reversedModStart;
                        modEnd = reversedModEnd;
                        start = reversedModStart;
                        //+1 to number of passes to skip the run encoded by the start
                        end = (length * (numberOfPasses + 1)) + modEnd;
                }

                List<Location> locations = new ArrayList<Location>();
                locations.add(new SimpleLocation(modStart, length, strand));
                for (int i = 0; i < numberOfPasses; i++) {
                        locations.add(new SimpleLocation(1, length, strand));
                }
                locations.add(new SimpleLocation(1, modEnd, strand));
                return new SimpleLocation(new SimplePoint(start),
                                new SimplePoint(end), strand, true, false, locations);
        }

        private static interface LocationPredicate {
                boolean accept(Location previous, Location current);
        }

        /**
         * Scans through a list of locations to find the Location with the
         * lowest start
         */
        public static Location getMin(List<Location> locations) {
                return scanLocations(locations, new LocationPredicate() {
                        @Override
                        public boolean accept(Location previous, Location current) {
                                int res = current.getStart().compareTo(previous.getStart());
                                return res < 0;
                        }
                });
        }

        /**
         * Scans through a list of locations to find the Location with the
         * highest end
         */
        public static Location getMax(List<Location> locations) {
                return scanLocations(locations, new LocationPredicate() {
                        @Override
                        public boolean accept(Location previous, Location current) {
                                int res = current.getEnd().compareTo(previous.getEnd());
                                return res > 0;
                        }
                });
        }

        /**
         * Used for scanning through a list of locations; assumes the
         * locations given will have at least one value otherwise
         * we will get a null pointer
         */
        private static Location scanLocations(List<Location> locations, LocationPredicate predicate) {
                Location location = null;
                for (Location l : locations) {
                        if (location == null) {
                                location = l;
                        }
                        else {
                                if (predicate.accept(location, l)) {
                                        location = l;
                                }
                        }
                }
                return location;
        }

        /**
         * Takes a point on a circular location and moves it left until it falls
         * at the earliest possible point that represents the same base.
         *
         * @param index Index of the position to work with
         * @param seqLength Length of the Sequence
         * @return The shifted point
         */
        public static int modulateCircularIndex(int index, int seqLength) {
                // Dummy case
                if (seqLength == 0) {
                        return index;
                }
                // Modulate
                while (index > seqLength) {
                        index -= seqLength;
                }
                return index;
        }

        /**
         * Works in a similar way to modulateCircularLocation but returns
         * the number of complete passes over a Sequence length a circular
         * location makes i.e. if we have a sequence of length 10 and the
         * location 3..52 we make 4 complete passes through the genome to
         * go from position 3 to position 52.
         */
        public static int completeCircularPasses(int index, int seqLength) {
                int count = 0;
                while (index > seqLength) {
                        count++;
                        index -= seqLength;
                }
                return count - 1;
        }

        /**
         * Loops through the given list of locations and returns true if it looks
         * like they represent a circular location. Detection cannot happen if
         * we do not have consistent accessions
         */
        public static boolean detectCicular(List<Location> subLocations) {
                boolean isCircular = false;
                if(! consistentAccessions(subLocations))
                        return isCircular;

                int lastMax = 0;
                for (Location sub : subLocations) {
                        if (sub.getEnd().getPosition() > lastMax) {
                                lastMax = sub.getEnd().getPosition();
                        }
                        else {
                                isCircular = true;
                                break;
                        }
                }
                return isCircular;
        }

        /**
         * Scans a list of locations and returns true if all the given locations
         * are linked to the same sequence. A list of null accessioned locations
         * is the same as a list where the accession is the same
         *
         * @param subLocations The locations to scan
         * @return Returns a boolean indicating if this is consistently accessioned
         */
        public static boolean consistentAccessions(List<Location> subLocations) {
                Set<AccessionID> set = new HashSet<AccessionID>();
                for(Location sub: subLocations) {
                        set.add(sub.getAccession());
                }
                return set.size() == 1;
        }

        /**
         * Loops through the given list of locations and returns the consensus
         * Strand class. If the class switches then we will return an undefined
         * strand
         */
        public static Strand detectStrand(List<Location> subLocations) {
                Strand strand = subLocations.get(0).getStrand();
                for (Location sub : subLocations) {
                        if (strand != sub.getStrand()) {
                                strand = Strand.UNDEFINED;
                                break;
                        }
                }
                return strand;
        }

        /**
         * Assumes that the first element is the start & clones it
         */
        public static Point detectStart(List<Location> subLocations) {
                return subLocations.get(0).getStart().clonePoint();
        }

        /**
         * This will attempt to find what the last point is and returns that
         * position. If the location is circular this will return the total length
         * of the location and does not mean the maximum point on the Sequence
         * we may find the locations on
         */
        public static Point detectEnd(List<Location> subLocations, boolean isCircular) {
                int end = 0;
                Point lastPoint = null;
                if(isCircular) {
                        for (Location sub : subLocations) {
                                lastPoint = sub.getEnd();
                                end += lastPoint.getPosition();
                        }
                }
                else {
                        lastPoint = subLocations.get(subLocations.size()-1).getEnd();
                        end = lastPoint.getPosition();
                }
                return new SimplePoint(end, lastPoint.isUnknown(), lastPoint.isUncertain());
        }
}