Реализация алгоритмов кодирования сигнала на языке Python

# При первом запуске необходимо раскомментировать магический метод ниже для установки сторонней 
# библиотеки, затем эту строку можно удалить 
#!pip install galois
import numpy as np
import matplotlib
import matplotlib.pyplot as plt
import random
import heapq
from collections import Counter
import math
import galois

def adc_converter(analog_signal, bits=8, v_ref=1.0):
    """
    Универсальный АЦП с обработкой сигналов любой амплитуды
    :param analog_signal: входной сигнал в вольтах
    :param bits: разрядность АЦП (8-16 бит)
    :param v_ref: опорное напряжение (±V)
    :return: (quantized, binary) - кортеж с результатами
    """
    # 1. Нормализация сигнала с защитой от перегрузок
    normalized = np.clip((analog_signal + v_ref) / (2 * v_ref), 0, 1)

    # 2. Квантование
    max_level = 2 ** bits - 1
    quantized = np.round(normalized * max_level).astype(int)

    # 4. Бинарное представление
    binary = [format(x, f'0{bits}b') for x in quantized]
    return quantized, binary


def dac_converter(quantized, bits=8, v_ref=1.0):
    """Цифро-аналоговый преобразователь"""
    max_level = 2 ** bits - 1
    analog_reconstructed = (quantized / max_level) * 2 * v_ref - v_ref
    return analog_reconstructed

def nrzi_encode(binary_signal, initial_level='1'):
    """
    Кодирует одну непрерывную битовую строку в NRZI.

    В NRZI (Non-Return-to-Zero Inverted):
    - '0' в исходном сигнале вызывает переход/инверсию уровня.
    - '1' в исходном сигнале означает сохранение текущего уровня.

    Аргументы:
        binary_signal (str): Входная строка из '0' и '1' (например, '10110010').
        initial_level (str): Начальный уровень сигнала ('0' или '1'). По умолчанию '1'.

    Возвращает:
        str: Строка с NRZI-кодированными уровнями такой же длины, что и входная.
             Например, для '1011001' и initial_level='1', результат будет '1000100'.
             (1->1, 0->0, 1->0, 1->0, 0->1, 0->0, 1->0)
    """
    if not binary_signal: # Обработка пустого ввода
        return ""

    # Убедимся, что начальный уровень - один из допустимых ('0' или '1')
    # Можно добавить более строгую проверку, если нужно
    current_level = str(initial_level) if initial_level in ('0', '1') else '1'

    encoded_levels = []
    for bit in binary_signal:
        if bit == '0':
            # Инвертируем уровень при встрече '0'
            current_level = '0' if current_level == '1' else '1'
        # Если bit == '1', уровень не меняется, просто используем текущий
        encoded_levels.append(current_level)

    return ''.join(encoded_levels)

def nrzi_decode(encoded_signal, initial_level='1'):
    """
    Декодирует одну непрерывную NRZI-кодированную строку обратно в биты.

    В NRZI:
    - Переход уровня ('0' -> '1' или '1' -> '0') соответствует биту '0'.
    - Сохранение уровня ('0' -> '0' или '1' -> '1') соответствует биту '1'.

    Аргументы:
        encoded_signal (str): Входная строка NRZI-уровней (например, '1000100').
        initial_level (str): Начальный уровень, который был *перед* первым битом
                             закодированного сигнала ('0' или '1'). Должен
                             совпадать с использованным при кодировании.
                             По умолчанию '1'.

    Возвращает:
        str: Декодированная битовая строка (например, '1011001').
    """
    if not encoded_signal: # Обработка пустого ввода
        return ""

    # Уровень *перед* началом обработки первого бита
    previous_level = str(initial_level) if initial_level in ('0', '1') else '1'

    decoded_bits = []
    for current_level in encoded_signal:
        # Проверяем, изменился ли уровень по сравнению с предыдущим
        if current_level != previous_level:
            decoded_bits.append('0') # Переход уровня = '0'
        else:
            decoded_bits.append('1') # Уровень не изменился = '1'

        # Обновляем предыдущий уровень для следующей итерации
        previous_level = current_level

    return ''.join(decoded_bits)

def manchester_encode(binary_signal):
    """
    Кодирует одну непрерывную битовую строку по алгоритму Манчестера.
    Предполагается, что входная строка содержит только '0' и '1'.

    Каждый бит преобразуется:
    '0' -> '01'
    '1' -> '10'

    Аргументы:
        binary_signal (str): Входная строка из '0' и '1'.

    Возвращает:
        str: Строка с Манчестер-кодированными уровнями.
    """
    if not binary_signal:
        return ""

    encoded_bits = []
    for bit in binary_signal:
        if bit == '0':
            encoded_bits.append('01')
        else: # Предполагается, что если не '0', то это '1'
            encoded_bits.append('10')

    return ''.join(encoded_bits)


