/*
 * Get clinical and genes expression
 * Make some feature extraction
 */
package biodiscml;

import java.io.FileWriter;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.TreeMap;
import utils.Weka_module;
import utils.utils.TableObject;
import static utils.utils.readTable;
import weka.classifiers.Classifier;
import weka.core.SerializationHelper;

/**
 *
 * @author Mickael
 */
public class AdaptDatasetToTesting {

    public static boolean debug = Main.debug;
    public static boolean missingClass = false;

    public AdaptDatasetToTesting() {
    }

    public boolean isMissingClass() {
        return missingClass;
    }

    /**
     * create dataset with a determined class
     *
     * @param theClass
     * @param infiles
     * @param outfile
     */
    public AdaptDatasetToTesting(String theClass, HashMap<String, String> infiles, String outfile, String separator, String model) {
        //get model features
        Weka_module weka = new Weka_module();
        ArrayList<String> alModelFeatures = weka.getFeaturesFromClassifier(model); //features in the right order
        HashMap<String, String> hmModelFeatures = new HashMap<>();//indexed hashed features
        System.out.println("# Model features: ");

        Boolean voteModel = false;
        try {
            voteModel = (((Classifier) SerializationHelper.read(model)).getClass().toString().contains("weka.classifiers.meta.Vote"));
        } catch (Exception e) {
            if (Main.debug) {
                e.printStackTrace();
            }
        }
        if (voteModel) {
            System.out.println("    Combined Vote model");
        }
        for (String f : alModelFeatures) {
            if (!f.startsWith("Model") && !f.startsWith("class")) {
                hmModelFeatures.put(f, f);
            }
        }
        hmModelFeatures.put("class", "class");
        for (String s : hmModelFeatures.keySet()) {
            System.out.println("\t" + s);
        }

        //convert hashmap to list
        String[] files = new String[infiles.size()];
        String[] prefixes = new String[infiles.size()];
        int cpt = 0;
        for (String f : infiles.keySet()) {
            files[cpt] = f;
            prefixes[cpt] = infiles.get(f);
            cpt++;
        }

        //load datasets of features
        if (debug) {
            System.out.println("loading files");
        }

        ArrayList<TableObject> al_tables = new ArrayList<>();
        int classIndex = -1;

        for (int i = 0; i < files.length; i++) {
            String file = files[i];
            TableObject tbo = new TableObject(readTable(file, separator));
            //locate class
            if (tbo.containsClass(theClass)) {
                classIndex = i;
            }
            al_tables.add(tbo);
        }

        //extract class 
        ArrayList<String> myClass = new ArrayList<>();

        try {
            myClass = al_tables.get(classIndex).getTheClass(theClass);
        } catch (Exception e) {
            String f = "";
            for (String s : infiles.keySet()) {
                f += " " + s;
            }
            System.out.println("Class " + theClass + " not found in " + f + ". Class values are filled by ?");
            missingClass = true;
        }

        // replace spaces by _ in class
        for (int i = 0; i < myClass.size(); i++) {
            String c = myClass.get(i).replace(" ", "_");
            myClass.set(i, c);
        }

        //remove feature that are not needed by the model
        //create outfile
        System.out.println("create outfile " + outfile);

        HashMap<String, ArrayList<String>> hmOutput = new HashMap<>();
        try {
            PrintWriter pw = new PrintWriter(new FileWriter(outfile));
            ///////// PRINT HEADER
            //pw.print(Main.mergingID);
            hmOutput.put(Main.mergingID, new ArrayList<>());
            for (int i = 0; i < al_tables.size(); i++) {
                TableObject tbo = al_tables.get(i);
                for (String s : tbo.hmData.keySet()) {
                    String head = null;
                    if (!prefixes[i].isEmpty()) {
                        head = prefixes[i] + "__" + s;
                    } else {
                        head = s;
                    }
                    if (hmModelFeatures.containsKey(head)) {
                        //pw.print("\t" + head);
                        hmOutput.put(head, new ArrayList<>());
                    }
                }
            }

            //pw.println("\tclass");
            hmOutput.put("class", new ArrayList<>());
            //pw.flush();

            //search for ids present in all datasets
            HashMap<String, String> hm_ids = getCommonIds(al_tables);
            if (al_tables.size() > 1) {
                System.out.println("Total number of common instances between files:" + hm_ids.size());
            } else {
                System.out.println("Total number of instances between files:" + hm_ids.size());
            }

            ///////PREPARE CONTENT FOR PRINTING
            TreeMap<String, Integer> tm = new TreeMap<>();
            tm.putAll(al_tables.get(0).hmIDsList);
            for (String id : tm.keySet()) {
                if (hm_ids.containsKey(id)) { //if sample exist in all files
                    //pw.print(id);
                    hmOutput.get(Main.mergingID).add(id);
                    for (int i = 0; i < al_tables.size(); i++) {
                        TableObject tbo = al_tables.get(i);
                        int idIndex = tbo.hmIDsList.get(id); //get index for sample
                        for (String s : tbo.hmData.keySet()) { //for all features
                            String feature = null;
                            if (!prefixes[i].isEmpty()) {
                                feature = prefixes[i] + "__" + s;
                            } else {
                                feature = s;
                            }
                            if (hmModelFeatures.containsKey(feature)) {
                                //pw.print("\t" + tbo.hmData.get(s).get(idIndex));
                                // print values and replace , per .
                                String out = tbo.hmData.get(s).get(idIndex).replace(",", ".").trim();
                                if (out.isEmpty()) {
                                    out = Main.missingValueToReplace;
                                }
                                hmOutput.get(feature).add(out);
                            }
                        }
                    }

                    if (missingClass) {
                        hmOutput.get("class").add("?");
                    } else {
                        //pw.print("\t" + myClass.get(al_tables.get(classIndex).hmIDsList.get(id)));
                        hmOutput.get("class").add(myClass.get(al_tables.get(classIndex).hmIDsList.get(id)));
                        //pw.print("\t" + myClass.get(idIndex).replace("1", "true").replace("0", "false"));
                    }

                    //pw.println();
                }
            }
            //PRINTING CONTENT IN THE RIGHT ORDER
            if (voteModel || (alModelFeatures.size() != hmModelFeatures.size())) {
                //ensure class is at the end of the list
                alModelFeatures = new ArrayList<>();
                for (String feature : hmModelFeatures.keySet()) {
                    if (!feature.equals("class")) {
                        alModelFeatures.add(feature);
                    }
                }
                alModelFeatures.add("class");
            }
            //header
            pw.print(Main.mergingID);
            for (String feature : alModelFeatures) {
                pw.print("\t" + feature);
            }
            pw.println();
            pw.flush();
            //content
            for (int i = 0; i < hm_ids.size(); i++) {//for every instance
                pw.print(hmOutput.get(Main.mergingID).get(i));
                for (String feature : alModelFeatures) {
                    try {
                        pw.print("\t" + hmOutput.get(feature).get(i));
                    } catch (Exception e) {
                        System.out.println("Feature "+feature+" is not present in the test set. Replacing with missing data");
                        pw.print("\t?");
                    }
                }
                pw.println();
            }
            pw.flush();
            pw.close();
            if (debug) {
                System.out.println("closing outfile " + outfile);
            }
            pw.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * get common ids between infiles
     *
     * @param al_tables
     * @return
     */
    public static HashMap<String, String> getCommonIds(ArrayList<TableObject> al_tables) {
        HashMap<String, String> hm_ids = new HashMap<>();
        //if many infiles
        if (al_tables.size() > 0) {
            HashMap<String, Integer> hm_counts = new HashMap<>();
            //get all ids, count how many times each one is seen
            for (TableObject table : al_tables) {
                for (String s : table.hmIDsList.keySet()) {
                    //s = s.toLowerCase();
                    if (hm_counts.containsKey(s)) {
                        int tmp = hm_counts.get(s);
                        tmp++;
                        hm_counts.put(s, tmp);
                    } else {
                        hm_counts.put(s, 1);
                    }
                }
            }
            //check number of times ids have been seen
            for (String s : hm_counts.keySet()) {
                if (hm_counts.get(s) == al_tables.size()) {
                    hm_ids.put(s, "");
                }
            }
        } else {//for one infile
            for (String s : al_tables.get(0).hmIDsList.keySet()) {
                hm_ids.put(s, "");
            }
        }

        return hm_ids;
    }

}