praktikum-holons/src/model/Flexibility.java

package model;

import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

import com.google.gson.annotations.Expose;

/**
 * Representative of a flexibility for a HolonElement.
 *
 */
public class Flexibility {
	/*
	 *  MODEL
	 */
	/** The owner of the Flexibility.*/
	private HolonElement element;
	/** The Name of a Flexibility.*/
	@Expose
	public String name;
	/** How fast in TimeSteps the Flexibility can be activated. */
	@Expose
	public int speed;
	/** How high the cost for a activation are. */
	@Expose
	public float cost;
	/** SHould this Flexibility be Offered when is constrainList is fulfilled the flexibility can be activated.*/
	@Expose
	public boolean offered;
	/** The Duration in TimeSteps how long the Flexibility is activated.*/
	@Expose
	private int duration;
	/** The Duration after a successful activation between the next possible activation.*/
	@Expose
	private int cooldown;
	/** The Element this flexibility is assigned.*/





	/** The List of Constrains the Flexibility */
	@Expose
	public List<Constrain> constrainList;
	
	
	public Flexibility(HolonElement element){
		this(0 , 0.f, 1, 0, false, element);		
	}
	public Flexibility(int speed, float cost, int duration, int cooldown, boolean offered, HolonElement element){
		this.speed = speed;
		this.cost = cost;
		setDuration(duration);
		setCooldown(cooldown);
		this.offered=offered;
		this.element = element;
		constrainList = new ArrayList<Constrain>();	
	}
	
	
	
	public HolonElement getElement() {
		return element;
	}
	public void setElement(HolonElement element) {
		this.element = element;
	}

	public int getDuration() {
		return duration;
	}
	/** Minimum duration is 1 TimeStep.*/
	public void setDuration(int duration) {
		this.duration = Math.max(1, duration);
	}

	public int getCooldown() {
		return cooldown;
	}
	/** No negative cooldown TimeSteps.*/
	public void setCooldown(int cooldown) {
		this.cooldown = Math.max(0, cooldown);
	}

	/** returns the total energy Amount accumulated over the TimeSteps.*/
	public float magnitude() {
		return ((float)duration) *  element.getEnergy();
	}
	
	public float energyReleased(){
		return (constrainList.stream().map(constrain -> constrain.getName()).anyMatch(name -> name.equals("onConstrain"))?-1.0f:1.0f) * element.getEnergy();
	}
	public boolean isPositive() {
		return energyReleased() >= 0;
	}
	public boolean isNegative() {
		return energyReleased() < 0;
	}
	
	
	
	public int getSpeed() {
		return speed;
	}
	public void setSpeed(int speed) {
		this.speed = speed;
	}
	@Override
	public String toString() {
		return "Flexibility: " + name + " from [HolonElement: " + element.getName() + " ID:" + element.getId() +"]";
	}

	
	public static enum FlexState{
		IN_USE, ON_COOLDOWN, OFFERED, NOT_OFFERED, UNAVAILABLE
	}		
	

	/*
	 *  STATE
	 */
	private FlexState state = FlexState.OFFERED;
	private int timestep;
	private int activationTime = -1;
	private int durationEndTime = -1;
	private int coolDownEndTime = -1;

	//TODO(Tom2021-12-1) public -> package 
	public void calculateState(int timestep) {
		this.timestep = timestep;
		state = revalidateState();
	}
	//TODO(Tom2021-12-1) public -> package 
	public boolean order() {
		if(canOrder()) {
			state = FlexState.IN_USE;
			durationEndTime = timestep + this.getDuration();
			coolDownEndTime = durationEndTime + this.getCooldown();
			activationTime = timestep;
			return true;
		}
		return false;
	}
	//TODO(Tom2021-12-1) public -> package 
	public boolean cancel() {
		if(activationTime == timestep) {
			state=FlexState.OFFERED;
			durationEndTime = -1;
			coolDownEndTime = -1;
			return true;
		}
		return false;
	}	
	public boolean canActivate() {
		return remainingTimeTillActivation() == 0;
	}
	
	public boolean canOrder() {
		boolean flexIsOffered = state.equals(FlexState.OFFERED);
		return  flexIsOffered && !element.isFlexActive() ;
	}
	public FlexState getState() {
		return state;
	}
	
	public int remainingTimeTillActivation() {
		return Math.max(0, coolDownEndTime - timestep);
	}
	public int remainingDuration() {
		return Math.max(0, durationEndTime - timestep);
	}
	
	/** Checks if all assigned constrains are fulfilled. When no constrains assigned returns true.*/
	private boolean fulfillsConstrains() {
		return constrainList.stream().map(constrain -> constrain.getConstrainFunction()).reduce(Predicate::and).orElse(f -> true).test(this);
	}
	
	private FlexState revalidateState() {
		if(canActivate()) {
			if (!this.fulfillsConstrains() || element.isFlexActive()) {
				return FlexState.UNAVAILABLE;
			}else if (this.offered){
				return FlexState.OFFERED;
			}
			return FlexState.NOT_OFFERED;
		}
		else if(remainingDuration()== 0) {
			return FlexState.ON_COOLDOWN;
		}
		else {
			return FlexState.IN_USE;
		}
	}
	

	
}