def manchester_decode(manchester_encoded_signal):
    """
    Декодирует одну непрерывную строку из Манчестерского кода.
    Предполагается, что входная строка имеет четную длину и
    состоит только из корректных пар ('01' или '10').

    Преобразование пар:
    '01' -> '0'
    '10' -> '1'

    Аргументы:
        manchester_encoded_signal (str): Входная строка с Манчестер-кодом
                                         (например, '1001101001'),
                                         предположительно корректная.

    Возвращает:
        str: Декодированная битовая строка (например, '10110').
    """
    if not manchester_encoded_signal:
        return ""

    decoded_bits = []
    # Итерируем по парам символов, предполагая четную длину
    for i in range(0, len(manchester_encoded_signal), 2):
        pair = manchester_encoded_signal[i:i+2]
        if pair == '01':
            decoded_bits.append('0')
        else: # Предполагается, что если не '01', то это '10'
            decoded_bits.append('1')

    return ''.join(decoded_bits)

class Huffman:
    @staticmethod
    def encode(signal):
        """Кодирование сигнала с использованием переменнодлинных кодов Хаффмана."""
        # 1. Строим частотный словарь
        freq = Counter(signal)

        # 2. Создаем узлы для кучи (символ, частота, битовая строка)
        heap = [[weight, [symbol, ""]] for symbol, weight in freq.items()]
        heapq.heapify(heap)

        # 3. Строим дерево Хаффмана
        while len(heap) > 1:
            lo = heapq.heappop(heap)
            hi = heapq.heappop(heap)

            # Добавляем '0' ко всем кодам левого поддерева
            for pair in lo[1:]:
                pair[1] = '0' + pair[1]

            # Добавляем '1' ко всем кодам правого поддерева
            for pair in hi[1:]:
                pair[1] = '1' + pair[1]

            heapq.heappush(heap, [lo[0] + hi[0]] + lo[1:] + hi[1:])

        # 4. Извлекаем коды (без дополнения нулями!)
        codes = {sym: bits for sym, bits in heap[0][1:]}

        # 5. Кодируем сигнал
        encoded = [codes[sym] for sym in signal]

        return encoded, codes

    @staticmethod
    def decode(encoded, codes):
        """Декодирование переменнодлинных кодов Хаффмана."""
        # Инвертируем таблицу кодов: битовая строка → символ
        inv_codes = {v: k for k, v in codes.items()}

        # Собираем битовую последовательность и декодируем
        bit_stream = "".join(encoded)
        decoded = []
        current_code = ""

        for bit in bit_stream:
            current_code += bit
            if current_code in inv_codes:
                decoded.append(inv_codes[current_code])
                current_code = ""

        return decoded

# --- Параметры Hamming(7,4) ---
DATA_BITS = 4
PARITY_BITS = 3
BLOCK_SIZE = 7  # DATA_BITS + PARITY_BITS


# --- Функция кодирования Hamming(7,4) ---
def hamming_encode(data_str):
    """
    Кодирует строку двоичных данных с использованием кода Hamming(7,4).
    Дополняет данные нулями до длины, кратной DATA_BITS.
    Возвращает закодированную строку и исходную длину данных.
    """
    original_length = len(data_str)

    # Дополнение нулями до длины, кратной DATA_BITS
    remainder = len(data_str) % DATA_BITS
    if remainder != 0:
        padding = '0' * (DATA_BITS - remainder)
        data_str = data_str + padding

    encoded_str = ""

    for i in range(0, len(data_str), DATA_BITS):
        chunk = data_str[i:i + DATA_BITS]
        d = [int(bit) for bit in chunk]  # d1, d2, d3, d4

        # Расчет проверочных битов (для четности)
        p1 = d[0] ^ d[1] ^ d[3]  # Позиции 3, 5, 7 (d1, d2, d4)
        p2 = d[0] ^ d[2] ^ d[3]  # Позиции 3, 6, 7 (d1, d3, d4)
        p3 = d[1] ^ d[2] ^ d[3]  # Позиции 5, 6, 7 (d2, d3, d4)

        # Формирование блока (p1, p2, d1, p3, d2, d3, d4)
        block = [p1, p2, d[0], p3, d[1], d[2], d[3]]
        encoded_str += "".join(map(str, block))

    return encoded_str, original_length


