pstlab / PLATINUm

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import it.cnr.istc.pst.platinum.ai.deliberative.heuristic.FlawSelectionHeuristic;

import it.cnr.istc.pst.platinum.ai.deliberative.strategy.SearchStrategy;

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

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

import it.cnr.istc.pst.platinum.ai.framework.microkernel.annotation.inject.deliberative.FlawSelectionHeuristicPlaceholder;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.annotation.inject.deliberative.SearchStrategyPlaceholder;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.annotation.inject.framework.PlanDataBasePlaceholder;

import it.cnr.istc.pst.platinum.ai.framework.microkernel.annotation.lifecycle.PostConstruct;

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

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

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

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.plan.Plan;

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

/**

 * 

 * @author anacleto

 *

 */

public abstract class Solver extends FrameworkObject {

	@PlanDataBasePlaceholder

	protected PlanDataBase pdb;

	@SearchStrategyPlaceholder

	protected SearchStrategy fringe;

	@FlawSelectionHeuristicPlaceholder

	protected FlawSelectionHeuristic heuristic;

	protected long timeout;

	protected long time;

	protected long stepCounter;

	protected String label;

	/**

	 * 

	 * @param label

	 * @param timeout

	 */

	protected Solver(String label, long timeout) {

		super();

		this.label = label;

		this.timeout = timeout;

	}

	/**

	 * 

	 */

	@PostConstruct

	protected void init() {

		// create the root node

		SearchSpaceNode root = new SearchSpaceNode();

		// set initial partial plan

		root.setPartialPlan(this.pdb.getPlan());

		// check flaws

		for (Flaw f : this.pdb.checkFlaws()) {

			root.addCheckedFlaw(f);

		}

		// enqueue the root node

		this.fringe.enqueue(root);

	}

	/**

	 * 

	 * @return

	 * @throws NoSolutionFoundException

	 */

	public abstract SearchSpaceNode solve() 

			throws NoSolutionFoundException;

	/**

	 * 

	 */

	public abstract void clear();

	/**

	 * 

	 * @return

	 */

	protected SearchSpaceNode createSearchSpaceNode() {

		return new SearchSpaceNode();

	}

	/**

	 * 

	 * @return

	 */

	public String getLabel() {

		return label;

	}

	/**

	 * 

	 * @param node

	 */

	protected void backtrack(SearchSpaceNode node) 

	{

		// list of operators that have been applied to generate the node

		List<Operator> operators = node.getOperators();

		// retract operators starting from the more recent ones

		Collections.reverse(operators);

		// retract all operators

		for (Operator operator : operators) {

			// retract operator

			this.pdb.retract(operator);

		}

	}

	/**

	 * 

	 * @param node

	 * @throws OperatorPropagationException

	 */

	protected void propagate(SearchSpaceNode node) 

			throws PlanRefinementException {

		// get the list of applied operators

		List<Operator> operators = node.getOperators();

		// list of committed operators

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

		try {

			// propagate operators in chronological order

			for (Operator operator : operators) {

				// propagate operator

				this.pdb.propagate(operator);

				// add committed operator

				committed.add(operator);

			}

		} catch (OperatorPropagationException ex) {

			// retract committed operators in reverse order

			Collections.reverse(committed);

			for (Operator operator : committed) {

				this.pdb.retract(operator);

			}

			// throw exception

			throw new PlanRefinementException("Error while propagating node:\n" + node + "\n- message: " + ex.getMessage() + "\n");

		}

	}

	/**

	 * 

	 * @param last

	 * @param extracted

	 * @throws PlanRefinementException

	 */

	}

	/**

	 * 

	 * Expand the search space by adding a new node for each solution of the flaw selected for 

	 * plan refinement

	 * 

	 * @param current

	 * @param flaw

	 * @return

	 * @throws UnsolvableFlawException

	 */

	protected List<SearchSpaceNode> expand(SearchSpaceNode current, Flaw flaw) 

			throws UnsolvableFlawException {

		// list of child nodes

		List<SearchSpaceNode> list = new ArrayList<>();

		// check if no expansion has done

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

			// this is for debug mainly, as this condition should never occur. Computed flaw solutions should be valid 

			throw new UnsolvableFlawException("Search space expansion failure as no valid operator can be applied:\n"

					+ "- current node: " + current + "\n"

					+ "- flaw: " + flaw + "\n");

		}

		// check flaw solutions

		for (FlawSolution solution : flaw.getSolutions()) {

			// create operator

			Operator op = new Operator(solution);

			try {

				// propagate operator

				this.pdb.propagate(op);

				// get plan with updated temporal bounds and variable binding

				Plan plan = this.pdb.getPlan();

				// create a child search space node

				SearchSpaceNode child = new SearchSpaceNode(current, op);

				// set partial plan

				child.setPartialPlan(plan);

				// look ahead of flaws representing the agenda of the node

				for (Flaw f : this.pdb.checkFlaws()) {

					// add checked flaw

					child.addCheckedFlaw(f);

				}

				// add child

				list.add(child);

				// retract operator

				this.pdb.retract(op);

			} catch (OperatorPropagationException ex) {

				// flaw with unsolvable solution

				throw new UnsolvableFlawException("Flaw with unsolvable solution found:\n- msg: " + ex.getMessage() + "\n");

			}

		}

		// get children

		return list;

	}

}