RoboterFabrik/Roboter/tpe/exceptions/roboter/RobotFactory.java

package tpe.exceptions.roboter;

import java.util.Collection;
import java.util.HashMap;

import de.hs_mannheim.informatik.bank.domain.Konto;
import tpe.exceptions.RobotException;

public class RobotFactory {
	private Robots nexus6=Nexus6.getInstance();
	private String factoryName;
	private HashMap<Integer,Robots> robotStock=new HashMap<>();
	/**
	 * <code>RobotFactory()</code> mit Namen <br />
	 * {@link Nexus6} in robotStock-HashMap als Standardmäßiger Roboter eingefügt
	 */
	public RobotFactory(String factoryName) {
		this.factoryName=factoryName;
		robotStock.put(nexus6.getId(), nexus6);
	}
	/**
	 * <code>constructRobot()</code> konstruiert Roboter mit durch Kunden gewählten Namen und fügt diese in die HashMap ein <br>
	 * Unterscheidung durch {@link RobotType} 
	 * @return Id des erstellten Roboters
	 */
	public int constructRobot(RobotType robotType, String name) {
		Robots robot;
		
		if(RobotType.R2D2==robotType) {
			robot=new R2D2(name, createIDR2D2(10000));
			robotStock.put(robot.getId(), robot);
			return robot.getId();
		}
		else  {
			robot=new C3PO(name, createIDC3PO(10000));
			robotStock.put(robot.getId(), robot);
			return robot.getId();
		}
					
	}
	/**
	 * RoboterID wird über Math.random() erstellt entsprechend der Anforderung variiert der Zahlenbereich
	 * @param value
	 * @return ID für die in <code>constructRobot()</code> erstellten Roboter
	 */
	private int createIDR2D2(int value) {
		
		int randomID = (int) (Math.random()*(value)) ;
		if(robotStock.containsKey(randomID))
		{
			createIDR2D2(value);
		}
		return randomID;
	}
	private int createIDC3PO(int value) {
		
		int randomID = (int) (Math.random()*(value))+value ;
		if(robotStock.containsKey(randomID))
		{
			createIDC3PO(value);
		}
		return randomID;
	}
	/**
	 * 
	 * @return Gibt den Namen der Fabrik zurück
	 */
	public String getFactoryName() {
		return factoryName;
	}
	/**
	 * Durchsucht die HashMap über Object Key in diesem Fall die Roboter ID
	 * @param id
	 * @return Gibt den zur entsprechenden ID gefunden Roboter zurück
	 */
	public Robots getRobot(int id) {
		return robotStock.get(id);
	}
	/**
	 * Schaltet den Roboter an bzw. aus und ruft Methode aus {@link Robots} auf
	 * @param id
	 * @return Rückgabe ob Roboter an ist true=an false=aus
	 */
	public boolean triggerPower(int id) {
		Robots robot=getRobot(id);
		robot.triggerPowerSwitch();
		return robot.powerStatus;
	}
	/**
	 * 
	 * @param id
	 * @return Rückgabe ob Roboter an ist true=an false=aus
	 */
	public boolean powerStatus(int id) {
		Robots robot=getRobot(id);
		return robot.powerStatus;
	}
	/**
	 * Sucht die Informationen zum über die ID gesuchten Roboter aus der HashMap
	 * @param id
	 * @return Gibt die Informationen zum über die ID gesuchten Roboter aus
	 */
	public String robotInfo(int id) {
		Robots robot=getRobot(id);
		return robot.toString();
	}
	/**
	 * Sucht den Roboter zur ID  aus der HashMap und ermittelt über {@link Robots} Funktion die {@link RobotException}
	 * @param id
	 * @return Gibt {@link RobotException} zurück
	 */
	public RobotException robotBlackbox(int id) {
		Robots robot=getRobot(id);
		return robot.getLastException();
	}
	/**
	 * Ruft die definierten Funktionalitäten aus {@link RobotInstructions} auf
	 * @param id
	 * @param zahlen
	 * @return Ergebnis der Instructions bei Fehler einer {@link RobotException}
	 * @throws RobotException
	 */
	public String robotInstructions(int id, int[]zahlen) throws RobotException {
		Robots robot=getRobot(id);
		return robot.speak(robot.think(zahlen));
	}
	/**
	 * 
	 * @return Gibt die Größe der HashMap zurück
	 */
	public int robotStockSize() {
		return robotStock.size();
	}
	public Collection<Robots> getRobotStock() {
		return robotStock.values();
	}
	/**
	 * Prüft ob Roboter mit übergebener ID existiert
	 * @param id
	 * @return True=Roboter existier; False=Roboter existiert nicht
	 */
	public boolean containsRobot(int id) {
		return robotStock.containsKey(id);
	}
}