# --- Функция декодирования Hamming(7,4) ---
def hamming_decode(encoded_str, original_length):
    """
    Декодирует строку, закодированную Hamming(7,4), исправляя одиночные ошибки.
    Обрезает результат до original_length.
    Возвращает декодированную строку и количество исправленных ошибок.
    """
    if len(encoded_str) % BLOCK_SIZE != 0:
        # Обычно это не должно происходить, если строка получена от hamming_encode. Если произошло, то случилась либо вставка либо выпадение битов
        raise ValueError(f"Длина закодированной строки ({len(encoded_str)}) не кратна размеру блока ({BLOCK_SIZE})")

    decoded_str = ""
    corrected_errors = 0

    for i in range(0, len(encoded_str), BLOCK_SIZE):
        chunk = encoded_str[i:i + BLOCK_SIZE]
        r = [int(bit) for bit in chunk]  # r1, r2, r3, r4, r5, r6, r7

        # Расчет синдромов
        s1 = r[0] ^ r[2] ^ r[4] ^ r[6]  # Позиции 1, 3, 5, 7
        s2 = r[1] ^ r[2] ^ r[5] ^ r[6]  # Позиции 2, 3, 6, 7
        s3 = r[3] ^ r[4] ^ r[5] ^ r[6]  # Позиции 4, 5, 6, 7

        syndrome = s3 * 4 + s2 * 2 + s1 * 1

        corrected_block = list(r)  # Копируем блок для возможного исправления

        if syndrome != 0:
            error_pos = syndrome - 1  # Позиция ошибки (индекс от 0 до 6)
            if error_pos < len(corrected_block):
                corrected_block[error_pos] = 1 - corrected_block[error_pos]  # Инвертируем бит
                corrected_errors += 1
            else:
                # Это может произойти при >1 ошибки, синдром указывает на несущ. позицию
                print(
                    f"Предупреждение: Синдром {syndrome} указывает на неверную позицию > {BLOCK_SIZE} в блоке {chunk}. Возможно, >1 ошибки.")

        # Извлечение данных из (возможно) исправленного блока
        # Позиции 3, 5, 6, 7 -> индексы 2, 4, 5, 6
        data_bits = [corrected_block[2], corrected_block[4], corrected_block[5], corrected_block[6]]
        decoded_str += "".join(map(str, data_bits))

    # Обрезаем до исходной длины
    return decoded_str[:original_length], corrected_errors

# --- Параметры Кода Рида-Соломона ---
m = 8
GF = galois.GF(2**m, irreducible_poly='x^8+x^4+x^3+x^2+1')


# --- Параметры RS(n, k) ---
k = 11 # Фиксированный размер информационного блока
BITS_PER_K_BLOCK = k * m
n = 15 # k + избыточность
t = (n - k) // 2 # Исправляющая способность = 2 ошибки на блок

# --- Создание объекта RS кодера/декодера ---
try:
    rs = galois.ReedSolomon(n, k, field=GF)
    print("Объект кода Рида-Соломона успешно создан.")
except ValueError as e:
    print(f"Ошибка создания кода RS: {e}")
    exit()

# --- Вспомогательные функции ---

def segment_and_encode(long_bin_str, rs_coder):
    """Сегментирует, дополняет, кодирует."""
    k_bytes = rs_coder.k
    bits_per_chunk = k_bytes * 8
    original_bit_length = len(long_bin_str)

    padding_len = (bits_per_chunk - (original_bit_length % bits_per_chunk)) % bits_per_chunk
    padded_bin_str = long_bin_str + '0' * padding_len
    total_padded_bits = len(padded_bin_str)
    num_chunks = total_padded_bits // bits_per_chunk

    print(f"Кодирование: Исходная длина: {original_bit_length} бит.")
    print(f"Кодирование: Дополнено до {total_padded_bits} бит.")
    print(f"Кодирование: Количество {bits_per_chunk}-битных чанков: {num_chunks}.")

    all_encoded_bytes = []
    for i in range(num_chunks):
        chunk_bin = padded_bin_str[i * bits_per_chunk : (i + 1) * bits_per_chunk]
        chunk_k_bytes = [int(chunk_bin[j:j+8], 2) for j in range(0, bits_per_chunk, 8)]
        message_gf = GF(chunk_k_bytes)
        codeword_gf_n = rs_coder.encode(message_gf)
        all_encoded_bytes.extend(list(codeword_gf_n))

    print(f"Кодирование: Закодировано в {len(all_encoded_bytes)} байт.")
    return all_encoded_bytes, original_bit_length

def decode_and_reassemble(received_n_bytes, rs_coder, original_total_bit_length):
    """Декодирует, собирает, обрезает."""
    n_block = rs_coder.n
    k_block = rs_coder.k

    if len(received_n_bytes) % n_block != 0:
        print(f"Предупреждение: Длина принятых ({len(received_n_bytes)}) не кратна n ({n_block}). Обрезаем.")
        num_blocks = len(received_n_bytes) // n_block
        if num_blocks == 0: return None, False
        received_n_bytes = received_n_bytes[:num_blocks * n_block]

    num_blocks_to_decode = len(received_n_bytes) // n_block
    all_decoded_k_bytes = []
    all_blocks_success = True

    print(f"Декодирование: Принято {len(received_n_bytes)} байт. Декодируем {num_blocks_to_decode} блоков по {n_block} байт...")
    for i in range(num_blocks_to_decode):
        chunk_n = received_n_bytes[i * n_block : (i + 1) * n_block]
        received_gf = GF(chunk_n)
        try:
            decoded_gf_k = rs_coder.decode(received_gf)
            all_decoded_k_bytes.extend(list(decoded_gf_k))
        except Exception as e:
            print(f"ОШИБКА ДЕКОДИРОВАНИЯ RS в блоке {i}: {type(e).__name__}")
            all_blocks_success = False
            all_decoded_k_bytes.extend([0] * k_block) # Заполняем нулями

    if not all_blocks_success:
         print("Декодирование завершено с ошибками в некоторых блоках.")

    print(f"Декодирование: Собрано {len(all_decoded_k_bytes)} байт k-блоков.")

    if not all_decoded_k_bytes:
        restored_bin_str_padded = ""
    else:
        restored_bin_str_padded = "".join(format(byte, '08b') for byte in all_decoded_k_bytes)

    final_len = min(original_total_bit_length, len(restored_bin_str_padded))
    restored_bin_signal = restored_bin_str_padded[:final_len]

    if len(restored_bin_signal) < original_total_bit_length and all_blocks_success:
         print(f"Предупреждение: Восстановлено бит {len(restored_bin_signal)}, ожидалось {original_total_bit_length}.")

    print(f"Декодирование: Восстановлена битовая строка длиной {len(restored_bin_signal)}.")
    return restored_bin_signal, all_blocks_success

