/*

 * To change this license header, choose License Headers in Project Properties.

 * To change this template file, choose Tools | Templates

 * and open the template in the editor.

 */

package utils;

import biodiscml.Main;

import java.io.BufferedReader;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

import java.nio.channels.FileChannel;

import java.text.DecimalFormat;

import java.text.DecimalFormatSymbols;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.Iterator;

import java.util.TreeMap;

import org.apache.commons.math3.stat.descriptive.moment.Mean;

import org.apache.commons.math3.stat.descriptive.moment.StandardDeviation;

/**

 *

 * @author Administrator

 */

public class utils {

    public static HashMap<String, ArrayList<String>> convertDataColumnsToHashMap(ArrayList<String[]> altable) {

        HashMap<String, ArrayList<String>> hmData = new HashMap<>();

        for (int i = 1; i < altable.get(0).length; i++) { //for column

            String header = altable.get(0)[i]; //get column header

            ArrayList<String> al = new ArrayList<>(); //data list of the column

            for (int j = 1; j < altable.size(); j++) { //for each value in the column

                try {

                    al.add(altable.get(j)[i]);

                } catch (Exception e) {

                    al.add("");

                }

            }

            hmData.put(header, al);

        }

        return hmData;

    }

    public static ArrayList<String[]> readTable(String file, String separator) {

        if (separator.isEmpty()) {

            separator = detectSeparator(file);

        }

        ArrayList<String[]> altable = new ArrayList<>();

        int cpt = 1;

        try {

            BufferedReader br = new BufferedReader(new FileReader(file));

            while (br.ready()) {

                if (Main.debug2) {

                    System.out.println("Reading line " + cpt++);

                }

                altable.add(br.readLine().split(separator));

            }

            br.close();

        } catch (Exception e) {

            e.printStackTrace();

        }

        return altable;

    }

    public static ArrayList<String[]> readTable(String file) {

        String separator = detectSeparator(file);

        if (Main.debug) {

            System.out.println("reading table " + file);

        }

        ArrayList<String[]> altable = new ArrayList<>();

        try {

            BufferedReader br = new BufferedReader(new FileReader(file));

            while (br.ready()) {

                altable.add(br.readLine().split(separator));

            }

        } catch (Exception e) {

            e.printStackTrace();

        }

        return altable;

    }

    public static String[][] transposeMatrix(String[][] m) {

        String[][] temp = new String[m[0].length][m.length];

        for (int i = 0; i < m.length; i++) {

            for (int j = 0; j < m[0].length; j++) {

                temp[j][i] = m[i][j];

            }

        }

        return temp;

    }

    /**

     *

     * @param doubles

     * @return

     */

    public static double[] convertStringListToDoubles(ArrayList<String> doubles) {

        double[] ret = new double[doubles.size()];

        Iterator<String> iterator = doubles.iterator();

        int i = 0;

        while (iterator.hasNext()) {

            ret[i] = Double.valueOf(iterator.next());

            i++;

        }

        return ret;

    }

    /**

     * auto detection of the delimiter

     *

     * @param infile

     * @return

     */

    public static String detectSeparator(String infile) {

        if (Main.debug) {

            //System.out.println("Delimiter not specified, auto-detection 10 first lines among these delimiters: \"\\t\" \" \" \";\" \",\" \"~\" \":\" \"/\" \"\\|\"");

            System.out.print("Delimiter not specified, auto-detection in the 10 first lines...");

        }

        String delimiter = "";

        String potentialDelimiters[] = {"\\t", " ", ";", ",", "~", ":", "/", "\\|"};

        for (String potentialDelimiter : potentialDelimiters) {

            try {

                BufferedReader br = new BufferedReader(new FileReader(infile));

                boolean sameNumberAsPreviousLine = true;

                String line = br.readLine();

                int init = line.split(potentialDelimiter).length;

                if (init > 1) {

                    int cpt = 0;

                    while (br.ready() & sameNumberAsPreviousLine && cpt < 10) {

                        cpt++;

                        line = br.readLine();

                        if (!line.trim().isEmpty()) {

                            int split = line.split(potentialDelimiter).length;

                            if (split == init) {

                                init = split;

                            } else {

                                sameNumberAsPreviousLine = false;

                            }

                        }

                    }

                    if (sameNumberAsPreviousLine) {

                        delimiter = potentialDelimiter;

                        break;

                    }

                }

            } catch (Exception e) {

                e.printStackTrace();

            }

        }

        if (delimiter.isEmpty()) {

            System.err.print("[error] CSV separator not detected. Guessing there is just one column. "

                    + "If not, change your CSV separator to a standard one (ex: tabulation or comma), or check the file consistency");

            delimiter = " ";

        }

        if (Main.debug) {

            System.out.println("Delimiter found:" + delimiter);

        }

        return delimiter;

    }

