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++;
 }
 }
}