pstlab / PLATINUm

@DomainKnowledgeConfiguration(

		// set domain knowledge

		knowledge = DomainKnowledgeType.STATIC

)

@TemporalFacadeConfiguration(

		// set temporal network 

		network = TemporalNetworkType.STNU, 

		// set planner solver

		solver = TemporalSolverType.APSP

)

@ParameterFacadeConfiguration(

		// set parameter reasoner

		solver = ParameterSolverType.CHOCHO_SOLVER

)

{

	@DomainKnowledgePlaceholder

	protected DomainKnowledge knowledge;

	// see Composite design pattern

	private Map<String, DomainComponent> components;

	// the planning problem

	protected Problem problem;

	// domain theory

	private Map<String, ParameterDomain> parameterDomains;

	private boolean allowRecursiveRules;								// check if recursive rules are allowed

	/**

	 * 

	 * @param name

	 */

	@DomainComponentConfiguration(resolvers = {

			// no resolver is needed

	})

	protected PlanDataBaseComponent(String name) 

	{

		super(name, DomainComponentType.PLAN_DATABASE);

		// initialize data structures

		this.components = new HashMap<>();

		this.parameterDomains = new HashMap<>();

		this.problem = null;

		this.allowRecursiveRules = false;				// default behavior

	}

	/**

	 * 

	 */

	@PostConstruct

	protected synchronized void init() {

		super.init();

		// clear static (global) information

		synchronized (rules) {

			// clear if needed global synchronization rules

			rules.clear();

		}

		synchronized(globalRelations) {

			// clear if needed global relations

			globalRelations.clear();

		}

		// reset predicate counter

		PREDICATE_COUNTER.set(0);

		// reset decision counter

		DecisionIdCounter.set(0);

		// reset relation counter

		RELATION_COUNTER.set(0);

		// check property file

		FilePropertyReader properties = new FilePropertyReader(

				FRAMEWORK_HOME + FilePropertyReader.DEFAULT_DELIBERATIVE_PROPERTY);

		// check property flag

		this.allowRecursiveRules = properties.getProperty("allow-recursive-rules").equals("1");

	}

	/**

	 * 

	 */

	@Override

	public synchronized void setup(Problem problem) 

			throws ProblemInitializationException {

		// setup problem

		this.doSetupProblem(problem);

	}

	/**

	 * 

	 */

	@Override

	public synchronized void clear() 

	{

		// clear components

		for (DomainComponent component : this.components.values()) {

			// clear component

			component.clear();

		}

		// clear local relations

		this.localRelations.clear();

		// clear global relations

		synchronized (globalRelations) {

			// clear global active relations

			for (Relation rel : globalRelations) {

				// delete global relation

				this.deactivate(rel);

			}

			// clear global relations

			globalRelations.clear();

		}

		// clear problem

		this.problem = null;

		// clear domain knowledge

		this.knowledge = null;

	}

	/**

	 * 

	 */

	@Override

	public synchronized DomainKnowledge getDomainKnowledge() {

		return this.knowledge;

	}

	/*

	 * 

	 */

	@Override

	public synchronized void addSynchronizationRule(SynchronizationRule rule) 

			throws SynchronizationCycleException

	{

		// get head value

		ComponentValue value = rule.getTriggerer().getValue();

		// set the trigger as complex

		value.setComplex();

		// check data

		if (!rules.containsKey(value.getComponent())) {

			rules.put(value.getComponent(), new HashMap<ComponentValue, List<SynchronizationRule>>());

		}

		if (!rules.get(value.getComponent()).containsKey(value)) {

			// initialize

			rules.get(value.getComponent()).put(value, new ArrayList<SynchronizationRule>());

		}

		// look for cycles

		for (TokenVariable var : rule.getTokenVariables()) 

		{

			// get value 

			ComponentValue v = var.getValue();

			// check if this value is trigger of other synchronizations

			if (rules.containsKey(v.getComponent()) && rules.get(v.getComponent()).containsKey(v)) {

				// get synchronizations

				List<SynchronizationRule> existingRules = rules.get(v.getComponent()).get(v);

				for (SynchronizationRule existingRule : existingRules) {

					// get rule trigger

					TokenVariable existingRuleTrigger = existingRule.getTriggerer();

					// check constraint

					for (SynchronizationConstraint cons : existingRule.getConstraints()) {

						// consider temporal constraint for cycle detection

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

							// get constraint target

							TokenVariable target = cons.getTarget();

							if (!target.equals(existingRuleTrigger) && target.getValue().equals(value)) { 

								// we've got a cycle

								warning("A cycle has been detected after the introduction of synchronization rule\n" + rule + "\n");

								// check recursive rules flag

								if (!this.allowRecursiveRules) {

									// stop parsing on detected cycle

									throw new SynchronizationCycleException("A cycle has been detected after the introduction of synchronization rule " + rule);

								}

							}

						}

					}

				}

			}

		}

		// add rule if no cycle is detected

		rules.get(value.getComponent()).get(value).add(rule);

	}

	/**

	 * 

	 * @param value

	 * @return

	 */

	@Override

	public synchronized SynchronizationRule createSynchronizationRule(ComponentValue value, String[] labels) 

			throws DomainComponentNotFoundException 

	{

		// check if related component exists

		if (!this.getComponents().contains(value.getComponent())) {

			throw new DomainComponentNotFoundException("Value's component not found " + value);

		}

		// set value as complex

		value.setComplex();

		// create synchronization rule

		return new SynchronizationRule(value, labels);

	}

	/**

	 * 

	 */

	@Override

	public synchronized SolutionPlan getSolutionPlan() 

	{

		// create a plan

		SolutionPlan plan = new SolutionPlan(this.name, this.getHorizon());

		// set components

		for (DomainComponent component : this.components.values()) {

			// add a component to the plan

			plan.add(component);

		}

		// add active relations

		for (Relation rel : this.getActiveRelations()) {

			// add relation

			plan.add(rel);

		}

		// computer parameter solutions

		ComputeSolutionParameterQuery query = this.pdb.

				createQuery(ParameterQueryType.COMPUTE_SOLUTION);

		// process query

		this.pdb.process(query);

		// get current plan

		return plan;

	}

	/**

	 * Compute the duration of a plan as the minimum and maximal average duration of the activities

	 * of its components 

	 */

	public synchronized double[] getMakespan() 

	{

		// set the initial minimal and maximal values

		double[] makespan = new double[] {

				0,

				0

			};

		// get the list of primitive components

		Set<DomainComponent> primset = new HashSet<>();

		// compute "local" makespan for each component

		for (DomainComponent comp : this.components.values()) 

		{

			// check type 

			if (comp.getType().equals(DomainComponentType.SV_PRIMITIVE)) 

			{

				// get local makespan

				double[] local = comp.getMakespan();

				// update "global" minimum makespan

				makespan[0] += local[0];

				// update "global" maximum makespan

				makespan[1] += local[1];

				// add component to primset

				primset.add(comp);

			}

		}

		// compute average values

		makespan[0] = makespan[0] / primset.size();

		makespan[1] = makespan[1] / primset.size();

		// get the makespan

		return makespan;

	}

	/**

	 * 

	 */

	public synchronized double[] getBehaviorDuration() 

	{

		// set the initial minimal and maximal values

		double[] duration = new double[] {

				0,

				0

			};

		// get the list of primitive components

		Set<DomainComponent> primset = new HashSet<>();

		// compute "local" makespan for each component

		for (DomainComponent comp : this.components.values()) 

		{

			// check type 

			if (comp.getType().equals(DomainComponentType.SV_PRIMITIVE)) 

			{

				// get local makespan

				double[] local = comp.getBehaviorDuration();

				// update "global" minimum makespan

				duration[0] += local[0];

				// update "global" maximum makespan

				duration[1] += local[1];

				// add component to primset

				primset.add(comp);

			}

		}

		// compute average values

		duration[0] = duration[0] / primset.size();

		duration[1] = duration[1] / primset.size();

		// get the duration

		return duration;

	}

	/**

	 * 

	 * @param decision

	 * @return

	 */

	private DecisionVariable prepareDecisionVariable(Decision decision) 

	{

		// get predicate

		Predicate predicate = decision.getToken().getPredicate();

		// prepare ground predicate

		String groundPredicate = predicate.getValue().getLabel();

		// check parameters

		for (Parameter<?> param : predicate.getParameters()) 

		{

			// query the plan database to retrieve values

			CheckValuesParameterQuery query = this.pdb.createQuery(ParameterQueryType.CHECK_PARAMETER_VALUES);

			query.setParameter(param);

			this.pdb.process(query);

			String val = "";

			// check parameter type

			{

				case ENUMERATION_PARAMETER_TYPE : 

				{

					EnumerationParameter ep = (EnumerationParameter) param;

					// check bounded values

					for (int index = 0; index < ep.getValues().length; index++) {

						if (index > 0) {

						}

					}

				}

				break;

				case NUMERIC_PARAMETER_TYPE : 

				{

					NumericParameter np = (NumericParameter) param;

					val += np.getLowerBound() + "_" + np.getUpperBound();

				}

				break;

			}

			// update grounded predicate

		}

		IntervalScheduleQuery query = this.tdb.createTemporalQuery(TemporalQueryType.INTERVAL_SCHEDULE);

		query.setInterval(decision.getToken().getInterval());

		this.tdb.process(query);

		TemporalInterval i = query.getInterval();

		// add decision variable to plan description

		return new DecisionVariable(

				decision.getId(), 

				decision.getComponent().getName(), 

				groundPredicate, 

				new long[] {i.getStartTime().getLowerBound(), i.getStartTime().getUpperBound()}, 

				new long[] {i.getEndTime().getLowerBound(), i.getEndTime().getUpperBound()}, 

				new long[] {i.getDurationLowerBound(), i.getDurationUpperBound()});

	}

	/**

	 * 

	 * @return

	 */

	@Override

	public synchronized Plan getPlan() 

	{

		// initialize the plan

		Plan plan = new Plan();

		// set decisions

		for (Decision decision : this.getActiveDecisions())  

		{

			// add decision variable to plan description

			plan.add(decision.getComponent(), this.prepareDecisionVariable(decision));

//			plan.add(goal);

		}

		// set relations

		for (Relation rel : this.getActiveRelations()) {

			plan.add(rel);

		}

		// get the plan

		return plan;

	}

	/**

	 * 

	 */

