praktikum-holons/src/ui/view/information/FilterableGroupNode.java

package ui.view.information;

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

import classes.Flexibility;
import classes.GroupNode;
import classes.HolonElement;
import classes.Node;
import jdk.jfr.Unsigned;
import ui.model.Consumer;
import ui.model.DecoratedCable;
import ui.model.DecoratedGroupNode;
import ui.model.DecoratedHolonObject;
import ui.model.DecoratedHolonObject.HolonObjectState;
import ui.model.DecoratedSwitch;
import ui.model.ExitCable;
import ui.model.Passiv;
import ui.model.Supplier;

/**
 * For the @VisualRepresentationalState only.
 * 
 * @author Tom
 *
 */
public class FilterableGroupNode {
	private GroupNode model;
	private ArrayList<Supplier> supplierList;
	private ArrayList<Passiv> passivList;
	private ArrayList<Consumer> consumerList;
	private ArrayList<Node> nodeList;
	/**
	 * Cables that only exist on that group node. From a object in that group node
	 * to a object in that group Node. Not exit the group node (a layer down).
	 */
	private ArrayList<DecoratedCable> internCableList;
	/**
	 * Cables that exit this group node (a Layer Up). From a object in this group
	 * node to a object in a upper layer.
	 */
	private ArrayList<ExitCable> exitCableList;
	private ArrayList<DecoratedSwitch> switchList;
	private ArrayList<FilterableGroupNode> groupNodeList;
	private int iteration;
	public FilterableGroupNode(GroupNode model, int iteration) {
		this.model = model;
		this.iteration = iteration;
		this.supplierList = new ArrayList<Supplier>();
		this.passivList = new ArrayList<Passiv>();
		this.consumerList = new ArrayList<Consumer>();
		this.nodeList = new ArrayList<Node>();
		this.internCableList = new ArrayList<DecoratedCable>();
		this.exitCableList = new ArrayList<ExitCable>();
		this.switchList = new ArrayList<DecoratedSwitch>();
		this.groupNodeList = new ArrayList<FilterableGroupNode>();
	}

	public FilterableGroupNode(DecoratedGroupNode dGroupNode, int iteration) {
		model = dGroupNode.getModel();
		this.iteration = iteration;
		supplierList = dGroupNode.getSupplierList();
		passivList = dGroupNode.getPassivList();
		consumerList = dGroupNode.getConsumerList();
		nodeList = dGroupNode.getNodeList();
		internCableList = dGroupNode.getInternCableList();
		exitCableList = dGroupNode.getExitCableList();
		switchList = dGroupNode.getSwitchList();
		groupNodeList = (ArrayList<FilterableGroupNode>) dGroupNode.getGroupNodeList().stream()
				.map(node -> new FilterableGroupNode(node, iteration)).collect(Collectors.toList());
	}

	public GroupNode getModel() {
		return model;
	}

	public ArrayList<Supplier> getSupplierList() {
		return supplierList;
	}

	public ArrayList<Passiv> getPassivList() {
		return passivList;
	}

	public ArrayList<Consumer> getConsumerList() {
		return consumerList;
	}

	public ArrayList<Node> getNodeList() {
		return nodeList;
	}

	public ArrayList<DecoratedCable> getInternCableList() {
		return internCableList;
	}

	public ArrayList<ExitCable> getExitCableList() {
		return exitCableList;
	}

	public ArrayList<DecoratedSwitch> getSwitchList() {
		return switchList;
	}

	public ArrayList<FilterableGroupNode> getGroupNodeList() {
		return groupNodeList;
	}

	// Returns the amount of holons and count himself
	public int getAmountOfGroupNodes() {
		return groupNodeList.stream().map(groupNode -> groupNode.getAmountOfGroupNodes()).reduce(1, Integer::sum);
	}

	public Stream<Flexibility> getFlexibilitiesStream(Predicate<DecoratedHolonObject> stateFilter,
			Predicate<HolonElement> priorityFilter) {

		Stream<Flexibility> flexInChildGorupNode = this.groupNodeList.stream()
				.flatMap(groupNode -> groupNode.getFlexibilitiesStream(stateFilter, priorityFilter));

		Stream<Flexibility> flexInThisGorupNode = objectStream().filter(stateFilter).flatMap(object -> object.getModel()
				.getElements().stream().filter(priorityFilter).flatMap(ele -> ele.flexList.stream()));

		return Stream.concat(flexInChildGorupNode, flexInThisGorupNode);
	}

	public Stream<DecoratedHolonObject> objectStream() {
		return Stream.concat(Stream.concat(this.consumerList.stream(), this.supplierList.stream()),
				this.passivList.stream());
	}

