OOP2

import java.util.Set;

import java.util.HashSet;

import java.util.Date;

/**

 * Represents a reservation in a hostel.

 * Reservation is a simple class that allows one to store reservation

 * information, request it when necessary, and so on.

 * Certain methods are provided for interaction, which use contracts to assert

 * proper functioning.

 *

 * Note: There is a form of redundancy in this class.

 * Reservation holds a Set of Beds, and an integer, indicating the amount of

 * people that are in this Reservation.

 * Normally, the amount of people in the Reservation is determined by the amount

 * of reserved Beds, because the amount of Beds implied the amount of people to

 * facilitate.

 * Because of the design of this program, I've weighed the advantages and

 * disadvantages of holding this implication, of using a seperate member

 * explicitely indicating the amount of people.

 *

 * I've chosen the latter option. It scales better in terms of weird

 * afterthoughts ("I also want to make people sleep on the floor"), but being

 * explicit is also a tad easier to manage. It also allows the other classes to

 * be far more decoupled from Reservation (otherwise, they'd have to check for

 * errors every time themselves, hindering cohesiveness).

 *

 * To overcome the possible difference, I've made it so that, every time, the

 * relation between the values is changed (the people in the Reservation

 * changes, for example), the class automatically checks if the values are

 * corresponding. If they're not, a warning is printed to system.out.err,

 * informing about the fact that there's a discrepancy.

 *

 * I think that's the best way to overcome this problem.

 * @author Maarten Vangeneugden - 1438256

 */

public class Reservation {

	// Members

	private String groupName;

	private Date beginDate;

	private Date endDate;

	private Set<Bed> reservedBeds;

	private int people; // The amount of people in this Reservation

	private int reservationID;

	private String roomType; // Room type requested by group

	private Set<String> roomFacilities; // Requested room facilities

	private Set<Date> breakfastDays; // Set of days numbers

	// Controllers

	private RoomController roomController;

	private ReservationController reservationController;

	/**

	 * Create a new Reservation.

	 * Be aware about the limitations of a Reservation: it's not the

	 * Reservation's duty to check whether the provided Beds are properly

	 * reserved; take care of this accordingly.

	 * 

	 * Some information is implicit. For example: The size of the set of

	 * reserved Beds implies the amount of people in the group; no breakfast

	 * days implies no breakfast, ...

	 * @param groupName The name of the group.

	 * @param people The amount of people that are reserving.

	 * @param beginDate The date that the Reservation begins.

	 * @param endDate The date that the Reservation ends.

	 * @param reservedBeds The set of Beds reserved and assigned to this

	 * Reservation.

	 * @param roomType The requested room type.

	 * @param roomFacilities The set of all requested room facilities.

	 * @param breakfastDays A set of all days that the group wants breakfast.

	 * @param reservationID An ID for this reservation, to differentiate from

	 * other Reservations.

	 * @pre No parameter must be a null pointer.

	 * @pre people must be a natural number, different from 0.

	 * @pre beginDate must come before endDate.

	 * @pre All dates in breakfastDays must fall between beginDate and endDate.

	 * @pre No string parameter may be empty.

	 * @post The amount of people in the Reservation is determined by the amount

	 * of reserved Beds.

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

	 * @throws IllegalArgumentException if any of the other preconditions is not

	 * met.

	 */

	public Reservation(String groupName, int people, Date beginDate, Date endDate, Set<Bed> reservedBeds, String roomType, Set<String> roomFacilities, Set<Date> breakfastDays) {

		// Contract validation:

		if(people < 1) {

			throw new IllegalArgumentException("The amount of people should be at least 1.");

		}

		if(!beginDate.before(endDate)) {

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

		}

		if(groupName.isEmpty() || roomType.isEmpty()) {

			throw new IllegalArgumentException("groupName and/or roomType were empty strings.");

		}

		for(String roomFacility: roomFacilities) {

			if(roomFacility.isEmpty()) {

				throw new IllegalArgumentException("One of the room facilities was an empty string.");

			}

		}

		for(Date breakfastDay : breakfastDays) {

			if(breakfastDay.before(beginDate) || breakfastDay.after(endDate)) {

				throw new IllegalArgumentException("One of the breakfast days occurs before/after the reservation period.");

			}

		}

		// Contract validated, execute constructor

		this.groupName = groupName;

		this.people = people;

		this.beginDate = beginDate;

		this.endDate = endDate;

		this.reservedBeds = reservedBeds;

		this.reservationID = reservationID;

		this.roomType = roomType;

		this.roomFacilities = roomFacilities;

		this.breakfastDays = breakfastDays;

	}

