source: TraumaOntologies/src/main/java/tudelft/healthpsychology/traumaontologies/answerstate/OntoPropAnswerState.java@ 5

package tudelft.healthpsychology.traumaontologies.answerstate;

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

import tudelft.healthpsychology.traumaontologies.questiontypes.TypedQuestion;
import tudelft.utilities.tree.Tree;

/**
 * Contains a answer to an ontology node: both the {@link OntologyAnswerState}
 * and the {@link PropertiesAnswerState}. The answerstate can be partial, eg the
 * OntologyAnswerState or PropertiesAnswerState may be not yet complete.
 * <p>
 * The node state has 2 main phases: 1. ontologyState is not final (has open
 * options). then this is the next question to be asked. 2. ontologyState is
 * final. Thus, he most accurate ontology node matching the user's idea is
 * available. All questions pertinent to that node are asked.
 * <p>
 * Special substitutions are done on elements of the form [XXX] where XXX is
 * some word string. If XXX is some property for which a value was already
 * collected in the {@link #propertiesState}, then the [XXX] is replaced with
 * that value.
 */

public class OntoPropAnswerState implements AnswerState {
        private final OntologyAnswerState ontologyState;
        private final PropertiesAnswerState propertiesState;

        /**
         * @param ontoState the state of the ontology question node.
         * @param propState the OntologyProperties state. Can (but does not need to
         *                  ) be null while ontoState has options (is not final)
         */
        @JsonCreator
        public OntoPropAnswerState(
                        @JsonProperty("ontologyState") OntologyAnswerState ontoState,
                        @JsonProperty("propertiesState") PropertiesAnswerState propState) {
                this.ontologyState = ontoState;
                this.propertiesState = propState;
        }

        /**
         * Convenience constructor that starts with a ontology node
         * 
         * @param node the {@link OntologyNode} to start at.
         * @pram nameOfObject a name of the object, to make the question to the user
         *       more specific which is especially relevant if this is part of a
         *       breath-first and the user entered some name or so some time before.
         *       If null, "het" ("it") is used.
         */
        public OntoPropAnswerState(OntologyNode node, String nameOfObject) {
                this(new OntologyAnswerState(node, nameOfObject), null);
        }

        /**
         * 
         * @return current {@link OntologyAnswerState}
         */
        public OntologyAnswerState getOntologyAnswer() {
                return ontologyState;
        }

        /**
         * 
         * @return current properties answer state, or null if the ontology answer
         *         has not been answered yet.
         */
        public PropertiesAnswerState getPropertyAnswer() {
                return propertiesState;
        }

        @Override
        public TypedQuestion getOptions(
                        Tree<String, Collection<Property>, OntologyNode> tree) {
                TypedQuestion options = ontologyState.getOptions(tree);
                if (options == null) {
                        options = propertiesState.getOptions(tree);
                }
                if (options == null)
                        return null;
                return options.substitute(getSubstitutions());
        }

        @Override
        public OntoPropAnswerState with(String answer,
                        Tree<String, Collection<Property>, OntologyNode> tree) {
                TypedQuestion ontoOptions = ontologyState.getOptions(tree);
                if (ontoOptions != null) {
                        if (!ontoOptions.fits(answer)) {
                                throw new IllegalArgumentException(
                                                "answer " + answer + " does not fit " + ontoOptions);
                        }
                        OntologyAnswerState newOntoState = ontologyState.with(answer, tree);
                        PropertiesAnswerState newPropState = propertiesState;
                        if (newOntoState.getOptions(tree) == null) {
                                // onto is final, set up the prop state.
                                if (propertiesState == null) {
                                        newPropState = new PropertiesAnswerState(
                                                        newOntoState.getNode());
                                } else {
                                        // we already had prop answers, keep them.
                                        newPropState = new PropertiesAnswerState(
                                                        newOntoState.getNode(),
                                                        propertiesState.getAnswers());
                                }
                        }
                        return new OntoPropAnswerState(newOntoState, newPropState);
                }

                // if we get here, the ontostate is final and prop state has been set
                TypedQuestion propOptions = propertiesState.getOptions(tree);
                if (propOptions != null) {
                        if (!propOptions.fits(answer)) {
                                throw new IllegalArgumentException(
                                                "answer " + answer + " does not fit " + propOptions);
                        }
                        return new OntoPropAnswerState(ontologyState,
                                        propertiesState.with(answer, tree));
                }
                // both already final so this is a final state.
                return this;
        }

        /**
         * 
         * @return substitution list based on the answers provided so far. For
         *         example if we collected the answer "Jaap" as an answer for a node
         *         labeled "Naam", we add a substitution "[Naam]"/"Jaap".
         */
        private Map<String, String> getSubstitutions() {
                if (propertiesState == null)
                        return Collections.emptyMap();
                Map<Property, String> props = propertiesState.getAnswers();
                Map<String, String> substis = new HashMap<>();
                for (Property prop : props.keySet()) {
                        substis.put("\\[" + prop.getQuestionType().getId() + "\\]",
                                        props.get(prop));
                }
                return substis;
        }

}