def scale_analog_to_digital(analog, bits, v_ref):
    """Масштабирование аналогового сигнала к цифровому диапазону"""
    max_level = 2 ** bits - 1
    scaled_analog = ((analog + v_ref) / (2 * v_ref)) * max_level
    return scaled_analog

def plot_signals(t, analog, quantized, reconstructed, bits, v_ref):
    """Визуализация с ЦАП и 4 субплотами"""
    plt.figure(figsize=(12, 12))


    # 1. Исходный аналоговый сигнал
    plt.subplot(4, 1, 1)
    plt.plot(t, analog, 'b', label='Аналоговый сигнал')
    plt.title('Исходный аналоговый сигнал (В)')
    plt.grid(True)

    # 2. Цифровой сигнал
    plt.subplot(4, 1, 2)
    plt.step(t, quantized, 'r', where='post', label='Цифровой сигнал')
    plt.title(f'{bits}-битное квантование (уровни)')
    plt.yticks(range(0, 2 ** bits, 2 ** (bits - 4)))
    plt.grid(True)

    # 4. Сравнение с восстановленным сигналом
    plt.subplot(4, 1, 3)
    plt.plot(t, analog, 'b', label='Исходный', alpha=0.7)
    plt.step(t, reconstructed, 'g', where='post', label='Восстановленный ЦАП', alpha=0.7)
    plt.title('Сравнение исходного и восстановленного сигналов')
    plt.xlabel('Время (с)')
    plt.ylabel('Напряжение (В)')
    plt.grid(True)
    plt.legend()

    plt.tight_layout()
    plt.show()


# --- Функция для визуализации ---
def plot_encoding(original_str, encoded_str, decoded_str, title, time_scale_factor=1):
    """
    Строит графики для исходного, кодированного и декодированного сигналов.
    """
    fig, axs = plt.subplots(3, 1, sharex=False, figsize=(15, 8))  # figsize для читаемости
    fig.suptitle(title, fontsize=16)

    # --- Подготовка данных для графиков ---
    # Используем уровни +1 и -1 для наглядности, но DC считаем по 0/1

    # 1. Исходный сигнал
    y_original = [1 if bit == '1' else -1 for bit in original_str]
    x_original = np.arange(len(y_original) + 1)  # +1 для отрисовки последнего уровня
    y_original_plot = np.append(y_original, y_original[-1])  # Дублируем последний для step

    # 2. Кодированный сигнал
    y_encoded = [1 if bit == '1' else -1 for bit in encoded_str]
    # Масштабируем время для Манчестера
    x_encoded = np.arange(len(y_encoded) + 1) / time_scale_factor
    y_encoded_plot = np.append(y_encoded, y_encoded[-1])

    # 3. Декодированный сигнал
    y_decoded = [1 if bit == '1' else -1 for bit in decoded_str]
    # Проверка на случай пустого декодированного сигнала
    if not y_decoded:
        x_decoded = np.array([0])
        y_decoded_plot = np.array([-1])  # Показать пустой график
    else:
        x_decoded = np.arange(len(y_decoded) + 1)
        y_decoded_plot = np.append(y_decoded, y_decoded[-1])

    # --- Построение графиков ---
    axs[0].step(x_original, y_original_plot, where='post', color='blue')
    axs[0].set_title('Исходный сигнал')
    axs[0].set_ylabel('Уровень')
    axs[0].set_yticks([-1, 1])
    axs[0].grid(True)
    axs[0].set_xlim(0, len(x_original) - 1)
    axs[0].set_ylim(-1.5, 1.5)

    axs[1].step(x_encoded, y_encoded_plot, where='post', color='red')
    axs[1].set_title('Закодированный сигнал')
    axs[1].set_ylabel('Уровень')
    axs[1].set_xlabel('Время (условные единицы)')
    axs[1].set_yticks([-1, 1])
    axs[1].grid(True)
    axs[1].set_xlim(0, x_encoded[-1] if len(x_encoded) > 1 else 1)  # Корректный xlim
    axs[1].set_ylim(-1.5, 1.5)

    axs[2].step(x_decoded, y_decoded_plot, where='post', color='green')
    axs[2].set_title('Декодированный сигнал')
    axs[2].set_ylabel('Уровень')
    axs[2].set_xlabel('Время (условные единицы)')
    axs[2].set_yticks([-1, 1])
    axs[2].grid(True)
    axs[2].set_xlim(0, len(x_decoded) - 1 if len(x_decoded) > 1 else 1)
    axs[2].set_ylim(-1.5, 1.5)

    # Улучшаем читаемость осей X
    max_time_orig = len(original_str)
    axs[0].set_xticks(np.linspace(0, max_time_orig, min(max_time_orig + 1, 21)))  # До 20 тиков
    axs[1].set_xticks(np.linspace(0, max_time_orig, min(max_time_orig + 1, 21)))
    axs[2].set_xticks(np.linspace(0, max_time_orig, min(max_time_orig + 1, 21)))

    plt.tight_layout(rect=[0, 0.03, 1, 0.95])

