praktikum-holons/src/classes/holonControlUnit/FlexibilityManager.java

package classes.holonControlUnit;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.stream.Collectors;

import classes.Flexibility;
import ui.controller.FlexManager;
import ui.controller.FlexManager.FlexState;

public class FlexibilityManager {

	private HolonControlUnit hcu;
	private HashMap<Integer, FlexManager> savesFlexManager;
	private int appliedFlexCounter;
	
	public FlexibilityManager(HolonControlUnit hcu) {
		this.hcu = hcu;
		this.savesFlexManager = new HashMap<>();
		this.appliedFlexCounter = 0;
	}
	
	public float applyFlexibilities(float currentPower, float requiredPower, ArrayList<Float> predictedPowerUsage, int timeStep) {
		FlexManager fm = getFlexManager(timeStep);
		
		List<Flexibility> offeredFlexes = fm.getAllFlexWrapperWithState(FlexState.OFFERED).stream().map(fw -> fw.getFlex()).collect(Collectors.toList());
		List<List<Flexibility>> offeredPerm = getAllPermutations(offeredFlexes);
		HashMap<Float, List<Flexibility>> map = new HashMap<>();
		for(List<Flexibility> l : offeredPerm) {
			float pu = 0f;
			Float[] savings = new Float[predictedPowerUsage.size()];
			for(int i=0; i<savings.length; i++)
				savings[i] = 0f;
			for(Flexibility f : l) {
				pu += f.fulfillsConstrains() ? f.getElement().getEnergyPerElement() : 0f;
				if(Math.abs(pu) > Math.abs(requiredPower))
					break;

				for(int i=0; i<Math.min(savings.length, f.getDuration()); i++) {
					savings[i] = savings[i] + f.bringtmir();
				}
			}
			if(this.hcu.decreasesPowerUsage(List.of(savings), currentPower, predictedPowerUsage, requiredPower)) {
				float s = 0f;
				for(int i=0; i<savings.length; i++)
					s += savings[i];
				s = s/savings.length; //average saving over the next time periods
				if(map.containsKey(s) && map.get(s).size() >= l.size())
					continue;
				map.put(s, l);
			}
		}

		float min = Float.MAX_VALUE;
		for(float f : map.keySet()) {
			if(Math.abs(requiredPower-f) < Math.abs(requiredPower-min)) {
				min = f;
			}
		}
		if(map.containsKey(min)) {
			fm.orderFlexFromList(map.get(min));
			this.appliedFlexCounter += map.get(min).size();
			return min;
		}
		
		return 0f;
	}
	
	public FlexManager getFlexManager(int timeStep) {
		boolean doesFlexManagerExist = savesFlexManager.containsKey(timeStep);
		boolean createNew = !doesFlexManagerExist;
		FlexManager newFlexManager;
		if(createNew) {
			newFlexManager = new FlexManager(List.of(this.hcu.getHolon().getHolonObject()), timeStep, savesFlexManager.get(timeStep-1));
			if(doesFlexManagerExist) newFlexManager.orderFlexFromList(savesFlexManager.get(timeStep).getAllFlexesOrderedThisTimeStep());
			savesFlexManager.put(timeStep, newFlexManager);
		}else {
			newFlexManager = savesFlexManager.get(timeStep);
		}
		return newFlexManager;
	}
	
	public void orderFlex(Flexibility flex, int timeStep) {
		getFlexManager(timeStep).orderFlex(flex);
	}
	
	private <T> List<List<T>> getAllPermutations(List<T> set){
		List<List<T>> out = new ArrayList<List<T>>();
		
		for(int i=0; i<set.size(); i++) {
			for(int j=i; j<set.size(); j++) {
				List<T> l = new ArrayList<T>();
				l.addAll(set.subList(i, j+1));
				out.add(l);
			}
		}
		return out;
	}

	public int getAppliedFlexCounter() {
		return appliedFlexCounter;
	}
	
	public int getAmountFlexesForState(int timeStep, FlexState state) {
		return getFlexManager(timeStep).getAllFlexWrapperWithState(state).stream().map(fw -> fw.getFlex()).collect(Collectors.toList()).size();
	}
}