import java.text.Normalizer;
import java.util.*;

public class Code_analyse_frequence {

    static ArrayList < Character > text_lettre = new ArrayList < Character > ();

    public static Scanner read = new Scanner(System.in);

    // cette fonction va éliminer les doublons d'une arraylist
    public static ArrayList < Character > antidoublon(ArrayList < Character > newlist) {
        ArrayList < Character > List = new ArrayList < Character > ();
        for (int i = 0; i < newlist.size(); i++) {
            Object o = newlist.get(i); // type objet qui sera l'index i de liste pricipale ( texte decomposer en char)
            if (!List.contains(o)) // regarde si la lettre de la liste rentré est deja dans la nouvelle list et l'ajoute si elle n'y est pas
                List.add(newlist.get(i)); // ceci va donc enlever les doublon
        }
        return List;
    }
    // cette fonction va transformer les majuscule en minuscule et enlever les accent ou autre charactère "speciaux"
    public static String FormatTexte(String texte) {
        return Normalizer.normalize(texte, Normalizer.Form.NFD).replaceAll("[\u0300-\u036F]", "");
        /* Sépare les caractere a accent en unicode ex â -> 'a'+'^' en unicode puis ilimine les caracter qui ne sont pas des lettre*/
    }
    // cette fonction va regarder si un string est constituer uniquement de nombre
    public static boolean IsNumeric(String decodeOrder) {
        boolean test = true;
        if (decodeOrder.length() == 0) // regarde si la liste et vide et retourne false si oui
            return false;
        for (int i = 0; i < decodeOrder.length(); i++) {
            if (!(Character.isDigit(decodeOrder.charAt(i)))) // regarde si la liste ne contient que des nombres
            {
                test = false;
                return test;
            } else
                test = true;

        }
        return test;
    }
    // cette fonction va décoder le text chiffré en lui donnant le décalage
    public static void decode(ArrayList < Character > newlist, String decodeOrder) {
        int decalage = 0; // decalage de decode
        boolean run = false; // dire si il faut lancer le decodage ou non
        char lettreE; // cette lettre servira au decode par la frequence ce serais la lettre la plus frequente
        if (IsNumeric(decodeOrder)) // regarde si decode ordeur est deja le decalage
        {
            decalage = Integer.parseInt(decodeOrder);
            if (decalage < 26 && decalage > -26) // verifie que le decalage est bien compris entre 25 et -25
                run = true;
            else
                run = false;
        } else {
            lettreE = decodeOrder.charAt(0); // recupere le premier character rentré pour analyser la frequence
            if (Character.isLetter(lettreE)) {
                decalage = AnalyseFreq(newlist, lettreE); // va realiser l'analyse de frequence de la lettre pour trouver le décalage
                run = true;
            } else
                run = false;
        }
        if (run) {
            String text = ""; // ceci est le texte decodé  via le decalage
            char lettre = '\0'; // ceci est la variable  qui va recuperer la la lettre dans la liste
            int nb_charact = newlist.size();

            for (int i = 0; i < nb_charact; i++) {
                lettre = newlist.get(i);
                if (lettre < 97 || lettre > 122) { // si autre chose qu'une lettre
                    text += (char) lettre;
                    continue;
                }
                if (decalage > 0) // decalage plus grand que 0 alors tu soustrait 1
                {
                    for (int nb = 0; nb < decalage; nb++) {
                        lettre -= 1;
                        if (lettre < 97) // quand arrive a 'a' retourne a 'z'
                            lettre = 122;
                    }
                    text += (char) lettre;
                } else // ajoute 1 si le decalage est plus petit que 1
                {
                    for (int nb = 0; nb < -decalage; nb++) {
                        lettre += 1;
                        if (lettre > 122) // quand arrive a 'z' retourne a 'a'
                            lettre = 97;
                    }
                    text += (char) lettre; // ajoute la lettre au texte
                }
            }
            System.out.println(text); //affiche le texte decodé
        } else if (decodeOrder.length() == 0) // si les info plus haut ne sont pas lancer et que la chaine de character est vide alors
            afficherTous(newlist, decodeOrder); //lancer afficherTous va stocker tous les possibilités

    }
    // cette fonction va codé un text decomposé en character dans une arraylist
    // cette fonction va coder le text chiffré en lui donnant le décalage
    public static void code(ArrayList < Character > newlist, String codeOrder) {
        boolean run = false; // ce boolean servira a lancer le code si tous est corect
        int decalage = 0;
        //cette partie va verifier  si la chaine de character donné est constituer uniquement de chiffre  si c est le cas elle le transforme en
        // int puis se int servira de decalage
        if (IsNumeric(codeOrder)) {
            decalage = Integer.parseInt(codeOrder);
            if (decalage < 26 && decalage > -26) // verifie que le decalage est bien compris entre 25 et -25
                run = true;
            else
                run = false;
        } else
            run = false;
        if (run) {
            String text = ""; // il s'agit du texte traduit (codé)
            char lettre = '\0'; // il s'agit de la lettre qui seras isolé a chaque pour etre codé
            int nb_charact = newlist.size(); // taille du tableau

            for (int i = 0; i < nb_charact; i++) {
                lettre = newlist.get(i);
                if (lettre < 97 || lettre > 122); // si le charactere n est pas une lettre
                else {
                    if (decalage > 0) // si le decalage est plus grand que 0 alors ajoute 1 au int du char
                    {
                        for (int nb = 0; nb < decalage; nb++) {
                            lettre++;
                            if (lettre > 122)
                                lettre = 97;
                        }
                        text += (char) lettre;
                    } else // l'inverse  plus  petit que 0 alors enleve 1
                    {
                        for (int nb = 0; nb < -decalage; nb++) {
                            lettre -= 1;
                            if (lettre < 97)
                                lettre = 122;
                        }
                    }
                }
                text += (char) lettre; // cocacene la lettre a une chaine de chractère (qui seras le texte)
            }
            System.out.println(text); // affiche le texte
        }
    }
    // cette fonction va stocker dans une ArrayList toute les possibilité de décodage
    // cette fonction va décoder toutes les possibilité de chiffrage
    public static ArrayList < String > afficherTous(ArrayList < Character > newlist, String codeOrder) {

        ArrayList < String > texteTraduit = new ArrayList < String > ();
        String text = ""; // texte codé pour la possibilité X
        char lettre = '\0'; // lettre recupérer dans la liste
        int nb_charact = newlist.size();
        for (int ii = 0; ii <= 25; ii++) // va coder toute les possibiliter de texte puis les stocker
        {
            for (int i = 0; i < nb_charact; i++) {
                lettre = newlist.get(i);
                if (lettre < 97 || lettre > 122);
                else {
                    for (int nb = 0; nb <= ii; nb++) // soustrait 1 pour decodeer le texte va realiser toute les possibiliter
                    {
                        lettre--;
                        if (lettre > 122)
                            lettre = 97;
                    }
                }
                text += (char) lettre; // crée le text en mettant  les lettre les une a la suite des autre
            }
            texteTraduit.add(text); // stocke le text dans une liste
            text = "";
        }
        return texteTraduit;

    }

