source: MotivateDuringTherapy/src/main/java/tudelft/mentalhealth/motivatepersisting/ProbOfCategoriesPerSituation.java

package tudelft.mentalhealth.motivatepersisting;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;

import tudelft.utilities.statistic.WeightedSet;

/**
 * Contains table 2: Probabilities of a given category in a given situation,
 * defined by PCL score and Trust. Immutable. Singleton to avoid re-loading the
 * table repeatedly.
 * 
 * This is read from a text file that has similar layout as in
 * Dataset_Database.pdf. The first and second column are category and
 * sub-category, the remaining 9 columns are for Dropping(high,med,low),
 * stable(high,med,low) and rising(high,med,low).
 */
class ProbOfCategoriesPerSituation {
        private static ProbOfCategoriesPerSituation instance = null;

        private final Map<Category, Map<Subcategory, Map<Situation, Double>>> probabilities = new HashMap<>();

        private ProbOfCategoriesPerSituation() {
                readTable();
        }

        private void readTable() {
                InputStream is = MeanNrStatements.class
                                .getResourceAsStream("ProbOfCategories.csv");

                BufferedReader reader = new BufferedReader(new InputStreamReader(is));
                reader.lines().forEach(line -> addLine(line));
        }

        private void addLine(String line) {
                if (line.isEmpty())
                        return;
                String[] values = line.split(",");
                Category cat = Category.valueOf(values[0].trim());
                Subcategory subcat;
                String value1 = values[1].trim();
                if (value1.isEmpty()) {
                        subcat = Subcategory.ALL;
                } else {
                        subcat = Subcategory.valueOf(value1);
                        if (!cat.isSubcategoryAllowed(subcat)) {
                                throw new IllegalArgumentException(
                                                "internal error reading csv: incorrect category-subcategory relation encountered");
                        }
                }

                if (!probabilities.containsKey(cat)) {
                        probabilities.put(cat, new HashMap<>());
                }
                if (!probabilities.get(cat).containsKey(subcat)) {
                        probabilities.get(cat).put(subcat, new HashMap<>());
                }
                Map<Situation, Double> situations = probabilities.get(cat).get(subcat);
                // the remaining 9 columns are the values for various PCL/Trust combi's.
                // Decode.
                int col = 2;
                for (PclTrend pcl : PclTrend.values()) {
                        for (Trust trust : Trust.values()) {
                                situations.put(new Situation(pcl, trust),
                                                Double.valueOf(values[col++]));
                        }
                }
        }

        /**
         * 
         * @return the instance of this class
         * @throws IOException
         */
        public static ProbOfCategoriesPerSituation instance() {
                if (instance == null) {
                        instance = new ProbOfCategoriesPerSituation();
                }
                return instance;
        }

        /**
         * 
         * @param cat       the {@link Category} of the planned statement
         * @param situation the patient {@link Situation}
         * @return a random chosen subcategory of the given category based on a
         *         weighted randomized selection. The random choice is weighted by
         *         the weights in probabilities table.
         */
        public Subcategory getweightedRandomSubcategory(Category category,
                        Situation situation) {
                Map<Subcategory, Double> map = new HashMap<>();
                for (Subcategory subcat : category.getSubCategories()) {
                        map.put(subcat, get(category, subcat, situation));
                }
                return new WeightedSet<>(map).getRandom();

        }

        /**
         * 
         * @param situation the {@link Situation} to generate a random Category for
         * @param excludes  list of {@link Category} that are excluded for selection
         * @return a weighted randomly chosen {@link Category} that is not in
         *         excludes.
         */
        public Category getWeightedRandomCategory(Collection<Category> excludes,
                        Situation situation) {
                Map<Category, Double> map = new HashMap<>();
                for (Category category : Category.values()) {
                        if (!(excludes.contains(category))) {
                                map.put(category, get(category, Subcategory.ALL, situation));
                        }
                }
                return new WeightedSet<>(map).getRandom();
        }

        @Override
        public String toString() {
                return probabilities.toString();
        }

        /**
         * 
         * @param cat       the {@link Category} of a possible statement to motivate
         * @param subcat    the {@link Subcategory} of a possible statement to be
         *                  given
         * @param situation the situation in which the patient is.
         * @return the probability that a statement is given for given
         *         situation,cat&subcat.
         */
        public Double get(Category cat, Subcategory subcat, Situation situation) {
                return probabilities.get(cat).get(subcat).get(situation);
        }

        /**
         * If this has no subcategory, returns category with ALL subcategory. If
         * this has a subcategory, returns
         * {@link #getweightedRandomSubcategory(cat, situation)}.
         * 
         * @param cat       the Category of the planned statement
         * @param situation the patient {@link Situation}
         * @return subcategory according to protocols
         */
        public Subcategory selectSubcategory(Category cat, Situation situation) {
                if (cat.getSubCategories().isEmpty()) {
                        return Subcategory.ALL;
                }
                return getweightedRandomSubcategory(cat, situation);
        }

}