/***
    *     Ambient - A music player for the Android platform
    Copyright (C) 2007 Martin Vysny
    
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
    
   This program 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
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
   */
  package sk.baka.ambient.commons;
  
  import java.util.Iterator;
  
  /***
   * Specifies an integer index interval. Immutable. Iterator simply iterates over
   * indices contained in this interval.
   * 
   * @author Martin Vysny
   */
  public final class Interval implements Iterable<Integer> {
  	/***
  	 * Index of first item in the interval.
  	 */
  	public final int start;
  
  	/***
  	 * Number of successive items in the interval.
  	 */
  	public final int length;
  
  	/***
  	 * Checks if at least a single item is in the interval.
  	 * 
  	 * @return <code>false</code> if at least single item is in the interval,
  	 *         <code>true</code> otherwise.
  	 */
  	public boolean isEmpty() {
  		return length == 0;
  	}
  
  	/***
  	 * Checks if given item is contained in the interval.
  	 * 
  	 * @param index
  	 *            index of item
  	 * @return <code>true</code> if the item belongs to the interval.
  	 */
  	public boolean contains(int index) {
  		return (index >= start) && (index <= end);
  	}
  
  	/***
  	 * Checks if given interval is contained in the interval.
  	 * 
  	 * @param other
  	 *            the other interval
  	 * @return <code>true</code> if given interval belongs to the interval.
  	 */
  	public boolean contains(final Interval other) {
  		return (other.start >= start) && (other.end <= end);
  	}
  
  	/***
  	 * Creates new interval.
  	 * 
  	 * @param start
  	 *            Index of first item in the interval.
  	 * @param length
  	 *            Number of successive items in the interval.
  	 */
  	public Interval(final int start, final int length) {
  		super();
  		if (length < 0)
  			throw new IllegalArgumentException("length must not be negative");
  		if (start < 0)
  			throw new IllegalArgumentException("start must not be negative");
  		this.start = start;
  		this.length = length;
  		this.end = start + length - 1;
  	}
  
  	/***
  	 * An empty interval.
  	 */
  	public static final Interval EMPTY = new Interval(0, 0);
  
  	/***
  	 * Creates given interval. The interval includes both endpoints.
  	 * 
  	 * @param intervalStart
  	 *            start of interval
 	 * @param intervalEnd
 	 *            end of interval
 	 * @return interval which includes both endpoints.
 	 */
 	public static Interval fromRange(int intervalStart, int intervalEnd) {
 		if (intervalEnd < intervalStart) {
 			return new Interval(intervalEnd, intervalStart - intervalEnd + 1);
 		}
 		return new Interval(intervalStart, intervalEnd - intervalStart + 1);
 	}
 
 	/***
 	 * Returns interval which contains only a single item.
 	 * 
 	 * @param itemIndex
 	 *            the item index.
 	 * @return interval containing only a single item.
 	 */
 	public static Interval fromItem(final int itemIndex) {
 		return fromRange(itemIndex, itemIndex);
 	}
 
 	@Override
 	public boolean equals(Object o) {
 		if (!(o instanceof Interval))
 			return false;
 		final Interval other = (Interval) o;
 		if (isEmpty() && other.isEmpty())
 			return true;
 		return (start == other.start) && (length == other.length);
 	}
 
 	@Override
 	public int hashCode() {
 		if (length == 0)
 			return 0;
 		int hashcode = start;
 		hashcode = hashcode * 4107 + length;
 		return hashcode;
 	}
 
 	@Override
 	public String toString() {
 		if (isEmpty())
 			return "<empty>";
 		return "<" + start + ".." + end + ">";
 	}
 
 	/***
 	 * Index of last item in the interval.
 	 */
 	public final int end;
 
 	public Iterator<Integer> iterator() {
 		return new Iterator<Integer>() {
 			private int i = start;
 
 			public boolean hasNext() {
 				return i <= end;
 			}
 
 			public Integer next() {
 				return i++;
 			}
 
 			public void remove() {
 				throw new UnsupportedOperationException();
 			}
 		};
 	}
 
 	/***
 	 * Checks if given index is an endpoint of this interval (i.e. it is minimal
 	 * or maximal index still belonging to this interval).
 	 * 
 	 * @param i
 	 *            the index to check
 	 * @return <code>true</code> if given index is an endpoint,
 	 *         <code>false</code> otherwise.
 	 */
 	public boolean isEndpoint(final int i) {
 		return (i == start) || (i == end);
 	}
 
 	/***
 	 * Compares this interval to the interval specified by two integers.
 	 * 
 	 * @param start
 	 *            the first end of the interval
 	 * @param end
 	 *            the second end of the interval
 	 * @return <code>true</code> if two intervals contain the same items,
 	 *         <code>false</code> otherwise.
 	 */
 	public boolean equals(int start, int end) {
 		if (start < end) {
 			return (this.start == start) && (this.end == end);
 		}
 		return (this.end == start) && (this.start == end);
 	}
 
 	/***
 	 * Checks if given interval covers items at the beginning of this interval.
 	 * 
 	 * @param other
 	 *            the other interval
 	 * @return <code>true</code> if other interval covers items at the
 	 *         beginning of this interval.
 	 */
 	public boolean startsWith(final Interval other) {
 		if (other.isEmpty())
 			return false;
 		return (this.start == other.start) && (this.end >= other.end);
 	}
 
 	/***
 	 * Checks if given interval covers items at the end of this interval.
 	 * 
 	 * @param other
 	 *            the other interval
 	 * @return <code>true</code> if other interval covers items at the
 	 *         end of this interval.
 	 */
 	public boolean endsWith(final Interval other) {
 		if (other.isEmpty())
 			return false;
 		return (this.end == other.end) && (this.start <= other.start);
 	}
 
 	/***
 	 * Subtracts given interval from this one and returns result.
 	 * 
 	 * @param other
 	 *            the interval to subtract
 	 * @return an Interval instance if result is a single interval, an array of
 	 *         intervals otherwise.
 	 */
 	public Object subtract(final Interval other) {
 		if (start < other.start) {
 			if (end < other.start) {
 				return this;
 			}
 			if (end <= other.end) {
 				return Interval.fromRange(start, other.start - 1);
 			}
 			return new Interval[] { Interval.fromRange(start, other.start - 1),
 					Interval.fromRange(other.end + 1, end) };
 		} else if (start == other.start) {
 			if (end <= other.end) {
 				return Interval.EMPTY;
 			}
 			return Interval.fromRange(other.end + 1, end);
 		} else {
 			if (start > other.end) {
 				return this;
 			}
 			if (end > other.end) {
 				return Interval.fromRange(other.end + 1, end);
 			}
 			return Interval.EMPTY;
 		}
 	}
 }