    /*public static ArrayList<Character>textList(String texte)
    {
        ArrayList<Character> text_lettre = new ArrayList<Character>();
        int nb_charact = texte.length();

         for(int i = 0 ; i<nb_charact ; i++)
             text_lettre.add(i,texte.charAt(i));
         antilettreMaj(text_lettre);
         return text_lettre;
    }*/



    // cette fonction va analyser la frequence d'une lettre (peu ensuite return le decalage trouvé a modifier
    // mettre int et rapporter le decalage

    public static int AnalyseFreq(ArrayList < Character > newlist, char LettreE) {
        int posnbmax = 0, nbmax = 0, nblettre = 0, difference = 0; // mot ayant le meme nombre de lettre ;
        char lettrefreq;
        boolean test = false;


        ArrayList < Character > lettre = new ArrayList < Character > ();

        lettre.addAll(antidoublon(newlist));

        //////////////////////////////////////////////
        //cette partie du code va analiser la frequence des lettre codé
        //////////////////////////////////////////////
        for (int i = 0; i < lettre.size(); i++) {

            for (int ii = 0; ii < newlist.size(); ii++) {
                test = lettre.get(i) == newlist.get(ii);

                if (test)
                    nblettre++;
            }
            if (nblettre > nbmax) {
                posnbmax = i;
                nbmax = nblettre;
            }

            // nb_lettre.add(i,nblettre);
            nblettre = 0;
        }
        //////////////////////////////////////////////
        //cette partie du code va s'occuper de donner la difference avec la lettre la plus commune, et redemander de tenter a chaque fois ou donner l'ordre de tous afficher
        //////////////////////////////////////////////

        System.out.println("rentrez la lettre la plus utilisé " + posnbmax);
        lettrefreq = read.nextLine().charAt(0);
        LettreE = lettre.get(posnbmax);
        difference = (int) LettreE - (int) lettrefreq;

        return difference;

    }

    // cette partie est la sequence d'initialisation demandant le text et le decomposant en character dans une
    // Array list base pour les autre fonction
    static void init() {

        System.out.println("rentrez votre texte a traduire");
        String texte = read.nextLine();
        texte = FormatTexte(texte);
        int nb_charact = texte.length();


        for (int i = 0; i < nb_charact; i++)
            text_lettre.add(i, texte.charAt(i));

    }

    public static void main(String[] args) {
        init();
        read.close();
    }
}