import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.Properties;
import java.util.*;

/**
 * Created with IntelliJ IDEA.
 * User: rebeccamancy
 * Date: 26/10/2012
 * Time: 17:27
 * To change this template use File | Settings | File Templates.
 */

public class Util {

    /**
     * Sums elements in an array of doubles
     * @param myArray    array of doubles
     * @return     sum of all elements
     */
    public static double sumArray(double[] myArray) {
        double sum = 0.0;
        for (double entry : myArray) {
            sum += entry;
        }
        return sum;
    }

    /**
     * Sums elements in an array of integers
     * @param myArray    array of integers
     * @return     sum of all elements
     */
    public static int sumArray(int[] myArray) {
        int sum = 0;
        for (int entry : myArray) {
            sum += entry;
        }
        return sum;
    }

    /**
     * General method that draws from an array of doubles a position proportional to the "size" of the slice
     * associated with the entry in the array (imagine that array entries measure slices of a number line)
     * @param proportions  array of proportions of the line (don't need to sum to 1)
     * @return  the selected array index
     */
    public static int drawPosit(double[] proportions) {
        int index = 0;
        double p = Math.random() * sumArray(proportions);
        double lwb = 0.0;     // lower bound for array
        for (int ind = 0; ind < proportions.length; ind ++) {
            if (lwb <= p   &&   p < lwb + proportions[ind]) {   // if p falls in this segment
                index = ind;
                break;
            }
            lwb = lwb + proportions[ind];
        }
        return index;
    }


    /**
     * Returns a pseudo-random number between min and max, inclusive.
     * The difference between min and max can be at most
     * <code>Integer.MAX_VALUE - 1</code>.
     *
     * @param min Minimim value
     * @param max Maximim value.  Must be greater than min.
     * @return Integer between min and max, inclusive.
     * @see java.util.Random#nextInt(int)
     */
    public static int randInt(int min, int max) {

        // Usually this can be a field rather than a method variable
        Random rand = new Random();

        // nextInt is normally exclusive of the top value,
        // so add 1 to make it inclusive
        int randomNum = rand.nextInt((max - min) + 1) + min;

        return randomNum;
    }


    /**
     * Converts a ListArray of Integers into a primitive int[] array
     * @param integers   List of integers
     * @return           Array of integers
     */
    public static int[] convertIntegers(List<Integer> integers)
    {
        int[] ret = new int[integers.size()];
        Iterator<Integer> iterator = integers.iterator();
        for (int i = 0; i < ret.length; i++)
        {
            ret[i] = iterator.next().intValue();
        }
        return ret;
    }

    /**
     * Converts a string in the form [1,3,...5] to an integer array
     * @param arr String representing an array
     * @return  integer array
     */
    public static int[] str2arr(String arr) {

        String[] items = arr.replaceAll("\\[", "").replaceAll("\\]", "").split(",");

        int[] results = new int[items.length];

        for (int i = 0; i < items.length; i++) {
            try {
                results[i] = Integer.parseInt(items[i]);
            } catch (NumberFormatException nfe) {
                nfe.printStackTrace();
                System.exit(1);
            }
        }
        return results;
    }

    public static String arr2str(double[] arr) {

        String results = "";

        for (int i=0; i<arr.length; i++) {
            if (i==0) {
                results += arr[i];
            } else {
                results += "," + arr[i];
            }
        }
        return results;
    }

    public static String arr2biStr(int[] arr) {
        String results = "";
        for (int i=0; i<arr.length; i++) {
            results += arr[i];
        }
        return results;
    }

    public static HashMap<String, String> makeConfigMap(String configLocation) {
        // Read in parameters from configuration file (.properties) from file given in command line call
        //HashMap<String, String> configMap;
        HashMap<String, String> configMap = new HashMap<String, String>();

        Properties configFile = new Properties();
        try {
            FileInputStream in = new FileInputStream(configLocation);
            configFile.load(in);
            in.close();
            configMap = new HashMap<String, String>((Map) configFile);
        } catch (IOException ex) {
            ex.printStackTrace();
            System.exit(1);
        } catch (ClassCastException ex2) {
            ex2.printStackTrace();
            System.exit(1);
        }
        return configMap;
    }

    public static int firstNonZero(int[] arr) {
        final int ZERO = 0;
        int currentIndex = 0;
        boolean itemFound = false;

        while (!itemFound && currentIndex < arr.length) {
            if (arr[currentIndex] != ZERO) {
                itemFound = true;
            } else {
                currentIndex++;
            }
        }
        if (!itemFound)
            return -1;
        else
            return currentIndex;

    }

