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

package holeg.ui.view.information;

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

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

/**
 * For the @VisualRepresentationalState only.
 * 
 * @author Tom
 *
 */
public class FilterableGroupNode {
	private GroupNode model;
	private ArrayList<Supplier> supplierList = new ArrayList<>();
	private ArrayList<Passiv> passivList = new ArrayList<>();
	private ArrayList<Consumer> consumerList = new ArrayList<>();
	private ArrayList<Node> nodeList = new ArrayList<>();
	/**
	 * 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<Edge> internCableList = new ArrayList<>();
	/**
	 * 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 = new ArrayList<>();
	private ArrayList<DecoratedSwitch> switchList = new ArrayList<>();
	private ArrayList<FilterableGroupNode> groupNodeList = new ArrayList<>();

	public FilterableGroupNode(GroupNode model, int iteration) {
		this.model = model;
	}

	public FilterableGroupNode(DecoratedGroupNode dGroupNode, int iteration) {
		model = dGroupNode.getModel();
		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<Edge> 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.getActualEnergy() < 0))
						.map(ele -> -ele.getActualEnergy()).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.getActualEnergy() > 0))
						.map(ele -> ele.getActualEnergy()).reduce(0.0f, Float::sum))
				.reduce(0.f, Float::sum)
				+ groupNodeList.stream().map(groupNode -> groupNode.getProduction(stateFilter, priorityFilter))
						.reduce(0.f, Float::sum);
	}

}