package stuff;

import static org.junit.Assert.assertEquals;

public class Movie {

	// See the README file for a description of what is required for this file.
	private String title;
	private int timesWatched;
	private Integer rating;
	
	public Movie(String title) {
		if (title == null) throw new IllegalArgumentException("Title must not be null");
		this.title = title;
		this.timesWatched = 0;
		this.rating = null;
	}
	
	public String getTitle() {
		return title;
	}
	
	public int getTimesWatched() {
		return timesWatched;
	}
	
	public Integer getRating() {
		return rating;
	}
	
	public void setRating(Integer rating) {
		this.rating = rating;
	}
	
	public void watch() {
		timesWatched += 1;
	}

	public static void main(String[] args) {

//		Movie db = new Movie("Das Boot");
//		assertEquals(0, db.getTimesWatched());
//		assertEquals("Das Boot", db.getTitle());
//		
//		db.watch();
//		assertEquals(1, db.getTimesWatched());
//		
//		assertEquals(null, db.getRating());
//		db.setRating(4);
//		assertEquals(4, (int)db.getRating());
	}

}

package stuff;

import java.util.ArrayList;
import java.util.Collection;
import java.util.function.Predicate;
import java.util.stream.Collectors;

public class MovieRegister {


	// Add internal variables
	private Collection<Movie> movies = new ArrayList<>();


	/**
	 * Add movie to register
	 * @param movie
	 */
	public void addMovie(Movie movie) {
		movies.add(movie);
	}

	/**
	 * 
	 * @param title
	 * @return the movie with matching title, or null if no such movie exists.
	 */
	Movie findMovie(String title) {
		return movies.stream().filter(m -> m.getTitle().equals(title)).findAny().orElse(null);
	}

	/**
	 * Filter all registered movies based on a Predicate, and return them as a Collection.
	 * @param pred is the filter for which movies to watch
	 * @return A collection of movies testing true to pred.
	 */
	Collection<Movie> filterMovies(Predicate<Movie> pred) {
		return movies.stream().filter(pred).collect(Collectors.toList());
	}

	/**
	 * Watch movie 'title'.
	 * @param title
	 * @throws IllegalStateException if the title does not exist.
	 */
	public void watch(String title) {
		try {
			findMovie(title).watch();
		} catch (NullPointerException e) {
			throw new IllegalStateException("Movie does not exsits!");
		}
	}

	/**
	 * Small example of use of the class. Does NOT necessarily cover all uses of methods specified in assignment. 
	 * @param args
	 */
	public static void main(String[] args) {

				MovieRegister cb = new MovieRegister();
				cb.addMovie(new Movie("Das Boot"));
				cb.watch("Das Boot");
				System.out.println("Should be 1: " + cb.findMovie("Das Boot").getTimesWatched());

	}

}

package stuff;

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import org.junit.Assert;
import org.junit.Test;

public class AverageComputerTest {

	private static final double epsilon = 1e-8;

	@Test
	public void testComputeAverage() {
		final AverageComputer ac = new AverageComputer(Arrays.asList(3, 4, 5));
		Assert.assertEquals(4.0, ac.computeAverage(), epsilon);
	}

	// We can manipulate the list by adding to it from outside after 
	// it has been added to the method.
	@Test
	public void testNewComputerNotModifiedByChangingList() {
		List<Integer> intVals = new ArrayList<>();
		intVals.addAll(Arrays.asList(2, 3, 1, 4));
		AverageComputer avg = new AverageComputer(intVals);

		assertEquals(2.5, avg.computeAverage(), epsilon);
		intVals.add(5);
		assertEquals(2.5, avg.computeAverage(), epsilon);
	}

	// No cast from integer, thereby messing up those numbers...
	@Test
	public void testRetValIsCastBeforeDivide() {
		AverageComputer ac = new AverageComputer(Arrays.asList(3, 4));

		assertEquals(3.5, ac.computeAverage(), epsilon);
	}
}

package stuff;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Random;

import javafx.fxml.FXML;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Label;
import javafx.scene.control.ListCell;
import javafx.scene.control.TextArea;
import javafx.scene.control.TextField;

public class MathController {
	
	Random rand;

	@FXML
	private ComboBox<Character> typeSelector;

	@FXML
	private TextField firstField;

	@FXML
	private TextField secondField;
	
	@FXML
	private TextArea resultArea;

	@FXML
	private void initialize() {
		rand = new Random();
		Collection<Character> tmp = new ArrayList<>();
		tmp.add('+');
		tmp.add('*');
		tmp.add('/');
		tmp.add('-');
		typeSelector.getItems().addAll(tmp);
		typeSelector.getSelectionModel().select(0);
	}


