package ecoparasite.nettoyage;

import ecoparasite.completion.Completion;
import ecoparasite.poisson.Poisson;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.function.BiConsumer;
import java.util.function.Function;

/**
 * Class Définissant les méthodes statics de Nettoyage des données
 */
public class Nettoyage {

    /**
     * Permet de remplacer les valeurs abérrantes d'un paramètre d'un HashSet par la moyenne des autres valeurs (non nulles).
     * Exemple d'utilisation : T = Poisson, V = Double, getValue = Poisson::getInfestation, setValue = Poisson::setInfestation.
     *
     * @param list La liste de données cobaye.
     * @param getValue La fonction (Getter) qui permet d'obtenir la valeur que l'on veut vérifier
     * @param setValue La fonction (Setter) qui permet de remplacer la valeur si null.
     * @param allowNegative Savoir si une valeur négative est forcément aberrant.
     * @return Le HashSet avec les valeurs remplacés.
     * @param <T> Le type de données cobaye. Exemple : Poisson, Population
     * @param <V> Le type de la donnée à vérifier, doit être un Wrapper Number. Exemple : Double.
     */
    public static <T,V extends Number> HashSet<T> nettoieColumnsMoyenne(HashSet<T> list, Function<T,V> getValue, BiConsumer<T,V> setValue, boolean allowNegative ){

        Double mean = Completion.calculateMean(list, getValue);

        ArrayList<Double> array = new ArrayList<>();
        for ( T item : list) {
            if (getValue.apply(item)!= null){ //Test des valeurs null pour les Tests Unitaires. Je ne devrais pas en avoir.
                array.add(getValue.apply(item).doubleValue());
            }
        }

        Collections.sort(array);

        int quartIndex = array.size()/4;
        Double firstQuart = array.get(quartIndex);
        Double thirdQuart = array.get(quartIndex *3);
        Double IQR =  thirdQuart - firstQuart;

        for(T item : list){
            if( getValue.apply(item).doubleValue() < firstQuart - (IQR * 1.5) || getValue.apply(item).doubleValue() > thirdQuart + (IQR * 1.5) || ( !allowNegative && getValue.apply(item).doubleValue() < 0 ) ){
                setValue.accept( item, (V) mean);
            }
        }

        return list;
    }

    /**
     * Polymorphisme de la fonction précédente. Autorise les valeurs abérrantes à être négative.
     * @param list
     * @param getValue
     * @param setValue
     * @return
     * @param <T>
     * @param <V>
     *
     * @see Nettoyage::nettoieColumnsMoyenne
     */
    public static <T,V extends Number> HashSet<T> nettoieColumnsMoyenne(HashSet<T> list, Function<T,V> getValue, BiConsumer<T,V> setValue){
        return nettoieColumnsMoyenne(list, getValue, setValue, true);
    }

    /**
     * Permet de remplacer les valeurs abérrantes d'un paramètre d'un HashSet à l'aide d'une regression linéaire, corrélation entre deux valeurs.
     * Exemple d'utilisation : T = Poisson, V = Double, getX = Poisson::getWidth, getY = Poisson::getInfes, setY = Poisson::setInfes
     *
     * @param list La liste de données cobaye.
     * @param getX La fonction (Getter) qui permet d'obtenir les données du X de notre regression linéaire.
     * @param getY La fonction (Getter) qui permet d'obtenir la valeur que l'on veut vérifier
     * @param setY La fonction (Setter) qui permet de remplacer la valeur si null.
     * @param allowNegative Savoir si une valeur négative est forcément aberrant.
     * @return Le HashSet avec les valeurs remplacés.
     * @param <T> Le type de données cobaye. Exemple : Poisson, Population
     * @param <V> Le type de la donnée à vérifier, doit être un Wrapper Number. Exemple : Double.
     */
    public static <T,V extends Number> HashSet<T> nettoieColumnsLinear(HashSet<T> list, Function<T,V> getX, Function<T,V> getY, BiConsumer<T,V> setY, boolean allowNegative ){

        double meanX =  Completion.calculateMean(list, getX);
        double meanY =  Completion.calculateMean(list, getY);

        double a = Completion.calculateLinearA(list,getX,getY,meanX,meanY);
        double b = Completion.calculateLinearB(meanX,meanY,a);

        ArrayList<Double> array = new ArrayList<>();
        for ( T item : list) {
            if (getY.apply(item)!= null){ //Test des valeurs null pour les Tests Unitaires. Je ne devrais pas en avoir.
                array.add(getY.apply(item).doubleValue());
            }
        }

        Collections.sort(array);

        int quartIndex = array.size()/4;
        Double firstQuart = array.get(quartIndex);
        Double thirdQuart = array.get(quartIndex *3);
        Double IQR =  thirdQuart - firstQuart;

        for(T item : list){
            if( getY.apply(item) == null || getY.apply(item).doubleValue() < firstQuart - (IQR * 1.5) || getY.apply(item).doubleValue() > thirdQuart + (IQR * 1.5) || ( !allowNegative && getY.apply(item).doubleValue() < 0 ) ){
                Double value = a * getX.apply(item).doubleValue() + b;
                setY.accept( item, (V) value );
            }
        }

        return list;
    }

    /**
     * Polymorphisme de la fonction nettoyage de colonne linéaire avec par défaut, l'autorisation des valeurs négatives.
     * @param list
     * @param getX
     * @param getY
     * @param setY
     * @return
     * @param <T>
     * @param <V>
     */
    public static <T,V extends Number> HashSet<T> nettoieColumnsLinear(HashSet<T> list, Function<T,V> getX, Function<T,V> getY, BiConsumer<T,V> setY){
        return nettoieColumnsLinear(list, getX, getY, setY, true);
    }
}