/*
    * Copyright (C) 2007 Alf Mikula
    * 
    * This file is part of PromoteGo.
    *
    * PromoteGo 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.
   *
   * PromoteGo 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 PromoteGo.  If not, see <http://www.gnu.org/licenses/>.
   */
  package org.promotego.logic.storehours;
  
  import java.util.Collections;
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  
  import org.apache.commons.lang.math.IntRange;
  
  class WeeklyHours
  {
  	private static IntRangeComparator s_intRangeComparator = new IntRangeComparator();
  	
  	private List<IntRange> m_ranges;
  	
  	public WeeklyHours()
  	{
  		m_ranges = new LinkedList<IntRange>();
  	}
  	
  	public boolean isOpen(IntRange theRange)
  	{
  		if (theRange.getMinimumInteger() >= StoreHours.SECONDS_IN_WEEK)
  		{
  			throw new IllegalArgumentException("Range must begin with a number less than the number of seconds in a week");
  		}
  
  		if (theRange.getMaximumInteger() > StoreHours.SECONDS_IN_WEEK)
  		{
  			// Range needs to be split before checking
  			IntRange range1 = new IntRange(theRange.getMinimumInteger(), StoreHours.SECONDS_IN_WEEK);
  			
  			IntRange range2 = new IntRange(0, theRange.getMaximumInteger()-StoreHours.SECONDS_IN_WEEK);
  			return isOpen(range1) && isOpen(range2);
  		}
  		else
  		{
  			int searchResult = Collections.binarySearch(m_ranges, theRange, s_intRangeComparator);
  			
  			if (searchResult >= 0)
  			{
  				IntRange foundRange = m_ranges.get(searchResult);
  				
  				if (foundRange.containsRange(theRange))
  				{
  					return true;
  				}
  			}
  			
  			return false;
  		}
  	}
  	
  	public void addRange(IntRange theRange)
  	{
  		if (theRange.getMinimumInteger() >= StoreHours.SECONDS_IN_WEEK)
  		{
  			throw new IllegalArgumentException("Range must begin with a number less than the number of seconds in a week");
  		}
  
  		if (theRange.getMaximumInteger() > StoreHours.SECONDS_IN_WEEK)
  		{
  			// Range needs to be split before adding
  			IntRange range1 = new IntRange(theRange.getMinimumInteger(), StoreHours.SECONDS_IN_WEEK);
  			addRange(range1);
  			
  			IntRange range2 = new IntRange(0, theRange.getMaximumInteger()-StoreHours.SECONDS_IN_WEEK);
  			addRange(range2);
  		}
  		else
  		{
  			addRangeInternal(theRange);
  		}
  	}
  
  	/***
  	 * @param theRange
  	 */
  	private void addRangeInternal(IntRange theRange)
  	{
  		int searchResult = Collections.binarySearch(m_ranges, theRange, s_intRangeComparator);
 		
 		if (searchResult >= 0)
 		{
 			// The given range intersects with the range at the result index.
 			IntRange currentRange = m_ranges.get(searchResult);
 			if (currentRange.containsRange(theRange))
 			{
 				// Nothing to do: the range provided doesn't add any open time.
 			}
 			else if (theRange.containsRange(currentRange))
 			{
 				// Replace the range in the list with the new range
 				m_ranges.remove(searchResult);
 				m_ranges.add(searchResult, theRange);
 			}
 			else
 			{
 				// Create a new range with the minimum of the two minimums and the maximum of the two maximums.
 				int newMinimum = minimum(currentRange.getMinimumInteger(), theRange.getMinimumInteger());
 				int newMaximum = maximum(currentRange.getMaximumInteger(), theRange.getMaximumInteger());
 				IntRange newRange = new IntRange(newMinimum, newMaximum);
 				m_ranges.remove(searchResult);
 				m_ranges.add(searchResult, newRange);
 			}
 		}
 		else
 		{
 			// No intersection, and search has returned -(insertionPoint + 1)
 			int insertionPoint = -searchResult - 1;
 			m_ranges.add(insertionPoint, theRange);
 		}
 	}
 	
 	private int minimum(int a, int b)
 	{
 		if (a < b)
 		{
 			return a;
 		}
 		else
 		{
 			return b;
 		}
 	}
 	
 	private int maximum(int a, int b)
 	{
 		if (a > b)
 		{
 			return a;
 		}
 		else
 		{
 			return b;
 		}
 	}
 
 	public boolean equals(Object anotherObject)
 	{
 		if (!(anotherObject instanceof WeeklyHours))
 		{
 			return false;
 		}
 		
 		WeeklyHours otherHours = (WeeklyHours)anotherObject;
 		
 		if (m_ranges.size() != otherHours.m_ranges.size())
 		{
 			return false;
 		}
 		
 		// Because we merge ranges that overlap, and we maintain them in sorted
 		// order, there will be the same number of ranges in each list, and they
 		// will have exactly the same values and be listed in the same order.
 		Iterator<IntRange> myIterator = m_ranges.iterator();
 		Iterator<IntRange> otherIterator = otherHours.m_ranges.iterator();
 		while(myIterator.hasNext())
 		{
 			if (!myIterator.next().equals(otherIterator.next()))
 			{
 				return false;
 			}
 		}
 		
 		return true;
 	}
 	
 	public int hashCode()
 	{
 		int retval = 0;
 		
 		for (IntRange thisRange : m_ranges)
 		{
 			retval ^= thisRange.hashCode();
 		}
 		
 		return retval;
 	}
 }