//	@Override

//	public synchronized Plan getPlan(PlanElementStatus status) 

//	{

//		// prepare the plan

//		Plan plan = new Plan();

//		// check desired level

//		switch (status) 

//		{

//			// get the plan

//			case ACTIVE : {

//				// get currently active plan

//				plan = this.getPlan();

//			}

//			break;

//			

//			// get the pending plan

//			case PENDING : {

//				// get pending decisions

//				for (Decision decision : this.getPendingDecisions()) {

//					plan.add(decision);

//				}

//				// get pending relations

//				for (Relation rel : this.getPendingRelations()) {

//					plan.add(rel);

//				}

//			}

//			break;

//			

//			// get silent plan

//			case SILENT : {

//				// get silent decisions

//				for (Decision decision : this.getSilentDecisions()) {

//					plan.add(decision);

//				}

//				// get silent relations

//				for (Relation rel : this.getSilentRelations()) {

//					plan.add(rel);

//				}

//			}

//			break;

//		}

//		

//		return plan;

//	}

	/**

	 * 

	 */

	@Override

	public synchronized List<DomainComponent> getComponents() {

		return new ArrayList<>(this.components.values());

	}

	/**

	 * 

	 */

	@Override

	public synchronized DomainComponent getComponentByName(String name) {

		if (!this.components.containsKey(name)) {

		}

		// get component

		return this.components.get(name);

	}

	/**

	 * Verify the temporal consistency of the plan.

	 * 

	 * If the underlying network is an STNU, then the 

	 * procedure checks also the pseudo-controllability

	 * of the plan. If the network is not pseudo-controllable

	 * the exception reports information concerning the values

	 * that have been "squeezed" during the solving process 

	 * 

	 * @throws ConsistencyCheckException

	 */

	@Override

	public synchronized void verify() 

			throws ConsistencyCheckException 

	{

		// check temporal consistency of the network

		this.tdb.verify();

		// check parameter consistency

		this.pdb.verify();

	}

	/**

	 * The method returns the list of all available domain values

	 */

	@Override

	public synchronized List<ComponentValue> getValues() {

		List<ComponentValue> values = new ArrayList<>();

		for (DomainComponent component : this.components.values()) {

			values.addAll(component.getValues());

		}

		// get all domain values

		return values;

	}

	/**

	 * 

	 */

	@Override

	public synchronized ComponentValue getValueByName(String name) {

		ComponentValue value = null;

		for (DomainComponent comp : this.components.values()) {

			for (ComponentValue v : comp.getValues()) {

				if (v.getLabel().equals(name)) {

					value = v;

					break;

				}

			}

			if (value != null) {

				break;

			}

		}

		// check if value has been found

		if (value == null) {

		}

		// get value

		return value;

	}

	/**

	 * 

	 * @param name

	 * @param type

	 */

	@Override

	public synchronized <T extends ParameterDomain> T createParameterDomain(String name, ParameterDomainType type) {

		// create parameter domain

		T pd = this.pdb.createParameterDomain(name, type);

		// add parameter domain

		this.parameterDomains.put(name, pd);

		return pd;

	}

	/**

	 * 

	 * @return

	 */

	@Override

	public synchronized List<ParameterDomain> getParameterDoamins() {

		return new ArrayList<>(this.parameterDomains.values());

	}

	/**

	 * 

	 * @param name

	 * @return

	 */

	@Override

	public synchronized ParameterDomain getParameterDomainByName(String name) {

		return this.parameterDomains.get(name);

	}

	/**

	 * 

	 * @param name

	 * @return

	 */

	@Override

	public synchronized <T extends DomainComponent> T createDomainComponent(String name, DomainComponentType type) 

	{

		// check if a component already exist

		if (this.components.containsKey(name)) {

		}

		// create domain component

		T c = DomainComponentBuilder.createAndSet(name, type, this.tdb, this.pdb);

		// get created component

		return c;

	}

	/**

	 * 

	 * @param component

	 */

	@Override

	public synchronized void addDomainComponent(DomainComponent component) {

		// add component

		this.components.put(component.getName(), component);

	}

	/**

	 * 

	 * @return

	 */

	@Override

	public synchronized List<Decision> getActiveDecisions() {

		// list of active decisions with schedule information

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

		// get schedule information from components

		for (DomainComponent comp : this.components.values()) {

			list.addAll(comp.getActiveDecisions());

		}

		// get list

		return list;

	}

	/**

	 * 

	 * @return

	 */

	@Override

	public synchronized List<Decision> getPendingDecisions() {

		// list of pending decisions

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

		for (DomainComponent comp : this.components.values()) {

			list.addAll(comp.getPendingDecisions());

		}

		// get list of pending decisions

		return list;

	}

	/**

	 * 

	 */

	@Override

	public synchronized Set<Relation> getPendingRelations(Decision dec) 

	{

		// get decision component 

		DomainComponent comp = dec.getComponent();

		return comp.getPendingRelations(dec);

	}

	/**

	 * 

	 */

	@Override 

	public synchronized void restore(Decision dec) {

		// dispatch request to the related component

		dec.getComponent().restore(dec);

	}

	/**

	 * 

	 */

	@Override

	public synchronized void restore(Relation rel) {

		// get reference component

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

		comp.restore(rel);

	}

	/**

	 * 

	 */

	@Override

	public synchronized Decision create(ComponentValue value, String[] labels) {

		// get the component the value belongs to

		DomainComponent comp = value.getComponent();

		// create decision

		Decision dec = comp.create(value, labels);

		// get created decision

		return dec;

	}

	/**

	 * 

	 */

	@Override

	public synchronized Decision create(ComponentValue value, String[] labels, long[] duration) {

		// get the component the value belongs to

		DomainComponent comp = value.getComponent();

		// create decision

		Decision dec = comp.create(value, labels, duration);

		// get created decision

		return dec;

	}

	/**

	 * 

	 */

	@Override

	public synchronized Decision create(ComponentValue value, String[] labels, long[] end, long[] duration) {

		// get the component the value belongs to

		DomainComponent comp = value.getComponent();

		// create decision

		Decision dec = comp.create(value, labels, end, duration);

		// get created decision

		return dec;

	}

	/**

	 * 

	 */

	@Override

	public synchronized Decision create(ComponentValue value, String[] labels, long[] start, long[] end, long[] duration) {

		// get the component the value belongs to

		DomainComponent comp = value.getComponent();

		// create decision

		Decision dec = comp.create(value, labels, start, end, duration);

		// get created decision

		return dec;

	}

	/**

	 * 

	 */

	@Override

	public synchronized Set<Relation> activate(Decision dec) 

			throws DecisionPropagationException 

	{

		// get the component the decision belongs to

		DomainComponent c = dec.getComponent();

		// add decision and get the list of local and global relations propagated

		Set<Relation> set = c.activate(dec);

		// get global and local relations propagated

		return set;

	}

	/**

	 * 

	 */

	@Override

	public synchronized Set<Relation> getRelations(Decision dec) 

	{

		// list of relations concerning the decision

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

		// get decision component

		DomainComponent comp = dec.getComponent();

		set.addAll(comp.getRelations(dec));

		// get the set

		return set;

	}

	/**

	 * Get the set of both active and pending local and global relations on components

	 */

	@Override

	public synchronized Set<Relation> getRelations() {

		// list of relations

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

		for (DomainComponent comp : this.components.values()) {

			set.addAll(comp.getRelations());

		}

		// add global relations

		synchronized (globalRelations) {

			for (Relation rel : globalRelations) {

				set.add(rel);

			}

		}

		// get the set

		return set;

	}

	/**

	 * Get the set of local active relations and local active relations on components 

	 *  

	 * @param dec

	 * @return

	 */

	@Override

	public synchronized Set<Relation> getActiveRelations()

	{

		// list of active relations

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

		// check local relations

		for (DomainComponent component : this.components.values()) {

			// add active local relations

			set.addAll(component.getActiveRelations());

		}

		// add global active relations

		synchronized (globalRelations) {

			for (Relation rel : globalRelations) {

				if (rel.isActive()) {

					set.add(rel);

				}

			}

		}

		// get the list

		return set;

	}

	/**

	 * Get the set of pending global relations and pending local relations on components

	 * 

	 * @return

	 */

	public synchronized Set<Relation> getPendingRelations()

	{

		// set of relations

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

		for (DomainComponent comp : this.components.values()) {

			set.addAll(comp.getPendingRelations());

		}

		// add pending global relations

		synchronized (globalRelations) {

			for (Relation rel : globalRelations) {

				if (rel.isPending()) {

					set.add(rel);

				}

			}

		}

		// get the set

		return set;

	}

	/**

	 * 

	 */

	@Override

	public synchronized Set<Relation> getActiveRelations(Decision dec) 

	{

		// list of active relations

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

		// get decision component

		DomainComponent comp = dec.getComponent();

		set.addAll(comp.getActiveRelations(dec));

		// get the set

		return set;

	}

	/**

	 * 

	 */

	@Override

	public synchronized Set<Relation> getToActivateRelations(Decision dec) 

	{

		// list of relations

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

		// get decision component

		DomainComponent comp = dec.getComponent();

		set.addAll(comp.getToActivateRelations(dec));

		// get the set

		return set;

	}

	/**

	 * 

	 * @param dec

	 * @throws Exception

	 */

	@Override

	public synchronized void free(Decision dec) 

	{

		// get decision component

		DomainComponent comp = dec.getComponent();

		comp.free(dec);

	}

	/**

	 * 

	 */

	@Override

	public synchronized Set<Relation> deactivate(Decision dec) {

		// get decision component

		DomainComponent comp = dec.getComponent();

		return new HashSet<>(comp.deactivate(dec));

	}

	/**

	 * 

	 * @param relation

	 */

	@Override

	public synchronized void delete(Relation relation) 

	{

		// get reference component

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

		refComp.delete(relation);

	}

	/**

	 * Only for debugging

	 */

	@Override

	public synchronized List<Decision> getSilentDecisions() {

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

		for (DomainComponent component : this.components.values()) {

			list.addAll(component.getSilentDecisions());

		}

		return list;

	}

	/**

	 * Only for debugging

	 */

	@Override

	public synchronized Set<Relation> getSilentRelations() {

		// set of relations

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

		for (DomainComponent component : this.components.values()) {

			set.addAll(component.getSilentRelations());