pstlab / PLATINUm

public class ReservoirResourceSchedulingResolver extends Resolver<ReservoirResource> {

	boolean load;

	private double schedulingCost;

	/**

	 * 

	 */

	protected ReservoirResourceSchedulingResolver() {

		super(ResolverType.RESERVOIR_RESOURCE_SCHEDULING_RESOLVER.getLabel(),

				ResolverType.RESERVOIR_RESOURCE_SCHEDULING_RESOLVER.getFlawTypes());

		// set load flag

		this.load = false;

	}

	/**

	 * 

	 */

	private void load() {

		// get deliberative property file

		FilePropertyReader properties = new FilePropertyReader(

				FRAMEWORK_HOME + FilePropertyReader.DEFAULT_DELIBERATIVE_PROPERTY);

		// get weight

		this.schedulingCost = Double.parseDouble(properties.getProperty("scheduling-cost"));

		// set flag

		this.load = true;

	}

	/**

	 * 

	 */

	@Override

	protected List<Flaw> doFindFlaws() {

		// check load

		if (!this.load) {

			this.load();

		}

		// list of flaws

		List<Flaw> flaws = new ArrayList<>();

		try {

			// check pessimistic resource profile

			ReservoirResourceProfile prp = this.component.

					computePessimisticResourceProfile();

			/*

			 * Analyze the pessimistic profile and find peaks if 

			 * any and generate production checkpoints

			 */

			flaws = this.doComputeProfileOverflows(prp);

		} catch (ResourceProfileComputationException ex) {

			// profile computation error

		}

		// get list of flaws detected

		return flaws;

	}

	/**

	 * 

	 */

	@Override

	protected void doComputeFlawSolutions(Flaw flaw) 

			throws UnsolvableFlawException {

		// check flaw type

		switch (flaw.getType()) {

			// resource peak

			case RESERVOIR_OVERFLOW : {

				// get peak

				ReservoirOverflow overflow = (ReservoirOverflow) flaw;

				// solvable condition

				boolean solvable = false;

				// check the size of the critical set

				if (overflow.getCriticalSet().size() > 1) {

					// check if solvable through scheduling - at least one production and one consumption are needed

					solvable = !overflow.getProductions().isEmpty() && !overflow.getConsumptions().isEmpty();

				}

				// check if solvable

				if (solvable) {

					// find a feasible solution if any

					this.doFindFeasibleSchedule(overflow);

				}

			}

			break;

			default : {

				warning("Resolver [" + this.getClass().getName() + "] cannot resolver flaw of type " + flaw.getType() + "\n");

			}

		}

		// check solutions found

		if (flaw.getSolutions().isEmpty()) {

			throw new UnsolvableFlawException("No feasible solutions found the following peak on reservoir resource \"" + this.component.getName() + "\":\n- flaw: " + flaw + "\n");

		}

	}

	/**

	 * 

	 * @param schedule

	 * @param initialLevel

	 * @return

	 */

	private boolean checkCapacityFeasibility(List<ResourceEvent<?>> schedule, double initialLevel) {

		// feasibility flag

		boolean feasible = true;

		// level of resource

		double currentLevel = initialLevel;

		// check resource level resulting from the schedule

		for (int index = 0; index < schedule.size() && feasible; index++) {

			// get event

			ResourceEvent<?> event = schedule.get(index);

			// update the current level

			currentLevel += event.getAmount();

			// check feasibility

			feasible = currentLevel >= this.component.getMinCapacity() && 

					currentLevel <= this.component.getMaxCapacity();

		}

		// get feasibility flag

		return feasible;

	}

	/**

	 * 

	 * @param schedule

	 * @return

	 */

		// feasibility flag

		boolean feasible = true;

		// list of propagated constraints

		List<BeforeIntervalConstraint> committed = new ArrayList<>();

		// check pairs of events 

		for (int index = 0; index < schedule.size() - 1 && feasible; index++) {

			try {

				// get events

				ResourceEvent<?> e1 = schedule.get(index);

				ResourceEvent<?> e2 = schedule.get(index + 1);

				// get associated tokens and temporal intervals to check schedule feasibility

				TemporalInterval i1 = e1.getDecision().getToken().getInterval();

				TemporalInterval i2 = e2.getDecision().getToken().getInterval();

				// create precedence constraint "i1 < i2"

				BeforeIntervalConstraint before = this.tdb.createTemporalConstraint(

						TemporalConstraintType.BEFORE);

				// set constraint data

				before.setReference(i1);

				before.setTarget(i2);

				before.setLowerBound(0);

				before.setUpperBound(this.tdb.getHorizon());

				// add constraints to committed

				committed.add(before);

				// propagate constraint

				this.tdb.propagate(before);

				// check temporal feasibility

				this.tdb.verify();

			} catch (TemporalConstraintPropagationException | ConsistencyCheckException ex) {

				// not feasible schedule

				feasible = false;

				// log data

				debug("Component [" + this.label + "] temporally unfeasible schedule:\n"

						+ "- potential schedule critical set: " + schedule + "\n");

			} finally {

				// retract all committed constraints

				for (BeforeIntervalConstraint before : committed) {

					// retract temporal constraint

					this.tdb.retract(before);

				}

			}

		}