	// Gather Informations:
	public int getAmountOfSupplier(Predicate<DecoratedHolonObject> stateFilter) {
		return (int) supplierList.stream().filter(stateFilter).count() + groupNodeList.stream()
				.map(groupNode -> groupNode.getAmountOfSupplier(stateFilter)).reduce(0, Integer::sum);
	}

	public int getAmountOfConsumer(Predicate<DecoratedHolonObject> stateFilter) {
		return (int) consumerList.stream().filter(stateFilter).count() + groupNodeList.stream()
				.map(groupNode -> groupNode.getAmountOfConsumer(stateFilter)).reduce(0, Integer::sum);
	}

	public int getAmountOfPassiv(Predicate<DecoratedHolonObject> stateFilter) {
		return (int) passivList.stream().filter(stateFilter).count() + groupNodeList.stream()
				.map(groupNode -> groupNode.getAmountOfPassiv(stateFilter)).reduce(0, Integer::sum);
	}

	public int getAmountOfConsumerWithState(Predicate<DecoratedHolonObject> stateFilter, HolonObjectState state) {
		return ((int) consumerList.stream().filter(stateFilter).map(con -> con.getState())
				.filter(rightState -> (rightState == state)).count())
				+ groupNodeList.stream().map(groupNode -> groupNode.getAmountOfConsumerWithState(stateFilter, state))
						.reduce(0, Integer::sum);
	}


	public PriorityCounts getPriorityCounts(Predicate<DecoratedHolonObject> stateFilter) {
		PriorityCounts priority = new PriorityCounts();
		objectStream().filter(stateFilter)
				.forEach(object -> object.getModel().getElements().stream().forEach(ele -> priority.Count(ele)));
		groupNodeList.stream().forEach(groupNode -> priority.Add(groupNode.getPriorityCounts(stateFilter)));
		return priority;
	}

	public class PriorityCounts {
		@Unsigned
		public int low, medium, high, essential;

		public void Add(PriorityCounts other) {
			low += other.low;
			medium += other.medium;
			high += other.high;
			essential += other.essential;
		}

		public void Count(HolonElement element) {
			switch (element.getPriority()) {
			case Essential:
				essential++;
				break;
			case High:
				high++;
				break;
			case Medium:
				medium++;
				break;
			case Low:
				low++;
				break;
			default:
				break;

			}
		}
	}

	public int getAmountOfElementsFromHolonObjects(Predicate<DecoratedHolonObject> stateFilter, Predicate<HolonElement> priorityFilter) {
		return objectStream().filter(stateFilter).map(object -> (int)object.getModel().getElements().stream().filter(priorityFilter).count()).reduce(0,
				Integer::sum)
				+ groupNodeList.stream().map(groupNode -> groupNode.getAmountOfElementsFromHolonObjects(stateFilter, priorityFilter))
				.reduce(0, Integer::sum);
	}
	public int getAmountOfAktiveElementsFromHolonObjects(Predicate<DecoratedHolonObject> stateFilter, Predicate<HolonElement> priorityFilter) {
		return objectStream().filter(stateFilter).map(object -> (int)object.getModel().getElements().stream().filter(priorityFilter).count()).reduce(0, Integer::sum)
				+ groupNodeList.stream()
						.map(groupNode -> groupNode.getAmountOfAktiveElementsFromHolonObjects(stateFilter, priorityFilter))
						.reduce(0, Integer::sum);
	}

	public float getConsumption(Predicate<DecoratedHolonObject> stateFilter, Predicate<HolonElement> priorityFilter) {
		return ((Stream<DecoratedHolonObject>) Stream.concat(this.consumerList.stream(), supplierList.stream())).filter(stateFilter).map(con -> con.getModel().getElements().stream().filter(priorityFilter.and(ele -> ele.getEnergyAtTimeStep(iteration) < 0)).map(ele -> -ele.getEnergyAtTimeStep(iteration)).reduce(0.0f, Float::sum)).reduce(0.f,
				Float::sum)
				+ groupNodeList.stream().map(groupNode -> groupNode.getConsumption(stateFilter, priorityFilter)).reduce(0.f,
						Float::sum);
	}

	public float getProduction(Predicate<DecoratedHolonObject> stateFilter, Predicate<HolonElement> priorityFilter) {
		return ((Stream<DecoratedHolonObject>) Stream.concat(this.consumerList.stream(), supplierList.stream())).filter(stateFilter).map(con -> con.getModel().getElements().stream().filter(priorityFilter.and(ele -> ele.getEnergyAtTimeStep(iteration) > 0)).map(ele -> ele.getEnergyAtTimeStep(iteration)).reduce(0.0f, Float::sum)).reduce(0.f,
				Float::sum)
				+ groupNodeList.stream().map(groupNode -> groupNode.getProduction(stateFilter, priorityFilter)).reduce(0.f,
						Float::sum);
	}


}