package Others;

import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

/**
 * @author dimgrichr
 */
public class CRCAlgorithm {

 private int correctMess;

 private int wrongMess;

 private int wrongMessCaught;

 private int wrongMessNotCaught;

 private int messSize;

 private double ber;

 private boolean messageChanged;

 private ArrayList<Integer> message;

 private ArrayList<Integer> dividedMessage;

 private ArrayList<Integer> p;

 private Random randomGenerator;


 /**
 * The algorithm's main constructor.
 * The most significant variables, used in the algorithm,
 * are set in their initial values.
 *
 * @param str The binary number P, in a string form, which is used by the CRC algorithm
 * @param size The size of every transmitted message
 * @param ber The Bit Error Rate
 */
 public CRCAlgorithm(String str, int size, double ber) {
 messageChanged = false;
 message = new ArrayList<>();
 messSize = size;
 dividedMessage = new ArrayList<>();
 p = new ArrayList<>();
 for (int i = 0; i < str.length(); i++) {
 p.add(Character.getNumericValue(str.charAt(i)));
 }
 randomGenerator = new Random();
 correctMess = 0;
 wrongMess = 0;
 wrongMessCaught = 0;
 wrongMessNotCaught = 0;
 this.ber = ber;
 }


 /**
 * Returns the counter wrongMess
 *
 * @return wrongMess, the number of Wrong Messages
 */
 public int getWrongMess() {
 return wrongMess;
 }

 /**
 * Returns the counter wrongMessCaught
 *
 * @return wrongMessCaught, the number of wrong messages, which are caught by the CRC algoriithm
 */
 public int getWrongMessCaught() {
 return wrongMessCaught;
 }

 /**
 * Returns the counter wrongMessNotCaught
 *
 * @return wrongMessNotCaught, the number of wrong messages, which are not caught by the CRC algorithm
 */
 public int getWrongMessNotCaught() {
 return wrongMessNotCaught;
 }

 /**
 * Returns the counter correctMess
 *
 * @return correctMess, the number of the Correct Messages
 */
 public int getCorrectMess() {
 return correctMess;
 }

 /**
 * Resets some of the object's values, used on the main function,
 * so that it can be re-used, in order not to waste too much memory and time,
 * by creating new objects.
 */
 public void refactor() {
 messageChanged = false;
 message = new ArrayList<>();
 dividedMessage = new ArrayList<>();
 }

 /**
 * Random messages, consisted of 0's and 1's,
 * are generated, so that they can later be transmitted
 */
 public void generateRandomMess() {
 for (int i = 0; i < messSize; i++) {
 int x = ThreadLocalRandom.current().nextInt(0, 2);
 message.add(x);
 }
 }

 /**
 * The most significant part of the CRC algorithm.
 * The message is divided by P, so the dividedMessage ArrayList<Integer> is created.
 * If check == true, the dividedMessaage is examined, in order to see if it contains any 1's.
 * If it does, the message is considered to be wrong by the receiver,so the variable wrongMessCaught changes.
 * If it does not, it is accepted, so one of the variables correctMess, wrongMessNotCaught, changes.
 * If check == false, the diviided Message is added at the end of the ArrayList<integer> message.
 *
 * @param check the variable used to determine, if the message is going to be checked from the receiver
 * if true, it is checked
 * otherwise, it is not
 */
 public void divideMessageWithP(boolean check) {
 ArrayList<Integer> x = new ArrayList<>();
 ArrayList<Integer> k = (ArrayList<Integer>) message.clone();
 if (!check) {
 for (int i = 0; i < p.size() - 1; i++) {
 k.add(0);
 }
 }
 while (!k.isEmpty()) {
 while (x.size() < p.size() && !k.isEmpty()) {
 x.add(k.get(0));
 k.remove(0);
 }
 if (x.size() == p.size()) {
 for (int i = 0; i < p.size(); i++) {
 if (x.get(i) == p.get(i)) {
 x.set(i, 0);
 } else {
 x.set(i, 1);
 }
 }
 for (int i = 0; i < x.size() && x.get(i) != 1; i++) {
 x.remove(0);
 }
 }
 }
 dividedMessage = (ArrayList<Integer>) x.clone();
 if (!check) {
 for (int z : dividedMessage) {
 message.add(z);
 }
 } else {
 if (dividedMessage.contains(1) && messageChanged) {
 wrongMessCaught++;
 } else if (!dividedMessage.contains(1) && messageChanged) {
 wrongMessNotCaught++;
 } else if (!messageChanged) {
 correctMess++;
 }
 }
 }

 /**
 * Once the message is transmitted, some of it's elements,
 * is possible to change from 1 to 0, or from 0 to 1,
 * because of the Bit Error Rate (ber).
 * For every element of the message, a random double number is created.
 * If that number is smaller than ber, then the spesific element changes.
 * On the other hand, if it's bigger than ber, it does not.
 * Based on these changes. the boolean variable messageChanged, gets the value:
 * true, or false.
 */
 public void changeMess() {
 for (int y : message) {
 double x = randomGenerator.nextDouble();
 while (x < 0.0000 || x > 1.00000) {
 x = randomGenerator.nextDouble();
 }
 if (x < ber) {
 messageChanged = true;
 if (y == 1) {
 message.set(message.indexOf(y), 0);
 } else {
 message.set(message.indexOf(y), 1);
 }
 }
 }
 if (messageChanged) {
 wrongMess++;
 }
 }
}