/**
 * La class Attente inclu un KeyListener, cette classe a pour objectif d'attendre une entré sur la touche espace du clavier
 * pour regarder le parcours qu'emprunte l'algorithme 
 * @version 1.1
 * @author Matthis Fauvet 
 */

public class outils {
    public static final int COULOIR=0;
    public static final int MUR=1;
    public static final int ENTREE=2;
    public static final int SORTIE=3;

    protected outils(){
    }

    /**
     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
     * @param unPerso On rentre 
     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
     * @param coord tableau double dimension qui stock les différentes Cellules.
     */
    public static int[] reverse(int[] un_tableau) {
        int taille = un_tableau.length;
        int[] cette_copie;
        cette_copie = new int[un_tableau.length];
        int compteur=taille;
        for(int j=0; j<cette_copie.length; j++){
            cette_copie[j]=un_tableau[compteur-1];
            compteur--;
        }
        return cette_copie;
    }
    /**
     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
     * @param unPerso On rentre 
     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
     * @param coord tableau double dimension qui stock les différentes Cellules.
     */
    public static int[] concatenate(int[] first_tab, int[] tab_to_add){
        int taille = first_tab.length;
        int[] tableau_temp = new int[taille+tab_to_add.length];
        int compteur = 0;
        if(first_tab != null){
            for(int i=0;i<taille;i++){
                tableau_temp[compteur]=first_tab[i];
                compteur++;
            }
        }
        if(tab_to_add != null){
            for(int i=0;i<tab_to_add.length;i++){
                tableau_temp[compteur]=tab_to_add[i];
                compteur++;
            }
        }
        return tableau_temp;
    }
    /**
     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
     * @param unPerso On rentre 
     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
     * @param coord tableau double dimension qui stock les différentes Cellules.
     */
    public static void PrintGrilleBool(boolean[][] leTableau, int saTaille){
        for(int i=0; i<saTaille; i++){
            for(int j=0; j<saTaille; j++){
                System.out.print(leTableau[i][j]+" ");
            }
            System.out.print("\n");
        }
        System.out.print("\n ------------ \n FIN \n");
    }
    /**
     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
     * @param unPerso On rentre 
     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
     * @param coord tableau double dimension qui stock les différentes Cellules.
     */
    public static void PrintGrilleCell(Cellules[][] leTableau, int saTaille){
        for(int i=0; i<saTaille; i++){
            for(int j=0; j<saTaille; j++){
                System.out.print("Le type vaut :  "+leTableau[i][j].getType()+" | ");
            }
            System.out.print("\n");
        }
        System.out.print("\n ------------ \n FIN \n");
    }
    /**
     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
     * @param unPerso On rentre 
     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
     * @param coord tableau double dimension qui stock les différentes Cellules.
     */
    public static int[] ParcoursCell(Cellules[][] leTableau, int saTaille){
        int[] ceTableau = new int[4];
        for(int i=0; i<saTaille; i++){
            for(int j=0; j<saTaille; j++){
                if(leTableau[i][j].getType() == ENTREE){
                    ceTableau[0] = leTableau[i][j].getLigne();
                    ceTableau[1] = leTableau[i][j].getColone();
                } else if(leTableau[i][j].getType() == SORTIE){
                    ceTableau[2] = leTableau[i][j].getLigne();
                    ceTableau[3] = leTableau[i][j].getColone();
                }
            }
        }
        return ceTableau;
    }
    /**
     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
     * @param unPerso On rentre 
     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
     * @param coord tableau double dimension qui stock les différentes Cellules.
     */
    public static byte[] ConvertToByte(int[] leTableau){
        byte[] taByte = new byte[leTableau.length];
        for(int i=0; i<leTableau.length; i++){
            taByte[i]=(byte) leTableau[i];
        }
        return taByte;
    }
    /**
     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
     * @param unPerso On rentre 
     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
     * @param coord tableau double dimension qui stock les différentes Cellules.
     */
    public static void printInt(int[] leTableau, int saTaille) {
        for(int i=0; i<saTaille;i++){
            System.out.print("["+leTableau[i] +"] ");
        }
        System.out.print("\n");
    }
    /**
     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
     * @param unPerso On rentre 
     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
     * @param coord tableau double dimension qui stock les différentes Cellules.
     */
    public static void printBool(boolean[] leTableau, int saTaille) {
        for(int i=0; i<saTaille*saTaille;i++){
            System.out.print("["+leTableau[i] +"] ");
        }
        System.out.print("\n");
    }
    /**
     * Class qui créer un objet Algo determinatif pour résoudre le Labyrinthe
     * @param unPerso On rentre 
     * @param grille c'est la grille de true et false qui permet de savoir si une cellules est un mur ou un couloir
     * @param coord tableau double dimension qui stock les différentes Cellules.
     */
    public static boolean[] PutToVertical(boolean[][] leTableau, int saTaille){
        boolean[] resultat = new boolean[saTaille*saTaille];
        int compteur=0;
        for(int i=0; i<saTaille; i++){
            for(int j=0; j<saTaille;j++){
                resultat[compteur] = leTableau[j][i];
                compteur++;
            }
        }
        return resultat;
    }

    public static int moyenneTabint(int[] leTableau){
        int somme = 0;
        for(int valeur : leTableau){
            somme = somme + valeur;
        }
        return somme/leTableau.length;
    }
}