	/**
	 * Gather doubles from two textfields, apply a mathematical method, and update a text component.
	 */
	@FXML
	private void onCalculate() {
		double res;
		double val1 = Double.parseDouble(firstField.getText());
		double val2 = Double.parseDouble(secondField.getText());
		switch (typeSelector.getValue()) { // Could use chained if-elseif-else instead of switch
			case '+':
				res = val1 + val2;
				break;
			case '-':
				res = val1 - val2;
				break;
			case '*':
				res = val1 * val2;
				break;
			case '/':
				res = val1 / val2;
				break;
			default:
				throw new IllegalArgumentException("Unexpected value: " + typeSelector.getValue());
		}
		
		resultArea.setText(Double.toString(res));
	}

	
	// Is there a method missing here? Where could it be?
	@FXML
	private void randomizeNumbers() {
		firstField.setText(Integer.toString(rand.nextInt(100) + 1));
		secondField.setText(Integer.toString(rand.nextInt(100) + 1));
	}
}

package food;

import java.util.ArrayList;
import java.util.Collection;

import food.def.IKitchen;
import food.def.KitchenObserver;
import food.def.PriceProvider;

// Important: There is no similarity between Kitchen in the exam v2020 and this one.
public class Kitchen implements IKitchen {

	// Add internal variables here:
	private Collection<String> recipes;
	private Collection<Customer> customers;
	
	private Collection<PriceProvider> priceProviders;
	private Collection<KitchenObserver> observers;

	private double turnover;
	
	public Kitchen() {
		super();
		recipes = new ArrayList<>();
		customers = new ArrayList<>();
		priceProviders = new ArrayList<>();
		observers = new ArrayList<>();
		turnover = 0;
	}
	
	
	/**
	 * Add a customer
	 * @param customer The customer to add
	 * 
	 * @throws IllegalArgumentException if the customer is already registered
	 */
	@Override
	public void addCustomer(Customer customer) {
		if (customers.contains(customer)) throw new IllegalArgumentException("Customer already registered");
		customers.add(customer);
	}

	/**
	 * Add a recipe
	 * @param recipe The recipe to add
	 */
	@Override
	public void addRecipe(String recipe) {
		recipes.add(recipe);
	}
	
	/**
	 * @return The turnover of this kitchen - price of all sold meals added together
	 * If the restaurant has sold for 50, 75 and 100, the turnover is 225.
	 * (Norsk: omsetning)
	 */
	@Override
	public double getTurnover() {
		return turnover;
	}

	
	/**
	 * @return A collection of this kitchen's recipes
	 */
	@Override
	public Collection<String> getRecipes() {
		return new ArrayList<>(recipes);
	}
	
	/**
	 * @param name The name of the customer to get
	 * 
	 * @return The customer with the given name, or null if no such customer is registered
	 */
	public Customer getCustomer(String name) {
		return customers.stream()
				.filter(c -> c.getName().equals(name))
				.findAny()
				.orElse(null);
	} // A nice exercise would be to make this with a for loop instead.

	/**
	 * Make a meal, with a given (standard)price and to a given customer.
	 * 
	 * This method needs to check that the kitchen knows the given recipe
	 * and has the given customer registered.
	 * (Task 2.3): rebates need to be considered
	 * Finally, data about the sale must be registered in all appropriate places.
	 * 
	 * @param meal The name of the meal to make
	 * @param price The standard price of the meal
	 * @param customerName The name of the customer that buys the meal
	 * 
	 * @throws IllegalStateException if a meal is not successfully made (somehow)
	 */
	@Override
	public void provideMeal(String meal, double price, String customerName) {
		Customer customer = getCustomer(customerName);
		if (customer == null || !recipes.contains(meal)) throw new IllegalStateException("Couldn't make meal!");
		
		price = computeActualPrice(meal, price, customer); // Added for task 2.3
		turnover += price; // updating the turnover, ya'know.
		customer.buyMeal(meal, price);
		
		for (var obs : observers) {
			obs.mealOrder(meal, price); // For task 2.4: inform all observers!
		}
}
		
	/**
	 * Exercise 2.3 - Delegation
	 * Calculate the total rebate of the given meal, using the PriceProviders (said 
	 * priceDelegates in the exam, fixed afterwards) of this Kitchen
	 * If more than one rebate exist, each of them applies. See README for example.
	 * 
	 * @param meal The name of the meal
	 * @param price The standard price of the meal
	 * @param customer The customer buying the meal
	 * @return The resulting price after all rebates have been considered.
	 */
	double computeActualPrice(String meal, double price, Customer customer) {
		double rebate = 1;
		for (PriceProvider priceProvider : this.priceProviders) {
			rebate = rebate * priceProvider.providePrice(meal, price, customer);
		}
		return rebate * price;
	}
	
