pstlab / PLATINUm

import java.util.ArrayList;

import java.util.Arrays;

import java.util.HashSet;

import java.util.List;

import java.util.Set;

import java.util.concurrent.atomic.AtomicInteger;

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.microkernel.FrameworkObject;

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

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

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

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.flaw.FlawType;

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

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

import it.cnr.istc.pst.platinum.ai.framework.parameter.ParameterFacade;

import it.cnr.istc.pst.platinum.ai.framework.time.TemporalFacade;

/**

 * 

 * @author anacleto

 *

 * @param <T>

 */

public abstract class Resolver<T extends DomainComponent> extends FrameworkObject implements FlawManager 

{

	@TemporalFacadePlaceholder

	protected TemporalFacade tdb;

	@ParameterFacadePlaceholder

	protected ParameterFacade pdb;

	@DomainComponentPlaceholder

	protected T component;

	protected String label;

	protected FlawType[] flawTypes;

	// static information

	protected static final AtomicInteger FLAW_COUNTER = new AtomicInteger(0);

	/**

	 * 

	 * @param label

	 * @param flawTypes

	 */

	protected Resolver(String label, FlawType[] flawTypes) {

		super();

		this.label = label;

		this.flawTypes = flawTypes;

		// reset counter if necessary

		FLAW_COUNTER.set(0);

	}

	/**

	 * 

	 * @return

	 */

	public String getLabel() {

		return label;

	}

	/**

	 * 

	 * @return

	 */

	public FlawType[] getFlawTypes() {

		return this.flawTypes;

	}

	/**

	 * 

	 */

	@Override

	public synchronized List<Flaw> checkFlaws() {

		// get detected flaws

		return new ArrayList<>(this.doFindFlaws());

	}

	/**

	 * 

	 */

	@Override

	public synchronized List<Flaw> findFlaws() 

			throws UnsolvableFlawException

	{

		// list of flaws on the related component

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

		// find flaws on component

		for (Flaw flaw :  this.doFindFlaws()) 

		{

			// compute possible solutions

			this.doComputeFlawSolutions(flaw);

			// add flaw

			flaws.add(flaw);

		}

		// get detected flaws

		return flaws;

	}

	/**

	 * 

	 */

	@Override

	public final synchronized void apply(FlawSolution solution) 

			throws FlawSolutionApplicationException 

	{

		// check flaw type

		if (!Arrays.asList(this.flawTypes).contains(solution.getFlaw().getType())) {

			throw new FlawSolutionApplicationException("Impossible to apply solution for flaws of type type " + solution.getFlaw().getType());

		}

		// apply flaw solution

		this.doApply(solution);

	}

	/**

	 * 

	 */

	@Override

	public final synchronized void restore(FlawSolution solution) 

			throws Exception 

	{

		// check flaw type

		if (!Arrays.asList(this.flawTypes).contains(solution.getFlaw().getType())) {

			throw new FlawSolutionApplicationException("Impossible to restore solution for flaws of type type " + solution.getFlaw().getType());

		}

		// apply flaw solution

		this.doRestore(solution);

	}

	/**

	 * 

	 */

	@Override

	public final synchronized void retract(FlawSolution solution) 

	{

		// check flaw type

		if (!Arrays.asList(this.flawTypes).contains(solution.getFlaw().getType())) {

		}

		// retract solution

		this.doRetract(solution);

	}

	/**

	 * 

	 * @param solution

	 */

	protected void doRetract(FlawSolution solution) 

	{

		// get the list of activated relations

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

			// get reference component

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

			// deactivate relation

			refComp.deactivate(relation);

		}

		// get the list of created relations

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

			// get reference component

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

			// remove relation from the data structure

			refComp.delete(relation);

		}

		// get the list of activated decisions

		for (Decision decision : solution.getActivatedDecisions()) {

			// get decision component

			DomainComponent dComp = decision.getComponent();

			// deactivate decision

			dComp.deactivate(decision);

		}

		// get the list of created decisions

		for (Decision decision : solution.getCreatedDecisions()) {

			// get decision component

			DomainComponent dComp = decision.getComponent();

			// delete decision from pending "list" 

			dComp.free(decision);

		}

	}

//	/**

//	 * 

//	 * @param constraint

//	 * @throws ConstraintPropagationException

//	 */

//	protected void doPropagetConstraint(Constraint constraint) 

//			throws ConstraintPropagationException 

//	{

//		// check constraint category

//		switch (constraint.getCategory()) 

//		{

//			// temporal constraint

//			case  TEMPORAL_CONSTRAINT : {

//				// cast constraint

//				TemporalConstraint cons = (TemporalConstraint) constraint;

//				// propagate temporal constraint

//				this.tdb.propagate(cons);

//			}

//			break;

//			

//			// parameter constraint

//			case PARAMETER_CONSTRAINT : {

//				// cast constraint

//				ParameterConstraint  cons = (ParameterConstraint) constraint;

//				// propagate parameter constraint

//				this.pdb.propagate(cons);

//			}

//			break;

//		}

//	}

//	/**

//	 * 

//	 * @param constraint

//	 */

//	protected void doRetractConstraint(Constraint constraint) {

//		// check constraint category

//		switch (constraint.getCategory()) {

//		

//			// temporal constraint

//			case  TEMPORAL_CONSTRAINT : {

//				

//				// cast constraint

//				TemporalConstraint cons = (TemporalConstraint) constraint;

//				// retract temporal constraint

//				this.tdb.retract(cons);

//			}

//			break;

//			

//			// parameter constraint

//			case PARAMETER_CONSTRAINT : {

//				

//				// cast constraint

//				ParameterConstraint cons = (ParameterConstraint) constraint;

//				// retract parameter constraint

//				this.pdb.retract(cons);

//			}

//			break;

//		}

//	}

	/**

	 * 

	 * @param solution

	 * @throws Exception

	 */

	protected abstract void doApply(FlawSolution solution) 

			throws FlawSolutionApplicationException;

	/**

	 * 

	 * @param solution

	 * @throws RelationPropagationException

	 * @throws DecisionPropagationException

	 */

	}

	/**

	 * 

	 * @return

	 */

	protected abstract List<Flaw> doFindFlaws();

	/**

	 * 

	 * @param flaw

	 * @throws UnsolvableFlawException

	 */

	protected abstract void doComputeFlawSolutions(Flaw flaw) 

			throws UnsolvableFlawException;

}