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

/**
 * In general a Coordinate must have a non-null non-zero value for both start and end.
 * DNA coordinate systems are complicated by the absence of zero (i.e. ...-3,-2,-1,+1,+2,+3...).
 */
public class Coordinate implements Comparable<Coordinate>, Serializable {

    Integer start = null;//never allowed to be zero
    Integer end = null;// never allowed to be zero
    Strand strand = null;
    private Integer strandInt = null;

    /**
     * Parameterless constructor. Only to be used by for Mybatis (object mapping API) etc.
     * In general a Coordinate must have a non null non zero value for both start and end.
     */
    public Coordinate() {
    }

    /**
     * Utility constructor that takes start and stop integer positions with
     * no defined Strand.
     * ZERO and null locations are disallowed and will throw IllegalArgument RuntimeExceptions.
     * @param begin
     * @param stop 
     */
    public Coordinate(Integer begin , Integer stop) {
        this(begin, stop, 0);
    }

    /**
     * Utility constructor that takes start and stop integer positions and an 
     * Integer defining the Strand to be used (FORWARD_STRAND for '+1'
     * and REVERSE_STRAND for '-1' - otherwise NULL). ZERO and null locations are disallowed 
     * and will throw IllegalArgument RuntimeExceptions.
     * @param begin
     * @param stop
     * @param strandID 
     */
    public Coordinate(Integer begin, Integer stop, Integer strandID) {
        this(begin, stop, Strand.strand(strandID));
    }

