AIT/src/controller/model_utils/hamming_code_seven_four.rs

use std::collections::HashMap;

use crate::{controller::view_utils::input_utils::*, model::model::*};

/// **Синдромы**
///
/// ошибочная позиция 1 false true true.
///
/// ошибочная позиция 2 false false true.
///
/// ошибочная позиция 3 true false true.
///
/// ошибочная позиция 4 false true false.
///
/// ошибочная позиция 5 true true false.
///
/// ошибочная позиция 6 true false false.
///
/// ошибочная позиция 7 false false false.

pub fn hamming(raw_input: String, mode: HammingMode) -> Result<String, String> {
    let length_of_code: usize = mode.clone() as usize;

    let prepared_input: String = processing_input(&raw_input);

    let (fc, sc) = check_correct_input(&raw_input, &prepared_input, length_of_code);

    if !fc || !sc {
        Err("Ошибка. Проверьте корректность ввода.".to_string())
    } else {
        let mut data: String = String::new();

        let prepared_data: Vec<u8> = from_string_to_vec_bits(prepared_input);

        match mode {
            HammingMode::Encrypt => hamming_encrypt_data(&prepared_data, &mut data, length_of_code),
            HammingMode::Decrypt => hamming_decrypt_data(&prepared_data, &mut data, length_of_code),
        }

        return Ok(data);
    }
}

pub fn hamming_encrypt_data(data: &Vec<u8>, result_string: &mut String, length_of_code: usize) {
    let mut i: usize = length_of_code;

    while i <= data.len() {
        let data_bits = &data[i - length_of_code..i];
        let (check_bit_1, check_bit_2, check_bit_3) = (
            data_bits[0] ^ data_bits[1] ^ data_bits[3],
            data_bits[0] ^ data_bits[2] ^ data_bits[3],
            data_bits[1] ^ data_bits[2] ^ data_bits[3],
        );
        result_string.push_str(&*format!(
            "{check_bit_1}{}{check_bit_2}{}{check_bit_3}{}{} ",
            data_bits[0], data_bits[1], data_bits[2], data_bits[3]
        ));
        i += length_of_code;
    }
}

pub fn hamming_decrypt_data(data: &Vec<u8>, result_string: &mut String, length_of_code: usize) {
    let mut general_length: usize = length_of_code;

    let syndromes: HashMap<usize, (bool, bool, bool)> = HashMap::from([
        (1, (false, true, true)),
        (2, (false, false, true)),
        (3, (true, false, true)),
        (4, (false, true, false)),
        (5, (true, true, false)),
        (6, (true, false, false)),
        (7, (false, false, false)),
    ]);

    let mut errors: String = String::new();

    while general_length <= data.len() {
        let data_bits = &data[general_length - length_of_code..general_length];

        let checked_bits: (bool, bool, bool) = (
            (data_bits[1] ^ data_bits[3] ^ data_bits[6]) == data_bits[0],
            (data_bits[1] ^ data_bits[5] ^ data_bits[6]) == data_bits[2],
            (data_bits[3] ^ data_bits[5] ^ data_bits[6]) == data_bits[4],
        );

        match checked_bits {
            (true, true, true) => {
                general_length += length_of_code;
                continue;
            }
            _ => {
                let error_position = syndromes
                    .iter()
                    .find(move |&(&_error_position, &error)| error == checked_bits)
                    .unwrap()
                    .0;

                let correctly_code: Vec<u8> = data_bits
                    .iter()
                    .enumerate()
                    .map(|(index, bit)| {
                        if index == error_position - 1 {
                            if *bit == 1u8 {
                                0u8
                            } else {
                                1u8
                            }
                        } else {
                            *bit
                        }
                    })
                    .collect();

                let error = format!(
                    "Ошибка в коде {} {:?}, позиция ошибки {}, корректный код: {:?}; \n",
                    general_length / 7,
                    &data_bits,
                    error_position,
                    correctly_code
                );

                errors.push_str(error.as_str());

                general_length += length_of_code;
            }
        }
    }

    if errors.len() == 0 {
        result_string.push_str("Все коды корректны.");
    } else {
        result_string.push_str(errors.as_str())
    }
}