pstlab / PLATINUm

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.Decision;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.DomainComponent;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.ex.DecisionPropagationException;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.ex.FlawSolutionApplicationException;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.ex.RelationPropagationException;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.pdb.ParameterSynchronizationConstraint;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.pdb.SynchronizationConstraint;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.pdb.SynchronizationRule;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.pdb.TemporalSynchronizationConstraint;

import it.cnr.istc.pst.platinum.ai.framework.domain.component.pdb.TokenVariable;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.ConstraintCategory;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.ex.ConsistencyCheckException;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.flaw.Flaw;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.flaw.FlawSolution;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.relations.Relation;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.relations.RelationType;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.relations.parameter.BindParameterRelation;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.relations.parameter.EqualParameterRelation;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.relations.parameter.NotEqualParameterRelation;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.relations.parameter.ParameterRelation;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.relations.temporal.BeforeRelation;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.lang.relations.temporal.TemporalRelation;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.resolver.Resolver;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.resolver.ResolverType;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.resolver.ex.UnsolvableFlawException;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.resolver.plan.GoalJustification.JustificationType;

import it.cnr.istc.pst.platinum.ai.framework.time.ex.TemporalConstraintPropagationException;

import it.cnr.istc.pst.platinum.ai.framework.time.lang.TemporalConstraintType;

import it.cnr.istc.pst.platinum.ai.framework.time.lang.allen.BeforeIntervalConstraint;

import it.cnr.istc.pst.platinum.ai.framework.utils.properties.FilePropertyReader;

/**

 * 

 * @author alessandro

 *

 */

public class TimelineAwarePlanRefinementResolver extends Resolver<DomainComponent> {

	private boolean load;

	private double expansionCost;

	private double unificationCost;

	/**

	 * 

	 */

	protected TimelineAwarePlanRefinementResolver() {

		super(ResolverType.TIMELINE_AWARE_PLAN_REFINEMENT.getLabel(),

				ResolverType.TIMELINE_AWARE_PLAN_REFINEMENT.getFlawTypes());

		// flag to load parameters when it is necessary

		this.load = false;

	}

	/**

	 * 

	 */

	private void load() {

		// get deliberative property file

		FilePropertyReader properties = new FilePropertyReader(

				FRAMEWORK_HOME + FilePropertyReader.DEFAULT_DELIBERATIVE_PROPERTY);

		// read weights

		this.expansionCost = Double.parseDouble(properties.getProperty("expansion-cost"));

		this.unificationCost = Double.parseDouble(properties.getProperty("unification-cost"));

		// set load flag

		this.load = true;

	}

	/**

	 * 

	 */

	/**

	 * 

	 */

	protected void doComputeFlawSolutions(Flaw flaw) 

			throws UnsolvableFlawException {

		// get goal

		Goal goal = (Goal) flaw;

		// check solving information

		if (!goal.isMandatoryExpansion()) {

			// compute unification solutions

			this.doComputeUnificationSolutions(goal);

		}

		// check solving information

		if (!goal.isMandatoryUnification()) {

			// compute expansion solutions

			this.doComputeExpansionSolutions(goal);

		}

		// check if solvable

		if (!goal.isSolvable()) {

			// simply throw exception

			throw new UnsolvableFlawException("Unsolvable flaw found on component " + this.component.getName() + ":"

					+ "\n" + flaw + "\n");

		}

	}

	/**

	 * 

	 * @param solution

	 * @throws Exception

	 */

	@Override

	protected void doApply(FlawSolution solution) 

			throws FlawSolutionApplicationException 

	{

		// get goal justification

		GoalJustification just = (GoalJustification) solution;

		// check type 

		switch (just.getJustificationType()) 

		{

			// expansion step

			case EXPANSION : {

				// apply solution

				this.doApplyExpansion((GoalExpansion) just);

			}

			break;

			// unification step

			case UNIFICATION : {

				// apply solution

				this.doApplyUnification((GoalUnification) just);

			}

			break;

		}

	}

