/*
    * 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.ArrayList;
  import java.util.Arrays;
  import java.util.Collection;
  import java.util.Collections;
  import java.util.HashSet;
  import java.util.LinkedList;
  import java.util.List;
  import java.util.Set;
  
  import org.apache.commons.lang.math.IntRange;
  
  /***
   * A single specification of store hours, featuring hours for one day or
   * same hours for a set of days.  Generates IntRange objects representing
   * the start and end seconds on a weekly schedule, and also contains helper
   * methods for merging multiple days' schedules into a single HourSpecification
   * object for nicer printing.
   * 
   * @author alf
   */
  public class HourSpecification
  {
  	private static int SECONDS_IN_DAY = 24*3600;
  	private static IntRangeComparator s_intRangeComparator = new IntRangeComparator();
  
  	/***
  	 * There are only 7 days, so having an initial size of 10 and default
  	 * load factor of 0.75 means we can hold all 7 days without resizing
  	 * the set's hash table.
  	 */
  	private Set<Day> m_days = new HashSet<Day>(10);
  	private List<IntRange> m_ranges = new ArrayList<IntRange>(2);
  	
  	private HourSpecification()
  	{ }
  	
  	public HourSpecification(String stringSpec)
  	{
  		String [] components = stringSpec.split(" +");
  		if (components.length != 2)
  		{
  			throw new IllegalArgumentException("Wrong number of space-separated tokens in string: " + stringSpec);
  		}
  		
  		String [] dayRanges = components[0].split(",");
  		for (String thisRange : dayRanges)
  		{
  			addDayRange(thisRange);
  		}
  		
  		String [] hourRanges = components[1].split(",");
  		for (String thisRange : hourRanges)
  		{
  			// Get base range from hours string
  			IntRange theBaseRange = getRange(thisRange);
  			
  			addHourRange(theBaseRange);
  		}
  	}
  	
  	public HourSpecification(Collection<Day> days, List<IntRange> ranges)
  	{
  		m_days.addAll(days);
  		for (IntRange thisRange : ranges)
  		{
  			addHourRange(thisRange);
  		}
  	}
  
  	/***
  	 * @param dayRange
  	 */
  	private void addDayRange(String dayRange)
  	{
  		// Split on dash to get day range.
  		String [] days = dayRange.split("-");
  		if (days.length > 2)
  		{
  			throw new IllegalArgumentException("Too many dash-separated days in string: " + dayRange);
 		}
 		
 		// Resolve the start day
 		Day startResult = Day.mapAbbreviation(days[0]);
 		if (startResult == null)
 		{
 			throw new IllegalArgumentException("Illegal day string: " + days[0]);
 		}
 		
 		int startDay = startResult.ordinal();
 		
 		// Resolve the end day, if present.
 		int endDay;
 		if (days.length > 1)
 		{
 			Day endResult = Day.mapAbbreviation(days[1]);
 			if (endResult == null)
 			{
 				throw new IllegalArgumentException("Illegal day string: " + days[1]);
 			}
 			
 			endDay = endResult.ordinal();
 		}
 		else
 		{
 			endDay = startDay;
 		}
 
 		// We'll calculate day modulo 7 below to keep it 0-6.
 		if (endDay < startDay)
 		{
 			endDay += 7;
 		}
 		
 		for (int theDay = startDay; theDay <= endDay; theDay++)
 		{
 			m_days.add(Day.values()[theDay%7]);
 		}
 	}
 	
 	/***
 	 * @param theRange
 	 */
 	private void addHourRange(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;
 		}
 	}
 
 	/***
 	 * Given a range of hours in format HH[:MM]-HH[:MM], return an <code>IntRange</code>
 	 * representing the time in seconds of the hours given.  Hours are in 24-hour format,
 	 * and an end time before the start time represents an end time the next day, such
 	 * as 9-1:30, meaning the store closes at 1:30 am the following morning.
 	 * 
 	 * @param string The hours to parse, in format HH[:MM]-HH[:MM].
 	 * @return An <code>IntRange</code> representing the start and end times in seconds.
 	 */
 	private IntRange getRange(String hourRange)
 	{
 		String [] hours = hourRange.split("-");
 		
 		if (hours.length != 2)
 		{
 			throw new IllegalArgumentException("Illegal hour range string: " + hourRange);
 		}
 		
 		int startHour = toSeconds(hours[0]);
 		int endHour = toSeconds(hours[1]);
 		if (endHour <= startHour)
 		{
 			// Strings like 10:00-1:30 represent a closing time the following morning.
 			endHour += SECONDS_IN_DAY;
 		}
 		
 		return new IntRange(startHour, endHour);
 	}
 
 	/***
 	 * Returns the time in seconds since midnight represented by the <code>String</code> passed in.
 	 * 
 	 * @param string A time, in HH:MM format.
 	 * @return The time in seconds since midnight.
 	 */
 	private int toSeconds(String string)
 	{
 		String [] components = string.split(":");
 		
 		if (components.length > 2)
 		{
 			throw new IllegalArgumentException("Illegal hour string: " + string);
 		}
 		
 		int retval;
 		
 		try
 		{
 			int hour = Integer.parseInt(components[0]);
 			retval = hour*3600;
 			if (components.length > 1)
 			{
 				int minutes = Integer.parseInt(components[1]);
 				retval += minutes*60;
 			}
 		} catch (NumberFormatException e)
 		{
 			throw new IllegalArgumentException("Illegal hour string: " + string);
 		}
 
 		return retval;
 	}
 
 	@Override
 	public boolean equals(Object obj)
 	{
 		if (obj == this)
 		{
 			return true;
 		}
 		
 		if (!(obj instanceof HourSpecification))
 		{
 			return false;
 		}
 		
 		HourSpecification otherSpec = (HourSpecification) obj;
 		return m_days.equals(otherSpec.m_days) && m_ranges.equals(otherSpec.m_ranges);
 	}
 
 	@Override
 	public int hashCode()
 	{
 		return m_days.hashCode() ^ m_ranges.hashCode();
 	}
 	
 	@Override
 	public String toString()
 	{
 		return getDaysString() + " " + getHoursString();
 	}
 	
 	private String getDaysString()
 	{
 		List<IntRange> daysList = new LinkedList<IntRange>();
 		
 		Day [] days = m_days.toArray(new Day[m_days.size()]);
 		Arrays.sort(days);
 		Day startDay = null;
 		Day endDay = null;
 		for (Day thisDay : days)
 		{
 			if (startDay == null)
 			{
 				// Initialization
 				startDay = thisDay;
 				endDay = thisDay;
 			}
 			else
 			{
 				if (thisDay.ordinal() - endDay.ordinal() > 1)
 				{
 					// Current day breaks the range.
 					// enter previous range
 					daysList.add(new IntRange(startDay.ordinal(), endDay.ordinal()));
 					
 					// Start a new range
 					startDay = thisDay;
 					endDay = thisDay;
 				}
 				else
 				{
 					// Still building the range.  Add the current day.
 					endDay = thisDay;
 				}
 			}
 		}
 		
 		// Enter the range that was being built when the loop terminated.
 		assert (startDay != null && endDay != null) : "HourSpecification must have at least one day";
 		
 		daysList.add(new IntRange(startDay.ordinal(), endDay.ordinal()));
 		
 		StringBuilder retval = new StringBuilder(12);
 		if (daysList.size() >= 2 && daysList.get(0).getMinimumInteger() == 0
 				&& daysList.get(daysList.size()-1).getMaximumInteger() == 6)
 		{
 			// First range starts with Sunday and last range ends with Saturday.  Merge them.
 			IntRange lastRange = daysList.remove(daysList.size() - 1);
 			IntRange firstRange = daysList.remove(0);
 			
 			retval.append(Day.values()[lastRange.getMinimumInteger()].getAbbreviation());
 			retval.append("-");
 			retval.append(Day.values()[firstRange.getMaximumInteger()].getAbbreviation());
 		}
 		
 		// Now iterate through the rest of the ranges.
 		for (IntRange thisRange : daysList)
 		{
 			if (retval.length() > 0)
 			{
 				retval.append(",");
 			}
 			
 			startDay = Day.values()[thisRange.getMinimumInteger()];
 			endDay = Day.values()[thisRange.getMaximumInteger()];
 			retval.append(startDay.getAbbreviation());
 			if (!startDay.equals(endDay))
 			{
 				retval.append("-");
 				retval.append(endDay.getAbbreviation());
 			}
 		}
 		
 		return retval.toString();
 	}
 	
 	private String getHoursString()
 	{
 		StringBuilder retval = new StringBuilder(16);
 		
 		for (IntRange thisRange : m_ranges)
 		{
 			if (retval.length() > 0)
 			{
 				retval.append(",");
 			}
 			
 			retval.append(toHourString(thisRange.getMinimumInteger()));
 			retval.append("-");
 			retval.append(toHourString(thisRange.getMaximumInteger()));
 		}
 		
 		return retval.toString();
 	}
 
 	/***
 	 * @param minimumInteger
 	 * @return
 	 */
 	private String toHourString(int minimumInteger)
 	{
 		// Size to hold HH:MM
 		StringBuilder retval = new StringBuilder(5);
 		int hour = minimumInteger/3600;
 		if (hour >= 24)
 		{
 			hour -= 24;
 		}
 		retval.append(hour);
 		
 		int leftoverSeconds = minimumInteger%3600;
 		if (leftoverSeconds > 60)
 		{
 			retval.append(":");
 			retval.append(leftoverSeconds/60);
 		}
 		return retval.toString();
 	}
 	
 	public boolean sameDays(HourSpecification otherSpec)
 	{
 		return m_days.equals(otherSpec.m_days);
 	}
 	
 	public boolean sameHours(HourSpecification otherSpec)
 	{
 		return m_ranges.equals(otherSpec.m_ranges);
 	}
 
 	/***
 	 * Return a new HourSpecification with all days and hour ranges of this
 	 * HourSpecification and the one provided.  This operation is idempotent
 	 * with respect to both HourSpecification objects used to calculate the
 	 * new HourSpecification.
 	 * 
 	 * @param otherSpec
 	 * @return
 	 */
 	public HourSpecification mergeWith(HourSpecification otherSpec)
 	{
 		HourSpecification retval = new HourSpecification();
 		
 		retval.m_days.addAll(m_days);
 		retval.m_days.addAll(otherSpec.m_days);
 		
 		retval.m_ranges.addAll(m_ranges);
 		for (IntRange thisRange : otherSpec.m_ranges)
 		{
 			retval.addHourRange(thisRange);
 		}
 		
 		return retval;
 	}
 	
 	public Set<Day> getDays()
 	{
 		return new HashSet<Day>(m_days);
 	}
 	
 	public List<IntRange> getSecondRanges()
 	{
 		return new ArrayList<IntRange>(m_ranges);
 	}
 }