    public static double largestAbsVal(double[] arr) {
        double val = arr[0];
        for (double x : arr) {
            if (Math.abs(x) > val) {
                val = Math.abs(x);
            }
        }
        return val;
    }

    public static int largestAbsIndex(double[] arr) {
        int ind = 0;
        double val = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (Math.abs(arr[i]) > val) {
                ind = i;
                val = Math.abs(arr[i]);
            }
        }
        return ind;
    }

    public static int largestAbsIndexCheck(double[] arr, String where) {
        int ind = 0;
        double val = arr[0];

        for (int i = 0; i < arr.length; i++) {
            if (Math.abs(arr[i]) > val) {
                ind = i;
                val = Math.abs(arr[i]);
            }
        }
        double[] newArray = Util.subArray(arr, ind);
        double secLargestVal = newArray[0];
        for (int i = 0; i < newArray.length; i++) {
            if (Math.abs(newArray[i]) > secLargestVal) {
                secLargestVal = Math.abs(newArray[i]);
            }
        }

        //System.out.println("val=" + val + " secLargestVal=" + secLargestVal);

        if (almostEqual(val, secLargestVal, 1E-13)) {
            System.err.println("Warning: two values indistinguishable - possibility of rounding errors " + where);
        }
        return ind;
    }

    public static boolean almostEqual(double a, double b, double eps){
        return Math.abs(a-b)<eps;
    }

    public static double[] subArray(double[] origArray, int start, int end) {
        int newLength = end - start + 1;
        double[] newArray = new double[newLength];
        int newCounter = 0;
        for (int i = start; i <= end; i++) {                 // TODO - check here as edited on 28 Oct 2013
            newArray[newCounter] = origArray[i];
            newCounter++;
        }
        return newArray;
    }

    public static double[] subArray(double[] origArray, int posToRemove) {
        int newLength = origArray.length - 1;
        double[] newArray = new double[newLength];
        for (int i = 0; i < posToRemove; i++) {
            newArray[i] = origArray[i];
        }
        for (int i=posToRemove; i<newLength; i++) {
            newArray[i] = origArray[i+1];
        }
        return newArray;
    }

    /**
     * Takes a double[][] and start and end indices and returns the subarray
     * @param origArray
     * @param startRow
     * @param endRow
     * @param startCol
     * @param endCol
     * @return newArray a double[][]
     */
    public static double[][] subArray(double[][] origArray, int startRow, int endRow, int startCol, int endCol) {
        int numRows = endRow-startRow+1;
        int numCols = endCol-startCol+1;
        double[][] newArray = new double[numRows][numCols];
        int newRowCounter=0, newColCounter=0;
        for (int oldRowCounter = startRow; oldRowCounter <= endRow; oldRowCounter++) {
            for (int oldColCounter = startCol; oldColCounter <= endCol; oldColCounter++) {
                newArray[newRowCounter][newColCounter] = origArray[oldRowCounter][oldColCounter];
                newColCounter++;
            }
            newColCounter = 0;
            newRowCounter++;
        }
        return newArray;
    }

    /**
     * Takes a double[][] and start and end indices and returns the subarray
     * @param origArray
     * @param startRow
     * @param endRow
     * @param startCol
     * @param endCol
     * @return newArray a double[][]
     */
    public static int[][] subArray(int[][] origArray, int startRow, int endRow, int startCol, int endCol) {
        int numRows = endRow-startRow+1;
        int numCols = endCol-startCol+1;
        int[][] newArray = new int[numRows][numCols];
        int newRowCounter=0, newColCounter=0;
        for (int oldRowCounter = startRow; oldRowCounter <= endRow; oldRowCounter++) {
            for (int oldColCounter = startCol; oldColCounter <= endCol; oldColCounter++) {
                newArray[newRowCounter][newColCounter] = origArray[oldRowCounter][oldColCounter];
                newColCounter++;
            }
            newColCounter = 0;
            newRowCounter++;
        }
        return newArray;
    }


    public static Point[] subArray(Point[] origArray, int start, int end) {
        int newLength = end - start;
        Point[] newArray = new Point[newLength];
        for (int i = 0; i < end; i++) {
            newArray[i] = origArray[i];
        }
        return newArray;
    }

    public static Point[] subArray(Point[] origArray, int posToRemove) {
        int newLength = origArray.length - 1;
        Point[] newArray = new Point[newLength];
        for (int i = 0; i < posToRemove; i++) {
            newArray[i] = origArray[i];
        }
        for (int i=posToRemove; i<newLength; i++) {
            newArray[i] = origArray[i+1];
        }
        return newArray;
    }


    // String result = String.format("10 / 3 = %.2f", 10.0 / 3.0);
    // result now equals  "10 / 3 = 3.33"
    public static void print(double[] arr) {
        for (double val : arr) {
            System.out.print(" " + val + " ");
        }
        System.out.println();
    }

    public static String toStringCSV(double[] arr) {
        String mystring = "";
        for (double val : arr) {
            mystring = mystring + " " + val + ", ";
        }
        return mystring;
    }

    public static String toStringCSV(int[][] arr) {
        String mystring = "";
        for (int row = 0; row < arr.length; row++) {
            for (int col = 0; col < arr[0].length; col++) {
                mystring = mystring + " " + arr[row][col] + ", ";
            }
            mystring = mystring + "\n";
        }
        return mystring;
    }

    public static void print(double[] arr, Boolean round) {
        if (round) {
            for (double val : arr) {
                String result = String.format(" %.7f ", val);
                System.out.print(result);
            }
            System.out.println();
        } else {
            for (double val : arr) {
                System.out.print(" " + val + " ");
            }
            System.out.println();
        }
    }

    public static void print(int[] arr) {
        for (double val : arr) {
            System.out.print(" " + val + " ");
        }
        System.out.println();
    }

    public static void print(double[][] arr) {
        for (int i=0; i < arr.length; i++) {
            for (int j=0; j < arr[0].length; j++) {
                System.out.print(" " + arr[i][j] + " ");
            }
            System.out.println();
        }
    }

    public static void print(int[][] arr) {
        for (int i=0; i < arr.length; i++) {
            for (int j=0; j < arr[0].length; j++) {
                System.out.print(" " + arr[i][j] + " ");
            }
            System.out.println();
        }
    }

    /**
     * Reads in from a CSV file which has commas as separators and newlines
     * @param filename
     * @param numCols
     * @param numRows
     * @return
     * @throws FileNotFoundException
     */
    public static double[][] csvRead(String filename, int numCols, int numRows) throws FileNotFoundException {
        double[][] myarray = new double[numRows][numCols];

        // Read in an array from the filename on entry (CSV)
        Scanner scanner = new Scanner(new File(filename));
        scanner.useDelimiter(",|\\n");   // delimiters in the csv file are new lines and commas
        int counter = 0;
        int itID = 0, streamID = 0;
        //int patch = -1;
        double curr;   // holds the next thing that's read in

        // double x = 0, y = 0;
        while(scanner.hasNext() && counter < (numCols*numRows)){

            curr = Double.parseDouble(scanner.next());
            myarray[itID][streamID] = curr;
            //System.out.println(counter + " streamID=" + streamID + " timePointID=" + itID + " " + curr);

            // Increment stuff
            counter += 1; // increment loop counter ...
            if (counter%numCols == 0) {     // move to the next stream if reached the end
                streamID = 0;
                itID += 1;
            } else {
                streamID += 1;
            }
        }
        scanner.close();
        return myarray;
    }

    /**
     * Sum array in the first dimension (would be "down" in Matlab)
     * @param arr
     * @return
     */
    public static double[] sumArray( double[][] arr) {
        int numCols = arr[0].length;
        int numRows = arr.length;
        double[] sums = new double[numCols];  // one position for each column (i.e. second dimension)

        // Sum over columns
        for (int c = 0; c<numCols ; c++) {
            sums[c] = 0;
            for (int r=0; r<numRows; r++)  {
                sums[c] += arr[r][c];
            }
        }

        return sums;

    }

    /**
     * Sum of the squares of values in an array (used in Rhat calculations)
     * @param arr
     * @return
     */
    public static double[] sumSqArray( double[][] arr) {
        int numCols = arr[0].length;
        int numRows = arr.length;
        double[] sums = new double[numCols];  // one position for each column (i.e. second dimension)

        // Sum over columns
        for (int c = 0; c<numCols ; c++) {
            sums[c] = 0;
            for (int r=0; r<numRows; r++)  {
                sums[c] += arr[r][c]*arr[r][c];
            }
        }

        return sums;

    }

    /**
     * Sums the values of two 1-d arrays of doubles of the same length.
     * @param arr1
     * @param arr2
     * @return
     */
    public static double[] add(double[] arr1, double[] arr2) {
        if (arr1.length != arr2.length) {
            System.err.println("Cannot add together two arrays of different length (arrays are printed out too in black)");
            Util.print(arr1);
            Util.print(arr2);
            System.exit(0);
        }
        double[] newarr = new double[arr1.length];
        for (int i=0; i<arr1.length; i++) {
            newarr[i] = arr1[i] + arr2[i];
        }
        return newarr;
    }

    /**
     * Adds a double to every elt of an array
     * @param arr1
     * @param num
     * @return
     */
    public static double[] add(double[] arr1, double num) {
        double[] newarr = new double[arr1.length];
        for (int i=0; i<arr1.length; i++) {
            newarr[i] = arr1[i] + num;
        }
        return newarr;
    }

    /**
     * Takes arr2 away from arr1, element-wise
     * @param arr1
     * @param arr2
     * @return
     */
    public static double[] minus(double[] arr1, double[] arr2) {
        if (arr1.length != arr2.length) {
            System.err.println("Cannot take away together two arrays of different length");
        }
        double[] newarr = new double[arr1.length];
        for (int i=0; i<arr1.length; i++) {
            newarr[i] = arr1[i] - arr2[i];
        }
        return newarr;
    }

    public static double[] minus(double[] arr, double num) {
        double[] newarr = new double[arr.length];
        for (int i=0; i<arr.length; i++) {
            newarr[i] = arr[i] - num;
        }
        return newarr;
    }

    /**
     * Divides all elements of a 1-d double array by a double value
     * @param arr
     * @param divisor
     * @return
     */
    public static double[] div(double[] arr, double divisor) {
        double[] newarr = new double[arr.length];
        for (int i=0; i<arr.length; i++) {
            newarr[i] = arr[i] / divisor;
        }
        return newarr;
    }

    /**
     * Multiplies each element of an array by a value
     * @param arr
     * @param divisor
     * @return
     */
    public static double[] times(double[] arr, double divisor) {
        double[] newarr = new double[arr.length];
        for (int i=0; i<arr.length; i++) {
            newarr[i] = arr[i] * divisor;
        }
        return newarr;
    }

    /**
     * Raises each element of an array of doubles to a power
     * @param arr
     * @param expon
     * @return
     */
    public static double[] expArr(double[] arr, double expon) {
        double[] newarr = new double[arr.length];
        for (int i=0; i<arr.length; i++) {
            newarr[i] = Math.pow(arr[i],expon);
        }
        return newarr;
    }

    /**
     * Converts a decimal number v to a binary array of length numels, most significant at start of array
     * @param v   decimal value
     * @param numels   length of array
     * @return
     */
    public static int[] de2bi(int v, int numels) {
        int[] bits = new int[numels];
        String binStr = Integer.toBinaryString(v);
        int ind = 0;
        // pad with zeros at start
        while (ind < (numels - binStr.length()) ) {
            bits[ind] = 0;
            ind ++;
        }
        // put in rest of values
        for (int i = 0; i < binStr.length(); i++) {
            bits[i+ind] = Character.getNumericValue(binStr.charAt(i));
        }
        return bits;
    }

    public static int[] biStr2biArr(String state) {
        int[] bits = new int[state.length()];
        // put in rest of values
        for (int i = 0; i < state.length(); i++) {
            bits[i] = Character.getNumericValue(state.charAt(i));
        }
        return bits;
    }

    public static int bi2de(int[] bits) {
        String bitsStr = arr2biStr(bits);
        int decimalValue = Integer.parseInt(bitsStr, 2);
        return decimalValue;
    }


    public static double[][] transposeMatrix(double [][] m){
        double[][] temp = new double[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;
    }

    public static int[][] transposeMatrix(int [][] m){
        int[][] temp = new int[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;
    }

    public static double[][] int2dbl(int [][] m){
        double[][] temp = new double[m.length][m[0].length];
        for (int i = 0; i < m.length; i++)
            for (int j = 0; j < m[0].length; j++)
                temp[i][j] = m[i][j];
        return temp;
    }

    public static BitSet bin2BitSet(int[] binRep) {
        int n = binRep.length;

        BitSet b = new BitSet(n);
        for (int i=0; i<n; i++) {
            if (binRep[i] == 1) {
                b.set(i);
            }
        }
        return b;
    }

    public static int[] BitSet2bin(BitSet bitsetrep) {
        int n = bitsetrep.size();

        int[] arr = new int[n];
        for (int i=0; i<n; i++) {
            if (bitsetrep.get(i) == true) {
                arr[i] = 1;
            }
        }
        return arr;
    }
}