package eg.ufe.codecorrecteur;

import java.util.Arrays;

/**
 * Bloc de données transmis. Composé de 3 octets censés représenter le même
 * octet. Cet octet est copié 2 fois au départ, ce qui permet à l'arrivée de
 * repérer et de corriger des erreurs de transmission.
 */
public class Bloc {
  private byte[] data = new byte[3];
  
  /**
   * Construit un bloc en dupliquant 2 fois un octet.
   * Il s'agit du codage de la donnée passée en paramètre.
   * 
   * @param donnee donnée codée par le bloc.
   */
  public Bloc(byte donnee) {
    data[0] = donnee;
    data[1] = donnee;
    data[2] = donnee;
  }

  //  public byte get(int i) {
  //    return data[i];
  //  }
  //
  //  /**
  //   * Retourne la valeur supposée être représentée par le bloc.
  //   * Version "détaillée", plus simple à trouver que getValeurDecodee().
  //   * 
  //   * @return la valeur supposée être représentée par le bloc.
  //   */
  //  public byte getValeurDecodee0() {
  //    if (data[0] == data[1]) {
  //      // on en a 2 égaux donc c'est la bonne valeur dans data[0]
  //      // on ne cherche pas à savoir s'il y a eu une erreur de transmission
  //      return data[0];
  //    } else {
  //      if (data[0] != data[2]) {
  //        if (data[1] == data[2]) {
  //          // on met cette valeur dans data[0]
  //          return data[1];
  //        } else {
  //          // 3 valeurs différentes ! On ne peut rien faire pour réparer
  //          // Pour ce 1er programme, on retourne la valeur de data[0]
  //          return data[0];
  //        }
  //      }
  //      // si data[0] == data[2], data[0] contient la bonne valeur
  //      return data[0];
  //    }
  //  }


  /**
   * Retourne la valeur supposée être représentée par le bloc.
   * Pas de rapport de ce qui s'est passé pendant le décodage du bloc.
   * 
   * @return la valeur du bloc décodé.
   */
  public byte getValeurDecodee() {
    if (data[1] == data[2]) {
      // Le seul cas où on ne retourne pas data[0]
      return data[1];
    } else {
      return data[0];
    }
  }
  
  /**
   * Méthode utilitaire pour coder un tableau d'octets en
   * tableau de Bloc.
   * @param valeurs
   * @return
   */
  public static Bloc[] coder(byte[] valeurs) {
    Bloc[] resultat = new Bloc[valeurs.length];
    for (int i = 0; i < valeurs.length; i++) {
      resultat[i] = new Bloc(valeurs[i]);
    }
    return resultat;
  }
  
  /**
  * Méthode utilitaire pour décoder un tableau de blocs
  * en tableau d'octet.
  * @param valeursTransmises les blocs à décoder
  * @return les octets obtenus à partir des blocs
  */
  public static byte[] decoder(Bloc[] valeursTransmises) {
    byte[] resultat = new byte[valeursTransmises.length];
    for (int i = 0; i < valeursTransmises.length; i++) {
      resultat[i] = valeursTransmises[i].getValeurDecodee();
    }
    return resultat;
  }
  
  /**
   * Simule une erreur de transmission du bloc.
   * @param i numéro de l'exemplaire de l'octet modifié.
   * @param valeur valeur modifiée
   */
  public void simulationErreurTransmission(int i, byte valeur) {
    data[i] = valeur;
  }
  
  @Override
  public String toString() {
    return "Bloc {data=" + Arrays.toString(data) + "}";
  }
}