package Domäne;

import java.util.HashMap;

import tpe.exceptions.roboter.exceptions.RobotException;
/**
 * 
 * Schnittstelle zwischen Roboter und FactorySystem.
 * hier wird auch das Objekt Pris erzeugt.
 * RobotFactory hat eine HashMap wo die Roboter gelagert werden.
 *
 */
public class RobotFactory {
	private String name;
	private Roboter pris = Nexus6.getInstance();
	private HashMap<Integer, Roboter> roboterLager = new HashMap<>();

	public RobotFactory(String name) {
		this.name = name;
		roboterLager.put(pris.getId(), pris);
	}
	/**
	 * Hier werden Roboter erzeugt und in die HashMap gespeichert.
	 * Außerdem wird durh die if-Abfrage zweischen R2D2 und C3PO unterschieden.
	 * @param robotType
	 * @param name
	 * @return id vom Roboter der gerade erzeugt worden ist.
	 */
	public int addRobot(RobotType robotType, String name) {
		Roboter roboter;

		if (RobotType.R2D2 == robotType) {
			roboter = new R2D2(name, idVergeben(0, 9999));
			roboterLager.put(roboter.getId(), roboter);
			return roboter.getId();
		} else if (RobotType.C3PO == robotType) {
			roboter = new C3PO(name, idVergeben(10000, 19999));
			roboterLager.put(roboter.getId(), roboter);
			return roboter.getId();

		} else
			return -1;
	}
	/**
	 * 
	 * @return name um eventuell den Namen der RobotFactory zurückzugeben.
	 */
	public String getName() {
		return name;
	}
	/**
	 * gibt den gesuchten Roboter mit der passenden ID zurück.
	 * @param id
	 * @return Roboter objekt 
	 */
	public Roboter findeRoboter(int id) {
		return roboterLager.get(id);
	}
	/**
	 * Diese Methode ist wichtig um die Ids zufällig zur vergeben.
	 * Je nach robotType wird ein anders min und max übergeben. Das gibt
	 * dann den Bereich an wo die Zahl zufällig vergeben wird.
	 * Wurde diese ID schon vergeben, so ruft sich die Methode von selbst auf.
	 * @param min minimum vom Bereich
	 * @param max Maximum vom Bereich
	 * @return randomValue die zufällige und noch nicht vergebene ID
	 */
	private int idVergeben(int min, int max) {

		int randomValue = (int) (Math.random() * (max - min)) + min;
		if (roboterLager.containsKey(randomValue)) {
			idVergeben(min, max);
		}

		return randomValue;
	}
	/**
	 * gibt anhand der ID den Zustand des Roboters zurück.
	 * @param id
	 * @return zustand vom Roboter
	 */
	public boolean roboterZustand(int id) {
		Roboter r = findeRoboter(id);
		boolean zustand = r.isPowerOn();
		return zustand;
	}
	/**
	 * Um den richtigen Roboter anhand der ID An oder Aus zu schalten.
	 * @param id um den richtigen Roboter zu finden
	 * @return zustand vom Roboter
	 */
	public boolean schalterAnAus(int id) {
		Roboter r = findeRoboter(id);
		r.triggerPowerSwitch();
		boolean zustand = r.isPowerOn();
		return zustand;
	}
	/**
	 * Hier werden beide Methoden aufgerufen. Zuerst wird der richtige
	 * Roboter gefunden, dann werden die zahlen von der think()-methode sortiert, und
	 * anschließend mit den richtigen Trennzeichen mit der speak()-methode ausgegeben.
	 * @param id
	 * @param zahlen
	 * @return ausgabe als String Sortiert, mit den richtigen Trennzeichen
	 * @throws RobotException falls der Roboter Aus ist oder zahlen[] die Zahl 42 enthält.
	 */
	public String aufrufSpeakAndThink(int id, int[] zahlen) throws RobotException {
		Roboter r = findeRoboter(id);
		int[] sotiert = r.think(zahlen);
		String ausgabe = r.speak(sotiert);
		return ausgabe;

	}
	/**
	 * Hier wird der letzte Fehler zurückgegeben, den der Roboter geworfen hat.
	 * @param id
	 * @return RobotException letzte Ausnahme vom Roboter
	 */
	public RobotException letzterFehler(int id) {
		Roboter r = findeRoboter(id);
		return r.getLastException();
	}
	/**
	 * Hier werden anhand der Id Typ, Name und Seriennummer vom Roboter zurückgegeben.
	 * @param id
	 * @return ausgabe als String für die Daten des Roboters
	 */
	public String datenDesRoboters(int id) {
		Roboter r = findeRoboter(id);
		String robotType = r.getRobotType().toString();
		String name = r.getName();
		int seriennummer = r.getId();
		String ausgabe = "RoboterType: " + robotType + "; Name: " + name + "; Seriennummer: " + seriennummer;
		return ausgabe;

	}
	/**
	 * gibt die größe vom roboterLager zurück.
	 * Wird für das Testen verwendet.
	 * @return int größe des Lagers
	 */
	public int getRoboterLagerSize() {
		return roboterLager.size();
	}
	/**
	 * Gibt einen boolean zurück um zu schauen ob dieser Roboter schon existiert.
	 * @param id um zu schauen ob diese Id schon vergeben wurde
	 * @return boolean true bedeutet, dass es diesen Roboter gibt
	 */
	public boolean istDieserRoboterDa(int id) {
		return roboterLager.containsKey(id);
	}
}