/**
 * 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.model;

import java.io.Serializable;
import java.util.TreeSet;

/**
 * Extension of a TreeSet for holding COordinates ordered using their Comparator 
 * which orders Coordinate objects by the plus strand start, or the plus strand
 * end if the starts are identical.
 * Utility methods for this set take account of the DNA coordinate dogma that
 * there is no base 0 (ZERO) (i.e. ... -3,-2,-1,+1,+2,+3...).
 * 
 */
public class CoordinateSet extends TreeSet<Coordinate>  implements Serializable {

    /**
     * Public Constructor for a new Empty instance.
     */
    public CoordinateSet() {
    }

    /**
     * Returns the very first position of the first Coordinate in this CoordinateSet.
     * @return Integer
     */
    public Integer getStart() {
        Integer out = null;

        if ( !this.isEmpty()) {
            out = this.first().getStart();
        }

        return out;
    }

    /**
     * Returns the very last position of the last Coordinate in this CoordinateSet.
     * @return Integer
     */    
    public Integer getEnd() {
        Integer out = null;

        if ( !this.isEmpty()) {

            out = this.last().getEnd();

            //this check is incase the last Coorinate object does not have the 
            //highest end
            for (Coordinate c : this) {
             if (c.getEnd()>out) {
                 out = c.getEnd();
             }
            }
        }
         return out;
    }

    /**
     * Returns a Coordinate representing the extent or range of this CoordinateSet
     * @return Coordinate extent
     */
    public Coordinate getRange() {
         Coordinate out = null;
         if (  !this.isEmpty()) {

             out = new Coordinate(this.getStart(),this.getEnd() ,1);

         }
         return out;
     }
    
    /**
     * Returns the length of the extent/range of this CoordinateSet (accounting for 
     * any span of the absent ZERO).
     * @return Integer length
     */
    public Integer getLength() {
        return  this.getRange()!=null?this.getRange().getLength():0;
    }

    /**
     * Returns a CoordinateSet containing  Coordinates for all of the gaps in this 
     * CoordinateSet.
     * @todo may only be ok for positive coordinates that don't span zero!
     * @return CoordinateSet of gap Coordinates
     */
    public CoordinateSet getGaps(){
        CoordinateSet gaps = new CoordinateSet();
        
        if ( this.isEmpty() || this.getEnd() == null || this.getStart()==null ){
            return gaps;
        }
        
        //we search allong the set for gaps, without taking acount of the absence 
        //of ZERO until we come to make the gap coordinates - when we must shift left or right
        //to omit a ZERO
        
        Integer rangeEnd = this.getEnd();
        Integer currentPosition = this.getStart();

        for (Coordinate c : this) {
           
            if (c.getStart()==null || c.getEnd()==null) {
                continue;
            }

            Integer s = c.getStart();
            Integer e = c.getEnd();
            
            //if we're already past the extent of this region
            if (currentPosition>=e) {
                continue;
            }

            if (s>currentPosition) {
                
                //ignore a gap just between -1 and +1
                if (currentPosition == 0 && s==1) {
                    
                } 
                
                //do the hacking to omit point ZERO
                else {
                    Coordinate newC =null;
                    if (currentPosition == 0) {
                        newC = new Coordinate(1, s-1, 1);
                    } else if (s==1) {
                       newC = new Coordinate(currentPosition, -1, 1); 
                    } 
                    //no hacking necessary
                    else {
                        newC = new Coordinate(currentPosition, s-1, 1);
                    }    
                    gaps.add(newC);
                }
            }

            if (e>=rangeEnd) {
                break;
            }


            currentPosition = e+1;
        }
        return gaps;
    }

    /**
     * Returns whether a test Coordinate is contained in this CoordinateSet range WITHOUT any gaps.
     * @param test
     * @return Boolean
     */
    public Boolean containsCoordinateWithoutGaps(Coordinate test) {
        Boolean out = false;

        if (test.getStart()==null || test.getEnd()==null) {
            return false;
        }
        
        Integer testBegin = test.getStart();
        Integer testEnd = test.getEnd();

        if (testBegin<this.getStart() || testEnd>this.getEnd()) {
            out = false;
        } else if (this.getGaps().isEmpty()) {
            out = true;
        } else {

            out = true;
            for(Coordinate c: this.getGaps()) {
                if(test.overlaps(c)) {
                    out = false;
                    break;
                }
            }

        }
        return out;
    }

    /**
     * Returns the CoordinateSet  (ordered set of Coordinates) that define regions 
     * of the test Coordinate not represented (covered)  in this CoordinateSet.
     * Hopefully this handles the horror of test ranges spanning the non-existent zero point!
     * @param test
     * @return CoordinateSet
     */
    public CoordinateSet getUncoveredRegions(Coordinate test) {

        //not sure if this is the correct return for an invalid coordinate
        if (test.getStart()==null || test.getEnd()==null) {
            return null;
        }
        
        CoordinateSet gaps = new CoordinateSet();

        if (this.isEmpty()) {
            gaps.add(test);
            return gaps;
        }

        if (this.containsCoordinateWithoutGaps(test)) {
            //the empty set
            return gaps;
        }

        if (!this.getRange().overlaps(test)) {
            gaps.add(test);
            return gaps;
        }
       
        Integer testBegin = test.getStart();
        Integer testEnd = test.getEnd();
        Integer thisBegin = this.getStart();
        Integer thisEnd = this.getEnd();

        CoordinateSet thisGaps = this.getGaps();

        //overlap at start
        if (testBegin<thisBegin) {
            Coordinate newC = null; 
            if (thisBegin !=1) {
                newC = new Coordinate(testBegin, thisBegin-1, 1);
            } else {
                newC = new Coordinate(testBegin, -1, 1);
            }
            gaps.add(newC);
        }

        //overlap at end
        if (testEnd>thisEnd) {
            Coordinate newC2 = null;
            if (thisEnd!=-1 ) {
                    newC2 = new Coordinate(thisEnd+1, testEnd,  1);
            } else {
                newC2 = new Coordinate(1, testEnd,  1);
            }
            gaps.add(newC2);
        }

        for (Coordinate cd : thisGaps) {

            //this gap completely contains the test Coordinate
            if (test.liesWithinCoordinate(cd)) {
                gaps.add(test);
                break;
            }

            // this gap lies completely within the range
            else if (cd.liesWithinCoordinate(test)) {
                gaps.add(cd);
            }

            else if (cd.overlaps(test)) {

                gaps.add(cd.getOverlap(test));
            }

        }

        return gaps;
    }

}