def calculate_signal_memory(signal):
    """
    Возвращает размер сигнала в байтах, не учитывает особенности ЯП.
    """
    return sum(len(code) for code in signal)

def calculate_dc_imbalance(encoded_signal_list):
    """
    Вычисляет DC имбаланс для списка закодированных сигналов ('0' и '1').
    Возвращает среднее значение (count('1') - count('0')) / total_length.
    0 - идеальный баланс. +1 - только '1'. -1 - только '0'.
    """
    total_ones = 0
    total_zeros = 0
    total_length = 0

    for encoded_signal_str in encoded_signal_list:
        length = len(encoded_signal_str)
        if length == 0:
            continue # Пропускаем пустые строки

        ones_in_str = encoded_signal_str.count('1')
        zeros_in_str = length - ones_in_str # Считаем нули как разницу

        total_ones += ones_in_str
        total_zeros += zeros_in_str
        total_length += length

    if total_length == 0:
        print("Предупреждение: Общая длина закодированного сигнала для расчета DC равна 0.")
        return 0.0 # Возвращаем 0 для пустого входа

    # Считаем финальный имбаланс: (Всего единиц - Всего нулей) / Общая длина
    imbalance = (total_ones - total_zeros) / total_length
    return imbalance

# Параметры сигнала
duration = 1 # 100 мс для лучшей детализации
fs = 24000  # Частота дискретизации 4 кГц
bits = 8  # 8-битное квантование
v_ref = 1  # Опорное напряжение ±1В

# Генерация сигнала
x = np.linspace(0, duration, int(fs * duration), endpoint=False)
analog = (
    0.5 * np.sin(2 * np.pi * 900 * x) +
    0.3 * np.sin(2 * np.pi * 200 * x) +
    0.2 * np.sin(2 * np.pi * 200 * x)
)

# АЦП преобразование
quantized, binary = adc_converter(analog, bits=bits, v_ref=v_ref)

# Также представим сигнал в сплошном виде
binary_concat = ''.join(binary)

# Визуализируем с обрезкой
reconstructed = dac_converter(quantized, bits=bits, v_ref=v_ref)
plot_signals(x[:20], analog[:20], quantized[:20], reconstructed[:20], bits, v_ref)

initial_nrzi_level = '1' # Установите начальный уровень
# Считаем исходную память
binary_bits = calculate_signal_memory(binary)

# Кодирование, декодирование методом NRZI и анализ.
nrzi_encoded = nrzi_encode(binary_concat, initial_level=initial_nrzi_level)
nrzi_decoded = nrzi_decode(nrzi_encoded, initial_level=initial_nrzi_level)
print(f'Сигналы идентичны до и после кодека (NRZI): {nrzi_decoded == binary_concat}')

# Анализ памяти (должна быть такой же)
nrzi_bits = calculate_signal_memory(nrzi_encoded)
print(f'Память, занимаемая NRZI кодом: {nrzi_bits} бит (ожидалось: {binary_bits})')

# Анализ DC составляющей
nrzi_dc = calculate_dc_imbalance(nrzi_encoded)
print(f'NRZI DC Имбаланс: {nrzi_dc:.4f} (0 = идеально, +/-1 = плохо)')

# Визуализация NRZI
plot_encoding(binary_concat[:20], nrzi_encoded[:20], nrzi_decoded[:20], "NRZI Кодирование/Декодирование")

# Кодирование, декодирование Манчестерским кодом и анализ
manchester_encoded = manchester_encode(binary_concat)
manchester_decoded = manchester_decode(manchester_encoded)
print(f'Сигналы идентичны до и после кодека (Манчестерское кодирование): {manchester_decoded == binary_concat}')

# Анализ памяти, ожидаем увеличение размера в два раза
manchester_bits = calculate_signal_memory(manchester_encoded)
print(f'Память, занимаемая Манчестерским кодом: {manchester_bits} бит (ожидалось: {binary_bits * 2})')
# Проверка отношения памяти
if binary_bits > 0:
    print(f'Отношение памяти (Манчестер/Исходный): {manchester_bits / binary_bits:.2f} (ожидалось: 2.0)')

# Анализ DC составляющей
manchester_dc = calculate_dc_imbalance(manchester_encoded)
print(f'Manchester DC Имбаланс: {manchester_dc:.4f} (0 = идеально, +/-1 = плохо)')