	/**

	 * Construct template Reservation.

	 * Use this constructor if you need to create an empty/new Reservation. 

	 * It omits the standard restrictions (for example, the group name will be

	 * empty) to accomodate for the expected usage of this Reservation.

	 */

	public Reservation() {

		this.groupName = "Blank name";

		this.people = 1;

		this.beginDate = new Date();

		this.endDate = new Date();

		// Adding 1 day, because the end date must be after the begin date.

		this.endDate.setTime(this.beginDate.getTime() + (1000*60*60*24));

		this.reservedBeds = new HashSet<>();

		this.reservationID = 0;

		this.roomType = "";

		this.roomFacilities = new HashSet<>();

		this.breakfastDays = new HashSet<>();

	}

	/**

	 * Checks whether the amount of people corresponds with the reserved Beds.

	 * Call this method whenever a change in the amount of Beds, or the amount

	 * of people is made, or, whenever you need to assure consistency.

	 *

	 * It also prints a warning to system.out.err to inform about a discrepancy,

	 * should one be found.

	 *

	 * @return True if the counts are consistent, false otherwise.

	 */

	private boolean checkPeopleCountConsistency() {

		// The getters for people and beds mustn't be used, as this causes an

		// infinite recursion.

		int people = this.people;

		int beds = this.reservedBeds.size();

		if(people != beds) {

			System.err.println("There's a discrepancy in the amount of people in Reservation "+

					this.reservationID +":");

			System.err.println("People: "+String.valueOf(people));

			System.err.println("Reserved Beds: "+String.valueOf(beds));

			return false;

		}

		return true;

	}

	/**

	 * Set the group name for this Reservation.

	 * @param groupName The new group name.

	 * @pre groupName mustn't be empty, or a null pointer.

	 * @post The group name is changed to the given name.

	 * @throws NullPointerException if groupName is a null pointer.

	 * @throws IllegalArgumentException if groupName is an empty String.

	 */

	public void setGroupName(String groupName) {

		if(groupName.isEmpty())

			throw new IllegalArgumentException("groupName is an empty String.");

		this.groupName = groupName;

	}

	/**

	 * Retrieve the current group name.

	 * @return The group name of this Reservation.

	 */

	public String getGroupName() {

		return this.groupName;

	}

	/**

	 * Get amount of people in this Reservation.

	 * @post A warning will be printed to system.out.err if the amount of people

	 * is inconsistent with the amount of reserved Beds.

	 * @see Reservation.checkPeopleCountConsistency

	 * @return The amount of people in this Reservation.

	 */

	public int getPeople() {

		this.checkPeopleCountConsistency();

		return this.people;

	}

	/**

	 * Set the amount of people for this Reservation.

	 * Note that this method will not notify you if the new amount of people is

	 * equal to the previous amount.

	 * 

	 * This method will print

	 * @param people The new amount of people in this Reservation.

	 * @pre people must be at least 1.

	 * @post A warning will be printed to system.out.err if the amount of people

	 * is inconsistent with the amount of reserved Beds.

	 * @post The amount of people is changed to the given value.

	 * @throws IllegalArgumentException if people is less than 1.

	 */

	public void setPeople(int people) {

		if(people < 1) {

			throw new IllegalArgumentException("people must be at least 1.");

		}

		this.people = people;

		this.checkPeopleCountConsistency();

	}

	/**

	 * Returns a copy of the begin Date of this Reservation.

	 * @return a copy of the begin Date of this Reservation.

	 */

	public Date getBeginDate() {

		return (Date)this.beginDate.clone();

	}

	/**

	 * Set the begin date for this Reservation.

	 * @param beginDate The new begin date.

	 * @pre beginDate mustn't be a null pointer.

	 * @pre beginDate must come strictly before the end date.

	 * @post The begin date is updated accordingly.

	 * @throws NullPointerException if beginDate is a null pointer.

	 * @throws IllegalArgumentException if beginDate comes after the end date.

	 */