	/**

	 * 

	 */

	@Override

	protected void doRestore(FlawSolution solution) 

			throws DecisionPropagationException, RelationPropagationException 

	{

		// get goal justification

		GoalJustification just = (GoalJustification) solution;

		// check if unification 

		if (just.getJustificationType().equals(JustificationType.UNIFICATION)) {

			// restore unification

			this.doRestoreUnification((GoalUnification) just);

		}

		else {

			// "standard" way of restoring a flaw solution

			super.doRestore(solution);

		}

	}

	/**

	 * 

	 * @param solution

	 * @throws RelationPropagationException

	 */

			throws RelationPropagationException {

		// restore relation translation

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

			// check relation category

			if (rel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT)) {

				// replace reference

				rel.setReference(solution.getUnificationDecision());

			}

			if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT)) {

				// check relation type

				switch (rel.getType()) {

					// bind parameter

					case BIND_PARAMETER: 

					{

						// the goal can be only the reference of the relation

						ParameterRelation pRel = (ParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = pRel.getReferenceParameterLabel();

						// get label index

						int refParameterIndex = pRel.getReference().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = solution.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);

						// update reference decision 

						pRel.setReference(solution.getUnificationDecision());

						// update reference label of the relation 

						pRel.setReferenceParameterLabel(label);

					}

					break;

					case EQUAL_PARAMETER : 

					{

						// get parameter relation

						EqualParameterRelation eqRel = (EqualParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = eqRel.getReferenceParameterLabel();

						// get label index

						int refParameterIndex = eqRel.getReference().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = solution.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);

						// update reference decision 

						eqRel.setReference(solution.getUnificationDecision());

						// update reference label of the relation 

						eqRel.setReferenceParameterLabel(label);

					}

					break;

					case NOT_EQUAL_PARAMETER : 

					{

						// get parameter relation

						NotEqualParameterRelation neqRel = (NotEqualParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = neqRel.getReferenceParameterLabel();

						// get label index

						int refParameterIndex = neqRel.getReference().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = solution.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);

						// update reference decision 

						neqRel.setReference(solution.getUnificationDecision());

						// update reference label of the relation 

						neqRel.setReferenceParameterLabel(label);

					}

					break;

					default:

						// unknown parameter relation

				}

			}

		}

		// restore relation translation

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

			// check relation category

			if (rel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT)) {

				// replace reference

				rel.setTarget(solution.getUnificationDecision());

			}

			if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT)) {

				// check relation type

				switch (rel.getType()) {

					case EQUAL_PARAMETER : 

					{

						// get parameter relation

						EqualParameterRelation eqRel = (EqualParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = eqRel.getTargetParameterLabel();

						// get label index

						int refParameterIndex = eqRel.getTarget().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = solution.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);

						// update reference decision 

						eqRel.setTarget(solution.getUnificationDecision());

						// update reference label of the relation 

						eqRel.setTargetParameterLabel(label);

					}

					break;

					case NOT_EQUAL_PARAMETER : 

					{

						// get parameter relation

						NotEqualParameterRelation neqRel = (NotEqualParameterRelation) rel;

						// get relation reference parameter label

						String refParamLabel = neqRel.getTargetParameterLabel();

						// get label index

						int refParameterIndex = neqRel.getTarget().getParameterIndexByLabel(refParamLabel);

						// get unification decision parameter label

						String label = solution.getUnificationDecision().getParameterLabelByIndex(refParameterIndex);

						// update reference decision 

						neqRel.setTarget(solution.getUnificationDecision());

						// update reference label of the relation 

						neqRel.setTargetParameterLabel(label);

					}

					break;

					default:

						// unknown parameter relation

				}

			}

		}

		// list of committed parameter constraints

		Set<Relation> committed = new HashSet<>();

		try	

		{

			// get goal component

			DomainComponent gComp = solution.getGoalDecision().getComponent();

			// remove original goal: PENDING -> SILENT

			gComp.free(solution.getGoalDecision());

			// activate translated relations

			for (Relation rel : solution.getActivatedRelations()) 

			{

				// check if can be activated

				if (rel.getReference().getComponent().activate(rel)) {

					// add relation to the committed list

					committed.add(rel);

				}

			}

			// check consistency

			this.tdb.verify();

			this.pdb.verify();

		} catch (RelationPropagationException | ConsistencyCheckException ex) {

			// get goal component

			DomainComponent gComp = solution.getGoalDecision().getComponent();

			// restore goal: SILENT -> PENDING

			gComp.restore(solution.getGoalDecision());

			// deactivate committed relations

			for (Relation rel : committed) {

				// get reference component

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

				refComp.deactivate(rel);

			}

			// translated back relations

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

				// check category

				if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT)) {

					// get parameter relation

					ParameterRelation pRel = (ParameterRelation) rel;

					// get relation reference parameter label

					String refParamLabel = pRel.getReferenceParameterLabel();

					// get label index

					int pIndex = pRel.getReference().getParameterIndexByLabel(refParamLabel);

					// get goal decision parameter label

					String label = solution.getGoalDecision().getParameterLabelByIndex(pIndex);

					// update relation

					pRel.setReference(solution.getGoalDecision());

					pRel.setReferenceParameterLabel(label);

				}

				if (rel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT)) {

					// update relation

					rel.setReference(solution.getGoalDecision());

				}

			}

			// translated back parameter relations

			for (Relation rel : solution.getTranslatedTargetGoalRelations())

			{

				// check relation category 

				if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT))

				{

					// check relation

					switch (rel.getType())

					{

						case EQUAL_PARAMETER : 

						{

							// get equal relation

							EqualParameterRelation eqRel = (EqualParameterRelation) rel;

							// get relation reference parameter label

							String tarParamLabel = eqRel.getTargetParameterLabel();

							// get label index

							int pIndex = eqRel.getTarget().getParameterIndexByLabel(tarParamLabel);

							// get goal decision parameter label

							String label = solution.getGoalDecision().getParameterLabelByIndex(pIndex);

							// update relation

							eqRel.setTarget(solution.getGoalDecision());

							eqRel.setTargetParameterLabel(label);

						}

						break;

						case NOT_EQUAL_PARAMETER : 

						{

							// get equal relation

							NotEqualParameterRelation neqRel = (NotEqualParameterRelation) rel;

							// get relation reference parameter label

							String tarParamLabel = neqRel.getTargetParameterLabel();

							// get label index

							int pIndex = neqRel.getTarget().getParameterIndexByLabel(tarParamLabel);

							// get goal decision parameter label

							String label = solution.getGoalDecision().getParameterLabelByIndex(pIndex);

							// update relation

							neqRel.setTarget(solution.getGoalDecision());

							neqRel.setTargetParameterLabel(label);

						}

						break;

						default:

							// unknown parameter relation

					}

				}

				// check temporal relation

				if (rel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT))

				{

					// update relation

					rel.setTarget(solution.getGoalDecision());

				}

			}

			// not feasible solution

			throw new RelationPropagationException(ex.getMessage());

		}

	}

	/**

	 * 

	 */

	@Override

	protected void doRetract(FlawSolution solution) {

		// check solution type

		GoalJustification justif = (GoalJustification) solution;

		// check if unification solution

		if (justif.getJustificationType().equals(JustificationType.UNIFICATION)) {

			// special management of unification

			this.doRetractUnification((GoalUnification) solution);

		}

		else {

			// "standard" management of flaw solution

			super.doRetract(solution);

		}

	}

	/**

	 * 

	 * @param goal

	 */

		// get goal component

		DomainComponent gComp = goal.getComponent();

		// list of goal unifications found

		List<GoalUnification> unifications = new ArrayList<>();

		// search active decisions that can be unified with the goal

		for (Decision unif : gComp.getActiveDecisions()) {

			// check predicate and temporal unification

			if (this.isPredicateUnificationFeasible(goal.getDecision(), unif) && 

					this.isTemporalUnificationFeasible(goal.getDecision(), unif)) {

				// possible unification found

				GoalUnification unification = new GoalUnification(goal, unif, this.unificationCost);

				// add unifications

				unifications.add(unification);

				info("Feasible unification found:\n"

						+ "- planning goal: " + goal + "\n"

						+ "- unification decision: " + unification + "\n");

			}

			else {

				// unification not feasible

				debug("No feasible unification:\n"

						+ "- planning goal: " + goal + "\n"

						+ "- decision : \"" + unif + "\"\n");

			}

		}

		// add unifications as goal solutions

		Collections.shuffle(unifications);

		for (GoalUnification unif : unifications) {

			goal.addSolution(unif);

		}

	}

	/**

	 * 

	 * @param goal

	 * @param decision

	 * @return

	 */

		// feasibility flag

		boolean feasible = true;

		// first check if the decisions refer to the same values

		if (!decision.getValue().equals(goal.getValue()) && 

				decision.getComponent().equals(goal.getComponent())) {

			// not feasible unification

			feasible = false;

			debug("Not feasible predicate unification:\n"

					+ "- planning goal: " + goal + "\n"

					+ "- unification decision: " + decision + "\n"); 

		} else {

			// list of committed parameter constraints

			Set<Relation> committed = new HashSet<>();

			// list of translated parameter relations - reference

			Set<ParameterRelation> translatedReferenceGoalRelations = new HashSet<>();

			// list of translated parameter relations - target

			Set<ParameterRelation> translatedTargetGoalRelations = new HashSet<>();

			// get goal component

			DomainComponent goalComp = goal.getComponent();

			// get all (pending) relation concerning the goal decision

			Set<Relation> pending = goalComp.getRelations(goal);

			// check relations

			for (Relation rel : pending)

			{

				// check parameter constraint type

				if (rel.getCategory().equals(ConstraintCategory.PARAMETER_CONSTRAINT))

				{

					// check relation type

					switch (rel.getType())

					{

						// bind parameter

						case BIND_PARAMETER: 

						{

							// the goal can be only the reference of the relation

							ParameterRelation pRel = (ParameterRelation) rel;

							// get relation reference parameter label

							String refParamLabel = pRel.getReferenceParameterLabel();

							// get label index

							int refParameterIndex = pRel.getReference().getParameterIndexByLabel(refParamLabel);

							// get unification decision parameter label

							String label = decision.getParameterLabelByIndex(refParameterIndex);

							// update reference decision 

							pRel.setReference(decision);

							// update reference label of the relation 

							pRel.setReferenceParameterLabel(label);

							// add relation to the list of translated ones

							translatedReferenceGoalRelations.add(pRel);

						}

						break;

						case EQUAL_PARAMETER : 

						{

							// get parameter relation

							EqualParameterRelation eqRel = (EqualParameterRelation) rel;

							// check if the goal is the reference or the parameter constraint 

							if (eqRel.getReference().equals(goal))

							{

								// get relation reference parameter label

								String refParamLabel = eqRel.getReferenceParameterLabel();

								// get label index

								int refParameterIndex = eqRel.getReference().getParameterIndexByLabel(refParamLabel);

								// get unification decision parameter label

								String label = decision.getParameterLabelByIndex(refParameterIndex);

								// update reference decision 

								eqRel.setReference(decision);

								// update reference label of the relation 

								eqRel.setReferenceParameterLabel(label);

								// add relation to the list of translated ones

								translatedReferenceGoalRelations.add(eqRel);

							}

							else // the goal is the target of the relation 

							{

								// get relation reference parameter label

								String refParamLabel = eqRel.getTargetParameterLabel();

								// get label index

								int refParameterIndex = eqRel.getTarget().getParameterIndexByLabel(refParamLabel);

								// get unification decision parameter label

								String label = decision.getParameterLabelByIndex(refParameterIndex);

								// update reference decision 

								eqRel.setTarget(decision);

								// update reference label of the relation 

								eqRel.setTargetParameterLabel(label);

								// add relation to the list of translated ones

								translatedTargetGoalRelations.add(eqRel);

							}

						}

						break;

						case NOT_EQUAL_PARAMETER : 

						{

							// get parameter relation

							NotEqualParameterRelation neqRel = (NotEqualParameterRelation) rel;

							// check if the goal is the reference or the parameter constraint 

							if (neqRel.getReference().equals(goal))

							{

								// get relation reference parameter label

								String refParamLabel = neqRel.getReferenceParameterLabel();

								// get label index

								int refParameterIndex = neqRel.getReference().getParameterIndexByLabel(refParamLabel);

								// get unification decision parameter label

								String label = decision.getParameterLabelByIndex(refParameterIndex);

								// update reference decision 

								neqRel.setReference(decision);

								// update reference label of the relation 

								neqRel.setReferenceParameterLabel(label);

								// add relation to the list of translated ones

								translatedReferenceGoalRelations.add(neqRel);

							}

							else // the goal is the target of the relation 

							{

								// get relation reference parameter label

								String refParamLabel = neqRel.getTargetParameterLabel();

								// get label index

								int refParameterIndex = neqRel.getTarget().getParameterIndexByLabel(refParamLabel);

								// get unification decision parameter label

								String label = decision.getParameterLabelByIndex(refParameterIndex);

								// update reference decision 

								neqRel.setTarget(decision);

								// update reference label of the relation 

								neqRel.setTargetParameterLabel(label);

								// add relation to the list of translated ones

								translatedTargetGoalRelations.add(neqRel);

							}

						}

						break;

						default:

							// unknown parameter relation

					}

				}

			}

			try {

				// activate translated relations

				for (Relation rel : translatedReferenceGoalRelations) {

					// check if can be activated

					if (rel.getReference().getComponent().activate(rel)) {

						// add relation to the committed list

						committed.add(rel);

					}

				}

				// activate translated relations

				for (Relation rel : translatedTargetGoalRelations) {

					// check if can be activated

					if (rel.getReference().getComponent().activate(rel)) {

						// add relation to the committed list

						committed.add(rel);

					}

				}

				// check parameter of the plan

				this.pdb.verify();

			}

			catch (ConsistencyCheckException | RelationPropagationException ex) {

				// not feasible 

				feasible = false;

				// not feasible unification

				debug("Not feasible predicate unification:\n"

						+ "- planning goal: " + goal + "\n"

						+ "- unification decision: " + decision + "\n");

			} finally  {

				// check committed relations

				for (Relation rel : committed) {

					// deactivate relation

					rel.getReference().getComponent().deactivate(rel);

				}

				// translated back parameter relations

				for (ParameterRelation rel : translatedReferenceGoalRelations) {

					// get relation reference parameter label

					String refParamLabel = rel.getReferenceParameterLabel();

					// get label index

					int pIndex = rel.getReference().getParameterIndexByLabel(refParamLabel);

					// get goal decision parameter label

					String label = goal.getParameterLabelByIndex(pIndex);

					// update relation

					rel.setReference(goal);

					rel.setReferenceParameterLabel(label);

				}

				// translated back parameter relations

				for (ParameterRelation rel : translatedTargetGoalRelations)

				{

					// check relation

					switch (rel.getType())

					{

						case EQUAL_PARAMETER : 

						{

							// get equal relation

							EqualParameterRelation eqRel = (EqualParameterRelation) rel;

							// get relation reference parameter label

							String tarParamLabel = eqRel.getTargetParameterLabel();

							// get label index

							int pIndex = eqRel.getTarget().getParameterIndexByLabel(tarParamLabel);

							// get goal decision parameter label

							String label = goal.getParameterLabelByIndex(pIndex);

							// update relation

							eqRel.setTarget(goal);

							eqRel.setTargetParameterLabel(label);

						}

						break;

						case NOT_EQUAL_PARAMETER : 

						{

							// get equal relation

							NotEqualParameterRelation neqRel = (NotEqualParameterRelation) rel;

							// get relation reference parameter label

							String tarParamLabel = neqRel.getTargetParameterLabel();

							// get label index

							int pIndex = neqRel.getTarget().getParameterIndexByLabel(tarParamLabel);

							// get goal decision parameter label

							String label = goal.getParameterLabelByIndex(pIndex);

							// update relation

							neqRel.setTarget(goal);

							neqRel.setTargetParameterLabel(label);

						}

						break;

						default:

							// unknown parameter relation

					}

				}

			}

		}

		// get feasibility flag

		return feasible;

	}

	/**

	 * 

	 * @param goal

	 * @param decision

	 * @return

	 */

		// feasibility flag

		boolean feasible = true;

		// list of translated relations

		Set<Relation> translated = new HashSet<>();

		// list of committed relations

		Set<Relation> committed = new HashSet<>();

		// get goal component 

		DomainComponent gComp = goal.getComponent();

		// get all (pending) relations associated to the goal 

		Set<Relation> pRels = gComp.getRelations(goal);

		// translate relations

		for (Relation pRel : pRels)

		{

			// focus on temporal relations only 

			if (pRel.getCategory().equals(ConstraintCategory.TEMPORAL_CONSTRAINT))

			{

				// check relation reference

				if (pRel.getReference().equals(goal)) {

					// replace reference

					pRel.setReference(decision);

					// add translated relation

					translated.add(pRel);

				}

				// check relation target

				if (pRel.getTarget().equals(goal)) {

					// replace target

					pRel.setTarget(decision);

					// add translated relation

					translated.add(pRel);

				}

			}

		}

		try {

			// check translated relation and activate them if possible

			for (Relation tRel : translated) {

				// activate relation

				if (tRel.getReference().getComponent().activate(tRel)) {

					// add relation to committed list

					committed.add(tRel);

				}

			}

			// check temporal consistency after activated relations

			this.tdb.verify();

		} catch (ConsistencyCheckException | RelationPropagationException ex) {

			// not feasible unification 

			feasible = false;

			// not feasible unification

			debug("Not feasible temporal unification:\n"

					+ "- planning goal: " + goal + "\n"

					+ "- unification decision: " + decision + "\n");

		} finally {

			// deactivate relations

			for (Relation rel : committed) {

				// deactivate relation

				rel.getReference().getComponent().deactivate(rel);

			}

			// translate back relations

			for (Relation rel : translated) {

				// check reference 

				if (rel.getReference().equals(decision)) {

					// replace reference

					rel.setReference(goal);

				}

				// check target

				if (rel.getTarget().equals(decision)) {

					// replace target

					rel.setTarget(goal);

				}

			}

		}

		// get feasibility flag

		return feasible;

	}

	/**

	 * 

	 * @param goal

	 */

	private void doComputeExpansionSolutions(Goal goal) {

		// get component

		DomainComponent gComp = goal.getComponent();

		// buffer of activated relations

		Set<Relation> rels = new HashSet<>();

		try {

			// get the list of current tokens on the timeline

			List<Decision> tokens = gComp.getActiveDecisions();

			// activate goal decision and check its feasibility

			rels = gComp.activate(goal.getDecision());

			// check temporal and parameter consistency

			this.tdb.verify();

			this.pdb.verify();

			info("Goal decision consistent.. check possible schedules and refinements\n-\t " + goal.getDecision());

			// evaluate possible schedules of the goal w.r.t. existing tokens.

			if (!tokens.isEmpty()) {

				// create relation

				BeforeIntervalConstraint c0 = this.tdb.createTemporalConstraint(

						TemporalConstraintType.BEFORE);

				// set constraint data

				c0.setReference(goal.getDecision().getToken().getInterval());

				c0.setTarget(tokens.get(0).getToken().getInterval());

				c0.setLowerBound(0);

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

					// propagate temporal constraint

					this.tdb.propagate(c0);

					// check temporal consistency

					this.tdb.verify();

					//  consistent so create a possible refinements considering this schedule

					for (GoalExpansion exp : this.expansions(goal)) {

						// add goal schedule

						exp.addGoalSchedule(new GoalSchedule(

								goal.getDecision(),

								tokens.get(0),

								0,

								this.tdb.getHorizon()));

						// add expansion and related relation as feasible refinement of the goal

						goal.addSolution(exp);

						debug("Add goal expansion solution\n\t- " + exp + "\n");

					}

				} catch (TemporalConstraintPropagationException | ConsistencyCheckException  ix) {

					// infeasible schedule of the decision

					debug("Infeasible schedule of goal " + goal.getDecision() + "\n"

							+ "\t- goal: " + goal.getDecision() + "\n"

							+ "\t- token: " + tokens.get(0) + "\n");

				} finally {

					// discard propagated constraints

					this.tdb.retract(c0);

				}

				// iterate over tokens to find feasible schedule of the activated one

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

					// create temporal constraint

					BeforeIntervalConstraint c1 = this.tdb.createTemporalConstraint(

							TemporalConstraintType.BEFORE);

					// set constraint data

					c1.setReference(tokens.get(index).getToken().getInterval());

					c1.setTarget(goal.getDecision().getToken().getInterval());

					c1.setLowerBound(0);

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

					// create temporal constraint

					BeforeIntervalConstraint c2 = this.tdb.createTemporalConstraint(

							TemporalConstraintType.BEFORE);

					// set constraint data

					c2.setReference(goal.getDecision().getToken().getInterval());

					c2.setTarget(tokens.get(index + 1).getToken().getInterval());

					c2.setLowerBound(0);

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

					try {

						// propagate constraints

						this.tdb.propagate(c1);

						this.tdb.propagate(c2);

						// check temporal consistency

						this.tdb.verify();

						//  consistent so create a possible refinements considering this schedule

						for (GoalExpansion exp : this.expansions(goal)) {

							// add goal schedules

							exp.addGoalSchedule(new GoalSchedule(

									tokens.get(index), 

									goal.getDecision(),

									0,

									this.tdb.getHorizon()));

							exp.addGoalSchedule(new GoalSchedule(

									goal.getDecision(),

									tokens.get(index + 1),

									0,

									this.tdb.getHorizon()));

							// add expansion and related relation as feasible refinement of the goal

							goal.addSolution(exp);

							debug("Add goal expansion solution\n\t- " + exp + "\n");

						}

					} catch (TemporalConstraintPropagationException | ConsistencyCheckException  ix) {

						// infeasible schedule of the decision

						debug("Infeasible schedule of goal " + goal.getDecision() + "\n"

								+ "\t- token: " + tokens.get(index) + "\n"

								+ "\t- goal: " + goal.getDecision() + "\n"

								+ "\t- token: " + tokens.get(index + 1) + "\n");

					} finally {

						// discard propagated constraints

						this.tdb.retract(c1);

						this.tdb.retract(c2);

					}

				}

				// check last token

				// create temporal constraint

				BeforeIntervalConstraint c3 = this.tdb.createTemporalConstraint(

						TemporalConstraintType.BEFORE);

				// set constraint data

				c3.setReference(tokens.get(tokens.size() - 1).getToken().getInterval());

				c3.setTarget(goal.getDecision().getToken().getInterval());

				c3.setLowerBound(0);

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

					// propagate temporal constraint

					this.tdb.propagate(c3);

					// check temporal consistency