Enigma en php

<?php
//on definis dans un array le mot que l'on choisis
//@TODO : mode verbose : pour que la fonction enigma parle, et donne les étapes
//@TODO : plus d'interactivité avec l'utilisateur : il rentre un mot, explode(), puis on travaille sur l'array.
//@TODO : effectuer le tout sur les 26 lettres de l'alphabet : donc plus grand tableau de connexion, plus grand rotor, plus grand reflecteur
//@TODO : la cryptanalyse de tout ça !
//@TODO : gerer la position initiale des rotors
$lettres = array( 'F', 'A', 'D', 'E', 'F', 'A', 'C');
//On commence par toutes les definitions
// Tableau de connexion
$connexion = array( 'A' => 'C',
                    'B' => 'B',
                    'C' => 'A',
                    'D' => 'F',
                    'E' => 'E',
                    'F' => 'D');
//Le premier rotor, dans son état initial
$rotor1 = array( 'A' => 'E',
                 'B' => 'A',
                 'C' => 'F',
                 'D' => 'B',
                 'E' => 'D',
                 'F' => 'C');
//le deuxieme
$rotor2 = array( 'A' => 'F',
                 'B' => 'D',
                 'C' => 'B',
                 'D' => 'E',
                 'E' => 'C',
                 'F' => 'A');
// et le troisième
$rotor3 = array( 'A' => 'D',
                 'B' => 'C',
                 'C' => 'E',
                 'D' => 'A',
                 'E' => 'F',
                 'F' => 'B');
//le reflecteur : on le definit comme un rotor
$reflecteur = array( 'A' => 'D',
                     'B' => 'C',
                     'C' => 'B',
                     'D' => 'A',
                     'E' => 'F',
                     'F' => 'E');
 $i = 0; // i=0 : c'est "l'aller" i=1 : c'est "le retour"
 $j = 0; // quand j=6, rotor2 tourne
 $k = 0; // quand k=6 rotor3 tourne
