import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

/**
 * 
 */

/**
 * I just very quickly made this class to help with loading example datasets.
 * No time to write comments, and I just stuffed this one-by-one with what I 
 * happened to need to make the hands-on demonstrations to work right here 
 * and now...
 * 
 * @author nieminen
 *
 */
public class DataSet {
    static final Random rg = new Random(123); // (fixed seed)
    int nattrib;
    int n;
    int ntrain,ntest;
    double data[][];
    int labels[];

    double trainvec[][];
    int trainlabel[];
    double testvec[][];
    int testlabel[];
    private int[] indexPermutation;
    


    private void clearPermutation() {
        indexPermutation = new int[n];
        for (int i=0;i<indexPermutation.length;i++) indexPermutation[i]=i;        
    }
    
    public void splitToTrainAndTest(double trainRatio) {
        ntrain = (int) Math.floor(trainRatio * n);
        ntest = n - ntrain;
        trainvec = new double[ntrain][nattrib];
        trainlabel = new int[ntrain];
        testvec = new double[ntest][nattrib];
        testlabel = new int[ntest];

        for (int i=0;i<ntrain;i++){
            for(int j=0;j<nattrib;j++){
                trainvec[i][j] = data[indexPermutation[i]][j];
                trainlabel[i] = labels[indexPermutation[i]];
            }
        }
        for (int i=0;i<ntest;i++){
            for(int j=0;j<nattrib;j++){
                testvec[i][j] = data[indexPermutation[ntrain+i]][j];
                testlabel[i] = labels[indexPermutation[ntrain+i]];
            }
        }        
    }
    
    public void shuffledSplitToTrainAndTest(double trainRatio){
        // Shuffle.
        clearPermutation();
        for (int i=indexPermutation.length-1;i>0;i--){
            int swap = rg.nextInt(i+1);
            int tmp = indexPermutation[swap];
            indexPermutation[swap] = indexPermutation[i];
            indexPermutation[i] = tmp;
        }        
        splitToTrainAndTest(trainRatio);
    }

    public void dlmread(String fname, int labelInd) throws FileNotFoundException {
        ArrayList<Double> readdata = new ArrayList<Double>();
        ArrayList<Integer> readlabels = new ArrayList<Integer>();
        Scanner sc = new Scanner(new FileInputStream(fname));
        int n = 0; int nattrib = 0;
        while(sc.hasNextLine()){
            String line = sc.nextLine();
            String[] spl = line.split(",");
            if (n==0) nattrib = spl.length;
            n++;
            for (int i=0;i<nattrib;i++){
                if (i==(labelInd-1)){
                    readlabels.add(Integer.parseInt(spl[i]));
                } else {
                    readdata.add(Double.parseDouble(spl[i]));
                }
            }
        }
        // we assume one attribute was the label:
        nattrib--;
        double[][] data = new double[n][nattrib];
        int[] labels = new int[n];
        for (int i=0;i<n;i++){
            for (int a=0;a<nattrib;a++){
                data[i][a] = readdata.get(i*nattrib+a);
            }
            labels[i] = readlabels.get(i);
        }
        
        /* huh, huh. */
        this.n = n;
        this.nattrib = nattrib;
        this.data = data;
        this.labels = labels;
    }

    public double[][] trainInputs() {
        return trainvec;
    }
    public int[] trainTargets() {
        return trainlabel;
    }
    
    public double[][] testInputs() {
        return testvec;
    }
    public int[] testTargets() {
        return testlabel;
    }
    

    public static void printConfusion(int[] predictions, int[] truth) {
        int maxt = 0;
        for (int i=0;i<truth.length;i++){
            if (truth[i]>maxt) maxt=truth[i];
        }
        
        int[][] cm = new int[maxt+1][maxt+1];
        for (int i=0;i<truth.length;i++){
            int row = predictions[i]-1;
            int col = truth[i]-1;
            cm[row][col] += 1;           
        }
        
        double diag=0.0, all=0.0;
        for (int i=0;i<maxt;i++){
            diag += cm[i][i];
            for(int j=0;j<maxt;j++){
                System.out.printf("%4d",cm[i][j]);
                System.out.printf("%s",j<maxt-1?" ":String.format("%n"));
                all += cm[i][j];
            }
        }
        double acc = diag/all;
        System.out.printf("Accuracy = %.2f%% %n",100*acc);
    }

    public static DataSet createFromTextFile(String fname, int labelInd) throws FileNotFoundException {
        DataSet ds = new DataSet();
        ds.dlmread(fname,labelInd);
        ds.clearPermutation();
        
        return ds;
    }
    
    public int getVecSize() {
        return data[0].length;
    }

    /** Returns number of different classes. Assumes class indexing begins with 1, and there is data present from each class. */
    public int getNumOfClasses() {
        
        int num=0;
        for(int i=0;i<labels.length;i++){
            if (labels[i]>num) num++;
        }
        return num;
    }

    /** Analyses training data to scale it thus: mean value is between min 
     * and max, and no value is outside [min,max]. Applies the same 
     * transformation to test data. Test data may lie outside [min,max]. 
     * This is "realistic" since test data should be "unseen" before training 
     * takes place. At least I intended to do such routine. May have bugs, I'm 
     * pouring code quite fast at the moment, to get these done before the 
     * hands-on sessions.
     */
    public void normalize(double min, double max) {
        double[] origMin = new double[getVecSize()];
        double[] origMax = new double[getVecSize()];
        double[] origMean = new double[getVecSize()];
        
        for(int i=0;i<trainvec[0].length;i++){
            origMin[i] = Double.POSITIVE_INFINITY;
            origMax[i] = Double.NEGATIVE_INFINITY;
            origMean[i] = 0.0;

            for(int v=0;v<trainvec.length;v++){
                if (trainvec[v][i] < origMin[i]) origMin[i] = trainvec[v][i];
                if (trainvec[v][i] > origMax[i]) origMax[i] = trainvec[v][i];
                origMean[i] += trainvec[v][i];
            }
            origMean[i] /= trainvec.length;
        }
        
        for(int i=0;i<trainvec.length;i++){
            for(int j=0;j<trainvec[0].length;j++){
                trainvec[i][j] = trainvec[i][j]-origMean[j];
                if (origMax[j]-origMin[j] > 0){
                    trainvec[i][j] /= Math.max(Math.abs(origMax[j]), Math.abs(origMin[j]));
                }
                trainvec[i][j] = min + .5 * (trainvec[i][j]+1)*(max-min);
            }
        }
        
        // Apply the same to test vectors.
        for(int i=0;i<testvec.length;i++){
            for(int j=0;j<testvec[0].length;j++){
                testvec[i][j] = testvec[i][j]-origMean[j];
                if (origMax[j]-origMin[j] > 0){
                    testvec[i][j] /= Math.max(Math.abs(origMax[j]), Math.abs(origMin[j]));
                }
                testvec[i][j] = min + .5 * (testvec[i][j]+1)*(max-min);
            }
        }
    }
}