import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.IntStream;

class Data implements Comparable<Data> {
    public int length;
    public double[] values, normValues;
    public Cluster cluster;

    public Data(int _length) {
        this.length = _length;

        this.values = new double[this.length];
        this.normValues = new double[this.length];
    }

    public Data(double ...tab) {
        this(tab.length);

        Arrays.setAll(this.values, (index) -> tab[index]);
    }

    @Override
    public int compareTo(Data arg0) {
        return 0; // On nous dit qu'il implémente Comparable, on nous donne pas la comparaison, d'où le 0
    }

    @Override
    public String toString() {
        String s = "";
        for(double v : values) s += (v + ", ");

        return s;
    }

    public boolean normalize(double[] max) {
        if(this.values.length != max.length)
            return false;

        Arrays.setAll(this.normValues, (index) -> this.values[index] / max[index]);

        return true;
    }

    public double dist(Data other) {
        double sum = 0;
        for(int i = 0; i < this.normValues.length && i < other.normValues.length; i++) {
            sum += Math.pow((this.normValues[i] - other.normValues[i]), 2);
        }

        return Math.sqrt(sum);
    }
}

class Cluster {
    private ArrayList<Data> dataSet;
    private Data centroid;
    private int no;

    private static int nb;

    public Cluster() {
        dataSet = new ArrayList<Data>();
        centroid = new Data();
        no = nb++;
    }

    public Cluster(Data _centroid) {
        this();
        centroid = _centroid;
    }

    public void add(Data data) {
        dataSet.add(data);
        data.cluster = this;
    }

    public void remove(Data data) {
        dataSet.remove(data);
        data.cluster = null;
    }

    public void centralize() {
        int min = Integer.MAX_VALUE;
        for(Data data : dataSet)
            if(data.values.length < min) min = data.values.length;

        double[] means = new double[min];
        double[] maxs = new double[min];

        double[] sum = new double[min];
        IntStream.range(0, min)
            .forEach(i -> { // Pour chaque entier de 0 à min
                // on initialise le sum[i] comme étant la sum de toutes les data.values[i]
                sum[i] = dataSet.stream().mapToDouble(data -> data.values[i]).sum();
            });

        for(int i = 0; i < min; i++) {
            double max = -Double.MIN_VALUE;

            for(Data data : dataSet) // On cherche le max de chaque colonnes
                if(data.values[i] > max)
                    max = data.values[i];

            // On calcul la moyenne
            means[i] = (sum[i] / dataSet.size());
            maxs[i] = max;
        }

        centroid = new Data(means);
        centroid.normalize(maxs);
    }
}

/*
 * 2.3.1 : Expliquer la ligne :
 * dataSet est une liste possédant une méthode "forEach", celle ci permet de lui passer une fonction
 * anonyme (ou autrement appelée lambda) qui prend en paramètre l'objet du tableau à l'index actuel (géré
 * par le forEach), et execute la méthode par rapport à cet objet passé.
 * Ainsi, on execute searchCluser(data).add(data) sur l'ensemble des objets contenus dans dataSet.
 *
 */

public class Revisions {

    private double[] dim;
    private Cluster[] clusters;

    void initialize(int _nbClusters, int _dim) {
        dim = new double[_dim];
        /*
         *
         * FONCTION SANS AUCUN SENS
         */
    }

    public Revisions() {
        Cluster cluster = new Cluster();
        cluster.add(new Data(2.4, 8.4, 1.3));
        cluster.add(new Data(4.6, 6.8, 2.7));
        cluster.add(new Data(8.1, 7.4, 4.4));
        cluster.add(new Data(1.6, 2.3, 7.3));

        cluster.centralize();
    }






    public static void main(String[] args) {
        new Revisions();
    }

}