		// get feasibility flag

		return feasible;

	}

	/**

	 * 

	 * @param overflow

	 */

	protected void doFindFeasibleSchedule(ReservoirOverflow overflow) {

		// get the critical set

		List<ResourceEvent<?>> cs = overflow.getCriticalSet();

		// start looking for a feasible schedule recursively 

		this.doFindFeasibleSchedule(new ArrayList<>(), cs, overflow);

	}

	/**

	 * 

	 * @param schedule

	 * @param cs

	 * @param overflow

	 */

	private void doFindFeasibleSchedule(List<ResourceEvent<?>> schedule, List<ResourceEvent<?>> cs, ReservoirOverflow overflow) {

		// check if a schedule is ready

		if (cs.isEmpty()) {

			// check schedule resource feasibility first and then temporal feasibility

			if (this.checkCapacityFeasibility(schedule, overflow.getInitialLevel()) && 

					this.checkTemporalFeasibility(schedule)) {

				// create flaw solution

				ResourceEventSchedule solution = new ResourceEventSchedule(overflow, schedule, this.schedulingCost);

				// add solution to the flaw

				overflow.addSolution(solution);

			}

		} else {

			// check possible schedules until no solution is found 

			for (int index = 0; index < cs.size(); index++) { // && overflow.getSolutions().isEmpty(); index++) {

				// get an event from the critical set

				ResourceEvent<?> ev = cs.remove(index);

				// add the event to the possible schedule

				schedule.add(ev);

				// recursively build the permutation

				this.doFindFeasibleSchedule(schedule, cs, overflow);

				// remove event from the permutation

				schedule.remove(ev);

				// restore data

				cs.add(index, ev);

			}

		}

	}

	/**

	 * 

	 */

	@Override

	protected void doApply(FlawSolution solution) 

			throws FlawSolutionApplicationException {

		// check flaw type

		switch (solution.getFlaw().getType()) {

			// check flaw type

			case RESERVOIR_OVERFLOW : {

				// cast flaw solution

				ResourceEventSchedule schedule = (ResourceEventSchedule) solution;

				// get events

				List<ResourceEvent<?>> events = schedule.getSchedule();

				try {

					// create relation between associated decisions

					for (int index = 0; index < events.size() - 1; index++) {

						// get decisions

						Decision reference = events.get(index).getDecision();

						Decision target = events.get(index + 1).getDecision();

						// create relation

						BeforeRelation before = this.component.create(

								RelationType.BEFORE, reference, target);

						// set relation bounds

						before.setBound(new long[] {

								0, 

								this.tdb.getHorizon()});

						// add created relation

						solution.addCreatedRelation(before);

						debug("Applying flaw solution:\n"

								+ "- solution: " + solution + "\n"

								+ "- created temporal constraint: " + before + "\n");

						// propagate relations

						this.component.activate(before);

						// add activated relations to solution

						solution.addActivatedRelation(before);

					}

					// check temporal feasibility

					this.tdb.verify();

				} catch (RelationPropagationException | ConsistencyCheckException ex) {

					// failure while applying solution

					debug("Error while applying flaw solution:\n"

							+ "- solution: " + solution + "\n"

							+ "- message: " + ex.getMessage() + "\n");

					// deactivate created relation

					for (Relation rel : solution.getActivatedRelations()) {

						// get reference

						DomainComponent refComp = rel.getReference().getComponent();

						refComp.deactivate(rel);

					}

					// delete created relations

					for (Relation rel : solution.getCreatedRelations()) {

						// get reference component

						DomainComponent refComp = rel.getReference().getComponent();

						// delete relation from component

						refComp.delete(rel);

					}

					// throw exception

					throw new FlawSolutionApplicationException("Error while applying flaw solution:\n"

							+ "- solution: " + solution + "\n"

							+ "- message: " + ex.getMessage() + "\n");

				}

			}

			break;

			default : {

			}

		}

	}

	/**

	 * Analyze the profile of a reservoir resource in order to find peaks and compute production checkpoints

	 * 

	 * @param profile

	 * @return

	 */

	private List<Flaw> doComputeProfileOverflows(ReservoirResourceProfile profile) {

		// list of flaws found

		List<Flaw> flaws = new ArrayList<>();

		// get profile samples

		List<ResourceUsageProfileSample> samples = profile.getSamples();

		// long start peak level

		long startPeakLevel = 0;

		// reset the current level of resource

		long currentLevel = this.component.getInitialLevel();

		// set minimum and maximum level of resource within the critical set

		long minCriticalSetLevel = Long.MAX_VALUE - 1;

		long maxCriticalSetLevel = Long.MIN_VALUE + 1;

		// set of consumptions that may generate a peak

		List<ResourceEvent<?>> criticalSet = new ArrayList<>();

		// peak mode flag

		boolean peakMode = false;

		// analyze the resource profile until a peak is found

		for (int index = 0; index < samples.size() && flaws.isEmpty(); index++) {

			// current sample

			ResourceUsageProfileSample sample = samples.get(index);

			// get resource event

			ResourceEvent<?> event = sample.getEvent();

			// check peak mode

			if (!peakMode) {

				// update the start peak level

				startPeakLevel = currentLevel;

				// update the current level of the resource

				currentLevel += event.getAmount();					// positive amount in case of production, negative in case of consumption

				// check resource peak condition

				peakMode = currentLevel < this.component.getMinCapacity() || currentLevel > this.component.getMaxCapacity();

				// check if a peak is starting 

				if (peakMode) {

					// first event of the peak

					criticalSet.add(event);

					// update minimum and maximum level of resource within the critical set

					minCriticalSetLevel = Math.min(minCriticalSetLevel, currentLevel);

					maxCriticalSetLevel = Math.max(maxCriticalSetLevel, currentLevel);

				}

			} else {

				// add the current event to the critical set

				criticalSet.add(event);

				// get current level of the resource

				currentLevel += event.getAmount();				// positive amount in case of production, negative in case of consumption

				// update minimum and maximum level of resource within the critical set

				minCriticalSetLevel = Math.min(minCriticalSetLevel, currentLevel);

				maxCriticalSetLevel = Math.max(maxCriticalSetLevel, currentLevel);

				// check peak condition

				peakMode = currentLevel < this.component.getMinCapacity() || 

						currentLevel > this.component.getMaxCapacity();				

				// check if exit from peak condition

				if (!peakMode) {

					// check over production

					if (maxCriticalSetLevel > this.component.getMaxCapacity()) {

						// get the maximum (positive) amount of over production

						// create reservoir overflow flaw

						ReservoirOverflow overflow = new ReservoirOverflow(

								FLAW_COUNTER.getAndIncrement(), 

								this.component, 

								criticalSet, 

								startPeakLevel,

								delta);

						// add flaw and stop searching 

						flaws.add(overflow);

					}

					// check over consumption

					if (minCriticalSetLevel < this.component.getMinCapacity()) {

						// get (negative) amount of over consumption

						// create reservoir overflow flaw

						ReservoirOverflow overflow = new ReservoirOverflow(

								FLAW_COUNTER.getAndIncrement(), 

								this.component, 

								criticalSet, 

								startPeakLevel,

								delta);

						// add flaw and stop searching 

						flaws.add(overflow);

					}

				}

			}

		}

		// check if a peak must be closed - "final peak"

		if (peakMode && flaws.isEmpty()) {

			// check over production

			if (maxCriticalSetLevel > this.component.getMaxCapacity()) {

				// get the maximum (positive) amount of over production

				// create reservoir overflow flaw

				ReservoirOverflow overflow = new ReservoirOverflow(

						FLAW_COUNTER.getAndIncrement(), 

						this.component, 

						criticalSet, 

						startPeakLevel,

						delta);

				// add flaw and stop searching 

				flaws.add(overflow);

			}

			// check over consumption

			if (minCriticalSetLevel < this.component.getMinCapacity()) {

				// get (negative) amount of over consumption

				// create reservoir overflow flaw

				ReservoirOverflow overflow = new ReservoirOverflow(

						FLAW_COUNTER.getAndIncrement(), 

						this.component, 

						criticalSet, 

						startPeakLevel,

						delta);

				// add flaw and stop searching 

				flaws.add(overflow);

			}

		}

		// get found peaks - only one element expected

		return flaws;