# Визуализация Манчестера
manchester_encoded_concat = "".join(manchester_encoded)
manchester_decoded_concat = "".join(manchester_decoded)
plot_encoding(binary_concat[:20], manchester_encoded_concat[:40], manchester_decoded_concat[:20],
              "Манчестерское Кодирование/Декодирование", time_scale_factor=2)

# Кодирование, декодирование алгоритмом Хаффмана и анализ
huffman_code, codes = Huffman.encode(binary)
huffman_decode = Huffman.decode(huffman_code, codes)
# Реальный размер данных (без накладных расходов ЯП):
huffman_bits = calculate_signal_memory(huffman_code)
binary_bits = calculate_signal_memory(binary)
print('--Анализ алгоритма Хаффмана:')
print(f'Сигналы идентичны до и после кодека (Хаффман): {huffman_decode == binary}')
print(f"Huffman: {huffman_bits} бит")
print(f"Binary: {binary_bits} бит")
print(f"Уменьшение размера на {(binary_bits-huffman_bits)/binary_bits * 100}%")

# для тестирования Хэмминга
def introduce_errors(encoded_block, num_errors):
    """Вносит ровно num_errors случайных битовых ошибок в один блок."""
    if not (0 <= num_errors <= len(encoded_block)):
        raise ValueError(f"Количество ошибок ({num_errors}) д.б. между 0 и {len(encoded_block)}")
    if num_errors == 0:
        return encoded_block, []
    block_list = list(encoded_block)
    block_length = len(block_list)
    # Убедимся, что не пытаемся выбрать больше позиций, чем есть в блоке
    if num_errors > block_length:
        num_errors = block_length # Вносим ошибки во все биты, если запрошено больше
    error_indices = random.sample(range(block_length), num_errors)
    for index in error_indices:
        block_list[index] = '1' if block_list[index] == '0' else '0'
    return "".join(block_list), sorted(error_indices)

print(f"Исходный сигнал ({len(binary_concat)} бит): (Первые 30 бит):: {binary_concat[:30]}")

# 2. Кодируем весь сигнал
encoded_signal, original_len_saved = hamming_encode(binary_concat)
num_blocks = len(encoded_signal) // BLOCK_SIZE
print(f"Закодированный сигнал ({len(encoded_signal)} бит, {num_blocks} блоков): (Первые 30 бит):: {encoded_signal[:30]}")
print("-" * 60)

# 3. Цикл по количеству ОШИБОК В КАЖДОМ БЛОКЕ
for errors_per_block in range(3): # Проверяем 0, 1, 2 ошибки В КАЖДОМ блоке
    print(f"\n===== Тест с {errors_per_block} ошибками В КАЖДОМ блоке =====")

    noisy_blocks = []
    total_errors_introduced = 0
    error_details = {} # Словарь для отслеживания ошибок по блокам

    # 4. Итерация по блокам закодированного сигнала
    for i in range(num_blocks):
        start_index = i * BLOCK_SIZE
        end_index = start_index + BLOCK_SIZE
        original_block = encoded_signal[start_index:end_index]

        # Вносим ошибки ИМЕННО в этот блок
        noisy_block, error_indices = introduce_errors(original_block, errors_per_block)
        noisy_blocks.append(noisy_block)

        if error_indices:
            total_errors_introduced += len(error_indices)
            error_details[i] = {"original": original_block, "noisy": noisy_block, "indices": error_indices}

    # 5. Собираем полный "шумный" сигнал
    noisy_encoded_signal = "".join(noisy_blocks)

    # Показать детализацию ошибок для первых нескольких блоков (если были ошибки)
    if error_details:
        print("  Примеры блоков с внесенными ошибками:")
        for block_idx in range(min(3, num_blocks)): # Показать до 3 примеров
            if block_idx in error_details:
                 details = error_details[block_idx]
                 diff_markers = "".join(['^' if details["original"][j] != details["noisy"][j] else ' ' for j in range(BLOCK_SIZE)])
                 print(f"    Блок {block_idx}: {details['original']} (ориг.)")
                 print(f"            {diff_markers}  (ошибки в поз: {details['indices']})")
                 print(f"            {details['noisy']} (с шумом)")


    # 6. Декодирование всего шумного сигнала
    print("\n  --- Декодирование ---")
    # Используем original_len_saved, которую вернул кодер!
    decoded_signal, corrected_count = hamming_decode(noisy_encoded_signal, original_len_saved)
    print(f"  Декодер сообщил об исправлении {corrected_count} ошибок (по блокам).")


    # 7. Проверка результата
    print("\n  --- Проверка результата ---")
    if decoded_signal == binary_concat:
        if errors_per_block <= 1:
            print("  РЕЗУЛЬТАТ: УСПЕХ! Сигнал полностью восстановлен (ожидаемо).")
        else:
            # Это очень маловероятно при >1 ошибке на блок
            print("  РЕЗУЛЬТАТ: УСПЕХ?! Сигнал совпал (НЕОЖИДАННО! Вероятно, ошибки случайно скомпенсировались).")
    else:
        if errors_per_block <= 1:
             # Этого не должно быть при 0 или 1 ошибке в каждом блоке
             print("  РЕЗУЛЬТАТ: ОШИБКА! Сигнал НЕ восстановлен (НЕОЖИДАННО!).")
             # Покажем различия
             max_len = max(len(binary_concat), len(decoded_signal))
             original_padded = binary_concat.ljust(max_len)
             decoded_padded = decoded_signal.ljust(max_len)
             diff_markers_final = "".join(['^' if original_padded[i] != decoded_padded[i] else ' ' for i in range(max_len)])
             print(f"  Ожидалось: {original_padded}")
             print(f"  Получено:  {decoded_padded}")
             print(f"  Различия:  {diff_markers_final}")

        else:
            # Ожидаемое поведение для >1 ошибки на блок
            print("  РЕЗУЛЬТАТ: ОШИБКА ДЕКОДИРОВАНИЯ! Сигнал НЕ восстановлен (ожидаемо).")

