source: MotivateDuringTherapy/src/main/java/tudelft/mentalhealth/motivatepersisting/MotivationalAnswer.java@ 2

package tudelft.mentalhealth.motivatepersisting;

import java.io.IOException;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.stream.Collectors;

/**
 * a motivational answer for some situation. This answer contans random aspects
 * and is generated only once. Create a new object if you need a new answer.
 */
public class MotivationalAnswer {
        private final Situation situation;
        private final String text;
        private final ProbOfCategoriesPerSituation probabilities = ProbOfCategoriesPerSituation
                        .instance();
        private final List<StatementSelection> selectedStatements;
        private final Statements allStatements;

        /**
         * 
         * @param situation the situation of the patient.
         * @param locale    the language to use towards the patient. Currently
         *                  supported are Locale("nl","NL") and Locale("en","").
         */
        public MotivationalAnswer(Situation situation, Locale locale) {
                this.situation = situation;
                this.allStatements = new Statements(locale);
                this.selectedStatements = createStatements();
                this.text = createText(selectedStatements);
        }

        /**
         * 
         * @return the ext for this motivational answer. This text will remain
         *         constant once the MotivationalAnswer has been created. Create a
         *         new MotivationalAnswer to get a new text.
         */
        public String getText() {
                return text;
        }

        @Override
        public String toString() {
                return " MotivationalAnswer(" + text + ")";
        }

        /**
         * 
         * @return the statements selected for this motivational answer.
         */
        public List<StatementSelection> getStatements() {
                return Collections.unmodifiableList(selectedStatements);
        }

        /***************** internals ***************/
        /**
         * @param stats the statements to be used for the text.
         * @return text generated.
         * @throws IOException
         */
        private String createText(List<StatementSelection> stats) {

                String text = "";
                for (StatementSelection statement : stats) {
                        text = text + allStatements.getText(statement.getCategory(),
                                        statement.getSubcategory()) + " ";
                }

                return text;
        }

        private List<StatementSelection> createStatements() {

                long nstatements = Math
                                .round(MeanNrStatements.instance().getMean(situation));
                List<StatementSelection> selection = selectBasic();

                while (selection.size() < nstatements) {
                        List<Category> excludes = selection.stream()
                                        .map(sel -> sel.getCategory()).collect(Collectors.toList());
                        selection.add(randomSelection(excludes));
                }

                return selection;
        }

        /**
         * Pick a random StatementSelection in a {@link Category} that is not yet
         * selected,
         * 
         * @param excludes the {@link Categories} excluded of selection
         * @return random {@link StatementSelection}, excluding the excludes
         */
        protected StatementSelection randomSelection(List<Category> excludes) {
                Category category = probabilities.getWeightedRandomCategory(excludes,
                                situation);
                return new StatementSelection(category,
                                probabilities.selectSubcategory(category, situation));

        }

        /**
         * @return one Selection from each category that has p(ALL)>0.5
         */
        protected List<StatementSelection> selectBasic() {
                List<StatementSelection> selection = new LinkedList<>();

                for (Category cat : Category.values()) {
                        if (probabilities.get(cat, Subcategory.ALL, situation) > 0.5) {
                                selection.add(new StatementSelection(cat,
                                                probabilities.selectSubcategory(cat, situation)));
                        }
                }
                return selection;
        }

}