OOP2

import java.util.Set;

import java.util.HashSet;

import java.util.Date;

/**

 * Controller class for the Reservations of this program.

 * Since this program handles a youth hostel, it's imperative that it holds a

 * number of Reservations.

 * 

 * ReservationController takes the responsibility of handling the addition,

 * cancelling, editing, ... of Reservations, and the related tasks inherent to

 * these responsibilities, such as reserving beds, generating IDs, ...

 * @author Maarten Vangeneugden - 1438256

 */

public class ReservationController {

	/* Rationale:

	 * Normally I'd put this as an interface (Set), but an interface does not

	 * inherit from Object, and thus, does not provide clone(). This is

	 * necessary, because otherwise, there's no point in having private

	 * members.

	 */

	private HashSet<Reservation> reservations; // Holds all Reservations

	private RoomController roomController;

	/**

	 * Creates the ReservationController.

	 * @param roomController The RoomController of the system.

	 * @pre roomController mustn't be null.

	 * @throws NullPointerException if roomController is null.

	 */

	public ReservationController(RoomController roomController) {

		if(roomController == null)

			throw new NullPointerException("roomController mustn't be a null pointer.");

		this.reservations = new HashSet<>();

		this.roomController = roomController;

	}

	/**

	 * Returns a copy of all Reservations.

	 * Emphasis on "copy"; There is no setReservations() for a reason, using

	 * this to edit the pointer variable would omit the use of 'private'.

	 * @return A verbatim copy of all Reservations.

	 */

	@SuppressWarnings("unchecked")

	public Set<Reservation> getReservations() {

		return (HashSet<Reservation>)this.reservations.clone();

	}

	/**

	 * Generates a unique ID for a new Reservation.

	 * This method is to be called when a new Reservation is to be stored.

	 * As every Reservation carries an ID, this method searches for a unique

	 * one, and returns it.

	 * @return An integer, different from all other stored Reservation IDs.

	 */

	public int generateReservationID() {

		/* Small optimization idea:

		 * Instead of starting from 0, and incrementing until it's unique, it

		 * will take the amount of stored Reservations, and test that as an ID.

		 * This may still overlap (by removing an older Reservation), but may be

		 * much faster. Consider implemting and testing for effectiveness if

		 * generating an ID takes too long.

		 */

		int ID = 0;

		boolean isUnique = false;

		do {

			ID++;

			isUnique = true;

			for(Reservation reservation: this.reservations) {

				if(ID == reservation.getReservationID()) {

					isUnique = false;

				}

			}

		} while(!isUnique);

		// Test:

		for(Reservation reservation: this.reservations) {

			assert reservation.getReservationID() != ID : "Duplicate ID generated!";

		}

		return ID;

	}

	/** 

	 * Check if Reservation can be made.

	 * Call this method whenever you're planning on adding a new Reservation. It

	 * will check the provided requirements (Room facilities, for example), and

	 * return whether this Reservation can continue.

	 *

	 * This method is deprecated. Use RoomController directly.

	 * @see RoomController.getQualifiedRoom

	 * @param reservation The Reservation to check for possible addition.

	 * @pre reservation mustn't be null.

	 * @throws NullPointerException if reservation is null.

	 * @return True if reservation can be added, False otherwise.

	 */

	@Deprecated

	public boolean checkReservation(Reservation reservation) {

		if(reservation == null) {

			throw new NullPointerException("reservation was a null pointer.");

		}

		if(this.roomController.getQualifiedRoom(reservation) == null) {

			return false;

		}

		return true;

	}

	/**

	 * Adds and confirms the reservation.

	 * By calling this method, the given reservation will be stored in the

	 * system, and the given room will be filled.

	 * You are to collect the necessary data, and assure yourself that all

	 * preconditions have been met.

	 * 

	 * The best way to accomplish this, is to only send 'sterile' Reservations

	 * as the first parameter. That is: Reservations without reserved Beds,

	 * without prior addition to the active Reservations, etc.

	 * NOTE: You must check for yourself if the Reservation can take place in

	 * this Room! If there are not enough Beds available, an exception will be

	 * thrown.

	 * @param reservation The Reservation to add.

	 * @param room The Room in which the people will reside.

	 * @pre room must have enough empty beds.

	 * @pre room must accomodate the Reservation's requirements.

	 * @pre No parameter must be null.

	 * @pre reservation mustn't already be stored in the active Reservations.

	 * @post reservation is stored in the active Reservations.

	 * @post The Beds in the provided Room are reserved for the Reservation's

	 * period.

	 * @throws IllegalArgumentException if the given Room can't fulfill the

	 * requirements of the Reservation, or occupants is less than 1.

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

	 */

	public void addReservation(Reservation reservation, Room room) {

		// Contract validation. Null pointers are implicitely checked by calling

		// methods.

		if(!this.roomController.getQualifiedRooms(reservation).contains(room))

			throw new IllegalArgumentException("The given Room cannot meet all requirements of the Reservation.");

		if(this.getReservations().contains(reservation))

			throw new IllegalArgumentException("The given Reservation was already included in the active Reservations.");

		// Contract validated

		// Acquire unique ID:

		reservation.setReservationID(this.generateReservationID());

		// Fill the required beds

		Bed[] beds = room.getEmptyBeds(reservation.getBeginDate(), reservation.getEndDate()).toArray(new Bed[1]);

		Set<Bed> reservedBeds = new HashSet<>();

		for(int i=0; i<reservation.getPeople(); i++) {

			beds[i].reservePeriod(reservation.getBeginDate(), reservation.getEndDate());

			reservedBeds.add(beds[i]);

		}

		reservation.setReservedBeds(reservedBeds);

		// Finally, add the Reservation to the system

		this.reservations.add(reservation);

	}

	/**

	 * Cancels and removes the given Reservation.

	 * If you want to remove a Reservation, use this method, and provide the

	 * Reservation up for removal.

	 * This method will take care of related actions, such as releasing Beds.

	 * @param reservation The Reservation to be removed.

	 * @pre reservation mustn't be null.

	 * @pre reservation must be contained in the active Reservations.

	 * @post The Reservation is removed from the active Reservations.

	 * @post The Beds, previously reserved for this Reservation, are now

	 * released, and can be reserved for another Reservation.

	 * @throws NullPointerException if reservation is a null pointer.

	 * @throws IllegalArgumentException if reservation is not contained in the

	 * active Reservations.

	 */

	public void cancelReservation(Reservation reservation) {

		// Contract validation

		if(!this.getReservations().contains(reservation)) {

			throw new IllegalArgumentException("The given Reservation was not contained in the active Reservations.");

		}

		if(reservation == null) {

			throw new NullPointerException();

		}

		// Contract validated, execute method

		this.reservations.remove(reservation); // Remove from active Reservations

		for(Bed bed: reservation.getReservedBeds()) { // Release reserved Beds

			bed.removeReservationPeriod(reservation.getBeginDate(), reservation.getEndDate());

		}

		// Asserting post conditions are met

		assert !this.getReservations().contains(reservation) : "The reservation is still part of the active Reservations.";

		for(Bed bed: reservation.getReservedBeds()) {

			assert bed.isFree(reservation.getBeginDate(), reservation.getEndDate()) : "One or more of the Beds are still reserved.";

		}

	}

}