OOP2

import java.util.Date;

import java.util.Map;

import java.util.HashMap;

import java.time.DateTimeException;

/**

 * Class representing a bed in the hostel.

 * Even though beds in a hostel could simply be an integer in a Room, these Beds

 * need to remember on what dates they are reserved.

 * @author Maarten Vangeneugden - 1438256

 */

public class Bed {

	/* Rationale:

	 * I know that a mapping is not necessarily the best solution for storing

	 * periods, because it doesn't offer built-in protection yadda yadda.

	 * However, that's Java's fault, as it doesn't provide a Pair<L,R> thing in

	 * the STL.

	 * The best solution is actually a collection of tuples: (Begin, End), but

	 * that doesn't exist in Java, and thus requires a custom implementation.

	 * All things considered, a Map is the least bad choice.

	 */

	private Map<Date, Date> reservedPeriods;

	public Bed() {

		this.reservedPeriods = new HashMap<>();

	}

	/**

	 * Reserves this Bed for the given period.

	 * This method will mark the given period for this Bed as "reserved", which

	 * can then be cancelled or queried later.

	 * @param begin The time where the reservation begins.

	 * @param end The time where the reservation ends.

	 * @pre No parameter may be a null pointer.

	 * @pre The given period mustn't overlap with a period already marked as

	 * reserved.

	 * @pre begin must come before end.

	 * @pre begin and end mustn't be equal.

	 * @post The given period will be marked as "Reserved", and will have to be

	 * manually cancelled/removed in order to reserve again.

	 * @throws NullPointerException if any parameter is a null pointer.

	 * @throws IllegalArgumentException if begin is equal to, or comes after

	 * end.

	 * @throws DateTimeException if the given period overlaps with an already

	 * reserved period.

	 */

	public void reservePeriod(Date begin, Date end) {

		if(!begin.before(end)) {

			throw new IllegalArgumentException("The begin date occurs after the end date.");

		}

		if(!this.isFree(begin, end)) {

			throw new DateTimeException("This period overlaps with a reserved period.");

		}

		// Contract validated, execute method

		this.reservedPeriods.put(begin, end);

	}

	/**

	 * Remove a previous registration from this Bed.

	 * This method will remove/cancel the given reservation period from the

	 * Bed, opening it up for reservation again.

	 * @param begin The time where the reservation begins.

	 * @param end The time where the reservation ends.

	 * @pre No parameter may be a null pointer.

	 * @pre The given period must already be marked as "Reserved" in this Bed.

	 * @pre begin must come before end.

	 * @pre begin and end mustn't be equal.

	 * @post The given period will lose its "Reserved" mark, allowing the period

	 * to be reserved again.

	 * @throws NullPointerException if any parameter is a null pointer.

	 * @throws IllegalArgumentException if begin is equal to, or comes after

	 * end; or, if the given period is not reserved.

	 */

	public void removeReservationPeriod(Date begin, Date end) {

		if(!begin.before(end)) {

			throw new IllegalArgumentException("The begin date occurs after the end date.");

		}

		if(!this.isFree(begin, end)) {

			throw new DateTimeException("This period overlaps with a reserved period.");

		}

		// Contract partially validated; further validation occurs while looking

		// for the reservation.

		// XXX: Check if Java correctly handles equality: 2 different Date

		// objects with the same date representation should be equal!

		boolean reservationFound = this.reservedPeriods.remove(begin, end);

		if(!reservationFound) {

			throw new IllegalArgumentException("The given period was not marked as reserved.");

		}

	}

	/**

	 * Checks whether this Bed can be reserved in the given period.

	 * Use this method whenever you need to inform yourself about any

	 * conflicting reservation period.

	 * @param begin The time where the reservation begins.

	 * @param end The time where the reservation ends.

	 * @pre No parameter must be a null pointer.

	 * @pre begin must come before end.

	 * @pre begin and end mustn't be equal.

	 * @throws NullPointerException if any parameter is a null pointer.

	 * @throws IllegalArgumentException if begin is equal to, or comes after

	 * end.

	 * @return True if the given period does not overlap with any reservation, false otherwise.

	 */

	public boolean isFree(Date begin, Date end) {

		if(!begin.before(end)) {

			throw new IllegalArgumentException("The begin date occurs after the end date.");

		}

		// Contract validated, execute method

		for(Map.Entry<Date, Date> reservedPeriod: this.reservedPeriods.entrySet()) {

			Date reservedBegin = reservedPeriod.getKey();

			Date reservedEnd = reservedPeriod.getValue();

			/* Forbidden possibilities:

			 * (A,B = reserved; X,Y = requested)

			 * X-A-Y-B / A-X-B-Y  -  Begins or ends in a reserved period

			 * X-A-B-Y  -  Complete overlapping of reserved period

			 * Allowed possibilities:

			 * A-B-X-Y / X-Y-A-B  -  No overlapping

			 */

			if((begin.after(reservedBegin) && begin.before(reservedEnd)) ||

			   (end.after(reservedBegin) && end.before(reservedEnd))) {

				// Triggered if any forbidden structure is detected

				return false;

			}

		}

		return true; // No overlapping found

	}

	/**

	 * Checks whether this Bed has open reservation periods.

	 * @return True if this Bed has reserved periods, false otherwise.

	 */

	public boolean hasReservations() {

		return !this.reservedPeriods.isEmpty();

	}

}