function connexion($connexion, $lettre) { // fonction qui passe dans le tableau de connexion
    $lettre_connexion = $connexion[$lettre];
    return $lettre_connexion; // ne retourne qu'une lettre
}
function rotor1($rotor, $lettre, $j, $i) { // fonction pour le rotor1

    if($i == 0) { // ca veut dire que c'est le premier passage
        $lettre_rotor1 = $rotor[$lettre];
        $j++;
    }
    else {
        foreach($rotor as $key => $values) { // au retour, on passe les rotor dans l'autre sens
            $rotor_e[$values] = $key;        // donc il faut echanger les clef et les valeurs des array
        }
        $lettre_rotor1 = $rotor_e[$lettre];
        $rotor = tourner_rotor($rotor); // au retour, après avoir remodifié la lettre, on tourne le rotor1
    }
    return array($rotor, $lettre_rotor1, $j); // on retourne un tableau : [0] = rotor [1] = lettre [2] = j
}
function rotor2($rotor, $lettre, $j, $k, $i) { // le rotor2


    if($i == 0) {
        $lettre_rotor2 = $rotor[$lettre];
        if($j == 6) {
            $k++; // k ne s'incremente qu'une fois que j=6
        }
    }
    else {
        foreach($rotor as $key => $values) {
            $rotor_e[$values] = $key;
        }
        $lettre_rotor2 = $rotor_e[$lettre];
        if($j == 6) {
            $rotor = tourner_rotor($rotor);
            $j=0;
        }
    }
    return array($rotor, $lettre_rotor2, $j, $k);
}
function rotor3($rotor, $lettre, $k, $i) { // le rotor3

    if($i == 0) {
        $lettre_rotor3 = $rotor[$lettre];
    }
    else {
        foreach($rotor as $key => $values) {
            $rotor_e[$values] = $key;
        }
        $lettre_rotor3 = $rotor_e[$lettre];
        if($k == 6) {
            $rotor = tourner_rotor($rotor);
            $k=0;
        }
    }
    return array($rotor, $lettre_rotor3, $k);
}
function reflecteur($reflecteur, $lettre) { // le reflecteur
    $lettre_reflecteur = $reflecteur[$lettre];
    $i=1; // on vient de finir "l'aller", on passe donc au "retour"
    return array($lettre_reflecteur, $i); // retourne un tableau : [0] = lettre [1] = i
}
function tourner_rotor($rotor) { // quand les rotors tourne
$tamp = array( 'A' => $rotor['B'],
               'B' => $rotor['C'],
               'C' => $rotor['D'],
               'D' => $rotor['E'],
               'E' => $rotor['F'],
               'F' => $rotor['A'] ); // on fait tout monter d'un cran

    foreach($tamp as $key => $value) { // sauf que en plus de tout monter d'un cran, il faut "baisser" d'un la valeur de chaque lettre
        switch ($value) {              // ainsi, si $tamp[A] vaut C, il faut le transformer en C-1 = "B"
            case "A" :
                $tamp[$key] = "F";
                break;
            case "B" :
                $tamp[$key] = "A";
                break;
            case "C" :
                $tamp[$key] = "B";
                break;
            case "D" :
                $tamp[$key] = "C";
                break;
            case "E" :
                $tamp[$key] = "D";
                break;
            case "F" :
                $tamp[$key] = "E";
                break;
            default :
                echo "ERROR";
                break;
        }
    }
    return $tamp; // on retourne le tableau
}
function enigma($connexion, $rotor1, $rotor2, $rotor3, $reflecteur, $lettres, $j, $k, $i) { // fonctions principale : appelle les autres fonctions
$lettres_return = array(); // on initialise le "return" en un array des nouvelles lettres
    $l=0; // on initialise l, qui sera incrémenter pour chaque lettre passer dans la machine
    foreach($lettres as $lettre) { // on parcourt l'array $lettres
        //echo $lettre . "=>";
        $lettre_connexion1 = connexion($connexion, $lettre); // on appelle la fonction qui fait le tableau de connexion
        //echo $lettre_connexion1 . "=>" ;

        $result_rotor1a = rotor1($rotor1, $lettre_connexion1, $j, $i); // on passe par le rotor1
        $rotor1 = $result_rotor1a[0];
        $lettre_rotor1a = $result_rotor1a[1];
        $j = $result_rotor1a[2];
        //echo $lettre_rotor1a . "=>";

        $result_rotor2a = rotor2($rotor2, $lettre_rotor1a, $j, $k, $i); // le rotor2
        $rotor2 = $result_rotor2a[0];
        $lettre_rotor2a = $result_rotor2a[1];
        $j = $result_rotor2a[2];
        $k = $result_rotor2a[3];
        //echo $lettre_rotor2a . "=>";

        $result_rotor3a = rotor3($rotor3, $lettre_rotor2a, $k, $i); // le rotor3
        $rotor3 = $result_rotor3a[0];
        $lettre_rotor3a = $result_rotor3a[1];
        $k = $result_rotor3a[2];
        //echo $lettre_rotor3a . "=><b>";

        $result_reflecteur = reflecteur($reflecteur, $lettre_rotor3a);// le reflecteur
        $lettre_reflecteur = $result_reflecteur[0];
        $i = $result_reflecteur[1]; // i=1, donc on passe tout dans le sens inverse
        //echo $lettre_reflecteur . "</b>=>";

        $result_rotor3b = rotor3($rotor3, $lettre_reflecteur, $k, $i); // rotor3, avec i=1
        $rotor3 = $result_rotor3b[0];
        $lettre_rotor3b = $result_rotor3b[1];
        $k = $result_rotor3b[2];
        //echo $lettre_rotor3b . "=>";

        $result_rotor2b = rotor2($rotor2, $lettre_rotor3b, $j, $k, $i); // rotor2, avec i=1
        $rotor2 = $result_rotor2b[0];
        $lettre_rotor2b = $result_rotor2b[1];
        $j = $result_rotor2b[2];
        $k = $result_rotor2b[3];
        //echo $lettre_rotor2b . "=>";

        $result_rotor1b = rotor1($rotor1, $lettre_rotor2b, $j, $i); // rotor1 avec i=1
        $rotor1 = $result_rotor1b[0];
        $lettre_rotor1b = $result_rotor1b[1];
        $j = $result_rotor1b[2];
        //echo $lettre_rotor1b . "=>";

        $lettre_connexion2 = connexion($connexion, $lettre_rotor1b); // on repasse dans le tableau de connexions
        //echo $lettre_connexion2 . "<br>" ;

        $i=0;
        $lettres_return[$l] = $lettre_connexion2; // on forme un array avec les nouvelles lettres
        $l++;
        }
        return $lettres_return;
}
foreach($lettres as $value) {
    echo $value; // on affiche les lettre de depart
}
$lettres = enigma($connexion, $rotor1, $rotor2, $rotor3, $reflecteur, $lettres, $j, $k, $i); // on applique la fonction enigma
echo 'a été transformé en : <b>';
foreach($lettres as $value) {
    echo $value; // on affiche les lettre à l'arrivé
}
echo '</b>';