# --- Функция внесения ошибок для RS ---
def introduce_rs_byte_errors(encoded_bytes, n_block_size, errors_per_block, gf_field):
    """
    Вносит ровно errors_per_block случайных БАЙТОВЫХ ошибок в КАЖДЫЙ n-байтовый блок.
    Заменяет байт на другой случайный байт из поля GF.
    """
    if not (0 <= errors_per_block <= n_block_size):
        raise ValueError(f"Количество ошибок ({errors_per_block}) д.б. между 0 и {n_block_size}")

    noisy_bytes = list(encoded_bytes) # Копируем, чтобы не изменять оригинал
    num_blocks = len(encoded_bytes) // n_block_size
    total_errors_introduced = 0
    error_details = {} # Словарь для отслеживания ошибок: {block_idx: {pos: (old_val, new_val)}}

    if errors_per_block == 0:
        return noisy_bytes, 0, error_details # Нет ошибок, возвращаем копию

    # Проходим по каждому n-байтовому блоку
    for i in range(num_blocks):
        block_start_idx = i * n_block_size
        block_end_idx = block_start_idx + n_block_size
        error_details[i] = {} # Инициализируем детали для блока

        # Выбираем уникальные позиции для ошибок внутри этого блока
        error_indices_in_block = random.sample(range(n_block_size), errors_per_block)

        # Вносим ошибки в выбранные позиции
        for err_pos_in_block in error_indices_in_block:
            global_pos = block_start_idx + err_pos_in_block # Глобальный индекс в списке noisy_bytes
            original_byte = noisy_bytes[global_pos]

            # Генерируем НОВЫЙ случайный байт (элемент поля GF)
            # Убедимся, что новый байт отличается от старого
            new_byte = original_byte
            while new_byte == original_byte:
                # Генерируем случайное целое число в диапазоне [0, порядок поля - 1]
                new_byte = random.randint(0, gf_field.order - 1)

            # Заменяем байт в "шумном" списке
            noisy_bytes[global_pos] = new_byte
            error_details[i][err_pos_in_block] = (original_byte, new_byte)
            total_errors_introduced += 1

    return noisy_bytes, total_errors_introduced, error_details

# --- ТЕСТИРОВАНИЕ ---

# 1. Генерируем исходный битовый сигнал (например, 5 k-блоков информации)
num_k_blocks_for_test = 5
original_data_len_bits = num_k_blocks_for_test * BITS_PER_K_BLOCK
long_bin_str = "".join(random.choices(['0', '1'], k=original_data_len_bits))

print("=" * 60)
print("НАЧАЛО ТЕСТИРОВАНИЯ КОДА РИДА-СОЛОМОНА")
print("=" * 60)
print(f"Параметры RS: n={n}, k={k}, m={m}, t={t} (байт/символов)")
print(f"Генерируем тестовый сигнал: {original_data_len_bits} бит ({num_k_blocks_for_test} инф. блоков по {k} байт)")
print(f"Исходный сигнал (первые 60 бит): {long_bin_str[:60]}...")


# 2. Кодируем весь сигнал ОДИН РАЗ
encoded_bytes, original_len_saved = segment_and_encode(long_bin_str, rs)
num_encoded_blocks = len(encoded_bytes) // n
print(f"Закодированный сигнал: {len(encoded_bytes)} байт ({num_encoded_blocks} блоков по {n} байт).")
print("-" * 60)