	// Exercise 2.3 - Delegation - these may not be all methods you need to create!
	@Override
	public void addPriceProvider(PriceProvider pp) {
		priceProviders.add(pp);
	}

	public void removePriceProvider(PriceProvider pp) {
		priceProviders.remove(pp);
	}

	// Exercise 2.4 - Observerer - these may not be all methods you need to create!
	@Override
	public void addObserver(KitchenObserver ko) {
		observers.add(ko);
	}

	
	public static void main(String[] args) {
		Kitchen k = new Kitchen();
		k.addRecipe("pancakes");
		k.addRecipe("waffles");
		k.addRecipe("taco");
		k.addRecipe("spam");
		Customer per = new Customer("per");
		k.addCustomer(per);
//		k.addCustomer(per); // IllegalArgumentException
		k.addCustomer(new Customer("ida"));
		k.provideMeal("pancakes", 99.50, "per");
		System.out.println(k.getTurnover());
		k.provideMeal("pancakes", 50, "ida");
		System.out.println(k.getTurnover());
	}
}

package food;

import food.def.PriceProvider;

/**
 * A rebate where a customer will get 50% off on every fifth purchase - 
 * Note: you get a rebate on the first buy, so in essence you end up with rebates on the
 * 0th, 5th, 10th, 15th etc buys if you start with 0.
 */
public class RebateEveryFifthBuyFromSameCustomer implements PriceProvider {

	/**
	 * Every fifth time a customer buys a meal, including the first time, 
	 * its price should be reduced to half, return 0.5
	 * If not, it should return 1 (no rebate)
	 */
	@Override
	public double providePrice(String meal, double price, Customer customer) {
        if(customer.getMealsOrdered().size()%5==0 || customer.getMealsOrdered().size()==0) {
            return 0.5;
        }
        return 1.0;
	}
}

package food;

import static org.junit.Assert.assertEquals;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

import food.def.KitchenObserver;

/**
 * The main point of this implementation of KitchenObserver is to keep track of revenue
 * from all meals sold. Every time a new meal is sold (and mealOrder is called), 
 * information about the meal(s) with the highest revenue is printed to System.out.
 *
 */
public class ObserveToPrintTopRevenue implements KitchenObserver {

	// Internal variables go here:
	Map<String, Double> meals = new HashMap<>();

	
	/**
	 * 
	 * @return A string that contains the string 'meal: price' for all meals that have the highest revenue, 
	 * separated by a newline. If more than one meal they are sorted in alphabetical order.
	 * If no meal has been sold: returns an empty string.
	 */
	public String getTopSellers() {
		if (meals.size() == 0) return "";
		List<String> highestMeals = new ArrayList<>();
		double highestPrice = 0.0;
		
		for (var entry : meals.entrySet()) {
			if (entry.getValue() > highestPrice) {
				highestMeals.clear();
				highestMeals.add(entry.getKey());
				highestPrice = entry.getValue();
			} else if (entry.getValue() == highestPrice) {
				highestMeals.add(entry.getKey());
			}
		}
		Collections.sort(highestMeals);
		
		StringBuilder sb = new StringBuilder();
		for (String meal : highestMeals) {
			sb.append(meal);
			sb.append(": ");
			sb.append(highestPrice);
			sb.append("\n");
		}
		return sb.substring(0, sb.length() - 1).toString();
	}
	
	/**
	 * When triggered, updates the revenue of 'meal' with 'price'.
	 * Should then print (System.out) the meal(s) with highest revenue (in alphabetical order), see the method 
	 * getTopSellers.
	 */
	@Override
	public void mealOrder(String meal, double price) {
		meals.put(meal, meals.getOrDefault(meal, 0.0) + price);
		System.out.println(getTopSellers());
	}
	

	// A basic use of the class. No need to use Kitchen to make it work. 
	public static void main(String[] args) {
		ObserveToPrintTopRevenue test = new ObserveToPrintTopRevenue();
		System.out.println("> Only waffles: 50.0");
		test.mealOrder("waffles", 50.0);
		assertEquals("waffles: 50.0", test.getTopSellers().trim());
		System.out.println("> Only waffles: 100.0");
		test.mealOrder("waffles", 50.0);
		System.out.println("> Pancakes and waffles (two lines): 100.0");
		test.mealOrder("pancakes", 100.0);
		System.out.println("> Only waffles: 150.0");
		test.mealOrder("waffles", 50.0);
		
		
	}
}