/* Hamming Code Test Program
   - Creates a Random Array of Bits (0/1 elements)
   - Randomly chooses EVEN or ODD Parity
   - Encodes via Hamming.encoding(data, parity)
   - Randomly introduces a Single-Bit Error in the Encoding
   - Decodes via Hamming.decoding(code, parity)
   - Displays the Encoding, and Original & Decoded Bits (for comparison)
   
   Norman Pestaina   CDA 4101 Assignment  Spring 2017
*/
import java.util.*;
public class HammingTester
{
   public static void main(String[] args)
   {
      //Select Parity: ODD (false), EVEN (true)
      boolean parity = (new Random()).nextBoolean();
      
      //Generate Random Data Bits (between 4 - 16)
      int[] data = randomBits(4, 16);
      
      //Create & Display the Hamming-Encoding
      int[] code = Hamming.encoding(data, parity);
      System.out.println((parity ? "EVEN" : "ODD") + " Parity" + "\n" +
                         "DATA: " + Arrays.toString( data )    + "\n" +
                         "CODE: " + Arrays.toString( code ) );
      
      //Invert a Single Randomly Selected Bit (perhaps none)
      makeRandomError(code);
      
      //Obtain the Hamming-Decoding with Single-Error-Correction
      int[] bits = Hamming.decoding(code, parity);
      
      //Display the Hamming-Encoding, Hamming-Decoding & Original Data
      System.out.println("CODE: " + Arrays.toString( code ) + "\n" +
                         "BITS: " + Arrays.toString( bits ) + "\n" + 
                         "DATA: " + Arrays.toString( data ) );
   }
   
   //Create an Random-Size Array of Randomly Generated 0's & 1's
   // @Param minSize: the Minimum Size of the Array
   // @Param maxSize: the Maximum Size of the Array
   // @Return: An Array of Randomly Assigned 0/1 Elements
   private static int[] randomBits(int minSize, int maxSize)
   {
      Random gen = new Random();
      
      int[] bits = new int[ minSize + gen.nextInt(maxSize - minSize + 1) ];
      for (int i = 0; i < bits.length; i++)
         bits[i] = gen.nextBoolean() ? 1 : 0;
         
      return bits;
   }
   
   //Invert a Randomly Selected Element of an Array of 0/1 Elements
   //There is 50% Probability that No Element will be Inverted
   // @Param bits: an Array of 0/1 Elements
   // @Post-Condition: At Most ONE 0/1 Element has been Inverted
   private static void makeRandomError(int[] bits)
   {
      int index = (new Random()).nextInt(bits.length * 2);
      if ( index < bits.length )
      {
         System.out.println("Inverting Bit " + (index + 1));
         bits[index] = 1 - bits[index];
      }
   }
}