package assignment_2;

/* Students: Lorenzo Casini (ID:10140), Edona Gashi(ID:11428)
*
* Hamming Code decoder and encoder.
* Given an input string, the string is parsed and iterated one character
* at a time. From each character we get its 8-bit ASCII representation
* and we divide it into two 4-bits strings. We generate three parity bits for
* each 4-bits string and we append the result to them in order to get a
* 14-bits string for each character (4bits-3parity-4bits-3parity). Each
* string is then written to a text file on different lines to ease retrieve
* and decoding.
* Encode is achieved by retrieving one line after another. Each line is a
* string of 14 character, which is parsed again in 4-3-4-3 bits. We generate
* again the parity bits on the 4-bits strings and we compare the 7-bits
* retrieved string with the generated one. If equals, no error occurred.
* Else we must look for errors. Depending on which parity bit we have a
* difference with the generated one, we know where the error is and we
* correct the corresponding bit of the retrieved string.
* If the error is a parity bit, we don't care. They are deleted anyway so
* we don't bother correcting those bits.
* At this point we return only the correct two 4-bits packets, concatenate
* them and we parse the string to decimal integer and cast to character,
* to translate the decimal ASCII value in an actual character.
* Character are then concatenated to get the original input string.
* 
* The code is unable to detect/correct more than one error. */


import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Scanner;

public class HammingCode {

	public static void main(String[] args) {
		
		// Input String
		String str = "Hello World!";
		
		// Encode method and output to file
		encode(str, "output.txt");
		
		// Prints decoded output taken from file
		System.out.println(decode("output.txt"));
		
	}
	
	private static void encode(String message, String filename){
		
		// Local variables
		int length = message.length();
		char currChar;
		String binaryString, frst4Bit, scnd4Bit;
		String decodedChar;
		
		try {
			// PrintWriter to write to file
			PrintWriter out = new PrintWriter(filename, "UTF-8");
			
			// For each char of input string
			for(int i=0; i<length; i++){
				
				// Takes character and converts to 8-bits binary string
				currChar = message.charAt(i);
				binaryString = Integer.toBinaryString(0x100 + currChar).substring(1);
				
				// Divides string into two 4-bits blocks
				frst4Bit = binaryString.substring(0,4);
				scnd4Bit = binaryString.substring(4);
				
				// Generates 14-bits string with parity bits for each 4-bits block
				decodedChar = frst4Bit + generateParityBits(frst4Bit) + scnd4Bit 
						+ generateParityBits(scnd4Bit);
				
				// Writes to file the generated string
				out.println(decodedChar);
				
			}
			
			// Closes PrintWriter
			out.close();

		} catch(IOException e){
			e.printStackTrace();
			}
		}
	
	private static String decode(String filename){
		
		// Local variables
		String word;
		String frstFile, scndFile;		
		String output = "";
		
		try{
			// Scanner to access file
			Scanner input = new Scanner(new File(filename));
			
			// For each line
			while (input.hasNextLine()) {
				
				String eightBit = "";
				word = input.nextLine();
				
				// Divides line in two 7-bit string
				frstFile = word.substring(0,7);				
				scndFile = word.substring(7);
				
				// Generates 8-bits to be decoded (eventually corrects one error)
				eightBit += getCorrect4Bits(frstFile);
				eightBit += getCorrect4Bits(scndFile);
				
				// Concatenation of char, cast to char of a binary converted to
				// integer, to get char from ASCII value
				output += (char) Integer.parseInt(eightBit, 2);
				
			}
			
			// Close Scanner
			input.close();
 
		}catch (IOException e){
			e.printStackTrace();
			}
		
		return output;
	}
	
	private static String generateParityBits(String fourBits){
		
		// Local variables
		String parity;
		int char1, char2, char3, char4, xor1, xor2, xor3;
		
		// Parse to integer each char of the four bits
		char1 = Integer.parseInt(fourBits.substring(0,1));
		char2 = Integer.parseInt(fourBits.substring(1,2));
		char3 = Integer.parseInt(fourBits.substring(2,3));
		char4 = Integer.parseInt(fourBits.substring(3));
		
		// XOR for each parity bit
		xor1 = char1^char2^char3;
		xor2 = char2^char3^char4;
		xor3 = char3^char4^char1;
		
		// Concatenation of parity bits toString
		parity = Integer.toString(xor1) + Integer.toString(xor2) + Integer.toString(xor3);
		
		return parity;
		
	}
	
	private static String getCorrect4Bits(String fileStr){
		
		// Local variables
		String generated, fourBits;
		int error;
		boolean A_Bit=false, B_Bit=false, C_Bit=false;
		
		// Stores 4-bits to generate parity bits to compare strings
		fourBits = fileStr.substring(0,4);
		generated = fourBits + generateParityBits(fourBits);
		
		// If input string equals generated one, there is no error
		if(fileStr.equals(generated)){
			return fourBits;
		}
		// Else looks for error and corrects it
		else{
			// Generate boolean variables based on parity bits, for quick compare later
			if(fileStr.charAt(4)!=generated.charAt(4)){
				A_Bit = true;
			}
			if(fileStr.charAt(5)!=generated.charAt(5)){
				B_Bit = true;
			}
			if(fileStr.charAt(6)!=generated.charAt(6)){
				C_Bit = true;
			}
			
			// If there is an error in all three parity bits, error is in third
			// position of the 4-bits. Returns corrected 4-bits
			if(A_Bit && B_Bit && C_Bit){
				error = (Integer.parseInt(fileStr.substring(2,3))+1)%2;
				return fileStr.substring(0,2) + error + fileStr.charAt(3);
			}
			
			// If there is an error in first and second parity bits, error is in
			// second position of the 4-bits. Returns corrected 4-bits
			if(A_Bit && B_Bit){
				error = (Integer.parseInt(fileStr.substring(1,2))+1)%2;
				return fileStr.substring(0,1) + error + fileStr.substring(2,4);
			}
			
			// If there is an error in first and third parity bits, error is in
			// first position of the 4-bits. Returns corrected 4-bits
			if(A_Bit && C_Bit){
				error = (Integer.parseInt(fileStr.substring(0,1))+1)%2;
				return error + fileStr.substring(1,4);
			}
			
			// If there is an error in second and third parity bits, error is in
			// fourth position of the 4-bits. Returns corrected 4-bits
			if(B_Bit && C_Bit){
				error = (Integer.parseInt(fileStr.substring(3,4))+1)%2;
				return fileStr.substring(0,3) + error;
			}
			
			// Else error is in first OR second OR third parity bits. Because we will
			// truncate them anyway, we don't need to correct anything. Returns 4-bits
			// with no change at all
			return fourBits;
		}
		
	}

}