	public void setBeginDate(Date beginDate) {

		if(beginDate.after(this.endDate))

			throw new IllegalArgumentException("beginDate comes after the end date.");

		this.beginDate = beginDate;

	}

	/**

	 * Returns a copy of the end Date of this Reservation.

	 * @return a copy of the end Date of this Reservation.

	 */

	public Date getEndDate() {

		return (Date)this.endDate.clone();

	}

	/**

	 * Set the end date for this Reservation.

	 * @param endDate The new end date.

	 * @pre endDate mustn't be a null pointer.

	 * @pre endDate must come strictly after the begin date.

	 * @post The end date is updated accordingly.

	 * @throws NullPointerException if endDate is a null pointer.

	 * @throws IllegalArgumentException if endDate comes after the begin date.

	 */

	public void setEndDate(Date endDate) {

		if(endDate.before(this.beginDate))

			throw new IllegalArgumentException("endDate comes before the begin date.");

		this.endDate = endDate;

	}

	public void setReservedBeds(Set<Bed> reservedBeds) {

		this.reservedBeds = reservedBeds;

		this.checkPeopleCountConsistency();

	}

	public Set<Bed> getReservedBeds() {

		this.checkPeopleCountConsistency();

		return reservedBeds;

	}

	// TODO: Write documentation for all of these, even though it's all mostly

	// copy/pasting. pfffff

	public void setReservationID(int reservationID) {

		this.reservationID = reservationID;

	}

	public int getReservationID() {

		return reservationID;

	}

	public void setRoomType(String roomType) {

		this.roomType = roomType;

	}

	public String getRoomType() {

		return roomType;

	}

	public void setRoomFacilities(Set<String> roomFacilities) {

		this.roomFacilities = roomFacilities;

	}

	public Set<String> getRoomFacilities() {

		return roomFacilities;

	}

	/**

	 * Calculates the price of the Reservation, based on its current state.

	 * Price table:

	 * - 20/person/day

	 *   - 5 less in low season, 5 more in high season

	 * - 4/breakfast ordered

	 * - If room is fully booked by the group --> 10% discount

	 * @param room The Room the Beds of this Reservation are in.

	 * @pre The Room must contain all Beds of this Reservation.

	 * @pre No parameter may be null.

	 * @throws IllegalArgumentException if room doesn't contain all Beds.

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

	 * @return The price in euros.

	 */

	public int getPrice(Room room) {

		// Contract validation

		if(!room.getBeds().containsAll(this.reservedBeds)) {

			throw new IllegalArgumentException("room does not have all the Beds of this Reservation.");

		}

		// Contract validated

		int totalPrice = 0;

		// Jan - Apr: Mid

		// May - Aug: High

		// Sep - Dec: Low

		// Calculate bed prices

		int month = this.getBeginDate().getMonth();

		int bedPrice = 20;

		if(month >=8) { // From September:

			bedPrice -= 5;

		} else if(month >=4) { // From May:

			bedPrice += 5;

		}

		// ΔDate represents the difference between the begin and end date.

		// allows to retrieve the days between them, because the difference is

		// expressed in milliseconds (nights = ΔDate ÷ 1000 ÷ 60 ÷ 60 ÷ 24)

		long deltaDate = this.getEndDate().getTime() - this.getBeginDate().getTime();

		long nights = deltaDate/1000/60/60/24;

		totalPrice += (this.getReservedBeds().size() * nights * bedPrice);

		// Calculate price for breakfasts

		int breakfasts = this.getBreakfastDays().size();

		totalPrice += breakfasts * this.getPeople();

		// Check if eligible for discount;

		// A group gets 10% discount iff they reserve a full Room for

		// themselves.

		Set<Bed> roomBeds = room.getBeds();

		if(roomBeds.containsAll(this.reservedBeds) && roomBeds.size() == this.reservedBeds.size()) {

			double discount = (double)totalPrice * 0.1;

			totalPrice -= (int)discount;

		}

		return totalPrice;

	}

	public void setBreakfastDays(Set<Date> breakfastDays) {

		this.breakfastDays = breakfastDays;

	}

	public Set<Date> getBreakfastDays() {

		return this.breakfastDays;

	}

}