    public static void copyFileUsingStream(File source, File dest) throws IOException {

        InputStream is = null;

        OutputStream os = null;

        try {

            is = new FileInputStream(source);

            os = new FileOutputStream(dest);

            byte[] buffer = new byte[1024];

            int length;

            while ((length = is.read(buffer)) > 0) {

                os.write(buffer, 0, length);

            }

        } finally {

            is.close();

            os.close();

        }

    }

    public static void copyFileUsingChannel(File source, File dest) throws IOException {

        FileChannel sourceChannel = null;

        FileChannel destChannel = null;

        try {

            sourceChannel = new FileInputStream(source).getChannel();

            destChannel = new FileOutputStream(dest).getChannel();

            destChannel.transferFrom(sourceChannel, 0, sourceChannel.size());

        } finally {

            sourceChannel.close();

            destChannel.close();

        }

    }

    public static String arrayToString(String[] array, String separator) {

        String s = "";

        for (int i = 0; i < array.length; i++) {

            if (array[i] != null) {

                s += array[i] + separator;

            }

        }

        return s.substring(0, s.length() - 1);

    }

    public static String arrayToString(ArrayList<Integer> array, String separator) {

        String s = "";

        for (int i = 0; i < array.size(); i++) {

            s += array.get(i) + separator;

        }

        return s.substring(0, s.length() - 1);

    }

    public static double[] arrayToDouble(ArrayList<Double> al) {

        return al.stream().mapToDouble(Double::doubleValue).toArray();

    }

    public static String getStandardDeviation(ArrayList<Double> al) {

        DecimalFormat df = new DecimalFormat();

        df.setMaximumFractionDigits(3);

        DecimalFormatSymbols dfs = new DecimalFormatSymbols();

        dfs.setDecimalSeparator('.');

        df.setDecimalFormatSymbols(dfs);

        StandardDeviation s = new StandardDeviation();

        s.setData(utils.arrayToDouble(al));

        return df.format(s.evaluate());

    }

    /**

     * Table Object to manipulate table

     */

    public static class TableObject {

        public HashMap<String, ArrayList<String>> hmData = new HashMap<>();//<ColName,Values>

        public HashMap<String, Integer> hmIDsList = new HashMap<>(); //<ID,index>

        public TableObject(ArrayList<String[]> altable) {

            if (Main.debug) {

                System.out.println("converting table");

            }

            hmData = convertDataColumnsToHashMap(altable);

            int ID_index = getIdIndex(altable);

            for (int i = 1; i < altable.size(); i++) { //for each ID

                //hmIDsList.put(altable.get(i)[ID_index].toLowerCase(), i - 1);

                Integer j = hmIDsList.put(altable.get(i)[ID_index], i - 1);

                if (j != null) {

                    System.err.println("DUPLICATED ID DETECTED: " + altable.get(i)[ID_index]);

                    System.err.println("All IDs must be unique");

                    System.exit(0);

                }

            }

        }

        public ArrayList<String> getTheClass(String theclass) {

            ArrayList<String> toreturn = hmData.get(theclass);

            hmData.remove(theclass);

            return toreturn;

        }

        public boolean containsClass(String theClass) {

            return hmData.containsKey(theClass);

        }

        public int getIdIndex(ArrayList<String[]> altable) {

            int cpt = 0;

            for (String s : altable.get(0)) {

                if (s.equals(Main.mergingID)) {

                    return cpt;

                } else {

                    cpt++;

                }

            }

            return 0;

        }

        public ArrayList<String> getSortedHmDataKeyset() {

            ArrayList<String> al = new ArrayList<>();

            TreeMap<String, ArrayList<String>> tm = new TreeMap<>();

            tm.putAll(hmData);

            for (String key : tm.keySet()) {

                al.add(key);

            }

            return al;

        }

    }

    /**

     * calculate mean of an array of doubles

     *

     * @param al

     * @return

     */

    public static String getMean(ArrayList<Double> al) {

        if (!al.isEmpty()) {

            double d[] = new double[al.size()];

            for (int i = 0; i < al.size(); i++) {

                if (!al.get(i).isNaN()) {

                    d[i] = (double) al.get(i);

                }

            }

            Mean m = new Mean();

            DecimalFormat df = new DecimalFormat();

            df.setMaximumFractionDigits(3);

            DecimalFormatSymbols dfs = new DecimalFormatSymbols();

            dfs.setDecimalSeparator('.');

            df.setDecimalFormatSymbols(dfs);

            return df.format(m.evaluate(d));

        } else {

            return "";

        }

    }

}