    /**
     * Full constructor that takes start and stop integer positions and a
     * specified Strand (FORWARD_STRAND, REVERSE_STRAND,  otherwise NULL). 
     * ZERO and null locations are disallowed and will throw IllegalArgument RuntimeExceptions.
     * @param begin
     * @param stop
     * @param _strand 
     */
    public Coordinate(Integer begin, Integer stop, Coordinate.Strand _strand) {
        //disallow zero and null in a Coordinate
        if (begin==null || begin==0 ||
                stop==null || stop ==0) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }        
        if (begin <= stop) {
            start=begin;
            end = stop;
        } else {
            start=stop;
            end=begin;
        }               
        this.strand =_strand;
    }

    /**
     * Returns String representation in of format '1 - 5987 REVERSE_STRAND',  '1 - 5987 FORWARD_STRAND', '1 - 5987 UNSPECIFIED_STRAND' etc.
     * @return String representation of this Coordinate as 'start - stop (Strand)'
     */
    @Override
    public String toString() {
        String out = "";
        out += this.start + " - " + this.end + " ("
                + ((this.strand != null) ? this.strand.toString() : "UNSPECIFIED_STRAND") + ")";
        return out;
    }

    /**
     * Returns String representation in format '1 - 2345' etc.
     * @return String representation of this Coordinate as 'start - stop'
     */
    public String toShortString() {

        if (start != null && end != null && start.equals(end)) {
            return start.toString();
        } else {
            return this.start + " - " + this.end;
        }
    }

    /**
     * Public enumeration of the two alternate Strands, FORWARD and REVERSE.
     * In Ensembl these are represented as +1 and -1 respectively.
     * 
     * 5'--------------FORWARDS------------->3'
     * 
     * 3'&lt;-------------ESREVER---------------5'
     */
    public static enum Strand implements Serializable {

        FORWARD_STRAND,
        REVERSE_STRAND;

        /**
         * Static  Strand provider returns FORWARD_STRAND for '+1'
         * and REVERSE_STRAND for '-1' - otherwise NULL
         * @param i
         * @return Singleton Strand object 
         */
        public static Strand strand(Integer i) {
            if (i==null) {
                return null;
            } else if (i == 1) {
                return FORWARD_STRAND;
            } else if (i == -1) {
                return REVERSE_STRAND;
            } else {
                return null;
            }
        }
    }

    public Integer getStart() {
        return start;
    }

    public Integer getEnd() {
        return end;
    }

    public Strand getStrand() {
        return strand;
    }

    /**
     * public setter for the start of the Coordinate, will swap start and end if new start is more than the end. 
     * Use of ZERO (0) or null is disallowed and will throw an IllegalArgument RuntimeException. 
     * @param b 
     */    
    public void setStart(Integer b) throws IllegalArgumentException {
        if ( b==null || b==0 ) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }
        start=b;
        if (end==null) {
            end = b;
        }
        if (end<start) {
            start = end;
            end = b;
        } 
    }

    /**
     * public setter for the End of the Coordinate, will swap start and end if new end is less than start.
     * Use of ZERO (0) or null is disallowed and will throw an IllegalArgument RuntimeException.
     * @param e 
     */
    public void setEnd(Integer e) throws IllegalArgumentException {
        if (e==null || e==0 ) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }     
        end = e;
        if (start==null){
            start = e;
        }
        if (end<start) {
            end = start;
            start = e; 
        }
    }
    
    /**
     * public setter for the start and end of the Coordinate, will swap start and end if  end is less than start.
     * Use of ZERO (0) or null is disallowed and will throw an IllegalArgument RuntimeException.
     * @param b
     * @param e 
     */
    public void setValues(Integer b, Integer e) {
        if (e==null || e==0 || b==null || b==0 ) {
            throw new IllegalArgumentException("The position 0 is meaningless in the Ensembl DNA world."
                    +" Use -1 for one base upstream or +1 for the first base.");
        }   
        if (b<e) {
            start = b;
            end = e;
        } else {
            start = e; 
            end = b;
        }
        
    }

    public void setStrand(Strand s) {
        strand = s;
    }

    /**
     * Utility method to set the Strand using an Integer (FORWARD_STRAND for '+1'
     * and REVERSE_STRAND for '-1' - otherwise NULL).
     * @param s 
     */
    public void setStrandInt(Integer s) {
        strandInt = s;
        strand = Coordinate.Strand.strand(s);
    }

    public Integer getStrandInt() {
        return strandInt;
    }

    /**
     * Returns the length of this Coordinate - taking into consideration whether 
     * the range spans the 'absent' Zero. 
     * @return span length of the coordinate
     */
    public Integer getLength() {
        //an unitialized Coordinate has no length
        if (this.getStart()==null || this.getEnd()==null) {
            return null;
        }
        // a single base
        if (this.getStart()==this.getEnd()) {
            return 1;
        }
        //if coordinates totally -ive or totally +ive
        if (this.getEnd()<1 || this.getStart()>0) {
            return this.getEnd()-this.getStart()+1;
        } 
        //coordinates span the -1/+1 junction
        else {
            return this.getEnd()-this.getStart();
        }
    }

   /**
    * Implements compareTo(another Coordinate) method for the Comparable interface.
    * It orders Coordinate objects by the plus strand start, or the plus strand
    * end if the starts are identical. If two Coordinates start at the same position, 
    * the the longer one is put first, this has consequences for getting the end coordinate of a set.
    * Zero (0) != Identity because the comparison doesn't consider the strand, just the order.
    * NB. Take care with Integer comparisons. 
    * @param o the compared other Coordinate
    * @return -1 if this object is upstream of 'o', 1 if downstream of 'o', 0 if coincident or not comparable
    */
    @Override
    public int compareTo(Coordinate o) {

        //dont compare if any nulls
        if (this.start == null || this.end == null
                || o.getStart() == null || o.getEnd() == null) {
            return 0;
        }


        if (!this.start.equals(o.getStart())) {

            if (this.start.compareTo(o.getStart()) < 0) {
                return -1;
            } else {
                return 1;
            }

        } else {
            //put the longest one first
            //this has consequences for getting the end coordinate of a set
            if (this.end.compareTo(o.getEnd()) < 0) {
                return 1;
            } else if (this.end.compareTo(o.getEnd()) > 0) {
                return -1;
            } else {
                //the coordinates are identical
                return 0;
            }
        }
    }

    /**
     * Tests whether this Coordinate lies TOTALLY within the range of another test Coordinate.
     * @param test
     * @return Boolean 
     */
    public Boolean liesWithinCoordinate(Coordinate test) {
        Boolean out = false;

        //dont compare if any nulls
        if (test.getStart() == null || test.getEnd() == null
                || this.start == null || this.end == null) {
            return out;
        }

        if (this.start >= test.getStart() && this.end <= test.getEnd()) {
            out = true;
        }

        return out;
    }

    /**
     * Returns whether this Coordinate overlaps with the extent of a test Coordinate.
     * @param test
     * @return Boolean
     */
    public Boolean overlaps(Coordinate test) {

        boolean out = false;

        //dont compare if any nulls
        if (this.start == null || this.end == null || test.getEnd() == null || test.getStart() == null) {
            out = false;
        } else if ((this.liesWithinCoordinate(test)) || (test.liesWithinCoordinate(this))
                || (this.start <= test.getStart() && this.end >= test.getStart())
                || (this.end >= test.getEnd() && this.start <= test.getEnd())) {
            out = true;
        }

        return out;
    }

    /**
     * Returns the overlap extent (as a Coordinate) between this Coordinate and a test Coordinate.
     * @param test
     * @return Coordinate
     */
    public Coordinate getOverlap(Coordinate test) {

        Coordinate out = null;
        Integer testStart = test.getStart();
        Integer testEnd = test.getEnd();

        //dont compare if any nulls, or if there is no overlap
        if (this.start == null || this.end == null || test.getEnd() == null || test.getStart() == null
                || !this.overlaps(test)) {
            out = null;
        } else {
            if (this.start >= test.getStart() && this.start <= test.getEnd()) {
                testStart = this.start;
            }
            if (this.end >= test.getStart() && this.end <= test.getEnd()) {
                testEnd = this.end;
            }
            out = new Coordinate(testStart, testEnd, 1);
        }

        return out;
    }

    
    public Boolean containsPoint(Integer point) {
        if (this.start==null || this.end==null || point==null) {
            return false;
        }
        return (this.start<=point && this.end>=point);
    }
}