# 3. Цикл по количеству ОШИБОК В КАЖДОМ N-БАЙТОВОМ БЛОКЕ
# Тестируем от 0 до t+1 ошибок, чтобы увидеть предел
for errors_per_block in range(t + 2):
    print(f"\n===== Тест с {errors_per_block} ошибками (байт) В КАЖДОМ n-блоке =====")

    # 4. Вносим ошибки в закодированные байты
    noisy_encoded_bytes, total_errors_introduced, error_details = introduce_rs_byte_errors(
        encoded_bytes,
        rs.n,
        errors_per_block,
        GF
    )
    print(f"  Внесение ошибок: Всего введено {total_errors_introduced} байтовых ошибок.")

    # Показать детализацию ошибок для первых нескольких блоков (если были ошибки)
    if error_details:
        print("  Примеры блоков с внесенными ошибками (до 3х блоков):")
        for block_idx in range(min(3, num_encoded_blocks)):
             if block_idx in error_details and error_details[block_idx]:
                 print(f"    Блок {block_idx}:")
                 details = error_details[block_idx] # {pos: (old, new)}

                 # --- ИСПРАВЛЕНИЕ ЗДЕСЬ ---
                 # Убедитесь, что нет посторонних символов в индексах среза
                 start_idx = block_idx * n
                 end_idx = (block_idx + 1) * n
                 original_block_bytes = encoded_bytes[start_idx : end_idx]
                 noisy_block_bytes = noisy_encoded_bytes[start_idx : end_idx]
                 # --- КОНЕЦ ИСПРАВЛЕНИЯ ---


                 # Формируем строки для сравнения
                 orig_str = " ".join(f"{b:02x}" for b in original_block_bytes)
                 noisy_str= " ".join(f"{b:02x}" for b in noisy_block_bytes)
                 diff_markers = ""
                 pos_details = []
                 for i in range(n):
                     if i in details:
                         diff_markers += "^^ "
                         pos_details.append(f"{i}({details[i][0]:02x}->{details[i][1]:02x})")
                     else:
                         diff_markers += "   "

                 print(f"      Ориг:  {orig_str}")
                 print(f"      Шум:   {noisy_str}")
                 print(f"             {diff_markers.strip()}")
                 print(f"      Ошибки в позициях (байт): {', '.join(pos_details)}")


    # 5. Декодирование всего "шумного" набора байт
    print("\n  --- Декодирование ---")
    # Используем original_len_saved, которую вернул кодер!
    restored_bin_signal, all_blocks_decoded_successfully = decode_and_reassemble(
        noisy_encoded_bytes,
        rs,
        original_len_saved
    )

    # 6. Проверка результата
    print("\n  --- Проверка результата ---")
    if restored_bin_signal is None:
         print("  РЕЗУЛЬТАТ: ОШИБКА! Декодер вернул None.")
         success = False
    elif restored_bin_signal == long_bin_str:
        if errors_per_block <= t:
            if all_blocks_decoded_successfully:
                 print(f"  РЕЗУЛЬТАТ: УСПЕХ! Сигнал полностью восстановлен ({errors_per_block} <= t={t} ошибок на блок, ожидаемо).")
                 success = True
            else:
                 # Это странно: сигнал совпал, но декодер сообщил об ошибках?
                 print(f"  РЕЗУЛЬТАТ: УСПЕХ?! Сигнал совпал, но декодер сообщил о неисправимых ошибках (НЕОЖИДАННО!).")
                 success = True # Формально данные верны
        else:
            # Это очень маловероятно при >t ошибках на блок
            print(f"  РЕЗУЛЬТАТ: УСПЕХ?! Сигнал совпал ({errors_per_block} > t={t} ошибок на блок, НЕОЖИДАННО! Возможно, ошибки случайно скомпенсировались или не затронули данные).")
            success = True
    else: # restored_bin_signal != long_bin_str
        if errors_per_block <= t:
             # Этого не должно быть при <= t ошибках в каждом блоке, если декодер работает
             print(f"  РЕЗУЛЬТАТ: ОШИБКА! Сигнал НЕ восстановлен ({errors_per_block} <= t={t} ошибок на блок, НЕОЖИДАННО!).")
             if not all_blocks_decoded_successfully:
                 print("             (Декодер также сообщил о неисправимых ошибках, что объясняет расхождение).")
             # Покажем различия
             max_len = max(len(long_bin_str), len(restored_bin_signal))
             original_padded = long_bin_str.ljust(max_len, '-')
             decoded_padded = restored_bin_signal.ljust(max_len, '-')
             diff_count = sum(1 for i in range(max_len) if original_padded[i] != decoded_padded[i])
             print(f"             Найдено {diff_count} различий в битах.")
             # Выведем только начало различий для краткости
             limit = 100
             diff_markers_final = "".join(['^' if original_padded[i] != decoded_padded[i] else ' ' for i in range(min(max_len, limit))])
             print(f"  Ожидалось (до {limit} бит): {original_padded[:limit]}")
             print(f"  Получено  (до {limit} бит): {decoded_padded[:limit]}")
             print(f"  Различия (до {limit} бит): {diff_markers_final}")
             success = False
        else:
            # Ожидаемое поведение для >t ошибок на блок
            print(f"  РЕЗУЛЬТАТ: ОШИБКА ДЕКОДИРОВАНИЯ! Сигнал НЕ восстановлен ({errors_per_block} > t={t} ошибок на блок, ожидаемо).")
            if not all_blocks_decoded_successfully:
                 print("             (Декодер корректно сообщил о невозможности исправить ошибки).")
            else:
                 print("             (Декодер НЕ сообщил об ошибках, но данные неверны - возможно, ложное декодирование).")
            diff_count = sum(1 for i in range(len(long_bin_str)) if i >= len(restored_bin_signal) or long_bin_str[i] != restored_bin_signal[i])
            print(f"             Найдено {diff_count} различий в битах.")
            success = False

    print("-" * 60)

print("\nТестирование завершено.")